Sistema Inteligente de Detecção de Vazamento de Água e Controle de Válvula

Componentes e Materiais

Componente	Quantidade
Caixa de alumínio	1
Arduino UNO	1
Arduino Ethernet Shield 2	1
Fonte de alimentação	1
Caixa AC	1
Kit de LEDs com resistores	1
Relés (1 duplo 5V e 1 duplo 12V)	1
Válvula motorizada	1
Conectores JST	1
Sensor de água	1

Sobre o Projeto

Visão Geral

Durante uma conversa com um amigo, percebi que vazamentos de água são um grande problema. Meu amigo teve que substituir todos os móveis do porão porque um cano estourou enquanto ele estava no trabalho.

Este projeto é semelhante ao que publiquei para o concurso Microsoft IoT, mas este é baseado em Arduino, não em Raspberry Pi. Minha abordagem é: em vez de centralizar muitas responsabilidades em uma plataforma grande (como RasPi, DragonBoard ou PC), prefiro delegar responsabilidades simples a dispositivos simples (como Arduino e outros). Eles farão o que devem fazer e, opcionalmente, conectar-se-ão pela rede a outros dispositivos (simples ou complexos) para oferecer serviços avançados. Em caso de falha na rede, eles continuam a fazer o que devem fazer.

Basicamente, o sistema monitora vazamentos de água e aciona ações como fechar a entrada principal de água, dependendo da falha detectada.

Também publica mensagens em um Broker MQTT. A ideia é que o dispositivo gerencie a água localmente, mas também participe, junto com outros dispositivos, de um sistema maior que gerencia a automação residencial.

Como Fica a Instalação

A entrada principal de água está localizada na parte inferior. O primeiro dispositivo é instalado pelos serviços de abastecimento de água da cidade para controlar a pressão da água. Instalei a parte superior da imagem. A válvula motorizada (em azul) é instalada em paralelo com uma válvula manual. Neste desenho, a válvula manual está aberta e a válvula motorizada é, portanto, bypassada. É útil em caso de queda de energia. No modo normal, a válvula manual deve ser fechada.

Há um motor DC (12V) dentro da válvula que gira no sentido horário ou anti-horário dependendo da polaridade. Há um loop de feedback que indica se a válvula está efetivamente Aberta ou Fechada. Para abri-la, basta aplicar tensão positiva na conexão superior esquerda.

O Controlador

Da esquerda para a direita: o plugue AC, um botão de reset, alguns LEDs para exibir status, conectores (para sensores, para motor), uma interface Ethernet e uma USB.

• LED1 (Vermelho): Aceso fixo = água detectada localmente; Piscando = água detectada remotamente; Apagado = sem vazamento
• LED2 (Amarelo): Aceso fixo = incapaz de controlar válvula motorizada; Piscando = incapaz de alcançar broker MQTT; Apagado = tudo OK
• LED3 (Azul): Aceso fixo = tudo OK; Piscando = válvula motorizada fechada; Apagado = sistema desligado ou sem energia

Sensor localizado onde acho que a água poderia vazar.

O que há por dentro do controlador.

⚠️ AVISO IMPORTANTE!

A fonte AC/DC que estou usando tem duas saídas: a primeira é 12V DC e alimenta a válvula motorizada (controlada por dois relés que controlam a rotação do motor) e a segunda é EXATAMENTE 5V DC, para alimentar o Arduino. Por isso estou alimentando diretamente no circuito de 5V, não no Vin que requer pelo menos 6V DC. Uma vez conectada a fonte AC/DC, você deve NUNCA (digo NUNCA) conectar nem o conector DC do Arduino nem o cabo USB do Arduino. Se ainda quiser depurar via USB, faça um cabo caseiro SEM as linhas de energia, mantenha apenas as linhas de dados. Aliás, a ligação entre a caixa AC e a fonte AC/DC é 110V. Não toque, nunca!

Código

Detecção de vazamento de água e controle de válvula motorizada (Arduino)

#include <PubSubClient.h> 
#include <Network.h> 
#include <Timer.h> 
#include <SPI.h> 
#include <Ethernet.h> 
#include <Dns.h> 
#include <avr/wdt.h> 

/* Funcionamento do Hardware:
- Caixa principal: Arduino Uno com Ethernet Shield
- LED vermelho: fixo = água local, piscando = água remota, apagado = sem vazamento
- LED amarelo: fixo = válvula com defeito, piscando = broker MQTT inalcançável, apagado = OK
- LED azul: fixo = válvula aberta e monitorando, piscando = válvula fechada, apagado = sistema down
- Botão: ao pressionar, inicia auto-teste
- Relé duplo para controlar válvula motorizada remota
- Outro relé duplo para detectar fim de curso da válvula
- Conjunto de detectores de água (todos em paralelo)

Conexões da válvula motorizada:
- Amarelo e Azul: DC para motor
- Preto: entrada fim de curso (GND no nosso circuito)
- Vermelho: vira GND quando válvula fecha totalmente
- Verde: vira GND quando válvula abre totalmente
*/

// Configuração de Rede
byte mac[] = { 0xDE, 0xAD, 0xBE, 0xCF, 0xFC, 0xEE };
IPAddress ip(192, 168, 12, 215);
IPAddress server(192, 168, 12, 130);
EthernetClient ethClient;
PubSubClient client(ethClient);

#define mqttClientPrefix "GLX"
#define mqttClientLocation "BASEMENT"
#define mqttClientUID "001"
#define mqttClientStatusTopic "Status"
#define mqttClientFaultTopic "Fault"
const int mqttInterval = 20;
int mqttIntervalCnt = 0;
int isConnectedToBroker = -1;

// Pinagem
const int SystemLedPin = A0;
const int FaultLedPin = A1;
const int AlarmLedPin = A2;
const int WaterDetectorPin = 2;
const int ToggleButtonPin = 3;
const int SdCardPin = 4;
const int ValveClosedPin = 5;
const int ValveOpenedPin = 6;
const int ValveControl1 = 8;
const int ValveControl2 = 7;

// Variáveis de estado
int isWaterDetected = 0;
int isWaterDetectedRemotely = 0;
int isValveClosed = -1;
const int valveTimeOut = 15;
int isConnectedToValve = -1;
volatile boolean isResetRequested = 0;
const int mainLoopDelay = 500;
void(* resetFunc) (void) = 0;

void setup() {
  wdt_disable();
  Serial.begin(9600);
  Serial.println(F("Início do setup"));
  
  // Configuração Hardware
  pinMode(SystemLedPin, OUTPUT);
  pinMode(FaultLedPin, OUTPUT);
  pinMode(AlarmLedPin, OUTPUT);
  pinMode(WaterDetectorPin, INPUT);
  pinMode(ToggleButtonPin, INPUT);
  pinMode(ValveOpenedPin, INPUT);
  pinMode(ValveClosedPin, INPUT);
  pinMode(ValveControl1, OUTPUT);
  digitalWrite(ValveControl1, HIGH);
  pinMode(ValveControl2, OUTPUT);
  digitalWrite(ValveControl2, HIGH);
  pinMode(SdCardPin, OUTPUT);
  digitalWrite(SdCardPin, HIGH);
  
  testLeds();
  
  // Rede e MQTT
  client.setServer(server, 1883);
  client.setCallback(MQTTBrokerCallback);
  Ethernet.begin(mac, ip);
  Serial.print(F("IP atual: "));
  Serial.print(Ethernet.localIP());
  Serial.print(F(" - IP Broker MQTT: "));
  Serial.println(server);
  
  // Abre válvula inicialmente
  if (openValve() == 0) {
    Serial.println(F("Válvula aberta e sistema monitorando"));
    subscribeToRemoteWaterSensors();
  } else {
    Serial.println(F("Não foi possível abrir válvula. Use bypass de encanamento"));
  }
  
  enableInterruptOnResetButton();
  delay(1500);
  Serial.println(F("Fim do setup"));
}

void loop() {
  configureLedsWithInitialStates();
  
  // Reset solicitado
  if (isResetRequested == 1) {
    Serial.println(F("Botão pressionado para reset"));
    publishStatus();
    wdt_enable(WDTO_1S);
    delay(5000);
    Serial.println(F("Esta mensagem nunca deve aparecer"));
  }
  
  // Verifica vazamento
  readLocalWaterSensor();
  if (isWaterDetected == 1 || isWaterDetectedRemotely == 1) {
    if (isValveClosed == 0) closeValve();
  }
  
  // Publica no MQTT
  if (mqttIntervalCnt == 0) {
    if (isWaterDetected == 1) publishFault();
    publishStatus();
    mqttIntervalCnt = mqttInterval;
  } else {
    if (isConnectedToValve == 0) {
      Serial.println(F("Sistema fora de ordem - não controla válvula"));
    } else {
      Serial.print(F("."));
    }
    mqttIntervalCnt--;
  }
  
  delay(mainLoopDelay / 2);
  client.loop();
  configureLedsWithFinalStates();
  delay(mainLoopDelay / 2);
}

// Funções auxiliares (sensor, botão, válvula, relés, debounce, LEDs, MQTT)
// ... (código completo mantido para referência técnica)

Biblioteca MQTT (C/C++)

Disponível para download no repositório do projeto.

Esquemáticos