ENCODER HT6P20

[Fabio_Jerena]

Pessoal, finalmente consegui colocar essa tranqueira prá funcionar, e o legal é que foi do jeito que eu comentei no post anterior, o mesmo algoritimo que parece funcionar muito bem para qualquer resistência no HT6P20B (testei umas 4 bem diferentes e todas mantiveram o mesmo funcionamento no bichinho, porem não está funcionando corretamente "ainda"...
O que acontece é o seguinte, para fazer o teste se estava funcionando corretamente resolvi só ler os botões e acender leds, daí depois eu trato a sequencia gravando o número do CI e tudo mais, para isso eu usei o comando shift_right(&codigo, 4, valor_do_bit); que insere bit a bit numa variável de 32 bits (int32) deslocando-os para a direita.
Depois eu pego o MSB desta variável onde estará o Anti-code + valor dos botões + pedaço da sequencia de identificação do CI.
O problema é que quando eu aperto o botão D0 e seguro ele acende o led, apaga o led, derrepente acende o outro led mantendo o anterior aceso também, daí acende só o segundo e depois apaga os dois, no mínimo eu achei bizarro pois não entendi porque faz isso, pior que o D1 funciona certinho, se eu seguro ele precionado acede o led e apaga, se eu precionar os dois botões acende e apagam os dois leds, ou seja, ele funciona perfeitamente um botão e apertando os dois, o outro botão têm um comportamento maluco, pior que eu já tentei entender o pq disso e não cheguei a uma conclusão, a única coisa que me passou na cabeça é a tal transição lógica de 01 para 10, mesmo assim acho que não têm nada a ver, sei lá, se alguém puder me ajudar o trecho do código que faz essa bagunça está citado abaixo... (pior é que o anti-code ele está lendo direitinho, se eu mudo essa sequencia ele não funciona e sempre para ele acender um led alem da informação do botão já lê o anti-code, se não bater ele nem acende... (Lembrando que essa é uma rotina de teste, a definitinha vai armazenar os códigos, compará-los e validá-los ou não...

dado = (valor_botao & 0b11111100); // parte "bruta" do código e
// elimino quem eu não vou precisar


if(dado==0b10101000) // esse é o botão 10 (fica bagunçado quando)
{
led_red=!led_red;
delay_ms(1000);
}
else
{
// esse botão abaixo é o botão 01, se eu retirá-lo do programa o outro botão funciona normalmente, se eu deixo ele aqui o outro fica bagunçado, coisa de louco...

if(dado==0b10100100)
{
led_green=!led_green;
delay_ms(1000);
}
else
{
if(dado==0b10101100) // 11 quando eu preciono os dois botões, funciona direitinho tb...
{
led_green=!led_green;
delay_ms(1);
led_red=!led_red;
delay_ms(1000);
}
}
}



enable_interrupts(global);
conta_bit=24;



Bom, é só esse trecho que está me dando problema, quem puder me ajudar serei grato, muito obrigado!!!

[Andre Rasminio]

obrigado a todos pelas discas, todas foram válidas.

[fabim]

num conheço muito bem "C".

Mais o pouco que eu consegui interpretar, a logica é basicamente o que eu passei pra vc.

Parabêns.

Em pascal são algumas linhas mais tudo bem.rsrs

Fabim

[Fabio_Jerena]

obrigado a todos pelas discas, todas foram válidas, estou postando o meu código.
//----- Função que recebe os dados do CR -----
//In: Null
//Out: Se for Lixo ERRO = 1
// Se for válido ERRO = 0
unsigned char GetRfData(void)
{
unsigned char fA0_A7 = 0,fA8_A15 = 0, fA16_A19 = 0,fData = 0, fAntiCode = 0;
unsigned char antiCode = 0x00;
unsigned char fim = 0; //'0' continua a ler os bits, '1' terminou a leitura
unsigned char erro = 0; //'0' continua a ler os bits, '1' indica erro
unsigned char blanck=0x00;
unsigned char try=0x00;

A0_A7 = 0x00;
A8_A15 = 0x00;
A16_A19 = 0x00;
rfData = 0x00;

//----- PROCURA BLANCK ----------------
try=0x00;
do
{
blanck = 0;
while(!RXDATA)
{
delay_us(100);
blanck++;
}
try++;
}while(((blanck<80)&&(blanck>86))&&(try<100));

if(((blanck<80)||(blanck>86))||(try>100)) erro = 1;

//---------------------------------------

if(rxData) delay_us(184);//delay_us(167);
if(!rxData) erro = 1;

while((!fim)&&(!erro))
{
while(rxData);
delay_us(184);
if(!rxData) //T1, tem que ser 0, se não for é ERRO
{
delay_us(368);
if(!rxData) //T2
{
delay_us(368);
if(rxData) //T3, tem que ser 1, se não for é ERRO
{
if(fA0_A7<8)
{
A0_A7 <<= 1;
A0_A7 = 0b00000001|A0_A7;
fA0_A7++;

}else if(fA8_A15<8)
{
A8_A15 <<= 1;
A8_A15 = 0b00000001|A8_A15;
fA8_A15++;
}else if(fA16_A19<4)
{
A16_A19 <<= 1;
A16_A19 = 0b00000001|A16_A19;
fA16_A19++;
}else if(fData<4)
{
rfData <<= 1;
rfData = 0b00000001|rfData;
fData++;
}else if(fAntiCode < 4)
{
antiCode <<= 1;
antiCode = 0b00000001|antiCode;
fAntiCode++;
}else fim=1;
}else fim = 1;
}else if(rxData) //T2
{
delay_us(368);
if(rxData) //T3, tem que ser 1, se não for é ERRO
{
if(fA0_A7<8)
{
A0_A7 <<= 1;
A0_A7 = (0b11111110)&(A0_A7);
fA0_A7++;

}else if(fA8_A15<8)
{
A8_A15 <<= 1;
A8_A15 = 0b11111110&A8_A15;
fA8_A15++;
}else if(fA16_A19<4)
{
A16_A19 <<= 1;
A16_A19 = 0b11111110&A16_A19;
fA16_A19++;
}else if(fData<4)
{
rfData <<= 1;
rfData = 0b00001110&rfData;
fData++;
}else if(fAntiCode<4)
{
antiCode <<= 1;
antiCode = 0b00001110&antiCode;
fAntiCode++;

}else fim=1;
}else fim = 1;
}
}

} //fim do while(!fim)

while(rxData);

if((fim&&(!erro)&&(antiCode==0x05))) ERRO = 0;
else ERRO = 1;

return(ERRO);


}

Qulquer dúvida estou a disposição

O que são esses emoticons???
Que C vc utiliza, não é o CCS, ou é?

[Fabio_Jerena]

Bom pessoal, eu ainda estou me matando com este programa, pior é que eu tenho impressão que eu estava no caminho certo, fiz alguns testes e tive a impressão de ter conseguido, porem não funcionou os dois botões corretamente, funcionava um botão e os dois juntos... Não sei onde estou errando, se tudo está errado, tenho impressão que esta rotina esta levando muito tempo para ser executada e devido esse tempo não está funcionando a lógica, se alguma alma caridosa quizer aproveitar ele e tentar consertá-lo se é que posso chamar assim...
O tratamento ainda não faz nada, eu só queria testá-lo para ver se ele estava lendo corretamente, assim sendo fiz com que ele identificasse um botão e acendesse e apagasse um LED!
Muito Obrigado!


#include "experiencia_pic.h"
#ZERO_RAM

// Programa para decodificar o Encoder HT6P20B utilizando o PIC16F628A (ultima revisão 29/05/06)


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Definição e inicialização das variáveis *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

short int startbit=0; // indica que ocorreu o startbit
int conta_borda=0; // libera analise da borda de descida
short int libera=0; // libera analise da borda de subida
long int tempo_low; // armazena tempo do pulso em nível lógico 0
long int tempo_high; // armazena tempo do pulso em nível lógico 1
int conta_bit=28;
int32 codigo=0; // armazena o código lido
//int32 code_mem; // código que será resgatado da memória
//int end; // endereço de memória
//int dado; // Dado que se quer gravar na memória
short int bit_recebido=0;
int contador=14;


/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* Definição e inicialização dos port's *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#use fast_io(a)
#use fast_io(b)

#byte porta = 0x05
#byte portb = 0x06

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* ENTRADAS *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// As entradas devem ser associadas a nomes para facilitar a programação e
//futuras alterações do hardware.

#bit entrada = portb.0 // Entrada do pulso que eu vou analisar

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
* SAÍDAS *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
// As saídas devem ser associadas a nomes para facilitar a programação e
//futuras alterações do hardware.

#bit led_direito = portb.1 // led verde (bit de entrada 0)
#bit led_esquerdo = portb.2 // led vermelho (bit de entrada 1)
#bit led_verde = portb.3 // led amarelo (ocorreu o startbit)


#int_TIMER0
TIMER0_isr()
{
startbit = 1;
disable_interrupts(INT_TIMER0);
}

#int_EXT
EXT_isr()
{
if(!startbit)
{
set_timer0 (55);
enable_interrupts(INT_TIMER0);
}
else
{
switch (conta_borda)
{

case 0 : tempo_high = get_timer1 ();
set_timer1 (0);
ext_int_edge(0, L_TO_H);

if(libera)
{
bit_recebido=1;
libera=0;
}

conta_borda++;
break;

case 1 : tempo_low = get_timer1 ();
set_timer1 (0);
ext_int_edge(0, H_TO_L);
libera=1;
conta_borda=0;
break;
}
}
}


void main()
{
setup_vref(FALSE);
setup_comparator(NC_NC_NC_NC);

setup_timer_0(RTCC_INTERNAL | RTCC_DIV_32);
setup_timer_1(T1_INTERNAL | T1_DIV_BY_1);
setup_timer_2(T2_DIV_BY_16,255,1); // verificar se não declarar ajuda a economizar consumo do uC...

enable_interrupts(INT_EXT);
ext_int_edge(0, H_TO_L);
enable_interrupts(global);

set_tris_a(0b11111111); // configuração da direção dos pinos de I/O
set_tris_b(0b11110001);

porta=0x00; // limpa porta
portb=0b00000110; // limpa portb


while(true)
{
if(bit_recebido) // verificar se está certo != como diferente
{

if (tempo_low > tempo_high)
{
shift_right(&codigo, 4, 1);
}
else
{
shift_right(&codigo, 4, 0);
}

conta_bit--;
bit_recebido = 0;

if(conta_bit==0)
{
int dado, anti_code;
disable_interrupts(global);
codigo = codigo >> 4;
anti_code = (make8(codigo,3) & 0b00001111);
if (anti_code == 0b00001010)
{
led_verde=!led_verde;
dado = (make8(codigo,2) & 0b11000000);

if(dado==0b10000000)
{
led_esquerdo=!led_esquerdo;
delay_ms(1000);
}

startbit=0;
bit_recebido=0;
enable_interrupts(global);
}
}
}
}

}

[Andre Rasminio]

é ccs, se quiser te passo por email o arquivo

[HC908]

ai esta amigo uma rotina bem simples para decodificar o HT6P20B da holtek. qualquer duvida é so escrever . A função retorna verdadeiros se os dados forem recebido corretamente. no primeiro momento ele aguarda o "pilot period". dados são gravado na variavel de DATA.

Obs. Resistor do oscilador 2M2, ou seja frequencia de 2khz

#define RFIn RB0 //entrada do sinal de RF
#define NBIT 28 // numero de bits
INT32 DATA=0;

int1 decoder(void)
{
byte x=0;
int16 time_aux=0;
DATA=0;
while(!RFIn)
{
time_aux++;
delay_us(10);
}

if((time_aux>1149) || (time_aux<=1151))
{

for(x=0;x<NBIT;x++)
{
while(RFin);
delay_us(250);

if(RFIn)
{
return FALSE;
}

delay_us(500);
if(!RFIn)
{
data|=0x8000000;
data>>=1;
}else data>>=1;
delay_us(500);
if(!RFin)
{
return FALSE;
}


}
return TRUE;
}
else return FALSE;

}

[aldomd]

Olá amigos ! Chega de ficar calado ! Já aprendi muito aqui e vamos ajudar também .... ou tentar pelo menos !!!!!!!!!

Bom, como programo em assembler, vou tentar descrever o que faço no código .... resumindo ...


Meu código (a parte de RF) fica o tempo todo "medindo" o intervalo dos 23 clks (low) entre uma transmissão e outra. Como as resistencias do clock do CI podem variar, e até nossa mão segurando o controle interfere um pouco no fosc, entre outras coisas, meço esse tempo entre transmissões em "LOW" e deixo uma margem para mais ou menos ....

Acabou este tempo, começa o START BIT ... nivel "1". Testo se o tempo em low (dos 23 clocks) atingiu o tempo mínimo (margem) e se ok começo a medir o tempo de start bit, que vale 1/3 de bit e é igual a 1 TE (1 bit = 3TEs, claro).


Muito bem ... medindo o start bit, eu consigo ajustar meu código a transmissão ... mesmo que varie um pouco.

Acabando o start bit, vem o código propriamente dito, então se eu der um delay de 1 TE e meio, eu consigo ler o bit, logo em seguida espero pelo final do mesmo (ou pelo início do proximo, como quiser), que é sempre low. Se não for low já melou tudo e se for, delay de 1 TE e meio e assim vai até receber todos os bits, "and" com o anti-code pra ver se bateu legal
e manda pra EEPROM.

Algumas coisas talvez estejam repetitivas com o que os colegas já disseram, mas com um ponto de vista diferente espero ter ajudado um pouquinho ....