ESP32 RMT periférico con EV1527, HS1572, PT2240 de 315 MHz o 433 MHz y similares
Controla tus dispositivos inalámbricos EV1527 y similares con ESP32 y un receptor y transmisor de 433 MHz, utilizando ESP32 RMT (Remote Control Transceiver).
Hoy, utilizaremos el ESP32 para capturar las señales de nuestro control remoto y luego enviar las mismas señales al dispositivo que deseamos controlar. Después de este tutorial, podrás controlar tu dispositivo inalámbrico, como una puerta de garaje remota, un enchufe inteligente, etc., utilizando el ESP32 con un transmisor de 433 MHz para enviar señales EV1527 con la ayuda del periférico RMT del ESP32.
Honestamente, el proyecto más popular con ESP32 y 433 MHz es el abridor de puertas de garaje ESP32. Así que si llegaste aquí por eso, sí, estás en el lugar correcto.
Componentes #
Antes de comenzar, necesitarás los siguientes componentes:
| Parte | Notas |
|---|---|
 Microcontrolador ESP32 | Dado que estás leyendo una publicación sobre ESP32, seguramente necesitarás la placa ESP32. Cualquier placa debería funcionar si puedes conectarla a tu computadora con un cable USB para transferir el programa. Consulta aquí para la comparación de chips ESP32. |
 Módulos de transmisor y receptor de 433MHz | Hay muchos módulos de transmisor de 433MHz disponibles en el mercado y deberías usar el que mejor se adapte a tu proyecto, pero si no estás seguro de qué elegir, echaremos un vistazo a las opciones más populares. |
 Protoboard y cables de salto | Necesitarás una protoboard y cables de salto para conectar fácilmente el ESP32 con los módulos RF. |
 Fuente de alimentación | Necesitarás una fuente de alimentación adecuada para el ESP32, el transmisor de 433MHz y el codificador EV1527. Puede ser una batería o una fuente de alimentación, dependiendo de las necesidades de tu proyecto. |
 Dispositivo que usa EV1527 o protocolo similar | Si deseas utilizar este conocimiento con el dispositivo inalámbrico que ya tienes, por ejemplo, de tu sistema de control remoto de la puerta del garaje, podrás controlarlo más tarde con el ESP32. |
Módulos de transmisor y receptor de 315 / 433 MHz #
Existen muchos módulos de transmisor de 433MHz con diferentes especificaciones disponibles. Al elegir un transmisor de 433MHz, debes considerar lo siguiente:
- Tasa de datos: puede variar desde unos pocos cientos de bits por segundo (bps) hasta varios kilobits por segundo (Kbps), dependiendo del módulo.
- Modulación: la modulación más comúnmente utilizada en los módulos de 433MHz es el Keying de Amplitud (ASK), aunque algunos módulos también admiten el Keying de Frecuencia (FSK).
- Potencia de salida: diferentes módulos proporcionan diferentes potencias de salida, lo que afectará el alcance de la comunicación inalámbrica.
- Voltaje de operación: la mayoría de los módulos funcionan con lógica de 5V. Mientras que el ESP32 trabaja con lógica de 3.3V, es mejor buscar un módulo de 433MHz que funcione a 3.3V, aunque también es posible hacer que el de 5V funcione.
- Antena: aunque normalmente los módulos de 433MHz tienen antena integrada, si necesitas un mejor alcance, deberías buscar un módulo que pueda conectar una antena externa.
Las siguientes dos placas son los módulos más ampliamente disponibles y utilizados para proyectos DIY:
| Parte | Notas |
|---|---|
FS1000A / MX-FS-03V | El transmisor tiene una velocidad de transferencia de datos de 10 Kbps y una potencia de transmisión de 10mW, y opera entre 3.5V-12V. El receptor opera a 5V DC y proporciona una sensibilidad de recepción de -105dBm. |
 SYN115 / SYN480R | El transmisor tiene una velocidad de transferencia de datos de 10 Kbps, potencia de salida de 10dBm y opera entre 1.8-3.6V. El receptor opera entre 3.3-5.5V DC y proporciona una sensibilidad de recepción de -107dBm. |
Ambas opciones deberían ser perfectas para tu proyecto DIY con ESP32. El transmisor puede usarse con 3.3V, lo cual es ideal para el ESP32, mientras que el receptor opera a 5V, así que necesitarás aumentar el voltaje.
Ten en cuenta que estamos proporcionando solo las opciones de 433 MHz, pero si tu sistema de control remoto utiliza 315 MHz, no hay mucha diferencia y puedes usar estas instrucciones también.
El Transceptor de Control Remoto (RMT) del ESP32 #
Si nunca has oído hablar del RMT antes, te estarás preguntando qué es... El RMT (Transceptor de Control Remoto) es un periférico de hardware especializado en el chip ESP32 que fue diseñado inicialmente para proporcionar una forma simple y eficiente de generar y enviar señales IR (Infrarrojas). Sin embargo, debido a su flexibilidad en el formato de datos, ahora se utiliza para una variedad de protocolos de comunicación de frecuencia de radio (RF), incluidos PT2262/PT272, HT12/HT12D, EV1527 y más.
Consta de dos canales, que se pueden usar para generar y recibir señales al mismo tiempo. Ambos canales tienen un conjunto dedicado de registros que se pueden utilizar para controlar la modulación y el tiempo de las señales.
Para ponerlo en uso, necesitarás tener la biblioteca RMT instalada. Esta se incluye en el núcleo de ESP32-Arduino, así que si has programado tu placa ESP32 con Arduino antes, ya deberías tenerla. Si no, aquí tienes las instrucciones sobre cómo instalarla con Arduino IDE:
- Abre el IDE de Arduino y ve al menú Archivo.
- Selecciona Preferencias.
- En el campo de URLs Adicionales del Gestor de Placas, agrega la siguiente URL:
https://dl.espressif.com/dl/package_esp32_index.json - Haz clic en Aceptar para guardar las preferencias.
- Ve al menú Herramientas y selecciona Placa.
- Selecciona Gestor de Placas.
- Busca "ESP32" en el cuadro de búsqueda.
- Selecciona el paquete ESP32 de Espressif Systems y haz clic en Instalar.
- Espera a que se complete la instalación.
Una vez que tengas la biblioteca lista, podemos escribir un ejemplo simple que enviará una señal IR, lo cual nos ayudará a entender cómo usar el RMT del ESP32.
#include <RMT.h>
// Set the RMT channel number
#define RMT_CHANNEL 0
// Define the IR signal in an array of durations in microseconds
const uint16_t irSignal[] = {8000, 4500, 500, 550, 500, 550, 500, 550, 500, 1600, 500, 1600, 500, 1600, 500, 1600, 500, 550, 500, 550, 500, 550, 500, 1600, 500, 1600, 500, 1600, 500, 1600, 500, 1600, 500, 1600, 500, 1600, 500, 1600, 500, 550, 500, 550, 500, 550, 500, 1600, 500, 1600, 500, 550, 500, 550, 500, 550, 500, 550};
void setup() {
// Initialize the RMT peripheral
RMT.begin();
// Set the output pin
pinMode(RMT.txChannelToOutput(RMT_CHANNEL), OUTPUT);
// Set the carrier frequency (38 kHz)
RMT.addCarrier(RMT_CHANNEL, 38000);
}
void loop() {
// Send the IR signal
RMT.write(RMT_CHANNEL, irSignal, sizeof(irSignal) / sizeof(irSignal[0]));
// Wait before sending the next signal
delay(500);
}En este ejemplo, primero definimos un arreglo irSignal[] con duraciones en microsegundos, que será nuestra señal IR.
A continuación, en la función setup(), llamamos a RMT.begin() para inicializar el periférico RMT del ESP32 con la configuración predeterminada. Luego, llamamos a la función RMT.addCarrier() para configurar el periférico RMT en el canal 0 con una frecuencia de señal portadora de 38 KHz.
Finalmente, en la función loop(), utilizamos la función RMT.write() para enviar realmente la señal IR usando RMT.
Ten en cuenta que la biblioteca RMT.h solo proporciona un control simplificado para el periférico RMT que es más similar a Arduino. Aunque en este proyecto vamos a usar la biblioteca mencionada anteriormente del núcleo Arduino de ESP32, si deseas más control sobre el periférico RMT del ESP32, puedes usar las APIs de
#include <driver/rmt.h>
// Set the RMT channel number
#define RMT_CHANNEL 0
// Define the IR signal in an array of durations in microseconds
const uint16_t irSignal[] = {8000, 4500, 500, 550, 500, 550, 500, 550, 500, 1600, 500, 1600, 500, 1600, 500, 1600, 500, 550, 500, 550, 500, 550, 500, 1600, 500, 1600, 500, 1600, 500, 1600, 500, 1600, 500, 1600, 500, 1600, 500, 1600, 500, 550, 500, 550, 500, 550, 500, 1600, 500, 1600, 500, 550, 500, 550, 500, 550, 500, 550};
void setup() {
// Configure the RMT peripheral
rmt_config_t config;
config.gpio_num = GPIO_NUM_4;
config.rmt_mode = RMT_MODE_CARRIER;
config.channel = RMT_CHANNEL;
config.clk_div = 80;
// Initialize the RMT peripheral
rmt_config(&config);
rmt_driver_install(config.channel, 0, 0);
// Start the carrier signal
rmt_carrier_mode_start(RMT_CHANNEL, 1, true, &carrier_config);
}
void loop() {
// Send the IR signal
rmt_write_items(RMT_CHANNEL, irSignal, sizeof(irSignal) / sizeof(irSignal[0]), true);
// Wait a bit before sending the next signal
vTaskDelay(pdMS_TO_TICKS(500));
}En este ejemplo utilizando la API RMT de ESP-IDF, primero definimos nuevamente un arreglo irSignal[] con duraciones en microsegundos, que será nuestra señal IR.
A continuación, definimos un CANAL RMT como 0. Luego, en la función setup(), creamos un objeto con la estructura rmt_config_t para configurar el periférico RMT en el ESP32. En la estructura rmt_config_t, establecemos el GPIO que se utilizará para generar señales como el 4. Luego, configuramos el modo RMT a RMT_MODE_CARRIER, lo que indica que queremos generar una señal portadora y establecemos el canal RMT al 0 previamente definido. A continuación, establecemos un divisor de reloj clk_div a 80, lo que indica que queremos generar una señal portadora de 38 kHz.
Para finalizar la configuración, inicializamos el periférico RMT utilizando las funciones rmt_config() y rmt_driver_install() y, finalmente, comenzamos la señal portadora.
En la función loop(), utilizamos rmt_write_items() para enviar la señal IR real que hemos definido anteriormente y esperamos un corto periodo de tiempo antes de enviar nuevamente la misma señal.
Si deseas saber más sobre el Transceptor de Control Remoto ESP32, puedes encontrar la documentación oficial de Espressif sobre ESP32 RMT aquí: https://docs.espressif.com/projects/esp-idf/en/latest/esp32/api-reference/peripherals/rmt.html
EV1527 y protocolos similares / Circuitos Integrados (ICs) #
El EV1527 es un protocolo de comunicación inalámbrica RF muy popular, ampliamente utilizado en dispositivos inalámbricos de bajo costo, como abridores de puertas de garaje controlados a distancia, sistemas de seguridad para el hogar, etc. A veces, también se puede encontrar en dispositivos para el hogar inteligente, como interruptores inalámbricos y enchufes inteligentes.
Este protocolo transmite datos a una frecuencia portadora de 433.92 MHz y utiliza modulación por cambio de amplitud (ASK). Con el protocolo EV1527, puedes transmitir hasta 24 bits de datos, que consisten en un código de dirección de 8 bits y datos de 16 bits. La dirección se utiliza para identificar el dispositivo que se está controlando y los datos indican al dispositivo qué comando ejecutar.
Una de las principales ventajas del protocolo EV1527 es su bajo consumo de energía, lo que lo hace ideal para dispositivos que funcionan con batería. Sin embargo, dado que los datos se transmiten sin cifrado y se envían en texto plano, es susceptible a la captura de códigos.
Aunque nos basamos en el EV1527, muchos circuitos integrados (IC) similares utilizan varios tipos de modulación y esquemas de codificación. Algunos de los IC deberían funcionar con las mismas instrucciones: EV1527 / HS1527 / FP527 / EV1528 / EV1530 / PT2240. Otros podrían necesitar un poco más de investigación, pero es muy probable que funcionen con estas instrucciones:
- PT2262 / PT2260 / PT2264 / HS2260 / HS2262 / SC2262 / SC2260
- HT12D / HT12E / HT12F / HT6P20B / HT6P20D / HT6P237A / HT6P247A / HT6P437A / HT600 / HT680 / HT6207 / HT6010 / HT6012 / HT6014
- SMC918 / SMC926 / SC5262 / VD5036 / VD5326
Hemos intentado recopilar la mayor cantidad de IC que deberían ser compatibles con las instrucciones proporcionadas, pero no los hemos probado nosotros mismos. Sin embargo, si tienes otro que utilice comunicación de 315 MHz o 433 MHz, aún podrías intentar probarlo.
Leer los datos de tu control remoto existente #
Como se mencionó anteriormente, el protocolo EV1527 no está cifrado, lo que lo hace perfecto para interceptar nuestro control remoto existente. Por lo tanto, solo necesitaremos conectar nuestro receptor de 433 MHz a la placa ESP32 y leer las señales de un control remoto.
Vamos a ello y veamos cómo conectar un módulo RF de 433 MHz al ESP32. La conexión es muy sencilla y la misma se puede usar para ESP8266 o incluso Arduino.
+---------+
+-------------+ | 433MHz |
| ESP32 | | Receiver|
| | +---------+
| RX +--------------+ DATA |
| GND +--------------+ GND |
| 3.3V +--------------+ VCC |
| | +---------+
+-------------+
Como puedes ver, solo necesitas conectar el pin de 3.3V en el ESP32 al VCC de tu receptor de 433 MHz, el pin GND al pin GND y finalmente el pin RX en el ESP32 al pin DATA en el receptor de 433 MHz. Ten en cuenta que en este ejemplo estamos utilizando un receptor de 433 MHz que funciona a 3.3V, que es el mismo voltaje que el ESP32.
A continuación, necesitamos escribir un código que nos muestre las señales leídas del control remoto en el Monitor Serial.
#include <RMT.h>
// Set the RMT channel number
#define RMT_CHANNEL 0
void setup() {
// Initialize the RMT peripheral
RMT.begin();
// Set the input pin
pinMode(RMT.rxChannelToInput(RMT_CHANNEL), INPUT);
// Set the carrier frequency (38 kHz)
RMT.addCarrier(RMT_CHANNEL, 38000);
// Set the decoder
RMT.setDecoder(RMT_CHANNEL, RMT_MODE_RX, RMT_MEM_64);
// Enable the RMT receiver
RMT.enableRx(RMT_CHANNEL);
}
void loop() {
// Wait for a signal to be received
if (RMT.getRxState(RMT_CHANNEL) == RMT_RX_ACTIVE) {
// Get the received signal
rmt_item32_t* items = NULL;
uint32_t numItems = 0;
if (RMT.read(RMT_CHANNEL, &items, &numItems) == ESP_OK) {
// Convert the signal to a byte array
uint8_t data[numItems / 2];
for (int i = 0; i < numItems / 2; i++) {
uint8_t high = items[i * 2].duration1 > items[i * 2].duration0 ? 1 : 0;
uint8_t low = items[i * 2 + 1].duration1 > items[i * 2 + 1].duration0 ? 1 : 0;
data[i] = (high << 1) | low;
}
// Print the received data
Serial.print("Received data: ");
for (int i = 0; i < numItems / 2; i++) {
Serial.print(data[i], HEX);
Serial.print(" ");
}
Serial.println();
}
// Reset the receiver
RMT.rxReset(RMT_CHANNEL);
}
}En este ejemplo, nuevamente preparamos el periférico RMT en la placa ESP32, como hicimos en el ejemplo anterior. Pero en este caso, necesitamos configurar el pin RX como entrada utilizando la función pinMode(), establecer el decodificador en modo de lectura con la función RMT.setDecoder() y habilitar el receptor RMT usando la función RMT.enableRx().
A continuación, en la función loop(), esperaremos a que se reciba una señal en el receptor de 433 MHz conectado, comprobando el estado del pin RX con la función RMT.getRxState(), que debería devolver verdadero cuando hay una transmisión activa en el pin RX. Luego, leeremos la señal en el buffer previamente inicializado rmt_item32_t usando RMT.read(), la convertiremos a un arreglo de bytes y la imprimiremos en el Monitor Serial.
Finalmente, reiniciaremos el receptor RMT para indicarle que hemos terminado y que estamos esperando el siguiente comando.
Después de cargar el código, abre el Monitor Serial y prueba presionando algunas teclas en tu control remoto. Si todo está configurado correctamente, deberías ver el mensaje impreso en el Monitor Serial que debería verse algo así:
Received data: FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 FF 00 Haz esto con todos los botones que tienes en tu control remoto y guarda las salidas para más tarde.
Conectar ESP32 con Transmisor de 433MHz #
¡Genial! Ahora tenemos los códigos de nuestro control remoto, y lo único que queda es usarlos en algún lugar. Para comenzar, necesitaremos ver cómo conectar el transmisor RF de 433 MHz al ESP32 esta vez. Te sorprenderá saber que la conexión es casi la misma; solo que esta vez necesitamos usar el pin TX en lugar del RX.
+------------+
+-------------+ | 433MHz |
| ESP32 | | Transmitter|
| | +------------+
| TX +--------------+ DATA |
| GND +--------------+ GND |
| 3.3V +--------------+ VCC |
| | +------------+
+-------------+
Después de haber conectado el ESP32 con tu transmisor de 433 MHz, por supuesto, necesitamos escribir un código para transmitir las señales que hemos grabado previamente. Esta vez, necesitaremos inicializar el periférico RMT como salida, y establecer la frecuencia portadora y la longitud del pulso antes de enviar los datos. Puedes ver esto en el siguiente código.
#include <RMT.h>
// Set the RMT channel number
#define RMT_CHANNEL 0
// The hex data to send
uint8_t data[] = {0xAA, 0x55, 0x10, 0xEF};
void setup() {
// Initialize the RMT peripheral
RMT.begin();
// Set the carrier frequency (38 kHz)
RMT.addCarrier(RMT_CHANNEL, 38000);
// Set the length of each pulse (in clock cycles)
RMT.setCarrierLevel(RMT_CHANNEL, true, 14);
RMT.setCarrierLevel(RMT_CHANNEL, false, 14);
// Set the transmitter
RMT.setCarrierMode(RMT_CHANNEL, 1, 1);
RMT.setChannel(RMT_CHANNEL, RMT_MODE_TX, 1, 1);
// Set the data buffer
RMT.txBufferWrite(RMT_CHANNEL, data, sizeof(data), true);
}
void loop() {
// Send the data repeatedly with a delay of 1 second
RMT.txStart(RMT_CHANNEL, true);
delay(1000);
}Así que, como ya hicimos antes, necesitamos inicializar el periférico RMT en la función setup(). También necesitaremos establecer la duración de los pulsos esta vez para enviar los datos, utilizando las funciones RMT.setCarrierLevel() con el segundo parámetro como true para configurar la duración del nivel ALTO y nuevamente RMT.setCarrierLevel(), pero con el segundo parámetro como false para establecer la duración del nivel BAJO.
Finalmente, configuraremos el RMT como transmisor y estableceremos los datos de la señal en el búfer RMT utilizando RMT.txBufferWrite().
Ahora que hemos configurado el RMT del ESP32, en el loop() enviaremos los datos con RMT.txStart() y esperaremos 1 segundo antes de repetir la transmisión de datos indefinidamente.
Recuerda cambiar uint8_t data[] = {0xAA, 0x55, 0x10, 0xEF}; por tus propios datos que anotaste anteriormente.
Después de cargar el código, el ESP32 enviará tu comando proporcionado cada segundo. Por lo tanto, si tienes el dispositivo que controlabas con tu control remoto anteriormente cerca, deberías ver cómo ejecuta el comando proporcionado después de recibir la señal del ESP32.
Conclusiones #
Con todo el trabajo arduo que hemos realizado, hemos revisado diferentes transmisores y receptores de 433 MHz, aprendido a usar los periféricos RMT en el ESP32 y profundizado un poco en los protocolos de comunicación inalámbrica, específicamente el protocolo EV1527.
Más tarde, pudimos leer las señales del control remoto existente utilizando un receptor de 433 MHz y poniendo en uso el periférico RMT del ESP32 para manejar fácilmente el protocolo EV1527 y anotar las señales para su uso posterior.
Finalmente, reutilizamos las señales leídas previamente y pudimos ejecutar un comando en nuestro dispositivo inalámbrico existente.
¿Qué sigue? #
Entonces, ahora que hemos leído y anotado las señales del control remoto existentes y hemos podido usar una de ellas para ejecutar un comando en un dispositivo inalámbrico existente, el siguiente paso lógico es poner todos los comandos en su lugar y dejar que tu mente divague libremente para imaginar cómo usarás los comandos. Como tenemos todo en ESP32, debería ser bastante fácil hacer que tu dispositivo sea controlado por WiFi.