Sensor de fluxo de água

Marcio Leandro B. Pizano · 23 de janeiro de 2020

Olá!
Estou precisando fazer um sensor de fluxo de água. Preciso desligar a bomba quando o volume de água baixar para não estragar o rotor que é de plástico ou polietileno.
Pretendo usar o pic 16f628A e o sensor é o YF-S201.

Características do sensor:

Modelo: YF-S201
• Tipo de sensor: Efeito Hall
• Tensão de operação: 5-24V
• Corrente máxima: 15mA (5V)
• Faixa de fluxo: 1-30L/min
• Pressão máxima: 2,0 MPa
• Pulsos por litro: 450
• Frequência (Hz) = 7,5*Fluxo(L/min)
• Temperatura de trabalho: -25 a 80°C
• Exatidão: 10%
• Comprimento do cabo: 15cm
• Dimensão conexão: 1/2"
• Dimensão diâmetro interno: 0,78
• Dimensão externa: 2,5 x 1,4 x 1,4

Não quero o código pronto é claro, o que preciso e saber por onde começar.

Fiz um código manipulando o Timer 0 mas não funcionou legal.

Um detalhe que observei é que quando eu sopro o sensor (Para testar os pulsos) o máximo de tensão que ele envia no fio amarelo é de 2,56V aproximados, deveria ser de 5V eu acho, porque alimento o sensor com 5V. Não sei se isso seria um problema.

Um trecho do código:

#include <16F628A.h>
#use delay(clock=4000000) // Oscilador interno
#fuses XT,nomclr,nowdt



#define rele_bomba   PIN_B0   //pino RELÉ BUZINA - (PINO 6) 
#define rele_cirene  PIN_B1   //pino RELÉ CORTA  - (PINO 7)
#define inicia_bomba PIN_B2   //pino INICIA      - (PINO 8)
#define sinal        PIN_B3   //pino SINAL       - (PINO 9)



//Tipo inteiro
int FOCO             = 1;     
int pulsos           = 100;
int vazao            = 0;
int tempo_minimo     = 0;
int ContadorIntTimer = 0;



void ConfigTimer1(void)
{
    ContadorIntTimer=0;
    setup_timer_1(T1_INTERNAL | T1_DIV_BY_4);
    set_timer1(15536);
    enable_interrupts(INT_TIMER1);      
    enable_interrupts(GLOBAL); 
}



#INT_TIMER1
void TrataTimer1()
{
     ContadorIntTimer++;
     if (ContadorIntTimer < 5)  
     {
     set_timer1(15536);
     Pulsos = 0; //Contagem zerada a cada segundo
     return;
     }
                if(input(sinal))
                { 
                pulsos ++;                //Adiciono contagens a variável pulso através do sensor de fluxo
                return;
                }

 }
 //1 segundo se passou. Pode executar o restante da função / cálculos

ETC.

Me ajudem rs.

Muito obrigado!
Abraço!

Carlos Zanon · 23 de janeiro de 2020

2 horas atrás, Marcio Leandro B. Pizano disse:

saber por onde começar

Nessa parte aqui... Você precisar saber o fluxo da água é uma coisa... você saber quanto de água tem é outra...

De sensor pra nível de água tem umas boias baratinhas no mercado livre tipo esse aqui:

https://produto.mercadolivre.com.br/MLB-870019171-boia-sensor-nivel-lateral-arduino-aquario-agua-_JM?matt_tool=79246729&matt_word&gclid=CjwKCAiAgqDxBRBTEiwA59eEN8M4oiByKtuRzNJvMEr55AfJckT6kWnYWykYzP1WwZajBxj2qfGa7xoCZBoQAvD_BwE&quantity=1

Você testar pela quantidade de água que passa pelo sensor, não acho que seja muito interessante...

Renato.88 · 23 de janeiro de 2020

Boias e pressostatos mecânicos são a melhor coisa pra bomba d'água.

Essas coisas eletrônicas nem vale a pena o trabalho, queimam muito fácil.

Sérgio Lembo · 23 de janeiro de 2020

O que tens na mão é um encoder ligado a uma turbina que te dá 450 pulsos por litro em onda quadrada, um voltímetro vai ler em DC a média dessa onda quadrada. Repita a operação em AC e vai ter uma leitura de uns 2VAC.

Em termos de segurança um sensor tipo boia é bem mais simples e seguro.

Sobre o código, creio que irá necessitar de 2 timers: 1 como base de tempo e outro como contador dos pulsos do sensor, a cada interrupt ou event (isso depende do uC usado) gerado pela base de tempo verifica-se o quanto foi contado. Quando a bomba for ligada vai ter que gerar um tempo de blank (cegueira) nesse sistema pois ele é muito rápido e a bomba nem tanto.

faller · 23 de janeiro de 2020

10 horas atrás, Marcio Leandro B. Pizano disse:

Olá!
Estou precisando fazer um sensor de fluxo de água. Preciso desligar a bomba quando o volume de água baixar para não estragar o rotor que é de plástico ou polietileno.

Claro, quem sou eu para lhe tirar o incentivo para a criação mas, fosse meu caso usaria a velha, eficiente e eficaz boia alta e boia baixa, usadas em bombas de recalque d'água em 9 em cada 10 edifícios..

Isso dai ó:

No seu caso use uma boia inferior, que abre o circuito ao faltar agua em baixo..

Marcio Leandro B. Pizano · 23 de janeiro de 2020

Obrigado a todos pelas respostas, mas, acho que me expressei errado, o que quero não é o nível da água e sim o fluxo mesmo, qual é a vazão por segundo e quando esta vazão diminuir e chegar a um determinado nível que eu julgar mínimo, desliga a bamba.

Obrigado!

.if · 23 de janeiro de 2020

Amigo, com o queijo

6 horas atrás, Sérgio Lembo disse:

que tens na mão é um encoder ligado a uma turbina que te dá 450 pulsos por litro

basta-lhe a faca: aplique estes pulsos numa entrada contadora de um timer (me lembro vagamente que o timer 1 conta por fora)

TMR1CS=1;//RB6 vira entrada

E de vez em quando a cada segundo p.ex. (usando interrupt timer0)

unsigned int vazao; //global
//...

interrupt timer0()
{
//...
vazao=TMR1H*256+TMR1L; //capture a contagem a cada segundo e...
TMR1H=TMR1L=0; //zere a contagem
}

10 minutos atrás, Marcio Leandro B. Pizano disse:

qual é a vazão por segundo

No loop do main()

10 minutos atrás, Marcio Leandro B. Pizano disse:

quando esta vazão diminuir e chegar a um determinado nível que eu julgar mínimo, desliga a bamba.

#define desligada 0
#define ligada 1
#define bomba RB0
#define nivel_minino 100

///...

if (vazao<nivel_minimo) bomba=desligada;

Difícil? ... Fala sério?

Marcio Leandro B. Pizano · 2 de fevereiro de 2020

Ainda não consegui cortar o queijo rs.
Fiz um código simples com entradas de pulsos simulados em um botão no pino RB6 do 16f628a, que é o T1OSO para testes.

Funciona no Proteus porém é de longe a forma correta eu sei.

Não entendo muito bem do modo comparador com TMR1H, flags etc.

Código simples:

#include <16F628A.h>
#include <stdlib.h> //Para strings
#use delay(clock=4000000) // Oscilador interno
#fuses XT,nomclr,nowdt





//*****************************************  LCD  *****************************************

#define lcd_enable pin_a1       // pino enable do LCD (E)
#define lcd_rs     pin_a0       // pino rs (register select)do LCD (RS)
                                // (0) para comandos    (1) para dados
                                // O pino RW vai no negativo.
#define lcd_db4    pin_b4       // pino de dados d4 do LCD
#define lcd_db5    pin_b5       // pino de dados d5 do LCD
#define lcd_db6    pin_b3       // pino de dados d6 do LCD
#define lcd_db7    pin_b7       // pino de dados d7 do LCD

#include <lcd.h>                //declaração da biblioteca do LCD
//*****************************************  LCD  *****************************************


#define	TRISB= 0b01010000; //Difini os pinos 5 e 4 como entrada, o resto saída.
#define	TRISA= 0b00000000; //Difini todos como saída.

//ZERANDO OS PINOS, DEFINO QUE ELES NAO TEM VALOR ALGUM NO INÍCIO DO PROGRAMA
#define PORTB= 0;
#define PORTA= 0;


#define rele_bomba   PIN_B2   //pino RELÉ BUZINA - (PINO 8) 
#define rele_cirene  PIN_B1   //pino RELÉ CORTA  - (PINO 9)
#define inicia_bomba PIN_B2   //pino INICIA      - (PINO 10)
#define pulsos       PIN_B6   //pino SINAL       - (PINO 12)



//Tipo inteiro
int nivel_minimo     = 5;
int pulso            = 0;


void main()
{

		inicializa_lcd();               //Inicializa o LCD

        caracter_inicio(1,4);
        printf(escreve_lcd,"AGUARDADNDO!");
 


   while(TRUE) //Loop Principal
   {


if (input(pulsos)){
		pulso++;
 		limpa_lcd(); //Limpo LCD
        caracter_inicio(1,4);
        printf(escreve_lcd,"PULSOS");
        delay_ms(100);
        caracter_inicio(2,5);
		printf (escreve_lcd, "%01u", pulso);
}

        
if (pulso < nivel_minimo) 
{

        limpa_lcd(); //Limpo LCD
		caracter_inicio(1,4);
        printf(escreve_lcd,"MENOR");
        delay_ms(100);

		pulso = 0; //Limpo a variável

        output_low(rele_bomba);       //Desligo o relé da bomba
        output_high(rele_cirene);     //Aciono o relé da cirene 

}

 
}//TRUE
}//void main

Na outra tentativa, já incluí o timer mas não tive sucesso.
Código:

#include <16F628A.h>
#include <stdlib.h> //Para strings
#use delay(clock=4000000) // Oscilador interno
#fuses XT,nomclr,nowdt





//*****************************************  LCD  *****************************************
 
#define lcd_enable pin_a1       // pino enable do LCD (E)
#define lcd_rs     pin_a0       // pino rs (register select)do LCD (RS)
                                // (0) para comandos    (1) para dados
                                // O pino RW vai no negativo.
#define lcd_db4    pin_b4       // pino de dados d4 do LCD
#define lcd_db5    pin_b5       // pino de dados d5 do LCD
#define lcd_db6    pin_b3       // pino de dados d6 do LCD
#define lcd_db7    pin_b7       // pino de dados d7 do LCD

#include <lcd.h>                //declaração da biblioteca do LCD
//*****************************************  LCD  *****************************************


#define	TRISB= 0b01010000; //Difini os pinos 5 e 4 como entrada, o resto saída.
#define	TRISA= 0b00000000; //Difini todos como saída.

//ZERANDO OS PINOS, DEFINO QUE ELES NAO TEM VALOR ALGUM NO INÍCIO DO PROGRAMA
#define PORTB= 0;
#define PORTA= 0;


#define rele_bomba   PIN_B2   //pino RELÉ BUZINA - (PINO 8) 
#define rele_cirene  PIN_B1   //pino RELÉ CORTA  - (PINO 9)
#define inicia_bomba PIN_B2   //pino INICIA      - (PINO 10)
#define pulsos       PIN_B6   //pino SINAL       - (PINO 12) INTERNAMENTE JÁ DEFINIDO PARA RECONHECER O PULSO



//Tipo inteiro
unsigned int pulso;        //global
int ContadorIntTimer = 0;
int nivel_minimo     = 20;



#byte TMR1H = 0xFCF 
#byte TMR1L = 0xFCE


void ConfigTimer1(void)
{

    ContadorIntTimer=0;
    setup_timer_1(T1_INTERNAL | T1_DIV_BY_4);
    set_timer1(15536);
    enable_interrupts(INT_TIMER1);      
    enable_interrupts(GLOBAL); 
}



#INT_TIMER1
void TrataTimer1()
{

if (input(pulsos)){
pulso++;
pulso=TMR1H*256+TMR1L; 
}

     ContadorIntTimer++;
     if (ContadorIntTimer < 5)   // 0,2s. Logo, 5 (5*2) equivalem a 1 segundo
     {
     set_timer1(15536);
     TMR1H=TMR1L=0; //zere a contagem
     return;
     }
 }
 //1 segundo se passou.

 



void main()
{

		inicializa_lcd();               //Inicializa o LCD

        caracter_inicio(1,4);
        printf(escreve_lcd,"AGUARDADNDO!");
        delay_ms(100);
        caracter_inicio(2,5);
		printf (escreve_lcd, "%01u", pulso);  

   while(TRUE) //Loop Principal
   {

        
if (pulso<nivel_minimo) 
{

        limpa_lcd(); //Limpo LCD
		caracter_inicio(1,4);
        printf(escreve_lcd,"OK");
        delay_ms(100);
        caracter_inicio(2,5);
		printf (escreve_lcd, "%01u", pulso);

		pulso = 0; //Limpo a variável

        output_low(rele_bomba);       //Desligo o relé da bomba
        output_high(rele_cirene);     //Aciono o relé da cirene 

}

       
}//TRUE
}//void main

Qualquer dica vai muito bem vinda.

valeu

Obrigado!

Sérgio Lembo · 2 de fevereiro de 2020

São duas as formas de descascar esse abacaxi: com 1 timer (base de tempo) e um contador (para seu sensor) e vai ter a leitura direta em litros por minuto. Com uma calculadora consegue fácil achar a base de tempo mais adequada para transformar os 450pulsos/litro em litros por minuto.

Uma outra que usa apenas um timer é ter uma frequência fixa no timer, colocar o sensor no interrupt e ao invés da frequência passa a trabalhar com o período. No interrupt zerar o timer e fazer a avaliação. Setar interrupt interno por ocasião do loop de contagem para detectar vazão zero.

.if · 3 de fevereiro de 2020

2 horas atrás, Marcio Leandro B. Pizano disse:

botão no pino RB6 do 16f628a, que é o T1OSO para testes.

O botão ou entrada nao deve ir no tioso e sim no T1OSI.

Como este mc tem 2 timers, meu voto vai pra opção um: base de tempo e contador. Assim sendo, praticamente só o hw do mc faz o todo trabalho sujo.

A busca/literatura: pic frequency meter deve te dar a orientação necessária

Marcio Leandro B. Pizano · 3 de fevereiro de 2020

2 horas atrás, Sérgio Lembo disse:

São duas as formas de descascar esse abacaxi: com 1 timer (base de tempo) e um contador (para seu sensor) e vai ter a leitura direta em litros por minuto. Com uma calculadora consegue fácil achar a base de tempo mais adequada para transformar os 450pulsos/litro em litros por minuto.

Uma outra que usa apenas um timer é ter uma frequência fixa no timer, colocar o sensor no interrupt e ao invés da frequência passa a trabalhar com o período. No interrupt zerar o timer e fazer a avaliação. Setar interrupt interno por ocasião do loop de contagem para detectar vazão zero.

Vou estudar os dois casos. Obrigado!

53 minutos atrás, Isadora Ferraz disse:

O botão ou entrada nao deve ir no tioso e sim no T1OSI.

Verdade, vacilei, deve ser de entrada.

56 minutos atrás, Isadora Ferraz disse:

Como este mc tem 2 timers, meu voto vai pra opção um: base de tempo e contador. Assim sendo, praticamente só o hw do mc faz o todo trabalho sujo.

A busca/literatura: pic frequency meter deve te dar a orientação necessária

Obrigado! Vou estudar.

Luís Roberto C. da Silva · 3 de fevereiro de 2020

Concordo que seria melhor um pressostato.

.if · 3 de fevereiro de 2020

3 horas atrás, Luís Roberto C. da Silva disse:

um pressostato

... não mede vazão

Luís Roberto C. da Silva · 3 de fevereiro de 2020

3 horas atrás, Isadora Ferraz disse:

... não mede vazão

Se o objetivo é desligar quando a vazão cai, o pressostato vai funcionar, visto que se a vazão cai, a pressão cai proporcionalmente se a espessura da tubulação permanece a mesma.

Sérgio Lembo · 3 de fevereiro de 2020

47 minutos atrás, Luís Roberto C. da Silva disse:

Se o objetivo é desligar quando a vazão cai, o pressostato vai funcionar, visto que se a vazão cai, a pressão cai proporcionalmente se a espessura da tubulação permanece a mesma.

Desculpe Luis mas erraste. Para sua declaração ser válida é necessário que as restrições existentes entre a bomba e o final da linha não se alterem. Uma simples boia de caixa dágua ao atingir o nível zera a vazão sem zerar a pressão (que irá aumentar ao máximo da bomba).

.if · 3 de fevereiro de 2020

Amigo @Marcio Leandro B. Pizano .. alguns errinhos que vi agora. Uns me incomodam mais que outros...

19 horas atrás, Marcio Leandro B. Pizano disse:

printf(escreve_lcd,"AGUARDADNDO!");

19 horas atrás, Marcio Leandro B. Pizano disse:

output_high(rele_cirene); //Aciono o relé da cirene

19 horas atrás, Marcio Leandro B. Pizano disse:

define TRISB= 0b01010000; //Difini os pinos 5 e 4 como entrada, o resto saída.

Este tem vários, a saber...

-não é 5 e sim 6

-o 7 deve ser entrada também . É o tal de t1osi

1 hora atrás, Luís Roberto C. da Silva disse:

o objetivo é desligar quando a vazão cai,

O garoto que medir a vazão...

Em 23/01/2020 às 12:14, Marcio Leandro B. Pizano disse:

e sim o fluxo mesmo, qual é a vazão por segundo e

e tem atém um medidor

Eu tenho um igualzinho mas diferente. Ele é só gerador 12V

Marcio Leandro B. Pizano · 4 de fevereiro de 2020

5 horas atrás, Isadora Ferraz disse:

printf(escreve_lcd,"AGUARDADNDO!");

Seria AGUARDANDO kkk, mals.

5 horas atrás, Isadora Ferraz disse:

cirene

Sem comentários! Putz.

5 horas atrás, Isadora Ferraz disse:

define TRISB= 0b01010000; //Difini os pinos 5 e 4 como entrada, o resto saída.

Defini!!?? rs
Realmente é o pino 6.

Na verdade eu acertei na configuração mas errei na escolha de entrada dos pinos, coloquei realmente no pino 6 quando seria no 7, então deveria ficar assim: #define TRISB= 0b10010000;
Troquei mas ainda nada.

6 horas atrás, Isadora Ferraz disse:

e tem atém um medidor

É realmente o modelo do meu.

Obrigado!

14 horas atrás, Luís Roberto C. da Silva disse:

Concordo que seria melhor um pressostato.

Obrigado! Por enquanto vou tentar com o pic, até mesmo para eu aprender a programar vazão, mas, não vou descartar a dica.

.if · 4 de fevereiro de 2020

Dicas:

no lugar do botão PULSOS, coloque um gerador de sinais.
Remova da simulação o que estiver na saída. Coloque apenas led digital e sem resistor: apenas pra simulação
remova retificador, regulador e todos os etc analógicos que não influenciam a simulação do desafio