ASM51

Participantes novatos, e visitantes.
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"

Aki em mikrobasic, bem menos complicado:

Código: Selecionar todos

'-----------------------------------

program decoder_ht6p20' pic16F628 a 20Mhz

symbol botao = portb.3
symbol dado = portb.0

dim contador as byte
dim baixo, alto as word
dim valor, memoria as longword

'-----------------------------------------------------------------
sub procedure pisca_pisca
portb.7 = 1
delay_ms(100)
portb.7 = 0
delay_ms(100)
portb.7 = 1
delay_ms(100)
portb.7 = 0
end sub
'------------------------------------------------------------
sub procedure grava_dados
EEPROM_Write(0, Highest(valor))
EEPROM_Write(1, Higher(valor))
EEPROM_Write(2, Hi(valor))
EEPROM_Write(3, lo(valor))

end sub
'-------------------------------------------------------------
sub procedure le_dados
Highest(memoria) = EEPROM_Read(0)
Higher(memoria) = EEPROM_Read(1)
Hi(memoria) = EEPROM_Read(2)
Lo(memoria) = EEPROM_Read(3)

if lo(memoria) = 255 then   'para não iniciar sem nada
Highest(memoria) = $F5    'comum para controle ECP       '
Higher(memoria) = $7D
Hi(memoria) = $8D
Lo(memoria) = $BA
valor = memoria
grava_dados
end if

end sub

'-----------------------------------------------------------------
sub procedure le_codigo

while contador < 28
'----------sinal-------
baixo= 0
alto = 0

while dado = 0
inc(baixo)
wend

while dado = 1
inc(alto)
wend
'--------fim do sinal-------

if baixo > alto then
valor.contador = 1
else
valor.contador = 0
end if

inc(contador)
wend

contador = 0

delay_ms(30)

end sub
'------------------------------------------------------------------------------
sub procedure compara_dados

if lo(valor) = lo(memoria) then

  if (Highest(valor)= Highest(memoria)) and (Higher(valor)= Higher(memoria)) then
  portb.7 = 1        'liga rele
  end if

  if (Highest(memoria)= Highest(valor)+1) and (Higher(valor)-128 = Higher(memoria)) then
  portb.7 = 0        'desliga rele
  end if

  if (Highest(valor)= Highest(memoria)) and (Higher(valor)-128= Higher(memoria)) then
  pisca_pisca
  end if

end if

end sub
'-----------------------------------------------------------
sub procedure verifica_botao
 if botao = 0 then
 while botao = 0
 wend

grava_dados

pisca_pisca
delay_ms(1500)

end if
end sub

'--------------------------------------------------------------
sub procedure interrupt
intcon = 0     'desliga tudo pra não dar reentrada

le_codigo
compara_dados

intcon = %11010000     'liga interrupt geral e portb.0

end sub

'-----------------------------------------------------------------
main:

trisa = 0
trisb = %00001001    'b0=dado, b3=botao
portb = 0
cmcon = 7
option_reg.6 = 1    'interrupt borda de subida
intcon = %11010000     'interrupt geral e portb.0

baixo= 0
alto = 0
contador = 0
le_dados

'----------------------------Loop Principal-------------------------------------
while TRUE

verifica_botao


wend

end.

Meu.
Aquilo lá é profissional, para aplicações onde não pode ficar preso esperando nada no main, tudo por maquina de estados... E não essas gambiarras com delay()...

AFF

E outra se o seu funcionasse bem, não teria entrado no forum pra procurar sobre HT6P20!! Zé mané !!! hehe


CHEGA PELO AMOR DE DEUS!!!!

Fabim, eu não estou conseguindo usar teu código, pode me explicar por favor comofas?
É que eu não manjo muito de C, já programei um pouco em html e não manjo quase nada de eletrônica e essas coisas, eu trabalho mais com manutenção de computadores, pode me passar um projeto pronto, funcionando, testado e montado e enviar umas 10 placas para minha casa? Valeu!!!!

xultz escreveu:Fabim, eu não estou conseguindo usar teu código, pode me explicar por favor comofas?
É que eu não manjo muito de C, já programei um pouco em html e não manjo quase nada de eletrônica e essas coisas, eu trabalho mais com manutenção de computadores, pode me passar um projeto pronto, funcionando, testado e montado e enviar umas 10 placas para minha casa? Valeu!!!!

claro.
Mando sim.
Fiz uma outra versão inteirinha em HEX direto, sem usar ASM!!! Na unha

O fabim faz rindo o que muita mulher nao chorando e nem cobra é só pedir.

Um caso desses aconteceu comigo. O cara me adicionou no msn e perguntou: "Cara como faço pra o PIC comandar outro pic pela serial?"
Eu não vi na hora a mensagem do cara, passado alguns minutos escrevi algo pra começar a conversa e o cara diz: "Cara agora não, tô jogando XXXX"

Onde XXX era o nome de um jogo que sei lá qual era.

Meu.
Aquilo lá é profissional, para aplicações onde não pode ficar preso esperando nada no main, tudo por maquina de estados... E não essas gambiarras com delay()...

AFF

E outra se o seu funcionasse bem, não teria entrado no forum pra procurar sobre HT6P20!! Zé mané !!! hehe

Oloko.
Postei pra ajudar quem não entende de "C", minha rotina não fica presa em nada, viu lá que está na interrupção do pic ??
A rotina do botão é só pra gravar na eeprom o controle desejado.
E postei aki pq é sobre o assunto, no intuito de ajudar e somar,
mas tudo bem, pode mandar pedradas !!

luis fernando escreveu:

Meu.
Aquilo lá é profissional, para aplicações onde não pode ficar preso esperando nada no main, tudo por maquina de estados... E não essas gambiarras com delay()...

AFF

E outra se o seu funcionasse bem, não teria entrado no forum pra procurar sobre HT6P20!! Zé mané !!! hehe

Oloko.
Postei pra ajudar quem não entende de "C", minha rotina não fica presa em nada, viu lá que está na interrupção do pic ??
A rotina do botão é só pra gravar na eeprom o controle desejado.
E postei aki pq é sobre o assunto, no intuito de ajudar e somar,
mas tudo bem, pode mandar pedradas !!

Liga não Luis Fernando... o fabim é assim mesmo... só ele é o bonzão... só ele sabe tudo.. manézão...

Relaxa Luis, vc da para um bom programador, certo? Mas coisas de mao beijada assim, sao sempre estranhas, pelo menos para mim.

Gosto de ensinar a pescar, quando dao o peixe, como o fabim, ai bate um monte de mendigo da porta dele, acho que ele nao pode reclamar, ne fabim? Rs...

Just my 2 cents. Mas o que ele falou sobre os delays por isntrução não costuma ser uma boa pratica de programação pois a eficiencia do seu codigo cai muito. O unica lugar que eu considero bem razoavel é na inicialização do sistema, porém na rotina é bem indesejável, porém ninguem vai morrer por isso, so você vai ter mais trabalho para reutilizar o seu código. Agora eu tenho algumas criticas pessoais sobre o codigo do Fabim, mas isso é estilo de programação. Normalmente incluir arquivos .c não é uma boa pratica pois você acaba incluindo junto toda a logica interna utilizada (variaveis globais e funções auxiliares), o que acaba criando uma situação péssima pois você perde controle das variaveis e funções. De modo geral é sempre bom criar um .h com os prototipos das funções que você quer exportar. Um exemplo, caso alguem use uma variável "data" em outro arquivo a coisa vai pegar. E de modo geral eu costumo usar bem mais definições hehe. Tento evita ao máximo numeros perdidos no código.

Mas de modo geral, tente tirar proveito dessa informação dele. Calcula você a eficiencia do seu codigo utilizando um delay(100ms). Lembre-se esse delay siginifica que seu codigo vai ficar jogando instruções fora (ou seja parado) por 100ms, o que é uma eternidade para um microcontrolador. Lembre-se de sempre usar e abusar de timers.. eles estão ai para isso...

Abs

estranho pq se observarem os delay´s que eu coloquei, foram pra fazer piscar led´s, intervalos a toa e etc... onde para quem for aproveitar o código, não irá utiliza-los...
pois o que mais importa no código (ler sinal do rádio) foi feito por interrupção que não atrapalha, nem deixa preso nenhuma outra rotina que alguém possa implementar.

outra coisa, eu já compilei os 2 códigos acima com o pic 16F628 e em Basic gastou menos código !!

EvandrPic escreveu:

luis fernando escreveu:

Meu.
Aquilo lá é profissional, para aplicações onde não pode ficar preso esperando nada no main, tudo por maquina de estados... E não essas gambiarras com delay()...

AFF

E outra se o seu funcionasse bem, não teria entrado no forum pra procurar sobre HT6P20!! Zé mané !!! hehe

Oloko.
Postei pra ajudar quem não entende de "C", minha rotina não fica presa em nada, viu lá que está na interrupção do pic ??
A rotina do botão é só pra gravar na eeprom o controle desejado.
E postei aki pq é sobre o assunto, no intuito de ajudar e somar,
mas tudo bem, pode mandar pedradas !!

Liga não Luis Fernando... o fabim é assim mesmo... só ele é o bonzão... só ele sabe tudo.. manézão...

Logico que não sou o bonzão !!!
Logico que não sabo tudo !!
Esse ta no CEU !!!

Eu só adoro tirar sarro com coisas sem sentido !!!!

Não foi eu quem postou um codigo para competir, nem fui eu que disse que ficou menor...

Pra começar PIC é para amadores, é apenas uma rampa má projetada... Que nos causa vicios muito dificeis de serem vencidos.. Graças ao meu esforço, eu esqueci até como se programa pic, e nem lembro mais como usa o MPLAB. E puxei varios amigos meus para sairem dessa m**** chamada pic... Os que sairam do microshit e entraram no CM3/arm7/9/11 e agora cortexA8/A9 eu ajudo, os outros com pic, eu sacaneio..!!!

Vocês são muito inocentes, nem manjam as coisas..

Eu não ajudo sobre micro controlador, eu ajudo sobre a logica, a implementação. A arquitetura o inutil que se exploda.

hehehe, como diria o proex. Odeio PIC, odeio atmerda, odeio holtek, odeio 8051...

Fabim, leia com muita atenção o que vou escrever abaixo, leia pausadamente cada palavra e reative suas memórias mais profundas, esquecidas e atormentadoras.

Pense profundamente nestas coisas: RB6 e RB7. Repita várias vezes: "RB6 e RB7...". Agora repita várias vezes: "ICSP, PicStart..."

Se você está começando a sentir pequenos tremores, não se preocupe, eles vão aumentar mas faz parte do processo.

Vamos mais fundo no trauma: repita algumas vezes "Compilador CCS". Sim, eu sei que é duro, mas vamos encarar o problema de frente.

Agora que as memórias mais negras estão aflorando, faça uma viagem por este universo que você tenta a todo custo esquecer: variaveis globais, um único registrador de 8 bits, 35 míseras instruções, stack de 8 níveis... Sim, eu sei, você deve estar se debatendo para todo lado, mas não desista.

Vamos encarar o maior de todos os traumas, respire fundo, e diga bem alto, liberando todos os demônios internos que ainda restam: "Bancos de memória!!!".

E então, sobreviveu?
Então pode esquecer esse negócio de ARM e o escambau e volte a programar com PIC.

Não precisa agradecer.