Como criar um detector de vazamento de água e gás com automação residencial e IA

Nos últimos anos, a automação residencial tem conquistado cada vez mais espaço no Brasil. Além de trazer conforto e praticidade para o dia a dia, a tecnologia também pode ser uma grande aliada na segurança e na prevenção de acidentes domésticos. Um exemplo prático e extremamente útil é a criação de detectores de vazamento de água e gás que não apenas alertam o morador sobre possíveis problemas, mas podem, em alguns casos, até interromper automaticamente o fornecimento para evitar maiores prejuízos.

Esse tipo de projeto une o melhor de dois mundos: a facilidade de usar plataformas acessíveis, como Arduino e ESP32, e a possibilidade de integrar inteligência artificial (IA) para tornar a automação cada vez mais inteligente e personalizada.

Neste artigo, você vai aprender de forma simples e direta como criar seu próprio detector de vazamento, começando pelo básico e evoluindo para soluções mais avançadas, capazes de prever e detectar problemas com mais precisão. Vamos lá?

Por que um detector de vazamento é tão importante?

Os acidentes domésticos envolvendo vazamentos de gás são uma das principais causas de incêndios residenciais no Brasil. Segundo o Corpo de Bombeiros, cerca de 30% dos incêndios residenciais têm origem em vazamentos de gás. Da mesma forma, um vazamento de água pode causar desde o aumento da conta no final do mês até sérios danos estruturais à casa, especialmente quando não é detectado a tempo.

O problema é que, na maioria dos casos, esses vazamentos acontecem quando não estamos por perto para perceber. Por isso, contar com um sistema automatizado que faz a detecção em tempo real e envia alertas para o celular ou toma medidas imediatas, como fechar a válvula de água ou gás, pode evitar prejuízos enormes e até salvar vidas.

Além disso, com o uso de IA embarcada (que abordaremos nas fases mais avançadas), esse tipo de sistema pode aprender padrões de consumo e identificar comportamentos anormais, oferecendo um nível ainda maior de segurança e eficiência.

O que você vai aprender neste artigo

Aqui está o que vamos abordar de forma bem didática, dividido em fases de complexidade crescente:

Não se preocupe se você nunca mexeu com eletrônica antes. Vou explicar cada parte de forma acessível, para que qualquer pessoa interessada consiga pelo menos completar as duas primeiras fases.

Materiais necessários

Para começar, vamos precisar de alguns componentes básicos. A vantagem é que todos eles são baratos e fáceis de encontrar em lojas físicas ou online no Brasil.

Componentes essenciais (Fase 1):

• ESP32: o "cérebro" do sistema. Escolha o ESP32 em vez do Arduino porque já tem Wi-Fi integrado, facilitando expansões futuras (R$ 50-70)
• Sensor de vazamento de água FC-28: detecta presença de líquido em determinado ponto (R$ 12-18)
• Sensor de gás MQ-2: para gás inflamável em geral, ou MQ-5 para GLP específico (R$ 15-25)
• Buzzer ativo 5V: para sinalizar localmente quando um vazamento for detectado (R$ 5-10)
• LED vermelho: indicação visual adicional (R$ 2-5)
• Resistor 220Ω: para o LED (R$ 1-3)
• Protoboard 830 pontos: para facilitar as conexões (R$ 15-25)
• Jumpers macho-macho: pelo menos 15 unidades (R$ 10-18)
• Fonte USB 5V: para energizar o sistema (R$ 18-30)

Componentes opcionais (Fases avançadas):

• Válvula solenoide 1/2": para cortar água automaticamente (R$ 60-120)
• Válvula solenoide para gás: APENAS com certificação INMETRO (R$ 180-400)
• Sensor de pressão: para detecção mais precisa (R$ 30-50)
• Display OLED 0.96": para informações locais (R$ 18-30)

Fase 1: Montando o circuito básico

A montagem é simples e segue a mesma lógica para água e gás. Vamos usar os pinos GPIO do ESP32 de forma organizada.

Esquema de conexões:

Fase 1: Programação básica

Vamos usar a Arduino IDE. Primeiro, instale o suporte para ESP32:

1. Abra Arduino IDE
2. Vá em Arquivo > Preferências
3. Em "URLs Adicionais para Gerenciadores de Placas", cole: https://dl.espressif.com/dl/package_esp32_index.json
4. Vá em Ferramentas > Placa > Gerenciador de Placas
5. Busque por "ESP32" e instale

Aqui está o código corrigido e melhorado:

// Definições dos pinos
#define SENSOR_AGUA 4      // GPIO 4
#define SENSOR_GAS 2       // GPIO 2  
#define BUZZER 5           // GPIO 5
#define LED_ALERTA 18      // GPIO 18

// Variáveis de controle
bool alertaAtivo = false;
unsigned long ultimoAlerta = 0;
const unsigned long INTERVALO_ALERTA = 2000; // 2 segundos entre alertas

void setup() {
  // Configuração dos pinos
  pinMode(SENSOR_AGUA, INPUT);
  pinMode(SENSOR_GAS, INPUT);
  pinMode(BUZZER, OUTPUT);
  pinMode(LED_ALERTA, OUTPUT);
  
  // Inicialização da comunicação serial
  Serial.begin(115200);
  Serial.println("=== Sistema Detector de Vazamentos ===");
  Serial.println("Aguardando aquecimento do sensor de gás...");
  
  // Aquecimento do sensor de gás (30 segundos)
  for(int i = 30; i > 0; i--) {
    Serial.print("Aquecendo: ");
    Serial.print(i);
    Serial.println("s");
    delay(1000);
  }
  
  Serial.println("Sistema pronto!");
  // Teste rápido dos alertas
  testarAlertas();
}

void loop() {
  // Leitura dos sensores
  int leituraAgua = digitalRead(SENSOR_AGUA);
  int leituraGas = digitalRead(SENSOR_GAS);
  
  // Verificação de vazamento de água
  // FC-28: LOW = água detectada, HIGH = sem água
  if (leituraAgua == LOW) {
    ativarAlerta("ÁGUA");
  }
  // Verificação de vazamento de gás  
  // MQ-2: LOW = gás detectado, HIGH = sem gás
  else if (leituraGas == LOW) {
    ativarAlerta("GÁS");
  }
  else {
    desativarAlerta();
  }
  
  delay(100); // Delay reduzido para resposta mais rápida
}

void ativarAlerta(String tipoVazamento) {
  unsigned long agora = millis();
  
  if (!alertaAtivo || (agora - ultimoAlerta > INTERVALO_ALERTA)) {
    alertaAtivo = true;
    ultimoAlerta = agora;
    
    // Mensagem no serial
    Serial.print("ALERTA: Vazamento de ");
    Serial.print(tipoVazamento);
    Serial.println(" detectado!");
    
    // Ativar sinalizações
    digitalWrite(LED_ALERTA, HIGH);
    digitalWrite(BUZZER, HIGH);
    delay(500);
    digitalWrite(BUZZER, LOW);
    
    // Para gás, alerta é mais insistente
    if (tipoVazamento == "GÁS") {
      delay(200);
      digitalWrite(BUZZER, HIGH);
      delay(300);
      digitalWrite(BUZZER, LOW);
    }
  }
}

void desativarAlerta() {
  if (alertaAtivo) {
    alertaAtivo = false;
    digitalWrite(LED_ALERTA, LOW);
    digitalWrite(BUZZER, LOW);
    Serial.println("Sistema: Normal");
  }
}

void testarAlertas() {
  Serial.println("Testando sistema de alertas...");
  
  digitalWrite(LED_ALERTA, HIGH);
  digitalWrite(BUZZER, HIGH);
  delay(200);
  digitalWrite(BUZZER, LOW);
  delay(200);
  digitalWrite(LED_ALERTA, LOW);
  
  Serial.println("Teste concluído!");
}

Como testar o sistema:

• Sensor de água: Coloque algumas gotas de água nos eletrodos do FC-28
• Sensor de gás: Use um isqueiro próximo ao sensor (SEM acender) ou spray desodorante
• Importante: Teste sempre em ambiente ventilado

Fase 2: Adicionando conectividade Wi-Fi

Agora vamos evoluir o projeto para enviar notificações para o celular. Vamos usar o Blynk, que é gratuito e simples de configurar.

Configurando o Blynk:

1. Baixe o app Blynk no seu celular
2. Crie uma conta gratuita
3. Crie um novo projeto e anote o "Auth Token"
4. Adicione widgets de notificação

Código com Wi-Fi e notificações:

// Incluir bibliotecas
#include <WiFi.h>
#include <BlynkSimpleEsp32.h>

// Configurações Wi-Fi e Blynk
char auth[] = "SEU_AUTH_TOKEN_AQUI";
char ssid[] = "NOME_DA_SUA_REDE_WIFI";
char password[] = "SENHA_DA_SUA_REDE_WIFI";

// Definições dos pinos (mesmas da Fase 1)
#define SENSOR_AGUA 4
#define SENSOR_GAS 2
#define BUZZER 5
#define LED_ALERTA 18

// Variáveis de controle
bool alertaAtivo = false;
bool wifiConectado = false;
unsigned long ultimoAlerta = 0;
const unsigned long INTERVALO_ALERTA = 10000; // 10 segundos entre notificações

void setup() {
  pinMode(SENSOR_AGUA, INPUT);
  pinMode(SENSOR_GAS, INPUT);
  pinMode(BUZZER, OUTPUT);
  pinMode(LED_ALERTA, OUTPUT);
  
  Serial.begin(115200);
  Serial.println("=== Sistema Detector de Vazamentos v2.0 ===");
  
  // Conectar Wi-Fi
  conectarWiFi();
  
  // Aquecimento do sensor de gás
  Serial.println("Aquecendo sensor de gás...");
  for(int i = 30; i > 0; i--) {
    Serial.print("Aquecimento: ");
    Serial.print(i);
    Serial.println("s");
    delay(1000);
  }
  
  Serial.println("Sistema pronto!");
  testarAlertas();
  
  // Notificação de sistema iniciado
  if (wifiConectado) {
    Blynk.notify("Sistema de detecção de vazamentos iniciado!");
  }
}

void loop() {
  if (wifiConectado) {
    Blynk.run();
  }
  
  int leituraAgua = digitalRead(SENSOR_AGUA);
  int leituraGas = digitalRead(SENSOR_GAS);
  
  if (leituraAgua == LOW) {
    ativarAlerta("ÁGUA", "💧 ALERTA: Vazamento de água detectado em casa!");
  }
  else if (leituraGas == LOW) {
    ativarAlerta("GÁS", "🔥 EMERGÊNCIA: Vazamento de gás detectado! Ventile o ambiente!");
  }
  else {
    desativarAlerta();
  }
  
  delay(100);
}

void conectarWiFi() {
  Serial.print("Conectando ao Wi-Fi");
  WiFi.begin(ssid, password);
  
  int tentativas = 0;
  while (WiFi.status() != WL_CONNECTED && tentativas < 20) {
    delay(500);
    Serial.print(".");
    tentativas++;
  }
  
  if (WiFi.status() == WL_CONNECTED) {
    wifiConectado = true;
    Serial.println();
    Serial.println("Wi-Fi conectado!");
    Serial.print("IP: ");
    Serial.println(WiFi.localIP());
    
    // Inicializar Blynk
    Blynk.begin(auth, ssid, password);
  } else {
    Serial.println();
    Serial.println("Falha na conexão Wi-Fi. Modo offline ativo.");
  }
}

void ativarAlerta(String tipo, String mensagem) {
  unsigned long agora = millis();
  
  if (!alertaAtivo || (agora - ultimoAlerta > INTERVALO_ALERTA)) {
    alertaAtivo = true;
    ultimoAlerta = agora;
    
    Serial.println(mensagem);
    
    // Alertas locais
    digitalWrite(LED_ALERTA, HIGH);
    for (int i = 0; i < 3; i++) {
      digitalWrite(BUZZER, HIGH);
      delay(200);
      digitalWrite(BUZZER, LOW);
      delay(200);
    }
    
    // Notificação remota
    if (wifiConectado) {
      Blynk.notify(mensagem);
      
      // Enviar dados para o app
      if (tipo == "ÁGUA") {
        Blynk.virtualWrite(V1, 1); // Virtual pin V1 para água
      } else if (tipo == "GÁS") {
        Blynk.virtualWrite(V2, 1); // Virtual pin V2 para gás
      }
    }
  }
}

void desativarAlerta() {
  if (alertaAtivo) {
    alertaAtivo = false;
    digitalWrite(LED_ALERTA, LOW);
    digitalWrite(BUZZER, LOW);
    
    if (wifiConectado) {
      Blynk.virtualWrite(V1, 0);
      Blynk.virtualWrite(V2, 0);
    }
    
    Serial.println("Sistema: Normal");
  }
}

void testarAlertas() {
  Serial.println("Testando alertas...");
  digitalWrite(LED_ALERTA, HIGH);
  digitalWrite(BUZZER, HIGH);
  delay(300);
  digitalWrite(BUZZER, LOW);
  digitalWrite(LED_ALERTA, LOW);
  Serial.println("Teste OK!");
}

Fase 3: Automação residencial avançada

Para esta fase, vamos integrar com o Home Assistant, uma plataforma open-source muito popular no Brasil.

Recursos da Fase 3:

• Integração via MQTT
• Dashboard personalizado
• Automações inteligentes
• Controle de válvulas automáticas
• Histórico de dados
• Sistema de backup

Exemplo de automação Home Assistant:

# automation.yaml
- alias: "Alerta Vazamento Água"
  trigger:
    platform: mqtt
    topic: "casa/sensores/agua"
    payload: "detectado"
  action:
    - service: notify.mobile_app
      data:
        message: "💧 Vazamento de água detectado!"
        title: "ALERTA DOMÉSTICO"
    - service: switch.turn_off
      entity_id: switch.valvula_agua_principal
    - service: camera.snapshot
      entity_id: camera.cozinha

Fase 4: Inteligência artificial embarcada

A IA embarcada é a fase mais avançada e requer conhecimentos de:

• Coleta e análise de dados
• Machine Learning básico
• TinyML (TensorFlow Lite para microcontroladores)

O que a IA pode fazer:

• Análise de padrões: Aprender consumo normal vs. anômalo
• Prevenção de falsos alarmes: Filtrar detecções baseadas em contexto
• Manutenção preditiva: Identificar degradação de componentes
• Otimização automática: Ajustar sensibilidade baseada no ambiente

Instalação e configuração final

Localização ideal dos sensores:

Dicas de instalação:

• Teste extensivamente antes da instalação definitiva
• Use caixas de proteção contra umidade
• Cabos organizados evitam acidentes
• Fonte de alimentação confiável com backup de bateria
• Acesso fácil para manutenção

Custos atualizados por fase

Manutenção e cuidados

Manutenção regular:

• Semanal: Teste dos alertas
• Mensal: Limpeza dos sensores
• Trimestral: Verificação das conexões
• Semestral: Inspeção profissional (para instalações com gás)

Sinais de que precisa manutenção:

• Alertas falsos frequentes
• Demora na detecção
• Problemas de conectividade
• Componentes corroídos

Conclusão

Criar um detector de vazamento é um projeto fascinante que combina eletrônica, programação e automação residencial. Começando pela Fase 1, qualquer pessoa pode construir um sistema funcional e útil. As fases avançadas oferecem possibilidades quase ilimitadas para quem quer se aprofundar.

Resumo dos níveis de dificuldade:

• Fase 1 (Básico): Iniciante - qualquer pessoa pode fazer
• Fase 2 (Wi-Fi): Iniciante/Intermediário - requer configuração de rede
• Fase 3 (Automação): Intermediário - conhecimento de sistemas de automação
• Fase 4 (IA): Avançado - requer conhecimentos de programação e ML

O mais importante é começar. Mesmo um sistema básico já oferece proteção valiosa para sua casa. Com o tempo e experiência, você pode evoluir para sistemas mais sofisticados.

Lembre-se sempre: segurança em primeiro lugar. Quando se trata de gás, não hesite em consultar profissionais qualificados. A tecnologia deve complementar, nunca substituir, as boas práticas de segurança residencial. Este sistema é um projeto educacional que deve ser usado apenas como complemento a sistemas de segurança certificados.