Comunicación de PIC a PIC por radio frecuencia con módulos de 434MHz

Hola a todos. Estoy realizando un
proyecto para la facultad en la cátedra de técnicas digitales 2
utilizando el compilador C de CCS. Consiste en comunicar dos pic con
los módulos transmisor y receptor de 434Mhz. Hemos avanzado bastante
en el código pero a la hora de probar todo casi nunca se recibe una
señal correctamente. El ruido hace casi imposible la comunicación.
Cuando se conecta el pin del pic transmisor al pin del pic receptor
por medio de un cable la comunicación es perfecta, pero no así con
los módulos RF.

La codificación consiste en enviar una trama
de 8, 12 o 16 bit de 1 y 0 al principio, que sirven para
estabilizar el sistema receptor y luego sigue una clave de 8 o 14
bits mas 4 u 8 bits de datos.

Cada bit de la señal dura 500us
por lo que en teoría se estaría trabajando a 1/500us = 2000baudios.

Código:


Señal de ejemplo:

1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0--1 0 0 1 1 1 0 1--0 1 0 1


1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0--delay_us(500)--1 0 0 1 1 1 0 1--0 1 0 1
-------------------------------                ----------------  --------
Trama de estabilización de señal                  Clave 8 bits    Dato


Entre la trama de estabilización y la
clave de 8 bits existe un retardo intermedio de 500us que podría ser
interpretado como un 0, pero ese no es el caso, este retardo sirve
para sincronizar el receptor con el emisor, ¿Como?, simple con un:

Código:

while(pin_receptor==0)
{
}

Código:



delay_ms(8); //Tiempo que se demora en recibir la trama de estabilización.

While(pin_receptor==0) //While encargado de la sincronización.
{
}

delay_us(246);
clave_0_ = pin_receptor; //Se muestrea el 1° bit en la mitad de su tiempo de duración.
delay_us(247);

delay_us(246);
clave_1_ = pin_receptor; //Se muestrea el 2° bit
delay_us(247);
.
.
.
.
.
.


Y así sucesivamente con los 8 bits de
la clave y los 4 bits de datos.

Las líneas "clave_1_ =
pin_receptor;" demoran 7us en ejecutarse (medidos con
mplab-sim), por eso se dejan pasar 246us luego 7us para guardar el
bit en la variable "clave_x_" y al final 247us mas para
sumar así un total de 500us que dura cada bit.

Bueno les dejo el código que estoy
probando para ver como si le anda a alguien o si encuentra algún
error o tiene alguna sugerencia. En este punto estoy estancado y
sinceramente pensé que iba a ser mas sencillo, no me imagine que iba
a haber tanto ruido.

Bueno saludos a todos y al que le
interese este proyecto podemos trabajar en conjunto!!!. Saludos.

El código esta en C del compilador CCS y es para un pic 12F629, pero
puede ser adaptado con mínimos cambios para cualquier otro pic. (No
he visto la necesidad de utilizar un pic mas potente y por ende mas
caro).


"Este código de prueba consiste 16 bits para
la trama de estabilización + 6 bits para la clave y 2 bits de
datos."

Código:


Código para el PIC Transmisor:
=============================================================================

#include <12F629.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES INTRC_IO                //Internal RC Osc, no CLKOUT
#FUSES CPD                      //Data EEPROM Code Protected
#FUSES PROTECT                  //Code protected from reads
#FUSES NOMCLR                  //Master Clear pin used for I/O
#FUSES PUT                      //Power Up Timer
#FUSES BROWNOUT                //Reset when brownout detected

#use delay(clock=4M)

#byte IOC = 0x96        //Registro de configuración de interrupción in_RA para cada pin individual.

//Se nombran los pines usados.
#bit pin_data = 0x05.0 //Pin 0 es salida de datos, conectado directo a la entrada del módulo transmisor.
#bit pin_1 = 0x05.1
#bit pin_2 = 0x05.2
#bit pin_3 = 0x05.3
#bit boton_1_ = 0x05.4          //Pin 4 es el boton 1.
#bit boton_2_ = 0x05.5          //Pin 5 es el boton 2.

//Variables.
int8 i;

//Funciones.
void boton_1_presionado(void);
void boton_2_presionado(void);


#int_RA
void RA_isr() //Función de atención a la interrupción por cambio de nivel.
{

  #ASM    //Código necesario para prevenir falla en una interrupción por cambio de nivel.
  movf 0x05,0
  clrw
  #ENDASM
 
  pin_data = 0;
 
  delay_ms(50);    //Previene rebotes.
 
  if(boton_1_==1)  //Si el boton 1 fue presionado se manda la señal boton_1_presionado();.
  {
      for(i=0; i<5; i++)  //Cada señal se envía 5 veces.
      {
        boton_1_presionado();
        delay_ms(5);      //Se envían 5 veces una cada 5ms.
      }
  }
  else              //Si no se manda boton_2_presionado();.
  {
      for(i=0; i<5; i++)  //Cada señal se envía 5 vaces.
      {
        boton_2_presionado();
        delay_ms(5);    //Se envían 5 veces una cada 5ms.
      }
  }
 
  pin_data = 0;
 
  while(boton_1_==1) //Se sale de la interrupción cuando se suelta el botón.
  {
  }
 
  while(boton_2_==1) //Se sale de la interrupción cuando se suelta el botón.
  {
  }
 
  delay_ms(50);  //Previene rebotes.
 
}


void main() //Programa principal.
{

  setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
  setup_timer_1(T1_DISABLED);
  setup_comparator(NC_NC);
  setup_vref(FALSE);
  enable_interrupts(INT_RA);  //Interrupción por cambio de nivel en algún pin.
  IOC = 0b00110000;            //Habilita interrupciones por cambio de nivel solo en pin_4 y pin_5_.
  enable_interrupts(GLOBAL);
 
  set_tris_A(0b00111110);  //Todas entradas pin_0_ como salida.
  port_a_pullups(TRUE);    //Habilita resistencias de pull_up en puertos configurados como entradas.

  pin_data = 0;

  while(TRUE)
  {
      sleep();
  }

}


void boton_1_presionado(void) //Función para enviar señal 1.
{
  pin_data = 1;  //Inicio y estabilización de la transmisión, 16 bits (1010101010101010).
  delay_us(500);
  pin_data = 0; 
  delay_us(500);
  pin_data = 1;
  delay_us(500);
  pin_data = 0;
  delay_us(500);
  pin_data = 1; 
  delay_us(500);
  pin_data = 0; 
  delay_us(500);
  pin_data = 1; 
  delay_us(500);
  pin_data = 0;
  delay_us(500);
  pin_data = 1; 
  delay_us(500);
  pin_data = 0; 
  delay_us(500);
  pin_data = 1; 
  delay_us(500);
  pin_data = 0; 
  delay_us(500);
  pin_data = 1; 
  delay_us(500);
  pin_data = 0; 
  delay_us(500);
  pin_data = 1; 
  delay_us(500);
  pin_data = 0; 
  delay_us(500);
 
  pin_data = 0;  //500us para sincronización.
  delay_us(500);
 
  pin_data = 1;  //1º bit de la clave.
  delay_us(500);
  pin_data = 0;  //2º bit de la clave.
  delay_us(500);
  pin_data = 1;  //3º bit de la clave.
  delay_us(500);
  pin_data = 0;  //4º bit de la clave.
  delay_us(500);
  pin_data = 1;  //5º bit de la clave.
  delay_us(500);
  pin_data = 1;  //6º bit de la clave.
  delay_us(500);
  pin_data = 1;  //1º bit de dato.
  delay_us(500);
  pin_data = 0;  //2º bit de dato.
  delay_us(500);
}


void boton_2_presionado(void) //Función para enviar señal 2.
{
  pin_data = 1;  //Inicio y estabilización de la transmisión, 16 bits (1010101010101010).
  delay_us(500);
  pin_data = 0; 
  delay_us(500);
  pin_data = 1;
  delay_us(500);
  pin_data = 0;
  delay_us(500);
  pin_data = 1; 
  delay_us(500);
  pin_data = 0; 
  delay_us(500);
  pin_data = 1; 
  delay_us(500);
  pin_data = 0;
  delay_us(500);
  pin_data = 1; 
  delay_us(500);
  pin_data = 0; 
  delay_us(500);
  pin_data = 1; 
  delay_us(500);
  pin_data = 0; 
  delay_us(500);
  pin_data = 1; 
  delay_us(500);
  pin_data = 0; 
  delay_us(500);
  pin_data = 1; 
  delay_us(500);
  pin_data = 0; 
  delay_us(500);
 
  pin_data = 0;  //500us para sincronización.
  delay_us(500);
 
  pin_data = 1;  //1º bit de la clave.
  delay_us(500);
  pin_data = 0;  //2º bit de la clave.
  delay_us(500);
  pin_data = 1;  //3º bit de la clave.
  delay_us(500);
  pin_data = 0;  //4º bit de la clave.
  delay_us(500);
  pin_data = 1;  //5º bit de la clave.
  delay_us(500);
  pin_data = 1;  //6º bit de la clave.
  delay_us(500);
  pin_data = 0;  //1º bit de dato.
  delay_us(500);
  pin_data = 1;  //2º bit de dato.
  delay_us(500);
}
=============================================================================


Código:


Código para el PIC Receptor:
=============================================================================
#include <12F629.h>

#FUSES NOWDT                    //No Watch Dog Timer
#FUSES INTRC_IO                //Internal RC Osc, no CLKOUT
#FUSES CPD                      //Data EEPROM Code Protected
#FUSES PROTECT                  //Code protected from reads
#FUSES MCLR                    //Pin 3 usado como recet.
#FUSES PUT                      //Power Up Timer
#FUSES BROWNOUT                //Reset when brownout detected

#use delay(clock=4M)

#byte IOC = 0x96                //Registro de configuración de interrupción in_RA para cada pin individual.
//Se nombran los pines usados.
#bit LED_0 = 0x05.0            //1º LED     
#bit LED_1 = 0x05.1            //2º LED     
#bit pin_2 = 0x05.2
#bit pin_recet = 0x05.3
#bit pin_4 = 0x05.4
#bit pin_receptor = 0x05.5      //Pin receptor conectado directamente al módulo receptor.

//Variables.   
int1 clave_0_, clave_1_, clave_2_, clave_3_, clave_4_, clave_5_, dato_0_, dato_1_, correcta;
int8 contador, i;

//Constantes.
int1 const clave__0_ = 1, clave__1_ = 0, clave__2_ = 1, clave__3_ = 0, clave__4_ = 1, clave__5_ = 1;


#int_RA
void RA_isr()
{

  #ASM
  movf 0x05,0
  clrw
  #ENDASM
 
  i = 0;
 
  for(i=0; i<5; i++)
  {
      delay_ms(8);  //Tiempo que tarda en recibirse la trama de estabilización.
     
      While(pin_receptor==0)    //Se sincroniza la recepción.
      {
      }
 
      delay_us(246);
      clave_0_ = pin_receptor; //Se muestrea el 1º bit.
      delay_us(247);
     
      delay_us(246);
      clave_1_ = pin_receptor; //Se muestrea el 2º bit.
      delay_us(247);
     
      delay_us(246);
      clave_2_ = pin_receptor; //Se muestrea el 3º bit.
      delay_us(247);
     
      delay_us(246);
      clave_3_ = pin_receptor; //Se muestrea el 4º bit.
      delay_us(247);
     
      delay_us(246);
      clave_4_ = pin_receptor; //Se muestrea el 5º bit.
      delay_us(247);
     
      delay_us(246);
      clave_5_ = pin_receptor; //Se muestrea el 6º bit.
      delay_us(247);
     
      delay_us(246);
      dato_0_ = pin_receptor; //Se muestrea el 7º bit.
      delay_us(247);
     
      delay_us(246);
      dato_1_ = pin_receptor; //Se muestrea el 8º bit.
      delay_us(247);
     
      contador = 0;
 
      if(clave__0_==clave_0_) //Si el 1º bit es correcto se incrementa el contador.
      {
        contador++;
      }
   
      if(clave__1_==clave_1_) //Si el 2º bit es correcto se incrementa el contador.
      {
        contador++;
      }
     
      if(clave__2_==clave_2_) //Si el 3º bit es correcto se incrementa el contador.
      {
        contador++;
      }
 
      if(clave__3_==clave_3_) //Si el 4º bit es correcto se incrementa el contador.
      {
        contador++;
      }
 
      if(clave__4_==clave_4_) //Si el 5º bit es correcto se incrementa el contador.
      {
        contador++;
      }
 
      if(clave__5_==clave_5_) //Si el 6º bit es correcto se incrementa el contador.
      {
        contador++;
      }
 
      if(contador==6)  //Si contador es 6 la clave es correcta.
      {
        i = 5;        //Entonces se sale del for.
        correcta = 1;
      }
     
      delay_ms(5);      //Cada repetición de la señal se envía cada 5ms.
  }
 
  if(correcta==1)      //Si la clave era correcta se presentan los 2 bits recibidos.
  {
      LED_0 = dato_0_;
      LED_1 = dato_1_;
      correcta = 0;
  }
   
  delay_ms(500);
 
}


void main()  //Programa principal.
{

  setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
  setup_timer_1(T1_DISABLED);
  setup_comparator(NC_NC);
  setup_vref(FALSE);
  enable_interrupts(INT_RA);
  IOC = 0b00100000;            //Habilita interrupciones por cambio de nivel solo pin_5_.
  enable_interrupts(GLOBAL);
 
  set_tris_A(0b00111100); //Todas entradas, pin_0_ y pin_1_ entradas.
  port_a_pullups(TRUE);  //Habilita resistencias de pull_up en puertos configurados como entradas.
 
  LED_0 = 0;
  LED_1 = 0;
  correcta = 0;

  while(TRUE)
  {
      sleep();
  }

}
=============================================================================


Wowwww, que interesante, estare pendiente del avance. Yo la verdad no tengo que aportar mas que los animos xD, pues aun voy por USB, pero muy interesante lo que estas haciendo y tiene mucho nicho de aplicacion. Saludos.

Si.. muy interesante, y yo aquí lo más que puedo hacer es intentar aprender algo, pero como soy un atrevido y siempre me meto aunque no sepa mucho... pues me resulta extraño que con un módulo de 434Mhz y mandando datos a una velocidad tan lenta el ruido sea un problema.
Lo único que se me ocurre, así por decir algo es si podría haber algún fallo de sintonización entre los módulos... no sé si tendrán algún ajuste de sintoía o algo por el estilo.

...O que hay otra fuente de RF por ahí cerca...

Solo por curiosidad... has mirado en un osciloscopio la señal recibida?


No sé... cosas que se me ocurren:

-filtrar la señal del módulo a la entrada del pic.

-Hacer varias lecturas de cada bit. Usando delays se complica la cosa, pero otra opción es no usar delays sino usar una base de tiempo con timer0+interrupciones (por ejemplo) que haga lecturas a 1/10 de bit (por ejemplo) y luego si el nº de lecturas > 5 el bit es un 1, sinó es un 0.


La verdad es que tengo ganas de probar alguna cosa de estas en vez de estar con un cable entre pic y pc (por ejemplo), pero por lo que leo por ahí, suele haber bastantes problemas con esto del ruido, y hacer una transmisión a velocidades rapidas no es facil.


saludos y suerte con eso.


EDITO:
Perdonen mi ignorancia: esos módulos eliminan la portadora?... el receptor me refiero.
Supongo que sí, pero la verdad es que no tengo ni idea.

Hola pikitin estoy muy corto de tiempo esta semana pero la semana que viene voy a estar probando unas placas de prueba RF que diseñe con la esperanza que se reduzca el ruido ya que las pruebas anteriores las hice en unas placas de prueba con los modulos RF cableados. Estube mirando por el foro y encontre esto:
https://pic-linux.forosactivos.net/robotica-f13/vickymi-primer-pojecto-t173.htm

Donde para comunicar el robot con la PC Alejandro utiliza los mismos módulos RF que yo utilizo, solo que creo que el a programado en basic. Me acabo de bajar el codigo y voy a tratar de pasarlo a C. Saludos, en cuanto tenga algo nuevo les comento.

Acabo de ver el código a muy grandes rasgos y no caso una, espero tener suerte. Si alguno lo entiende soy todo oídos. Saludos.

yo iria por partes , primero verificar la sintonia entre los modulos ....no se que tipo de modulacion utlizan , verificar primero la calidad de los datos con el osciloscopio.Luego implementar un sistema de verificacion de datos tal y como lo hace cualquier modem, algo tipo te envio una A y me devuelves una A ,si no , te la vuelvo a enviar hasta que me devuelvas la A , una transmision con eco y comenzar con tasas de transmision bajas....mira tambien en las especificaciones que ancho de banda tienes.si puedes postea marca y modelo de los modulos.

perdonenme si me permito di opinar.mas por experiencia con modulos RF te puedo decir que ha esa frequencia es màs que normal.a veces basta un telecomando de portòn corredizo de un vecino para interferir con el seńal.
1)TX(modulo transmetidor) y antena lejos del circuito del pic a minimo 3 cm
2)idem para el RX(modulo recibidor)
3)un buen ground_plane(plano de tierra) alrededor de la antena del RX y un condensador ceramico de 100nF(desacoplador) entre la alimentaciòn(5V) y GND.te puedo enviar un esquema de una soluciòn simple de ground_plane que estoy usando para los modulos a 434mhz y funciona.
4)si conectando TX del pic transmetidor al Rx del pic recibidor funciona,entonces es un problema de recepciòn del RX.

hace un programa de prueva tipo "HELLO".comenza con un baud de 600 y subis mano a mano hasta 2400(limite maximo de questo modulos economicos)
yo estoy usando el USART en hardware de GCBasic y recibe muy bien hasta unos 50-60 m con baud a 2400.

Código:


''''''''''''''' CONFIGURACION DEL PIC '''''''''''''''''''''''''''
#chip 16F767, 20                                  'modelo de pic y velocidad de reloj

#config CP_OFF,DEBUG_OFF,WDT_OFF,PWRTE_ON,VBOR_2_7,BOREN_0,MCLR_ON,OSC=HS,IESO_OFF,FCMEN_OFF

''''''''''''''' Init USART '''''''''''''''''''''''''''''
#DEFINE USART_BLOCKING
#DEFINE USART_BAUD_RATE 2400
''''''''''''''' SUB PROCEDURAS ''''''''''''''''''''''''''
SUB Envia_dato(Header AS String,Dato AS WORD)
DIM bBytes AS BYTE
FOR bBytes=1 TO 2
    HSerSend 0x0A
    HSerSend "#"
    HSerSend "$"
    WAIT 25 ms
NEXT bBytes
HSerPrint Header
HSerPrint Dato
HSerSend "#"
HSerSend "$"
WAIT 25 ms

END SUB

''''''''''''''' PARAMETROS '''''''''''''''''''''''''
ADCON1=b'10001110'                                'PORTA.0 analogica,las demas digitales.Justificado a derecha.Vref+=Vdd -- Vref-=Vss
INTCON=b'00000000'                                'Interrupts desabilitados
TRISA=b'000001'                                  'PORTA como output
TRISB=b'00000000'                                'PORTB como output
TRISC=b'00011000'                                'Puertas PORTC.3 y PORTC.4 son input
PORTA=b'000000'                                  'Setaje PORTA
PORTB=b'00000000'                                'Setaje PORTB
PORTC=b'00000000'                                'Setaje PORTC
InitUSART
WAIT 1 s
DO
  Envia_dato("BS",ReadAD10(AN0))
  WAIT 2 s
LOOP


es muy simple de usar y de transformar en C(depende de la libreria para C que tiene tu compilador).
una cosa.esta parte del codigo de transmiciòn

Código:

FOR bBytes=1 TO 2
    HSerSend 0x0A
    HSerSend "#"
    HSerSend "$"
    WAIT 25 ms
NEXT bBytes

sirve para tener el "nivel de recepciòn" del modulo alto,despues envio el "mensaje".sin el tenia problemas de recepciòn
practicamente envia un "tren de bit"(0A=1010) antes del "mensaje" verdadero.si quieres los esquemas mi e-mail es publica.
a proposito,es para pikitin.como puedo poner en el sito un programa para calcular el TMR0 en un interrupt?? es en gambas.
atenciòn que es el codigo fuente.podeis modificarlo a placer y mejorar(seguramente ).màs adelante,quando sera posible,voy ha crear el .deb

Sobre colocar archivos en el sitio, no es posible hacerlo de manera automática, por el momento hay que enviarle los archivos a pikitin y él se encarga de subirlos.

Bueno, lo de subir el archivo ya está solucionado.

Quizás sea buena idea que abras un tema en la sección de Gambas, comentes lo que hace el programa y pongas un enlace para la descarga, creo que puede ser util a más de uno.


Saludos.