Usando o Sensor de Fluxo de Água

Introdução

Em indústrias, reservatórios de água, tanques e caldeiras costumam ser controlados automaticamente por sensores de nível com o auxílio de válvulas. Entretanto, em algumas aplicações mais sofisticadas, é necessário manter um controle de fluxo de entrada constante e determinado, que é identificado por meio de sensor de fluxo. De modo geral, todos os sensores de fluxo possuem um funcionamento similar, portanto é simples aprender seu conceito e estudar possibilidades de aplicação.

Neste tutorial você vai aprender a realizar a leitura de fluxo de líquidos, e a desenvolver um simples projeto de controle de volume de reservatórios.

Lista de Materiais

Lista completa de produtos

comprar

BlackBoard UNO R3

R$99.90

Sensor de Fluxo de Água

R$29.90

Módulo Relé

R$9.90

Válvula Solenoide 1/2 x 1/2 - 220VAC 110VAC

R$65.00

Chave Momentânea (PushButton) - Pacote com 10 unidades

R$3.00

Resistor 10kΩ - Pacote com 10 unidades

R$0.75

Protoboard 400 Pontos

R$7.50

WorkPlate 400 - Preta

R$14.90

Jumpers Macho-Macho x40 Unidades

R$7.90

Jumper Premium 10cm Macho-Fêmea - 40 Unidades

R$9.00

Conceitos Teóricos

Funcionamento do Sensor de Fluxo

O sensor de fluxo possui em seu interior um sensor de efeito Hall preso à carcaça e um ímã em seu eixo. O ímã é posicionado de modo a ter o seu pólo sul e o seu pólo norte em pé, para que a cada volta o sensor de efeito Hall identifique a mudança do pólo sul para o pólo norte, e o retorno para o pólo sul. Essa rotação e variação de pólos é o que gera os pulsos na saída de sinal deste sensor.

construction — Exemplo de Construção de Sensor de Fluxo
Fonte: Engineers Garage

Projeto Leitura de Fluxo e Volume

Nesse primeiro projeto vamos fazer uma leitura simples do sensor, além de exibir o volume total de líquido que passou por ele.

Circuito

Para começar os estudos sobre o funcionamento deste sensor, monte o circuito abaixo.

Código

Para que possamos obter as primeiras leituras do sensor, copie e carregue o código a seguir para sua placa.

/*******************************************************************************
* Sensor de Fluxo D'Agua: Primeiros Passos (v1.0)
* 
* Codigo para medir o fluxo (em L/min) e o volume atraves do numero de pulsos
* dados pelo sensor.
* 
* Copyright 2020 RoboCore.
* Escrito por Giovanni de Castro (11/12/2019).
* Creditos: Arvind Sanjeev - DIYhacking
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

//definicao do pino do sensor e de interrupcao
const int INTERRUPCAO_SENSOR = 0; //interrupt = 0 equivale ao pino digital 2
const int PINO_SENSOR = 2;

//definicao da variavel de contagem de voltas
unsigned long contador = 0;

//definicao do fator de calibracao para conversao do valor lido
const float FATOR_CALIBRACAO = 4.5;

//definicao das variaveis de fluxo e volume
float fluxo = 0;
float volume = 0;
float volume_total = 0;

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

void setup(){

  //inicializacao do monitor serial
  Serial.begin(9600);

  //mensagem de inicializacao
  Serial.println("Medidor de Fluxo e Volume de Liquidos\n");

  //configuracao do pino do sensor como entrada em nivel logico alto
  pinMode(PINO_SENSOR, INPUT_PULLUP);
  
}

void loop() {

  //executa a contagem de pulsos uma vez por segundo
  if((millis() - tempo_antes) > 1000){

    //desabilita a interrupcao para realizar a conversao do valor de pulsos
    detachInterrupt(INTERRUPCAO_SENSOR);

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

    //exibicao do valor de fluxo
    Serial.print("Fluxo de: ");
    Serial.print(fluxo);
    Serial.println(" L/min");

    //calculo do volume em L passado pelo sensor
    volume = fluxo / 60;

    //armazenamento do volume
    volume_total += volume;

    //exibicao do valor de volume
    Serial.print("Volume: ");
    Serial.print(volume_total);
    Serial.println(" L");
    Serial.println();
   
    //reinicializacao do contador de pulsos
    contador = 0;

    //atualizacao da variavel tempo_antes
    tempo_antes = millis();

    //contagem de pulsos do sensor
    attachInterrupt(INTERRUPCAO_SENSOR, contador_pulso, FALLING);
    
  }
   
}

//funcao chamada pela interrupcao para contagem de pulsos
void contador_pulso() {
  
  contador++;
  
}

Entendendo o Código

Inicialmente declaramos o pino de interrupção (INTERRUPCAO_SENSOR) e o pino em que o sensor está conectado (PINO_SENSOR). Ambas as variáveis estão atreladas ao pino digital 2, porém para a conexão de interrupção, temos que declarar o seu valor como "0" para que a biblioteca da Arduino IDE associe corretamente a interrupção ao pino digital 2.

//definicao do pino do sensor e de interrupcao
const int INTERRUPCAO_SENSOR = 0; //interrupt = 0 equivale ao pino digital 2
const int PINO_SENSOR = 2;

Logo após essa definição de pinos, declaramos a variável contador, responsável por armazenar a contagem de pulsos do sensor. Em seguida definimos a variável que armazena o fator de calibração do sensor (FATOR_CALIBRACAO) sendo constante e igual a 4,5. Esta variável é utilizada para a conversão entre o fluxo (em "L/min") e a frequência da leitura (em "Hz"), e pode ser alterada para maior precisão, ou caso haja alguma divergência na leitura obtida. Fazemos o mesmo para as variáveis que receberão o valor de fluxo convertido (fluxo), e o valor de volume calculado (volume e volume_total). Por fim, a variável tempo_antes nos auxiliará a realizar a conversão de unidades e a realizar a leitura do sensor com intervalos de 1 segundo.

//definicao da variavel de contagem de voltas
unsigned long contador = 0;

//definicao do fator de calibracao para conversao do valor lido
const float FATOR_CALIBRACAO = 4.5;

//definicao das variaveis de fluxo e volume
float fluxo = 0;
float volume = 0;
float volume_total = 0;

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

Na configuração do código, abrimos o monitor serial com a velocidade de 9600 bps e configuramos o pino em que o sensor está conectado como uma entrada com o resistor de pull-up interno ativado, através do comando INPUT_PULLUP. Deste modo, podemos realizar as leituras digitais dos pulsos do sensor de efeito Hall, porém sem a necessidade de um resistor de pull-up externo.

//inicializacao do monitor serial
Serial.begin(9600);

//configuracao do pino do sensor como entrada em nivel logico alto
pinMode(PINO_SENSOR, INPUT_PULLUP);

Pulando brevemente o looping do código, temos ao fim a função contador_pulso(), que é responsável somente por incrementar em uma unidade a variável contador, e que será mencionada posteriormente neste tutorial.

//funcao chamada pela interrupcao para contagem de pulsos
void contador_pulso() {
  contador++;
}

No looping do código, iniciamos sua execução com a condição if((millis() - tempo_antes) > 1000), que garante que todos os comandos que estão dependendo dela só sejam executados com o intervalo de 1 segundo. Dentro desta condição, desabilitamos brevemente a interrupção do pino digital 2, através do comando detachInterrupt(INTERRUPCAO_SENSOR), para não interferir no cálculo das variáveis.

O cálculo do fluxo é feito através da fórmula a seguir.

O numerador da equação faz uma conversão de tempo em milissegundos para tempo em segundos para dividir a quantidade de pulsos contados. Esse produto é então dividido pelo fator de calibração, para chegar em valor em "L/min".

//executa a contagem de pulsos uma vez por segundo
if((millis() - tempo_antes) > 1000){

  //desabilita a interrupcao para realizar a conversao do valor de pulsos
  detachInterrupt(INTERRUPCAO_SENSOR);

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

Após determinar a vazão, calculamos, através deste dado em "L/min", o volume total passado pelo sensor, apenas dividindo o valor de fluxo obtido por 60 segundos. Por se tratar de um fluxo em litros por minuto, ao dividirmos esse valor por um minuto (60 segundos), obtemos um fluxo em litros por segundo ("L/s"). Deste modo, podemos saber o volume total passado pelo sensor no intervalo de 1 segundo entre as leituras. A variável volume, que é utilizada, em função do fluxo, para saber o volume de líquido passado na última medição (volume = fluxo / 60), é somada à variável volume_total através do comando volume_total += volume, armazenando, deste modo, o volume total passado pelo sensor.

//calculo do volume em L passado pelo sensor
volume = fluxo / 60;

//armazenamento do volume
volume_total += volume;

Após essa conversão e a exibição do volume total no monitor serial, zeramos a variável contador através do comando contador = 0, para que a leitura seja refeita. Em seguida atualizamos a contagem de tempo da variável tempo_antes através do comando tempo_antes = millis(). Esta variável é utilizada tanto para a condição de intervalo de 1 segundo, quanto para a conversão de valores em um valor de fluxo.

//reinicializacao do contador de pulsos
contador = 0;

//atualizacao da variavel tempo_antes
tempo_antes = millis();

Entretanto, nada disso seria possível se não fosse pela última função do looping. attachInterrupt(INTERRUPCAO_SENSOR, contador_pulso, FALLING) habilita a função de interrupção do microcontrolador no pino INTERRUPCAO_SENSOR, que configuramos para ser o pino digital 2. Então, a interrupção chamará a função contador_pulso() para cada borda de descida, configurada através de FALLING, obtida com os pulsos do sensor.

O Que Deve Acontecer

Ao executar o código e manter a passagem de líquidos (ou se você assoprar o bocal do sensor por alguns instantes), você verá a contagem de fluxo em "L/min" e o volume total que passou pelo sensor, como na imagem a seguir.

Projeto Controle de Volume

Neste projeto iremos adicionar uma lógica ao código anterior para que possamos acionar uma válvula solenóide quando o nível estiver abaixo do desejado, e então desligá-la após um determinado volume.

Circuito

Para este projeto, monte o circuito a seguir.

Atenção: tome muito cuidado ao realizar ligações elétricas com corrente alternada. Caso você não tenha conhecimento adequado para mexer na rede elétrica, peça auxílio a um profissional. A RoboCore não se responsabiliza por danos à rede elétrica e/ou à integridade física do praticante do experimento.

Note que conectamos a válvula solenóide diretamente à rede elétrica por meio do relé, porém é recomendado que você utilize algum método de proteção neste circuito para evitar picos de energia e prolongar a vida útil de seu relé. Existem diversos métodos de proteção para acionamento de cargas indutivas, por exemplo um filtro snubber, lembrando que ele deve ser devidamente dimensionado para sua melhor eficácia.

Código

Com o circuito montado corretamente, copie e carregue o código a seguir para a sua placa.

/*******************************************************************************
* Sensor de Fluxo D'Agua: Primeiros Passos (v1.0)
* 
* Codigo para medir o fluxo (em L/min) e o volume atraves do numero de pulsos
* dados pelo sensor. Um rele é mantido acionado enquanto o volume estiver abaixo
* do desejado e desligado quando alcancar um determinado volume. O volume 
* e zerado ao pressionar um botao, apenas para testes do sistema.
* 
* Copyright 2020 RoboCore.
* Escrito por Giovanni de Castro (11/12/2019).
* Creditos: Arvind Sanjeev - DIYhacking
* 
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version (<https://www.gnu.org/licenses/>).
*******************************************************************************/

//definicao do pino do sensor e de interrupcao
const int INTERRUPCAO_SENSOR = 0; //interrupt = 0 equivale ao pino digital 2
const int PINO_SENSOR = 2;

//definicao dos pinos conectados ao rele e ao botao
const int PINO_RELE = 7;
const int PINO_BOTAO = 8;

//definicao da variavel de contagem de voltas
unsigned long contador = 0;

//definicao do fator de calibracao para conversao do valor lido
const float fator_calibracao = 4.5;

//definicao das variaveis de fluxo e volume
float fluxo = 0;
float volume = 0;
float volume_total = 0;

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

void setup(){

  //inicializacao do monitor serial
  Serial.begin(9600);

  //mensagem de inicializacao
  Serial.println("Medidor de Fluxo e Volume de Liquidos\n");

  //configuracao do pino do sensor como entrada em nivel logico alto
  pinMode(PINO_SENSOR, INPUT_PULLUP);

  //configuracao do pino do rele como saida em nivel logico baixo
  pinMode(PINO_RELE, OUTPUT);
  digitalWrite(PINO_RELE, LOW);

  //configuracao do pino do botao como entrada
  pinMode(PINO_BOTAO, INPUT);
  
}

void loop() {

  //executa a contagem de pulsos uma vez por segundo
  if((millis() - tempo_antes) > 1000){

    //desabilita a interrupcao para realizar a conversao do valor de pulsos
    detachInterrupt(INTERRUPCAO_SENSOR);

    //conversao do valor de pulsos para L/min
    fluxo = ((1000.0 / (millis() - tempo_antes)) * contador) / fator_calibracao;

    //exibicao do valor de fluxo
    Serial.print("Fluxo de: ");
    Serial.print(fluxo);
    Serial.println(" L/min");

    //calculo do volume em L passado pelo sensor
    volume = fluxo / 60;

    //armazenamento do volume
    volume_total += volume;

    //exibicao do valor de volume
    Serial.print("Volume: ");
    Serial.print(volume_total);
    Serial.println(" L");
    Serial.println();

    //logica para o acionamento do rele
    if(volume_total < 10){
      digitalWrite(PINO_RELE, HIGH);
    } else {
      digitalWrite(PINO_RELE, LOW);
    }
   
    //reinicializacao do contador de pulsos
    contador = 0;
    
    //atualizacao da variavel tempo_antes
    tempo_antes = millis();

    //contagem de pulsos do sensor
    attachInterrupt(INTERRUPCAO_SENSOR, contador_pulso, FALLING);
    
  }

  //logica para zerar a variavel volume_total
  if(digitalRead(PINO_BOTAO) == HIGH){
    delay(30);
    if(digitalRead(PINO_BOTAO) == HIGH){
      volume_total = 0;
    }
  }
  
}

//funcao chamada pela interrupcao para contagem de pulsos
void contador_pulso() {
  
  contador++;
  
}

Entendendo o Código

De modo geral, o código para leitura do fluxo de líquidos é o mesmo, porém, inicialmente, adicionamos as variáveis PINO_RELE e PINO_BOTAO, que armazenam o pino em que o relé e o botão estão conectados, respectivamente. Na etapa de configuração do código, nós configuramos esses pinos de acordo com a necessidade do projeto, ou seja, o pino em que o relé está conectado é configurado como uma saída em nível lógico baixo, e o pino do botão é configurado como uma entrada.

//definicao dos pinos conectados ao rele e ao botao
const int PINO_RELE = 7;
const int PINO_BOTAO = 8;
        
//configuracao do pino do rele como saida em nivel logico baixo
pinMode(PINO_RELE, OUTPUT);
digitalWrite(PINO_RELE, LOW);

//configuracao do pino do botao como entrada
pinMode(PINO_BOTAO, INPUT);

Já entrando no looping do código, dentro da condição de intervalo de 1 segundo, adicionamos a condição if(volume_total < 10), para acionar a válvula caso o volume total passado pelo sensor seja inferior a 10 L. Caso o volume passado supere 10 L, a válvula é fechada.

//logica para o acionamento do rele
if(volume_total < 10){
  digitalWrite(PINO_RELE, HIGH);
} else {
  digitalWrite(PINO_RELE, LOW);
}

Além disso, para reiniciar a contagem de volume da sistema, utilizamos outra condição (if(digitalRead(PINO_BOTAO) == HIGH)), com um debounce, para, quando o botão for pressionado, zerar a variável volume_total e reiniciar o sistema.

//logica para zerar a variavel volume_total
if(digitalRead(PINO_BOTAO) == HIGH){
  delay(30);
  if(digitalRead(PINO_BOTAO) == HIGH){
    volume_total = 0;
  }
}

O Que Deve Acontecer

Ao iniciar a execução de código, o relé irá se manter acionado, já que o sensor não mediu nenhum volume passado. Então, ao identificar a passagem de um volume de 10 L, o relé será desativado, impedindo a passagem de líquidos pela válvula.

Resultado Final

Atenção: a condição de controle do acionamento do relé foi alterada para que o GIF tivesse um tamanho reduzido. Além disso, utilizamos um ventilador para que fosse mais vísivel o desacionamento do relé. Entretanto, caso você tenha seguido os passos deste tutorial cuidadosamente, a válvula solenoide irá ser fechada após 10 L passados pelo sensor.

Indo Além

Neste tutorial, para fins educacionais, utilizamos um botão para zerar o valor de volume lido, mas você pode implementar esse sistema e utilizar um Sensor de Nível de Água, que possui um funcionamento similar a um pushbutton, para zerar o volume de um tanque lido pelo sensor.

Além disso, com esse sensor, você pode fazer um monitoramento via aplicativo do consumo de água de sua residência, para que você não precise se deslocar até o relógio para isso.

Comentários

Para fazer comentários é necessário estar logado. Efetuar login.

Você ainda nao é cadastrado? Cadastre-se agora!

adson.torino
date

Enviado 2024-02-01 16:52:38

Dando uma olhada nos comentários aqui, eu tive muita duvida de como chegar no fator de conversão correto para o meu sensor, vocês podem elaborar mais sobre como chegar no valor ideal ?

carlos.oliveira
date

Enviado 2024-02-05 15:04:40
adson.torino

Olá! Você pode usar uma abordagem empírica, que consiste em pegar um volume de água "conhecido" e fazer ela passar pelo sensor, cronometrando o tempo e calculando os pulsos do sensor enquanto a água passa. Com o volume e o tempo é possível calcular o fluxo, após calcular o fluxo é possível relacionar com a quantidade de pulsos ou de frequência.

reginaldo.francisco
date

Enviado 2023-12-17 08:01:10

Olá! Desejo usar três válvulas solenoides ativadas apenas por um sensor de fluxo d’água. Minhas dúvidas são: seria possível? Em caso afirmativo, posso utilizar apenas uma blackboard? E a quantidade de relés?

Giovanni5

Enviado 2023-12-18 07:09:30
reginaldo.francisco

É possível, porém o uso de apenas uma BlackBoard e a quantidade de relés irá depender muito do seu projeto, circuito, e cargas que serão acionadas. Se apenas as três válvulas serão acionadas, a princípio apenas três relés são necessários (um para cada válvula), e uma única BlackBoard UNO seria suficiente para ler o sensor e realizar os acionamentos.

samuel812767
date

Enviado 2023-10-17 22:19:46

Olha eu usei esse código para facilitar minha vida, mas ele realmente não funciona. Eu sei que esse sensor o máximo dele é 6 l por minuto, e eu tenho uma bomba que ela tem uma vazão máxima de 2 l por minuto, na hora de realizar esse código tava dando 18 litros por minuto, muito distante do real

luan.ferreira
date

Enviado 2023-10-18 14:26:03
samuel812767

Olá! Neste caso, é recomendado alterar o fator de calibração do código, pois assim você deve obter leituras mais otimizadas.

glauciobaraquet
date

Enviado 2023-04-14 19:14:42

Entendi, mas  caso eu utilize um sensor de fluxo de água de 3/4" não seria só mudar o fator de calibração no projeto ?

luan.ferreira
date

Enviado 2023-04-17 08:05:41
glauciobaraquet

Olá! Como a princípio os sensores de fluxo possuem o mesmo sistema de funcionamento, talvez o código mostrado acima seja diretamente compatível. Porém, para ter um resultado mais preciso, você pode calcular um fator de calibração que mais se ajuste ao seu projeto.

glauciobaraquet
date

Enviado 2023-03-25 11:28:08

Esse circuito funciona para tubulação de 3/4" ?  Em caso afirmativo, tem os materiais para esse diâmetro ?

luan.ferreira
date

Enviado 2023-03-27 09:10:46
glauciobaraquet

O Sensor de Fluxo de Água ( https://www.robocore.net/sensor-robo/sensor-de-fluxo-de-agua ) usando neste tutorial, é diretamente compatível com tubo de ½.  Sendo assim, para usar uma tubulação maior, será necessário adaptar a conexão.

japgarrido
date

Enviado 2023-01-14 23:25:38

Eu posso usar esse mesmo esquema do circuito elétrico para ligação física dos componentes no Raspiberry Pi 3?
Eu vi em outros sites o pessoal usando resistores para conectar o cabo amarelo do sensor de fluxo ao GPIO do Raspiberry Pi 3, mas aqui está sendo ligado direto, sem qualquer resistor.

Giovanni5

Enviado 2023-01-16 07:58:20
japgarrido

Como este sensor possui tensão operacional na faixa entre 4,5V e 18V, e a Raspberry Pi opera em 3,3V, infelizmente eles não são diretamente compatíveis, e é necessário utilizar um conversor de nível lógico (https://www.robocore.net/regulador-de-tensao/conversor-de-nivel-logico - por exemplo), para compatibilizar o pino de sinal, já que a alimentação pode ser feita pela saída de 5V da placa. Neste tutorial não utilizamos um resistor ou conversor de nível lógico, pois a BlackBoard UNO opera em 5V, sendo diretamente compatível com o sensor.

gabrielresende756
date

Enviado 2022-07-15 17:18:04

Boa tarde, por acaso haveria a passibilidade de ligar o sensor a um tipo de arduino para sinalização, como Leds ?

luan.ferreira
date

Enviado 2022-07-18 11:57:04
gabrielresende756

Olá! Sim, é possível realizar essa aplicação. Inclusive você pode usar esse tutorial com referência para criar o seu projeto.

ehillesheim72
date

Enviado 2022-06-24 14:05:23

Boa Tarde, este código eu escrevo no programa do arduino  IDE ou ha outro Sw?

luan.ferreira
date

Enviado 2022-06-24 14:30:03
ehillesheim72

Olá! Geralmente os nossos tutoriais são voltados para a Arduino IDE, pois ela é a mais comumente usada, e a que recomendamos. Para este tutorial não é diferente, e você pode usar a Arduino IDE para carregar o código de exemplo para a sua placa.

CledsonBaldon
date

Enviado 2022-04-18 10:02:42

Interessante sinalizar na descrição do sensor a compatibilidade com o Board principal do processador. Tenho uma IoT Devkit LoraWan com sensores onboard e gostaria de ampliar com outros sensores offboard. 

A black board tem compatibilidade com ESP32?

Giovanni5

Enviado 2022-04-18 10:45:18
CledsonBaldon

Normalmente a compatibilidade de sensores com placas microcontroladas é limitada apenas à tensão operacional. Como este sensor opera em 5V, e o ESP32 do IoT DevKit opera em 3,3V, não são diretamente compatíveis entre si. Entretanto, como se tratam de sinais digitais, é possível utilizar o conversor de nível lógico (https://www.robocore.net/regulador-de-tensao/conversor-de-nivel-logico) para compatibilizar as tensões operacionais. O mesmo vale para a BlackBoard UNO usada neste tutorial, que também opera em 5V, para comunicação serial (UART, SPI ou I2C) com o ESP32 do IoT DevKit.

yurildss
date

Enviado 2020-11-13 14:03:20

Se eu utilizar este sensor para calcular o fluxo/volume de agua, ira funcionar ?

Francois

Enviado 2020-11-13 18:36:56
yurildss

Sim, o primeiro projeto deste tutorial ensina a usar o sensor de fluxo de água para medir o volume escoado.

yurildss

Enviado 2020-11-13 18:40:38
yurildss

O nao, desculpa eu escrevi errado. Fluxo/volume de ar

Francois

Enviado 2020-11-13 21:14:23
yurildss

O sensor de fluxo deveria funcionar com o ar porque o deslocamento é monitorado a partir do ímã interno. No entanto não testamos esse sensor nessa aplicação porque é difícil manter uma vazão razoavelmente constante dentro da faixa de leitura, então o mais indicado é testar na sua aplicação.