Componentes · 10 min de leitura

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.

Placa de desenvolvimento Wemos D1 mini ESP8266
Wemos D1 mini: módulo ESP-12 (ESP8266, 4 MB de flash), chip USB-serial CH340, botão RESET e duas fileiras de 8 pinos.

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ísticaValor
ChipESP8266EX, 32 bits, 80/160 MHz
Flash4 MB (D1 mini Pro: 16 MB)
RAM80 KB de RAM de dados (cerca de 40–50 KB livres com o Wi-Fi ativo)
Wi-Fi802.11 b/g/n, somente 2,4 GHz
Pinos digitais11 (D0–D8, TX, RX)
Entrada analógica1 (A0, 0–3,2 V, 10 bits)
Nível lógico3,3 V (alimentado pelo USB ou pelo pino 5V)
Chip USB-serialGeralmente CH340
Tamanho34,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ótuloGPIOFunção especialObservação de uso
TXGPIO 1UART TX (Monitor Serial)Envia dados na inicialização; deixe desconectado se usar Serial
RXGPIO 3UART RXHIGH na inicialização; deixe desconectado se usar Serial
D0GPIO 16Despertar do deep sleep (ligado ao RST)Sem PWM, interrupções ou I2C; HIGH na inicialização
D1GPIO 5I2C SCLSeguro; pino padrão do shield de relé
D2GPIO 4I2C SDASeguro
D3GPIO 0FLASH, pull-up de 10 kΩSe estiver em LOW na inicialização, a placa entra no modo de programação
D4GPIO 2LED 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
D5GPIO 14SPI SCKSeguro
D6GPIO 12SPI MISOSeguro
D7GPIO 13SPI MOSISeguro
D8GPIO 15SPI CS, pull-down de 10 kΩSe estiver em HIGH na inicialização, a placa não liga; pino CS do shield SD
A0ADC0Entrada analógica0–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 VAlimente seus sensores por aqui
5V-5 V do USB / entrada externa de 5 VSaída quando o USB está conectado; caso contrário, entrada de alimentação
G-GNDGND comum
Quando o ESP8266 é ligado, D3 (GPIO 0) e D4 (GPIO 2) precisam estar em HIGH e D8 (GPIO 15) precisa estar em LOW. Um botão no D3 que fica pressionado na hora de ligar, um módulo que puxa o D4 para LOW ou um sensor que coloca o D8 em HIGH impedem a placa de inicializar: o LED azul fica apagado, o Monitor Serial mostra caracteres estranhos e o seu código nunca roda. Use esses três pinos apenas com circuitos que não alterem o nível padrão deles na inicialização.

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

  1. 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.
  2. Busque esp8266 no Gerenciador de Placas e instale o pacote ESP8266 Community.
  3. Escolha LOLIN(WEMOS) D1 R2 & mini em Ferramentas > Placa > ESP8266 Boards.
  4. Se nenhuma porta aparecer, instale o driver CH340 e use um cabo USB que transmita dados, e não um cabo só de carga.
  5. 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:

C++ (Arduino IDE)
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}
No código, digitalWrite(D4, LOW) e digitalWrite(2, LOW) fazem a mesma coisa, enquanto digitalWrite(4, LOW) aciona o D2. As constantes D só ficam definidas quando o D1 mini está selecionado em Ferramentas > Placa. O NodeMCU usa a mesma correspondência entre rótulo e GPIO que o D1 mini, então os sketches passam de uma placa para a outra sem mudanças.

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 A0Chega ao chipanalogRead() (aprox.)
0 V0 V0
1,0 V0,31 V320
1,65 V0,52 V527
3,2 V1,0 V1023
3,3 V1,03 V1023 (saturado)
C++ (Arduino IDE)
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}
Não aplique mais de 3,3 V no A0; ligar diretamente a saída de um sensor de 5 V distorce a leitura e pode danificar o chip a longo prazo. Chamar o analogRead() sem parar em um laço com o Wi-Fi ligado pode derrubar a conexão, então espere pelo menos alguns milissegundos entre as leituras. Além disso, se o seu código tiver ADC_MODE(ADC_VCC), o A0 fica desativado e o ADC passa a ler a tensão de alimentação da placa.

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:

ShieldPino usadoObservaçã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 SHT30D1, 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 SDD5, D6, D7, D8 (CS)SPI; o D8 precisa ficar em LOW na inicialização
Shield de bateriaNenhum pinoCarrega 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:

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

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

EstadoCorrente aproximada
Enviando dados por Wi-Fi70–170 mA
Wi-Fi conectado, ocioso (modem sleep)15–20 mA
Light sleepCerca 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)
C++ (Arduino IDE)
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.

Com o fio D0–RST ligado, algumas placas têm dificuldade para receber o código; se o carregamento falhar, tire o fio temporariamente. Em vez de um fio direto, um resistor de 470 Ω–1 kΩ ou um diodo Schottky (cátodo do lado do D0) mantém o botão RESET e o carregamento automático funcionando sem problemas. Não use o D0 para mais nada enquanto estiver usando o deep sleep.

Wemos D1 mini, NodeMCU ou D1 mini ESP32?

PlacaChipDestaqueQuando escolher
Wemos D1 miniESP8266Muito pequena, sistema de shieldsSensores Wi-Fi pequenos, projetos com shields
NodeMCU V3ESP8266Maior, pinos identificadosProtótipos confortáveis na protoboard
D1 mini ESP32 (MiniKit)ESP32-WROOM-32Disposição do D1 mini + uma fileira interna extra de pinosBluetooth, mais canais ADC e mais memória
LOLIN S2 mini / C3 miniESP32-S2 / ESP32-C3Tamanho do D1 mini e compatível com os shieldsUSB 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

SintomaCausa provávelSolução
Nenhuma porta apareceFalta o driver CH340 ou o cabo é só de cargaInstale o driver e use um cabo de dados
O pino errado respondeO código usa 4 em vez de D4Use as constantes D ou o número GPIO da tabela
A placa não inicializa, o código não rodaUm circuito no D3, D4 ou D8 altera o nível de inicializaçãoPasse o circuito para pinos seguros (D1, D2, D5–D7)
O Wi-Fi cai com frequênciaanalogRead() chamado sem parar ou alimentação fracaColoque uma pausa entre as leituras e use uma boa fonte de 5 V
Nunca acorda do deep sleepO D0 não está ligado ao RSTLigue o D0 ao RST com um fio, resistor ou diodo
Relé e OLED não funcionam juntosOs dois usam o D1Mude o pino do relé ou ligue-o com fio a outro pino
O LED funciona ao contrárioO LED integrado acende em LOWInverta a lógica: LOW = aceso, HIGH = apagado
Se a placa ficar reiniciando, abra o Monitor Serial a 74880 baud. O carregador de inicialização do ESP8266 imprime as linhas “rst cause” e “boot mode” nessa velocidade; rst cause:2, por exemplo, indica o botão RESET ou um despertar do deep sleep, enquanto rst cause:4 significa um reset do watchdog, o que mostra rapidamente onde está o problema.

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.

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
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
Conexão Wi-Fi STA com ESP32 e display LCD
ES-25Avançado

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.

4.4(21)
38
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
ESP32 em sono profundo — Economia de bateria (OLED + contador na RAM RTC)
ES-33Avançado
Premium

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.

4.3(10)
16
Atualização OTA no ESP32 — firmware sem fio (com display LCD)
ES-30Avançado
Premium

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.

4.6(14)
22
ESP32 mDNS: acesso via bluegrays-esp.local (com display LCD)
ES-29Avançado
Premium

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

4.8(14)
23
Iluminação inteligente com ESP32 (PIR + LDR + relé + OLED)
ES-37Avançado
Premium

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.

4.3(6)
11