Decodificando control IR, preguntas

[pirate_x]

Hola, necesito ayuda por favor, estoy intentando decodificar un mando SONY y no puedoooo!!!! leo los tiempos y armo una secuencia pero no puedo compararla...
nose que estara malo si el calculo del tiempo o la comparacion (que se la quite al codigo porque no sirve)

Si alguien ha hecho esto antes me puede ayudar por favor... o postear un codigo porfavor.

Chau!

Código: [Seleccionar]


#include <16F84A.h>
#use delay (clock=40000000)
#fuses XT,NOWDT,NOPROTECT,NOPUT
#use fast_io(b)

#define on  output_high
#define off output_low
#define in input


int1  Flanco=0;
int1  edata=0;
int16 t1=0x00,t2=0x00,tt=0x00;
float ts=0.0;
int c,t[3],s=0;


#int_ext
void handle_ext_int()
   {                                      /* calculo de tiempo LOW */
   if(Flanco==0)
      {

      t1=get_timer0();                     
      ext_int_edge(L_TO_H);             
      Flanco=1;                   

      }
   else
      {                               
      t2=get_timer0();                     
      ext_int_edge(H_TO_L);               
      Flanco=0;                 
      set_timer0(0);                       
         if(edata==0)
            {                 
            edata=1;                   
            }

      }
   }



void main(void)

{

   disable_interrupts(GLOBAL);
   off(PIN_B1);
   off(PIN_B2);
   set_tris_b(0b000001);
   set_tris_a(0b0);
   setup_timer_0 (RTCC_INTERNAL|RTCC_DIV_32);

   ext_int_edge(H_TO_L);
   Flanco = 0;

   enable_interrupts(int_ext);
   enable_interrupts(global);
   set_timer0(0);

   for(;;)
   {
      for(c=0,s=0;c<=9,edata==1;)
      {
       if(edata==1)
            {                             /* generacion de secuencia en data[c] */
            c++;
               if(t2 > t1)
               {
               tt = (t2 - t1);
               ts = 32* tt;
               }
             if((ts>2350)&&(ts<2450)) s=1;
             if((ts>550)&&(ts<650)) data[c]=0;
             if((ts>1150)&&(ts<1250)) data[c]=0;


            }
  /* aca se lee la secuencia despues de s=1...*/


      }

   }

}

[Nocturno]

Veo un fallo.

Utilizas el flag edata para saber cuándo la interrupción ha capturado los dos flancos y procesar los tiempos desde el main.
Sin embargo, en el main no haces edata=0 en ningún momento.

[Cryn]

pues una vez realice este código con la ayuda del gran amigo ALGEC, esta basado en retardos solamente, y tb lo puse en otros hilos, pero como este tb va al caso, y para que vaya de acuerdo al tema tb lo pondre aca, talvez te sirva, a mi me ayudo bastante:

Código: [Seleccionar]

/*------------------------------------------------------------------------*/
/* CCS Compiler// Receptor IR (código Sony SIRC de Sony)                    */
/* Programado por Rodrigo - Cryn 12-Noviembre-2006                                 */
/* HAY QUE TENER EN CONSIDERACION QUE EL SENSOR                           */
/* IR INVIERTE LOS DATOS (el 1 es 0 y el 0 es 1)                          */
/*------------------------------------------------------------------------*/

#include <16F84a.h>
#fuses XT,NOWDT,NOPROTECT,PUT          // Los Fuses de siempre
#use delay(clock=4000000)              // Oscilador a 4 Mhz
#use fast_io(a)
#use fast_io(b)

#define REC_IR PIN_A4                  // selecciona la entrada a usar para el sensor IR

int error = 0;                         // Bit global de error
int a=0;
byte direccion;
byte comando;

int1 recibir_bit()
{  // OJO los bits son diferentes en tiempo si son 1 o 0
   // el 1 dura 600(0)+600(0)+600(1)   el 0 es   600(0)+600(1)
   // se usara retardos de 580us porque las instrucciones consumen ciclos de reloj
   // entonces será muy proximo a los 600us usados por el protocolo
   delay_us(580);                        // empieza a leer bits
   if(input(REC_IR) == 0)              // si lee un 0 es correcto de momento
   {
      delay_us(580);
      if(input(REC_IR) == 0)           // si lee un 0 es 1 y es correcto de momento
      {
         delay_us(580);
         if(input(REC_IR) == 1)        // si lee un 1 es 1 y es correcto el bit completo
            error =0;
            return 1;
      }
      else                             // si es 1 es cero y es correcto y ya acabo el bit completo
      {
         error =0;
         return 0;
      }
   }
   else
   {
      error = 3;
      return 0;
   }
}

void obtener_dato()
{                  // se posiciona para leer en mitad del periodo de 600 msg a partir de que el flanco bajo
   delay_us(280);   // la mitad seria 300us pero por consumo de reloj por las instrucciones se usará 280 para el retardo
   if(input(REC_IR)==0)             // si llega un 0 es que va bien y continua
   {
      delay_us(580);                // se posiciona en mitad
      if(input(REC_IR) == 0)        // si llega un 0 es que sigue bien
      {
         delay_us(1160);            // se posiciona en mitad
         if(input(REC_IR) == 0)     // si llega un 0 es que sigue bien
         {
            delay_us(580);          // se posiciona en mitad
            if(input(REC_IR) == 1)  // ojo ahora llega el CERO
               error=0;
         }
            else
               error = 1;
      }
      else
         error=2;       // si no se cumple todo asi, hay un error
   }
   else
      error = 4;
   if(error==0)         // lee los bits de direccion y comando (5 direccion + 7 comando)
   {
      if(recibir_bit())
         bit_set(comando,0);
      if(recibir_bit())
         bit_set(comando,1);
      if(recibir_bit())
         bit_set(comando,2);
      if(recibir_bit())
         bit_set(comando,3);
      if(recibir_bit())
         bit_set(comando,4);
      if(recibir_bit())
         bit_set(comando,5);
      if(recibir_bit())
         bit_set(comando,6);
      if(recibir_bit())
         bit_set(direccion,0);
      if(recibir_bit())
         bit_set(direccion,1);
      if(recibir_bit())
         bit_set(direccion,2);
      if(recibir_bit())
         bit_set(direccion,3);
      if(recibir_bit())
         bit_set(direccion,4);
   }
}

void main()               // programa principal
{
   set_tris_a(0x1f);      // definicion de puertos
   set_tris_b(0x0f);
   output_b(0);
   while(1)
   {
      direccion=0;      // inicializa los bits de control de comunicacion
      comando=0;
      while(input(REC_IR)==0)   // Espera al 1er bit de START (flanco de bajada) del receptor IR; mientras se queda en el bucle While
      {                          // cuando llega el flanco de bajada. LEER el BIT DE START que dura 2400 usg en 0 + 600 usg en 10
         obtener_dato();        // obtiene dato y lo guarda en comando y direccion
                                  // aqui vendria la rutina a ejecutar para chequeo de que la direccion sea la adjudicada al receptor
                                // y la rutina a ejecutar para cada comando
/*
aca ya se tiene el valor del comando y direccion enviado por el mando IR, los valores están guardados en las
variables COMANDO y DIRECCCION respectivamente; a partir de aca se hace lo necesario con ello, lo que yo
hice esta vez fue simplemente conmutar un LED
*/


         if(error==0 & comando==21)
         {
            if(a==0)
            {
               delay_ms(80);
               output_high(PIN_B4);   // adelante
               a=!a;
               delay_ms(100);

            }
            else
            {
               delay_ms(80);
               output_low(PIN_B4);
               a=!a;
               delay_ms(100);
            }
            comando=0;
            direccion=0;
         }
      }
   }
}
me basaba para el codigo en general, y para los comandos y direcciones de la pagina mas popular sobre el tema:
http://www.sbprojects.com/knowledge/ir/sirc.htm

[pirate_x]

gracias por las respuestas, voy a analizar el codigo posteado por Cryn (yo = habia intendo de esa forma, pero tenia la duda sobre la velocidad con que avanzaria el micro. pero me han dado una idea.
Voy a seguir intenando y mas adelante posteo avances...

Chau

[Algec]

EL del amigo funciona, asi que basate en ese. Y por cierto gracias por la referencia, no era necesaria

[Cryn]

 

no seas modesto hombre!! que fue con ayuda tuya, jeje
un saludo a la distancia.