Guias · 11 min de leitura

Projetos ESP32 para Home Assistant: 12 ideias de casa inteligente com ESPHome

12 projetos ESP32 para Home Assistant: temperatura, presença mmWave, medidor de energia, portão de garagem, vazamento de água, campainha; ESPHome ou MQTT, com tabela de peças e custo.

Os projetos ESP32 para Home Assistant juntam uma placa ESP32 de poucos dólares com sensores e relés e a conectam ao servidor Home Assistant da sua casa, para você acompanhar luzes, temperatura, portas e consumo de energia em um único painel e transformar tudo isso em automações. A maioria dos dispositivos inteligentes prontos depende de nuvem, o app deles muda ou o fabricante abandona o suporte; um dispositivo ESP32 feito por você roda totalmente local, continua funcionando quando a internet cai e aceita qualquer sensor que você quiser. Além disso, um sensor de temperatura ou um alarme de vazamento de água sai bem mais barato que o equivalente comercial.

Neste guia reunimos 12 projetos em uma tabela com lista de peças, custo aproximado e caminho de conexão recomendado (ESPHome ou MQTT?). Depois explicamos cada projeto rapidamente e damos três exemplos prontos: um alarme de vazamento de água que funciona sem código, uma configuração ESPHome que mostra um abridor de portão de garagem de botão único como uma cover que abre e fecha no Home Assistant, e uma campainha com código Arduino que se anuncia pelo MQTT Discovery. Se você nunca instalou o ESPHome, comece pelo artigo de instalação do ESPHome; todos os detalhes do lado MQTT estão no guia ESP32, MQTT e Home Assistant.

Placa de desenvolvimento ESP32 usada em projetos com Home Assistant
ESP32 DevKit: com Wi-Fi e Bluetooth integrados, muitos GPIOs e suporte ao ESPHome, é a placa mais comum para dispositivos feitos em casa para o Home Assistant.

ESPHome ou MQTT? Como os dois caminhos se diferem

Há duas formas principais de conectar um ESP32 ao Home Assistant. Com o ESPHome você não escreve código: descreve sensores e relés em poucas linhas de YAML, o ESPHome compila e grava na placa, e o dispositivo aparece sozinho no Home Assistant. Centenas de sensores são suportados de fábrica, as atualizações acontecem pelo ar e a ligação entre o dispositivo e o Home Assistant é criptografada. Com o MQTT você mesmo escreve o código na Arduino IDE: o ESP32 envia as leituras para um broker (normalmente o complemento Mosquitto no Home Assistant), e o Home Assistant lê essas mensagens. Dá mais trabalho, mas você pode usar qualquer biblioteca e qualquer lógica, e o mesmo dispositivo também conversa com outros sistemas, como o Node-RED. A regra prática: se existe um componente ESPHome pronto, use ESPHome; para hardware incomum ou lógica complexa, use MQTT.

CaracterísticaESPHomeMQTT (código Arduino)
CódigoYAML; lambdas curtas em C++ quando necessárioTudo em C++, você escreve tudo
Adicionar ao Home AssistantDescoberto automaticamente, adicionado com um cliqueVocê envia as mensagens de Discovery
Infraestrutura necessáriaComplemento ESPHome ou ESPHome BuilderBroker Mosquitto
AtualizaçõesPelo ar (OTA), a partir do painelVocê adiciona o código de OTA
Uso com outros sistemasLimitado (também dá para ativar o MQTT)Funciona com qualquer cliente MQTT
Melhor paraDispositivos padrão como sensores, relés, luzesProtocolos próprios, lógica complexa, código Arduino que já existe

12 projetos ESP32 para Home Assistant: tabela de peças, caminho e custo

#ProjetoPeçasCaminho recomendadoCusto aprox.Nível
1Sensor de temperatura e umidadeESP32, BME280 ou SHT31ESPHome$8–12Fácil
2CO2 e qualidade do arESP32, SCD40 ou MH-Z19ESPHome$20–35Fácil
3Luz acionada por movimentoESP32, PIR HC-SR501, reléESPHome$7–10Fácil
4Sensor de presença mmWaveESP32, LD2410ESPHome$8–12Médio
5Sensor de porta e janelaESP32, reed switch, ímãESPHome$6–8Fácil
6Alarme de vazamento de águaESP32, módulo sensor de chuva, buzzerESPHome$6–8Fácil
7Controle do portão da garagemESP32, relé, reed switchESPHome$8–12Médio
8Aviso de campainhaESP32, botão, buzzerMQTT ou ESPHome$6–8Fácil
9Tomada inteligente com reléESP32, módulo relé, caixa, fusívelESPHome$10–15Médio
10Medidor de energiaESP32, PZEM-004T v3 + transformador de correnteESPHome ou MQTT$12–18Médio
11Controle de fita de LEDESP32, fita WS2812B, adaptador de 5 VWLED ou ESPHome$15–30Fácil
12Proxy BluetoothSó o ESP32ESPHome$4–6Fácil

Os custos são aproximados e variam conforme o vendedor, o país e peças extras como caixa ou adaptador; considera-se $4–6 para a placa ESP32 DevKit. Esses 12 itens são ideias de projeto comuns para o Home Assistant. O app BlueGrays tem projetos com ESP32 que ensinam o lado do hardware deles: ESP32 DHT22 Temperatura e Umidade, ESP32 Iluminação automática com sensor de movimento PIR, ESP32 Iluminação inteligente (PIR + LDR + Relé + OLED), ESP32 Detector de gás/fumaça MQ-2 e ESP32 Controle de fita NeoPixel WS2812B. Monte o circuito pelo esquema de lá e conecte o software ao Home Assistant com ESPHome ou MQTT.

Projetos de medição (1–2): temperatura, umidade e CO2

O Projeto 1 é o primeiro dispositivo ESPHome da maioria das pessoas. Um DHT22 dá conta, mas sensores I2C como o BME280 ou o SHT31 são mais precisos e mais estáveis; no ESP32, usa-se o GPIO 21 para SDA e o GPIO 22 para SCL. Não coloque o sensor colado na placa: o ESP32 esquenta enquanto o Wi-Fi funciona e empurra a leitura 1–2 °C para cima, então leve o sensor para fora ou para o fundo da caixa com alguns centímetros de cabo (sensor BME280). O Projeto 2 acrescenta um sensor que mede CO2. O SCD40 e o MH-Z19 são sensores de CO2 de verdade, com medição NDIR ou fotoacústica; o barato MQ-135 só dá uma tendência geral da qualidade do ar. Quando o CO2 passa de 1000 ppm, o Home Assistant pode mandar uma notificação ou ligar a ventilação; em um quarto onde alguém estuda, a diferença é bem perceptível (sensor de CO2 MH-Z19).

Projetos de presença e movimento (3–5): PIR, mmWave e sensor de porta

No Projeto 3 a luz acende quando o HC-SR501 detecta movimento. Se você definir a automação dentro do ESPHome, no próprio dispositivo, a luz funciona mesmo com o Home Assistant fora do ar; essa operação local é a maior vantagem dos dispositivos feitos em casa (sensor de movimento PIR). O ponto fraco do PIR é que ele não vê uma pessoa parada: a luz apaga enquanto você lê no sofá. O Projeto 4 resolve isso com o radar mmWave LD2410. O radar detecta até movimentos mínimos como a respiração, tem componente ESPHome integrado e permite ajustar a sensibilidade por faixa de distância; os melhores resultados vêm da combinação com um PIR (sensor de presença LD2410). No Projeto 5 um reed switch e um ímã informam se uma porta ou janela está aberta; como o ESP32 fica no Wi-Fi o tempo todo, planeje alimentar esse sensor com um adaptador, e não com pilhas (reed switch).

Se você quer monitorar várias portas ou janelas, não precisa de um ESP32 para cada uma: ligue oito reed switches em GPIOs separados da mesma placa e defina cada um como um binary_sensor próprio. Na escolha dos pinos, evite os pinos de boot (GPIO 0, 2, 12, 15); os pinos adequados estão na ferramenta de pinagem.

Alarme de vazamento de água (6): um exemplo ESPHome sem código

O Projeto 6 é o mais barato da lista, mas talvez o mais valioso: um sensor colocado embaixo da máquina de lavar, da lava-louças ou do aquecedor toca um buzzer e manda uma notificação para o seu celular no instante em que a água vaza. Aqui a placa sensora de um módulo sensor de chuva fica no chão; o comparador LM393 do módulo coloca a saída digital (DO) em LOW quando a placa molha, e a sensibilidade é ajustada no potenciômetro do módulo (sensor de chuva). Na configuração abaixo, a automação do buzzer roda dentro do dispositivo: o alarme toca mesmo que o Wi-Fi ou o Home Assistant estejam fora do ar.

Código
1# ESPHome: ESP32 su kaçağı alarmı / ESP32 water leak alarm
2esphome:
3  name: su-kacagi                   # küçük harf ve tire / lowercase and hyphens
4  friendly_name: Su Kacagi
5
6esp32:
7  board: esp32dev
8
9logger:
10api:                                # Home Assistant bağlantısı / Home Assistant link
11  encryption:
12    key: !secret api_key
13ota:
14  - platform: esphome
15    password: !secret ota_password
16wifi:
17  ssid: !secret wifi_ssid
18  password: !secret wifi_password
19
20binary_sensor:
21  - platform: gpio
22    name: "Water Leak"
23    device_class: moisture          # HA'da "Islak / Kuru" görünür / shows as Wet / Dry
24    pin:
25      number: GPIO25
26      inverted: true                # modül ıslakken DO = LOW / module DO goes LOW when wet
27    filters:
28      - delayed_on: 2s              # tek damlayı yok say / ignore a single splash
29      - delayed_off: 30s
30    on_press:                       # Wi-Fi kopsa da yerel alarm çalar / local alarm works without Wi-Fi
31      - switch.turn_on: buzzer
32    on_release:
33      - switch.turn_off: buzzer
34
35switch:
36  - platform: gpio
37    id: buzzer
38    name: "Leak Buzzer"
39    pin: GPIO23
40    restore_mode: ALWAYS_OFF        # elektrik gelince sessiz / silent after power-up

A linha device_class: moisture faz o Home Assistant mostrar o sensor como "Molhado / Seco" e escolher o ícone certo. O filtro delayed_on: 2s impede que um respingo isolado dispare o alarme, e o delayed_off: 30s evita que o alarme fique ligando e desligando enquanto a água seca e molha a placa de novo. Coloque os dados do Wi-Fi e as senhas no arquivo secrets.yaml do ESPHome, e não direto no arquivo; as linhas !secret pegam os valores de lá. A notificação no celular você configura com uma automação no Home Assistant: como gatilho, escolha este sensor mudando para Molhado e, como ação, envie uma notificação para o app.

Lembre que a placa sensora e o módulo vão encontrar água embaixo de aparelhos elétricos: coloque o ESP32 e o adaptador no alto, longe do chão, em uma caixa onde a água não respingue, e desça só um cabo fino até a placa. Um alarme de vazamento é um aviso; se você quiser fechar o registro geral, precisa de uma válvula motorizada e de uma fonte separada, e nunca ligue uma válvula solenoide de 12 V direto em um pino do ESP32; use sempre um relé ou um MOSFET.

Portão da garagem (7): controle de cover com relé e reed switch

O Projeto 7 se baseia em ligar um relé nos contatos do botão de parede que a maioria dos motores de portão de garagem tem: quando o relé fecha por meio segundo, o motor abre, para ou fecha o portão como se alguém tivesse apertado o botão. Para saber o estado real do portão, um reed switch e um ímã são posicionados para se encontrar quando o portão está fechado. A template cover do ESPHome transforma essas duas peças em um único portão de garagem com setas para cima e para baixo no Home Assistant; o comando "Abrir" só aciona o relé quando o portão está fechado e o "Fechar" só quando está aberto, então o portão nunca começa a andar para o lado errado por acidente.

LigaçãoPino do ESP32Observação
Reed switch (uma ponta)GPIO 27Outra ponta no GND; pull-up interno ativado
IN do módulo reléGPIO 26COM e NO do relé em paralelo com a entrada do botão do motor
VCC / GND do módulo reléVIN (5 V) / GNDA bobina precisa de 5 V; prefira um módulo com acionamento em 3,3 V
Alimentação do ESP32USB ou adaptador de 5 VNão use diretamente a saída de 24 V do próprio motor
Código
1# ESPHome: tek butonlu garaj kapısı motoru için kapak (cover)
2# ESPHome: cover for a single-button garage door opener
3binary_sensor:
4  - platform: gpio
5    id: garage_closed
6    name: "Garage Closed"
7    pin:
8      number: GPIO27
9      mode:
10        input: true
11        pullup: true                # reed röle GND'ye / reed switch to GND
12      inverted: true                # mıknatıs yakın = kapalı / magnet near = closed
13    filters:
14      - delayed_on_off: 100ms       # kontak sıçramasını süz / debounce
15
16switch:
17  - platform: gpio
18    id: garage_relay
19    pin: GPIO26
20    internal: true                  # HA'da ayrı anahtar görünmesin / hide from HA
21    restore_mode: ALWAYS_OFF
22    on_turn_on:                     # motor butonuna 0,5 sn bas / press the opener button for 0.5 s
23      - delay: 500ms
24      - switch.turn_off: garage_relay
25
26cover:
27  - platform: template
28    name: "Garage Door"
29    device_class: garage
30    lambda: |-
31      if (id(garage_closed).state) {
32        return COVER_CLOSED;
33      } else {
34        return COVER_OPEN;
35      }
36    open_action:                    # yalnız kapalıysa bas / press only if closed
37      - if:
38          condition:
39            binary_sensor.is_on: garage_closed
40          then:
41            - switch.turn_on: garage_relay
42    close_action:                   # yalnız açıksa bas / press only if open
43      - if:
44          condition:
45            binary_sensor.is_off: garage_closed
46          then:
47            - switch.turn_on: garage_relay
48    stop_action:
49      - switch.turn_on: garage_relay
Fechar um portão de garagem a distância pode ser perigoso: pode haver uma criança, um animal ou um carro embaixo. Confira se os sensores de obstáculo do próprio motor (fotocélulas) funcionam e, no Home Assistant, só permita o comando de fechar quando você puder ver o portão ou depois de uma confirmação por câmera. Ligue os terminais do relé apenas na entrada de botão de baixa tensão do motor; não mexa no lado da rede elétrica.

Campainha (8): código Arduino com MQTT Discovery

Daria para fazer o Projeto 8 em poucas linhas de ESPHome também, mas ele é um bom exemplo para conhecer o caminho MQTT. O código abaixo envia uma entidade event ao Home Assistant quando o botão da campainha é apertado. Ao conectar, o código grava uma mensagem de descoberta retida em um tópico homeassistant/event/...; quando o Home Assistant a vê, cria sozinho um dispositivo chamado "ESP32 Kapi Zili" e uma entidade de evento do tipo campainha. Graças à mensagem Last Will, se a placa perder energia ou cair do Wi-Fi, o Home Assistant mostra o dispositivo como indisponível. Ligue o evento que chega a cada toque a uma automação e envie uma notificação ao celular, um toque para um alto-falante ou uma foto de uma câmera na porta.

C++ (Arduino IDE)
1// ESP32 kapı zili: MQTT Discovery ile Home Assistant'ta "event" varlığı
2// ESP32 doorbell: an "event" entity in Home Assistant via MQTT Discovery
3#include <WiFi.h>
4#include <PubSubClient.h>
5
6const char* WIFI_SSID = "WIFI_ADIN";
7const char* WIFI_PASS = "WIFI_SIFRESI";
8const char* MQTT_HOST = "192.168.1.50";      // Home Assistant / Mosquitto IP'si / broker IP
9const char* MQTT_USER = "mqtt_kullanici";
10const char* MQTT_PASS = "mqtt_sifresi";
11
12#define BUTTON_PIN 27        // zil butonu GND'ye / bell button to GND
13const char* CLIENT_ID  = "esp32-kapi-zili";
14const char* T_CONFIG   = "homeassistant/event/esp32_kapi_zili/config";
15const char* T_EVENT    = "bluegrays/kapi_zili/event";
16const char* T_AVAIL    = "bluegrays/kapi_zili/status";
17
18WiFiClient net;
19PubSubClient mqtt(net);
20unsigned long lastTry = 0, lastRing = 0;
21bool lastLevel = HIGH;
22
23void announce() {
24  // Keşif mesajı: Home Assistant cihazı kendiliğinden ekler / discovery: HA adds the device by itself
25  const char* cfg =
26    "{\"name\":\"Kapi Zili\",\"unique_id\":\"esp32_kapi_zili\",\"device_class\":\"doorbell\","
27    "\"event_types\":[\"press\"],\"state_topic\":\"bluegrays/kapi_zili/event\","
28    "\"availability_topic\":\"bluegrays/kapi_zili/status\","
29    "\"device\":{\"identifiers\":[\"esp32_kapi_zili\"],\"name\":\"ESP32 Kapi Zili\",\"manufacturer\":\"BlueGrays\"}}";
30  mqtt.publish(T_CONFIG, cfg, true);          // retain: HA yeniden başlasa da bulur / retained for HA restarts
31  mqtt.publish(T_AVAIL, "online", true);
32}
33
34void ensureMqtt() {
35  if (mqtt.connected() || millis() - lastTry < 5000) return;   // beklemeden 5 sn'de bir dene / retry every 5 s, never block
36  lastTry = millis();
37  // Son vasiyet: koparsa broker "offline" yazar / last will: broker writes "offline" if we drop
38  if (mqtt.connect(CLIENT_ID, MQTT_USER, MQTT_PASS, T_AVAIL, 1, true, "offline")) {
39    announce();
40    Serial.println("MQTT bagli / connected");
41  } else {
42    Serial.printf("MQTT hata / error rc=%d\n", mqtt.state());
43  }
44}
45
46void setup() {
47  Serial.begin(115200);
48  pinMode(BUTTON_PIN, INPUT_PULLUP);
49  WiFi.mode(WIFI_STA);
50  WiFi.setAutoReconnect(true);
51  WiFi.begin(WIFI_SSID, WIFI_PASS);
52  mqtt.setServer(MQTT_HOST, 1883);
53  mqtt.setBufferSize(512);                     // keşif JSON'u 256 baytı aşar / discovery JSON exceeds 256 bytes
54}
55
56void loop() {
57  if (WiFi.status() == WL_CONNECTED) {
58    ensureMqtt();
59    mqtt.loop();
60  }
61  bool level = digitalRead(BUTTON_PIN);
62  // Düşen kenar + 3 sn kilit: tek basış tek bildirim / falling edge + 3 s lockout: one press, one event
63  if (lastLevel == HIGH && level == LOW && millis() - lastRing > 3000) {
64    delay(30);                                 // kısa debounce / short debounce
65    if (digitalRead(BUTTON_PIN) == LOW) {
66      lastRing = millis();
67      bool ok = mqtt.connected() && mqtt.publish(T_EVENT, "{\"event_type\":\"press\"}");
68      Serial.println(ok ? "Zil! / Ding!" : "Gonderilemedi / Not sent");
69    }
70  }
71  lastLevel = level;
72}

Repare em três detalhes do código. Sem a linha setBufferSize(512), o buffer padrão de 256 bytes da PubSubClient não comporta a mensagem de descoberta e o publish() falha em silêncio. As tentativas de conexão acontecem a cada cinco segundos e o loop() nunca trava em lugar nenhum, então o botão continua sendo lido enquanto o broker está fora. O bloqueio de três segundos evita que dezenas de notificações cheguem ao seu celular quando alguém aperta o botão várias vezes. Ligue o botão entre o GPIO 27 e o GND; graças ao INPUT_PULLUP, não precisa de resistor extra. Não ligue a linha de 8–24 V AC de um transformador de campainha existente direto no ESP32; leia o botão da campainha por um fio separado ou use um optoacoplador.

Energia e iluminação (9–11): tomada, medidor de energia e fita de LED

No Projeto 9 um módulo relé permite que o ESP32 ligue e desligue uma tomada; definido como switch no ESPHome, ele pode usar os agendamentos e as automações do Home Assistant. Neste projeto ligado à rede elétrica, uma caixa fechada, ventilada e com fusível é obrigatória; se você não tem experiência, tomadas inteligentes prontas que podem receber ESPHome ou Tasmota são uma escolha mais segura (módulo relé). No Projeto 10 o módulo PZEM-004T v3 mede tensão, corrente, potência, energia total (kWh), frequência e fator de potência e se conecta ao ESP32 por UART. O componente pzemac do ESPHome leva esses valores direto para o painel de energia do Home Assistant; como o transformador de corrente se prende ao cabo sem cortá-lo, só os fios de medição de tensão vão à rede elétrica (medidor de energia PZEM-004T). No Projeto 11, o caminho mais rápido para uma fita WS2812B é o WLED: o Home Assistant descobre dispositivos WLED sozinho e deixa você escolher efeitos direto do painel (instalação do WLED). Se preferir controlar a fita com o componente light do ESPHome dentro das suas automações, também funciona.

Proxy Bluetooth (12): amplie o alcance do Home Assistant

O Projeto 12 não precisa de sensor nenhum: um ESP32 com o componente bluetooth_proxy do ESPHome ativado escuta os dispositivos BLE ao redor e os repassa ao Home Assistant. Assim, termômetros Xiaomi, sensores de plantas, balanças inteligentes e outros dispositivos BLE em cômodos longe do servidor ficam visíveis no Home Assistant. Um por andar geralmente basta. Como o Wi-Fi e o Bluetooth dividem a mesma antena, não coloque outras tarefas pesadas no dispositivo proxy; se possível, use uma placa ESP32 com Ethernet cabeada ou uma placa dedicada a essa função.

Erros comuns em projetos ESP32 com Home Assistant

SintomaCausa provávelSolução
O dispositivo não aparece no Home AssistantO ESP32 e o servidor estão em redes diferentes ou o mDNS está bloqueadoColoque-os na mesma rede e adicione a integração ESPHome pelo IP em Configurações > Dispositivos
O dispositivo fica indisponível com frequênciaSinal de Wi-Fi fraco ou alimentação insuficienteVerifique o RSSI com o sensor wifi_signal; se for mais fraco que -75 dBm, aproxime a placa e use um adaptador de 1 A
A temperatura aparece mais alta que a realO sensor é aquecido pelo ESP32Afaste o sensor da placa com um cabo e acrescente um pequeno offset com filtros
O dispositivo MQTT nunca é criadoA mensagem de descoberta não cabe no buffer ou o broker está inacessívelAdicione setBufferSize(512) e veja o código rc no Serial
Sensor analógico enlouquece com o Wi-Fi ligadoO sensor está em um pino ADC2Use os pinos ADC1 entre o GPIO 32 e o 39
O relé liga sozinho ao energizarSem restore_mode definido ou pino de boot em usoAdicione restore_mode: ALWAYS_OFF e passe o relé para um pino seguro como o GPIO 26
Adicione um sensor wifi_signal e um uptime a todo dispositivo ESPHome. O primeiro mostra cedo os problemas de conexão, o segundo revela se o dispositivo reinicia sozinho; juntos, eles permitem medir um problema em vez de adivinhar.

Por qual projeto começar?

  • Você acabou de instalar o Home Assistant: conheça o ESPHome com o sensor de temperatura do Projeto 1; quando o dispositivo aparecer no painel, você terá aprendido o fluxo básico.
  • Você quer algo útil logo de cara: o alarme de vazamento de água do Projeto 6 fica pronto em uma noite e se paga muitas vezes ao pegar um único vazamento.
  • Você quer automatizar as luzes: comece pelo Projeto 3 e depois detecte pessoas paradas com o radar mmWave do Projeto 4.
  • Você gosta de escrever código Arduino: use o exemplo MQTT do Projeto 8 como base e anuncie os seus próprios sensores do mesmo jeito.
  • Você tem curiosidade sobre a conta de luz: acompanhe o consumo dia a dia no painel de energia do Home Assistant com o Projeto 10.

Uma casa inteligente feita com os seus próprios dispositivos ESP32 é muito mais flexível e barata que uma montada com aparelhos prontos; cada nova necessidade vira apenas um novo projeto com poucas peças. Comece com um único sensor, curta vê-lo no Home Assistant e depois amplie as suas automações. No app BlueGrays você encontra projetos com ESP32 como medição de temperatura e umidade com DHT22, iluminação automática com PIR, iluminação inteligente, detector de gás e controle de fita WS2812B, cada um com esquema de ligação, lista de peças e código pronto, e pode conectar esses circuitos ao Home Assistant com ESPHome ou MQTT.

Perguntas frequentes

Como conectar um ESP32 ao Home Assistant?

O jeito mais fácil é o ESPHome: você descreve os sensores em um arquivo YAML, o ESPHome compila e grava na placa, e o dispositivo aparece sozinho no Home Assistant. Se preferir escrever código Arduino, instale o broker Mosquitto, envie mensagens MQTT do ESP32 com a PubSubClient e anuncie o dispositivo com o MQTT Discovery.

ESPHome ou Tasmota?

Se você usa o Home Assistant, o ESPHome costuma ser a melhor escolha: os dispositivos são adicionados automaticamente, o suporte a sensores é muito amplo e as automações podem rodar no próprio dispositivo. O Tasmota serve para tomadas inteligentes prontas e dispositivos independentes que precisam se conectar a sistemas diferentes por MQTT.

ESP32 ou ESP8266 para o Home Assistant?

Projetos novos devem usar o ESP32: ele oferece mais memória, mais entradas analógicas e Bluetooth, e recursos como o proxy Bluetooth só funcionam no ESP32. O ESP8266 ainda serve com ESPHome para dispositivos simples com um sensor ou um relé.

Um dispositivo ESPHome funciona sem internet?

Sim. Os dispositivos ESPHome conversam com o Home Assistant pela rede local e não precisam de nuvem. As automações definidas no dispositivo, como tocar um buzzer quando um vazamento é detectado, continuam funcionando mesmo com o Wi-Fi ou o Home Assistant fora do ar.

Um sensor de casa inteligente com ESP32 pode funcionar com pilhas?

Um ESP32 que fica no Wi-Fi o tempo todo dura só alguns dias com pilhas. Sensores que usam deep sleep e acordam a cada poucos minutos para enviar uma leitura podem funcionar por semanas ou meses; dispositivos que precisam reagir na hora, como um sensor de porta, ficam melhor alimentados por adaptador.

Por que um sensor mmWave é melhor que um PIR no Home Assistant?

Um PIR só detecta uma fonte de calor em movimento e não vê alguém parado, então as luzes apagam enquanto você lê ou vê TV. Radares mmWave como o LD2410 também detectam movimentos mínimos como a respiração e informam presença enquanto houver alguém no cômodo; os melhores resultados vêm do uso dos dois juntos.

Ver todos os projetos
Temperatura e umidade com ESP32 e DHT22 (com display LCD)
ES-15Intermediário

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.

4.8(38)
57
Iluminação automática com ESP32 e sensor de movimento PIR
ES-19Intermediário
Premium

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.

4.4(24)
38
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
Alarme detector de gás e fumaça com ESP32 e MQ-2
ES-20Intermediário

Alarme detector de gás e fumaça com ESP32 e MQ-2

Neste projeto, um módulo sensor de gás MQ-2 detecta gases combustíveis (LPG, metano e propano) e fumaça, acionando um alarme tipo sirene em um buzzer passivo. A saída digital de limiar (DO) do sensor é conectada ao GPIO 4 do ESP32. Quando a concentração de gás ou fumaça ultrapassa o limiar, DO passa para LOW e o alarme é acionado. A sensibilidade é ajustada pelo potenciômetro do módulo. O buzzer passivo é acionado com tone() para criar um efeito de sirene que alterna entre duas frequências.

4.7(29)
44
Controle de fita WS2812B NeoPixel com ESP32
ES-24Intermediário
Premium

Controle de fita WS2812B NeoPixel com ESP32

Os LEDs endereçáveis WS2812B (NeoPixel) são LEDs RGB inteligentes que podem ser controlados em cadeia por um único pino de dados. Neste projeto, vamos controlar uma fita WS2812B de 8 LEDs com a biblioteca Adafruit_NeoPixel para criar uma animação suave de arco-íris. Embora o nível lógico de 3,3V do ESP32 funcione sem problemas na maioria dos lotes de WS2812B, vamos mostrar uma solução com um resistor de 470Ω em série e um capacitor de 1.000µF para casos de instabilidade.

4.9(19)
30
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