¿Te imaginas prender un LED, abrir el portón del garaje o disparar un relé desde el otro lado de la pieza sin tirar un solo cable? Eso es exactamente lo que resuelven los módulos de radiofrecuencia de 433MHz: un par chiquito y barato que le da "voz" inalámbrica a cualquier Arduino. En este tutorial vas a montar un enlace de radio funcional entre dos placas Arduino y, al final, vas a escribir 1, 2 o 3 en el monitor serial de una placa para encender, apagar o hacer parpadear un LED conectado a la otra. Sin WiFi, sin Bluetooth, sin pareo: pura radio.

Más importante que copiar el cableado, vas a entender por qué funciona, qué hace la librería VirtualWire por debajo y cómo estirar el alcance de 3 metros a más de 100 con un truco de antena que cuesta cero pesos.

Cómo funciona un enlace de 433MHz (el concepto antes del cable)

Estos módulos trabajan como un enlace simplex: los datos viajan en un solo sentido, del transmisor al receptor, nunca al revés. Suena limitado, pero para la mayoría de los proyectos de control remoto es justo lo que necesitas. No requieren configuración, no se emparejan y no negocian nada: el transmisor escupe la señal y el receptor la atrapa si está en rango.

La banda de 433MHz es de uso libre en buena parte del mundo y la modulación que usan estos módulos baratos es ASK (Amplitude Shift Keying): básicamente prenden y apagan la portadora de radio para representar unos y ceros. Es simple y robusta para tasas de datos bajas, que es justo el caso de un control remoto o un sensor que reporta cada cierto rato.

El problema es que esa señal cruda viene con ruido y sin sincronización. Acá entra la magia del software: la librería VirtualWire se encarga de armar las tramas, agregar bits de sincronización, codificar los datos y filtrar el ruido del lado del receptor. Sin ella, leer estos módulos a pelo es una pesadilla. Con ella, mandar un dato es tan fácil como un vw_send().

Estas son algunas aplicaciones reales donde brillan: apertura de portones de garaje, control de persianas o cortinas, encendido de luces, monitoreo remoto de procesos, alarmas y seguridad, y telemetría sencilla de uno o varios nodos hacia un punto central.

Lo que necesitas

Para este montaje vas a usar dos placas Arduino (una hace de emisor y la otra de receptor), el par de módulos RF 433MHz, unos cuantos jumpers macho hembra y un LED. El kit típico trae el transmisor (la plaquita con el resonador SAW marcado FS1000A) y el receptor (la plaquita más grande con el integrado y la bobina). Más abajo te dejo el detalle exacto con stock local.

Módulos transmisor y receptor RF 433MHz para encender un LED con Arduino

Antes de tocar el hardware, prepara el software:

  1. Descarga la librería VirtualWire (link directo en la sección de Recursos al final).
  2. En el IDE de Arduino ve a Programa > Incluir Librería > Añadir biblioteca .ZIP y selecciona el archivo descargado.
  3. Listo: ya puedes usar #include <VirtualWire.h> en ambos sketches.

Lado transmisor: el que manda la orden

El transmisor es la plaquita más chica. Tiene tres pines y el cableado al Arduino es directo:

  • VCC al 5V del Arduino
  • GND al GND
  • OUT (dato) al pin 12

Diagrama de conexión del transmisor 433MHz al Arduino Uno

Este Arduino va a leer lo que escribas en el monitor serial. Cuando mandes un 1, transmite el caracter "1"; con 2 transmite "2"; con 3 transmite "3". Cada caracter viaja por el aire hacia el receptor. Carga este código (acuérdate de tener la librería ya instalada):

C++ 
/*ElectroCrea.com

Transmisor     Arduino
----------------------------
 VCC           5V
 GND           GND
 OUT           12              
*/
#include <VirtualWire.h>//Incluimos esta librería
char *controller;
int state = 0;
int flag = 0;
////////////////////////////////////////////////////////////////////VOID SETUP
void setup() {
vw_set_ptt_inverted(true); 
vw_set_tx_pin(12);//Pin de Arduino
vw_setup(4000);//Velocidad de la transmisión de datos
Serial.begin(9600);
}
////////////////////////////////////////////////////////////////////VOID LOOP
void loop(){
if(Serial.available() > 0){
state = Serial.read();
flag=0;
}

////////////////////////////ACCION 1
if (state == '1') {//Escribimos 1 en monitor serial
controller= "1"  ;//Se envía 1
vw_send((uint8_t *)controller, strlen(controller));
vw_wait_tx(); //Espera a que se envie el mensaje completo
if(flag==0){//Flag evita que el texto se repita infinitamente
Serial.println("LED: Encendido");
flag=1;
}
}

////////////////////////////ACCION 2    
else if (state == '2') {//Escribimos 2 en monitor serial
controller= "2"  ;
vw_send((uint8_t *)controller, strlen(controller));
vw_wait_tx(); 
if(flag==0){
Serial.println("LED: Apagado");
flag=1;
}
}

////////////////////////////ACCION 3   
else if (state == '3') {//Escribimos 3 en monitor serial
controller= "3"  ;
vw_send((uint8_t *)controller, strlen(controller));
vw_wait_tx(); 
if(flag==0){
Serial.println("LED: Parpadeando");
flag=1;
}
}

}
//Mas información en ElectroCrea.com

Fíjate en dos detalles del setup que valen oro: vw_setup(4000) fija la velocidad del enlace en 4000 bits por segundo (tiene que ser idéntica en ambos lados o no se entienden), y vw_set_ptt_inverted(true) ajusta la polaridad de la señal que esperan estos módulos chinos. La variable flag está para que el mensaje en el monitor serial no se repita infinito mientras mantienes la misma orden: se imprime una sola vez por cambio de estado.

Lado receptor: el que ejecuta la acción

El receptor es la plaquita más grande. El cableado es igual de simple, solo que ahora el dato sale del receptor hacia el Arduino, y agregamos un LED en el pin 13:

  • VCC al 5V del Arduino
  • GND al GND
  • OUT (dato) al pin 12
  • LED en el pin 13 (con su resistencia, o usa el LED integrado de la placa)

Diagrama de conexión del receptor 433MHz y el LED al Arduino Uno

El receptor queda escuchando todo el tiempo. Cuando llega un "1" enciende el LED, con "2" lo apaga, y con "3" lo hace parpadear. Este es el código:

C++ 
/*ElectroCrea.com

Receptor     Arduino
----------------------------
 VCC         5V
 GND         GND
 OUT         12              
*/
#include <VirtualWire.h>//Incluimos esta librería
int led = 13;
////////////////////////////////////////////////////////////////////VOID SETUP
void setup(){
vw_set_ptt_inverted(true);
vw_set_rx_pin(12);//Pin de Arduino
vw_setup(4000);//Velocidad de la transmisión de datos
pinMode(led, OUTPUT);
vw_rx_start();     
}
////////////////////////////////////////////////////////////////////VOID LOOP
void loop(){
uint8_t buf[VW_MAX_MESSAGE_LEN];
uint8_t buflen = VW_MAX_MESSAGE_LEN;
if (vw_get_message(buf, &buflen)){ //No bloqueada
 
////////////////////////////ACCION 1   
if(buf[0]=='1'){//Si recibimos 1
digitalWrite(led,HIGH);//Se enciende el led
} 
////////////////////////////ACCION 2
if(buf[0]=='2'){
digitalWrite(led,LOW);//Se apaga el led
}
////////////////////////////ACCION 3
if(buf[0]=='3'){
digitalWrite(led,LOW);//Parpadea el led
delay (200);
digitalWrite(led,HIGH);
delay (200);
}

}
}
//Mas información en ElectroCrea.com

La parte clave acá es vw_get_message(buf, &buflen): es una lectura no bloqueante, o sea, el Arduino no se queda congelado esperando datos. Si llegó un mensaje válido (con su sincronización y sin errores), devuelve verdadero y guarda los bytes en buf. Por eso solo leemos buf[0], el primer caracter, que es donde viaja nuestro "1", "2" o "3".

Pruébalo

Conecta los dos Arduino por USB. Abre el monitor serial del transmisor (a 9600 baudios) y escribe 1: el LED del receptor debería encenderse. Escribe 2 y se apaga; 3 y empieza a parpadear. Si nada responde, revisa lo de siempre: que ambos vw_setup() tengan la misma velocidad, que VCC y GND no estén cruzados, y que los pines de dato coincidan con el código (pin 12 en ambos).

El truco de la antena: de 3 metros a más de 100

Acá está el detalle que casi todos pasan por alto. Tal cual sale de la caja, el enlace anda apenas unos metros. Para multiplicar el alcance solo necesitas soldar un pedacito de cable rígido al pin ANT de cada módulo. ¿Por qué funciona? Porque a 433MHz la longitud de onda completa es de unos 69cm, y una antena de un cuarto de onda mide aproximadamente 17.3cm. Ese pedazo de alambre actúa como antena resonante y, dependiendo de la calidad y orientación, te puede dar entre 100 y 300 metros de alcance al aire libre.

No es magia, es física: una antena del largo correcto irradia y capta muchísima más energía a esa frecuencia que el pin pelado. Corta dos trozos de 17.3cm de cable rígido (uno para el transmisor, otro para el receptor), suéldalos al pin de antena y nota la diferencia.

Variantes y mejoras

Una vez que tengas el enlace andando, hay harto para crecer:

  • Manda más que un caracter: en lugar de enviar "1", "2" o "3", puedes transmitir cadenas completas o estructuras de datos. Arma un sensor de temperatura DHT22 en el lado transmisor y reporta las lecturas por radio al receptor, que las muestra en una pantalla. Tienes una estación meteorológica inalámbrica sin pagar un peso de datos.
  • Varios transmisores, un receptor: como varios lectores de ElectroCrea preguntaban, sí se puede tener un solo receptor escuchando a varios transmisores. El truco es que cada transmisor mande un identificador propio al inicio del mensaje (por ejemplo "A1", "B2"), y el receptor decida qué hacer según el primer caracter. Así sabes cuál control remoto se activó.
  • Controla cargas reales con un relé: cambia el LED del pin 13 por un módulo relé y ya estás encendiendo una ampolleta de 220V, un motor o lo que quieras, de forma inalámbrica y segura.
  • Encripta o valida: para proyectos de seguridad (como una cerradura), agrega un código rodante o un checksum simple para que no cualquiera pueda replicar la señal con otro transmisor 433MHz genérico.

Personalización para Chile

En Chile consigues todo lo necesario en MechatronicStore, con stock local y despacho rápido:

  • Kit de Radiofrecuencia 433MHz 5V (Transmisor y Receptor) (SKU GP3-6): $2.490 CLP. Es exactamente el par de módulos FS1000A + receptor que usa este tutorial.
  • Arduino Uno R3 compatible (SKU N-301): $7.890 CLP. Necesitas dos (uno emisor, uno receptor); cumplen la misma función que cualquier Uno original a un precio mucho más amable para experimentar.

Los jumpers macho hembra, el LED de 5mm y el pedazo de cable rígido para la antena son insumos básicos que probablemente ya tengas en tu caja de maker. Si te falta alguno, búscalo en la tienda por su nombre.

Recursos

Versión chilena basada en el tutorial de ElectroCrea, ampliada con la explicación de la modulación ASK, el cálculo de la antena de cuarto de onda y componentes en stock local en MechatronicStore.