Sensor de nivel utilizando hcsr04

[andre_luis]

Então devo declarar:
const float k = 0,182 ( que o compilador não esta aceitando declarar e não entendi o porque).

Existe uma alternativa para não utilizar valores do tipo float, que é a substituição desse numero por 2 operações basicas, sendo uma delas necessariamente uma divisão por potencia de 2 conforme abaixo. Essa técnica era muito empregada com microcontroladores de 8 bits com pouca capacidade de processamento, mas é também util quando se deseja evitar o uso de floats:



Nesse caso, a sua função seria instanciada com o seguinte argumento:

Código: Selecionar todos

exibe_distancia( ( ( ler_US() * 47 ) >> 8 ) ) ;

+++

[carlucio]

Melhor do que falar a respeito de um problema é mostra-lo. Veja video abaixo.




Para ninguem estranhar fiz poucos alterações do circuito original por enquanto. O problema persiste no modo de que se estar fazendo a leitura ou seja a incrementação não esta correta. Terei que tira ainda pelo menos 3 casas da visualização que aparece no lcd, mas veja que a leitura esta de maneira esquesita, muito instavel.
O programa original a leitura, vamos dizer é " mais suave" a incrementação fica bem visivel ou seja no video voce pode ver que movimento minha mão apenas alguns milimetros e a medida no lcd e muito brusca.

Pelo que vejo vou ter que alterar alguma coisa no codigo, ainda não descobri aonde.

Andre,

Entendi sua colocação, no caso eu usei um #define k 0.182, não sei se tem diferença do que voce postou acima (não usei o float). Mas primeiro agora tenho que fazer a leitura ficar mais instavel, veja o video e olhe a instabilidade!

O resultado la no final que quero no display no final de tudo é esse:

Nivel Cx: 109 lt
Aprox: 100%

[carlucio]

Esqueci foi de postar o codigo para mostrar o resultado ocorrido acima.

Código: Selecionar todos


#include <16F877A.h>
#device *=16
#device adc=8

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES XT                       //Crystal osc <= 4mhz for PCM/PCH , 3mhz to 10 mhz for PCD
#FUSES NOPUT                    //No Power Up Timer
#FUSES NOPROTECT                //Code not protected from reading
#FUSES NODEBUG                  //No Debug mode for ICD
#FUSES NOBROWNOUT               //No brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES NOCPD                    //No EE protection
#FUSES NOWRT                    //Program memory not write protected

#use delay(clock=4000000)

#ZERO_RAM

#define k 0.182 -------------------------------->>>>>>> a constante de k
#include <LCD_MSS.h>
/******************************************************************************
*  Ligações do LCD                                                            *
*   D7 -> RD7 (PORTD 7)                                                       *
*   D6 -> RD6 (PORTD 6)                                                       *
*   D5 -> RD5 (PORTD 5)                                                       *
*   D4 -> RD4 (PORTD 4)                                                       *
*   RS -> RD3 (PORTD 3)                                                       *
*   EN -> RD2 (PORTD 2)                                                       *
*   R/W -> Deve ser conectado ao GND                                          *
*   VCC -> Deve ser conectado ao +5V                                          *
*   GND -> Deve ser conectado ao GND                                          *
*   VO -> Deve ser conectado ao potenciômetro/trimpot de ajuste de brilho     *
******************************************************************************/

/******************************************************************************
* Ligações do Sensor HC-SR04                                                  *
*  Trig -> Pino RC0 do PORTC                                                  *
*  Echo -> Pino RC1 do PORTC                                                  *
*  VCC -> Deve ser conectado ao +5V                                           *
*  GND -> Deve ser conectado ao GND                                           *
******************************************************************************/
 
#use fast_io(c)//O Controle de direção (Entrada/Saida) dos pinos será feito no programa
#use fast_io(d)//O Controle de direção (Entrada/Saida) dos pinos será feito no programa

#byte PORTC = 0x07//Endereço do PORTC
#byte PORTD = 0x08//Endereço do PORTD

#bit Trig = PORTC.0 //pino que dispara o ultrasom
#bit Echo = PORTC.1 //pino que lê a resposta


//Declaração de funções
//const float k = 182; // 109 litros (capacidade) / 600mm = 0,182 por isso utilizei 182 /10 = 0,182litros a constante para 1 mm
unsigned int16 ler_US(void); //função que lê e retorna a distância em mm
void exibe_distancia(unsigned int16);//rotina que converte a distância em caracteres e envia para o LCD

void main()
{

   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_OFF);
   setup_psp(PSP_DISABLED);
   setup_spi(SPI_SS_DISABLED);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_2);
   setup_timer_1(T1_INTERNAL | T1_DIV_BY_2);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   
   // TODO: USER CODE!!
   
   //Os Pinos RD2 a RD7 são usados pelo LCD, os pinos RD0 e RD1 estão livre para uso
   set_tris_d(0b00000000);//Configurando todos os pinos como saída
   //Os pinos Trig e Echo estão conectados no PORTC, Trig -> RC0 e Echo -> RC1
   set_tris_c(0b00000010);//Pino RC1 como entrada e o restante como saída
   
   PORTC = 0;//Inicia com todos os pinos que forem saída em zero
   PORTD = 0;//Inicia com todos os pinos que forem saída em zero
 
   configura_lcd();//Chama a rotina que faz as configurações básica para o LCD funcionar
   inicio_lcd();//Coloca o cursor no inicio
   limpa_lcd();//Limpra o LCD
   
   linha_1_lcd(3);//Começa a escrever apartir do caracter 4 na primeira linha
   caracter_lcd('N');
   caracter_lcd('I');
   caracter_lcd('V');
   caracter_lcd('E');
   caracter_lcd('L');
   caracter_lcd(':');
   caracter_lcd(' ');
 
   while(1)//Loop infinito do programa
      {
      linha_1_lcd(10);//Imprime a distância apartir do caracter 10
     
      delay_ms(250); //Garante o tempo minimo para aquisição de nova distancia (O fabricante exige minimo 50ms)
      exibe_distancia(k*ler_US());//Chama a rotina que exibe a distancia no LCD, e passa como parametro a distancia lida em ler_US() ------>>>> aqui a inclusao de k
      }

}

unsigned int16 ler_US(void)//Esta rotina realiza a leitura da distancia e a retorna em mm
   {
   unsigned int16 vl_timer = 0;//Variavel para armazenar o tempo
   unsigned int16 distancia = 0;//Armazena a distancia convertida
   Trig = 1;//Dispara o Ultrasom
   delay_us(20);//Aguarda um tempo (minimo de 10us)
   Trig = 0;//Volta para 0 (zero)
   
   while(!Echo){}//Aguarda começar a enviar a resposta
   
   set_timer1(0);//Reinicia o TIMER1
         
   while(Echo){}//Fica parado até receber a resposta
   
   vl_timer = get_timer1();//Le o tempo em que ficou recebendo a resposta (Tempo de instrução / 2 em uS)

   distancia = ((((vl_timer * 2) * 10) / 58) + 10);//Como o divisor do TIMER1 estar 1:2, multiplicamos por 10, passo para mm (x 10) e converto ( / 58)
   return distancia;//A função retorna o valor convertido em mm
   }

void exibe_distancia(unsigned int16 distancia)//Rotina responsavel por converter em caracter e enviar a distância
   {
   unsigned int16 x;//declara uma váriavel auxiliar
   
   x = distancia / 10000;//Pega a dezena de milhar(Ex: 12345, pega apenas o '1') Inteiro de 12345/10000
   x = x + 48; //Converte em caracter ASCII
   caracter_lcd(x);//Envia para o LCD
   
   x = distancia / 1000;//Pega a Dezena e Unidade de Milhar (Ex: 12345, pega '12') Inteiro de 12345/1000
   x = x % 10; //Pega a Unidade de milhar (Ex: 12345, pega apenas '2') resto da divisão 12/10
   x = x + 48; //Converte em caracter ASCII
   caracter_lcd(x); //Envia para o LCD
   
   x = distancia / 100; //Pega dezena, unidade de milhar e a centena (Ex:12345, pega '123') Inteiro de 12345/100
   x = x % 10; //Pega a centena (Ex: 12345, pega apenas '3') o resto da divisão 123/10
   x = x + 48; //Converte em caracter ASCII
   caracter_lcd(x);//Envia para o LCD
   
   x = distancia / 10; //Pega dezena e unidade de milhar, centena e desena (Ex: 12345, pega '1234') Inteiro de 12345/10
   x = x % 10; //Pega a dezena (Ex: 12345, pega apenas '4') o resto da divisão 1234/10
   x = x + 48;//Converte em caracter ASCII
   caracter_lcd(x);//Envia para o LCD
   
   x = distancia % 10;//Pega a unidade (Ex: 12345, pega apenas '5')  Resto de 12345/10
   x = x + 48;//Converte em caracter ASCII
   caracter_lcd(x);//Envia para o LCD
   caracter_lcd('m');
   caracter_lcd('m');//Exibe mm   
   }




Sem alguem viu algum erro, por favor nos ajude.

[Renie]

Olá Carlucio,

Só para pensar, respondendo a esta colocação que você fez e acabei não vendo...

Este tal tubo " parasita " conhecido por mim como nivel por coluna de agua tambem pensei, mas no caso tenho que furar o recepiente para isso acontecer. Agora imagina se voce furar sua caixa d'agua onde a agua esta dentro do tubo " parasita" que geralmente é a mesma que esta dentro da caixa d'agua e que normalmente devera ter a parte superior aberta, estiver recebendo a poeira do forro onde geralmente fica animais tambem como passaros ? Da nojo so de pensar. ...

O tubo parasita ou coluna d'água não precisa ter sua parte superior aberta, apenas um furo de 10mm seriam o suficiente para a vazão do ar do tubo e o mesmo
poderia também ter um pedaço de tela evitando entrada de corpos estranhos maiores que menos que mm, sendo que a própria tampa seja da caixa dágua
quanto do balde ambos tem entradas de ar bem mais consideráveis!

[MOR_AL]

Olha.
"O ótimo é inimigo do bom."
Eu estava com o mesmo problema. Minha água é "por favor". A mina é do meu vizinho e está minguando. Tem uma mini cisterna de 2k litros.
Ele fecha a água que eu recebo, para poder encher a caixa dele, mais alta da mini cisterna. Caso ele não feixe, entra ar na bomba dele e já viu, né.
Bom. O problema é que ele sempre "esquece" de reabrir o meu registro. Aí eu vou lá e peço para ele abrir, o que nem sempre ocorre nas primeiras horas.
Para não ficar sem água, pensei em colocar no telhado, junto à caixa,, um pic, um sensor de nível e um Tx junto à caixa e outro pic, um RX, um LCD e um buzzer, mais embaixo, onde ficasse fácil de visualizar.
Pois bem!
Pensei, pensei, pensei e cansei, hehehe. Daria muito trabalho.
Comecei a reduzir daqui e dali, até que concluí o seguinte.
De nada adianta eu saber exatamente qual o nível de água eu disponho na caixa em todo o instante.
É importante saber que o nível ficou abaixo de uma determinada altura da caixa. Isso mostrava que não estava entrando água.
Coloquei uma boia com um contato para disparar com menos de 80% de água na caixa.
O contato da boia aciona uma campainha e uma pequena lâmpada, dessas xing ling com cerca de 5W. Tanto a campainha como a lâmpada possuem uma chave L/D.
Quando a água cai abaixo de 80% a campainha toca e a luz acende. Corro para a campainha e desligo, já que ela não foi feita para funcionar continuamente. Aí fico monitorando a caixa com a lâmpada. Quando a lâmpada apaga eu ligo a chave da campainha.
Claro que quando a patroa usa a máquina de lavar, o troço dispara, mas se estiver entrando água na caixa, a lâmpada apaga em duas horas.
Com isso eu não sou mais surpreendido com falta d`água. Aos 80% eu começo a economizar.
Eu fiz a boia com uma ampola de mercúrio que eu tinha e um recipiente plástico vedado e com um peso, para a conexão fechar sempre com a mesma altura.
O nível da boia foi determinado pelo comprimento do fio até a borda da caixa, onde um nó fixa o comprimento do fio.
Esta boia substituiu outra (comercial) do tipo bola e contato. Não durou nem 2 meses.
Depois eu vi para vender, uma chave que possui um reed e um ímã. Custa cerca de R$30,00, mas tem que furar a caixa. Esta chave permite alterar seu estado tanto quando a água desce, como quando a água sobe, bastando instalá-la girando 180º. O detalhe dessas chaves é que não são feitas para grandes isolamentos e grandes correntes. Ela devem acionar a bobina de um relé.
Foi a solução mais simples que eu fiz. Ainda coloquei um fusível e um interruptor em série com tudo.
A distância (altura) entre o sensor e o alarme é cerca de 6 metros. Usei aqueles fios cinzas transados de linha telefônica. O custo e o trabalho foram os menores possíveis. Funciona 100% (até o momento, hehe).
MOR_AL

[carlucio]

Moral,

A ideia sua é interresante, mas cada situação exige uma solução. Não mensionei anteriormente mas va fiquei 6 dias s/ ter o abastecimento de agua normal aqui, e quando volta é so aquele "mijãozinho" dentro da caixa.
Apesar de tudo esse sensor é muito barato (R$ 10,00) e pode ser bastante pratico, veja os video acima e no youtube os videos com hcsr04 controlando nivel.

Preciso de ajuda no codigo acima para acertar a leitura e medição do mesmo.

[andre_luis]

Se eu fosse você, faria o teste com algo mais estável do que a mão. Experimenta montar algum aparato onde haja uma repetibilidade na medição, de tal modo que possa ser utilizado para a calibração.

Outra coisa, o sensor que voce adquiriu é proprio para medir distancias tão pequenas ???
Dá uma olhada no datasheet pra confirmar, mas não tenho certeza se são feitos pra isso.




+++

[carlucio]

Novamente, mostrar e melhor do que falar. Veja que o sensor funciona perfeitamente, com a mão ou qualquer superficie rigida, etc...

O sensor mede de 2 cm ate 4 metros.

No youtube, se pesquisar sobre medir nivel com esse sensor, vera diversos exemplos, ate mais com arduino, mas o mesmo funciona tambem com pic.







O que sera que devo modificar para ter uma leitura estavel?

[carlucio]

Outro video para mostrar com é eficiente e preciso este sensor.

Quero conseguir ainda medir nivel com ele de uma maneira eficiente.

[andre_luis]

O que sera que devo modificar para ter uma leitura estavel?

Experimenta apresentar no display uma média-móvel de várias medidas, isso funciona tal qual o efeito de emortecimento de um capacitor em paralelo.



+++

[carlucio]

O meu problema maior que acabei de notar é a bendita "matematica".
Como estou agora aprendendo usar este sensor, e apos alguns videos vistos, me parece que o problema é somente em como montar o programa para transforma milimetros em litros ou adequar o codigo diretamente para ler em litros.

A aqueles que são mais aprofundados em calculos com microcontradores o que deve ser feito para adequar o codigo ?

[carlucio]

Como dito acima o problema maior esta na matematica.



larios.tecnologia.ws/iBlog/archives/3715


Vejam como é feito o calculo para medir centimetros.

A parte do codigo a ser alterada é esta abaixo, so ainda não entendi como calculuar ou montar a formula.

Código: Selecionar todos


vl_timer = get_timer1();//Le o tempo em que ficou recebendo a resposta (Tempo de instrução / 2 em uS)

   distancia = (((((vl_timer * 2) * 10) / 58) + 10)) ;//Como o divisor do TIMER1 estar 1:2, multiplicamos por 10, passo para mm (x 10) e converto ( / 58)
   return distancia;//A função retorna o valor convertido em mm



Se alguem puder me ajudar

[ze]

esquece a matemática. de fato é meio que complicado vc fazer a conversão direta. depende p.ex da geometria da caixa (que acho que alguém já mencionou). se eu fosse você, veja o que você, que na verdade seria eu, faria:
-primeiro, certifique-se (co-me) que sua (minha) montagem proporciona uma medição qualquer de distância. ou seja deixe ele retornar o valor que quiser desde que seja linear
-numa caixa totalmente irregular...
-coloco xL de h2O
-anoto o valor medido numa const unsigned char tabela[]
-coloco +xL de h2O
-anoto o valor medido numa const unsigned char tabela[]
-coloco +xL de h2O
-anoto o valor medido numa const unsigned char tabela[]
-coloco +xL de h2O
-anoto o valor medido numa const unsigned char tabela[]
-...
-No meu (meu) caso cerca de 10 medições de 25L seriam suficientes. (De fato eu (eu) nem me importaria com o valor numérico exato dos litros. Bastar-me-iam as pro'porções' de h2O na caixa).
-com os dados em mãos, basta adicioná-lo ao fonte em forma de tabela e uns 10 if´s me fariam a conversão de cm para litros
na verdade acho que faria algo assim
unsigned char convete_cm_l(unsigned char cm)
{
unsigned char l=0;
while(cm<=tabela[l]) l++;
return l;
}
a-góra...
se a caixa for regular, anote (eu anotaria) os valores de vl_timer (unidades de timer) com ela vazia e cheia. Assim, apenas uma (ou duas) operação matemática simples faria a conversão. preguiça de pensar agora

e anda logo antes que comece o racionamento e ninguém vai poder te mandar ir tomar banho!
sei lá. ainda não pinguei meu colírio alucinógeno no 3º olho

[carlucio]

Caro Ze,

Ate pensei em fazer isso, mas com esse componente consigo fazer sim uma leitura linear, seria um disperdicio de precisão. Este componente tem uma resoluçao de 0,3mm

Este video abaixo, apesar de ser em casteliano, em bem entendivel e explica acho que bem claro o funcionamento do componente



Preciso saber montar a tal formula matematica para me dar a leitura em forma de litros, por isso peço ajuda ao pessoal do forum.

[andre_luis]

Preciso saber montar a tal formula matematica para me dar a leitura em forma de litros, por isso peço ajuda ao pessoal do forum.

Ainda não entendi porque não aplicou a formula indicada no post do dia Qui Jul 24, 2014 8:27 pm.


+++