Pelo amor de Deus, parem de ficar enchendo minha caixa de entrada com pergunta sobre esse maldito e velho encoder.
O Projeto que eu coloquei em ASM, funciona, mais não ia colocar nada de mão beijada, mais se for para pararem de me mandar e-mail´s sobre esse maldito, pararem de ficar me add no msn por causa desse mala.
Segue projeto completo em C, Por favor, não perguntem nada, se não souber programar em C, perguntem aqui, ou simplesmente não se meta com isso logo de cara.
XTAL 20MHZ, para utilizar outros, leiam os comentários.
Main CODE
- Código: Selecionar todos
#include "makros.c"
#include "drive_ht6p20.c"
//***********************variaveis do sistema*******************
unsigned char newdata;
long data2;
unsigned char dados_hex[12];
unsigned char dados_hex2[9];
//*********************** pega hex de uma long******************
void pegahex(unsigned short *varlong, char *arraybytes){
unsigned short num = 4, temp=0;
arraybytes = arraybytes + 8;
*arraybytes = '\0';
arraybytes--;
while(num){
temp = *varlong;
temp &= 0x0f;
if(temp<=9)
temp = temp + '0';
else
temp = temp + ('A'-10);
*arraybytes = temp;
arraybytes--;
temp = *varlong;
temp = (temp >> 4) & 0x0f;
if(temp<=9)
temp = temp + '0';
else
temp = temp + ('A'-10);
*arraybytes = temp;
arraybytes--;
varlong++;
num--;
}
}
//***********************inicialização do sistema***************
void init_sistem(void){
trisa = 0xff;
porta = 0x00;
trisb = 0x00;
portb = 0x00;
trisc = 0x00;
portc = 0x00;
trisd = 0x00;
portd = 0x00;
//rs,en,rw,b7,b6,b5,b4
Lcd_Config(&PORTD, 0, 2, 1, 7, 6, 5, 4);
delay_ms(10);
Lcd_Out(1, 1, "receiver");
}
//*********************** vetor de interrupção******************
void interrupt(void){
intcon.gie = 0; // desliga gie por precaução
intcon.inte = 0; // desliga int rb0 por precaução
if(intcon.intf){// se int rb0
if(receive_ht6p20()){ // se recebeu algo !!
newdata = 0xff;
}else{
newdata = 0;
}
}
intcon.intf = 0; // limpa flag de indicação de interrupt
intcon.inte = 1; // liga flag de int RB0 borda de descida
intcon.gie = 1; // obrigatório ligar o global interrupr
}
//***************** main principal-------------------//
void main(void){
init_sistem();
init_ht6p20();
while(1){
if(newdata){ //recebeu algo ?
intcon.gie = 0;
newdata = 0;
data2 = data;
longtostr(data,dados_hex);
Lcd_Out(2, 1, dados_hex);
delay_ms(5);
pegahex(&data2,&dados_hex2[0]);
Lcd_Out(3, 1, dados_hex2);
intcon.gie = 1;
}
}
}
INCLUDE DO DECODER
- Código: Selecionar todos
//////////////////desc drive_ht6p20.c//////////////////////////////////
// FUNÇÃO : decodificação de controle ht6p20
// PROCEDIMENTO : faz leitura por interrupção
// : retorna 0xff para ok e 0x00 para erro
// PARÃMETRO : nenhum
// RETORNO : 1 byte boolean
// ULTIMA EDIÇÃO : 18-03-09
// OBS : utiliza variavel de 32 bits para guardar
// : código recebido
/////////////////////////////////////////////////////////////////////////
#include "makros.c"
////////////////////////////////////////////////////////////////////////////////
// FUNÇÃO : definição de makros e constantes do sistema
// PARÃMETRO : flag´s para controle de timer 16bits
// RETORNO : nenhum
// ULTIMA EDIÇÃO : 18-03-09
// OBS : pode haver diferença nos nomes de uC para outro
////////////////////////////////////////////////////////////////////////////////
#define inpcode portb.f0 // entrada de RF
#define lig_tmr T1CON.TMR1ON //on/off timer1
#define est_tmr PIR1.F0 // flag de estouro de timer0
#define clr_tmr PIR1 &= 0b11111110 // o mesmo
#define error 0x00 // se erro = false
#define recebido 0xff // se ok = true
unsigned const int tmp_10ms = 50000;
//*********** variavel onde fica o dado recebido**********
unsigned long data; //*
//********************************************************
////////////////////////////////////////////////////////////////////////////////
// FUNÇÃO : inicialização de perifericos para utilizar timer1
// PROCEDIMENTO : configura SFR´s para rotina decoder
// PARÃMETRO : nenhum
// RETORNO : nenhum
// ULTIMA EDIÇÃO : 18-03-09
// OBS : pode ser inserido outras config´s
////////////////////////////////////////////////////////////////////////////////
void init_ht6p20(void){
TRISB |= 0B00000001;
//faz portb0 como entrada
T1CON = 0B00000100;
//prescaler 1:1 // oscilador tmr1 desligado
//sincronização externa desligada
//incremento Fosc/4 interno
//tmr1 deligado
OPTION_REG = 0B10000000;
//pull-ups desligado portb // intRB0 borda de descida
CCP1CON = 0b00000000;
//TMR1 sem aplicação especifica utilizando como tmr apenas
INTCON = 0B10010000;
//liga intRB0
PIE1 = 0B00000000;
}
////////////////////////////////////////////////////////////////////////////////
// FUNÇÃO : decodificação de codigo padrão ht6p20
// PROCEDIMENTO : faz leitura de pino rb0 int low, uso de timer
// PARÃMETRO : nenhum
// RETORNO : retorna 1 boolean// se recebido 0xff se não 0x00
// ULTIMA EDIÇÃO : 18-03-09
// OBS : variavel com 22 + 2 + 4 bits apenas externo
////////////////////////////////////////////////////////////////////////////////
short receive_ht6p20(void){
// variaveis do sistema de recepção
short nbits=24;
short inperr, tmrerr;
unsigned int timeb, timec, temptime, geral, tempTE;
//********************************************************
// detecção de sincronismo em low >10mS e <13mS
// 1 frame //
//compara sincronismo XXXXXXX| |´´´|
// XXXXXXX|____________________| |__
if(inpcode){ // tem que ser 0, pois borda de descida
return(error);// se entrada 1 = erro.
}else{
data = 0;
lig_tmr = 0;
clr_tmr;
tmr1h = 0;
tmr1l = 0;
lig_tmr = 1;
while((!inpcode)&&(!est_tmr));
lig_tmr = 0;
if(est_tmr){clr_tmr; return(error);} // se estourou 13mS
// então erro
// tempo máximo para estouro do tmr1 é de 13ms em 20mhz
// sendo assim o teste a baixo verifica o seguinte
// se sinal foi para um e o tempo em zero foi maior que 10ms
// então sincronismo ok, se nao ele sai pois foi erro
unihi(tempTE, tmr1h);// MSB -converte tmr1 em int para teste
unilo(tempTE, tmr1l);// LSB -converte tmr1 em int para teste
if((inpcode)&&(tempTE > tmp_10ms)){ // se inpdata 1 e não estourou ok!
//********************************************************
// 1 frame ( TE ) captura TE referencia
// XXXXXXX| entre 10 e 13ms |´´´|
// XXXXXXX|____________________| |
tmr1h = 0;
tmr1l = 0;
lig_tmr = 1;
while((inpcode)&&(!est_tmr)); //captura 1TE bit sinc 1/3 bit inteiro
lig_tmr = 0;
if((!inpcode)&&(!est_tmr)){// se inprf = 0 e não estourou
unilo(timeb, tmr1l);
unihi(timeb, tmr1h);//
}else{
return(error);
}
timec = timeb+(timeb/2); // 1,5TE
temptime = (65535 - timec); // dif 65536 - 1,5TE
tempTE = (65535 - timeb); // dif 65536 - 1TE
//********************************************************
//********************************************************
//********************************************************
// recebe código
while(nbits){ // enquanto recebe bits."28"
//*******************************************************
//descobre lógica do bit se é 1 ou zero
//
// (1,5TE)
// | |
// 1 frame |1? 0? |
// XXXXXXX| >10mS e <13mS |´´´| |XXXX|''''|
// XXXXXXX|____________________| |____|XXXX| |
tmr1h = hi(temptime);
tmr1l = lo(temptime);
lig_tmr = 1;
while(!est_tmr); // aguarda 1,5TE
lig_tmr = 0;
clr_tmr;
if(inpcode){ // descobre se o bit é 1 ou zero
clrbit0(data);
}else{
setbit0(data);
}
//*******************************************************
//*******************************************************
//confirma protocolo, confirma se + 1 te o nivel logico = 1
//se nivel lógico não for = 1 então error
// (1TE)
// | |
// 1 frame |1! |
// XXXXXXX| >10mS e <13mS |´´´| |XXXX|''''|
// XXXXXXX|____________________| |____|XXXX| |
//*******************************************************
tmr1h = hi(tempTE);
tmr1l = lo(tempTE);
clr_tmr;
lig_tmr = 1;
while(!est_tmr);// aguarda 1TE
lig_tmr = 0;
clr_tmr;
if(!inpcode){return(error);}// meio do 3° TE bit // obrigatório ser 1.
//*******************************************************
//confirma protocolo, confirma se dentro de 1 TE o nivel
//inverte para zero, se sim protocolo ok, caso contrario error
// (1TE)
// | |
// 1 frame |1!0!|
// XXXXXXX| >10mS e <13mS |´´´| |XXXX|''''|XXXX
// XXXXXXX|____________________| |____|XXXX| |XXXX
//*******************************************************
tmr1h = hi(tempTE);
tmr1l = lo(tempTE);
lig_tmr = 1;
while((!est_tmr)&&(inpcode));
lig_tmr = 0;
if((est_tmr)&&(inpcode)){return(error);}
data = data << 1;
nbits--;
}
return(recebido);
}else{return(error);} //(if((inpcode)&&(tempTE>50000)) teste de sincronismo
} //if(inpcode);
} //receive_ht6p20b();
makros utilizados Vide um outro post meu, "makros para novatos"
