Monitore o volume na sua caixa d'água

Monitore o volume na sua caixa d’água 5

No artigo de hoje você vai aprender um projeto que permite que monitore o volume na sua caixa d’água (ou outro reservatório) pela internet de maneira simples e com baixo custo utilizando um ESP8266 NodeMCU e um sensor ultrassônico. Esse projeto pode te servir integralmente ou como ponta pé inicial para realizar outros projetos IoT (Internet of Things – Internet das Coisas). 

Projeto Monitore o volume da sua caixa d'água completo

Esse projeto visa monitorar qualquer reservatório que possua até 4 metros de profundidade de água de maneira não invasiva, ou seja, sem contato com o líquido. Pode muito bem ser aplicado em sua residência com finalidade de administrar o recurso natural, evitando assim um desabastecimento inesperado.

Material necessário

Para reproduzir o projeto, você precisará de:

Circuito para monitorar o volume da caixa d’água

Abaixo está o circuito eletrônico do projeto para monitorar o volume da caixa d’água:

Esquemático do projeto Monitore o volume da sua caixa d'água

A ideia é que o ESP8266 NodeMCU faça a leitura do sensor ultrassônico HC-SR04 que deve ser instalado na tampa da caixa d’água. A utilização do conversor bidirecional é necessária pois o ESP8266 contido no NodeMCU trabalha com 3,3 Vcc como nível alto, enquanto o sensor ultrassônico trabalho com 5 Vcc em seus terminais Trig e Echo.

Dúvidas sobre o funcionamento do sensor ultrassônico? Aprenda a conectá-lo e saiba mais.

Existem dois capacitores de desacoplamento com o valor de 100nF para auxiliar na estabilização da tensão 3,3V e 5V nas pontas da protoboard. 

Cuidado! Cada linha de alimentação positiva da protoboard contém um nível de tensão diferente, não misture.

Desenvolvimento do projeto para monitorar o volume da caixa d’água

Com esse trabalho conseguiremos medir volumes em reservatórios de qualquer formato geométrico tridimensional, mas para ter exatidão, é necessário inserir dentro do código de programação a matemática necessária para resolver a equação tendo somente uma variável, a profundidade (que será a altura). As formas geométricas mais comuns para as caixas d’água são o cubo, o paralelepípedo e o cilindro. 

Além de monitorar em tempo real, também conseguiremos ver seu nível ao longo do tempo, podendo ver a última hora ou até os últimos 30 dias. Incrível!

Para fins didáticos e testes de funcionamento, nosso projeto será instalado em uma vasilha plástica simulando a caixa d’água. O valor lido será entre 0 e 1000 mL, mas lembrando: não estamos limitados a isso, a ideia é escalável e pode ser aplicada em reservatórios que possuam até 4 metros de profundidade.

Projeto Monitore o volume da sua caixa d'água montado

Utilizaremos a plataforma de IoT da empresa Adafruit, a Adafruit IO. A grande maioria aqui já conhece a empresa internacional que atua na área de embarcados e eletrônica. Ela fabrica diversos hardwares e bibliotecas facilitando a integração dos seus produtos com o desenvolvimento dos projetos. 

Entenda mais sobre a AdafruitIO e os recursos disponíveis.

Preparando a plataforma Adafruit IO

Para ter acesso à plataforma, será necessário criar uma conta da Adafruit de maneira gratuita. 

Efetue o cadastro no link https://io.adafruit.com/ e caso já possua conta, é só logar.

Ao logar, será levado à área de Dashboards da sua conta.

Inicialmente deve estar em branco. No meu caso, possui três arquivos. Iremos criar um dashboard do zero.

Vá em “Actions” e depois em “Create a new Dashboard”. Dê um nome a ela e faça um breve resumo da sua funcionalidade. Eu irei nomeá-la como “Monitore o volume da sua caixa d’água”. Note que aparecerá seu primeiro item. No meu caso, existem outros projetos que já fiz, porém um novo foi criado com o nome que dei.

Antes de iniciarmos a montagem dos objetos da dashboard, devemos criar um feed. Feed equivale a um endereço onde a informação será publicada.

Vá em “Feeds” e depois em “view all”. Clique em “Actions” e depois em “Create a New Feed”. Dê um nome e descreva seu funcionamento. Nomearei como “volume”. Pronto, feed criado.

Agora em “Dashboards” e depois em “view all”, clique e abra a dashboard que você criou.

Note que a tela está sem informações. Agora criaremos dois objetos. Clique no símbolo de mais “Add a new block”. Você verá a lista dos possíveis widgets disponíveis até o momento:

Para este projeto utilizaremos dois widgets, o Gauge e o Line Chart. Clique no item superior direito, o Gauge. Ele é somente para leitura, então deve escolher o feed que deseja monitorar. No nosso caso o nome é “volume”.

Clique em “Next step”. Preencha as informações conforme solicitadas. Recomendo que as deixe iguais às minhas. Após funcionar, brinque e entenda o que cada item trará de resultado para sua dashboard.

Gauge para o projeto Monitore o volume da sua caixa d'água

Clique em “Create block” no canto inferior direito da sua tela. Pronto, nosso primeiro widget está criado.

Estando na dashboard, clique novamente no símbolo de mais “Add a new block”

Abaixo do Gauge está o “Line Chart”. Clique nele. Selecione novamente o feed que criou, no meu caso “volume”.

Line Chart para Monitore o volume da sua caixa d'água

Preencha as informações conforme solicitadas. Novamente recomendo que deixe iguais às minhas. Agora é só ajustar o layout da dashboard e a parte de configuração dela está prontinha!

Dashboard Monitore o volume da sua caixa d'água quase pronta

Código

Boa parte do código de programação para esse projeto é necessária para a conexão com a internet através do NodeMCU e para integrar à dashboard AdafruitIO. Algumas particularidades explicarei agora:

Vale ressaltar que as bibliotecas possuem versões. Para garantir que a reprodução do seu projeto seja bem sucedida, em Gerenciador de Biblioteca, instale a biblioteca Adafruit MQTT Library versão 1.0.3.

Se tiver dúvidas em como programar a ESP8266 NodeMCU pela IDE do Arduino, acesse nosso artigo sobre!

Recomendo que seja instalada a versão 2.3.0, é a mesma que utilizei durante os testes.

/* Programa para Artigo FilipeFlop:
 * Monitor o volume na sua caixa d'água
 * Autor: Eduardo Castro
 * Biblioteca da Placa: "esp8266 by ESP8266 Community versão 2.3.0"
 * Placa: "NodeMCU 1.0 (ESP-12E Module)"
 * Upload Speed: "115200"
 * CPU Frequency: "160MHz"
*/
//=====================================================================
// --- Inclusão de bibliotecas ---
#include <ESP8266WiFi.h> 
#include "Adafruit_MQTT.h"
#include "Adafruit_MQTT_Client.h"
// ======================================================================
// --- Dados de Acesso do seu roteador ---
#define WLAN_SSID       "NomedaSuaRede" // Informação da SSID do seu roteador
#define WLAN_PASS       "SenhadaSuaRede"   // senha de acesso do seu roteador
// ======================================================================
// --- Dados de Acesso da Plataforma Adafruit IO ---
#define AIO_SERVER      "io.adafruit.com"     // manter fixo
#define AIO_SERVERPORT  1883                  // manter fixo
#define AIO_USERNAME    "SuaInfoAIOUSERNAME"        // sua informação
#define AIO_KEY         "SuaInfoAIO_KEY" // sua informação
// ======================================================================
// --- Mapeamento de Hardware ---
#define trigPin 5  //D1 - PINO DE TRIGGER PARA SENSOR ULTRASSONICO
#define echoPin 4  //D2 - PINO DE ECHO PARA SENSOR ULTRASSONICO

WiFiClient client; // cria uma classe WiFiClient com o ESP8266 para conexão com o servidor MQTT

// Configura a classe MQTT passando para o WiFi cliente e Servidor MQTT os detalhes do login
Adafruit_MQTT_Client mqtt(&client, AIO_SERVER, AIO_SERVERPORT, AIO_USERNAME, AIO_KEY);

// O endereçamento para enviar os arquivos seguem o formato: <username>/feeds/<feedname>
Adafruit_MQTT_Publish volume = Adafruit_MQTT_Publish(&mqtt, AIO_USERNAME "/feeds/volume");

// ======================================================================
// --- Variáveis Globais ---
long duracao = 0;
float distancia = 0;
int volumevar = 0;
// ======================================================================
// --- Void Setup ---
void setup() {
  
  Serial.begin(115200); // inicia comunicação serial com velocidade 115200

  Serial.println(F("Monitorar Volume Caixa D'água - Adafruit MQTT")); // escreve na serial
  
  // Conecta ao ponto de acesso WiFi
  Serial.println(); Serial.println();
  Serial.print("Conectando ao ");
  Serial.println(WLAN_SSID);

  WiFi.begin(WLAN_SSID, WLAN_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();

  Serial.println("WiFi Conectado");
  Serial.println("IP endereço: "); Serial.println(WiFi.localIP());
  
// ======================================================================
// --- Configuração IO ---
  pinMode(trigPin, OUTPUT); // pino D1 como saída para TRIGGER
  pinMode(echoPin, INPUT);  // pino D2 como entrada para ECHO
}
// ======================================================================
// --- void loop ---
void loop() {
  MQTT_connect();   // chama função para conexão com MQTT server
  
  digitalWrite(trigPin, LOW);    // Limpa trigPin
  delayMicroseconds(2);          // aguarda 2 microsegundos

  digitalWrite(trigPin, HIGH);   // Seta trigPin HIGH aguarda 
  delayMicroseconds(10);         // aguada 10 microsegundos
  digitalWrite(trigPin, LOW);    // Seta trigPin LOW 
  
  // Leitura do echoPin, retorna a onda de som em microsegundos
  duracao = pulseIn(echoPin, HIGH);
  distancia= duracao*0.034/2;
  distancia = distancia*10; // converter cm para mm

  if (distancia > 96){  // leitura mínima. Reservatório vazio
    distancia = 96;
  }
    if (distancia < 37){  // leitura máxima. Reservatório vazio
    distancia = 37;
  }
  volumevar = map(distancia, 37, 96, 1000, 0); 
  /* Remapeia o range de leitura
   * Ao invés de ler de 37 a 96, lerá de 1000 a 0*/

  Serial.print("distancia:"); // imprime "distancia:"
  Serial.println(distancia);  // imprime a variavel distancia
  Serial.print("volume:");    // imprime "volume:"
  Serial.println(volumevar);  // imprime a variavel volume
  
  volume.publish(volumevar);     // publica variável "distância" em no feed "volume"
  // nossa saída será em mL
  
  delay(3000); // aguarda 3 segundos
  /* Observação: A plataforma Adafruit IO só permite 30 publicações/minuto
   * na conta gratuita. Então é importante não ultrapassar ou sua leitura 
   * na dashboard será instável e incorreta.*/
}

// ======================================================================
// --- Função para Conexão / Reconexão MQTT ---
  void MQTT_connect() {
    int8_t ret;
  
    // para de tentar reconexão quando consegue
    if (mqtt.connected()) {
      return;
    }
    Serial.print("Conectando ao MQTT... "); // imprime na serial
    // tenta conexão 5 vezes. Depois WatchDogTime!
    uint8_t retries = 5;
    while ((ret = mqtt.connect()) != 0) { // conectará quando retornar 0
      Serial.println(mqtt.connectErrorString(ret));
      Serial.println("Nova tentativa de conexão MQTT em 5 segundos...");
      mqtt.disconnect();
      delay(5000);  // aguarda 5 segundos
      retries--;
      if (retries == 0) { // trava e espera reset
        while (1);
      }
    }
    Serial.println("MQTT Conectado!"); // imprime na serial
  }
// ======================================================================
// --- FIM ---

Importante!

Note que no código existe a necessidade de preencher quatro informações:

01 – O nome da sua rede;

02 – A senha da sua rede;

03 e 04 – Os dados de acesso da sua conta Adafruit IO. Essa pode ser visualizada na própria plataforma em “Adafruit IO Key” disponível no canto superior direito do site.

Com esse código você também conseguirá utilizar o monitor serial da IDE do Arduino para visualizar alguns status.

Lembre-se que o código está para ler entre 0 e 1000mL e considerando a distância no meu vasilhame plástico. Para dar certa sua reprodução, é necessário verificar a distância do seu vasilhame vazio e depois cheio. Considerar também que quanto mais líquido dentro, menor será a distância lida pelo sensor.

Após a transferência do código e seu NodeMCU conseguir acesso à internet, a dashboard será preenchida com as informações que o projeto enviará ao endereço do feed criado. Além de verificar o nível atual, também é possível ver o histórico desse nível com possibilidades que vão de 1 hora até 30 dias.

Para bom funcionamento e exatidão na informação, faça o cálculo da distância do volume de maneira correta. Utilize o monitor serial para saber quanto o sensor de fato está detectando.

Dashboard Monitore o volume da sua caixa d'água

Conclusão

O projeto foi montado em um protótipo de dimensões reduzidas com intuito de validação de funcionamento, mas é importante reforçar que o porte é você quem determina. A leitura ocorrerá em reservatórios com até 4 metros de profundidade.

A ideia é tão abrangente que além de permitir que você monitore o volume na sua caixa d’água de uma residência, ela pode também ser supervisório de diversos líquidos industriais que não emitam gases que possam prejudicar o sensor, ou até ajudar o agronegócio com monitoramento de grãos como milho, café, soja etc. 

Gostou do post “Monitore o volume na sua caixa d’água”? Deixe seu comentário. Realizou os ensaios dos projetos? Compartilhe a experiência. Sua participação é muito importante para o Universo Maker.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

5 Comentários

  1. Olá

    Como faço para transmitir o sinal de medição? E via internet?
    Tenho 10 tanques.

    1. Olá.
      Seguindo o tutorial deste post você conseguirá e enviar pela Internet as informações medidas pelo sensor ultrassônico.

      Eduardo de Castro Quintino
  2. Boa tarde. Estou usando uma placa ESP32.
    Apresenta o erro:
    call of overloaded ‘publish(int&)’ is ambiguous

    Tem como resolver?
    Desde já agradeço.
    Sérgio

    1. Olá Sérgio.
      Pode ser por conta de diferenças entre as bibliotecas do ESP8266 e do ESP32.

      Eduardo de Castro Quintino
  3. Boa tarde… Se suprimir a linha ele compila.

    Tem como resolver esse erro. No Inicio, troquei ESP8266 por wifi.h

    Veja erro:
    volume.publish(volumevar); // publica variável “distância” em no feed “volume”

    exit status 1
    call of overloaded ‘publish(int&)’ is ambiguous