LED azul do ESP32: o que significa, mais os LEDs L e TX/RX do Arduino e o LED da Pico
O que significa o LED azul do ESP32, o LED vermelho de energia, os LEDs ON, L, TX e RX do Arduino e o LED GP25 da Pico: tabela por placa, causas das piscadas e LED_BUILTIN.
O LED azul do ESP32, na maioria das placas ESP32 DevKit V1, é um LED de usuário ligado ao GPIO 2 e controlado inteiramente pelo seu código; o LED vermelho ao lado só indica que a placa está energizada. As luzes ON, L, TX e RX do Arduino Uno e o pequeno LED verde da Raspberry Pi Pico funcionam da mesma forma: cada uma informa um estado do hardware ou o que o seu programa está fazendo. Quando você aprende a lê-las, sabe na hora se a placa tem energia, se os dados estão passando durante o upload e se o seu sketch está realmente rodando.
Neste guia, reunimos em uma tabela a qual pino ou trilho de alimentação cada LED das placas Arduino, ESP32 e Pico está ligado. Vamos explicar os motivos reais de situações comuns como “o LED azul do ESP32 fica aceso”, “o LED azul fica piscando” e “o LED L do Arduino pisca sozinho”, mostrar para qual pino LED_BUILTIN aponta em cada placa e usar código para transformar o LED da placa em um indicador de status nos seus próprios projetos.

Para que servem os LEDs da placa?
Os LEDs das placas de desenvolvimento se dividem em três grupos. Os LEDs de energia são ligados diretamente a um trilho de alimentação por meio de um resistor; ficam acesos enquanto a placa tiver energia e não podem ser desligados por software. Os LEDs de comunicação (TX e RX) são acionados pelo chip conversor USB-serial e piscam sempre que há troca de dados com o computador. Os LEDs de usuário são ligados a um pino do microcontrolador e fazem apenas o que o seu código manda; o L do Arduino, o LED azul do ESP32 e o LED verde da Pico pertencem a esse grupo. A tabela abaixo resume as placas mais comuns:
| Placa | LED | Ligado a | Significado |
|---|---|---|---|
| Arduino Uno R3 | ON (verde) | Trilho de 5 V | A placa está energizada |
| Arduino Uno R3 | L (amarelo/laranja) | D13 (por meio de um buffer com amp-op) | LED controlado pelo seu código; o bootloader também o pisca após um reset |
| Arduino Uno R3 | TX / RX (amarelos) | Chip USB-serial (ATmega16U2) | Troca de dados com o computador; pisca rápido durante o upload |
| Arduino Nano / Mega | POW ou ON, L, TX, RX | 5 V, D13, chip USB-serial | Mesmo significado do Uno |
| ESP32 DevKit V1 | LED vermelho | Trilho de 3,3 V | A placa está energizada; não dá para apagar pelo código |
| ESP32 DevKit V1 | LED azul | GPIO 2 | LED controlado pelo seu código |
| ESP32-DevKitC (Espressif) | LED vermelho | Trilho de 3,3 V | Só energia; não há LED de usuário |
| ESP32-S3-DevKitC | LED RGB (WS2812) | GPIO 48 (38 em algumas revisões) | Qualquer cor definida pelo código |
| ESP32-CAM | LED vermelho / flash branco | GPIO 33 / GPIO 4 | LED de status (acende em LOW) / flash da câmera |
| Wemos D1 mini, NodeMCU | LED azul | GPIO 2 (D4) | LED de usuário; acende em LOW |
| Raspberry Pi Pico | LED verde | GP25 | LED controlado pelo seu código; não há LED de energia |
| Raspberry Pi Pico W | LED verde | Chip Wi-Fi (WL_GPIO0) | Controlado com Pin("LED") |
Os LEDs do Arduino Uno: ON, L, TX e RX
O LED ON é ligado ao trilho de 5 V e acende assim que a placa recebe energia pelo USB ou pelo conector P4. Se ele continuar apagado, a placa está sem energia: o cabo pode estar com defeito, a porta USB pode não estar fornecendo energia ou um curto-circuito na sua montagem acionou o fusível rearmável (polyfuse) da placa. O LED L é ligado ao pino digital 13; no Uno R3 há um buffer com amp-op no meio, para que o LED não carregue o próprio pino. Os LEDs TX e RX são acionados pelo chip USB-serial ATmega16U2: o TX pisca enquanto você carrega o código ou envia dados ao computador com Serial.print(), e o RX pisca quando chegam dados do computador. Um detalhe importante: no Uno R3 esses dois LEDs mostram apenas o tráfego USB, então não piscam quando você conversa com um módulo Bluetooth ligado aos pinos 0 e 1.
Por que o LED L do Arduino pisca sozinho?
- O sketch Blink de fábrica: a maioria das placas Uno e Nano novas vem com o exemplo Blink carregado para teste, então o L pisca uma vez por segundo. Ele para assim que você carrega o seu próprio código.
- As piscadas de inicialização do bootloader: quando você aperta o reset, conecta o USB ou abre o Monitor Serial, a placa reinicia e o bootloader pisca o L algumas vezes rapidamente antes de o seu código rodar.
- L aceso fraco ou o tempo todo: se o seu código não usa o D13, o pino fica flutuando como entrada e, como a entrada do buffer com amp-op do Uno R3 também fica flutuando, o L pode acender fraco ou por completo. Não é defeito.
- Tremulando com um módulo SPI ligado: o D13 é a linha de clock do SPI (SCK). O L tremula enquanto um RFID RC522, um cartão SD ou um módulo Ethernet está trabalhando, o que também é normal.
- Piscando rápido sem parar e o seu código não roda: a placa está reiniciando sem parar. Uma fonte fraca, um curto entre 5 V e GND ou um código que causa um loop de reset podem provocar isso.
1// Uno, Nano, Mega: L LED'i D13'tedir, LED_BUILTIN = 13 / the L LED is on D13, LED_BUILTIN = 13
2void setup() {
3 pinMode(LED_BUILTIN, OUTPUT);
4}
5
6void loop() {
7 digitalWrite(LED_BUILTIN, HIGH); // L yanar / L on
8 delay(1000);
9 digitalWrite(LED_BUILTIN, LOW); // L söner / L off
10 delay(1000);
11}O que significam os LEDs vermelho e azul do ESP32?
O LED vermelho do ESP32 DevKit V1 e de placas parecidas é ligado ao trilho de 3,3 V que sai do regulador. Ele acende quando a placa é alimentada pelo USB ou pelo pino VIN e nenhum código consegue apagá-lo. Se não acender de jeito nenhum, a placa está sem energia; se tremular ou acender fraco, a alimentação está fraca demais. O LED azul é um LED de usuário no GPIO 2: acende quando o pino está em HIGH e apaga quando está em LOW. Nem toda placa ESP32 tem esse LED; a ESP32-DevKitC da própria Espressif tem só o LED de energia, e as placas ESP32-S3 e ESP32-C3 costumam trazer um LED RGB endereçável no lugar de um LED de uma cor só.
Para a maioria das pessoas que se pergunta por que o LED azul do ESP32 fica aceso, o motivo é simples: o sketch gravado na placa colocou o GPIO 2 em HIGH e deixou assim, ou um circuito ligado ao GPIO 2 está puxando o pino para cima. Em placas novas, um LED azul que pisca sozinho geralmente vem de um programa de teste parecido com o Blink que o vendedor carregou. Se o seu código não mexe no LED e ele ainda pisca rápido e de forma irregular, o mais provável é que a placa esteja reiniciando sem parar: abra o Monitor Serial a 115200 baud e procure uma mensagem como “Brownout detector was triggered” ou “Guru Meditation Error”. Se o LED azul nunca acende, a sua placa pode não ter LED de usuário, ou o seu código está acionando outro pino.
Transformando o LED azul do ESP32 em indicador de status do Wi-Fi
A função mais útil de um LED de placa é mostrar em que estado está um dispositivo sem tela. O código abaixo pisca o LED azul cinco vezes por segundo enquanto o ESP32 tenta entrar no Wi-Fi e dá um “batimento” curto a cada dois segundos depois de conectado. Mesmo com o dispositivo preso na parede, você vê do outro lado da sala se ele está na rede e se o programa travou. Como o código não usa delay(), ainda dá para colocar outras tarefas no loop():
1#include <WiFi.h>
2
3const char* ssid = "AgAdi"; // Wi-Fi adın / your Wi-Fi name
4const char* password = "Sifre123"; // Wi-Fi şifren / your Wi-Fi password
5const int LED_PIN = 2; // DevKit V1 mavi LED / blue LED on DevKit V1
6
7void setup() {
8 pinMode(LED_PIN, OUTPUT);
9 WiFi.mode(WIFI_STA);
10 WiFi.begin(ssid, password);
11}
12
13void loop() {
14 unsigned long t = millis();
15 if (WiFi.status() == WL_CONNECTED) {
16 digitalWrite(LED_PIN, (t % 2000) < 80); // bağlı: 2 sn'de bir kısa çakma / connected: short flash every 2 s
17 } else {
18 digitalWrite(LED_PIN, (t % 200) < 100); // bağlanıyor: hızlı yanıp sönme / connecting: fast blink
19 }
20}O truque aqui é millis() % period: millis() retorna os milissegundos desde a inicialização, e o módulo transforma esse número em um contador que vai de 0 até o período e recomeça. O LED fica aceso enquanto o contador está abaixo de um valor definido e apagado acima dele; quando conectado, por exemplo, o LED acende só nos primeiros 80 ms de cada período de 2000 ms. Explicamos em detalhes a diferença entre delay() e millis() em Arduino millis() x delay(); se a placa nunca conecta, siga a lista de verificação em ESP32 não conecta ao Wi-Fi.
O LED RGB das placas ESP32-S3 e ESP32-C3
Nas placas mais novas da Espressif, o LED de usuário costuma ser um LED RGB endereçável do tipo WS2812. Na ESP32-S3-DevKitC ele fica no GPIO 48 (GPIO 38 em algumas revisões da placa) e na ESP32-C3-DevKitM, no GPIO 8. Não dá para definir a cor dele com digitalWrite(), porque ele recebe os dados de cor como uma sequência de bits com tempo exato. O core Arduino do ESP32 já traz uma função pronta para isso: rgbLedWrite() nas versões 3.x e neopixelWrite() na 2.x. O código abaixo compila nas duas e alterna o LED entre vermelho, verde e azul. Já as placas baratas ESP32-C3 SuperMini têm, no lugar do LED RGB, um único LED azul no GPIO 8 que acende em LOW.
1// ESP32-S3-DevKitC dahili RGB LED (WS2812): GPIO 48, bazı sürümlerde 38 / onboard RGB LED: GPIO 48 (38 on some revisions)
2const uint8_t RGB_PIN = 48;
3
4void setColor(uint8_t r, uint8_t g, uint8_t b) {
5#if ESP_ARDUINO_VERSION_MAJOR >= 3
6 rgbLedWrite(RGB_PIN, r, g, b); // ESP32 çekirdeği 3.x / ESP32 core 3.x
7#else
8 neopixelWrite(RGB_PIN, r, g, b); // ESP32 çekirdeği 2.x / ESP32 core 2.x
9#endif
10}
11
12void setup() {
13}
14
15void loop() {
16 setColor(40, 0, 0); delay(500); // kırmızı / red
17 setColor(0, 40, 0); delay(500); // yeşil / green
18 setColor(0, 0, 40); delay(500); // mavi / blue
19 setColor(0, 0, 0); delay(500); // kapalı / off
20}O LED da placa na Raspberry Pi Pico e na Pico W
A Raspberry Pi Pico tem um único LED verde ao lado do conector USB, ligado ao pino GP25. A Pico não tem LED de energia, então, sem nenhum programa rodando, ela parece completamente morta mesmo ligada ao USB, e quem usa pela primeira vez costuma achar que a placa está com defeito. Na Pico W e na Pico 2 W, o LED não está ligado ao microcontrolador, mas a um pino do chip Wi-Fi, e o GP25 é usado para conversar com o chip sem fio. Por isso Pin(25) não acende o LED na Pico W; no MicroPython é preciso escrever Pin("LED"). As versões recentes do MicroPython aceitam isso também na Pico comum, então você pode escrever um único código para as duas placas:
1from machine import Pin, Timer
2
3led = Pin("LED", Pin.OUT) # Pico, Pico W, Pico 2 ve Pico 2 W'de çalışır / works on all Pico boards
4# Çok eski Pico yazılımında / on very old Pico firmware: led = Pin(25, Pin.OUT)
5
6timer = Timer()
7timer.init(freq=2, mode=Timer.PERIODIC, callback=lambda t: led.toggle()) # saniyede bir yanıp sönme / one blink per secondNa Pico W, grave sempre a versão do MicroPython feita para a Pico W; o firmware da Pico comum não conhece o chip Wi-Fi, então também não alcança o LED. Se você programa a Pico pela Arduino IDE (com o core Raspberry Pi Pico/RP2040 de Earle Philhower), LED_BUILTIN aponta para o LED certo nas duas placas. Uma Pico conectada segurando o BOOTSEL não acende LED nenhum; se ela aparecer no computador como uma unidade chamada RPI-RP2, a placa está boa. Para conhecer a placa, veja O que é a Raspberry Pi Pico?.
O que é LED_BUILTIN e em qual pino ele fica em cada placa?
LED_BUILTIN é uma constante escrita no arquivo de definição da placa que guarda o número do pino do LED de usuário daquela placa. Se você usa LED_BUILTIN no código em vez de 13 ou 2, o mesmo sketch acende o LED certo em placas diferentes. Fique atento a duas coisas: a placa selecionada na Arduino IDE precisa ser a mesma que está na sua mão, e algumas definições de placa genéricas nem têm essa constante. No ESP32, por exemplo, com ESP32 Dev Module selecionado, o compilador pode reclamar “'LED_BUILTIN' was not declared in this scope”; nesse caso, escolha a placa DOIT ESP32 DEVKIT V1 ou adicione const int LED_PIN = 2; no início do código.
| Placa | LED_BUILTIN | Observação |
|---|---|---|
| Arduino Uno, Nano, Mega, Leonardo, Uno R4 | 13 | HIGH acende |
| Wemos D1 mini, NodeMCU (ESP8266) | 2 | LOW acende (invertido) |
| ESP32 (com DOIT ESP32 DEVKIT V1 selecionado) | 2 | HIGH acende |
| ESP32 Dev Module | Pode não estar definido | Defina você mesmo: const int LED_PIN = 2; |
| ESP32-S3-DevKitC | RGB_BUILTIN (GPIO 48) | Use rgbLedWrite() ou neopixelWrite() para a cor |
| Raspberry Pi Pico (core Arduino) | 25 | HIGH acende |
| Raspberry Pi Pico W (core Arduino) | Pino virtual especial | Basta escrever LED_BUILTIN |
O que cada LED está dizendo? Tabela de sintomas
| Sintoma | Significado provável | O que fazer |
|---|---|---|
| O L do Arduino pisca uma vez por segundo | O sketch Blink de fábrica está carregado | Normal; para quando você carrega o seu código |
| O L pisca rápido algumas vezes após o reset | O bootloader está iniciando, depois o seu código roda | Normal |
| O L pisca rápido sem parar e o código não roda | A placa está reiniciando sem parar | Verifique a alimentação e os curtos, carregue o código de novo |
| O L acende fraco ou fica aceso sozinho | O D13 está flutuando, a entrada do amp-op está aberta | Normal; se quiser, coloque o D13 em OUTPUT e LOW |
| O LED ON não acende | Sem energia, cabo com defeito ou fusível desarmado | Teste outro cabo e outra porta, elimine o curto, espere alguns minutos |
| TX/RX nunca piscam durante o upload | Porta, driver ou placa errados | Selecione a porta e a placa certas, instale o driver CH340 |
| O LED azul do ESP32 fica aceso | O sketch deixou o GPIO 2 em HIGH | Verifique o GPIO 2 no seu código |
| O LED azul do ESP32 pisca rápido e irregular | A placa está reiniciando sem parar, ou há um programa de teste carregado | Procure erros no Monitor Serial, melhore a alimentação |
| O LED azul do ESP32 nunca acende | A placa não tem LED de usuário, ou o código aciona outro pino | Confira o número do pino ou ligue um LED externo |
| O LED vermelho do ESP32 tremula | Falta energia (a tensão cai quando o Wi-Fi transmite) | Use um cabo bom e um adaptador de 5 V de pelo menos 1 A |
| Nenhum LED acende na Pico | A Pico não tem LED de energia e nenhum programa está rodando | Normal; veja se a unidade RPI-RP2 aparece com o BOOTSEL |
Usando o LED da placa nos seus projetos
- Códigos de erro: pisque o LED duas vezes se um sensor não for encontrado e três vezes se não houver Wi-Fi, depois faça uma pausa; você saberá o que está errado sem abrir o Monitor Serial.
- Batimento: dê uma piscada curta a cada poucos segundos enquanto o programa estiver saudável; se o LED parar, você sabe que o código travou em algum ponto.
- Aviso de evento: pisque o LED uma vez quando chegar uma mensagem MQTT ou uma requisição web; isso facilita muito a depuração de servidores web no ESP32.
- Efeito respiração: acenda e apague o LED da placa suavemente com PWM no ESP32 e na Pico; no Uno isso não funciona, porque o D13 não tem PWM. Detalhes em O que é PWM?.
- Projetos com bateria: em um dispositivo que usa deep sleep, sempre apague o LED da placa antes de dormir; ESP32 Deep Sleep mostra como baixar a corrente para a faixa de µA.
- Passando para um LED externo: para um indicador mais forte ou de outra cor, adicione um LED e um resistor como mostrado em O que é um LED?.
Os LEDs da placa são a primeira e mais barata ferramenta de depuração da eletrônica: respondem em segundos “tem energia?”, “os dados estão passando?” e “o programa está rodando?”. Se quiser dar o primeiro passo, os projetos Arduino LED Blink, LED integrado do ESP32 e LED integrado da Raspberry Pi Pico no app BlueGrays mostram o esquema de ligação e o código passo a passo.
Perguntas frequentes
O que significa o LED azul do ESP32?
No ESP32 DevKit V1 e em placas parecidas, o LED azul é um LED de usuário ligado ao GPIO 2, e só o código que você carrega o acende ou apaga. O LED vermelho é o que mostra que a placa está energizada. Nem toda placa ESP32 tem LED azul; a DevKitC da Espressif tem só o LED de energia.
Por que o LED azul do meu ESP32 fica sempre aceso?
O motivo mais comum é um sketch na placa que coloca o GPIO 2 em HIGH. Um módulo ligado ao GPIO 2 também pode puxar o pino para cima e acender o LED. Coloque o GPIO 2 em LOW no código ou mude o circuito para outro pino; um LED azul aceso por si só não é defeito.
Por que a luz azul do meu ESP32 está piscando?
Se o seu sketch não pisca o GPIO 2, uma piscada rápida e irregular geralmente significa que a placa está presa em um loop de reinicialização, muitas vezes por fonte fraca ou por um travamento. Abra o Monitor Serial a 115200 baud e procure mensagens de brownout ou Guru Meditation. Uma piscada constante em uma placa novinha costuma ser o programa de teste do vendedor.
Em qual pino fica o LED_BUILTIN no ESP32?
Na definição de placa DOIT ESP32 DEVKIT V1, LED_BUILTIN é o GPIO 2. Com ESP32 Dev Module selecionado, a constante pode não existir e o compilador dá erro; escrever const int LED_PIN = 2; no código resolve. Nas placas ESP32-S3, usa-se RGB_BUILTIN para o LED RGB.
Por que o LED da placa não funciona na minha Raspberry Pi Pico W?
Na Pico W, o LED é ligado ao chip Wi-Fi e não ao microcontrolador, então não dá para controlá-lo com Pin(25). No MicroPython, escreva Pin("LED", Pin.OUT) e confira se você gravou o firmware MicroPython feito para a Pico W.
Por que o LED L do Arduino pisca sozinho?
Placas novas geralmente vêm com o sketch Blink carregado, então o L pisca uma vez por segundo. Algumas piscadas rápidas após um reset vêm do bootloader. Se o D13 não for usado, o L pode acender fraco, e com um módulo SPI ligado pode tremular; tudo isso é normal.
Projetos para montar depois desta leitura
Ver todos os projetos
LED integrado do ESP32 piscando
Faça o LED azul integrado do ESP32 DevKit V1 piscar. Nenhum componente externo é necessário! O primeiro projeto para experimentar ao comprar um ESP32. GPIO 2 está conectado ao LED integrado.

Piscar o LED integrado do Raspberry Pi Pico (Pico e Pico W)
O primeiro projeto da série Raspberry Pi Pico! Fazemos o LED verde integrado piscar para verificar se a placa funciona — um primeiro experimento no estilo clássico "Hello World". SEM componentes externos, apenas o Pico e um cabo USB. O código foi escrito em MicroPython (a linguagem com suporte oficial da Raspberry Pi Foundation). Aprenda a usar a classe machine.Pin, o modo Pin.OUT, os métodos led.on()/off() e time.sleep() no Thonny IDE.

LED piscante
O primeiro contato com a eletrônica: acender e apagar um único LED. O Arduino acende e apaga o LED em intervalos curtos, fazendo a luz piscar rapidamente.

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.

Raspberry Pi Pico: controle de LED externo (protoboard)
O próximo passo depois do LED integrado do Pico: conectar um LED externo na protoboard e controlá-lo pelo pino GP14. Você aprende a usar qualquer pino GPIO do Pico como saída, a polaridade do LED (terminal longo = ânodo/+, terminal curto = cátodo/–) e por que um resistor limitador de corrente (220Ω) é indispensável. Sem o resistor, passa corrente demais pelo LED e ele pode queimar.

Controle de LED com botão (momentâneo)
É como uma campainha: a luz fica acesa enquanto você pressiona o botão e apaga quando você solta.

Controle de LED com botão no ESP32 (momentâneo)
O LED acende enquanto o botão está pressionado e apaga ao soltá-lo. Mostra como usar o pino de entrada digital e o resistor pull-up interno do ESP32. O modo INPUT_PULLUP dispensa um resistor externo.

Semáforo com ESP32
Simulação de um semáforo real com 3 LEDs: vermelho, amarelo e verde. Os tempos se aproximam da lógica real: vermelho longo, amarelo curto e verde longo. Um exemplo clássico de controle sequencial de GPIOs.
Mais artigos
- O que é LED? Como funciona e como ligar no Arduino
- O que é ESP32? Características, configuração na Arduino IDE e seu primeiro projeto com Wi-Fi
- O que é Raspberry Pi Pico? Instalação do MicroPython, pinagem e primeiros projetos
- Failed uploading: no upload port provided? Como resolver o erro de carregamento 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

