Módulo RF 433 MHz Arduino: emisor, receptor, antena y código

Un módulo RF de 433 MHz es la forma más barata de añadir una conexión inalámbrica a un proyecto con Arduino: un kit formado por un emisor (FS1000A) y un receptor (XY-MK-5V) cuesta muy poco, se conecta con un solo cable de datos y, con una antena de cable de 17 cm, lleva la señal a decenas de metros. Los enchufes con mando a distancia, los timbres inalámbricos, los mandos de persianas, los sensores de puertas y ventanas y los sensores exteriores de las estaciones meteorológicas también suelen usar la misma frecuencia. Por eso, con estos módulos puedes enviar datos entre dos Arduino y, además, leer los códigos de los mandos que ya tienes en casa y volver a enviarlos desde un Arduino.

En esta guía aprenderás cómo funcionan los módulos con modulación ASK (OOK), por qué la antena debe medir 17,3 cm y cómo conectarlos a un Arduino Uno, un ESP32 y una Raspberry Pi Pico. Después enviarás texto y datos de sensores entre dos Arduino con la librería RadioHead, leerás y clonarás el código del mando de un enchufe con la librería RCSwitch, verás cómo aumentar el alcance y compararás el módulo con el nRF24L01.

¿Qué es un módulo RF de 433 MHz y cómo funciona?

El kit consta de dos placas separadas. El pequeño emisor cuadrado FS1000A (también se vende como XY-FST) enciende y apaga una onda portadora de 433,92 MHz según la señal que llega a su pin DATA. El receptor XY-MK-5V, más alargado, capta esa señal del aire y la vuelve a entregar como ceros y unos por su pin DATA. Es decir, los módulos en sí no tienen protocolo, dirección ni control de errores; su única tarea es llevar una señal digital sin cables hasta el otro lado. Empaquetar, verificar y decodificar los datos es trabajo de la librería del Arduino. La comunicación es unidireccional: el emisor solo envía y el receptor solo escucha.

Los dos pines DATA del receptor están unidos en la placa, así que da igual cuál uses. El XY-MK-5V es un receptor superregenerativo barato pero poco selectivo: su frecuencia la fija una bobina ajustable de la placa y le afectan fácilmente las interferencias cercanas. No gires el tornillo de esa bobina; si se pierde el ajuste de fábrica, el receptor deja de oír al emisor. Si buscas resultados más estables, los receptores superheterodinos como el RXB6 son más sensibles y también funcionan a 3,3 V. El kit se vende también en versión de 315 MHz; emisor y receptor deben tener la misma frecuencia, y el resonador metálico de la placa del emisor suele llevar la frecuencia impresa.

Modulación ASK (OOK): ¿por qué necesitas una librería?

En la OOK (On-Off Keying), la forma más sencilla de ASK (Amplitude Shift Keying, modulación por desplazamiento de amplitud), la portadora se enciende para un bit 1 y se apaga para un bit 0. Parece fácil, pero el receptor tiene una manía: su control automático de ganancia (AGC) sube la ganancia al máximo cuando no hay señal, confunde el ruido del aire con datos y saca pulsos aleatorios por el pin DATA todo el tiempo. Por eso, conectar el emisor directamente al pin TX del Arduino y el receptor al RX e intentar comunicarse con Serial.print suele acabar en caracteres sin sentido.

El driver RH_ASK de la librería RadioHead resuelve este problema así: antes de cada paquete envía un preámbulo de 36 bits y un símbolo de inicio de 12 bits para que la ganancia del receptor se estabilice. Después convierte cada byte en dos símbolos de 6 bits equilibrados en continua (codificación de 4 a 6) y añade un CRC de 16 bits al final del paquete. El receptor descarta en silencio los paquetes cuyo CRC no coincide, de modo que solo te llegan datos íntegros. RCSwitch, en cambio, decodifica la codificación por ancho de pulso que usan los chips de los mandos: cada bit se representa con pulsos que permanecen en HIGH y LOW durante tiempos determinados.

Longitud de la antena de 433 MHz: ¿por qué 17,3 cm?

Los módulos no traen antena; solo tienen un punto de soldadura marcado como ANT. Sin antena, un kit solo funciona a 1–3 metros. La antena sencilla más eficiente es un cable recto de un cuarto de longitud de onda: λ = c / f = 300 000 000 / 433 920 000 ≈ 0,69 m, y un cuarto de eso son unos 17,3 cm. Para los módulos de 315 MHz el mismo cálculo da 23,8 cm. Suelda un extremo de un cable rígido de un solo hilo al punto ANT y mantén el cable recto y vertical; suelda también un cable de la misma longitud al receptor y orienta las dos antenas en la misma dirección.

Conexión del módulo RF de 433 MHz: Arduino Uno, ESP32 y Pico

El emisor funciona sin problemas con una señal de 3,3 V en su pin DATA, así que en el ESP32 y la Pico puedes alimentarlo a 5 V y conectar DATA directamente a un GPIO. Lo que más influye en el alcance es la tensión del emisor: a 3,3 V el alcance baja claramente y a 9–12 V se multiplica. Colocar un condensador cerámico de 100 nF y uno electrolítico de 10 µF justo al lado de los pines VCC y GND del receptor reduce el ruido de la alimentación y mejora la recepción de forma visible.

Enviar mensajes entre dos Arduino con RadioHead

1. Abre el Gestor de Librerías del Arduino IDE, busca RadioHead e instala la librería de Mike McCauley. Si necesitas más detalles, consulta cómo añadir una librería en Arduino.
2. Conecta el emisor al primer Arduino: DATA → D12, VCC → 5V, GND → GND.
3. Conecta el receptor al segundo Arduino: DATA → D11, VCC → 5V, GND → GND.
4. Suelda un cable de 17,3 cm al punto ANT de cada módulo.
5. Carga el código del emisor en la primera placa y el del receptor en la segunda, y abre el Monitor Serie en el lado del receptor a 9600 baudios.

1#include <RH_ASK.h>
2#include <SPI.h>                  // RadioHead derlemesi için / needed for RadioHead to compile
3
4RH_ASK rf(2000, 11, 12);          // hız (bps), RX pini, TX pini / speed (bps), RX pin, TX pin
5unsigned int sayac = 0;
6
7void setup() {
8  Serial.begin(9600);
9  if (!rf.init()) Serial.println("RF init hatasi / failed");
10}
11
12void loop() {
13  char mesaj[24];
14  snprintf(mesaj, sizeof(mesaj), "Merhaba %u", sayac++);
15  rf.send((uint8_t *)mesaj, strlen(mesaj));
16  rf.waitPacketSent();            // paket bitene kadar bekle / wait until the packet is sent
17  Serial.print("Gonderildi / sent: ");
18  Serial.println(mesaj);
19  delay(1000);
20}

1#include <RH_ASK.h>
2#include <SPI.h>                  // RadioHead derlemesi için / needed for RadioHead to compile
3
4RH_ASK rf(2000, 11, 12);          // vericiyle aynı hız / same speed as the transmitter
5
6void setup() {
7  Serial.begin(9600);
8  if (!rf.init()) Serial.println("RF init hatasi / failed");
9}
10
11void loop() {
12  uint8_t buf[RH_ASK_MAX_MESSAGE_LEN + 1];   // +1: metin sonu için / +1 for the string terminator
13  uint8_t len = RH_ASK_MAX_MESSAGE_LEN;      // her turda yeniden ayarla / reset on every pass
14  if (rf.recv(buf, &len)) {                  // yalnız CRC doğruysa true / true only if the CRC is valid
15    buf[len] = '\0';
16    Serial.print("Alindi / received: ");
17    Serial.println((char *)buf);
18  }
19}

En el código del receptor es importante volver a ajustar la variable len en cada vuelta: recv() escribe en ella el tamaño del paquete recibido y, en la siguiente llamada, ese valor se toma como el tamaño del búfer; si no la reajustas, los mensajes más largos se recortan. Si todo va bien, verás cada segundo las líneas "Merhaba 0", "Merhaba 1" en el Monitor Serie. Si se saltan números, algunos paquetes se han perdido por el camino; en ese caso revisa la antena y la alimentación.

Enviar datos de sensores: un paquete con struct

En proyectos reales es más eficiente enviar números que texto. Puedes reunir tus lecturas en un struct y enviar sus bytes tal cual. El emisor de abajo envía cinco veces por segundo el valor de una LDR o un potenciómetro conectado a A0 y el estado del pulsador de D2. El receptor enciende el LED de D13 cuando se pulsa el botón remoto y detecta los paquetes perdidos.

1#include <RH_ASK.h>
2#include <SPI.h>
3
4struct __attribute__((packed)) Paket {   // iki tarafta birebir aynı olmalı / must be identical on both sides
5  uint16_t no;                           // paket numarası / packet number
6  int16_t deger;                         // analog değer / analog value
7  uint8_t buton;                         // 1 = basılı / 1 = pressed
8};
9
10RH_ASK rf;                               // varsayılan: 2000 bps, RX 11, TX 12 / defaults
11Paket p = {0, 0, 0};
12
13void setup() {
14  pinMode(2, INPUT_PULLUP);              // buton D2-GND / button D2-GND
15  rf.init();
16}
17
18void loop() {
19  p.no++;
20  p.deger = analogRead(A0);              // örneğin LDR ya da potansiyometre / e.g. LDR or potentiometer
21  p.buton = (digitalRead(2) == LOW);
22  rf.send((uint8_t *)&p, sizeof(p));
23  rf.waitPacketSent();
24  delay(200);
25}

1#include <RH_ASK.h>
2#include <SPI.h>
3
4struct __attribute__((packed)) Paket {
5  uint16_t no;
6  int16_t deger;
7  uint8_t buton;
8};
9
10RH_ASK rf;
11const int LED = 13;
12uint16_t sonNo = 0;
13
14void setup() {
15  Serial.begin(9600);
16  pinMode(LED, OUTPUT);
17  rf.init();
18}
19
20void loop() {
21  Paket p;
22  uint8_t len = sizeof(p);
23  if (rf.recv((uint8_t *)&p, &len) && len == sizeof(p)) {
24    digitalWrite(LED, p.buton ? HIGH : LOW);   // uzaktaki buton LED'i yakar / remote button lights the LED
25    if (sonNo != 0 && p.no != (uint16_t)(sonNo + 1)) {
26      Serial.println("Paket kaybi / packet lost");
27    }
28    sonNo = p.no;
29    Serial.print(p.no);
30    Serial.print("  A0 = ");
31    Serial.println(p.deger);
32  }
33}

La expresión __attribute__((packed)) impide que el compilador añada huecos de relleno entre los campos. Esto es importante: el mismo struct puede ocupar 5 bytes en un Arduino Uno y 6 en un ESP32, y los datos se desplazan cuando se comunican dos placas distintas. Gracias al número de paquete, el receptor puede contar las pérdidas. Como los módulos de 433 MHz no tienen confirmación de recepción, es buena costumbre repetir varias veces las órdenes importantes. Si pones emisor y receptor en ambos lados, también puedes montar una comunicación con confirmación y reintentos usando la clase RHReliableDatagram de RadioHead.

Leer los códigos de mandos comerciales con RCSwitch

Muchos enchufes con mando, timbres inalámbricos, mandos de persianas y de puertas de jardín, así como sensores de puertas, ventanas y alarmas PIR, usan chips codificadores como el EV1527 o el PT2262. En cada pulsación, estos chips envían el mismo código de 12 a 24 bits varias veces seguidas, con pausas de sincronización entre medias. La librería RCSwitch (rc-switch en el Gestor de Librerías) decodifica estos códigos. En el Uno, conecta el pin DATA del receptor a un pin de interrupción, es decir, D2 o D3, y carga el código siguiente:

1#include <RCSwitch.h>
2
3RCSwitch rf = RCSwitch();
4
5void setup() {
6  Serial.begin(9600);
7  rf.enableReceive(digitalPinToInterrupt(2));   // alıcı DATA -> D2 (kesme pini) / receiver DATA -> D2 (interrupt pin)
8  Serial.println(F("Kumandanin tusuna bas / press a remote button"));
9}
10
11void loop() {
12  if (rf.available()) {
13    Serial.print(F("Kod / code: "));
14    Serial.print(rf.getReceivedValue());
15    Serial.print(F("  Bit: "));
16    Serial.print(rf.getReceivedBitlength());
17    Serial.print(F("  Protokol / protocol: "));
18    Serial.print(rf.getReceivedProtocol());
19    Serial.print(F("  Darbe / pulse: "));
20    Serial.print(rf.getReceivedDelay());
21    Serial.println(F(" us"));
22    rf.resetAvailable();                         // bir sonraki koda hazırlan / get ready for the next code
23  }
24}

Abre el Monitor Serie y pulsa un botón del mando; verás una línea como "Kod / code: 5393 Bit: 24 Protokol / protocol: 1 Darbe / pulse: 350 us". Apunta el código, el número de bits, el protocolo y la duración del pulso de cada botón; para clonarlo necesitarás los cuatro. En los mandos con EV1527, los primeros 20 de los 24 bits son el identificador del mando y los 4 últimos el botón pulsado; por eso los códigos de los botones de un mismo mando son muy parecidos. En el protocolo 1 una unidad dura unos 350 µs: un bit 0 es 1 unidad en HIGH y 3 en LOW, un bit 1 son 3 unidades en HIGH y 1 en LOW, y la sincronización es 1 unidad en HIGH y 31 en LOW.

Enviar el código del mando desde el Arduino

Para enviar el código que has leído, conecta el pin DATA del emisor a D10 y dos pulsadores entre D4 y D5 y GND. Cada vez que pulses un botón, el Arduino repetirá el código 10 veces, igual que el mando; los botones de encendido y apagado del enchufe ahora están en tu Arduino:

1#include <RCSwitch.h>
2
3RCSwitch rf = RCSwitch();
4const int BTN_AC = 4;            // "aç" butonu D4-GND / "on" button D4-GND
5const int BTN_KAPAT = 5;         // "kapat" butonu D5-GND / "off" button D5-GND
6
7void setup() {
8  pinMode(BTN_AC, INPUT_PULLUP);
9  pinMode(BTN_KAPAT, INPUT_PULLUP);
10  rf.enableTransmit(10);         // verici DATA -> D10 / transmitter DATA -> D10
11  rf.setProtocol(1);             // önce protokol... / protocol first...
12  rf.setPulseLength(350);        // ...sonra okuduğun darbe süresi / ...then the pulse length you read
13  rf.setRepeatTransmit(10);      // her gönderim 10 kez tekrarlanır / each send is repeated 10 times
14}
15
16void loop() {
17  if (digitalRead(BTN_AC) == LOW) {
18    rf.send(5393, 24);           // okuduğun "aç" kodu ve bit sayısı / the "on" code and bit length you read
19    delay(300);
20  }
21  if (digitalRead(BTN_KAPAT) == LOW) {
22    rf.send(5396, 24);           // okuduğun "kapat" kodu / the "off" code you read
23    delay(300);
24  }
25}

Como setProtocol() devuelve la duración del pulso al valor por defecto del protocolo, llama siempre a setPulseLength() después. Si el enchufe no responde, escribe primero exactamente la duración de pulso que leíste (p. ej., 320 o 420 µs) y luego sube las repeticiones a 15. Los enchufes con código de aprendizaje ofrecen otro atajo: si pones el enchufe en modo aprendizaje y envías cualquier código de 24 bits desde el Arduino, el enchufe lo guarda en su memoria. Así puedes crear tus propios códigos sin clonar ningún mando.

Receptor de 433 MHz con ESP32: controlar un relé con un mando

El ESP32 es un puente ideal para llevar los mandos de 433 MHz al mundo Wi-Fi. RCSwitch también funciona en el ESP32 y, como todos sus GPIO admiten interrupciones, puedes conectar el receptor al pin seguro que prefieras. El código siguiente lee los códigos de un receptor conectado a GPIO 27 (con divisor de tensión); cuando llega el código de tu propio mando, conmuta el LED de GPIO 2 o un módulo de relé. Como el mando envía el código muchas veces en una sola pulsación, el programa no vuelve a conmutar hasta que el código haya dejado de llegar durante 600 ms:

1#include <RCSwitch.h>
2
3RCSwitch rf = RCSwitch();
4const int RX_PIN = 27;              // alıcı DATA, gerilim bölücüyle / receiver DATA, through a divider
5const int ROLE_PIN = 2;             // dahili LED ya da röle girişi / onboard LED or relay input
6const unsigned long KOD = 5393;     // kendi kumandanın kodu / your own remote's code
7bool durum = false;
8unsigned long sonGorulme = 0;
9
10void setup() {
11  Serial.begin(115200);
12  pinMode(ROLE_PIN, OUTPUT);
13  rf.enableReceive(digitalPinToInterrupt(RX_PIN));   // ESP32'de her GPIO kesme alır / every GPIO takes interrupts on the ESP32
14}
15
16void loop() {
17  if (rf.available()) {
18    unsigned long kod = rf.getReceivedValue();
19    Serial.printf("Kod / code: %lu  %u bit  protokol %u\n", kod, rf.getReceivedBitlength(), rf.getReceivedProtocol());
20    if (kod == KOD) {
21      // kumanda kodu art arda tekrarlar; yalnız yeni basışta değiştir / the remote repeats the code; toggle only on a new press
22      if (millis() - sonGorulme > 600) {
23        durum = !durum;
24        digitalWrite(ROLE_PIN, durum ? HIGH : LOW);
25      }
26      sonGorulme = millis();
27    }
28    rf.resetAvailable();
29  }
30}

Sobre esta base puedes construir mucho: reenvía los códigos recibidos a Home Assistant por MQTT para sumar sensores de puerta de 433 MHz baratos a tu domótica, o controla enchufes desde el móvil con un emisor en GPIO 26. RadioHead también es compatible con el ESP32; la única diferencia es que escribes los pines de forma explícita en el constructor: RH_ASK rf(2000, 27, 26, 25); (receptor 27, emisor 26 y 25 como pin libre para PTT). Si el ESP32 es nuevo para ti, echa un vistazo a ¿Qué es el ESP32?.

Emisor de 433 MHz con Raspberry Pi Pico y MicroPython

MicroPython no tiene un equivalente listo de RCSwitch, pero la temporización del protocolo 1 es tan sencilla que puedes escribirla tú mismo en pocas líneas. Conecta el VCC del FS1000A al pin VBUS (5 V) de la Pico, DATA a GP15 y un pulsador entre GP16 y GND. Al pulsarlo, la Pico envía los 24 bits empezando por el más significativo, igual que RCSwitch, añade el pulso de sincronización al final y repite el paquete completo 10 veces. Si todavía no sabes instalar MicroPython en la Pico, empieza por ¿Qué es la Raspberry Pi Pico?.

1from machine import Pin
2import time
3
4tx = Pin(15, Pin.OUT, value=0)        # FS1000A DATA -> GP15
5buton = Pin(16, Pin.IN, Pin.PULL_UP)  # buton GP16-GND / button GP16-GND
6T = 350                               # darbe süresi µs (RCSwitch protokol 1) / pulse length µs (RCSwitch protocol 1)
7
8def darbe(yuksek, dusuk):             # süreler T cinsinden / durations in units of T
9    tx.value(1)
10    time.sleep_us(yuksek * T)
11    tx.value(0)
12    time.sleep_us(dusuk * T)
13
14def gonder(kod, bit=24, tekrar=10):
15    for _ in range(tekrar):
16        for i in range(bit - 1, -1, -1):   # en anlamlı bitten başla / start from the most significant bit
17            if (kod >> i) & 1:
18                darbe(3, 1)                # "1" biti: 3T HIGH, 1T LOW / bit "1"
19            else:
20                darbe(1, 3)                # "0" biti: 1T HIGH, 3T LOW / bit "0"
21        darbe(1, 31)                       # senkron: 1T HIGH, 31T LOW / sync
22
23while True:
24    if buton.value() == 0:                 # butona basıldı / button pressed
25        gonder(5393)                       # okuduğun kodu yaz / put the code you read here
26        time.sleep_ms(300)

Para el procesador de 125 MHz de la Pico, los pulsos de 350 µs son un ritmo cómodo; los pequeños retrasos de Python quedan muy por debajo de la tolerancia de tiempo del 60 % de los receptores RCSwitch. Puedes probar el código enseguida poniendo al lado un Arduino con el código lector de RCSwitch: en el Monitor Serie debería aparecer el número que has enviado. Para recibir tendrías que medir y decodificar la duración de los pulsos con marcas de tiempo; para eso es más práctico un Arduino o un ESP32 con RCSwitch.

Alcance e interferencias: llevar la señal más lejos

• No olvides la antena: suelda un cable recto de 17,3 cm en ambos lados; es lo que más influye en el alcance.
• Sube la tensión del emisor: alimentar el FS1000A con 9–12 V aumenta claramente la potencia y el alcance. No olvides la masa común.
• Baja la velocidad: usar 1000 bps en lugar de 2000 en RadioHead hace que cada bit dure más y que el receptor pueda decodificar señales más débiles. Pon la misma velocidad en ambos lados.
• Línea de visión y altura: los muros de hormigón armado, las cajas metálicas y el montaje cerca del suelo pueden reducir el alcance a la mitad; saca las antenas de las cajas metálicas y súbelas todo lo posible.
• Limpia la alimentación: los motores, los relés y las fuentes conmutadas dejan sordo al receptor. Dale una alimentación filtrada y mantén los cables cortos.
• Usa un receptor mejor: un receptor superheterodino como el RXB6 en lugar del XY-MK-5V suele llegar bastante más lejos con el mismo emisor.
• Envía varias veces: como no hay confirmación, envía las órdenes importantes 3–5 veces y filtra los duplicados en el receptor con el número de paquete.

Recuerda que 433 MHz es una banda compartida: la estación meteorológica del vecino, las llaves de los coches y los timbres emiten en la misma frecuencia. En Europa y Turquía, el rango de 433,05–434,79 MHz está abierto al uso sin licencia por dispositivos de corto alcance, pero la potencia está limitada a 10 mW (PRA) y no debes ocupar el canal de forma continua; las normas varían según el país. Enviar los datos a intervalos, o solo cuando algo cambia, en lugar de continuamente, cumple las normas y además alarga la vida de la batería; para un emisor a pilas puedes usar la calculadora de duración de batería.

¿Módulo RF de 433 MHz o nRF24L01?

En resumen, si necesitas enviar en un solo sentido datos pequeños y esporádicos (un pulsador, un valor de temperatura, el aviso de que una puerta se ha abierto) o trabajar con enchufes y sensores comerciales, el módulo de 433 MHz es la solución más barata y sencilla. Para un coche teledirigido, un joystick o redes de sensores con muchos nodos que necesitan comunicación rápida, bidireccional y con confirmación, el nRF24L01 es mejor opción. Si necesitas kilómetros de alcance, mira los módulos LoRa; para ver todas las opciones juntas, lee módulos de comunicación inalámbrica para Arduino.

Ideas de proyectos con el módulo RF de 433 MHz

• Timbre inalámbrico: reproduce una melodía dentro de casa cuando el pulsador de la puerta del jardín envíe una señal; para el sonido basta un zumbador.
• Controlar enchufes desde Arduino: clona los códigos de los enchufes con mando y enciende y apaga lámparas según la hora o el nivel de luz.
• Sensor de puerta inalámbrico: pon en la puerta un interruptor reed y un Arduino pequeño con emisor; cuando la puerta se abra, el lado receptor dará la alarma.
• Sistema de alarma para casa: monta un sistema de alarma con Arduino que reúna en una central sensores PIR y de puerta comerciales de 433 MHz.
• Estación de sensores para el jardín: envía la humedad del suelo o la temperatura a casa cada pocos minutos con un emisor a pilas.
• Puente de 433 MHz a Wi-Fi: controla con un ESP32 todos los dispositivos de 433 MHz de casa desde el móvil y tu sistema domótico.

Errores comunes y cómo solucionarlos

Los módulos RF de 433 MHz dan a tus proyectos un brazo inalámbrico por muy poco dinero y son de los pocos módulos capaces de hablar con los aparatos con mando que ya tienes en casa. Cuando entiendas la lógica del control inalámbrico, aprenderás con facilidad otros métodos como los mandos IR y el Bluetooth. En la aplicación BlueGrays encontrarás proyectos como la comunicación entre dos Arduino, encender una bombilla de 220 V con un mando, un sensor de puerta con interruptor reed y una alarma de movimiento con ESP32, con esquemas de circuito y código paso a paso.