Decodificador mando a distancia Philips (protocolo rc5)

[naieto]

Y lo prometido es deuda, asi que aca algo tengo funcionando. Envia por rs232 la direccion y el comando. Tambien prende un led cuando esta ocupado imprimiendo (no se para que pero bueno por algo en algun momento lo hice jejejej). Me gustaria que me ayuden  como hacer para comparar el arreglo que recibe con otro arreglo guardado en memoria para saber que tecla aprete y poder hacer algo mas interesante con el programa que solo mostrar lo que recibe. Como comparo arreglos??.
Otra cosa, note que algunas teclas del control remoto philips que tengo no parecen respetar el protocolo rc5, y envian los bits de start con otros tiempos totalmente distintos, cosa que comprobe con un analizador logico (alguna idea porque?)
Bueno espero comentarios y/o posibles mejoras, sugerencias etc
Saludos

////////////////////////////////////////////////////////////////////////////////
//Programa que decodifica el protocolo RC5 de Philips y lo envia via
//rs232 para poder ser visto con un monitor de puerto serie
////////////////////////////////////////////////////////////////////////////////

#include <18F252.h>

#FUSES NOWDT                   //No Watch Dog Timer
#FUSES XT                          //Crystal Osc <= 4mhz
#FUSES NOPROTECT            //Code not protected from reading
#FUSES NOBROWNOUT         //No brownout reset
#FUSES NOPUT                    //No Power Up Timer

#use delay(clock=4000000)
#use rs232(baud=19200, xmit=PIN_C6, rcv=PIN_C7)

#define RX_READY 0
#define RX_RECEIVING 1
#define RX_COMPLETE 2

int16 period=0;
int8 word[14];
int8 state;
int8 i;
int8 j;

void rx_decoder(void);

////////////////////////////////////////////////////////////////////////////////
//Atiende la interrupcion externa por flanco descendente
////////////////////////////////////////////////////////////////////////////////

#INT_EXT
void ext_isr(void)
{period=get_timer1();
 set_timer1(0);
 state=RX_RECEIVING;
 rx_decoder();

}

////////////////////////////////////////////////////////////////////////////////
//Funcion que decodifica los tiempos entre flancos descendentes, en ceros y unos
// y los guarda en el arreglo word[14]
////////////////////////////////////////////////////////////////////////////////

void rx_decoder(void)
{
 if((period>=1768)&&(period<=1788))
   {word[i+1]=word;++i;}
 else
    {if((period>=2657)&&(period<=2677))
       {if(word==1)
          {word[i+1]=!word;word[i+2]=!word;++i;++i;}
        else
            {word[i+1]=!word;++i;}
        }
 else
     {if((period>=3546)&&(period<=3566))
        {word[i+1]=!word;word[i+2]=word;++i;++i;}
 else
     {state=RX_READY;
      i=0;}
     }
     }

 if(i==13)
   {state=RX_COMPLETE;}
}

////////////////////////////////////////////////////////////////////////////////
//Funcion principal
////////////////////////////////////////////////////////////////////////////////

void main(void) {

disable_interrupts(global);

i=0;
word[0]=1;

state=RX_READY;

set_tris_a(0b00000000);
set_tris_b(0b00000001);
set_tris_c(0b00000000);

output_low(pin_B7);

setup_timer_1(T1_INTERNAL | T1_DIV_BY_1);

ext_int_edge(0,H_TO_L);

enable_interrupts(INT_EXT);
enable_interrupts(GLOBAL);

do
  {if(state==RX_COMPLETE)
     {output_high(pin_B7);
      i=0;
      printf("\n\rPalabra recibida");
      printf("\n\rDireccion ");
      for(j=3;j<8;++j)
         {printf("%u",word[j]);}
      printf("\n\rComando ");
      for(j=8;j<14;++j)
         {printf("%u",word[j]);}
      printf("\n\rPalabra completa\n\r");
      state=RX_READY;
      output_low(pin_B7);
     }
  }
while(TRUE);

}

[naieto]

Autorrespondiendome encontre una forma de comparar lo que se recibe con constantes. Basicamente tomo del arreglo el comando y se lo vuelco a una variable, y lo mismo con la direccion. Despues es facil comparar variables.
Aca esta el codigo:

 mask = 0x01;
  for(i=8; i<14; i++)
      {if(word)
          {cmd = cmd | mask;}
       mask <<= 1;
      }

  mask = 0x01;
  for(i=3; i<8; i++)
     {if(word)
        {addr = addr | mask;}
       mask <<= 1;
     }

[Nocturno]

Te sugiero que pegues el código entre indicadores de código [ code ][ /code ] o usando Geshi.
Algunos trozos de código de tu programa han sido interpretado como cambio a cursiva y han desaparecido.

[naieto]

A ver nocturno como funciona,no sabia de eso

Código: CSS

1. mask=0b00000001;
2.       for(j=3;j<8;++j)
3.          {if(word[j])
4.             {addr | mask;}
5.           mask<<=1;
6.          }
7.          mask=0b00000001;
8.       for(j=8;j<14;++j)
9.          {if(word[j])
10.             {cmd | mask;}
11.           mask<<=1;

Buenisimo, igualmente mi intencion era mostrar solamente como volcar elementos de un arreglo a variables.

[chuibert]

hola ke tal!  he modificado tu codigo para utilizarlo en un 16f84A, de tal forma ke cuando leyera un nuevo codigo lo imprimiera en leds por los puertos A Y B, pero no me ha kedado y ahora lo he modificado para ke de acuerdo al valor de state, cambien las salidas PORTA0 y PORTA1

lo ke kiero identificar es si lleva a cabo la interrupcion externa y con esto me he dado cuenta de ke no lo hace.

hice bien la conversion al pic16f84A??

saludos y muchas gracias de antemano

[chuibert]

hay! se me olvido poner el codigo

Código: C#

1. #include <16f84A.h>
2.  
3. #FUSES NOWDT          // No Watch Dog Timer
4. #FUSES XT            // Crystal Osc <= 4mhz
5. #FUSES NOPROTECT    // Code not protected from reading
6. #FUSES NOPUT         // No Power Up Timer
7.  
8. #use delay(clock=4000000)
9. #USE STANDARD_IO(A)
10.  
11. #define RX_READY 0
12. #define RX_RECEIVING 1
13. #define RX_COMPLETE 2
14.  
15. // variables globales
16. int16 period=0;
17. int8 word[14];
18. int8 state;
19. int8 i;
20.  
21. void rx_decoder(void);
22.  
23. ////////////////////////////////////////////////////////////////////////////////
24. //Atiende la interrupcion externa por flanco descendente
25. ////////////////////////////////////////////////////////////////////////////////
26.  
27. #INT_EXT
28. void ext_isr(void)
29. {period=get_timer0(); //period= ciclos del timer
30.  set_timer0(0); // resetea el timer
31.  state=RX_RECEIVING;// mientras sucede esto, se enciende el led de recibiendo
32.  output_high(PIN_A4);
33.  rx_decoder();
34.  
35. }
36.  
37. ////////////////////////////////////////////////////////////////////////////////
38. //Funcion que decodifica los tiempos entre flancos descendentes, en ceros y unos
39. // y los guarda en el arreglo word[14]
40. ////////////////////////////////////////////////////////////////////////////////
41.  
42. void rx_decoder(void)
43. {
44.  if((period>=1768)&&(period<=1788)) //1.17ms = (4MHz/4)^(-1)*1768
45.    {word[i+1]=word;++i;}
46.  else
47.     {if((period>=2657)&&(period<=2677))
48.        {if(word==1)
49.           {word[i+1]=!word;
50.            word[i+2]=!word;++i;++i;}
51.         else
52.             {word[i+1]=!word;++i;}
53.         }
54.     else
55.      {if((period>=3546)&&(period<=3566))
56.         {word[i+1]=!word;
57.          word[i+2]=word;++i;++i;}
58.      else
59.      {state=RX_READY;
60.       i=0;}
61.      }
62.     }
63.  
64.  if(i==13)
65.    {state=RX_COMPLETE;}
66. }
67.  
68. ////////////////////////////////////////////////////////////////////////////////
69. //Funcion principal
70. ////////////////////////////////////////////////////////////////////////////////
71.  
72. void main(void) {
73.  
74.  disable_interrupts(global);
75.  
76.  i=0;
77.  word[0]=1;
78.  
79.  state=RX_READY;
80.  
81.  set_tris_a(0b00000000); // PA salida
82.  set_tris_b(0b00000001); // PB0 entrada, los demas salidas
83.  
84.  output_low(pin_B7);
85.  output_low(PIN_A0);
86.  output_low(PIN_A1);
87.  output_low(PIN_A4);
88.  
89.  setup_timer_0(RTCC_INTERNAL | RTCC_DIV_1);
90.  
91.  ext_int_edge(0,H_TO_L); //configura interrupcion externa por
92.                         //flanco de bajada
93.  
94.  enable_interrupts(INT_EXT); //habilita interrupcion externa
95.  enable_interrupts(GLOBAL);
96.  
97.  do
98.   {if(state==RX_COMPLETE)
99.      {
100.      output_bit(PIN_A3,word[2]);
101.      output_bit(PIN_A2,word[3]);
102.      output_bit(PIN_B6,word[7]);
103.      output_bit(PIN_B5,word[8]);
104.      output_bit(PIN_B4,word[9]);
105.      output_bit(PIN_B3,word[10]);
106.      output_bit(PIN_B2,word[11]);
107.      output_bit(PIN_B1,word[12]);
108.      output_high(PIN_A0);
109.      output_low (PIN_A1);
110.      }
111.    else
112.      {
113.       if (state==RX_RECEIVING)
114.       {
115.        output_low(PIN_A0);
116.        output_high(PIN_A1);
117.       }    
118.       else // state = RX_READY
119.       {
120.        output_high(PIN_A0);
121.        output_high(PIN_A1);
122.       }
123.      }
124.   }
125.  while(TRUE);
126.  
127. }

[micro_pepe]

Buenas, alguien ha probado el programa del inicio del hilo? yo lo he probado, pero no me funciona.

Un saludo.