Receptor DIY Arduino RC para modelos RC y proyectos Arduino

Puede obtener los componentes necesarios para este ejemplo en los siguientes enlaces:

• Conductor L298N ……………………………….. 
• Motor de CC de alto par de 12 V ………….. 
• Motor CC con rueda de plástico …….
• Protoboard y cables de salto ………… 

Entonces, las conexiones son realmente simples, los 12V que provienen de las baterías van al pin de 12V de nuestro receptor, y los seis pines de control del controlador van a los 6 canales. Debemos señalar aquí que para poder controlar la velocidad de los motores, debemos proporcionar una señal PWM a los pines Habilitar A y Habilitar B del controlador. En nuestro receptor, los canales número 2, 3, 6 y 9 pueden emitir señales PWM, por lo que conecté los pines de habilitación del controlador a los canales número 2 y 6 en este caso.

Echemos un vistazo al código de Arduino ahora.

/*
   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  // Arduino pin D9 - CH6 on PCB board - PWM output
#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 - PWM output

RF24 radio(3, 2);   // nRF24L01 (CE, CSN)
const byte address[6] = "00001";
unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;

// Max size of this struct is 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; //Create a variable with the above structure

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(); //  Set the module as receiver
  resetData();
}
void loop() {
  // Check whether we keep receving data, or we have a connection between the two modules
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) { // If current time is more then 1 second since we have recived the last data, that means we have lost connection
    resetData(); // If connection is lost, reset the data. It prevents unwanted behavior, for example if a drone jas a throttle up, if we lose connection it can keep flying away if we dont reset the function
  }
  // Check whether there is data to be received
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
    lastReceiveTime = millis(); // At this moment we have received the data
  }
  
  // Parse the data from the Joystic 1 to the throttle and steering variables
  throttle = data.j1PotY;
  steering = data.j1PotX;  
  
  // Throttle used for forward and backward control
  // Joystick values: 0 to 255; down = 0; middle = 127; up = 255
  if (throttle < 110) {
    // Set Motor A backward
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    // Set Motor B backward
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
    // Convert the declining throttle readings for going backward from 110 to 0 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedA = map(throttle, 110, 0, 0, 255);
    motorSpeedB = map(throttle, 110, 0, 0, 255);
  }
  else if (throttle > 140) {
    // Set Motor A forward
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    // Set Motor B forward
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
    // Convert the increasing throttle readings for going forward from 140 to 255 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedA = map(throttle, 140, 255, 0, 255);
    motorSpeedB = map(throttle, 140, 255, 0, 255);
  }
  // If joystick stays in middle the motors are not moving
  else {
    motorSpeedA = 0;
    motorSpeedB = 0;
  }
  // Steering used for left and right control
  if (steering < 110) {
    // Convert the declining steering readings from 140 to 255 into increasing 0 to 255 value
    int xMapped = map(steering, 110, 0, 0, 255);
    // Move to left - decrease left motor speed, increase right motor speed
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA < 0) {
      motorSpeedA = 0;
    }
    if (motorSpeedB > 255) {
      motorSpeedB = 255;
    }
  }
  if (steering > 140) {
    // Convert the increasing steering readings from 110 to 0 into 0 to 255 value
    int xMapped = map(steering, 140, 255, 0, 255);
    // Move right - decrease right motor speed, increase left motor speed
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    // Confine the range from 0 to 255
    if (motorSpeedA > 255) {
      motorSpeedA = 255;
    }
    if (motorSpeedB < 0) {
      motorSpeedB = 0;
    }
  }
  // Prevent buzzing at low speeds (Adjust according to your motors. My motors couldn't start moving if PWM value was below value of 70)
  if (motorSpeedA < 70) {
    motorSpeedA = 0;
  }
  if (motorSpeedB < 70) {
    motorSpeedB = 0;
  }
  analogWrite(enA, motorSpeedA); // Send PWM signal to motor A
  analogWrite(enB, motorSpeedB); // Send PWM signal to motor B
}
void resetData() {
  // Reset the values when there is no radio connection - Set initial default values
  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: Entonces, primero debemos incluir el SPI y la biblioteca RF24, definir algunos pines, el objeto de radio y la estructura de datos donde almacenaremos los datos entrantes del transmisor. En la sección de configuración, debemos definir las salidas de los pines y comenzar la comunicación por radio. Para obtener más detalles sobre cómo funciona esto y qué hace cada una de estas líneas, puede consultar mi tutorial detallado NRF24L01.

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

Entonces, una vez que leemos esos datos, podemos hacer lo que queramos con ellos. En este caso, utilizaremos el valor del eje Y del Joystick 1 para controlar el acelerador y el valor del eje X para controlar la dirección. Puse estos datos en variables separadas de aceleración y dirección. Los valores que obtenemos de los joysticks van de 0 a 255. Por lo tanto, si movemos el joystick hacia abajo, configuraremos los pines de control del conductor de manera adecuada para que el automóvil se mueva hacia atrás y usaremos el valor del acelerador para controlar la velocidad de movimiento. El mismo principio se aplica para conducir hacia adelante, hacia la izquierda y hacia la derecha. Nuevamente, ya tengo un tutorial detallado sobre cómo funciona este automóvil para que pueda verificarlo para una mejor comprensión. En la parte inferior del código, podemos observar la función personalizada resetData(), que restablece todos los valores a sus valores iniciales predeterminados, de modo que, en caso de que se pierda la comunicación por radio, el automóvil detectará el movimiento.

Ejemplo 2 – Arduino RC Receiver Servos and Brushless Motors Control

Muy bien, ahora podemos continuar con el segundo ejemplo, controlar servos y motores sin escobillas usando este receptor Arduino RC.

Para controlar motores sin escobillas, necesitamos un ESC o controlador electrónico de velocidad. 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 5 V a través de su función de circuito eliminador de batería, por lo que también podemos alimentar nuestro receptor con él.

Ver también: Tutorial de control de motores sin escobillas de Arduino | ESC | BLDC

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

Puede obtener los componentes necesarios para este ejemplo en los siguientes enlaces:

• Motor sin escobillas ………………………..
• ESC 30A ……………………………………………
• Batería Li-Po ……………………..……
• Servomotor MG996R ………………

Las señales de entrada para controlar tanto los servos como los motores sin escobillas mediante ESC son casi las mismas. Utilizan una señal PWM específica de 50 Hz que se puede generar fácilmente con la biblioteca Arduino Servo.

Nota:  Al usar servos MG996R con esta configuración, pueden causar un problema en el circuito y quemar el Arduino Pro Mini. Podría consumir una corriente más alta y provocar picos de voltaje en el riel de 5V. El Arduino Pro Mini debe manejar hasta 5.5v en el pin de 5V, pero cuando ocurren esos picos, pueden quemar el Arduino. Tuve este problema al probar el circuito, y alguien en la sección de comentarios también informó lo mismo. Una solución a esto podría ser colocar condensadores de desacoplamiento más grandes en los servos, pero no estoy muy seguro y no lo he probado. Por lo tanto, tenga en cuenta este problema.

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

Ver también: Cómo funciona el servomotor & Cómo controlar servos usando Arduino

/*
  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;  // create servo object to control the ESC
Servo servo1;
Servo servo2;
int escValue, servo1Value, servo2Value;
// Max size of this struct is 32 bytes - NRF24L01 buffer limit
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; //Create a variable with the above structure
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(); //  Set the module as receiver
  resetData();
  esc.attach(10);   // Arduino digital pin D10 - CH9 on PCB board
  servo1.attach(4); // D4 - CH1
  servo2.attach(5); // D5 - CH2
}
void loop() {

  // Check whether we keep receving data, or we have a connection between the two modules
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) { // If current time is more then 1 second since we have recived the last data, that means we have lost connection
    resetData(); // If connection is lost, reset the data. It prevents unwanted behavior, for example if a drone jas a throttle up, if we lose connection it can keep flying away if we dont reset the function
  }

  // Check whether there is data to be received
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
    lastReceiveTime = millis(); // At this moment we have received the data
  }

  // Controlling servos
  servo1Value = map(data.j2PotX, 0, 255, 0, 180); // Map the receiving value form 0 to 255 to 0 to 180(degrees), values used for controlling servos
  servo2Value = map(data.j2PotY, 0, 255, 0, 180);
  servo1.write(servo1Value);
  servo2.write(servo2Value);

  // Controlling brushless motor with ESC
  escValue = map(data.j1PotY, 127, 255, 1000, 2000); // Map the receiving value form 127 to 255 to  1000 to 2000, values used for controlling ESCs
  esc.writeMicroseconds(escValue); // Send the PWM control singal to the ESC
  
}
void resetData() {
  // Reset the values when there is no radio connection - Set initial default values
  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)

Entonces, 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 número 1, hasta la posición superior, por lo que convertimos los valores desde el medio , 127 a 255 en valores de 1000 a 2000. Usando la función writeMicroseconds() de Servo Library enviamos la señal PWM al ESC y así podemos controlar la velocidad del motor sin escobillas de mínimo a máximo.

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

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

Ejemplo 3:Control de modelo de coche RC

El auto RC vino con su propio controlador que puede controlar las ruedas delanteras para moverse hacia la izquierda y hacia la derecha, así como mover el auto hacia adelante y hacia atrás.

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

Una vez que descubrí los componentes electrónicos, noté que los dos motores son en realidad simples motores de CC que funcionan a 5V. Incluso el motor delantero que controla los movimientos limitados de la dirección es un simple motor de CC de rotación continua.

Entonces, aparentemente, ya sabemos cómo controlar los motores de CC, por lo 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 manejar dos motores al mismo tiempo. Hay muchas opciones para ese propósito, incluso la que usamos en el primer ejemplo, el controlador L298N.

Sin embargo, ese es demasiado grande para esta aplicación, así que elegí el controlador de motor MX1508. Este es un controlador de motor de CC dual 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 de circuito del coche RC y las soldé al controlador. En la parte trasera soldé los pines de alimentación y lo que queda ahora es conectar este controlador con el receptor. La energía de este automóvil RC proviene de una batería Ni-Cd de 4,8 V ubicada en la parte inferior del automóvil.

Entonces, usando cables de salto, conecté estos pines al pin VCC del Arduino y también conecté los 4 pines de entrada de control del controlador a 4 canales digitales. Como dije, este controlador es compatible con el control PWM, por lo que para el motor B, o el motor trasero, utilicé los canales PWM número 2 y 3.

Puede obtener los componentes necesarios para este ejemplo en los siguientes enlaces:

• Coche teledirigido MGRC ………………………………
• MX1508 Controlador de motor de CC ………………
• Protoboard y cables de salto ………… 

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

/*
   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 - PWM output
#define in4 6  // D6 - CH3 - PWM output
#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;

// Max size of this struct is 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; //Create a variable with the above structure

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(); //  Set the module as receiver
  resetData();
}
void loop() {
  // Check whether we keep receving data, or we have a connection between the two modules
  currentTime = millis();
  if ( currentTime - lastReceiveTime > 1000 ) { // If current time is more then 1 second since we have recived the last data, that means we have lost connection
    resetData(); // If connection is lost, reset the data. It prevents unwanted behavior, for example if a drone jas a throttle up, if we lose connection it can keep flying away if we dont reset the function
  }
  // Check whether there is data to be received
  if (radio.available()) {
    radio.read(&data, sizeof(Data_Package)); // Read the whole data and store it into the 'data' structure
    lastReceiveTime = millis(); // At this moment we have received the data
  }
  // Parse the data from the Joystic 1 to the steering and throttle variables
  steering = data.j2PotX;
  throttle = data.j1PotY;


// Throttle used for forward and backward control
  if (throttle < 110) {
    // Convert the declining throttle readings for going backward from 110 to 0 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedB = map(throttle, 110, 0, 0, 255);
    // Set Motor B backward
    analogWrite(in3, motorSpeedB);
    digitalWrite(in4, LOW);
  }
  else if (throttle > 140) {
    // Convert the increasing throttle readings for going forward from 140 to 255 into 0 to 255 value for the PWM signal for increasing the motor speed
    motorSpeedB = map(throttle, 140, 255, 0, 255);
    // Set Motor B forward
    digitalWrite(in3, LOW);
    analogWrite(in4, motorSpeedB);
  }
  // If joystick stays in middle the motors are not moving
  else {
    digitalWrite(in3, HIGH);
    digitalWrite(in4, HIGH);
  }
  
// steering used for left and right control
  if (steering < 110) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
  }
  if (steering > 140) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
  }
  // If joystick stays in middle the motors are not moving
  else {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, HIGH);
  }
}
void resetData() {
  // Reset the values when there is no radio connection - Set initial default values
  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 provenientes de los joysticks para controlar el acelerador y la dirección del auto RC. Para retroceder, usamos la función analogWrite() para enviar la señal PWM al controlador en el pin Input3, mientras mantenemos el pin input4 BAJO. Para avanzar, lo hacemos al revés. Si el joystick se queda en el medio, le damos la orden al conductor para que frene o pare los motores. El mismo principio se usa para el motor de dirección, aunque aquí no tenemos que usar la función analogWrite() ya que no necesitamos controlar la velocidad de este motor.

Después de subir este boceto al Arduino, tuve que volver a montar el coche RC. Coloqué el pequeño controlador en la carcasa interior y aseguré el resto de las piezas con los tornillos. Volví a conectar el receptor con el conductor y lo coloqué debajo de la carcasa exterior del automóvil, que tenía espacio suficiente para caber en el receptor.

Entonces, no solo modificamos este auto RC para que sea controlado con nuestro transmisor DIY RC, sino que también lo mejoramos agregando control PWM para que ahora también podamos controlar la velocidad del auto. 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éntase libre de hacer cualquier pregunta en la sección de comentarios a continuación y no olvide consultar mi colección de proyectos Arduino.

Avión RC Arduino | 100% bricolaje Máquina de corte de espuma CNC Arduino