Construye un Receptor RC Arduino Fiable para Modelos y Proyectos

En este tutorial aprenderemos a construir un receptor RC basado en Arduino. Desde que construí mi transmisor RC Arduino casero en uno de mis videos anteriores, recibí muchas solicitudes para hacer un receptor dedicado, así que aquí está.

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

Ahora estos dos dispositivos pueden comunicarse fácilmente y podemos usarlos para controlar muchas cosas de forma inalámbrica. Explicaré cómo funciona todo a través de algunos ejemplos. En el primer ejemplo usaremos este receptor RC Arduino para controlar un coche simple que consta de dos motores DC. En el segundo ejemplo mostraré cómo controlar motores brushless y servos, que son componentes comunes en muchos aviones, barcos y coches RC comerciales. Si sabemos cómo controlarlos, podemos modificar y controlar fácilmente muchos modelos RC con nuestro propio transmisor Arduino personalizado.

Diagrama de Circuito del Receptor RC Arduino

Para comenzar, echemos un vistazo al diagrama de circuito de este sistema. La comunicación por radio se basa en los módulos transceptores NRF24L01.

El transmisor envía constantemente datos de sus controladores: joysticks, botones, potenciómetros e interruptores, y recibimos estos datos con el receptor. Para más detalles sobre cómo funciona este transmisor Arduino, puedes consultar mi otro tutorial detallado.

También cabe destacar que este receptor RC no necesariamente funciona solo con este transmisor en particular que construí. Puede funcionar con cualquier otra configuración similar que consista en una placa Arduino y un módulo NRF24L01.

Sin embargo, el cerebro de este receptor RC es una placa Arduino Pro Mini. Para la alimentación, podemos usar el pin VCC al que podemos conectar 5V, o el pin RAW al que podemos conectar de 6 a 12V. Ten en cuenta que hay dos versiones del Arduino Pro Mini: la que uso aquí que opera a 5V y la otra que opera a 3.3V. Por otro lado, el módulo NRF24L01 opera a 3.3V, por lo que necesitamos un regulador de voltaje. Esta vez estoy usando el regulador de voltaje AMS1117, que entrega 3.3V a partir de entradas que pueden variar de 5V a 12V.

Componentes Necesarios

• Módulo Transceptor NRF24L01
• NRF24L01 + PA + LNA (versión de largo alcance)
• Regulador de Voltaje AMS1117 3.3V
• Headers de Pines Macho + Hembra
• Arduino Pro Mini (versión 5V / 16MHz)

Para la comunicación con el Arduino, el módulo NRF24L01 usa el protocolo SPI, más dos pines digitales adicionales. Eso nos deja con 9 pines digitales que pueden usarse como canales de salida, dos de los cuales son los pines RX y TX. Vale la pena notar que estos pines deben estar desconectados de cualquier cosa mientras subimos un sketch a la placa Arduino, por lo que los hice conectables o desconectables mediante headers de pines separados. En realidad, también podemos usar las entradas analógicas como salidas digitales, así que aunque esta placa Arduino es bastante pequeña, tenemos muchos canales de salida disponibles.

Diseño del PCB

No obstante, para mantener este circuito compacto, diseñé un PCB personalizado usando el software gratuito de diseño de circuitos en línea EasyEDA. Aquí, organicé los 8 canales junto a un rail de 5V y uno de Tierra, para poder conectar servos y ESCs directamente a ellos. El canal número 9 está ubicado en una posición separada, cerca del pin VCC del Arduino, para poder usar, por ejemplo, un ESC para alimentar el Arduino con su función BEC (Battery Eliminator Circuit) que proporciona 5V. Por supuesto, podríamos usar cualquier otro canal para ese propósito, ya que el pin VCC está conectado a ese rail de 5V también.

En cuanto a los canales 7 y 8, vemos aquí cómo están interrumpidos con estos headers de pines. Si queremos usarlos, solo tenemos que conectar los dos pines entre sí. El header de programación está ubicado en la esquina superior derecha y el capacitor de 100uF sirve tanto para el regulador de voltaje como para el módulo NRF24L01. En la esquina inferior izquierda del PCB, coloqué los pines analógicos.

Aquí hay que notar una cosa más: algunas placas Arduino Pro Mini pueden tener una disposición de pines diferente, por lo que incluí una versión más del PCB para que puedas elegir la que coincida con tu placa.

Aquí tienes el enlace a los archivos del proyecto de este PCB. Una vez terminado el diseño, generé los archivos Gerber necesarios para la fabricación del PCB.

Fabricación en JLCPCB

Luego pedí el PCB a JLCPCB, que también son los patrocinadores de este video.

Aquí simplemente arrastramos y soltamos el archivo Gerber y una vez subido, podemos revisar nuestro PCB en el visor Gerber. Si todo está bien, podemos continuar y seleccionar las propiedades que queremos para nuestro PCB. Y listo, ahora podemos pedir nuestro PCB a un precio razonable. Ten en cuenta que si es tu primer pedido en JLCPCB, puedes conseguir hasta 5 PCBs por solo $2.

Montaje del PCB

Después de varios días, los PCBs han llegado. La calidad es excelente y todo coincide exactamente con el diseño.

Ahora podemos proceder a montar el PCB. Primero, necesitamos soldar los headers de pines de la placa Arduino. Una forma conveniente es usar una protoboard para insertar los headers y así la placa se mantendrá firme mientras soldamos. Como dije antes, dependiendo de tu placa, los pines pueden variar un poco, así que ten eso en cuenta al soldarlos.

También hay algunos pines de Tierra que debemos dejar libres ya que hay pistas corriendo en el PCB debajo de ellos. Una vez soldada la placa Arduino, corté el exceso de longitud de los pines.

Luego, coloqué todos los demás headers de pines en su lugar. Necesitamos headers macho y hembra, o en realidad depende de ti qué headers elijas. Sin embargo, es buena idea usar headers macho para los canales digitales ya que las conexiones de servomotores y ESCs son hembra, así podemos conectarlos fácilmente.

El regulador de voltaje es un componente de montaje superficial (SMD), así que usé un poco de adhesivo Blue-Tack para mantenerlo en su lugar mientras soldaba. Por último, una vez soldamos los dos capacitores en su lugar, podemos colocar el módulo NRF24L01 en los headers de pines apropiados.

Dependiendo de la aplicación o del alcance que necesitemos, podemos usar el módulo normal con antena integrada, o el que permite conectar una antena mayor y alcanzar comunicaciones inalámbricas de hasta 700 metros en espacio abierto. ¡Así que nuestro receptor RC Arduino ya está listo y podemos usarlo para lo que queramos!

Para programar el receptor, o conectar el Arduino Pro Mini a la computadora, podemos usar una interfaz USB a serial UART que se conecta al header de programación.

En el menú Herramientas del IDE de Arduino, necesitamos seleccionar la placa "Arduino Pro or Pro Mini", seleccionar la versión correcta del procesador, seleccionar el puerto y seleccionar el método de programación como "USBasp".

Y así ya podemos subir códigos al Arduino.

Ejemplo 1 – Coche RC Arduino

Bien, ahora pasemos al primer ejemplo.

Es un coche simple que consta de dos motores DC de 12V y en algunos de mis videos anteriores ya mostré cómo funciona y cómo construirlo.

Ver también: Controlador de Motor L298N – Interfaz con Arduino, Cómo Funciona, Códigos, Esquemas

Esta vez usaremos nuestro nuevo receptor RC Arduino para controlarlo. Para impulsar los motores DC, usamos el controlador de motor L298N y para la alimentación, usamos 3 baterías Li-ion que proporcionan alrededor de 12V.

Componentes para este ejemplo

• Controlador L298N
• Motor DC de Alto Torque 12V
• Motor DC con Rueda de Plástico
• Protoboard y Cables Jumper

Las conexiones son realmente simples: los 12V que vienen de las baterías van al pin de 12V en nuestro receptor, y los seis pines de control del driver van a los 6 canales. Hay que notar que para poder controlar la velocidad de los motores necesitamos proporcionar señal PWM a los pines Enable A y Enable B del driver. En nuestro receptor, los canales 2, 3, 6 y 9 pueden emitir señales PWM, así que conecté los pines Enable del driver a los canales 2 y 6 en este caso.

Código Arduino para el Coche RC

/* Arduino RC Receiver - Car Example by Dejan, www.HowToMechatronics.com Library: TMRh20/RF24, https://github.com/tmrh20/RF24/ */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#define enA 9 // Pin Arduino D9 - CH6 en PCB - Salida PWM
#define in1 8 // D8 - CH5
#define in2 7 // D7 - CH4
#define in3 6 // D6 - CH3
#define in4 4 // D4 - CH1
#define enB 5 // D5 - CH2 - Salida PWM
RF24 radio(3, 2); // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;
// Tamaño máximo de esta estructura es 32 bytes
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; // Crear una variable con la estructura anterior
int steering, throttle;
int motorSpeedA = 0;
int motorSpeedB = 0;
void setup() {
  pinMode(enA, OUTPUT);
  pinMode(enB, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
  //Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  radio.startListening(); // Configurar el módulo como receptor
  resetData();
}
void loop() {
  // Verificar si seguimos recibiendo datos, o si tenemos conexión entre los dos módulos
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) {
    // Si el tiempo actual es más de 1 segundo desde que recibimos el último dato, significa que perdimos conexión
    resetData(); // Si se pierde la conexión, reiniciar los datos. Evita comportamiento no deseado, por ejemplo si un dron tiene acelerador arriba, si perdemos conexión puede seguir volando si no reiniciamos la función
  }
  // Verificar si hay datos para recibir
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package)); // Leer todos los datos y almacenarlos en la estructura 'data'
    lastReceiveTime = millis(); // En este momento hemos recibido los datos
  }
  // Analizar los datos del Joystick 1 a las variables throttle y steering
  throttle = data.j1PotY;
  steering = data.j1PotX;
  // Throttle usado para control adelante/atrás
  // Valores del joystick: 0 a 255; abajo = 0; medio = 127; arriba = 255
  if (throttle < 110) {
    // Motor A hacia atrás
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    // Motor B hacia atrás
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    // Convertir lecturas de throttle descendentes para ir hacia atrás de 110 a 0 en valor 0 a 255 para señal PWM para aumentar velocidad del motor
    motorSpeedA = map(throttle, 110, 0, 0, 255);
    motorSpeedB = map(throttle, 110, 0, 0, 255);
  } else if (throttle > 140) {
    // Motor A hacia adelante
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    // Motor B hacia adelante
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
    // Convertir lecturas de throttle ascendentes para ir hacia adelante de 140 a 255 en valor 0 a 255 para señal PWM para aumentar velocidad del motor
    motorSpeedA = map(throttle, 140, 255, 0, 255);
    motorSpeedB = map(throttle, 140, 255, 0, 255);
  }
  // Si el joystick se queda en el medio, los motores no se mueven
  else {
    motorSpeedA = 0;
    motorSpeedB = 0;
  }
  // Steering usado para control izquierda/derecha
  if (steering < 110) {
    // Convertir lecturas de steering descendentes de 140 a 255 en 0 a 255 creciente
    int xMapped = map(steering, 110, 0, 0, 255);
    // Mover a izquierda - disminuir velocidad motor izquierdo, aumentar motor derecho
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Limitar rango de 0 a 255
    if (motorSpeedA < 0) { motorSpeedA = 0; }
    if (motorSpeedB > 255) { motorSpeedB = 255; }
  }
  if (steering > 140) {
    // Convertir lecturas de steering ascendentes de 110 a 0 en 0 a 255
    int xMapped = map(steering, 140, 255, 0, 255);
    // Mover a derecha - disminuir velocidad motor derecho, aumentar motor izquierdo
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    // Limitar rango de 0 a 255
    if (motorSpeedA > 255) { motorSpeedA = 255; }
    if (motorSpeedB < 0) { motorSpeedB = 0; }
  }
  // Evitar zumbido a bajas velocidades (Ajustar según tus motores. Mis motores no podían empezar a moverse si el valor PWM era inferior a 70)
  if (motorSpeedA < 70) { motorSpeedA = 0; }
  if (motorSpeedB < 70) { motorSpeedB = 0; }
  analogWrite(enA, motorSpeedA); // Enviar señal PWM al motor A
  analogWrite(enB, motorSpeedB); // Enviar señal PWM al motor B
}
void resetData() {
  // Reiniciar valores cuando no hay conexión de radio - Establecer valores iniciales por defecto
  data.j1PotX = 127;
  data.j1PotY = 127;
  data.j2PotX = 127;
  data.j2PotY = 127;
  data.j1Button = 1;
  data.j2Button = 1;
  data.pot1 = 1;
  data.pot2 = 1;
  data.tSwitch1 = 1;
  data.tSwitch2 = 1;
  data.button1 = 1;
  data.button2 = 1;
  data.button3 = 1;
  data.button4 = 1;
}Code language: Arduino (arduino)

Descripción: Primero necesitamos incluir la librería SPI y RF24, definir algunos pines, el objeto radio y la estructura de datos donde almacenaremos los datos entrantes del transmisor. En la sección setup definimos las salidas de pines e iniciamos la comunicación por radio. Para más detalles de cómo funciona y qué hace cada línea, puedes consultar mi tutorial detallado del NRF24L01.

En la sección loop, verificamos constantemente si estamos recibiendo datos y si lo hacemos, leemos esos datos entrantes. Si echamos un vistazo rápido al código del transmisor, vemos qué tipo de datos envía al receptor. Lee los datos de todos sus controladores: joysticks, potenciómetros y botones, y envía esos datos como un solo paquete al receptor.

Así que una vez leemos esos datos, podemos hacer lo que queramos con ellos. En este caso, usaremos el valor del eje Y del Joystick 1 para controlar el acelerador (throttle) y el valor del eje X para controlar la dirección (steering). Puse estos datos en variables separadas throttle y steering. Los valores que obtenemos de los joysticks van de 0 a 255. Así que si movemos el joystick hacia abajo, configuraremos los pines de control del driver apropiadamente para que el coche vaya hacia atrás, y usaremos el valor throttle para controlar la velocidad de movimiento. El mismo principio se aplica para avanzar, girar izquierda y derecha. De nuevo, ya tengo un tutorial detallado de cómo funciona este coche, así que puedes consultarlo para mejor comprensión. Al final del código notamos la función personalizada resetData(), que reinicia todos los valores a sus valores iniciales por defecto, así que en caso de perder la comunicación por radio, el coche se detendrá.

Ejemplo 2 – Control de Servos y Motores Brushless con Receptor RC Arduino

Bien, ahora continuamos con el segundo ejemplo: controlar servos y motores brushless usando este receptor RC Arduino.

Para controlar motores brushless, necesitamos un ESC (Electronic Speed Controller). El Arduino se comunica con el ESC con un solo pin. Para controlar el ESC, el Arduino envía una señal PWM específica al ESC y con ella el ESC controla la velocidad del motor. El ESC con esa misma conexión proporciona 5V a través de su función BEC (Battery Eliminator Circuit), así que también podemos alimentar nuestro receptor con él.

Ver también: Tutorial Control Motor Brushless Arduino | ESC | BLDC

En cuanto a los servomotores, tienen el mismo tipo de conexiones que el ESC y simplemente podemos conectarlos a cualquiera de los canales disponibles.

Componentes para este ejemplo

• Motor Brushless
• ESC 30A
• Batería Li-Po
• Servomotor MG996R

Las señales de entrada para controlar tanto servos como motores brushless usando ESCs son casi las mismas. Usan una señal PWM específica de 50Hz que se puede generar fácilmente usando la librería Servo de Arduino.

Nota importante: Al usar servos MG996R con esta configuración, podrían causar un problema en el circuito y quemar el Arduino Pro Mini. Pueden consumir una corriente mayor y causar picos de voltaje en el rail de 5V. El Arduino Pro Mini debería manejar hasta 5.5V en el pin 5V, pero cuando ocurren esos picos, podrían quemar el Arduino. Tuve este problema al probar el circuito, y alguien en los comentarios también reportó lo mismo. Una solución podría ser colocar capacitores de desacoplo más grandes en los servos, pero no estoy seguro y no lo he probado. Por favor, ten en cuenta este problema.

Por otro lado, en el ejemplo usé otros dos servos MG996R que no quemaron el Arduino, supongo porque no causaban picos tan altos. También usé este ejemplo con 4 servos S90 más pequeños y no tuvo ningún problema.

Ver también: Cómo Funciona un Servomotor y Cómo Controlar Servos con Arduino

Código Arduino para Servos y Motores Brushless

/* DIY RC Receiver - Servos and Brushless motors control by Dejan, www.HowToMechatronics.com Library: TMRh20/RF24, https://github.com/tmrh20/RF24/ */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <Servo.h>
RF24 radio(3, 2); // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;
Servo esc; // crear objeto servo para controlar el ESC
Servo servo1;
Servo servo2;
int escValue, servo1Value, servo2Value;
// Tamaño máximo de esta estructura es 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; // Crear una variable con la estructura anterior
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(); // Configurar el módulo como receptor
  resetData();
  esc.attach(10); // Pin digital Arduino D10 - CH9 en PCB
  servo1.attach(4); // D4 - CH1
  servo2.attach(5); // D5 - CH2
}
void loop() {
  // Verificar si seguimos recibiendo datos, o si tenemos conexión entre los dos módulos
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) {
    // Si el tiempo actual es más de 1 segundo desde que recibimos el último dato, significa que perdimos conexión
    resetData(); // Si se pierde la conexión, reiniciar los datos. Evita comportamiento no deseado, por ejemplo si un dron tiene acelerador arriba, si perdemos conexión puede seguir volando si no reiniciamos la función
  }
  // Verificar si hay datos para recibir
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package)); // Leer todos los datos y almacenarlos en la estructura 'data'
    lastReceiveTime = millis(); // En este momento hemos recibido los datos
  }
  // Controlar servos
  servo1Value = map(data.j2PotX, 0, 255, 0, 180); // Mapear valor recibido de 0-255 a 0-180 (grados), valores para controlar servos
  servo2Value = map(data.j2PotY, 0, 255, 0, 180);
  servo1.write(servo1Value);
  servo2.write(servo2Value);
  // Controlar motor brushless con ESC
  escValue = map(data.j1PotY, 127, 255, 1000, 2000); // Mapear valor recibido de 127-255 a 1000-2000, valores para controlar ESCs
  esc.writeMicroseconds(escValue); // Enviar señal PWM de control al ESC
}
void resetData() {
  // Reiniciar valores cuando no hay conexión de radio - Establecer valores iniciales por defecto
  data.j1PotX = 127;
  data.j1PotY = 127;
  data.j2PotX = 127;
  data.j2PotY = 127;
  data.j1Button = 1;
  data.j2Button = 1;
  data.pot1 = 1;
  data.pot2 = 1;
  data.tSwitch1 = 1;
  data.tSwitch2 = 1;
  data.button1 = 1;
  data.button2 = 1;
  data.button3 = 1;
  data.button4 = 1;
}Code language: Arduino (arduino)

Así que, después de recibir los datos del transmisor, convertimos los valores de 0 a 255 a valores de 0 a 180 para controlar los servos usando la función write(). De manera similar, convertimos los datos para controlar el ESC a valores de 1000 a 2000. En este ejemplo controlamos este ESC desde el punto medio del Joystick 1 hasta la posición arriba, por lo que convertimos los valores del medio, 127 a 255, en valores de 1000 a 2000. Usando la función writeMicroseconds() de la librería Servo, enviamos la señal PWM al ESC y así podemos controlar la velocidad del motor brushless de mínimo a máximo.

Ver también: Avión RC Arduino | 100% DIY

Así es como podemos controlar aviones RC, coches, barcos, etc., ya que suelen usar este tipo de motores, servos y motores brushless.

Ejemplo 3 – Control de Modelo RC Coche

El coche RC venía con su propio controlador que puede mover las ruedas delanteras a izquierda y derecha, así como mover el coche adelante y atrás.

Sin embargo, como es un coche RC barato, los controles son digitales, o sea, todo o nada, a posición máxima izquierda/derecha y velocidad máxima. Independientemente de eso, desarmé el coche para ver qué hay dentro y cómo puedo implementar el receptor RC Arduino para controlarlo.

Al descubrir los componentes electrónicos, noté que los dos motores son en realidad motores DC simples que operan a 5V. Incluso el motor delantero que controla los movimientos limitados para la dirección es un motor DC simple de rotación continua.

Así que, aparentemente, ya sabemos cómo controlar motores DC, así que reemplazar esta placa de circuito con nuestro receptor Arduino DIY será bastante fácil. Además de nuestro receptor, solo necesitamos un controlador de motor capaz de impulsar dos motores al mismo tiempo. Hay muchas opciones para ese propósito, incluso el que usamos en el primer ejemplo, el driver L298N.

Sin embargo, ese es demasiado grande para esta aplicación, así que elegí el driver de motor MX1508. Este es un driver dual DC simple que cuenta con puente H y control PWM. Tiene 4 pines de entrada de control, 4 pines para los motores y 2 pines para alimentación.

Desoldé las conexiones de los motores de la placa del coche RC y las soldé al driver. En la parte trasera soldé los pines de alimentación y lo que queda ahora es conectar este driver con el receptor. La alimentación para este coche RC proviene de una batería Ni-Cd de 4.8V ubicada en la parte inferior del coche.

Así que, usando cables jumper, conecté estos pines al pin VCC del Arduino, y también conecté los 4 pines de entrada de control del driver a 4 canales digitales. Como dije, este driver soporta control PWM, así que para el motor B (el motor trasero), usé los canales PWM número 2 y 3.

Componentes para este ejemplo

• Coche RC MGRC
• Driver de Motor DC MX1508
• Protoboard y Cables Jumper

El código para este coche RC es muy similar al primer ejemplo.

Código Arduino para Control de Modelo RC

/* Arduino RC Receiver - RC Model control by Dejan , www.HowToMechatronics.com Library: TMRh20/RF24, https://github.com/tmrh20/RF24/ */
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#define in3 5 // D5 - CH2 - Salida PWM
#define in4 6 // D6 - CH3 - Salida PWM
#define in1 7 // D7 - CH4
#define in2 8 // D8 - CH5
RF24 radio(3, 2); // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;
// Tamaño máximo de esta estructura es 32 bytes
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; // Crear una variable con la estructura anterior
int steering, throttle;
int motorSpeedA = 0;
int motorSpeedB = 0;
void setup() {
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
  Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address);
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  radio.startListening(); // Configurar el módulo como receptor
  resetData();
}
void loop() {
  // Verificar si seguimos recibiendo datos, o si tenemos conexión entre los dos módulos
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) {
    // Si el tiempo actual es más de 1 segundo desde que recibimos el último dato, significa que perdimos conexión
    resetData(); // Si se pierde la conexión, reiniciar los datos. Evita comportamiento no deseado
  }
  // Verificar si hay datos para recibir
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package)); // Leer todos los datos y almacenarlos en la estructura 'data'
    lastReceiveTime = millis(); // En este momento hemos recibido los datos
  }
  // Analizar datos del Joystick a variables steering y throttle
  steering = data.j2PotX;
  throttle = data.j1PotY;
  // Throttle usado para control adelante/atrás
  if (throttle < 110) {
    // Convertir lecturas de throttle descendentes para ir hacia atrás de 110 a 0 en valor 0 a 255 para señal PWM para aumentar velocidad del motor
    motorSpeedB = map(throttle, 110, 0, 0, 255);
    // Motor B hacia atrás
    analogWrite(in3, motorSpeedB);
    digitalWrite(in4, LOW);
  } else if (throttle > 140) {
    // Convertir lecturas de throttle ascendentes para ir hacia adelante de 140 a 255 en valor 0 a 255 para señal PWM para aumentar velocidad del motor
    motorSpeedB = map(throttle, 140, 255, 0, 255);
    // Motor B hacia adelante
    digitalWrite(in3, LOW);
    analogWrite(in4, motorSpeedB);
  }
  // Si el joystick se queda en el medio, los motores no se mueven
  else {
    digitalWrite(in3, HIGH);
    digitalWrite(in4, HIGH);
  }
  // Steering usado para control izquierda/derecha
  if (steering < 110) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
  }
  if (steering > 140) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
  }
  // Si el joystick se queda en el medio, los motores no se mueven
  else {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, HIGH);
  }
}
void resetData() {
  // Reiniciar valores cuando no hay conexión de radio - Establecer valores iniciales por defecto
  data.j1PotX = 127;
  data.j1PotY = 127;
  data.j2PotX = 127;
  data.j2PotY = 127;
  data.j1Button = 1;
  data.j2Button = 1;
  data.pot1 = 1;
  data.pot2 = 1;
  data.tSwitch1 = 1;
  data.tSwitch2 = 1;
  data.button1 = 1;
  data.button2 = 1;
  data.button3 = 1;
  data.button4 = 1;
}Code language: Arduino (arduino)

Usamos los datos que vienen de los joysticks para controlar el acelerador y la dirección del coche RC. Para mover hacia atrás usamos la función analogWrite() para enviar señal PWM al driver en el pin Input3, mientras mantenemos el pin input4 en LOW. Para mover hacia adelante, hacemos lo opuesto. Si el joystick se queda en el medio, damos orden al driver para frenar o detener los motores. El mismo principio se usa para el motor de dirección, aunque aquí no tenemos que usar analogWrite() ya que no necesitamos controlar la velocidad de este motor.

Después de subir este sketch al Arduino, tuve que volver a armar el coche RC. Coloqué el pequeño driver dentro de la carcasa y aseguré el resto de las partes con los tornillos. Reconecté el receptor con el driver y lo coloqué debajo de la carcasa exterior del coche, que tenía suficiente espacio para que entrara el receptor.

Así que no solo modificamos este coche RC para ser controlado con nuestro transmisor RC DIY, sino que también lo mejoramos agregando control PWM, así que ahora también podemos controlar la velocidad del coche. En caso de que el modelo RC que quieras modificar tenga servos y motores brushless en lugar de motores DC, puedes seguir el método explicado en el segundo ejemplo.

Espero que hayas disfrutado este tutorial y hayas aprendido algo nuevo. Siéntete libre de hacer cualquier pregunta en la sección de comentarios a continuación y no olvides revisar mi colección de Proyectos Arduino.