Controle Inteligente para Abastecimento de Caixa D’Água com Arduino Nano

Introdução

A automação residencial tem avançado significativamente nos últimos anos, permitindo o desenvolvimento de sistemas eficientes para otimizar o uso de recursos e melhorar o conforto do nosso dia a dia. Um dos problemas recorrentes em residências e indústrias é o controle do nível de água em reservatórios, especialmente caixas d’água e cisternas onde o abastecimento inadequado pode resultar em desperdício de água.

Neste artigo, vamos apresentamos um sistema inteligente de controle do abastecimento de caixa d’água utilizando um Arduino Nano, um sensor de fluxo YF-S201, um relé para controle da bomba de água, um display LCD I2C para exibição das informações e botões para ajustes manuais. O projeto visa garantir o abastecimento correto da caixa d’água, desligando a bomba automaticamente ao atingir o volume desejado.

O objetivo desse sistema é proporcionar um controle preciso do abastecimento, permitindo que o usuário tenha maior segurança no gerenciamento do seu consumo de água. Muitos sistemas tradicionais utilizam boias mecânicas para interromper o fluxo de água quando o reservatório está cheio, mas esses dispositivos podem apresentar falhas ao longo do tempo. Com a abordagem eletrônica baseada em sensores, conseguimos um controle mais confiável e adaptável às necessidades do usuário.

Princípio de Funcionamento

O sistema funciona monitorando o fluxo de água por meio do sensor de fluxo YF-S201, que gera pulsos elétricos proporcionais à quantidade de água que passa pelo cano. O Arduino Nano interpreta esses pulsos e calcula a vazão instantânea e o volume total que passou pelo sensor.

O sensor de fluxo é um componente essencial neste projeto, pois permite medir com uma certa precisão a quantidade de água que passa pelo encanamento. Ele contém uma pequena hélice interna que gira conforme a água flui. Esse movimento gera pulsos elétricos que são lidos pelo Arduino, convertidos para litros por minuto e acumulados ao longo do tempo para determinar o volume total de água, para saber mais sobre esse sensor, veja o nosso artigo: Guia Prático do Sensor de Fluxo de Água.

O usuário pode definir o volume desejado através dos botões de Aumentar e Diminuir e visualizar a quantidade de litros no display LCD. Uma vez que o volume programado for atingido, o Arduino desliga a bomba automaticamente por meio do relé, evitando transbordamentos ou desperdícios. Isso é especialmente útil para quem depende de abastecimento irregular de água, permitindo o uso eficiente sem riscos de desperdício.

Além disso, o display LCD I2C exibe em tempo real a vazão e o volume total abastecido, fornecendo uma interface amigável para o usuário. O LCD permite que o usuário visualize rapidamente as informações do sistema, como a vazão atual e a quantidade de água já adicionada ao reservatório. Com isso, o usuário pode acompanhar o funcionamento do sistema e fazer ajustes conforme necessário.

Etapas do funcionamento

1. Definição do Volume Desejado: O usuário ajusta o volume desejados de água nos botões.
2. Inicio do bombeamento: Após inserir o volume desejado o usuário pressiona botão de iniciar o bombeamento.
3. Monitoramento da Vazão: O sensor de fluxo mede a quantidade de água passando pelo tubo.
4. Cálculo do Volume: O Arduino soma os pulsos gerados pelo sensor e converte para litros bombeados.
5. Exibição de Dados: No display LCD é exibido a vazão instantânea e o volume total bombeados.
6. Desligamento Automático: Ao atingir o volume configurado pelo usuário, o Arduino desliga a bomba via relé.
7. Reinício do Sistema: O sistema pode ser reiniciado manualmente para iniciar um novo ciclo de abastecimento.

A principal vantagem desse sistema é a precisão no controle do bombeamento de água, reduzindo desperdícios e prevenindo danos causados por transbordamento. Diferente de sistemas convencionais, que dependem de sensores de nível simples ou boias mecânicas, este sistema permite que o usuário defina exatamente quantos litros deseja adicionar à caixa d’água.

Materiais Necessários

Para este projeto, você precisará dos seguintes componentes:

• 1x Arduino Nano V3.0 + Cabo Usb para Arduino 
• 1x Sensor de Fluxo de Água de 1/2″ – YF-S201
• 1x Display LCD 16×2 com Backlight Azul
• 1x Módulo Serial I2C para Display LCD
• 1x Módulo Relé 1 Canal 5v
• 3x Resistor 10K 1/4W
• 3x Push Button (Chave Táctil) 12x12x4,3mm
• 2x Protoboard 830 Pontos ou Protoboard 1660 Pontos com Base Metálica
• 1x Fonte 5V 1A Bivolt ou Fonte 5v com cabo Micro USB
• Jumpers

Montagem do Circuito e Esquemático

A montagem do circuito deve seguir os seguintes passos:

1. Conecte o sensor de fluxo: O fio vermelho vai para 5V do Arduino, o preto para GND do Arduino e o amarelo para o pino D3 do Arduino (Veja mais sobre Display LCD e interface I2C nesse artigo Guia Prático do Sensor de Fluxo de Água.).
2. Conecte o módulo relé: O pino de controle vai para o pino digital D5 do Arduino, o VCC para 5V e o GND para GND.
3. Conecte o display LCD: Utilize a interface I2C, conectando SDA ao A4 e SCL ao A5 do Arduino (Veja mais sobre Display LCD e interface I2C nesse artigo Guia Completo do Display LCD – Arduino).
4. Conecte os botões push-button: Um lado dos botões no GND do Arduino e o outro no pino D2 para o botão de diminuir a quantidade de água, pino D6 para o botão de aumentar a quantidade de água e pino D9 para o botão de iniciar o sistema, com resistores de 10kΩ como pull-up para 5V (Caso não saiba o que é pull-up veja esse artigo no nosso blog Entendendo os Resistores de Pull-Up e Pull-Down).
5. Alimente o sistema: O Arduino pode ser alimentado por 5V via USB, e a bomba de água requer uma fonte externa conectada ao relé para acionar ou desligar a bomba.

A escolha do Arduino Nano foi feita por sua versatilidade e tamanho compacto, permitindo que o sistema seja instalado em pequenos painéis elétricos ou caixas de controle. Além disso, o uso do protocolo I2C para o display reduz a quantidade de fios necessários, facilitando a montagem do circuito. Outra vantagem desse projeto é a possibilidade de adaptação para diferentes tipos de bombas d’água. Caso o usuário tenha uma bomba de maior potência, pode-se utilizar um relé de estado sólido ou um contato auxiliar para suportar cargas elétricas mais altas. Essa flexibilidade torna o sistema aplicável tanto para uso doméstico quanto para aplicações industriais de pequeno porte.

Código

/**
 * @file Controle_de_abastecimento_da_Caixa_da_agua.ino
 * @author Saulo Aislan (aislansaulo@gmail.com)
 * @brief Firmware para o o controle e monitoramento do abastecimento de uma caixa de água
 *        com sensor de fluxo, display LCD e Relé.
 * @version 0.1
 * @date 2025-02-10
 *
 * @copyright Copyright (c) 2025
 *
 */

#include <Arduino.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h> 

// Definições de pinos
const float SENSOR_FLUXO_PIN = 3;   // Pino do sensor de fluxo/vazão
const float RELE_BOMBA_PIN = 5;     // Pino do relé da bomba
const float BOTAO_AUMENTAR_PIN = 6; // Botão para aumentar a quantidade
const float BOTAO_DIMINUIR_PIN = 2; // Botão para diminuir a quantidade
const float BOTAO_INICIAR_PIN = 9;  // Botão para iniciar o fluxo/vazão

const float LIMITE_MAXIMO_LITROS = 1000;  // Limite máximo de litros
const float LIMITE_MINIMO_LITROS = 10;    // Limite mínimo de litros
const float INCREMENTO_LITROS = 10;       // Incremento/decremento em litros
const float FATOR_MULTIPLICADOR_BOTAO = 10; // Fator multiplicador para o Incremento/decremento dos botões
// definicao do fator de calibracao para conversao do valor lido
const float FATOR_CALIBRACAO = 4.5;

// Variáveis globais
volatile int pulsos = 0;       // Contador de pulsos do sensor de fluxo/vazão
float litros_desejados = 0;    // Quantidade inicial desejada (em litros)
int incremento_litros = INCREMENTO_LITROS;    // Incremento/decremento em litros

//definicao das variaveis de fluxo/vazão e volume
float vazao = 0;        // variavel para armazenar o valor da vazao
float volume = 0;       // variavel para armazenar o valor de volume
float volume_total = 0; // Quantidade de água medida pelo sensor de fluxo/vazão

//definicao da variavel de intervalo de tempo
unsigned long tempo_antes = 0;

// Debounce dos botões
unsigned long debounce_delay = 200;
unsigned long ultimo_tempo_botao = 0;

LiquidCrystal_I2C lcd(0x3F, 16, 2);

// Protótipos de funções
void iniciarAbastecimento(void);

// Função de interrupção para contar pulsos
void contadorPulsos(void) {
  pulsos++;
}

/**
 * @brief Setup do Arduino, inicializa as configurações iniciais
 * 
 */
void setup() {
  // Configuração dos pinos
  pinMode(SENSOR_FLUXO_PIN, INPUT);
  pinMode(RELE_BOMBA_PIN, OUTPUT);
  pinMode(BOTAO_AUMENTAR_PIN, INPUT_PULLUP);
  pinMode(BOTAO_DIMINUIR_PIN, INPUT_PULLUP);
  pinMode(BOTAO_INICIAR_PIN, INPUT_PULLUP);

  // Inicialização
  digitalWrite(RELE_BOMBA_PIN, LOW);

  // Configuração da interrupção do sensor de fluxo/vazão
  attachInterrupt(digitalPinToInterrupt(SENSOR_FLUXO_PIN), contadorPulsos, FALLING);

  // Inicializa a comunicação serial
  Serial.begin(115200);

  // Inicializa o display LCD
  lcd.init(); 
  lcd.backlight();
  lcd.setCursor(0, 0);        // selecionando coluna 0 e linha 0
  lcd.print("Controle de");   // print da mensagem
  lcd.setCursor(0, 1);        // selecionando coluna 0 e linha 0
  lcd.print("Abastecimento!");// print da mensagem

  Serial.print("Controle de abastecimento de Caixa d’Água");
}

/**
 * @brief Loop principal do Arduino, onde é feito
 * o controle do abastecimento atraves dos botões
 * 
 */
void loop() {
  // Leitura e ajuste da quantidade desejada
  if (digitalRead(BOTAO_AUMENTAR_PIN) == LOW && millis() - ultimo_tempo_botao > debounce_delay) {
    litros_desejados += incremento_litros; // Incrementa em litros inteiros
    litros_desejados = constrain(litros_desejados, LIMITE_MINIMO_LITROS, LIMITE_MAXIMO_LITROS); // Limita entre 1 e 10 litros
    ultimo_tempo_botao = millis();

    lcd.clear();                       // limpa a tela
    lcd.setCursor(0, 0);               // selecionando coluna 0 e linha 0
    lcd.print("Litros desejados: ");   // print da mensagem
    lcd.setCursor(2, 1);               // selecionando coluna 2 e linha 1
    lcd.print(litros_desejados);       // Print da mensagem

    Serial.print("Litros desejados: ");
    Serial.println(litros_desejados);
  }

  if (digitalRead(BOTAO_DIMINUIR_PIN) == LOW && millis() - ultimo_tempo_botao > debounce_delay) {
    litros_desejados -= incremento_litros; // Decrementa em litros inteiros
    litros_desejados = constrain(litros_desejados, LIMITE_MINIMO_LITROS, LIMITE_MAXIMO_LITROS); // Limita entre 1 e 10 litros
    ultimo_tempo_botao = millis();

    lcd.clear(); 
    lcd.setCursor(0, 0);               // selecionando coluna 0 e linha 0
    lcd.print("Litros desejados: ");   // print da mensagem
    lcd.setCursor(2, 1);               // selecionando coluna 2 e linha 1
    lcd.print(litros_desejados);       // Print da mensagem

    Serial.print("Litros desejados: ");
    Serial.println(litros_desejados);
  }

  // Inicia o Abastecimento de água ao pressionar o botão iniciar
  if (digitalRead(BOTAO_INICIAR_PIN) == LOW && litros_desejados > 0) {
    iniciarAbastecimento();
  }
}

/**
 * @brief Função para iniciar o abastecimento de
 * água e controlar a vazão e a bomba de água
 * 
 */
void iniciarAbastecimento() {
  pulsos = 0;
  volume_total = 0;

  // Ativa a bomba
  digitalWrite(RELE_BOMBA_PIN, HIGH);

  Serial.println("Iniciando Abastecimento...");

  // Aguarda até atingir a quantidade desejada
  while (volume_total < litros_desejados) {
    // Verifica se o sensor de fluxo/vazão está funcionando
    if (pulsos == 0) {
      continue;
    } 
    
    //Executa a contagem de pulsos uma vez por segundo
    if((millis() - tempo_antes) > 1000){

      //conversao do valor de pulsos para L/min
      vazao = ((1000.0 / (millis() - tempo_antes)) * pulsos) / FATOR_CALIBRACAO;

      //Exibe na serial
      Serial.print("Vazao de: ");
      Serial.print(vazao);
      Serial.println(" L/min");

      //calculo do volume em litros passado pelo sensor
      volume = vazao / 60; // Conversão de L/min para L/s
      volume_total += FATOR_MULTIPLICADOR_BOTAO * volume;  //armazenamento do volume total passado pelo sensor

      //Exibe na serial
      Serial.print("Volume: ");
      Serial.print(volume_total);
      Serial.println(" L");
      Serial.println();
    
      lcd.clear();               // limpa a tela
      lcd.setCursor(0, 0);       // selecionando coluna 0 e linha 0
      lcd.print("Vazao: ");      // print da mensagem
      lcd.print(vazao, 1);       // print o valor da vazão
      lcd.print(" L/min");       // print da mensagem
      lcd.setCursor(0, 1);       // selecionando coluna 2 e linha 1
      lcd.print("Vol.Total: ");  // print da mensagem
      lcd.print(volume_total, 1);// Print o volume total
      lcd.print(" L");           // print da mensagem

      // Reinicialização do contador de pulsos
      pulsos = 0;

      // Atualização da variavel tempo_antes
      tempo_antes = millis();
      }

    if (volume_total >= litros_desejados) {
      break;
    }
  }

  // Desliga a bomba
  digitalWrite(RELE_BOMBA_PIN, LOW);

  lcd.clear();
  lcd.setCursor(0, 0);                     // selecionando coluna 0 e linha 0
  lcd.print("Abastecimento");              // print da mensagem
  lcd.setCursor(0, 1);                     // selecionando coluna 0 e linha 1
  lcd.print("Concluido!");                 // print da mensagem
  Serial.println("Abastecimento concluído!");
}

Resultado e Demonstração

Possíveis Melhorias, Expansões e cuidados

Esse projeto pode ser aprimorado com algumas funcionalidades adicionais, como também melhorados no quesito de segurança. Algumas sugestões incluem:

• Calibração do sensor de fluxo/vazão: É necessário a calibração do sensor em qualquer aplicação desse projeto.
• Conexão com Wi-Fi ou LoRa: Permitiria que o usuário monitorasse o sistema remotamente via smartphone ou computador.
• Histórico de Consumo de Água: Armazenando dados sobre os ciclos de abastecimento, o usuário poderia acompanhar seu consumo ao longo do tempo.
• Integração com Assistentes Virtuais: Conectando o sistema a plataformas como Alexa ou Google Assistant, o usuário poderia ativar o abastecimento por comando de voz.
• Sensores de Nível Adicionais: A inclusão de sensores ultrassônicos ou boias digitais poderia atuar como redundância para maior confiabilidade.
• Implementação de medidas de segurança: Adição de proteção contra sobrecarga na bomba d’água, fusíveis de proteção no circuito e um sistema de alarme sonoro para indicar falhas no sensor de fluxo ou na bomba.
• Botão de emergência: Inclusão de um botão físico que permita o desligamento manual da bomba em caso de emergência.
• Monitoramento de tensão e corrente da bomba: Para evitar danos e prever falhas antes que elas ocorram.

Com essas melhorias, o projeto poderia se tornar um sistema completo de gerenciamento de água para residências e pequenas empresas, oferecendo um controle mais preciso do consumo e permitindo economia de recursos hídricos e elétricos.

Conclusão

Este projeto demonstra como é possível criar um sistema de controle de abastecimento de caixa d’água eficiente e de baixo custo utilizando Arduino. Com essa solução, evitamos desperdícios e aumentamos a eficiência do abastecimento de água. Com o avanço da Internet das Coisas (IoT), soluções como essa podem ser cada vez mais aplicadas em diferentes contextos, contribuindo para o uso inteligente da água. Esse tipo de automação não apenas traz comodidade, mas também desempenha um papel importante na preservação dos recursos naturais. Existem várias outras aplicações que necessitam de um sistema de controle, qual projeto vem na sua mente? Conte-nos na caixa de comentários.

Para mais materiais como esse, continue acompanhando as postagens semanais do blog e não deixe de visitar nossa loja. Lá você encontra todos os componentes necessários para desenvolver esse e muitos outros projetos!

Que a força esteja com você!

NÃO ENTREM EM PÂNICO!

Até mais!

Saulo Aislan

Saulo Aislan Graduando em Tecnologia em Telemática pelo IFPB – Campus de Campina Grande – PB. Tenho experiência com os microcontroladores da família Arduino, ESP8266, ESP32, STM32 e microprocessador Raspberry Pi. Tenho projetos na áreas de IoTs voltada para a indústria 4.0, agroindústria e indústria aeroespacial civil utilizando LoRa, Bluetooth, ZigBee e Wi-Fi. Atualmente estudando e desenvolvendo em FreeRTOS para sistemas em tempo real com ESP32 e LoRaWan para Smart City e compartilhando alguns projetos no blog da Eletrogate.