Comunicacin Inalmbrica con mdulos de RF de 433Mhz

Posted by Tutoriales 37 Comments

En este tutorial vamos a realizar una comunicacin inalmbrica entre dos Arduino usando mdulos de radiofrecuencia
de bajo costo.
Los mdulos RF de 433Mhz son muy populares por su bajo costo y fcil uso. Vienen en pareja, emisor (FS1000A) y
receptor (XY-MK-5V), el tipo de comunicacin es simplex, es decir en un solo canal y unidireccional, son de baja
velocidad de transmisin pero para aplicaciones bsicas son muy tiles.
La frecuencia de trabajo es de 433MHz, debido a que es una banda de libre uso. Para utilizar estos mdulos basta con
alimentarlos y conectar el pin de datos por un lado del Transmisor (TX) y en otro el Receptor (RX). Para la
programacin no es necesario agregar ningn tipo de librera, ya que es un proceso "transparente", por lo que el
programa sera igual a usar una comunicacin serial (UART) entre 2 MCUs , sin embargo existen algunas libreras que
nos ofrecen ciertas ventajas como: verificacin de errores, mejor transmisin, Direccionamiento, Enrutamiento, mallas,
etc.

Antena para mdulos de 433Mhz

La antena tiene una gran influencia sobre todo en el mdulo receptor, por lo que se recomienda conectar un cable de
cobre de unos 17cm de largo para alcanzar la frecuencia de 433MHz.Tambien son muy comunes y eficientes antenas
helicoidales de 5mm de dimetro y 3.4cm de longitud. La posicin de la antena tambin afecta la recepcin de datos.
Para este tutorial se est usando antenas helicoidales.
Comunicacin Serial con mdulos RF
Para este tipo de comunicacin solo basta con conectar el mdulo RF al Pin RX o TX del Arduino dependiendo si es
transmisor y receptor.
Para este ejemplo usaremos un Arduino el cual transmitir seriamente informacin a travs del RF transmisor, el
mdulo receptor est conectado a un conversor USB serial (Puedes usar otro Arduino en lugar del conversor) y
visualizaremos los datos des de la pc.
La conexin es la siguiente:
Conexiones del emisor:
Conexiones del receptor
Con respecto al programa se trabaja como si se tratase de una comunicacin serial (UART) normal, con el inconveniente
que no existe validacin o seguridad para saber si los datos son transmitidos correctamente. Pero se puede usar para
visualizar mensajes o datos que sean redundantes o que no sean necesarios validar.
Para lograr una mejor transferencia se recomienda usar velocidades de 1200 o 2400 baudios o inferiores.
A continuacin se muestra un cdigo de ejemplo para testear nuestros mdulos.
void setup() {
// Inicializamos la comunicacin serial a 2400 baudios
Serial.begin(2400);

void loop() {
Serial.print("Hola mundo ... ");
Serial.print(millis()); // enviamos los ms transcurridos
Serial.println("ms");
delay(10);
}

Para visualizar los datos recibidos, en herramientas cambiamos al puerto COM al del conversor, abrimos el Monitor
serial y cambiamos la velocidad a 2400 baudios, debemos recibir los datos como se muestra en la siguiente imagen
Existen varios mtodos para validar informacin, una de las ms fcil de implementar es en enviar el mismo dato varias
veces, por ejemplo 3 veces y en el receptor se debe validar verificando que se reciba 3 veces el mismo dato. Otros
mtodos son la paridad, agregar tramas de validacin, sumar los bytes trasmitidos, etc.

Comunicacin inalmbrica RF entre Arduinos usando libreras

Una de las librera ms comunes y eficientes es la VirtualWire desarrollado por Mike McCauley, con esta librera vamos
a trabajar los proximos ejemplos del tutorial
Necesitamos descargar la librera VirtualWire e importarla a nuestro IDE Arduino.
A continuacin explicamos las funciones principales de la librera:

void vw_setup(uint16_t speed)

Inicializar el software VirtualWire, como parmetro hay que indicarle la velocidad de operacin, que representa los
bits por segundo para la transmisin RF

void vw_set_tx_pin(uint8_t pin)

Estable el pin IO digital por donde se va a transmitir los datos

void vw_set_rx_pin(uint8_t pin)

Estable el pin digital IO por donde se va a recibir datos.

void vw_rx_start()
Empieza a escuchar los datos provenientes por el pin_rx, es necesario llamar a esta funcin para poder recibir los datos

uint8_t vw_send(uint8_t * buf,uint8_t len )

Enviar un mensaje con la longitud dada. La funcin termina rpido pero mensaje ser enviado en el momento adecuado
establecido por las interrupciones. Dnde: buf , es el puntero al vector para trasmitir. Y len es el nmero de bytes a
transmitir
void vw_wait_tx()
Hace una pausa hasta que se trasmitan todos los datos.

uint8_t vw_get_message(uint8_t * buf, uint8_t * len )

Si un mensaje est disponible (con buena suma de comprobacin o no), almacena el mensaje en buf , devuelve true si
la comprobacin es correcta. buf es puntero a la ubicacin para guardar los datos de lectura y leng es un puntero a la
cantidad de bytes disponibles de buf.

Conexiones entre el modulo RF y Arduino.

Antes de empezar a programar necesitamos hacer las siguientes conexiones:
Conexiones del Emisor:
Conexiones del receptor:
Ej.1 Encender y apagar una Led de forma inalmbrica:
En este ejemplo se encender un led conectado al pin 13 del Arduino, para apagar y prender se lo har de forma remota
desde otro Arduino, para enviar la orden lo haremos desde la PC pero se lo puede hacer a travs de un pulsador.
El cdigo del Emisor es el siguiente:
#include <VirtualWire.h>

void setup()
{
Serial.begin(9600);
Serial.println("Emisor RF");

// Se inicializa el RF
vw_setup(2000); // velocidad: Bits per segundo
vw_set_tx_pin(2); //Pin 2 como salida para el RF
}

void loop()
{

while (Serial.available() > 0)

{
char dato[1];
dato[0] = Serial.read();
//Enviamos el carcter recibido al RF
vw_send((uint8_t*)dato,sizeof(dato));
vw_wait_tx();
}
delay(200);
}

Como se observa el programa enva inalmbricamente el dato que recibe por el puerto serie.

EL cdigo del receptor se muestra a continuacin:

#include <VirtualWire.h>

void setup()
{
 Serial.begin(9600); // Debugging only
Serial.println("setup");

// Se inicializa el RF
vw_setup(2000); // velocidad: Bits per segundo
vw_set_rx_pin(2); //Pin 2 como entrada del RF
vw_rx_start(); // Se inicia como receptor

pinMode(13, OUTPUT); //Configuramos el pin del Led como entrada

digitalWrite(13, false);
}

void loop()
{
uint8_t dato;
uint8_t datoleng=1;
//verificamos si hay un dato valido en el RF
if (vw_get_message(&dato,&datoleng))
{
if((char)dato=='a')
{
digitalWrite(13, true); //Encendemos el Led
}
else if((char)dato=='b')
{
digitalWrite(13, false); //Apagamos el Led
}
}
}

Para encender el led es necesario abrir el monitor serial del trasmisor y enviar una a o b para encender o apagar el
Led respectivamente

Ej.2 Enviando Mensajes Entre mdulos RF

En este ejemplo un Arduino enva una mensaje Hola mundo hacia otro Arduino receptor, para visualizar el mensaje
recibido usaremos el monitor serial.
Cdigo del Emisor:

#include <VirtualWire.h>

void setup()
{
Serial.begin(9600);
Serial.println("Emisor: Setup");

// Se inicializa el RF
vw_setup(2000); // velocidad: Bits per segundo
vw_set_tx_pin(2); //Pin 2 como salida para el RF
}

void loop()
{
const char *msg = "Hola mundo";

digitalWrite(13, true); // Parpadeamos el led al enviar

vw_send((uint8_t *)msg, strlen(msg));
vw_wait_tx(); //Esperamos hasta que el mensaje se envie
digitalWrite(13, false);
delay(200);
}

Cdigo del receptor:

#include <VirtualWire.h>

void setup()
{
Serial.begin(9600); // Debugging only
Serial.println("Emisor: Setup");

// Se inicializa el RF
vw_setup(2000); // velocidad: Bits per segundo
vw_set_rx_pin(2); //Pin 2 como entrada del RF
vw_rx_start(); // Se inicia como receptor
}

void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
//verificamos si hay un dato valido en el RF
if (vw_get_message(buf, &buflen))
{
int i;

digitalWrite(13, true); // Parpadeamos el led al recibir

//verificamos si hay un dato valido en el RF
Serial.print("Mensaje: ");

for (i = 0; i < buflen; i++)

{
Serial.print((char)buf[i]);
}
Serial.println("");
digitalWrite(13, false);
}
}

Para visualizar los datos es necesario abrir el monitor serial del receptor.
Ej.3 Enviando datos y variables con los mdulos RF
La librera principalmente trasmite cadenas de bytes, que pueden ser una cadena de texto o un dato convertido en
cadena, pero cuando se necesitan enviar varios datos hay dos formas de hacerlo, un mtodo es empaquetar todo en
una sola trama y enviarlo, el receptor debe de desempaquetar y obtener los datos.
Otra forma ms sencilla es enviar un inicio de trama diferente para cada dato, el cual indicara al receptor que dato es
el que se est enviando, el siguiente ejemplo lo hacemos de esta forma, enviaremos dos datos, cada uno con un inicio
de trama diferente.
Cdigo del emisor:
#include <VirtualWire.h>

void setup()
{
Serial.begin(9600); // Debugging only
Serial.println("setup");

// Se inicializa el RF
vw_setup(2000); // velocidad: Bits per segundo
vw_set_tx_pin(2); //Pin 2 como salida para el RF
}

void loop()
{
char buf[VW_MAX_MESSAGE_LEN]; // Cadena para enviar
int dato1=millis()/1000; //variable con el tiempo en segundos
float dato2=3.14; //segundo dato para enviar
String str="";

str="i"+String(dato1); //convertimos el entero a String y agramos un inicio de trama

str.toCharArray(buf,sizeof(buf)); //convertimos el String en un array
vw_send((uint8_t *)buf, strlen(buf)); //Enviamos el array
 vw_wait_tx(); //Esperamos hasta que el mensaje se envie

str="f"+String(dato2); //convertimos el float a String y agramos un inicio de trama

str.toCharArray(buf,sizeof(buf)); //convertimos el String en un array
vw_send((uint8_t *)buf, strlen(buf)); ////Enviamos el array
vw_wait_tx(); //Esperamos hasta que el mensaje se envie

delay(200);
}

Cdigo del Receptor

#include <VirtualWire.h>

void setup()
{
Serial.begin(9600); // Debugging only
Serial.println("Receptor: setup");

// Se inicializa el RF
vw_setup(2000); // velocidad: Bits per segundo
vw_set_rx_pin(2); //Pin 2 como entrada del RF
vw_rx_start(); // Se inicia como receptor
}

void loop()
{
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
int dato1=0;
float dato2=0.0;
//verificamos si hay un dato valido en el RF
if (vw_get_message((uint8_t *)buf,&buflen))
{
int i;
String DatoCadena="";
 if((char)buf[0]=='i') //verificamos el inicio de trama
{
for (i = 1; i < buflen; i++)
{
DatoCadena.concat((char)buf[i]);
}
dato1=DatoCadena.toInt();
Serial.print("Dato1 recivido: ");
Serial.println(dato1);
}
else if((char)buf[0]=='f') //verificamos el inicio de trama
{
for (i = 1; i < buflen; i++)
{
DatoCadena.concat((char)buf[i]);
}
dato2=DatoCadena.toFloat();
Serial.print("Dato2 recivido: ");
Serial.println(dato2);
}
}
}

Los datos lo visualizaremos en el monitor serial del receptor

Pueden adquirir los materiales usados en este tutorial en nuestra
tienda
- Arduino Uno R3
- Mdulo RF 433MHz TX y RX
- Cable Dupont, hembra a macho 20cm x 20Und