nRF24L01 para Arduino (AVR), ejemplo con structs

En el último post de esta serie de publicaciones con respecto al módulo de RF nRF24L01, hemos transmitido un simple entero desde un Arduino Nano a un Arduino Mega2560. 

En este caso veremos un pequeño ejemplo, que permitirá transmitir un struct, que estará conformado por 

• ID del paquete
• Cantidad de milisegundos en el que fue enviado el paquete.

El paquete saldrá del Arduino Nano, llegará al Mega el cual simplemente lo recibe, lo imprime en consola por medio del protocolo UART y luego lo reenvía. por su lado el Arduino Nano, se queda esperando un determinado lapso de tiempo. Cuando recibe el paquete que envió calcula la diferencia de milisegundos y la imprime en consola (UART).

La estructura del ejemplo es muy parecida a la del post anterior (sería conveniente volverlo a mirar). Desde el lado del transmisor usamos el struct siguiente:

1:  struct Data_struct {  
2:       uint8_t id;  
3:       uint64_t timing;  
4:  } data_to_send, data_responce;  

Se usará data_to_send para el struct que se envía; y se usa data_responce para el mensaje que se recibe. Se podría usar el mismo y optimizar el código pero opté por mantenerlo simple (y no tan eficiente).

Por el lado del receptor el struct es el siguiente:

1:  struct Data_struct {  
2:       uint8_t id;  
3:       uint64_t timing;  
4:  } data_to_read;  

Envío de datos

Para envíar el dato, primero conformamos el struct. asignamos un ID y llamamos  a la función millis():

1:  data_to_send.id = i;  
2:  data_to_send.timing = millis();  
3:  i++;  
4:  /*Go to TX_MODE*/  
5:  TX_MODE(&data_to_send);  
6:  /*Sending data*/  

Espero mientras se termina el proceso de envío y luego paso al modo de recepción:

1:  /*Wait for transmission end*/  
2:  while(nrf24_isSending());  
3:  RX_MODE(); /*Go to RX MODE*/

La variable lastTiming la utilizo para almacenar el instante en el que envío el paquete (Nota: no es lo más eficiente. Solo es una prueba.)

Si recibo el dato, calculo el tiempo que demora y lo imprimo en pantalla.

Si pasa más de 10000 ms imprimo un mensaje de error, de no llegada de paquetes.

1:     lastTiming = millis();  
2:            do{  
3:                 if(rf_data_ready())  
4:                      {  
5:                           rf_get_data(&data_responce);  
6:                           put_string("\nData recieve correctly\n");  
7:                           put_int(data_responce.id);  
8:                           put_string("\n");  
9:                           put_string("El mensaje tardo: ");  
10:                           put_long(millis() - data_responce.timing);  
11:                           break;  
12:                      }  
13:            }while((lastTiming - temp) < 10000);  
14:            if((lastTiming - temp) > 1000){  
15:                 put_string("\nSending Fails\n");  
16:            }  

Recepción de datos

Para la recepión de datos (en el Arduino Mega2560) simplemente se reciben los paquetes, los imprimo en pantalla y luego se los reenvía, sin realizar ninguna modificación.

1:  if(rf_data_ready())  
2:            {  
3:                 rf_get_data(&data_to_read);  
4:                 put_int(data_to_read.id);  
5:                 put_string("\n");  
6:                 put_long(data_to_read.timing);  
7:                 put_string("\n");  
8:                 TX_MODE(&data_to_read);  
9:                 /*Wait for transmission end*/  
10:                 while(nrf24_isSending());  
11:                 RX_MODE();  
12:            }  

Resultados

El resultado de la ejecución se la ve en la siguiente imágen:

El código del receptor se lo puede encontrar aquí.
El código del transmisor se lo puede encontrar aquí.