Entrar    Registrar

Como contar o intervalo entre pulsos? para RPM

Fórum sobre plataforma Arduino

Moderadores: andre_teprom, guest2003, 51, Renie

  • Autor
    Mensagem

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor Deivid Roza » 27 Set 2016 12:53

Bom vamos lá encontrei a formula contraria. Digamos que fiz um contador de tempo e ja sei o tempo de uma volta completa. T=0,01

F=1/T
F=1/0,01
F=100

Como sabemos que frequencia é igual rps podemos multiplicar frequencia por 60 e obter o numero de rotacoes por minuto.
Rpm=60*rps
Rpm=60*100
Rpm=6000

Pronto. Agora so preciso de um contador de intervalo entre uma interrupçao e outra


Enviado de meu LG-E415f usando Tapatalk
Deivid Roza
Bit
 
Mensagens: 24
Registrado em: 14 Set 2016 12:42

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor brasilma » 27 Set 2016 15:42

Aqueles links que enviei na primeira página indicam caminhos!
" A Teoria orienta e a Prática decide" ;-)
Avatar do usuário
brasilma
Dword
 
Mensagens: 3228
Registrado em: 11 Out 2006 15:39
Localização: Planeta Terra

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor Deivid Roza » 27 Set 2016 17:26

brasilma escreveu:Aqueles links que enviei na primeira página indicam caminhos!

Claro vou estudar hoje. É que demorei a chegar nessa resposta. Agora que tenho uma base vou fixar nela o conteudo. Obrigado pela ajuda amigao ;)

Enviado de meu LG-E415f usando Tapatalk
Deivid Roza
Bit
 
Mensagens: 24
Registrado em: 14 Set 2016 12:42

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor MOR_AL » 27 Set 2016 22:25

Deivid Roza escreveu:Bom vamos lá. Eu procurei meu professor de fidica i ele me passou as seguintes informaçoes:
Se temos 6000rpm temos 100rps e temos 0.1 rpms.
Logo a frequencia é 100hz pois temos 100rps.
Sabendo a frequencia podemos saber o periudo de tempo que existe entre uma rotaçao e outra com o seguinte calculo.

T= 1/f

Logo temos:

0,01= 1/100

Oque pensei é em contar o tempo entre um pulso e o outro e fazer o calculo inverso para chegar em RPM logo nao preciso esperar todooooo aquele tempo de ciclos para saber o rpm. Isso seria praticamente instantaneo.

Alguem que manja de fisica pode me ajudar a fazer essa inversao?

Enviado de meu LG-E415f usando Tapatalk


Peço que releia uma de minhas postagens anteriores, pois lá tem algumas dicas, que pelas suas respostas, acredito que tenham passado despercebidas.
Tente entender o que está escrito. Deve sanar algumas dúvidas suas.
MOR_AL
"Para o triunfo do mal só é preciso que os bons homens não façam nada." Edmund Burke.
"Nunca discutas com pessoas estúpidas. Elas irão te arrastar ao nível delas e vencê-lo por possuir mais experiência em ser ignorante". Mark Twain
Avatar do usuário
MOR_AL
Dword
 
Mensagens: 2729
Registrado em: 19 Out 2006 09:38
Localização: Mangaratiba - RJ

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor Deivid Roza » 28 Set 2016 13:07

Opáaa galera . bom consegui reverter o calculo i foi muito mais simples que parece!

Se eu souber o tempo (T) de uma rotação ou seja o intervalo entre um pulso e o outro eu uso a seguinte formula.

F = 1/T
F= 1/0,01
F = 100

Agora que ja sei a frequencia F que é a mesma coisa que RPS é só multiplicar este valor por 60 que terei o RPM ;)

Agora ontem lendo pelo celular eu fiz um codigo mais não tive tempo de compilar e testar no arduino, mais acho que vai funcionar. porem tive um problema, preciso que esse codigo fique dentro da função chamada pelo interrupt, e não dentro do loop. segue o codigo a baixo, lembrando que ele não está completo pois usei um exemplo e adaptei no meu codigo porem não fiz a chamada pelo interrupt.

cpp code
#include <LiquidCrystal.h> // inclui a biblioteca para funcionar o display
LiquidCrystal lcd(10, 9, 8, 7, 6, 5); // define a pinagem do display
int rps=0; // armazena valor RPS
int rpm=0; // armazena valor RPM
int rpms=0; // armazena valor RPMS
int t=0; // armazena o valor de t


unsigned char flagHIGH=0;
unsigned long temp1;
unsigned long temp2;
unsigned long tempab;
// exemplo de valores
// rpm 6000
// rps 100
// f 100
// rpms 0,1
// T 0,01
// exemplo de valores
const int bobina = 12; // variável a guardar o pino do tip da bobina.
const int pulso = 11; // variável a guardar o pino de entrada do pulso da bobina
int bobinaled;

void setup() {
Serial.begin(9600);
pinMode(bobina, OUTPUT);
pinMode(pulso, INPUT);
pinMode(2, INPUT);
digitalWrite(2, HIGH);
digitalWrite(bobina, HIGH);
digitalWrite(pulso, LOW);
lcd.begin(16, 2);
attachInterrupt(0, sinal_crono, FALLING);
}

void loop() {
attachInterrupt(0, sinal_crono, FALLING);
lcd.setCursor(0, 0);
lcd.print("RPM:");
lcd.print(rpm);
lcd.print(" ");

// inicio dos calculos
rpm = rps*60;
rps = 1/t
// fim dos calculos

// inicio da funcao
if(digitalRead(pulso)==HIGH && flagHIGH == 0)
{
temp1=millis();
flagHIGH=1;
}
if(digitalRead(pulso)==LOW && flagHIGH==1)
{
temp2=millis();
tempHL=(temp2-temp1);
flagHIGH=0;
t=tempHL
}
// fim da funcao
//==============================================
// funcao corte de rpm
if (rpm > 2000)
{
digitalWrite(bobina, LOW);
(bobinaled = 0);
}
if (rpm < 1900)
{
digitalWrite(bobina, HIGH);
(bobinaled = 1);
}
//==============================================
}
void sinal_crono() //funcao chamada a cada interrupçao
{


// imprime na serial (funcao antiga usada como datalogger do resultado)
Serial.println("======== Novo Valor ========");
Serial.print("T:");
Serial.println((t));
Serial.print("RPMS:");
Serial.println((rpms));
Serial.print("RPS:");
Serial.println((rps));
Serial.print("RPM:");
Serial.println((rpm));
Serial.print("Bobina:");
Serial.println((bobinaled));
Serial.println("=========== FIM ============");
// imprime na serial

}


Assim que compilar vou ver se funcionou.
Idéia => Posso calcular o tempo que ficou em LOW. ai em HIGH eu imprimo o tempo, calculo pra RPM, zero o valor ou congelo ele até a proxima atualização, ai assim que chegar LOW eu inicio o contador dnovo,

Isso posso iniciar o contador com LOW. Ai quando o PULSO for == HIGH eu paro o contador, imprimo o T e faço o calculo da formula. depois que o sinal cair para LOW e inicio o contador denovo ;)

(eu escrevo um textãoooooo ai no final eu acabo solucionando o problema kkkkk ai apago tudo rsrsrs)

Bora reler tudo e encontrar uma forma de fazer isso funcionar com micros (para ser mais preciso) e usar a interrupção pois no meu code não esta assim rsrs.

Desculpem a bagunça amigos.
Deivid Roza
Bit
 
Mensagens: 24
Registrado em: 14 Set 2016 12:42

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor andre_teprom » 28 Set 2016 13:53

Bom, eu só acho que voce pode estar pecando no fato de estar utilizando uma série de funções "pesadas" (Serial.print) dentro do tratamento da interrupção (sinal_crono), o que pode matar a precisão que você está desejando. Nesse exato momento não tenho como te indicar nenhum tutorial pra isso, mas seria importante voce dar uma pesquisada em como programar com o conceito de agendamento de tarefas, no qual a escrita no LCD seria feita por exemplo apenas no loop() principal, e dentro da interrupção voce estaria apenas lidando com a captura do conteúdo do timer, e nada mais.
"Por maior que seja o buraco em que você se encontra, relaxe, porque ainda não há terra em cima."
Avatar do usuário
andre_teprom
Dword
 
Mensagens: 5219
Registrado em: 11 Out 2006 18:27
Localização: Brasil - RJ

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor Deivid Roza » 29 Set 2016 12:50

Boa. Gostei da ideia. Ouvi falar q isso gera um certo atraso. Mais no momenta esta ali so por estar. Nem compilei ainda. Mais vou remover. Acho q so vou ter tempo no sabado :( ai vou analizar melhor isso.
Obrigado pela dica ;)


Enviado de meu LG-E415f usando Tapatalk
Deivid Roza
Bit
 
Mensagens: 24
Registrado em: 14 Set 2016 12:42

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor Deivid Roza » 03 Out 2016 12:59

Olá galera estou de volta hehe bom seguinte compilei o código, resolvi inúmeros erros e no final acabei fazendo funcionar bem como eu queria. vou dar um exemplo aqui do funcionamento bem basico.

Enquanto o carro esta LIGADO porem com o motor desligado eu tenho na leitura de RPM um sinal LOW.

Fiz o funcionamento em IFs dessa forma:
Enquanto o arduino não receber o primeiro sinal HIGH ele não inicia a contagem de intervalos. se sim ele libera os outros IFs através do estado=1
Código: Selecionar todos
if(digitalRead(pulso)== HIGH && estado == 0) // se pulso HIGH e estado anterior 0 (aguarda primeiro pulso HIGH para iniciar a leitura)
{
  estado=1; // define estado como 1 (flagHIGH=1 libera as funções abaixo para fazer a leitura do intervalo)
}

A baixo temos a função que é executada quando recebe um pulso LOW
Código: Selecionar todos
if(digitalRead(pulso)== LOW && estado == 1) // se pulso LOW e estado anterior 1 
{
  temp1=millis(); // define temp1=millis()
  tempHL=(temp1-temp2); // define tempHL como temp2 - temp1
}

Agora temos a função que é executada quando recebe um pulso HIGH (faisca)
Código: Selecionar todos
if(digitalRead(pulso)== HIGH && estado == 1) // se pulso HIGH e estado anterior 1
{
  temp2=millis(); // define temp2=millis()
  t=tempHL;     // T IGUAL A TEMPHL pega valor de TEMPHL e armazena em T para ser usado pelo loop para calcular o RPM final.
}


Bom a função a principio é bem simples. após receber o primeiro pulso HIGH ele muda o estado para 1.
Logo quando esse pulso se tornar LOW ele inicia o contador de tempo.
Ai quando ele receber o pulso HIGH ele finaliza a contagem, pega os valores de TEMPO1 e TEMPO2 subtrai e guarda em tempHL
Quando cair em LOW denovo antes de iniciar a contagem ele pega o valor de tempHL e manda para T. Segue o codigo completo a baixo. (precisei colocar um display 4x20 para testar se os tempos estavam iniciando certinho. a principio esta funcionando. segue:

Código: Selecionar todos
#include <LiquidCrystal.h> // inclui a biblioteca para funcionar o display
LiquidCrystal lcd(10, 9, 8, 7, 6, 5); // define a pinagem do display
int rps=0; // armazena valor RPS
int rpm=0; // armazena valor RPM
int t=0;   // armazena o valor de t
int estado=0;

unsigned long temp1;       // tempo 1
unsigned long temp2;       // tempo 2
unsigned long tempHL;      // tempo entre HIGH e LOW

const int bobina =  12;    // variável a guardar o pino do tip da bobina.
const int pulso =  2;     // variável a guardar o pino de entrada do pulso da bobina

void setup() {
pinMode(bobina, OUTPUT);
pinMode(pulso, INPUT);
digitalWrite(bobina, HIGH);
digitalWrite(pulso, LOW);
lcd.begin(20, 4);
}

void loop() {
 
lcd.setCursor(0, 0);
lcd.print("RPM:");
lcd.print(rpm);
lcd.print("    "); // area vazia para n precisar limpar display -> evita delay

lcd.setCursor(0, 1);
lcd.print("RPS:");
lcd.print(rps);
lcd.print("    "); // area vazia para n precisar limpar display -> evita delay

lcd.setCursor(10, 3);
lcd.print("HL:");
lcd.print(tempHL);
lcd.print("  "); // area vazia para n precisar limpar display -> evita delay

lcd.setCursor(10, 2);
lcd.print("TH:");
lcd.print(temp2);
lcd.print("   "); // area vazia para n precisar limpar display -> evita delay

lcd.setCursor(10, 1);
lcd.print("TL:");
lcd.print(temp1);
lcd.print("    "); // area vazia para n precisar limpar display -> evita delay

lcd.setCursor(11, 0);
lcd.print("T:");
lcd.print(t);
lcd.print(" "); // area vazia para n precisar limpar display -> evita delay

// inicio dos calculos
rpm = rps*60; // RPM IGUAL A RPS*60
rps = 1/t;    // RPS IGUAL A 1/T
// fim dos calculos



// =======================================================================================
if(digitalRead(pulso)== HIGH && estado == 0) // se pulso HIGH e estado anterior 0 (aguarda primeiro pulso HIGH para iniciar a leitura)
{
  estado=1; // define estado como 1 (flagHIGH=1 libera as funções abaixo para fazer a leitura do intervalo)
}
// =======================================================================================
if(digitalRead(pulso)== LOW && estado == 1) // se pulso LOW e estado anterior 1
{
  temp1=millis(); // define temp1=millis()
  tempHL=(temp1-temp2); // define tempHL como temp2 - temp1
}
//========================================================================================
if(digitalRead(pulso)== HIGH && estado == 1) // se pulso HIGH e estado anterior 1
{
  temp2=millis(); // define temp2=millis()
  t=tempHL;     // T IGUAL A TEMPHL
}
// =======================================================================================

}

/*   EXEPLO DE VALORES EM 6000 RPM
// rpm:  6000
// rps:  100
// rpms: 0,1
// f:    100
// T:    0,01
 */


Só tive um unico problema. é em relação aos zeros!!! segue um exemplo aqui.

// rpm: 6000
// rps: 100
// rpms: 0,1
// f: 100
// T: 0,01 => aqui tenho o tempo entre um pulso e o outro! porem o arduino me retorna esse tempo sem o 0,0 só me retorna 1 ou 10.

Fiz como um amigo disse usei um 555 para oscilar a entrada fixo no rpm e fui alterando os valores para tentar chegar a um acerto e não deu certo.

Agora temos este problema dos zeros rsrsr e o problema de jogar isso tudo dentro da função interrupt.
Deivid Roza
Bit
 
Mensagens: 24
Registrado em: 14 Set 2016 12:42

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor brasilma » 03 Out 2016 17:13

" A Teoria orienta e a Prática decide" ;-)
Avatar do usuário
brasilma
Dword
 
Mensagens: 3228
Registrado em: 11 Out 2006 15:39
Localização: Planeta Terra

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor Deivid Roza » 04 Out 2016 12:12

Brasilma meu amigo pesquisei mais n tive tempo de ir a fundo no assunto.
Outra coisa q eu percebi é que o pessoal multiplica os valores por 10. Isso me pareceu uma boa ideia. Mais n estou com o pc aqui para ver como ficaria entao vou deixar d lado e vou seguir no estudo.
Obrigado pela ajuda amigo.

Sobre a forma como fiz a contagem no codigo alguma sugestao?

Enviado de meu LG-E415f usando Tapatalk
Deivid Roza
Bit
 
Mensagens: 24
Registrado em: 14 Set 2016 12:42

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor brasilma » 04 Out 2016 15:03

A questão consiste na representação correta das casas decimais, você pode fazer isto até manualmente (em assembly isto é normal).

Quanto ao código, existem infinitas formas de se chegar a um resultado, não se preocupe com isso, o importante é funcionar como deseja!
" A Teoria orienta e a Prática decide" ;-)
Avatar do usuário
brasilma
Dword
 
Mensagens: 3228
Registrado em: 11 Out 2006 15:39
Localização: Planeta Terra

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor Deivid Roza » 07 Out 2016 10:36

Ola amigos surgiu uma duvida relampago aqui que vai ser adicionado neste mesmo codigo futuramente.
Seguinte eu tenho uma sonda que lê. A mistura ar combustivel.
O valor dela varia de 0 a 1.000mv
Eu preciso ler este valor em tempo real com precisão. Maxima algo em torno de 99% de precisão entao pensei em mudar a Vref do arduino para 1.1v e fazer um map de 0 a 1.1 por 0-1023 correto?
So temos um problema eu preciso que o arduino mostre o valor exato em mv (convertido pelo a/d) sem erro algum e a velocidade de 100hz

A proposito eu to afim de mostrar no display 20x4 o rpm e a sonda.

Rpm
############
Sonda
############

Tipo isso. Acha q vai ser rapido para mostrar? Pretendo encher em bar graph


Enviado de meu LG-E415f usando Tapatalk
Deivid Roza
Bit
 
Mensagens: 24
Registrado em: 14 Set 2016 12:42

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor Deivid Roza » 07 Out 2016 10:52

40 - 980mv este é meu range de resposta da sonda. Logo Vref em 1.1v eu n vou ter a precisão. Exata digamos em 500mv da sonda vai ser igual a 550 no arduino.

I se eu fizer um regulador de tensao para 1.0mv e ligar no vref sera que da certo?

Enviado de meu LG-E415f usando Tapatalk
Deivid Roza
Bit
 
Mensagens: 24
Registrado em: 14 Set 2016 12:42

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor andre_teprom » 07 Out 2016 14:33

De um modo geral, é preferivel sempre trabalhar com potencias de 2 na divisão, isso ajuda o compilador á gerar um codigo menor e mais rápido. No caso, uma divisão por 1024 ( 210 ) significar em assembly um "shift-right" de 10 posições seguido de uma multiplicação, assumindo o Arduino baseado num uC com barramento de dados maior que 8 bits. Tudo bem que estaria adicionando um erro intrinseco ao resultado de -0,097% =(1023-1024)/(1023) mas isso seria mais que aceitável.

No seu caso por exemplo, a divisão por 1.000 acima poderia ser feito da seguinte forma:

N/1000
( N x ( 8 x 1/213 ) )
( ( N x 8 ) >> 13 )
N x ( 1 / 1024.5 )

Isso dá uma diferença de apenas 0,048% ( 1.024,5-1024 / 1024 )
"Por maior que seja o buraco em que você se encontra, relaxe, porque ainda não há terra em cima."
Avatar do usuário
andre_teprom
Dword
 
Mensagens: 5219
Registrado em: 11 Out 2006 18:27
Localização: Brasil - RJ

Re: Como contar o intervalo entre pulsos? para RPM

Mensagempor Deivid Roza » 07 Out 2016 21:47

Mais uma vez n intendi nada :(
Puts preciso fazer uma faculdade sobre isso. Pois faz tempo q eu mexo com isso e as vezes essas partes + tecnicas matemática acabam me dando nó no cabeça.
Mais obrigado pela ajuda vou estudar.

O bom deste forum é que a galera explica ao invés de dar o código mastigado, isso ajuda as pessoas a aprender.
Boa noite a todos

Enviado de meu LG-E415f usando Tapatalk
Deivid Roza
Bit
 
Mensagens: 24
Registrado em: 14 Set 2016 12:42

AnteriorPróximo

Voltar para ARDUINO

Quem está online

Usuários navegando neste fórum: Nenhum usuário registrado e 2 visitantes