Construye un Transmisor RC Arduino Multifuncional: Guía DIY Paso a Paso

En este tutorial aprenderemos a construir un transmisor RC Arduino DIY. A menudo necesito control inalámbrico para mis proyectos, así que construí este controlador de radio multifuncional que puede usarse para prácticamente todo.

Puedes ver el siguiente video o leer el tutorial escrito a continuación.

Resumen

Ahora puedo controlar inalámbricamente cualquier proyecto Arduino con solo pequeños ajustes en el receptor. Este transmisor también puede usarse como cualquier transmisor RC comercial para controlar juguetes RC, coches, drones, etc. Para ello solo necesita un receptor Arduino simple que genere las señales adecuadas para controlar esos dispositivos RC comerciales.

Explicaré cómo funciona todo a través de algunos ejemplos: control de un coche robot Arduino, control del Robot Hormiga Arduino de mi video anterior y control de un motor DC brushless usando un ESC y servomotores.

La comunicación por radio de este controlador se basa en el módulo transceptor NRF24L01, que si se usa con una antena amplificada puede tener un alcance estable de hasta 700 metros en espacio abierto. Cuenta con 14 canales, 6 de los cuales son entradas analógicas y 8 digitales.

Tiene dos joysticks, dos potenciómetros, dos interruptores basculantes, seis botones y además una unidad de medición interna que consiste en un acelerómetro y un giroscopio (MPU6050) que también puede usarse para controlar cosas simplemente moviendo o inclinando el controlador.

Diagrama del Circuito del Transmisor RC Arduino

Para comenzar, veamos el diagrama del circuito. El cerebro de este controlador RC es un Arduino Pro Mini alimentado por 2 baterías LiPo que producen alrededor de 7.4 voltios. Podemos conectarlas directamente al pin RAW del Pro Mini, que tiene un regulador de voltaje que reduce la tensión a 5V. Ten en cuenta que hay dos versiones del Arduino Pro Mini: una que opera a 5V y otra a 3.3V.

Por otro lado, el módulo NRF24L01 requiere estrictamente 3.3V y se recomienda que provenga de una fuente dedicada. Por eso necesitamos un regulador de voltaje de 3.3V conectado a las baterías para convertir los 7.4V a 3.3V. También necesitamos un capacitor de desacoplo justo al lado del módulo para mantener el voltaje más estable, mejorando así la estabilidad de la comunicación por radio. El módulo NRF24L01 se comunica con el Arduino mediante protocolo SPI, mientras que el módulo acelerómetro/giroscopio MPU6050 usa protocolo I2C.

Componentes necesarios

• Módulo Transceptor NRF24L01
• NRF24L01 + PA + LNA (versión amplificada)
• Potenciómetros
• Servomotores
• Interruptores basculantes (toggle switches)
• Joysticks (con y sin placa breakout)
• Arduino Pro Mini (versiones PCB V1, V2 o V3 según el regulador)
• Regulador de voltaje 3.3V HT7333 (PCB V1 y V2)
• Regulador de voltaje 3.3V AMS1117 (PCB V3)

Diseño del PCB

Terminé utilizando todos los pines analógicos y digitales del Arduino Pro Mini. Conectar todo con cables jumper sería un lío, así que diseñé un PCB personalizado usando el software gratuito de diseño de circuitos en línea EasyEDA.

Tuve en cuenta la ergonomía del controlador y lo diseñé para sostenerse fácilmente con dos manos, con todos los controles al alcance de los dedos. Los bordes son redondeados y agregué orificios de 3mm para montar el PCB posteriormente. Colocé los pines para programar el Arduino Pro Mini en la parte superior para acceso fácil. Los pines RX y TX se usan para los botones de los joysticks, pero deben desconectarse durante la carga del sketch, por lo que están interrumpidos con pines que se conectan fácilmente con jumpers.

Nota importante: Asegúrate de tener la versión correcta de Arduino Pro Mini que coincida con el PCB o modifica el diseño según tu versión. Aquí hay una foto comparativa entre las tres versiones diferentes.

Enlace a los archivos del proyecto del diseño PCB (se abren las tres versiones en pestañas separadas).

Una vez finalizado el diseño, generé los archivos Gerber necesarios para la fabricación del PCB.

Pedí el PCB a JLCPCB (patrocinadores del video). Simplemente arrastras y sueltas el archivo Gerber, revisas en el visor, seleccionas propiedades (elegí color negro) y ordenas. Nota: en tu primer pedido puedes obtener hasta 10 PCBs por solo $2.

Montaje del PCB

Comencé soldando los headers de pines del Arduino Pro Mini. Una buena forma es colocarlos en una protoboard para que se mantengan firmes durante la soldadura.

El Pro Mini también tiene pines laterales, pero su ubicación puede variar según el fabricante. En mi modelo necesito 5 pines por lado, dejando un GND libre porque usé su área en el PCB para pistas. Soldé el Arduino directamente al PCB y recorté el exceso de los headers. Junto a él va el módulo MPU6050.

Soldé el regulador de 3.3V con un capacitor, y otro capacitor cerca del módulo NRF24L01 (cualquiera de las tres versiones funciona). Continué con los pines de programación, RX/TX, alimentación y el interruptor de encendido.

Para los potenciómetros extendí sus pines con headers. Previamente recorté las perillas para que encajen los caps. Los soldaré al PCB más tarde.

Inserté y soldé los dos interruptores basculantes y los dos joysticks.

Finalmente soldé los cuatro pulsadores, extendiendo también sus pines con headers por altura.

El PCB está listo. Para la carcasa usé acrílico transparente de 4mm para que el PCB sea visible. La idea: dos placas con la forma del PCB, una arriba y otra abajo.

Marqué la forma del PCB y corté el acrílico con sierra de mano. Luego afiné la forma con lima. Las dos placas encajan perfectamente.

Marqué las ubicaciones para los orificios de componentes. Con broca de 3mm hice los 4 orificios de montaje con avellanado. Para interruptores y potenciómetros usé broca de 6mm, y para joysticks broca Forstner de 25mm. Afiné todas las aberturas con lima.

Nota: soldé el header de alimentación al revés para acceder desde la parte trasera donde está la batería.

Ensamblé la carcasa: quité el film protector del acrílico, fijé los potenciómetros en la placa superior, inserté tornillos de 3mm y anillas separadoras de 11mm.

Uní la placa superior al PCB con tornillos. En este punto soldé los potenciómetros al PCB (antes no sabía su altura exacta).

En la placa trasera fijé el portabaterías con 2 tornillos. Completé el ensamblaje asegurando la placa trasera al PCB con los 4 tornillos de montaje.

Conecté los cables de la batería a los pines de alimentación, puse las perillas en los potenciómetros, los caps en los joysticks y la antena al NRF24L01. ¡Transmisor RC DIY completado!

Para programar el Arduino Pro Mini necesitamos una interfaz USB a serie UART conectada al header de programación en la parte superior.

En el menú Herramientas del IDE Arduino: seleccionar "Arduino Pro or Pro Mini", el procesador correcto, el puerto y el programador "USBasp".

Código del Transmisor RC Arduino DIY

Explicamos el código del transmisor. Primero incluimos las librerías SPI y RF24 para comunicación inalámbrica, y Wire para el acelerómetro. Definimos entradas digitales, variables, el objeto radio y la dirección de comunicación.

#include <SPI.h> 
#include <nRF24L01.h> 
#include <RF24.h> 
#include <Wire.h> 

// Entradas digitales
#define jB1 1 // Botón joystick 1
#define jB2 0 // Botón joystick 2
#define t1 7  // Interruptor basculante 1
#define t2 4  // Interruptor basculante 2
#define b1 8  // Botón 1
#define b2 9  // Botón 2
#define b3 2  // Botón 3
#define b4 3  // Botón 4

const int MPU = 0x68; // Dirección I2C MPU6050
float AccX, AccY, AccZ;
float GyroX, GyroY, GyroZ;
float accAngleX, accAngleY, gyroAngleX, gyroAngleY;
float angleX, angleY;
float AccErrorX, AccErrorY, GyroErrorX, GyroErrorY;
float elapsedTime, currentTime, previousTime;
int c = 0;

RF24 radio(5, 6); // nRF24L01 (CE, CSN)
const byte address[6] = "00001"; // Dirección

Definimos una estructura para almacenar los 14 valores de entrada. El tamaño máximo es 32 bytes (límite del buffer NRF24L01).

// Máximo 32 bytes - límite buffer NRF24L01
struct Data_Package {
  byte j1PotX; byte j1PotY; byte j1Button;
  byte j2PotX; byte j2PotY; byte j2Button;
  byte pot1; byte pot2;
  byte tSwitch1; byte tSwitch2;
  byte button1; byte button2; byte button3; byte button4;
};
Data_Package data;

En setup() inicializamos el MPU6050 y calculamos el error del IMU (valores usados para corregir los ángulos).

void initialize_MPU6050() {
  Wire.begin();
  Wire.beginTransmission(MPU);
  Wire.write(0x6B); Wire.write(0x00); // Reset
  Wire.endTransmission(true);
  
  // Configurar acelerómetro (±8g)
  Wire.beginTransmission(MPU);
  Wire.write(0x1C); Wire.write(0x10);
  Wire.endTransmission(true);
  
  // Configurar giroscopio (1000dps)
  Wire.beginTransmission(MPU);
  Wire.write(0x1B); Wire.write(0x10);
  Wire.endTransmission(true);
}

Inicializamos la radio, activamos resistencias pull-up internas y establecemos valores por defecto.

radio.begin();
radio.openWritingPipe(address);
radio.setAutoAck(false);
radio.setDataRate(RF24_250KBPS);
radio.setPALevel(RF24_PA_LOW);

pinMode(jB1, INPUT_PULLUP); pinMode(jB2, INPUT_PULLUP);
pinMode(t1, INPUT_PULLUP); pinMode(t2, INPUT_PULLUP);
pinMode(b1, INPUT_PULLUP); pinMode(b2, INPUT_PULLUP);
pinMode(b3, INPUT_PULLUP); pinMode(b4, INPUT_PULLUP);

En loop() leemos todas las entradas analógicas y mapeamos de 0-1023 a 0-255 (byte).

data.j1PotX = map(analogRead(A1), 0, 1023, 0, 255);
data.j1PotY = map(analogRead(A0), 0, 1023, 0, 255);
data.j2PotX = map(analogRead(A2), 0, 1023, 0, 255);
data.j2PotY = map(analogRead(A3), 0, 1023, 0, 255);
data.pot1 = map(analogRead(A7), 0, 1023, 0, 255);
data.pot2 = map(analogRead(A6), 0, 1023, 0, 255);

Leemos entradas digitales (con pull-up, 0 = presionado).

data.j1Button = digitalRead(jB1);
data.j2Button = digitalRead(jB2);
data.tSwitch2 = digitalRead(t2);
data.button1 = digitalRead(b1);
data.button2 = digitalRead(b2);
data.button3 = digitalRead(b3);
data.button4 = digitalRead(b4);

Enviamos la estructura completa al receptor.

radio.write(&data, sizeof(Data_Package));

Si el interruptor basculante 1 está activado (LOW), usamos datos del acelerómetro/giroscopio en lugar del joystick 1.

if (digitalRead(t1) == 0) {
  read_IMU(); // Usar MPU6050 para control
}

Mapeamos los ángulos (-90° a +90°) a valores byte (0-255).

data.j1PotX = map(angleX, -90, +90, 255, 0);
data.j1PotY = map(angleY, -90, +90, 0, 255);

El código completo del transmisor está al final del artículo.

Código del Receptor

Veamos cómo recibir los datos. Esquema simple de receptor Arduino + NRF24L01 (puedes usar otra placa Arduino).

Código receptor básico que imprime en monitor serie para verificar comunicación. Incluimos librería RF24, definimos objetos y estructura igual que en transmisor. En setup() configuramos radio con mismos parámetros y ponemos módulo en modo receptor con radio.startListening().

/* Receptor RC Arduino DIY */
#include <SPI.h> #include <nRF24L01.h> #include <RF24.h>
RF24 radio(10, 9); const byte address[6] = "00001";
unsigned long lastReceiveTime = 0, currentTime = 0;

struct Data_Package { /* misma estructura que transmisor */ };
Data_Package data;

void setup() {
  Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  radio.startListening();
  resetData();
}

void loop() {
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package));
    lastReceiveTime = millis();
  }
  currentTime = millis();
  if (currentTime - lastReceiveTime > 1000) {
    resetData(); // Perder conexión: resetear valores
  }
  // Imprimir en Serial Monitor
  Serial.print("j1PotX: "); Serial.print(data.j1PotX);
  Serial.print("; j1PotY: "); Serial.print(data.j1PotY);
  Serial.print("; button1: "); Serial.print(data.button1);
  Serial.print("; j2PotX: "); Serial.println(data.j2PotX);
}

void resetData() { /* valores por defecto */ }

En loop usamos available() para comprobar datos entrantes. Si hay datos, los leemos y almacenamos. Usamos millis() para detectar pérdida de conexión (>1 segundo sin datos) y resetear variables, evitando comportamiento no deseado (ej. drone con throttle arriba que sigue volando).

Ahora podemos implementar este método de recepción en cualquier proyecto Arduino. Ejemplo: control inalámbrico del coche robot Arduino.

Como actualización, hice un receptor RC Arduino dedicado basado en Pro Mini con conexiones listas para servos y ESCs en PCB compacto.

Control Inalámbrico de Coche Robot Arduino con Transmisor RC

Definimos librerías, estructura y comunicación radio como antes. En loop principal leemos datos entrantes y usamos valores del joystick 1 para conducir el coche.

Control de Robot Hormiga/Hexápodo Arduino con Transmisor RC

De la misma forma hice el Robot Hormiga controlable inalámbricamente. Leemos datos y ejecutamos funciones según ellos: avanzar, girar, morder, atacar, etc.

Control de ESC y Servos con Transmisor RC

Veamos cómo usar este transmisor para dispositivos RC comerciales.

Para controlar servos usamos librería Servo de Arduino (0-180°). Para motores brushless con ESC, usamos la misma librería para generar señal PWM 50Hz. Variando duty cycle de 1000 a 2000 microsegundos controlamos RPM de 0 a máximo.

Nota: No podemos vincular receptores RC estándar con este sistema NRF24L01 2.4GHz. Necesitamos crear nuestro propio receptor con Arduino y NRF24L01 que genere señales PWM/PPM apropiadas.

/* Receptor - Control ESC y Servos */
#include <SPI.h> #include <nRF24L01.h> #include <RF24.h> #include <Servo.h>
RF24 radio(10, 9); const byte address[6] = "00001";
// ... misma estructura Data_Package ...
Servo esc, servo1, servo2;
int escValue, servo1Value, servo2Value;

void setup() {
  Serial.begin(9600);
  radio.begin(); radio.openReadingPipe(0, address);
  radio.setAutoAck(false); radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW); radio.startListening();
  resetData();
  esc.attach(9); servo1.attach(3); servo2.attach(4);
}

void loop() {
  currentTime = millis();
  if (currentTime - lastReceiveTime > 1000) resetData();
  
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package));
    lastReceiveTime = millis();
  }
  
  // Control servos
  servo1Value = map(data.j2PotX, 0, 255, 0, 180);
  servo2Value = map(data.j2PotY, 0, 255, 0, 180);
  servo1.write(servo1Value); servo2.write(servo2Value);
  
  // Control ESC
  escValue = map(data.pot1, 0, 255, 1000, 2000);
  esc.writeMicroseconds(escValue);
}

void resetData() { /* valores por defecto */ }

¡Eso es todo! Espero que hayas disfrutado y aprendido algo nuevo. Preguntas en comentarios y revisa mi colección de Proyectos Arduino.