PIC Controle de vaga para garagem

fabiano aladin · 2 de novembro de 2021

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)

fabiano aladin · 2 de novembro de 2021

Corrigido aqui a posição dos resistores!

fabiano aladin · 3 de novembro de 2021

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);
     
   }
  

}

.if · 3 de novembro de 2021

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

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...

aphawk · 4 de novembro de 2021

@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

fabiano aladin · 5 de novembro de 2021

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

Comece estudando o funcionamento de um encoder de quadratura

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?

aphawk · 5 de novembro de 2021

@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

.if · 5 de novembro de 2021

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.

aphawk · 5 de novembro de 2021

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

.if · 6 de novembro de 2021

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

fabiano aladin · 7 de novembro de 2021

@.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);
      }

.if · 8 de novembro de 2021

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

fabiano aladin · 9 de novembro de 2021

@.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.

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.

.if · 9 de novembro de 2021

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?

.if · 9 de novembro de 2021

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

fabiano aladin · 10 de novembro de 2021

@.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.

.if · 10 de novembro de 2021

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.

fabiano aladin · 11 de novembro de 2021

@.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.

.if · 11 de novembro de 2021

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)

fabiano aladin · 21 de novembro de 2021

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);
     
   }  
}

.if · 21 de novembro de 2021

1 hora atrás, fabiano aladin disse:

uma contagem infinita

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

fabiano aladin · 21 de novembro de 2021

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.

.if · 22 de novembro de 2021

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