Transmisión a través de RF433Hz Par de transmisor / receptor con falla AVR

2

Estoy tratando de enviar datos de forma inalámbrica a través de un par de transmisor / receptor RF433Hz, pero nada parece querer funcionar. Quiero que el transmisor envíe continuamente un número (0x81) al receptor cuando presiono un botón bajo activo, Espero ver Ox81 en el lado del receptor pero no lo veo.

int main( void )
{
        //initializeUART ( BAUD , DoubleAsync, DataBitLength, Parity, Stopbits )
        iniUSART0( 1200 , 0 , 8 , 0 , 2 );

        //Code for transmitter
        if(Transmitter)
        {        
            DDRA = 0xff;
            while(1){                        
                        if( bit_is_clear(PINB, 0) )
                        {          
                             data = 0x81;   
                             TransmitData(data);
                             PORTA = 0x81;
                        }
                     }
         }


      //Code For receiver
      if(Receiver)
      { 
      DDRA = 0xff;      
        while(1)
        {    
                     while(!flag)
                     {
                        data = ReceiveData();                           
                        PORTA = data;
                     }
        }        

}

Los métodos se han colocado en un archivo de encabezado separado y se pueden ver a continuación

 unsigned char ReceiveData(void)
    {
        while ( ! UCSR0A & ( 1 << RXC0)) //Check if there ids data waiting for you
        {

        }
        return UDR0; //return data
    }

    void TransmitData( unsigned char data)
    {
        while( !UCSR0A & ( 1 << UDRE0)) //Check if uC is ready to transmit
        {

        }
        UDR0 = data; //Transmit Data
    }


    void iniUSART0(int baud, char doubleAsync, char dataLength, char parity, char numberOfStopBits)
    {

        int UBRR_Value = lrint ( (F_CPU / (16L * baud)) - 1 );

        UBRR0H = (unsigned char) (UBRR_Value >> 8);  //Upper Baud number
        UBRR0L = (unsigned char) UBRR_Value; //Put remainder in lower bits

        //Enable reception and transmission
        UCSR0B |= (unsigned char) (1 << RXEN0) | (1 << TXEN0);


        if(numberOfStopBits == 2)
        {
            UCSR0C |= (1 << USBS0);
        }   
        else 
        {
            UCSR0C &= ~(1 << USBS0);
        }       

        //Use an 8-Bit length data bit
        UCSR0C |= (unsigned char) (1 << UCSZ00);



        //Double Asynchronous mode?
        if(doubleAsync) UCSR0A |= (1 << U2X0); 

        //Set the data bit length

          if ( dataLength == 6) UCSR0C |= ( 1 << UCSZ00 );
          if ( dataLength == 7) UCSR0C |= (1 << UCSZ10);
          if ( dataLength == 8) UCSR0C |= (1 << UCSZ10) | (1 << UCSZ00);

         if(parity == 2)UCSR0C |= (1 << UPM10); //Sets parity to EVEN
         if(parity == 1)UCSR0C |= (1 << UPM10) | (1 << UPM00); //Sets parity

 to ODD
}
    
pregunta KillaKem

1 respuesta

1

Por lo general, no es una buena idea usar un UART y un esquema de comunicación simple con módulos RF de bajo costo. Algunos problemas que encontrarás:

  • A los receptores les gusta una señal de CC balanceada (igual número de unos y ceros), de lo contrario, el cortador de datos no funcionará correctamente. Su ejemplo de 0x81 es 10000001 en binario que contiene una cadena larga de ceros.
  • Los datos recibidos a través de RF pueden tener un poco de sesgo en el momento en que se recibió el final del byte. La mayoría de los UART de hardware diseñados para comunicaciones por cable no se adaptan bien a eso.
  • Antes de enviar datos, normalmente necesitará un preámbulo para que el receptor tenga tiempo de bloquear.
  • Los receptores recibirán datos aleatorios cuando no esté presente la portadora correctamente modificada, por lo que querrá una forma de detectar un paquete / datos válido.

Los Monolíticos de RF tienen una buena nota de aplicación Consideraciones únicas para UARTs de Radio de datos que explora y explica estos problemas . Hace algún tiempo implementé la técnica básica del receptor PLL que describen, junto con un nivel superior de detección de errores y control de paquetes que funcionó bien.

Eso fue un poco de esfuerzo pero ahora está disponible el proyecto VirtualWire que realiza todas esas funciones. Está dirigido a un Arduino, pero debería ser bastante sencillo para moverse a otras plataformas basadas en AVR (u otras arquitecturas).

    
respondido por el PeterJ

Lea otras preguntas en las etiquetas