Olá, pessoal! Meu nome é Yuri Merçon e eu sou novo aqui na Garagem :P, assim como na programação.


  Bem, eu estou tentando fazer uma contagem a partir de dois sensores ópticos do tipo barreira.
Os sensores estão dispostos em paralelo na porta à uma distância miníma e o funcionamento é assim:
Caso uma pessoa passe pelo sensor1 o programa espera até o sensor2 ser acionado, quando o sensor é acionado soma-se 1 ao montante de pessoas, caso o sensor2 seja acionado primeiro e o sensor1 for acionado depois subtraí-se 1 do montante de pessoas. O programa funciona, porém com uma falha gravíssima.
  O loop é tão rápido que quando aciona-se o botão seguinte e a leitura é feita ele atribuí essa leitura
a duas ações diferentes, por exemplo:
 

  Se eu aciono o sensor1 e depois o sensor2 soma-se 1 ao montante, até ai tudo bem, porém quando eu aciono o sensor1 novamente a leitura do sensor 2, que concluiu o comando de soma, é atribuída a ação e o programa interpreta que houve uma outra leitura do sensor 2 antes da leitura do sensor1, assim subtraí-se um número.
Dessa forma:

Sensor 1( Ativado) - depois - Sensor 2( Ativado ) => Soma-se um.(loop) => x=1.
( a leitura do sensor2 ainda afirma que o sensor2 está comutado, mesmo depois do loop)

Caso eu acione o sensor1 o programa interpreta que:

Sensor2(Ativado, pois o houve o loop enquanto o sensor 2 está comutado) - depois Sensor1( Ativado ) => Subtraí-se um.(loop)  x = 0.
( a leitura do sensor1 ainda afirma que o sensor1 está comutado)

Caso eu resolva ativar o sensor2, depois desse erro, o programa interpreta:

Sensor 1( Ativado, pois há um loop enquanto há leitura do sensor1) - depois - Sensor 2( Ativado ) => Soma-se um.(loop) x=1.

Eu estou tentando resolver esse problema já faz algum tempo e não tive
sucesso. x.x

Se não entender, me peça o vídeo que o farei de boas :).
O programa segue ai embaixo.

 Bom dia :).


*/

#include <SevSeg.h> //biblioteca pra ver o valor contado no display de 7 segmentos.
 SevSeg sevseg;


//estou usando botões ao invés dos sensores pois só preciso do sinal de saída.
 int bot1; // "sensor 1"
 int bot2; // "sensor 2"


 unsigned long timer; //Usado para gerar números no display com períodos pré-estipulados.
 int x = 0; // váriavel que guarda o número de pessoas contadas.
 int sinaliza1 = 0;
 int sinaliza2 = 0;
 void setup(){
 sevseg.Begin(1,22,23,24,25,26,27,28,29,30,31,32,13); //pinagem do arduíno para o display
 pinMode(40,INPUT); // pino responsável pelo bot1
 pinMode(41,INPUT);// pino responsável pelo bot2
 timer=millis(); // função que auxília no controle do período de execução dos comandos.
 }
 
 void loop(){
  bot1= digitalRead(40);
  bot2= digitalRead(41);
  sevseg.PrintOutput(); // imprime um valor no display
  unsigned long mils=millis();
   if(timer-mils>=1000){ 
      timer=mils; 
      sevseg.PrintOutput();
        if(bot1==0){
        sinaliza1=1; // sinaliza que o primeiro sensor foi ativado
                        }
        if(bot2==0 && sinaliza1==1){ // se o sensor2 for ativado soma-se 1 ao montante de pessoas.
        x++;
        sinaliza1=0; //zera o flag do sensor 1
        bot2=1;
                                                 }
      if(x>100){ //valor máximo a ser atingido por essa contagem.
      x=100;
                   }
    sevseg.NewNum(x,(byte) 2); //atualiza o valor no display a partir do valor de "x". 

 

 
    bot2=digitalRead(41); // relê o sensor 2
     if(bot2==0 && sinaliza1==0){// caso o sensor2 for ativado e o sensor1 ainda não for ativado o flag       do  sensor2 será ativado.
      sinaliza2=1;
      }
        if(bot1==0 && sinaliza2==1){ // se o sensor1 for ativado e o flag do sensor2 for ativado conta-           se  menos uma pessoa ao montante total e zera-se o flag do sensor 2.
         x--;
         sinaliza2=0;
 
                                                  }
          if(x<0){ // valor minímo no programa
          x=0;
                    }
           sevseg.NewNum(x,(byte) 2); //atualiza-se o valor no display.  
 
                 }

    }      

Exibições: 2597

As respostas para este tópico estão encerradas.

Respostas a este tópico

Esse seu problema pelo qual vc veio pedir ajuda é facilmente resolvido através de flags, tipo quando o sensor 1 é acionado, vc precisaria usar uma variável auxiliar para informar ao arduino que essa variável está ligada e quando o sensor 2 for acionado em seguida, ocorre a contagem da pessoa, pois essa variável auxiliar está acionada. Logo assim que ocorrer a contagem, programe o sketch pra desligar a variável auxiliar, de forma que vc evite a contagem errada.

Portanto a contagem só ocorre quando tal variável auxiliar estiver acionada.

Mas vou complicar um pouquinho teu projeto:

como vc lidará com o cenário onde duas pessoas passam simultaneamente pela porta, sendo que uma passa pra sair e outra passa pra entrar?

e no cenário onde duas pessoas passam pela porta juntas, ao lado uma da outra, tipo um casal de namorados andando abraçados?

Percebe que do jeito que vc projetou, vc não conseguirá lidar com tais situações?

Veja um vídeo onde o carinha usou o kinect pra monitorar o trajeto das pessoas e fazer a contagem apropriada. Acho que o caminho teria que ser por aí:

 Olá, muito obrigado pela atenção! Eu já uso as flags ai no programa com os nomes "sinaliza1" e "sinaliza2".

 E quanto aos problemas de pessoas juntas e td mais, o processo onde eu quero implementar esse sistema permite margem de erro.

 Meu problema nessa sketch é no loop, pois enquanto o programa lê o sensor o loop é finalizado e há um releitura.

É como se o programa fizesse assim:

"Você acionou o sensor1 e dps o sensor2, então vou somar 1"(o loop é feito e a leitura do sensor2 ainda é feita)

quando eu ativo o sensor1 novamente ele interpreta assim :

"Você está com o sensor2 ativado e ativou o sensor1, agr vou decrementar 1".

 Muito obrigado pelo suporte! Estou pesquisando por rotinas de debounce pra ver se ajuda, se alguém tiver alguma ideia, por favor não deixe de colocar aqui.

confesso que, por pura preguiça,  não havia lido o código. Agora vi que realmente usou as flags pra sinalizar.

Mas perceba seu erro da seguinte maneira:

veja que para  if(bot2==0) vc faz análise da flag sinaliza1==0 e sinaliza1==1 em conjunto. Isso está correto

Mas e pra   if(bot1==0) ? Veja que vc faz análise da flag sinaliza2==1, mas não vi em nenhum momento vc fazer análise de sinaliza2==0. 

Vc teria que seguir a mesma lógica usada para o bot2

Ok, euheuhe.

 Vou tentar quando chegar em casa :). Obg, amigo!

Amigão, eu tentei aqui do jeito que você indicou e agr existe um problema parecido.

 Acabei de realizar uma correção de debounce com Delay eeee funcionou(viva \o/), mas eu não posso deixar o arduíno em standby como a função Delay(); faz. Eu vou tentar usar millis agora.

 Hehe muito obrigado :)

Olá imhugo, é possível contornar esse problema de outra forma, mas depende do cenário/ambiente , por exemplo existem as roleta ou catraca de ônibus, elas contam quantas pessoas passaram.

 Eu não pretendo usar uma roleta, porque é um objeto muito robusto e eu prefiro um contador mais discreto.

Mesmo assim, muito obrigado!

Dúvidas :

- O trajeto por onde passam as pessoas limita a passagem de somente uma por vez ?

- pois se o trajeto  couber mais de uma pessoa, acho que precisaria de mais sensores no sentido perpendicular aos seus sensores. Nesse caso, poderia determinar se mais de uma pessoa passou ao mesmo tempo. 

- As pessoas podem parar no trajeto do sensor ? Acredito que sim. 

 O trajeto não limita o número de passageiros por vez, porém eu admito uma margem de erro nesse projeto.

 Quando você diz sensores no sentido perpendicular, você está falando sobre sensores redundantes, não é?

 O meu objetivo é colocar esse contador em diferentes lugares, muitos aliás, então pra mim não seria bom usar mais sensores já que o custo aumentaria.

As pessoas podem parar no sensor.

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço