Pinagem do Wemos D1 mini: mapa GPIO D0–D8, A0, shields e deep sleep
Pinagem do Wemos D1 mini explicada: correspondência D0–D8 com GPIO, pinos sensíveis na inicialização, o limite de 3,2 V do A0, shields de relé, DHT e OLED, e deep sleep com D0–RST.
O Wemos D1 mini coloca o chip Wi-Fi ESP8266 em uma placa de 34 × 26 mm que você programa direto pelo USB e expande com shields empilháveis, o que o torna uma das mini placas de desenvolvimento mais populares que existem. Ele é pequeno, barato e funciona com o Arduino IDE, por isso é a primeira escolha para sensores Wi-Fi, tomadas inteligentes e controladores de fita LED. O problema é que os rótulos D0–D8 da placa não são números GPIO, e alguns pinos impedem a placa de inicializar se forem usados do jeito errado. Por isso, uma pinagem do Wemos D1 mini clara é a primeira coisa de que você precisa.
Este guia reúne toda a pinagem do Wemos D1 mini em uma única tabela, com o número GPIO de cada pino. Com códigos de exemplo, vamos ver quais pinos são arriscados na inicialização (boot), por que a entrada analógica A0 vai só até 3,2 V, quais pinos os shields de relé, DHT e OLED usam e por que o D0 precisa ser ligado ao RST para o deep sleep. No final, damos uma olhada rápida nas versões irmãs da placa baseadas no ESP32.

O que é o Wemos D1 mini? Especificações
O D1 mini foi projetado pela Wemos (hoje chamada LOLIN) e, como seu esquema é aberto, foi copiado por muitos fabricantes. O módulo ESP-12 com blindagem metálica contém o processador ESP8266EX e 4 MB de flash, enquanto a placa adiciona um conversor USB-serial, um regulador que baixa 5 V para 3,3 V e um botão RESET. As versões mais comuns são a v3 com micro-USB e a v4 com USB-C; a disposição dos pinos é idêntica em todas.
| Característica | Valor |
|---|---|
| Chip | ESP8266EX, 32 bits, 80/160 MHz |
| Flash | 4 MB (D1 mini Pro: 16 MB) |
| RAM | 80 KB de RAM de dados (cerca de 40–50 KB livres com o Wi-Fi ativo) |
| Wi-Fi | 802.11 b/g/n, somente 2,4 GHz |
| Pinos digitais | 11 (D0–D8, TX, RX) |
| Entrada analógica | 1 (A0, 0–3,2 V, 10 bits) |
| Nível lógico | 3,3 V (alimentado pelo USB ou pelo pino 5V) |
| Chip USB-serial | Geralmente CH340 |
| Tamanho | 34,2 × 25,6 mm |
Pinagem do Wemos D1 mini: D0–D8 e seus números GPIO
O erro mais comum é escrever o rótulo da placa como número no código. Se você escrever pinMode(4, OUTPUT) no Arduino IDE, a placa usa o GPIO 4, que é o D2, e não o D4. No código, use as constantes de rótulo como D4 (elas ficam definidas quando o D1 mini está selecionado como placa) ou o número GPIO da tabela. Você também pode consultar o mapa da sua placa na ferramenta Pinagem.
| Rótulo | GPIO | Função especial | Observação de uso |
|---|---|---|---|
| TX | GPIO 1 | UART TX (Monitor Serial) | Envia dados na inicialização; deixe desconectado se usar Serial |
| RX | GPIO 3 | UART RX | HIGH na inicialização; deixe desconectado se usar Serial |
| D0 | GPIO 16 | Despertar do deep sleep (ligado ao RST) | Sem PWM, interrupções ou I2C; HIGH na inicialização |
| D1 | GPIO 5 | I2C SCL | Seguro; pino padrão do shield de relé |
| D2 | GPIO 4 | I2C SDA | Seguro |
| D3 | GPIO 0 | FLASH, pull-up de 10 kΩ | Se estiver em LOW na inicialização, a placa entra no modo de programação |
| D4 | GPIO 2 | LED integrado (lógica invertida), pull-up de 10 kΩ | Se estiver em LOW na inicialização, a placa não liga; pino do shield DHT |
| D5 | GPIO 14 | SPI SCK | Seguro |
| D6 | GPIO 12 | SPI MISO | Seguro |
| D7 | GPIO 13 | SPI MOSI | Seguro |
| D8 | GPIO 15 | SPI CS, pull-down de 10 kΩ | Se estiver em HIGH na inicialização, a placa não liga; pino CS do shield SD |
| A0 | ADC0 | Entrada analógica | 0–3,2 V; divisor de 220 kΩ / 100 kΩ na placa |
| RST | - | Reset (ativo em LOW) | Ligado ao D0 para o deep sleep |
| 3V3 | - | Saída de 3,3 V | Alimente seus sensores por aqui |
| 5V | - | 5 V do USB / entrada externa de 5 V | Saída quando o USB está conectado; caso contrário, entrada de alimentação |
| G | - | GND | GND comum |
Resumindo, os pinos que você pode usar com segurança para qualquer coisa são D1, D2, D5, D6 e D7. O D0 serve para saídas simples e para despertar do deep sleep, mas não tem suporte a PWM nem a interrupções. D3 e D4 funcionam para botões (desde que não estejam pressionados na inicialização) e LEDs. Todos os pinos, exceto o D0, têm resistor de pull-up interno (INPUT_PULLUP); o D0 tem apenas pull-down interno. Na versão 3.x do core ESP8266, o analogWrite() usa por padrão a faixa 0–255 a 1 kHz. Cada pino fornece no máximo cerca de 12 mA, então use um transistor ou um driver para relés, motores ou fitas LED longas.
Configurando o Wemos D1 mini no Arduino IDE
- Em Arquivo > Preferências, adicione http://arduino.esp8266.com/stable/package_esp8266com_index.json em “URLs do Gerenciador de Placas Adicionais”; separe de outras URLs com vírgula.
- Busque esp8266 no Gerenciador de Placas e instale o pacote ESP8266 Community.
- Escolha LOLIN(WEMOS) D1 R2 & mini em Ferramentas > Placa > ESP8266 Boards.
- Se nenhuma porta aparecer, instale o driver CH340 e use um cabo USB que transmita dados, e não um cabo só de carga.
- Se o carregamento a 921600 falhar, reduza o Upload Speed para 115200.
Primeiro sketch: piscando o LED integrado
O pequeno LED azul do módulo ESP-12 está ligado ao GPIO 2 (D4) e funciona com lógica invertida: acende quando o pino está em LOW e apaga quando está em HIGH. O LED_BUILTIN está definido como 2 para o D1 mini, então o código abaixo funciona sem nenhuma alteração:
1// D1 mini dahili LED: D4 = GPIO 2, LOW'da yanar / onboard LED: D4 = GPIO 2, lights on LOW
2void setup() {
3 pinMode(LED_BUILTIN, OUTPUT); // LED_BUILTIN = 2 (D4)
4}
5
6void loop() {
7 digitalWrite(LED_BUILTIN, LOW); // LED yanar (ters mantık) / LED on (inverted logic)
8 delay(500);
9 digitalWrite(LED_BUILTIN, HIGH); // LED söner / LED off
10 delay(500);
11}A entrada analógica A0: o limite de 3,2 V e a medição de tensão
O único conversor analógico-digital (ADC) do ESP8266 mede, na verdade, apenas 0–1,0 V com resolução de 10 bits (0–1023). O D1 mini coloca um divisor de tensão de 220 kΩ e 100 kΩ atrás do pino A0: a tensão que chega ao ADC é Ventrada × 100 / (220 + 100), então 3,2 V no A0 chegam ao chip como 1,0 V. É por isso que a fórmula para converter o valor bruto em volts é V = bruto × 3,2 / 1023. Para medir uma tensão maior, adicione um resistor em série antes do A0: com mais 100 kΩ, a parte de cima do divisor passa a ter 320 kΩ e o fundo de escala sobe para 1,0 × (320 + 100) / 100 = 4,2 V, que é exatamente a tensão de uma célula Li-ion totalmente carregada. Você pode calcular outras razões com a ferramenta Divisor de tensão.
| Tensão no A0 | Chega ao chip | analogRead() (aprox.) |
|---|---|---|
| 0 V | 0 V | 0 |
| 1,0 V | 0,31 V | 320 |
| 1,65 V | 0,52 V | 527 |
| 3,2 V | 1,0 V | 1023 |
| 3,3 V | 1,03 V | 1023 (saturado) |
1// A0: kartta 220k/100k bölücü, 0–3,2 V → 0–1023 / on-board 220k/100k divider, 0–3.2 V → 0–1023
2const float FULL_SCALE = 3.2; // ek 100 kΩ seri dirençle 4.2 olur / 4.2 with an extra 100 kΩ in series
3
4void setup() {
5 Serial.begin(115200);
6}
7
8void loop() {
9 long sum = 0;
10 for (int i = 0; i < 16; i++) { // 16 ölçümün ortalaması / average of 16 readings
11 sum += analogRead(A0);
12 delay(10); // Wi-Fi'ye zaman bırak / leave time for Wi-Fi
13 }
14 float raw = sum / 16.0;
15 float volts = raw * FULL_SCALE / 1023.0;
16 Serial.print("A0 ham / raw: ");
17 Serial.print(raw, 0);
18 Serial.print(" gerilim / voltage: ");
19 Serial.print(volts, 2);
20 Serial.println(" V");
21 delay(1000);
22}Shields do Wemos D1 mini: relé, DHT, OLED e outros
O melhor do D1 mini é que os shields feitos no mesmo tamanho encaixam direto em cima ou embaixo da placa por meio de barras de pinos fêmea. Não precisa soldar nem passar fios; mas, como cada shield usa um pino fixo, você precisa garantir que os shields empilhados não compartilhem pinos. Estes são os shields mais comuns e os pinos que eles usam:
| Shield | Pino usado | Observação |
|---|---|---|
| Shield de relé | D1 (GPIO 5) | Contatos geralmente para 10 A / 250 V AC; conflita com o pino SCL do I2C |
| Shield DHT (DHT11 ou DHT22 Pro) | D4 (GPIO 2) | Mesmo pino do LED integrado; o sensor capta o calor da placa |
| Shield SHT30 | D1, D2 (I2C) | Mais preciso que um DHT; endereço I2C 0x45 |
| Shield OLED de 0,66" | D1 (SCL), D2 (SDA) | 64×48 pixels, driver SSD1306, endereço 0x3C |
| Shield Micro SD | D5, D6, D7, D8 (CS) | SPI; o D8 precisa ficar em LOW na inicialização |
| Shield de bateria | Nenhum pino | Carrega uma célula LiPo e alimenta a placa pelo pino 5V |
A tabela mostra a maior armadilha: o shield de relé usa o D1 por padrão, e esse pino também é a linha de clock do I2C. Se você empilhar o relé com o shield OLED ou SHT30, nenhum dos dois funciona direito. Algumas versões do shield de relé permitem mudar o pino com um jumper de solda na parte de trás; se a sua não permitir, ligue o relé com fio a um dos pinos D5–D7. Se você encaixar o shield DHT direto na placa, o calor do ESP8266 faz ele marcar 1–3 °C a mais; afaste o sensor com uma base dupla (dual base) ou um cabo curto. O código abaixo usa o shield DHT e o shield de relé juntos como um termostato simples para uma ventoinha:
1#include <DHT.h>
2
3const uint8_t DHT_PIN = 2; // D4 = GPIO 2 (DHT shield)
4const uint8_t RELAY_PIN = 5; // D1 = GPIO 5 (röle shield / relay shield)
5const float ON_ABOVE = 28.0; // bunun üstünde fan açılır / fan on above this
6const float OFF_BELOW = 26.5; // bunun altında kapanır (histerezis) / off below this (hysteresis)
7
8DHT dht(DHT_PIN, DHT11); // DHT Pro shield için DHT22 / DHT22 for the DHT Pro shield
9bool fanOn = false;
10
11void setup() {
12 Serial.begin(115200);
13 pinMode(RELAY_PIN, OUTPUT);
14 digitalWrite(RELAY_PIN, LOW); // röle kapalı başlasın / start with the relay off
15 dht.begin();
16}
17
18void loop() {
19 float t = dht.readTemperature();
20 if (!isnan(t)) { // hatalı ölçümü atla / skip failed readings
21 if (!fanOn && t > ON_ABOVE) fanOn = true;
22 if (fanOn && t < OFF_BELOW) fanOn = false;
23 digitalWrite(RELAY_PIN, fanOn ? HIGH : LOW); // HIGH = röle çeker / HIGH = relay on
24 Serial.print(t, 1);
25 Serial.println(fanOn ? " C fan ON" : " C fan OFF");
26 }
27 delay(2000);
28}Os dois limites no código (liga a 28 °C, desliga a 26,5 °C) criam uma histerese: com um único limite, o relé ligaria e desligaria a cada segundo enquanto a temperatura oscilasse entre 28,0 e 28,1, desgastando o relé e a ventoinha. Para ligar um relé com segurança, veja O que é um módulo relé?. O shield OLED é um display SSD1306 minúsculo de 64×48 pixels; a biblioteca padrão Adafruit SSD1306 não suporta esse tamanho, então a biblioteca U8g2 é o jeito mais fácil de controlá-lo. Este exemplo mostra a tensão no A0 como número e como barra:
1#include <Wire.h>
2#include <U8g2lib.h>
3
4// 0,66" OLED shield: 64×48, I2C D1 (SCL) / D2 (SDA) / 0.66" OLED shield: 64×48, I2C on D1/D2
5U8G2_SSD1306_64X48_ER_F_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
6
7void setup() {
8 oled.begin();
9}
10
11void loop() {
12 float volts = analogRead(A0) * 3.2 / 1023.0; // A0 → volt
13 oled.clearBuffer();
14 oled.setFont(u8g2_font_6x10_tf);
15 oled.drawStr(0, 10, "D1 mini");
16 oled.setCursor(0, 28);
17 oled.print(volts, 2);
18 oled.print(" V");
19 oled.drawFrame(0, 36, 64, 10); // çubuk çerçevesi / bar frame
20 oled.drawBox(2, 38, (int)(volts / 3.2 * 60), 6); // gerilim çubuğu / voltage bar
21 oled.sendBuffer();
22 delay(500);
23}Deep sleep: a ligação D0–RST e o funcionamento com bateria
No deep sleep, o ESP8266 desliga completamente o processador e o Wi-Fi; só o timer RTC interno continua funcionando. Quando o tempo acaba, o RTC coloca o GPIO 16 (D0) em LOW por um instante. Se o D0 estiver ligado ao pino RST da placa, esse pulso reinicia o chip e o seu código começa de novo a partir do setup(). Sem esse fio, a placa nunca acorda. Como acordar é uma reinicialização, as variáveis normais se perdem; você pode guardar valores pequenos, como um contador de leituras, na memória de usuário do RTC de 512 bytes. Um único período de sono pode durar até cerca de 3,5 horas; para períodos maiores, coloque a placa para dormir várias vezes seguidas.
| Estado | Corrente aproximada |
|---|---|
| Enviando dados por Wi-Fi | 70–170 mA |
| Wi-Fi conectado, ocioso (modem sleep) | 15–20 mA |
| Light sleep | Cerca de 1 mA |
| Deep sleep (só o chip ESP8266) | Cerca de 20 µA |
| Deep sleep (placa D1 mini inteira) | 80–200 µA (por causa do regulador e do chip USB-serial) |
1// D0 (GPIO 16) ile RST arasına kablo tak / wire D0 (GPIO 16) to RST
2const uint64_t SLEEP_US = 10ULL * 60 * 1000000; // 10 dakika, mikrosaniye / 10 minutes in µs
3
4void setup() {
5 Serial.begin(115200);
6 delay(100);
7 float volts = analogRead(A0) * 3.2 / 1023.0; // ölç / measure
8 Serial.print("A0: ");
9 Serial.print(volts, 2);
10 Serial.println(" V");
11 // Wi-Fi ile gönderim burada yapılır / send the reading over Wi-Fi here
12 Serial.println("10 dk uyku / sleeping 10 min");
13 ESP.deepSleep(SLEEP_US); // uyanınca setup() baştan başlar / wakes up into setup()
14}
15
16void loop() {
17 // buraya hiç gelinmez / never reached
18}Você pode estimar a autonomia da bateria com uma conta aproximada. Digamos que a placa acorde a cada 10 minutos, consuma em média 80 mA por 5 segundos enquanto envia dados e durma com 0,15 mA nos 595 segundos restantes. Cada ciclo gasta 5 × 80 = 400 mAs mais 595 × 0,15 ≈ 89 mAs; são 489 mAs no total, ou uma média de 0,82 mA ao longo de 600 segundos. Uma célula 18650 de 2000 mAh dura então 2000 / 0,82 ≈ 2440 horas, ou cerca de 100 dias. Use a ferramenta Autonomia da bateria para fazer as contas com a sua montagem e veja ESP32 Deep Sleep para a versão do mesmo assunto no ESP32.
Wemos D1 mini, NodeMCU ou D1 mini ESP32?
| Placa | Chip | Destaque | Quando escolher |
|---|---|---|---|
| Wemos D1 mini | ESP8266 | Muito pequena, sistema de shields | Sensores Wi-Fi pequenos, projetos com shields |
| NodeMCU V3 | ESP8266 | Maior, pinos identificados | Protótipos confortáveis na protoboard |
| D1 mini ESP32 (MiniKit) | ESP32-WROOM-32 | Disposição do D1 mini + uma fileira interna extra de pinos | Bluetooth, mais canais ADC e mais memória |
| LOLIN S2 mini / C3 mini | ESP32-S2 / ESP32-C3 | Tamanho do D1 mini e compatível com os shields | USB nativo (S2), BLE e baixo consumo (C3) |
Nas placas D1 mini ESP32, as fileiras externas de pinos coincidem com os shields do D1 mini, então você pode encaixar o shield de relé ou OLED do jeito que estão. Mas os rótulos D correspondem a GPIOs diferentes no ESP32; os pinos I2C, por exemplo, são D1 = GPIO 22 e D2 = GPIO 21. No código, use WiFi.h em vez de ESP8266WiFi.h e ajuste os números dos pinos conforme o mapa da placa. A versão ESP32 lê valores analógicos com 12 bits (0–4095), tem Bluetooth e muito mais memória. Se não tiver certeza de qual escolher, compare O que é o ESP32? com NodeMCU ESP8266.
Ideias de projetos com o Wemos D1 mini
- Termômetro Wi-Fi a bateria: use um shield SHT30 ou DHT, o shield de bateria e o deep sleep para enviar uma leitura a cada 10 minutos.
- Tomada inteligente: ligue uma lâmpada pelo celular com o shield de relé; leia o guia do módulo relé para fazer a ligação com segurança.
- Controlador de fita LED: grave o WLED e controle uma fita WS2812B pelo celular.
- Sensor de porta: envie uma notificação quando a porta abrir usando uma chave reed.
- Mini display de mesa: mostre a hora, a previsão do tempo ou pequenos gráficos no shield OLED, como em um display OLED maior.
- Sensor para casa inteligente: envie os valores para o Home Assistant via MQTT.
Erros comuns e soluções
| Sintoma | Causa provável | Solução |
|---|---|---|
| Nenhuma porta aparece | Falta o driver CH340 ou o cabo é só de carga | Instale o driver e use um cabo de dados |
| O pino errado responde | O código usa 4 em vez de D4 | Use as constantes D ou o número GPIO da tabela |
| A placa não inicializa, o código não roda | Um circuito no D3, D4 ou D8 altera o nível de inicialização | Passe o circuito para pinos seguros (D1, D2, D5–D7) |
| O Wi-Fi cai com frequência | analogRead() chamado sem parar ou alimentação fraca | Coloque uma pausa entre as leituras e use uma boa fonte de 5 V |
| Nunca acorda do deep sleep | O D0 não está ligado ao RST | Ligue o D0 ao RST com um fio, resistor ou diodo |
| Relé e OLED não funcionam juntos | Os dois usam o D1 | Mude o pino do relé ou ligue-o com fio a outro pino |
| O LED funciona ao contrário | O LED integrado acende em LOW | Inverta a lógica: LOW = aceso, HIGH = apagado |
Com seu tamanho minúsculo, o sistema de shields e o Wi-Fi, o Wemos D1 mini é uma das formas mais fáceis de entrar em projetos de automação residencial e sensores. Desde que você tenha em mente a tabela de pinos e as regras de inicialização, quase qualquer exemplo do ESP8266 vai rodar sem problemas. No app BlueGrays, você encontra esquemas do circuito e códigos passo a passo nos projetos de ESP (LED piscante, conexão Wi-Fi, servidor web, OTA e deep sleep) e pode testá-los também no D1 mini, adaptando os números dos pinos com esta tabela.
Perguntas frequentes
Qual GPIO é o D4 no Wemos D1 mini?
O D4 é o GPIO 2, e o LED azul integrado da placa está ligado a ele. Você pode escrever pinMode(D4, OUTPUT) ou pinMode(2, OUTPUT) no código, enquanto pinMode(4, OUTPUT) seleciona o D2. O LED usa lógica invertida, então acende em LOW.
O Wemos D1 mini funciona com 5 V?
A placa pode ser alimentada com 5 V pelo USB ou pelo pino 5V; o regulador da placa baixa isso para 3,3 V. Os pinos GPIO, porém, usam lógica de 3,3 V, então, em vez de ligar diretamente sensores com saída de 5 V, use um divisor de tensão ou um conversor de nível lógico.
Que tensão o pino A0 do Wemos D1 mini consegue ler?
Graças ao divisor de 220 kΩ / 100 kΩ da placa, o pino A0 lê 0–3,2 V como 0–1023. O chip ESP8266 sozinho só mede 0–1,0 V. Adicione um resistor extra de 100 kΩ em série antes do A0 e a faixa sobe para 4,2 V, o suficiente para ler uma bateria Li-ion.
Por que meu Wemos D1 mini não acorda do deep sleep?
O ESP8266 precisa do pulso de reset que o RTC envia pelo D0 (GPIO 16) para acordar. Se você não ligar o D0 ao RST com um fio, um resistor de 470 Ω–1 kΩ ou um diodo Schottky, a placa continua dormindo. Confira também se você passou o tempo de sono em microssegundos.
Qual é a diferença entre o Wemos D1 mini e o NodeMCU?
Os dois usam o mesmo chip ESP8266, e os rótulos D0–D8 correspondem aos mesmos GPIOs, então os sketches rodam em qualquer um sem alterações. O D1 mini é bem menor e aceita shields empilháveis, enquanto o NodeMCU é maior e mais confortável na protoboard.
O Wemos D1 mini tem Bluetooth?
Não, o ESP8266 só suporta Wi-Fi. Se você precisar de Bluetooth, use um D1 mini ESP32 ou o LOLIN C3 mini, baseado no ESP32-C3, que têm o mesmo formato e também funcionam com os shields do D1 mini.
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.

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.

Conexão Wi-Fi STA com ESP32 e display LCD
Neste projeto, conectamos o ESP32 à rede Wi-Fi de casa no modo estação (STA), de forma segura e tolerante a falhas. Guardamos o SSID e a senha em um arquivo secrets.h separado para evitar que sejam expostos no Git, configuramos um mecanismo de reconexão automática e exibimos o nível de sinal RSSI e o endereço IP em um display LCD I2C. O LED integrado funciona como indicador de status. É um gerenciador de conexão pronto para uso em produção.

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.

ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
O modo de sono profundo do ESP32 reduz o consumo de corrente para ~10 µA ao desligar a CPU e a maioria dos periféricos, sendo essencial para dispositivos IoT alimentados por bateria. Neste projeto, usamos três fontes de despertar: um temporizador (15 segundos), um pino externo (EXT0 — botão no GPIO 33) e toque (T0/GPIO 4). As variáveis marcadas com RTC_DATA_ATTR são preservadas durante o sono profundo, mantendo os contadores de inicializações e de despertares por temporizador e botão.

Atualização OTA no ESP32 — firmware sem fio (com display LCD)
Neste projeto, você aprende a carregar um novo firmware no ESP32 por Wi-Fi, sem cabo USB. Com a biblioteca ArduinoOTA, o ESP32 fica visível na rede e aparece automaticamente como bluegrays-ota na aba "Porta de rede" do Arduino IDE. A primeira carga é feita por USB, e todas as atualizações seguintes são sem fio — um recurso essencial para dispositivos em campo. O LCD I2C mostra o estado do Wi-Fi, o IP, o nome do host, a porcentagem de envio por OTA e as mensagens de erro em turco e inglês.

ESP32 mDNS: acesso via bluegrays-esp.local (com display LCD)
Neste projeto, adicionamos o serviço mDNS (Multicast DNS) ao ESP32 para acessar o dispositivo por um nome de host fácil de ler, como bluegrays-esp.local, em vez de um endereço IP. Mesmo que o IP atribuído pelo DHCP mude, você pode acessar o dispositivo pelo mesmo nome. Também executamos um pequeno servidor web no dispositivo para enviar comandos de controle do LED pelo navegador no endereço http://bluegrays-esp.local/.

Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)
Transforme a iluminação do corredor, banheiro ou despensa em iluminação inteligente com ESP32! Com um sensor de movimento PIR, um sensor de luz LDR e um módulo relé, montamos o cenário clássico de "acender a luz ao detectar movimento no escuro" — se o ambiente já estiver claro, o movimento NÃO aciona a luz, economizando energia durante o dia. A luz fica acesa por 30 segundos; se o movimento continuar, o temporizador reinicia e a luz permanece acesa por mais tempo.
Mais artigos
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

