×
Ir ao conteúdo
  • Cadastre-se

PIC Controle de vaga para garagem


Posts recomendados

Estou  fazendo um programa   que irá fazer o controle de vagas de uma garagem , porém a mesma só possui uma única entrada e uma saída  , e onde não posso colocar um sensor para cada vaga.

Ao entrar ele decrementa uma variável e ao sair  incrementa , por enquanto estou fazendo com lâmpadas para depois fazer por display , porém não estou acertando  a lógica para reconhecer  quando entra e quando sai da garagem  e também gostaria de pedir ajuda em  como  gravar o valor desta variável na memória e caso de falta de energia .Estou usando  o c compiler e o pic 18f4520 .

#include <lamp.h>
#use fast_io(D)
#use fast_io(C)
int cont1=14;


void main()
{

   while(TRUE)
   {
      set_tris_D(0B00000000);
      set_tris_C(0B00000111);
      if(input(PIN_C0)==1)
      {
         delay_ms(100);
         cont1 = cont1--;
      }
      if(input(PIN_C2)==1)
      {
         delay_ms(100);
         if(input(PIN_C1)==1)
         {  
            delay_ms(100);
            cont1 = cont1++;
         }
      }
      if(cont1 < 14)
      {
         output_high(PIN_D0);
      }
      if(cont1 == 14)
      {
         output_high(PIN_D1);
      }
      
   }

}
                    #include <18F4520.h>


#FUSES NOWDT                    //No Watch Dog Timer
#FUSES BROWNOUT               // brownout reset
#FUSES NOLVP                    //No low voltage prgming, B3(PIC16) or B5(PIC18) used for I/O
#FUSES HS, PUT

#use delay(crystal=4MHz)

 

garagem.png

proteus.png

Link para o comentário
Compartilhar em outros sites

Como faço para a variável cont1 seja incrementada e decrementada , para eu usá-la para acionar os leds de acordo com o valor dela , para teste eu usei somente para acender  e apagar os leds , ainda não consegui alterar o valor de cont . O  lcd é só para saber  valor dela , e os displays talvez  mais tarde eu  os use , mas por enquanto  o problema maior está em fazer  a variável  decrementar ou incrementar de acordo com os sensores , os quais substituir no proteus por botões. Se alguém puder me ajudar eu agradeço muito.

#include <lamp.h>


#include <LCD8B.c>
#use fast_io(D)
#use fast_io(C)
int cont1 = 14;
int cont2 = 0;
#define sensor_1  PIN_C0
#define Sensor_2  PIN_C1
#define sensor_3  PIN_C2
void main()
{

   lcd_ini();

   while(TRUE)
   {
      set_tris_D(0B00000000);
      set_tris_C(0B00000111);
      if(input(sensor_1)==1)
      {
         delay_ms(100);
         output_high(PIN_C3);
         cont1 = cont1 --;  
      }
    if(input(sensor_1)==0)
      {
         delay_ms(300);
         output_low(PIN_C3);
         cont2 = cont1;
      }
    if(input(sensor_3)==1)
      {
         if(input(sensor_2)==1)
          {
            delay_ms(300);
            output_high(PIN_C4);
            cont1 = cont1 ++;
          }
      }
     if(input(sensor_3)==0)
      {
         delay_ms(300);
         output_low(PIN_C4);
      }
      cont2 = cont1;
     delay_ms(200);
     printf(lcd_escreve,"\f %u",cont2);
     
   }
  

}

 

lamp_a.png

lamp_b.png

lamp_c.png

lamp_d.png

  • Curtir 1
Link para o comentário
Compartilhar em outros sites

  • Membro VIP
Em 02/11/2021 às 12:30, fabiano aladin disse:

a lógica para reconhecer  quando entra e quando sai da garagem

Comece estudando o funcionamento de um encoder de quadratura

sitesexta11.png

https://mokka-contadores.com.br/encoders-de-quadratura-mokka/

 

Em 02/11/2021 às 12:30, fabiano aladin disse:

Ao entrar ele decrementa uma variável e ao sair  incrementa

O macete é colocar os sensores de tal forma que os sinais fiquem defasados em 90º

 

Já fiz algo do gênero certa feita. Se algum dia achar o fonte... talvez publique...🤪

Link para o comentário
Compartilhar em outros sites

  • Membro VIP

@fabiano aladin ,

 

Posso apenas lhe passar alguns insights :

 

Os Pics possuem uma certa quantidade possível de regravações na EEPROM, depois elas podem falhar. Então seria bem interessante você saber quando que a energia irá falhar e gravar esse dado apenas nesse instante.

 

Eu usei muito um truque de colocar dois diodos em série antes do regulador de 5V , e na junção deles eu usava um eletrolítico de valor baixo e um divisor resistivo com um trim-pot. Na entrada do regulador de 5V tinha um outro eletrolítico de valor bem maior.

Assim, quando a tensão falhava, ela caía antes nesse divisor, e gerava o nível 0 na entrada do microcontrolador, que gerava uma interrupcão, e imediatamente eu salvava tudo o que me interessava e ficava no aguardo durante 3 segundos. Caso a tensão voltasse antes de o capacitor principal na entrada do regulador cair muito a tensão, eu voltava ao processamento normal. Senão, ocorria o reset e assim na volta da energia eu verificava se havia havido uma queda e nesse caso repunha os valores.

 

Paulo

 

 

 

  • Curtir 1
Link para o comentário
Compartilhar em outros sites

Em 03/11/2021 às 18:20, .if disse:

Comece estudando o funcionamento de um encoder de quadratura

sitesexta11.png

https://mokka-contadores.com.br/encoders-de-quadratura-mokka/

 

O macete é colocar os sensores de tal forma que os sinais fiquem defasados em 90º

 

Já fiz algo do gênero certa feita. Se algum dia achar o fonte... talvez publique...🤪

Entendi o conceito , porém não sei como  pôr em prática e nem como  fazer o programa.

 

14 horas atrás, aphawk disse:

@fabiano aladin ,

 

Posso apenas lhe passar alguns insights :

 

Os Pics possuem uma certa quantidade possível de regravações na EEPROM, depois elas podem falhar. Então seria bem interessante você saber quando que a energia irá falhar e gravar esse dado apenas nesse instante.

 

Eu usei muito um truque de colocar dois diodos em série antes do regulador de 5V , e na junção deles eu usava um eletrolítico de valor baixo e um divisor resistivo com um trim-pot. Na entrada do regulador de 5V tinha um outro eletrolítico de valor bem maior.

Assim, quando a tensão falhava, ela caía antes nesse divisor, e gerava o nível 0 na entrada do microcontrolador, que gerava uma interrupcão, e imediatamente eu salvava tudo o que me interessava e ficava no aguardo durante 3 segundos. Caso a tensão voltasse antes de o capacitor principal na entrada do regulador cair muito a tensão, eu voltava ao processamento normal. Senão, ocorria o reset e assim na volta da energia eu verificava se havia havido uma queda e nesse caso repunha os valores.

 

Paulo

 

 

 

Obrigado pela dica. Vou usar  botões para decremento e incremento .

#include <lamp.h>
#include <LCD8B.c>
#use fast_io(D)
#use fast_io(C)
int cont1 = 14;
#define sensor_1  PIN_C0
#define Sensor_2  PIN_C1
#define sensor_3  PIN_C2
void main()
{

   lcd_ini();

   while(TRUE)
   {
      set_tris_D(0B00000000);
      set_tris_C(0B00000111);
      if((input(sensor_1)==1) && (input(sensor_3)==0))
      {
         delay_ms(100);
         output_high(PIN_C3);
         cont1 = cont1 --;  
      }
    if(input(sensor_1)==0)
      {
         delay_ms(300);
         output_low(PIN_C3);
      }
    if((input(sensor_3)==1) && (input(sensor_1)==0))
      {
         if(input(sensor_2)==1)
          {
            delay_ms(300);
            output_high(PIN_C4);
            cont1 = cont1 ++;
          }
      }
     if(input(sensor_3)==0)
      {
         delay_ms(300);
         output_low(PIN_C4);
      }
     delay_ms(200);
     printf(lcd_escreve,"\f %u",cont1);    
   }
}

Estou com 2 problemas como fazer o programa entender quem está entrando e quem está saindo , de maneira correta .

E não consigo  fazer com que a variável cont1 incremente ou decremente.Fiz as Alterações porém estão longe de serem solucionadas.

Para armazenar valores na variável cont1 eu devo criar interrupção?

  • Triste 1
Link para o comentário
Compartilhar em outros sites

  • Membro VIP

@fabiano aladin ,

 

Em todo programa que uso encoder, eu uso no mínimo uma interrupção em um dos sinais.

Nunca ví um programa que trata esse tipo de encoder sem interrupção.... eu fiz uma rotina em Assembler que é uma maravilha,  mas como você está usando C, existem librarys montadas para te facilitar isso ok ?

 

Paulo

 

 

Link para o comentário
Compartilhar em outros sites

  • Membro VIP

Apesar de sua gratidão ter sido direcionada apenas a Paulão, vou quebrar seu galho e te dar o exemplo que fiz há décadas

//identifica direção e retorna 1 prum lado, 2 pro outro e 0 se parado
#define pa		RA6
#define pb		RA5
unsigned char ret,port,port0;
static bit a,b,a0,b0;
unsigned char decode()
{
a=pa;b=pb;
port=PORTA&0b1100000;
if (port^port0)	//comparar leitura atual c/anterior
	{
	if (!a0 & a)	{ //bit A mudou de 0 para 1
			if  (!b) ret=1; //bit B = 0:direita
		       	else ret=2;	//bit B = 1:esquerda
			}
	if (a0 & !a)	{ //bit A: 1 para 0
			if (b) ret=1;	// B em 1:direita
			else ret=2;	// B em 0:esquerda
			}
	if (!b0 & b)	{ //bit B: 0 para 1
			if (!a) ret=2;	// A em 0:esquerda
			else ret=1;	// A em 1:direita
			}	
	if (b0 & !b)	{ //bit B: 1 para 0
			if (a) ret=2;	// A em 1:esquerda
			else ret=1;	// A em 0:direita
			}
	}
else ret=0;	
a0=pa;b0=pb;
port0=PORTA&0b1100000;
return ret;
} 

void main()
{
//unsigned char pa;
TRISA=0b11111111;
TRISB=0b00000000;

for (;;)
{
PORTB=decode();
}


}	

Obviamente o hw deve estar preparado e fornecendo os sinais defasados.

 

6 horas atrás, aphawk disse:

fiz uma rotina em Assembler que é uma maravilha

A rotina acima foi feita originalmente em asm 51🙂

 

6 horas atrás, aphawk disse:

Nunca ví um programa que trata esse tipo de encoder sem interrupção

Agora viu 😁. Mas ela deve estar dentro do loop. De fato se usar interrupt fica mais melhor de bão pois obriga o hw a trabalhar e libera o sw. O garoto pode até usar o recurso de interrupt por mudança de estado dos ports e meu exemplo pra este propósito...(não detalho)

 

6 horas atrás, aphawk disse:

existem librarys montadas para te facilitar isso

E sem lib complexa que aliás desconheço🙃

 

Em 04/11/2021 às 09:06, aphawk disse:

quando a tensão falhava, ela caía antes nesse divisor, e gerava o nível 0 na entrada do microcontrolador, que gerava uma interrupcão, e imediatamente eu salvava tudo o que me interessava e ficava no aguardo durante 3 segundos. Caso a tensão voltasse antes de o capacitor principal na entrada do regulador cair muito a tensão, eu voltava ao processamento normal. Senão, ocorria o reset e assim na volta da energia eu verificava se havia havido uma queda e nesse caso repunha os valores.

Em total sintonia com o amigo Paulão, fiz algo simplesmente quase idêntico no passado com pic mas com zero trimpot - usei dado da eeprom como 'ajuste'. .. uma rotininha de ajuste. E há pouco tempo atrás dei uma evoluída com a mesma coisa num stm32xxx mas neste usei seu comparador e também zero trimpot.🙂. O desafio foi que este mc não tem eeprom mas sim  com uma rebolada dá pra usar sua flash como tal .. usei. 😉

Link para o comentário
Compartilhar em outros sites

  • Membro VIP
14 minutos atrás, .if disse:

Agora viu 😁. Mas ela deve estar dentro do loop

 

Ahhhhhh simmmmmm kkkkkk esse é o problema, o programa tem de ficar esperando pelo encoder, e não pode fazer outra coisa até terminar os giros e o usuário encerrar a operação via botão ou apertando o próprio encoder usando o outro pino dele .....

 

Já por interrupção eu sinalizo num flag que teve movimento, e em uma variável inteira se foi para a esquerda ou para a direita, tudo mastigadinho pro loop principal hehehe !

 

17 minutos atrás, .if disse:

Em total sintonia com o amigo Paulão, fiz algo simplesmente quase idêntico no passado com pic mas com zero trimpot - usei dado da eeprom como 'ajuste'. .. uma rotininha de ajuste.

 

Eu usei o trimpot para facilitar a mudança de 1 para 0 e não complicar a rotina de interrupção .

Hoje faria diferente, usaria o comparador também ..... mas quando fiz isso foi em 1985 com um hardware Z-80 ....

 

Paulo

 

 

Link para o comentário
Compartilhar em outros sites

  • Membro VIP
13 horas atrás, aphawk disse:

o programa tem de ficar esperando pelo encoder, e não pode fazer outra coisa até terminar

não necessariamente. A cada passada ele avalia se houve mudança de estado. Mas nem percamos tempo com isso pois ...

14 horas atrás, .if disse:

usar interrupt fica mais melhor de bão

 

13 horas atrás, aphawk disse:

trimpot para facilitar a mudança de 1 para 0 e não complicar a rotina de interrupção

em outras palavras...  preguiça 😁. No meu (meu) caso a redução de custo nem se comparou à adrenalina como agente motivador 🤪

 

13 horas atrás, aphawk disse:

foi em 1985 com um hardware Z-80 ....

Meu avô me falava mesmo dele 😂

  • Haha 1
Link para o comentário
Compartilhar em outros sites

@.if Obrigado também e desculpe não ter agradecido antes.

Pelo método de encoder de quadradura  não vai ser possível para eu posicionar os sensores de maneira que fique em 90° defasados os pulsos um do outro , achei uma solução  que a princípio parece que resolveu a parte dos sensores , vou testar mais vezes e depois fazer uma maquete.

Mas estou com problemas para a variável , já que preciso dela para saber a quantidade de vagas disponíveis , não consigo incrementar e nem decrementá-la pensei em usar  interrupção externa , mas acho que o programa que fiz  não funcionaria  com interrupção.Talvez eu esteja declarando  e colocando a  variável em lugar errado . Tentei usar o output_drive e output_float , porém não funcionou , não sei se foi por eu ter setado antes as saídas e entradas das portas.

Se puder me ajudar  na parte da variável eu agradeço. 

Vão entrar mais dois sensores  para vagas especiais .Portanto deverei utilizar mais uma variável para essas duas vagas , como  os sensores podem ser colocados na vaga parece q vai dá menos trabalho, só terei que  diminuir ou aumentar  no total de vagas gerais , já que a entrada e saída são únicas  para as vagas comuns e especiais.

#include <lamp.h>
#include <LCD8B.c>
#use fast_io(D)
#use fast_io(B)
int cont1;
#define sensor_1  PIN_B0
#define Sensor_2  PIN_B2
#define sensor_3  PIN_B1
void main()
{
   lcd_ini();
   while(TRUE)
   {
     set_tris_D(0B00000000);
     set_tris_B(0B00000111);
     if((input(sensor_1)==1) && (input(sensor_3)==0))
      {
         delay_ms(100);
         output_high(PIN_B6);
         cont1 = cont1 ++ ;
         //output_drive(sensor_3);
         delay_ms(10000);
         //output_float(sensor_3);
      }

 

ckt_1.png

Link para o comentário
Compartilhar em outros sites

  • Membro VIP
13 horas atrás, fabiano aladin disse:

uma solução  que a princípio parece que resolveu a parte dos sensores

Fale mais sore tal solução ou seja a parte física mesmo entende? Sobre isso, teorizei um sensor de aproximação especial: ele sente se está vindo ou indo. Claro só um conceito teórico e teoricamente factível com peças que 'temos em casa'

Ainda não consegui entender totalmente sua dúvida. Talvez depois de explicar (e eu entender) a física da coisa e tal possamos dar alguns passos na direção do sucesso.

Aliás ... 1.jpg>1k.txt ... mensagem subliminar 🤪

Link para o comentário
Compartilhar em outros sites

@.if Boa noite.

É um ckt para mostrar  vagas em uma garagem com uma única entrada e saída , onde pessoas passam pelo canto , a mesma possui 14 vagas comuns e 2 especiais.

- Os sensores devem diferenciar quem está saindo e quem está entrando (problema resolvido através de delays  ), tentei resolver por output_drive e output_float mas deste jeito não funcionou.

- Preciso de 2 variáveis  para incrementar e decrementar vagas comuns e vagas especiais , como possui uma entrada e uma saída , são 2 sensores para todos q entrarem na garagem e dois sensores em cada vaga especial , por tanto  tenho que fazer  caso exista a diferença de todas as vagas e as vagas especiais.

- os sensores ficarão no teto  da garagem pegando os veículos pelo meio  assim não pego as pessoas que entrarem  pelos cantos.Por tanto o encoder de enquadradura não seria possível neste caso .

- Os sensores das vagas especiais ficarão  no local  para acionarem assim q algum carro  ocupá-las.

- será necessário botões para incrementar e decrementar vagas comuns e para vagas especiais, para caso de faltar energia elétrica ou acontecer algum problema.

- Não estou conseguindo  incrementar e decrementar as variáveis , talvez seja erro  de e onde declara-las.

- Para indicar se possui vaga ou não  , tentarei usar  display gigante(mas não encontrei ainda onde comprá-los), lâmpadas ou aqueles letreiros  luminosos que existem em muitas lojas (porém este último eu nem imagino como fazer).

- Não sei se  usar interrupção externa para  alterar os valores das  variáveis vai resolver também o problema de incrementar e decrementar  pelos botões.

Como eu disse anteriormente parece que consegui resolver( de maneira simples e nem sei se na prática vai realmente  funcionar) o problema dos sensores que devem reconhecer quem entra e quem sai .

Acho que é tudo !!!!!

E obrigado pela ajuda.

 

 

 

 

garagem.png

14 horas atrás, .if disse:

Fale mais sore tal solução ou seja a parte física mesmo entende? Sobre isso, teorizei um sensor de aproximação especial: ele sente se está vindo ou indo. Claro só um conceito teórico e teoricamente factível com peças que 'temos em casa'

Ainda não consegui entender totalmente sua dúvida. Talvez depois de explicar (e eu entender) a física da coisa e tal possamos dar alguns passos na direção do sucesso.

Aliás ... 1.jpg>1k.txt ... mensagem subliminar 🤪

Obs.: os diodos nos sensores foram só para tentar resolver  com output_drive e output_float(assim o sinal não passaria da porta para o sensor em caso de alterar de entrada para saída) . Os dois leds que coloquei foram para só indicar se s sensores ativaram  quando devia e quando não deviam.

Link para o comentário
Compartilhar em outros sites

  • Membro VIP

Pensando bem, penso que você precisa apenas saber se tem ou não carro na vaga. Ou seja a informação é apenas 1 bit por vaga. 14 + 2 especiais são 16 = o exato tamanho de um int. voce pode até fazer algo complexo e elegante com as sinistras entidades do c struct e union e seus campos de bits mas não sei se é seu momento.

Por hora, caso concorde com a teoria acima, veja isso...
 

unsigned int v=0;
unsigned char i;
for (i=0;i<16;i++) if (sensor(i)) v|=1<<i; 
//a rotina sensor() retorna 1 se tem carro e 0 se não.. por sua conta

depois pra saber quantas vagas tem, basta contar o números 1 que tem em v

unsigned char vaga=0,i;
for (i=0;i<16;i++) if (v&1<<i) vaga++;

No fim você vai ter duas informações

v=posição das vagas em seus bits

vaga=número de vagas usadas

Obviamente não testei as funções acima e nem sei se entendi direito seu dilema ok?

Link para o comentário
Compartilhar em outros sites

  • Membro VIP

Bem... pelo seu desenho achei que é um conjunto daquele pra cada vaga...

 

Mas se for só sensor de passagem porquê você acha que o minimalismo...
 

unsigned char vaga;
if (entrando()) //sua função que detecta carro entrando
vaga++;

if (saindo()) //sua função que detecta carro saindo
vaga--;

não funciona?

12 horas atrás, fabiano aladin disse:

Não estou conseguindo  incrementar e decrementar as variáveis , talvez seja erro  de e onde declara-las.

 

O saber do uso de interrupção externa não tem relação com seu dilema. você precisa primeiro definir o algoritmo de incremento e decremento da 'vaga'. Sendo que o pulo do gato são as funções entrando() e saindo() cujo princípio de funcionamento do encoder de quadratura poderia sim te ser trocadilhamente uma mão na roda.

 

12 horas atrás, fabiano aladin disse:

consegui resolver( de maneira simples e nem sei se na prática vai realmente  funcionar) o problema dos sensores que devem reconhecer quem entra e quem sai .

Neste caso já tem a faca e o queijo na mão🙂

Link para o comentário
Compartilhar em outros sites

@.if A garagem  possui só uma abertura que se destina para  entrada e saída de veículos para todas as vagas , então  serão 3 sensores no teto da entrada/saída e mais sensores para vagas especiais , com a entrada é única então  devo ter  uma variável para o total de carros que se encontram ainda na garagem , e desse total deve verificar se tem e quantas  vagas especiais ocupadas, já que não tem como na entrada identificar quem é vaga especial ou vaga comum  . Como as vagas especiais possuem sensores nelas, é só fazer  a diferença dessas vagas ocupadas com o total de carros que entraram e não saíram.

Então preciso de variáveis  para armazenar  o total de vagas comuns    e  vagas  especiais (idosos ou de  deficientes) ocupadas.

Ao todo são 14 vagas comuns e 2 vagas especiais (sendo que as especiais terão sensores nelas  ,as vagas comuns será a diferença  entre  número de veículos q entraram e não saíram da garagem e as vagas especiais ocupadas.

Aparentemente consegui resolver o problema  dos sensores , agora eles reconhece  quem está entrando e quem está saindo , já que passam pelo mesmo lugar .

No programa não fiz ainda os botões de incremento e decremento das vagas comuns e das vagas especiais , porque estou tendo dificuldade em  fazer a variável cont_1 decrementar e incrementar  valores.

Pensei em fazer  cont_1 incrementar/decrementar valores dentro da interrupção externa , vindo  do sensores como tem ainda os botões para incremento/decremento,teria q usar várias portas B's como interrupção externa.

Não criei as funções ainda porque não consegui acertar  as variáveis.

vou colocar o  programa aqui  e me diga como  usar a variável cont_1 de maneira correta   porque se eu acertar uma as outras seguirão o mesmo processo, tentei inicializá-la com valores e não funcionou. Só quero incrementar/decrementar  as variáveis  todas as vez que os sensores forem ativados e também os botões de incremento/decremento.

Exemplo : sensor_1 (entrada/saída da garagem) = decrementa a variável cont_1;

sensor_2 , sensor_3 (entrada/saída da garagem) = incrementa variável cont_1;

sensor_4 , sensor_5 vagas especiais ou de idosos) = incrementa/decrementa variável cont_2;

botão 1 = decrementa a variável cont_1;

botão 2 = incrementa variável cont_1;

botão 3 = decrementa a variável cont_2;

botão 4 = incrementa variável cont_2;

cont_3 = cont_1 - cont _2;

 número de vagas de idosos  é de "cont_2"

número de vagas comuns é de "cont_3"

Obrigado pela ajuda!!!

 

Só falta por enquanto resolver o problema da variável!!!!

#include <lamp.h>
#include <LCD8B.c>
#use fast_io(D)
#use fast_io(B)
int cont_1;
#define sensor_1  PIN_B0
#define Sensor_2  PIN_B2
#define sensor_3  PIN_B1
void main()
{
   lcd_ini();
   while(TRUE)
   {
     set_tris_D(0B00000000);
     set_tris_B(0B00000111);
     if((input(sensor_1)==1) && (input(sensor_3)==0))
      {
         delay_ms(100);
         output_high(PIN_B6);
         cont_1 = cont_1 ++ ;
         //output_drive(sensor_3);
         delay_ms(10000);
         //output_float(sensor_3);
      }
    if(input(sensor_1)==0)
      {
         delay_ms(100);
         output_low(PIN_B6);
      } 
    if((input(sensor_3)==1) && (input(sensor_1)==0))
      {
         if(input(sensor_2)==1)
          {
            delay_ms(100);
            output_high(PIN_B7);
            cont_1 = cont_1 -- ;
            //output_drive(sensor_1);
            delay_ms(10000);
            //output_float(sensor_1);
          }   
      }
    if(input(sensor_3)==0)
      {
         delay_ms(100);
         output_low(PIN_B7);
      }
     delay_ms(200);
     printf(lcd_escreve,"\f %u",cont_1);
     
   }  
}

Fiz o programa só para testar  , mas não consigo  com que a variável acumule os valores.

Link para o comentário
Compartilhar em outros sites

  • Membro VIP
7 horas atrás, fabiano aladin disse:

tendo dificuldade em  fazer a variável cont_1 decrementar e incrementar  valores.

Então seu dilema é bem básico. Pra incrementar e decrementar basta fazer variavel++ ou variavei--

if((input(sensor_1)==1) && (input(sensor_3)==0))
      {
         delay_ms(100);
         output_high(PIN_B6);
         cont_1 ++ ; //<<<<<<<<<<---
         //output_drive(sensor_3);
         delay_ms(10000);
         //output_float(sensor_3);
      }

Me diga onde e como está vendo a variavel cont_1 e o que você vê em

7 horas atrás, fabiano aladin disse:
printf(lcd_escreve,"\f %u",cont_1);

o que esta função faz?

E não te esqueças de tratar valores negativos

 

7 horas atrás, fabiano aladin disse:

fazer  cont_1 incrementar/decrementar valores dentro da interrupção externa , vindo  do sensores como tem ainda os botões para incremento/decremento,teria q usar várias portas B's como interrupção externa.

melhor resolver a questão do software pra depois se embrenhar no mundo do hardware...

 

7 horas atrás, fabiano aladin disse:

as vagas especiais possuem sensores nelas, é só fazer  a diferença dessas vagas ocupadas com o total de carros que entraram e não saíram.

nisso não posso opinar pois desconheço como tais informações são tratadas.

Link para o comentário
Compartilhar em outros sites

@.if A função abaixo , é só para eu saber os valores da variável agora no teste, através desta função eu sei que não está havendo decremento e incremento .

printf(lcd_escreve,"\f %u",cont_1);

Aparece no  lcd a variável cont_1 com valor zero , mesmo  quando  é incrementado  através dos botões .

Em 09/11/2021 às 11:07, .if disse:

Bem... pelo seu desenho achei que é um conjunto daquele pra cada vaga...

 

Mas se for só sensor de passagem porquê você acha que o minimalismo...
 

unsigned char vaga;
if (entrando()) //sua função que detecta carro entrando
vaga++;

if (saindo()) //sua função que detecta carro saindo
vaga--;

não funciona?

 

O saber do uso de interrupção externa não tem relação com seu dilema. você precisa primeiro definir o algoritmo de incremento e decremento da 'vaga'. Sendo que o pulo do gato são as funções entrando() e saindo() cujo princípio de funcionamento do encoder de quadratura poderia sim te ser trocadilhamente uma mão na roda.

 

Neste caso já tem a faca e o queijo na mão🙂

Eu tentei usar  o q você  usou de exemplo aí em vaga++ , porém  não foi alterado os valores na variável .Não sei se estou errando em declarar a variável.

Obrigado pela ajuda.

Link para o comentário
Compartilhar em outros sites

  • Membro VIP

Talvez você esteja errando na formatação no printf por isso perguntei o que a função faz. Dei uma googlada rápida mas como é específica do ccs e não c puro, não foquei direito. Consulte seu manual. Tente escrever outra coisa variável no display e com outros formatos. Dizem que o ccs é cheio de bugs. Por fim, tente ver a variável no seu ambiente IDE. Provavelmente existe algum campo algo como view variables ou do gênero.

2 horas atrás, fabiano aladin disse:

Não sei se estou errando em declarar a variável

Tente unsigned char (0 a 255) ou unsigned int (0 a 65535)

Link para o comentário
Compartilhar em outros sites

  • 2 semanas depois...
Em 11/11/2021 às 00:56, .if disse:

Talvez você esteja errando na formatação no printf por isso perguntei o que a função faz. Dei uma googlada rápida mas como é específica do ccs e não c puro, não foquei direito. Consulte seu manual. Tente escrever outra coisa variável no display e com outros formatos. Dizem que o ccs é cheio de bugs. Por fim, tente ver a variável no seu ambiente IDE. Provavelmente existe algum campo algo como view variables ou do gênero.

Tente unsigned char (0 a 255) ou unsigned int (0 a 65535)

Este problema já consegui resolver , decrementou e incrementou conforme o esperado , porém como possui 2 vagas especiais que devem deve ser contabilizadas separadas ( mesmo possuindo uma única entrada  que também é a saída ), para isso usei 1  variável  para todos que entram na garagem , e uma em cada uma das 2 vagas especiais.Para isso usei algo do tipo : cont_vaga = cont_geral - cont_idoso, só que apresenta uma contagem infinita  de ambas variáveis(cont_vaga,cont_idoso).

int cont_idoso = 2;
int cont_geral = 16;
int cont_comum = 14;
unsigned int entra_idoso() 
   {
      cont_idoso = cont_idoso - 1;
      return cont_idoso;
   }
unsigned int sai_idoso()
   {
      cont_idoso = cont_idoso + 1; 
      return cont_idoso;
   }
void quant_vaga ()
   {
      if(cont_comum == 14)
       {
         output_high(PIN_B6);
       }
    if(cont_comum < 14)
       {
         output_high(PIN_B7);
       }
     if(cont_idoso == 2)
      {
        output_high(PIN_B5); 
      }
     else if(cont_idoso < 2)
      {
         output_high(PIN_B4);
      }   
   }

#use fast_io(D)
#use fast_io(B)
#use fast_io(A)



void main()
{
   lcd_ini();
   while(TRUE)
   {
     set_tris_D(0B00000000);
     set_tris_B(0B00000111);
     set_tris_A(0B00001100);
     if((input(sensor_1)==1) && (input(sensor_3)==0))
      {
         delay_ms(100); 
         cont_geral = cont_geral - 1 ;   
         delay_ms(10000);         
      }
    if(input(sensor_1)==0)
      {
         delay_ms(100);
         output_low(PIN_B6);
      } 
    if((input(sensor_3)==1) && (input(sensor_1)==0))
      {
         if(input(sensor_2)==1)
          {
            delay_ms(100);
            cont_geral = cont_geral + 1 ;
            delay_ms(10000);
          }   
      }

    if(input(sensor_idoso_1)==0)
      {
          delay_ms(100);
          entra_idoso();
      }
    if(input(sensor_idoso_1)==1)
      {
         delay_ms(100);
         sai_idoso();
      }
    if(input(sensor_idoso_2)==0)
      {
         delay_ms(100);
         entra_idoso();
      }
    if(input(sensor_idoso_2)==1)
      {
         delay_ms(100);
         sai_idoso();
      }
     cont_comum = cont_geral - cont_idoso;
     quant_vaga();
    
     delay_ms(50);
     printf(lcd_escreve,"\f vaga comum :%u\n vaga idosos: %u",cont_comum,cont_idoso);
     
   }  
}

 

Link para o comentário
Compartilhar em outros sites

21 minutos atrás, .if disse:

😁

Mostre o resultado ou numero que aparece...Tenta tratar número negativo como te disse.

if (vaga<0) vaga=0; //ou algo do gênero

 

Vaga comum aumenta em velocidade em maior , indo de 0 à 255, já vaga idoso  decrementa em velocidade menor indo de 25 à 0 de maneira cíclica. Fica neste loop direto. Os botões sensores fazem até decrementar e incrementar, porém não sai do loop infinito.

Link para o comentário
Compartilhar em outros sites

  • Membro VIP
13 horas atrás, fabiano aladin disse:

Vaga comum aumenta em velocidade em maior , indo de 0 à 255, já vaga idoso  decrementa em velocidade menor indo de 25 à 0 de maneira cíclica. Fica neste loop direto. Os botões sensores fazem até decrementar e incrementar, porém não sai do loop infinito.

Acho que te falta como entender como seu próprio hardware opera pra deixar o software coerente com ele. P.ex. penso que seu sistema tem que ficar parado e aguardar um movimento de carro passando pra fazer alguma coisa. Algo como

while(sensor1 && sensor3 && sensor_idoso); //fica parado aqui até algum evento ocorrer

Obviamente não é a exata condição acima. Só lhe foi 1 norte. Outra opção (menos desinteligente) é fazer o sistema (hw) causar uma interrupção por mudança de estado dos pinos. Algo como se mudar o estado da entrada, o loop principal é interrompido e vai pra uma determinada função que avalia os estados dos pinos pra fazer as contagens incrementais ou decrementais. Por gentileza queira pesquisar sobre interrupt para o seu compilador e mc ok?

 

Dica: faça desenhos e esquemas ou até mesmo fluxogramas

Link para o comentário
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisa ser um usuário para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora

Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas comunidades sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×
×
  • Criar novo...

Como ganhar dinheiro montando computadores!

MINICURSO GRÁTIS!

Como ganhar dinheiro montando computadores!

CLIQUE AQUI E INSCREVA-SE AGORA MESMO!