Tutorial de ESPHome no ESP32: sensores no Home Assistant sem código
Tutorial de ESPHome no ESP32: Device Builder, seu primeiro YAML, Wi-Fi e OTA, DHT22, PIR, relé e LED. E mais: erros comuns de YAML, soluções para o offline e comparação com o Tasmota.
Este tutorial de ESPHome no ESP32 mostra o caminho mais curto para colocar um ESP32 no Home Assistant sem escrever uma única linha de C++. No ESPHome você descreve seu dispositivo em um arquivo YAML: qual sensor está em qual pino, com que frequência ele é lido e qual saída deve aparecer como um interruptor. O ESPHome transforma sozinho essa descrição em código C++, compila e grava na placa. Depois de ligada, a placa entra na sua rede doméstica, o Home Assistant a descobre por conta própria e os sensores aparecem no seu painel em segundos.
Vamos começar do zero: você vai instalar o ESPHome Device Builder, escrever seu primeiro arquivo YAML, gravar uma vez por USB e, daí em diante, por Wi-Fi (OTA). Depois vamos adicionar ao mesmo ESP32 um sensor de temperatura e umidade DHT22, um sensor de movimento PIR, um relé e um LED. No final você também vai conhecer os erros de YAML mais comuns, saber por que um dispositivo aparece como “offline” e entender onde o ESPHome se encaixa em comparação com o Tasmota e com o seu próprio código MQTT.

O que é o ESPHome e como ele funciona?
O ESPHome é um gerador de firmware de código aberto desenvolvido junto com o Home Assistant. Seu arquivo YAML funciona como um formulário de pedido: o ESPHome o lê, escolhe código C++ pronto e testado para cada componente listado, compila tudo com o PlatformIO e produz um único arquivo de firmware. O dispositivo conversa com o Home Assistant por sua própria API nativa criptografada, na porta 6053, e se anuncia na rede via mDNS, então você nunca precisa digitar um endereço IP. Quando quiser mudar alguma coisa, você edita o YAML, clica em Install e o novo firmware chega à placa pelo Wi-Fi.
| Bloco YAML | O que faz | Linha de exemplo |
|---|---|---|
| esphome: | Nome na rede e nome amigável do dispositivo | name: esp32-sensor |
| esp32: / esp8266: / rp2040: | Família e modelo da placa | board: esp32dev |
| wifi: | Rede doméstica e ponto de acesso de reserva | ssid: !secret wifi_ssid |
| api: | Conexão criptografada com o Home Assistant | encryption: key |
| ota: | Atualizações de firmware pelo ar | platform: esphome |
| logger: | Logs por USB e por Wi-Fi | level: DEBUG |
| sensor: / binary_sensor: | Entradas que medem um valor ou informam ligado/desligado | platform: dht |
| switch: / output: / light: | Saídas como relés e LEDs | platform: gpio |
Do que você precisa
- Uma placa de desenvolvimento ESP32 (ESP32 DevKit V1 ou parecida) e um cabo USB que transmita dados, não só energia.
- Um sensor de temperatura e umidade DHT22; se for o sensor avulso, e não um módulo, acrescente um resistor de pull-up de 10 kΩ.
- Um sensor de movimento PIR HC-SR501.
- Um módulo relé de 5 V de um canal; escolha um com optoacoplador, que comute de forma confiável com um sinal de 3,3 V.
- Um LED com um resistor de 220 Ω, uma protoboard e jumpers.
- Uma máquina rodando o Home Assistant: um Raspberry Pi 4/5, um mini PC ou um notebook antigo. Sem o Home Assistant, você também pode instalar o ESPHome no seu próprio computador.
Tabela de ligações
| Peça | Pinos | Pino do ESP32 | Observação |
|---|---|---|---|
| DHT22 | VCC / DATA / GND | 3V3 / GPIO 4 / GND | Sensor avulso: 10 kΩ entre DATA e 3V3 |
| PIR HC-SR501 | VCC / OUT / GND | VIN (5 V) / GPIO 27 / GND | A saída é de 3,3 V, segura para o ESP32 |
| Módulo relé | VCC / IN / GND | VIN (5 V) / GPIO 26 / GND | A maioria dos módulos é ativa em LOW |
| LED | Ânodo / Cátodo | GPIO 18 (via 220 Ω) / GND | Brilho via PWM |
Instalando o ESPHome Device Builder
A interface web do ESPHome se chama ESPHome Device Builder (antes, ESPHome Dashboard). É nela que você cria dispositivos, edita o YAML deles, compila e grava. No Home Assistant OS bastam alguns cliques:
- No Home Assistant, abra Configurações > Add-ons (chamado de Apps nas versões mais novas) e clique no botão da loja, no canto inferior direito.
- Busque por ESPHome, escolha ESPHome Device Builder e clique em Instalar.
- Quando terminar, clique em Iniciar e ative Mostrar na barra lateral.
- Clique no ícone do ESPHome na barra lateral; você vai ver uma lista de dispositivos vazia e um botão + New Device no canto inferior direito.
Se você roda o Home Assistant como contêiner Docker ou em uma instalação Core, não existe loja de add-ons. Nesse caso, rode o ESPHome em um contêiner Docker próprio ou instale-o no computador com Python: depois de pip install esphome, o comando esphome dashboard config/ abre a interface no navegador, na porta 6052. Se você não precisa de interface nenhuma, esphome run esp32-sensor.yaml faz todo o trabalho pela linha de comando: compila, carrega e depois exibe os logs em tempo real.
Primeiro dispositivo: o assistente e seu primeiro arquivo YAML
- Clique em + New Device e escolha Continue na janela que se abre.
- Dê ao dispositivo um nome usando só letras minúsculas, números e hifens, por exemplo esp32-sensor; na sua rede ele será esp32-sensor.local.
- Escolha ESP32 como tipo de placa. O assistente gera uma chave de criptografia e a escreve no YAML.
- Pule a instalação por enquanto, clique em Edit no cartão do dispositivo e altere o arquivo como mostrado abaixo.
1esphome:
2 name: esp32-sensor # küçük harf, rakam, tire / lowercase, digits, hyphens
3 friendly_name: ESP32 Sensor
4
5esp32:
6 board: esp32dev # ESP32 DevKit V1 ve benzerleri / and similar boards
7
8logger: # günlükler USB ve Wi-Fi'den / logs over USB and Wi-Fi
9
10api: # Home Assistant bağlantısı / Home Assistant link
11 encryption:
12 key: !secret api_key
13
14ota:
15 - platform: esphome # kablosuz güncelleme / over-the-air updates
16 password: !secret ota_password
17
18wifi:
19 ssid: !secret wifi_ssid
20 password: !secret wifi_password
21 ap: # bağlanamazsa yedek ağ / fallback hotspot
22 ssid: "ESP32-Sensor"
23 password: !secret ap_password
24
25captive_portal: # yedek ağda ayar sayfası / setup page on the hotspotCada bloco desse arquivo faz um único trabalho. esphome: define o nome do dispositivo na rede e esp32:, o modelo da placa; esp32dev serve para o ESP32 DevKit V1 e para a maioria das placas parecidas. logger: permite ler os logs tanto por USB quanto por Wi-Fi. api: abre a conexão com o Home Assistant e ota: permite atualizações sem fio. A seção ap: dentro de wifi: é a sua rede de segurança: se o ESP32 não conseguir entrar na sua rede, ele abre a própria, chamada “ESP32-Sensor”, e captive_portal: mostra ali uma página em que você pode informar os novos dados do Wi-Fi.
As senhas não ficam em texto puro dentro do YAML; a tag !secret lê cada valor do arquivo secrets.yaml, que fica na mesma pasta. No Device Builder, abra-o pelo botão Secrets, no canto superior direito, e preencha assim. Passe para lá também a chave de criptografia que o assistente escreveu no YAML, para que ela continue privada mesmo se você compartilhar sua configuração.
1# secrets.yaml
2wifi_ssid: "EvAgi_2.4GHz"
3wifi_password: "gizli#Sifre2024" # özel karakter varsa tırnak / quote special characters
4api_key: "SIHIRBAZIN_URETTIGI_44_KARAKTERLIK_ANAHTAR" # sihirbazın anahtarını koru / keep the wizard's key
5ota_password: "ota-sifresi"
6ap_password: "yedek12345" # en az 8 karakter / at least 8 charactersPrimeira gravação por USB, depois por Wi-Fi (OTA)
Enquanto ainda não há ESPHome no ESP32, você precisa gravá-lo uma vez por cabo. Clique em Install no cartão do dispositivo e várias opções aparecem. Se o ESP32 estiver conectado à máquina que roda o Home Assistant, “Plug into the computer running ESPHome Device Builder” é a mais fácil. Se ele estiver conectado ao seu próprio computador, “Plug into this computer” programa a placa direto pelo Chrome ou pelo Edge. Só que os navegadores permitem acesso à USB apenas por HTTPS; se você abre o Home Assistant por http simples, use “Manual download” para baixar o arquivo e grave-o pela página ESPHome Web.
A primeira compilação leva alguns minutos, porque o ESPHome baixa o toolchain do compilador; 5–10 minutos em um Raspberry Pi 4 é normal, e as compilações seguintes são bem mais rápidas. Se o navegador não encontrar a placa ou disser “Failed to connect”, segure o botão BOOT e inicie o carregamento de novo; há mais detalhes no nosso guia sobre o erro “Failed to connect” no ESP32. Depois da gravação, a placa reinicia, entra no seu Wi-Fi e o Device Builder mostra Online no dispositivo. A partir daí, você escolhe Install > Wirelessly a cada alteração; o firmware vai por OTA e você não precisa mais do cabo USB.
Agora vá em Configurações > Dispositivos e serviços no Home Assistant. Em “Descoberto” você vai ver o esp32-sensor; clique em Configurar, confirme e o dispositivo é adicionado. Como o Device Builder roda no mesmo Home Assistant, a chave de criptografia costuma ser reconhecida automaticamente; se ela for pedida, cole o valor de api_key do secrets.yaml.
Adicionando sensores: DHT22, PIR, relé e LED
É aqui que a diversão começa. Acrescente os blocos abaixo ao final do seu YAML; cada um corresponde aos pinos da tabela de ligações acima. Se você tiver vários componentes do mesmo tipo, como dois sensores, liste-os um depois do outro sob um único cabeçalho “sensor:”.
1sensor:
2 - platform: dht
3 pin: GPIO4
4 model: DHT22
5 update_interval: 30s
6 temperature:
7 name: "Temperature"
8 filters:
9 - offset: -0.5 # kalibrasyon farkı / calibration offset
10 humidity:
11 name: "Humidity"
12 - platform: wifi_signal
13 name: "Wi-Fi Signal"
14 update_interval: 60s
15
16binary_sensor:
17 - platform: gpio
18 pin: GPIO27
19 name: "Motion"
20 device_class: motion
21 filters:
22 - delayed_off: 30s # son hareketten 30 sn sonra temiz / clear 30 s after last motion
23
24switch:
25 - platform: gpio
26 id: relay
27 name: "Relay"
28 pin:
29 number: GPIO26
30 inverted: true # aktif LOW röle / active-LOW relay
31 restore_mode: ALWAYS_OFF # elektrik gelince kapalı / off after power-up
32
33output:
34 - platform: ledc # ESP32 PWM birimi / ESP32 PWM unit
35 pin: GPIO18
36 id: led_pwm
37
38light:
39 - platform: monochromatic
40 output: led_pwm
41 name: "LED"
42
43button:
44 - platform: restart
45 name: "Restart"| Bloco | Como aparece no Home Assistant | Ajuste principal |
|---|---|---|
| platform: dht | Sensores de temperatura (°C) e umidade (%) | update_interval: 30s; não leia um DHT22 em intervalos menores que dois segundos |
| platform: wifi_signal | Intensidade do sinal (dBm) | Mais fraco que -75 dBm: aproxime a placa do roteador |
| binary_sensor gpio | Movimento detectado / livre | device_class: motion dá o ícone certo |
| switch gpio | Interruptor liga/desliga | inverted: true para um relé ativo em LOW |
| output ledc + light | Luz com controle deslizante de brilho | ledc é a unidade de PWM por hardware do ESP32 |
| button restart | Botão de reinício | Reinicia a placa remotamente |
Alguns detalhes: se o DHT22 estiver lendo um pouco fora, corrija com o filtro offset; o -0.5 do exemplo subtrai meio grau de cada leitura. A saída do PIR fica em HIGH por alguns segundos depois de cada movimento; o filtro delayed_off: 30s espera 30 segundos após o último movimento antes de informar “livre”, para que o estado não fique oscilando no Home Assistant. No relé, restore_mode: ALWAYS_OFF impede que o que estiver conectado ligue sozinho depois de uma queda de energia. Para os ajustes de tempo e sensibilidade do PIR, veja nosso guia do sensor de movimento PIR; para usar relés com segurança, veja o guia do módulo relé.
Automação no dispositivo: continua funcionando mesmo com o Home Assistant fora do ar
Um dos pontos fortes do ESPHome é que automações simples rodam direto no ESP32. Com a alteração abaixo, o PIR liga o relé quando detecta movimento e o desliga 60 segundos depois do último movimento; a luz continua funcionando mesmo se o Home Assistant reiniciar ou o Wi-Fi cair. Substitua o bloco binary_sensor anterior por este:
1binary_sensor:
2 - platform: gpio
3 pin: GPIO27
4 name: "Motion"
5 device_class: motion
6 filters:
7 - delayed_off: 60s # 60 sn hareketsizlikten sonra kapalı / off after 60 s without motion
8 on_press: # hareket başladı / motion started
9 then:
10 - switch.turn_on: relay
11 on_release: # 60 sn hareket yok / no motion for 60 s
12 then:
13 - switch.turn_off: relayÉ aqui que a linha id: relay mostra seu valor: a automação chega ao relé por esse ID. Se um novo movimento chegar antes de o delayed_off terminar, o temporizador recomeça, então a luz fica acesa enquanto alguém estiver circulando pelo cômodo. Para regras mais complexas, como “só quando estiver escuro” ou “só à noite”, as automações do Home Assistant são mais práticas; mas deixar uma tarefa básica como “movimento acende a luz” por conta do próprio dispositivo é um bom hábito.
Se o seu dispositivo aparece como “offline”
A reclamação mais comum: o Home Assistant mostra os valores dos sensores, mas o Device Builder mostra o dispositivo em cinza, como Offline. O Device Builder deduz o status pelos anúncios mDNS, enquanto o Home Assistant se conecta direto à API. Quando uma rede Docker, VLANs separadas ou uma rede Wi-Fi de convidados bloqueiam o mDNS, o dispositivo parece offline mesmo funcionando bem. A tabela traz a solução para cada sintoma:
| Sintoma | Causa provável | Solução |
|---|---|---|
| Offline no Device Builder, mas os valores chegam ao Home Assistant | O mDNS está sendo bloqueado | Ative status_use_ping nas opções do add-on; no Docker, defina ESPHOME_DASHBOARD_USE_PING=true |
| Não aparece em lugar nenhum e uma rede “ESP32-Sensor” surge no seu celular | Senha do Wi-Fi errada ou rede de 5 GHz | Entre nessa rede, informe os dados da sua rede de 2,4 GHz na página que se abre e corrija o secrets.yaml |
| A placa reinicia a cada 15 minutos | api: está ativo, mas o Home Assistant nunca adotou o dispositivo | Adicione o dispositivo no Home Assistant ou coloque reboot_timeout: 0s dentro de api: |
| O carregamento sem fio dá timeout | O nome não é resolvido; o dispositivo está em outra sub-rede | Adicione use_address: com o IP da placa dentro de wifi: ou dê a ela um IP fixo |
| A placa reinicia quando o relé estala | A alimentação pela USB é fraca demais e a tensão cai | Use uma fonte de 5 V separada e de boa qualidade e una os GNDs |
| Um dispositivo na rede de convidados nunca é encontrado | Redes de convidados isolam os dispositivos da rede doméstica | Passe a placa para a mesma rede do Home Assistant |
Se aparecer “Brownout detector was triggered” quando ela reinicia, a causa é quase sempre a alimentação; nosso guia sobre brownout e Guru Meditation no ESP32 mostra como um capacitor e a fonte certa resolvem o problema. O jeito mais rápido de ver se o dispositivo está mesmo funcionando é o botão Logs: o log mostra a conexão Wi-Fi, o endereço IP recebido e cada uma das leituras dos sensores.
Erros comuns de YAML e o que eles significam
| Mensagem de erro | O que significa | Solução |
|---|---|---|
| found character '\t' that cannot start any token | Há um caractere de tabulação na linha | Troque as tabulações por espaços |
| mapping values are not allowed here | A indentação está errada ou falta um espaço depois de um dois-pontos | Alinhe com a linha de cima e escreva pin: GPIO4 em vez de pin:GPIO4 |
| Secret 'wifi_ssid' not defined | Esse nome não existe no secrets.yaml | Escreva o nome igual nos dois arquivos; maiúsculas e minúsculas fazem diferença |
| Platform not found: 'sensor.dht22' | Nome de plataforma errado | Use platform: dht com model: DHT22 |
| Duplicate key "sensor" | A mesma seção aparece duas vezes | Coloque todos os sensores sob um único sensor: |
| GPIO12 is a strapping PIN | Aviso: o pino afeta a inicialização | Mude para um pino seguro, se puder |
| ID relay redefined | Dois componentes usam o mesmo id | Dê a cada componente um id único |
ESPHome, Tasmota ou seu próprio código MQTT?
Há três caminhos comuns para levar um ESP32 à automação residencial com pouco ou nenhum código. Eles diferem em onde você faz a configuração e em como o dispositivo conversa com o Home Assistant:
| Característica | ESPHome | Tasmota | Arduino + MQTT (seu próprio código) |
|---|---|---|---|
| Como se configura | Arquivo YAML, recompilado a cada alteração | Firmware pronto, ajustes na interface web | Código C++ |
| Conexão com o Home Assistant | API nativa, descoberta automática | MQTT e a integração Tasmota | MQTT, você escreve as mensagens de descoberta |
| Atualizações sem fio | Sim, com um clique | Sim, pela interface web | Você mesmo adiciona o ArduinoOTA |
| Automação no dispositivo | on_press, interval, lambda | Comandos de Rules | O que você programar |
| Placas compatíveis | ESP32, ESP8266, Pico W e alguns outros chips Wi-Fi | ESP32 e ESP8266 | Todas |
| Curva de aprendizado | Baixa: YAML é fácil de ler | Muito baixa: você escolhe nos menus | Alta: é preciso programar |
| Ideal para | Dispositivos com sensores em torno do Home Assistant | Regravar uma tomada inteligente comprada pronta | Comportamento sob medida e controle total |
Em resumo, se você usa o Home Assistant, o ESPHome é quase sempre a opção que dá menos dor de cabeça. Se quiser regravar uma tomada inteligente que comprou, o Tasmota é uma mão na roda. Quando quiser decidir cada detalhe por conta própria, como em um jogo com display, um protocolo próprio ou um sistema sem Home Assistant, escrever seu próprio código é mais flexível, como no nosso guia ESP32, MQTT e Home Assistant. Também dá para misturar os dois: o ESPHome permite escrever pequenos trechos de C++ em blocos lambda.
ESPHome no ESP8266 e no Raspberry Pi Pico W
Para usar o mesmo YAML em outra placa, você só troca o bloco da placa e a plataforma da saída PWM. Os nomes dos pinos dependem da placa: no ESP8266 você escreve as marcações impressas na placa, como D5, e no Pico W, os números de GPIO. O Pico comum, sem Wi-Fi, e o Arduino Uno não servem para o ESPHome. A primeira gravação em um Pico W é um pouco diferente: segure BOOTSEL enquanto conecta a USB, uma unidade chamada RPI-RP2 aparece no computador e você arrasta para ela o arquivo .uf2 que o ESPHome gerou.
| Placa | Bloco da placa | Saída PWM | Primeira gravação |
|---|---|---|---|
| ESP32 DevKit | esp32: board: esp32dev | ledc | USB, pelo navegador |
| ESP32-C3 SuperMini | esp32: board: esp32-c3-devkitm-1 | ledc | USB, pelo navegador |
| Wemos D1 mini | esp8266: board: d1_mini | esp8266_pwm | USB, pelo navegador |
| NodeMCU V3 | esp8266: board: nodemcuv2 | esp8266_pwm | USB, pelo navegador |
| Raspberry Pi Pico W | rp2040: board: rpipicow | rp2040_pwm | BOOTSEL + arquivo .uf2 |
Ideias de projetos com ESPHome
- Sensor de clima do cômodo: coloque um sensor de luz BH1750 ao lado do DHT22 e envie o nível de luz em lux para o Home Assistant.
- Irrigação automática de plantas: use um sensor de umidade do solo e o relé para acionar uma bomba quando a terra secar.
- Sensor de porta e janela: com um reed switch, receba uma notificação no celular quando a porta abrir.
- Monitor de CO2: acompanhe o ar do cômodo com um MH-Z19 e receba um lembrete para abrir a janela quando o nível subir.
- Fita de LED colorida: acione uma fita WS2812B com o componente esp32_rmt_led_strip do ESPHome; se você só quer efeitos de luz, o WLED é a opção mais pronta.
- Abridor de portão de garagem: configure o relé como um botão que dá um pulso curto e use um reed switch para mostrar se o portão está aberto ou fechado.
A primeira gravação é a parte mais difícil de configurar o ESPHome; depois disso, é só questão de acrescentar algumas linhas ao seu YAML. Se você quiser conhecer as peças uma a uma antes de montar esses circuitos, o app BlueGrays tem projetos com ESP32 de iluminação automática com PIR, de temperatura e umidade com DHT22 e de iluminação inteligente com PIR, LDR e relé, cada um com esquema do circuito passo a passo e código; você pode levar a mesma ligação para o ESPHome sem mudar nada.
Perguntas frequentes
O ESPHome funciona sem o Home Assistant?
Sim. Remova o bloco api: e adicione web_server:, e o dispositivo passa a servir a própria página web; adicione mqtt: e ele conversa com sistemas como o Node-RED. As automações no dispositivo rodam independentemente do Home Assistant de qualquer forma. Só fique atento: se api: estiver presente e nenhum cliente se conectar, o dispositivo reinicia a cada 15 minutos; desative isso com reboot_timeout: 0s.
ESPHome ou Tasmota: qual é melhor?
Se você usa o Home Assistant, o ESPHome costuma ser mais prático: o dispositivo é descoberto automaticamente, os sensores chegam com as unidades certas e tudo fica em um único arquivo YAML. O Tasmota não exige compilação, então é mais conveniente quando você quer gravar uma única vez uma tomada inteligente comprada pronta e configurá-la por uma página web.
Por que meu dispositivo ESPHome aparece como offline?
O Device Builder verifica o status do dispositivo por mDNS; se o Docker, VLANs ou uma rede de convidados o bloquearem, o dispositivo aparece como Offline mesmo funcionando. Ativar status_use_ping nas opções do add-on geralmente resolve. Se o dispositivo não aparece em lugar nenhum, os dados do Wi-Fi estão errados ou a rede é de 5 GHz; o ESP32 só entra em redes de 2,4 GHz.
Posso usar código Arduino no ESPHome?
Em parte. Você pode escrever expressões C++ em blocos lambda e adicionar seus próprios componentes com external_components. Mas não dá para colar um sketch Arduino completo, com setup e loop, do jeito que está; é preciso dividir a lógica em componentes e automações do ESPHome.
Quais placas o ESPHome suporta?
A maior parte da família ESP32 (ESP32, S2, S3, C3, C6), as placas ESP8266, o Raspberry Pi Pico W, que tem Wi-Fi, e alguns outros chips Wi-Fi. O Raspberry Pi Pico comum, sem Wi-Fi, e o Arduino Uno não servem para o ESPHome.
O ESPHome não encontra meu ESP32 na primeira gravação. O que eu faço?
Primeiro confira se o cabo transmite dados e se o driver do chip USB da placa, CP2102 ou CH340, está instalado. Se estiver gravando pelo navegador, use o Chrome ou o Edge e abra a página por HTTPS. Segurar o botão BOOT enquanto ela conecta resolve a maioria dos erros “Failed to connect”.
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.

Temperatura e umidade com ESP32 e DHT22 (com display LCD)
Este projeto mede a temperatura e a umidade do ambiente com um sensor DHT22 e exibe os dados em tempo real em um LCD I2C 16x2. Os dados são lidos do sensor pelo protocolo de um fio (one-wire) com a biblioteca Adafruit DHT. Este projeto serve de base para estações meteorológicas IoT, automação residencial ou sistemas de monitoramento ambiental em estufas. A comunicação com o DHT22 é feita pelo pino GPIO 4 do ESP32.

Iluminação automática com ESP32 e sensor de movimento PIR
Neste projeto, usaremos o sensor de movimento PIR HC-SR501 para detectar quando alguém entra no cômodo e acender o LED automaticamente. Acompanharemos o tempo em que o LED fica aceso com millis(). Cada leitura HIGH do sensor atualizará o instante do último movimento, e o LED apagará pelo menos 10 segundos após a última leitura HIGH. O código atual também espera 50 ms em cada ciclo com delay(50), portanto o laço da aplicação não é totalmente livre de bloqueios.

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.

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

Alarme de movimento com ESP32 (PIR + buzzer + LED + Telegram)
Um sistema de alarme de segurança inteligente que aciona o buzzer e o LED quando o sensor PIR detecta movimento e, ao mesmo tempo, envia uma notificação instantânea ao proprietário pelo Telegram. Inclui um intervalo de espera de 30 segundos para limitar a frequência dos alarmes repetidos; esse mecanismo não valida as detecções do PIR nem elimina disparos falsos. Pode ser usado na segurança de casas, no monitoramento de garagens, depósitos ou salas de trabalho.
Mais artigos
- Tutorial de MQTT com ESP32: Mosquitto, Home Assistant e ESPHome
- Sensor de movimento PIR (HC-SR501): detecção de movimento com Arduino, ESP32 e Pico
- Instalação do WLED no ESP32: controle LEDs endereçáveis sem programar
- O que é ESP32? Características, configuração na Arduino IDE e seu primeiro projeto com Wi-Fi
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

