Problema con la deteccion de datos por interrupcion rs232

[Kanick]

Hola a todos,

Tengo un problema que me tiene bastante perplejo y despues de darle muchas vueltas y probar de todo ya no se por donde pillarlo. A ver si alguien podria decirme donde tengo el fallo.

Lo que intento hacer es comunicar un 18f4550 con un pc via rs232 de forma inalámbrica a traves de 2 módulos xbee pro. El software del pc funciona perfectamente comunicándolo con el pic mediante usb y rs232 emulado con las funciones cdc y por cable físico. Estas son las pruebas que he ido haciendo hasta llegar a los xbee.

De entrada, al hacer la comunicación con los xbee veo que no siempre llega todo al pic. Para probar mando 3 bytes al pic y los devuelvo directamente al pc a ver que se esta mandando y en el pc no siempre recibo todo lo que envio. Esto es un tema.

Pero lo que me tiene deshubicado es que si la comunicacion la gestiono dentro del bucle infinito del main, funciona (a medias pero funciona). En cambio si intento detectar la entrada de datos mediante interrupción, no va nada de nada.

El código resumido es el siguente:

Código: [Seleccionar]

#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL3,CPUDIV1,VREGEN
#use delay(clock=48000000)
#use rs232(baud=115200, xmit=PIN_C6, rcv=PIN_C7)

#use fast_io(A)
#use fast_io(B)
#use fast_io(C)
#use fast_io(D)
#use fast_io(E)
 
int8 ordre;

#int_rda
void serial_isr(void)
{
  if(kbhit())                                 //Si lo pongo aquí es cuando no recibo nada
  {
      ordre=getc();                       //Hago eco como prueba a ver que es lo que le llega al pic
      putc(ordre);
      ordre=getc();
      putc(ordre);
      ordre=getc();
      putc(ordre);
   }
}

#int_RTCC                 
void RTCC_isr()
{
       (...)
}

#int_timer1     
void timer1_isr(void)
{
       (...)
}

#int_timer2             
void timer2_isr(void)   
{
       (...)
}

#int_timer3               
void timer3_isr(void)
{
       (...)
}
void main() {
   
   delay_ms(300);
   
   setup_counters(RTCC_INTERNAL,RTCC_DIV_4);//RTCC_8_BIT|RTCC_DIV_4);
   setup_timer_1(T1_INTERNAL | T1_DIV_BY_4);
   setup_timer_2(T2_DIV_BY_4,255,1);       
   setup_timer_3(T3_INTERNAL | T3_DIV_BY_4);

   enable_interrupts(INT_RTCC);
   enable_interrupts(INT_timer1);
   enable_interrupts(INT_timer2);
   enable_interrupts(INT_timer3);
   enable_interrupts(INT_rda);

   enable_interrupts(global);
   
   set_tris_a(0b00000000);
   set_tris_b(0b00000000);
   set_tris_c(0b10000000);
   set_tris_d(0b00000000);
   set_tris_e(0b00000000);

   output_a(0x00);
   output_b(0x00);
   output_c(0x00);
   output_d(0x00);
   output_e(0x00);
   
   do {
     /*if(kbhit())                     //Si lo pongo aquí si que recivo datos
     {
         ordre=getch();
         putc(ordre);
         ordre=getch();
         putc(ordre);
         ordre=getch();
         putc(ordre);
      }*/
               
   } while (TRUE);
}
Tengo que decir que las velocidades las he comprobado el todos los puntos (xbee, pic y puerto pc).

Cualquier ayuda o sugerencia me será de gran ayuda.
Muchas gracias.

Saludos

[pablomanieri]

Creo que estás teniendo problemas al colocar las tres lecturas del buffer y envío de datos en la misma entrada a la interrupción, prueba colocando solo una, de esta manera:

Código: C

1. #int_rda
2. void serial_isr(void)
3. {
4.   if(kbhit())                                 //Si lo pongo aquí es cuando no recibo nada
5.   {
6.       ordre=getc();                       //Hago eco como prueba a ver que es lo que le llega al pic
7.       putc(ordre);
8.    }
9. }

creo que así debe funcionar, prueba en todo caso con velocidades de transmisión mas bajas si es posible

[joseto]

Hola Kanick

 :)Para que el pic reciba todos los datos y no los pierda, te recomiendo que use la interrupción por recepción serial, el código que gestiona esta interrupción se encargara solo de la recepción, mientras que dentro de Main puedes poner código para que procese los datos recibidos.
Dentro del código que atiende la interrupción no es necesario que uses kbhit() ya que si se esta ejecutando estas líneas de código es por que el caracter ya fue recibido y solo hace falta leerlo con getc(). La interrupción por recepción serial solo recibe un caracter a la vez por lo tanto solo se debe leer una sola ves el caracter con getc(). Hay que salir de la interrupción lo mas pronto posible y tenerla disponible para los siguientes caracteres. El código quedaría así:

Código: [Seleccionar]

#int_rda
void serial_isr(void)
{     
      ordre=getc();                       //leo caracter
      putc(ordre);                        //eco
}                                          //salgo de la interrupción


Si deseas recibir tres caracteres te podría se útil guardarlos en un búfer y solo procesarlos cuando hayan llegado los tres caracteres te pongo un ejemplo:

Código: [Seleccionar]

#INT_RDA
void serial_isr()
{
   buf_rx[cont_rx] =getc();                     //leo caracter y lo guardo en un búfer ( declarado como    char  buf_rx[3]  )
   ++cont_rx;                                     //contador de caracteres recibidos
   if(cont_rx==2)
     {
         datos_listos=1;                         //si el contado llega a 2 activo una bandera para procesar estos datos dentro de main
         cont_rx=0;                              //encero contador
       }
}

 

[MLO__]

Hola.

Yo pensaba que la interrupcion de recepcion se daba al recibir el bit de start. 

[Kanick]

Hola,

Ante todo os he de decir que ya he conseguido enviar y recibir con la interrupcion rda.

He estado probado todo lo que me habeis dicho y al final he encontrado la cominación ganadora. He tenido que bajar un poco la velocidad como sugeria pablomanieri y he ordenado un poco la rutina de la interrupción como apuntaba también joseto consiguiendo que quadre perfectamente el envio de datos con su eco.

Asi que muchas gracias por vuestra ayuda.

Saludos

Kanick