Guias · 11 min de leitura

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.

Placa de desenvolvimento ESP32 e seus LEDs integrados
Placa ESP32 DevKit: o LED vermelho mostra a alimentação de 3,3 V e o LED azul mostra o estado do GPIO 2; os botões EN e BOOT ficam bem ao lado.

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:

PlacaLEDLigado aSignificado
Arduino Uno R3ON (verde)Trilho de 5 VA placa está energizada
Arduino Uno R3L (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 R3TX / RX (amarelos)Chip USB-serial (ATmega16U2)Troca de dados com o computador; pisca rápido durante o upload
Arduino Nano / MegaPOW ou ON, L, TX, RX5 V, D13, chip USB-serialMesmo significado do Uno
ESP32 DevKit V1LED vermelhoTrilho de 3,3 VA placa está energizada; não dá para apagar pelo código
ESP32 DevKit V1LED azulGPIO 2LED controlado pelo seu código
ESP32-DevKitC (Espressif)LED vermelhoTrilho de 3,3 VSó energia; não há LED de usuário
ESP32-S3-DevKitCLED RGB (WS2812)GPIO 48 (38 em algumas revisões)Qualquer cor definida pelo código
ESP32-CAMLED vermelho / flash brancoGPIO 33 / GPIO 4LED de status (acende em LOW) / flash da câmera
Wemos D1 mini, NodeMCULED azulGPIO 2 (D4)LED de usuário; acende em LOW
Raspberry Pi PicoLED verdeGP25LED controlado pelo seu código; não há LED de energia
Raspberry Pi Pico WLED verdeChip 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.
C++ (Arduino IDE)
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}
Se o L aceso fraco incomoda, basta adicionar pinMode(13, OUTPUT); digitalWrite(13, LOW); ao setup(). Em placas mais antigas (Unos anteriores ao R3 e muitos Nanos), o LED L é ligado diretamente ao D13 por um resistor; nessas placas, usar o D13 como entrada de botão com INPUT_PULLUP não é confiável, porque o LED puxa o pino para baixo. Se for adicionar um LED externo, calcule o valor do resistor com a ferramenta resistor para LED.

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.

O GPIO 2 é um dos pinos de strapping (inicialização) do ESP32: quando a placa entra no modo de programação para receber o código, o GPIO 2 precisa estar em LOW ou flutuando. O LED da placa e o resistor dele já o mantêm em nível baixo, mas, se você ligar um módulo com pull-up ou um sensor que coloca o GPIO 2 em HIGH, o upload pode falhar com “Failed to connect” ou “Wrong boot mode detected”. Use o GPIO 2 para o LED e saídas simples e ligue as entradas em outros pinos.

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

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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:

MicroPython
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 second

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

PlacaLED_BUILTINObservação
Arduino Uno, Nano, Mega, Leonardo, Uno R413HIGH acende
Wemos D1 mini, NodeMCU (ESP8266)2LOW acende (invertido)
ESP32 (com DOIT ESP32 DEVKIT V1 selecionado)2HIGH acende
ESP32 Dev ModulePode não estar definidoDefina você mesmo: const int LED_PIN = 2;
ESP32-S3-DevKitCRGB_BUILTIN (GPIO 48)Use rgbLedWrite() ou neopixelWrite() para a cor
Raspberry Pi Pico (core Arduino)25HIGH acende
Raspberry Pi Pico W (core Arduino)Pino virtual especialBasta escrever LED_BUILTIN

O que cada LED está dizendo? Tabela de sintomas

SintomaSignificado provávelO que fazer
O L do Arduino pisca uma vez por segundoO sketch Blink de fábrica está carregadoNormal; para quando você carrega o seu código
O L pisca rápido algumas vezes após o resetO bootloader está iniciando, depois o seu código rodaNormal
O L pisca rápido sem parar e o código não rodaA placa está reiniciando sem pararVerifique a alimentação e os curtos, carregue o código de novo
O L acende fraco ou fica aceso sozinhoO D13 está flutuando, a entrada do amp-op está abertaNormal; se quiser, coloque o D13 em OUTPUT e LOW
O LED ON não acendeSem energia, cabo com defeito ou fusível desarmadoTeste outro cabo e outra porta, elimine o curto, espere alguns minutos
TX/RX nunca piscam durante o uploadPorta, driver ou placa erradosSelecione a porta e a placa certas, instale o driver CH340
O LED azul do ESP32 fica acesoO sketch deixou o GPIO 2 em HIGHVerifique o GPIO 2 no seu código
O LED azul do ESP32 pisca rápido e irregularA placa está reiniciando sem parar, ou há um programa de teste carregadoProcure erros no Monitor Serial, melhore a alimentação
O LED azul do ESP32 nunca acendeA placa não tem LED de usuário, ou o código aciona outro pinoConfira o número do pino ou ligue um LED externo
O LED vermelho do ESP32 tremulaFalta 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 PicoA Pico não tem LED de energia e nenhum programa está rodandoNormal; 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?.
O LED de energia pode parecer pequeno, mas em projetos com bateria ele pode ser o maior consumidor, com 1–5 mA. Em um circuito que consome poucos microampères dormindo, remover o resistor do LED de energia pode esticar a duração da bateria de semanas para meses; é um truque popular em projetos com bateria feitos com o Arduino Pro Mini.

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.

Ver todos os projetos
LED integrado do ESP32 piscando
ES-4Iniciante

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.

4.8(29)
54
Piscar o LED integrado do Raspberry Pi Pico (Pico e Pico W)
PI-1Iniciante

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.

5.0(1)
10
LED piscante
AR-1Iniciante

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.

4.6(200)
1246
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
Raspberry Pi Pico: controle de LED externo (protoboard)
PI-2Iniciante

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.

4.5(2)
7
Controle de LED com botão (momentâneo)
AR-9Iniciante

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.

4.8(114)
253
Controle de LED com botão no ESP32 (momentâneo)
ES-2Iniciante

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.

4.6(36)
57
Semáforo com ESP32
ES-5Iniciante

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.

4.4(22)
45