Problema interpretando tren de pulsos (16F84A)

[pablomanieri]

hola nuevamente yo. ¿Como sabes cuando hay varios ceros seguidos o cuando hay varios unos seguidos? Mi consejo es que realices el chequeo de los bits por interrupción, es decir detectas que hay un cambio en la salida del sensor y contas que tiempo esta en ese estado, luego te fijas en el ancho del pulso que te da el control remoto (T) entonces si tienes en uno la señal por un tiempo 2T entonces son dos unos seguidos. El tiempo de cada bit que te da el control remoto lo tienes que calcular con el osciloscopio o mirar si conseguis la hoja de datos de dicho control, para saber el ancho de los pulsos. Una vez que tienes la tabla con todos los botones puedes codificar con el pic y usar tu propia codificación para indicarlo on leds o con lo que sea. Ya que la cantidad de botones que tiene un control remoto no utiliza todas las combinaciones.

[chacruna]

Hola pablo!!, tanto tiempo jajaja.

Ya solucioné el problema, que basicamente era entender la bizarra forma de codificar de este remoto (muy distinto a RC5). Es el control de una sintonizadora de tv PCI que evidentemente tiene su propio protocolo.

Hay que admitir que el osciloscopio / placa de sonido es una pedorrada, pero me salva la vida.

[pablomanieri]

Me alegro que lo hayas solucionado. Estaría bueno que vayas posteando tus avances tanto de software como de hardware aunque no tengas más dudas porque seguro nos va a servir a muchos

[chacruna]

Hola pablo, justamente estaba armando una imagen y ajustando un poco el código para postear los resultados.



En ésta imagen se pueden ver dos señales que son del mismo botón, cada vez que apreto un botón alternan unos bits del principio (rectángulo amarillo). Me explico mejor: si apreto el botón una vez aparece la primer señal, si apreto de nuevo aparece la siguiente, si apreto de nuevo vuelve a la primer señal y así sucesivamente (creo que se llaman bits de toggle).

Como notarán cada ciclo son 2 bits (raro), esto creo que es así ya que en algunos botones lo único que cambia en la señal es la duración de algún semiciclo (por ejemplo: en el asterisco azul de la imagen hay un bit (1 en este caso), pero hay otro botón que lo único que cambia es la duración de ese semiciclo.

La barrita verde marca que de ese bit para adelante son los comandos (bit 11). Del bit 11 para atras lo único que cambia son los bits de "toggle".

En la imagen se puede ver que la señal tiene 21bits, sin embargo la mitad de los botones tienen 19bits. (el control remoto es de la placa "Asus My Cinema 7131").



Éste código funciona CASI bien leyendo botones que emiten señales de 19bits (se come el ultimo bit). También lee los de 21bits pero se come los ultimos tres bits.

Código: [Seleccionar]

#include <16F84A.h>

#fuses XT,NOWDT,NOPROTECT,PUT
#use delay (clock=4000000)
#use fast_io(a)
#use fast_io(b)

int bit[21], i;

void main() {

      set_tris_a(0);
      set_tris_b(0x10);

      for(i=0;i<21;i++) {
         bit[i]=0;
      }
      i=0;
      while(1) {
            do {
               while(input(PIN_B4));
               delay_us(1200);

               if(!input(PIN_B4)) {
                  bit[i]=1;
               }else {
                  bit[i]=0;
               }
               i++;

               while(!input(PIN_B4));

               delay_us(950);
               if(input(PIN_B4)) {
                  bit[i]=1;
               }else {
                  bit[i]=0;
               }
               i++;
            }while(i<18); // no se porque si pongo i<19 no sale en la primer pulsada del botón, como q lee un bit menos

            if(i==18) {
               output_bit(PIN_A2,bit[11]); // primer bit del comando
               output_bit(PIN_A3,bit[12]);
               output_bit(PIN_B0,bit[13]);
               output_bit(PIN_B1,bit[14]);
               output_bit(PIN_B2,bit[15]);
               output_bit(PIN_A1,bit[16]);
               output_bit(PIN_A0,bit[17]);
               output_bit(PIN_B7,bit[18]); // siempre en 0 pq el while es i<18 y no i<19
               output_bit(PIN_B6,bit[19]); // siempre en 0 pq el while es i<18 y no i<21 (en este codigo no leeo los comandos de 21bits enteros)
               output_bit(PIN_B5,bit[20]); // siempre en 0 pq el while es i<18 y no i<21 (en este codigo no leeo los comandos de 21bits enteros)
               delay_ms(250);
               output_bit(PIN_A2,0);
               output_bit(PIN_A3,0);
               output_bit(PIN_B0,0);
               output_bit(PIN_B1,0);
               output_bit(PIN_B2,0);
               output_bit(PIN_A1,0);
               output_bit(PIN_A0,0);
               output_bit(PIN_B5,0);
               output_bit(PIN_B6,0);
               output_bit(PIN_B7,0);

               for(i=0;i<21;i++) {
                  bit[i]=0;
               }
               i=0;
            }
      }
}


Éste es el código que debería leer tanto 19bits como 21bits, pero no funciona (por algún motivo no sale de un while).

Código: [Seleccionar]

#include <16F84A.h>

#fuses XT,NOWDT,NOPROTECT,PUT
#use delay (clock=4000000)
#use fast_io(a)
#use fast_io(b)

long ticks=0;
int bit[21], i, seconds=0;

#INT_TIMER0
void int_timer() {
      set_timer0(156);
      if (++ticks == 10000) {
         seconds++;
         ticks=0;
      }
}

void main() {

      set_tris_a(0);
      set_tris_b(0x10);
     
      setup_counters(RTCC_INTERNAL,RTCC_DIV_1);
      set_timer0(156);
     
      enable_interrupts(GLOBAL);
      enable_interrupts(INT_TIMER0);

      for(i=0;i<21;i++) {
         bit[i]=0;
      }
      i=0;
      while(1) {
            while(input(PIN_B4));
            do {
               delay_us(1200);
               
               if(!input(PIN_B4)) {
                  bit[i]=1;
               }else {
                  bit[i]=0;
               }
               i++;

               while(!input(PIN_B4));

               delay_us(950);
               if(input(PIN_B4)) {
                  bit[i]=1;
               }else {
                  bit[i]=0;
               }
               i++;
               ticks=0;
               seconds=0;
               set_timer0(156);
               while(input(PIN_B4) || seconds < 1); // aparentemente no sale nunca de éste while
               if(seconds >= 1) {
                  bit[19]=0;
                  bit[20]=0;
                  i=21;
               }
            }while(i<21);

            if(i==21) {
               output_bit(PIN_A2,bit[11]); // primer bit del comando
               output_bit(PIN_A3,bit[12]);
               output_bit(PIN_B0,bit[13]);
               output_bit(PIN_B1,bit[14]);
               output_bit(PIN_B2,bit[15]);
               output_bit(PIN_A1,bit[16]);
               output_bit(PIN_A0,bit[17]);
               output_bit(PIN_B7,bit[18]);
               output_bit(PIN_B6,bit[19]);
               output_bit(PIN_B5,bit[20]);                         
               delay_ms(250);
               output_bit(PIN_A2,0);
               output_bit(PIN_A3,0);
               output_bit(PIN_B0,0);
               output_bit(PIN_B1,0);
               output_bit(PIN_B2,0);
               output_bit(PIN_A1,0);
               output_bit(PIN_A0,0);
               output_bit(PIN_B5,0);
               output_bit(PIN_B6,0);
               output_bit(PIN_B7,0);
               
               for(i=0;i<21;i++) {
                  bit[i]=0;
               }
               i=0;
            }
      }
}


[chacruna]

Bueno, voy avazando de poco.

Con éste nuevo código puedo leer las señales de 19bits ENTERAS, y las de 20bits pero sin los últimos 2bits.

Código: [Seleccionar]

#include <16F84A.h>

#fuses XT,NOWDT,NOPROTECT,PUT
#use delay (clock=4000000)
#use fast_io(a)
#use fast_io(b)

int bit[21], i;

void main() {

      set_tris_a(0);
      set_tris_b(0x10);

      for(i=0;i<21;i++) {
         bit[i]=0;
      }
      i=0;
      while(1) {
            do {
               while(input(PIN_B4));
               delay_us(1200);

               if(!input(PIN_B4)) {
                  bit[i]=1;
               }else {
                  bit[i]=0;
               }
               i++;
               if(i<19) {
                  while(!input(PIN_B4));

                  delay_us(950);
                  if(input(PIN_B4)) {
                     bit[i]=1;
                  }else {
                     bit[i]=0;
                  }
                  i++;
               }
            }while(i<19);

            if(i==19) {
               output_bit(PIN_A2,bit[11]);
               output_bit(PIN_A3,bit[12]);
               output_bit(PIN_B0,bit[13]);
               output_bit(PIN_B1,bit[14]);
               output_bit(PIN_B2,bit[15]);
               output_bit(PIN_A1,bit[16]);
               output_bit(PIN_A0,bit[17]);
               output_bit(PIN_B7,bit[18]);
               output_bit(PIN_B6,bit[19]);
               output_bit(PIN_B5,bit[20]);
               delay_ms(250);
               output_bit(PIN_A2,0);
               output_bit(PIN_A3,0);
               output_bit(PIN_B0,0);
               output_bit(PIN_B1,0);
               output_bit(PIN_B2,0);
               output_bit(PIN_A1,0);
               output_bit(PIN_A0,0);
               output_bit(PIN_B5,0);
               output_bit(PIN_B6,0);
               output_bit(PIN_B7,0);

               for(i=0;i<21;i++) {
                  bit[i]=0;
               }
               i=0;
            }
      }
}


[chacruna]

Hola gente, despues de leer un poco cai en la cuenta de que el protocolo del control si era RC5 :S.

Hice el algoritmo para decoficarlo usando delay_us, pero despues de un par de bits leidos correctamente empieza a "saltar error" (el codigo verifica que los bits sean correctos).

Código: [Seleccionar]

#include <16F84A.h>

#fuses XT,NOWDT,NOPROTECT,PUT
#use delay (clock=4000000)
#use fast_io(b)

#define IR_IN (!input(PIN_B4))

int8 bit[14], i, error;

void main() {
      set_tris_a(0);
      set_tris_b(0x10);

      delay_ms(250);

      while(1) {
         while(IR_IN==0);
         delay_us(444);
         if(IR_IN==0) {
            error=1;
         }else {

            bit[0]=1;
            error=0;
         }

         for(i=1;i<14;i++) {
            delay_us(889);
            if(IR_IN==0) {
               delay_us(889);
               if(IR_IN==1) bit[i]=1; else error=1; // despues de un par de bits empieza a leer mal
            }else {
               delay_us(889);
               if(IR_IN==0) bit[i]=0; else error=1;
            }
         }
         if(error==1) {
            output_bit(PIN_A2,1);
            output_bit(PIN_A3,1);
            output_bit(PIN_B0,1);
            output_bit(PIN_B1,1);
            output_bit(PIN_B2,1);
            output_bit(PIN_A1,1);
            output_bit(PIN_A0,1);
            output_bit(PIN_B7,1);
            output_bit(PIN_B6,1);
            output_bit(PIN_B5,1);
            delay_ms(1000);
            output_bit(PIN_A2,0);
            output_bit(PIN_A3,0);
            output_bit(PIN_B0,0);
            output_bit(PIN_B1,0);
            output_bit(PIN_B2,0);
            output_bit(PIN_A1,0);
            output_bit(PIN_A0,0);
            output_bit(PIN_B7,0);
            output_bit(PIN_B6,0);
            output_bit(PIN_B5,0);
         }else {
            output_bit(PIN_A2,bit[0]);
            output_bit(PIN_A3,bit[1]);
            output_bit(PIN_B0,bit[2]);
            output_bit(PIN_B1,bit[3]);
            output_bit(PIN_B2,bit[4]);
            output_bit(PIN_A1,bit[5]);
            output_bit(PIN_A0,bit[6]);
            output_bit(PIN_B7,bit[7]);
            output_bit(PIN_B6,bit[8]);
            output_bit(PIN_B5,bit[9]);
            delay_ms(250);
            output_bit(PIN_A2,0);
            output_bit(PIN_A3,0);
            output_bit(PIN_B0,0);
            output_bit(PIN_B1,0);
            output_bit(PIN_B2,0);
            output_bit(PIN_A1,0);
            output_bit(PIN_A0,0);
            output_bit(PIN_B7,0);
            output_bit(PIN_B6,0);
            output_bit(PIN_B5,0);
         }
         for(i=0;i<14;i++) {
            bit[i]=0;
         }
      }
}

[chacruna]

Bueno, creo que voy a llorar... AL FIN FUNCIONA!!!!!!!!!!!!

Lo terminé haciendo como se debe, con interrupcion externa y timer para los retrasos.

Código: [Seleccionar]

#include <16F84A.h>

#fuses XT,NOWDT,NOPROTECT,PUT
#use delay (clock=4000000)
#use fast_io(b)

#define IR_IN (!input(PIN_B4))

int8 bit[14], i, error, state=0;

#int_rb
void RC5Decoder() {
      error=0;
      while(IR_IN==0);
      bit[0] = 1;
      set_timer0(0);
      while(get_timer0()<111);
      for(i=1;i<14;i++) {
         set_timer0(0);
         while(get_timer0()<222);
         if(IR_IN==0) {
            set_timer0(0);
            while(get_timer0()<222);
            if(IR_IN==1) bit[i]=1; else error=1;
         }else {
            set_timer0(0);
            while(get_timer0()<222);
            if(IR_IN==0) bit[i]=0; else error=1;
         }
      }
      state=1;
      disable_interrupts(INT_RB);
}

void main() {
      set_tris_a(0);
      set_tris_b(0x10);

      setup_timer_0(RTCC_INTERNAL|RTCC_DIV_4);
      ext_int_edge(H_TO_L);

      enable_interrupts(INT_RB);
      enable_interrupts(GLOBAL);     

      delay_ms(500);

      while(1) {
         if(state==1) {
            if(error==0) {
               output_bit(PIN_A2,bit[0]);
               output_bit(PIN_A3,bit[1]);
               output_bit(PIN_B0,bit[2]);
               output_bit(PIN_B1,bit[3]);
               output_bit(PIN_B2,bit[4]);
               output_bit(PIN_A1,bit[5]);
               output_bit(PIN_A0,bit[6]);
               output_bit(PIN_B7,bit[7]);
               output_bit(PIN_B6,bit[8]);
               output_bit(PIN_B5,bit[9]);
               delay_ms(250);
               output_bit(PIN_A2,0);
               output_bit(PIN_A3,0);
               output_bit(PIN_B0,0);
               output_bit(PIN_B1,0);
               output_bit(PIN_B2,0);
               output_bit(PIN_A1,0);
               output_bit(PIN_A0,0);
               output_bit(PIN_B7,0);
               output_bit(PIN_B6,0);
               output_bit(PIN_B5,0);
               state=0;
            }else {
               output_bit(PIN_A2,1);
               output_bit(PIN_A3,1);
               output_bit(PIN_B0,1);
               output_bit(PIN_B1,1);
               output_bit(PIN_B2,1);
               output_bit(PIN_A1,1);
               output_bit(PIN_A0,1);
               output_bit(PIN_B7,1);
               output_bit(PIN_B6,1);
               output_bit(PIN_B5,1);
               delay_ms(250);
               output_bit(PIN_A2,0);
               output_bit(PIN_A3,0);
               output_bit(PIN_B0,0);
               output_bit(PIN_B1,0);
               output_bit(PIN_B2,0);
               output_bit(PIN_A1,0);
               output_bit(PIN_A0,0);
               output_bit(PIN_B7,0);
               output_bit(PIN_B6,0);
               output_bit(PIN_B5,0);           
            }
            enable_interrupts(INT_RB);
         }
      }
}


[handpic]

Hola,

por casualidad, en otro comentario del foro, he visto que hay sensores para el protocolo RC5 que tienen la salida negada, es decir, tienen un nivel alto (podrían ser tus 4V) en ausencia de señal.

Busca el tema de recepción de códigos RC5.

hacen eso mismo que tu quieres hacer.

Saludos,