Receptor DIY Arduino RC para modelos RC y proyectos Arduino

En este tutorial aprenderemos cómo hacer un receptor RC basado en Arduino. Desde que construí mi transmisor DIY Arduino RC en uno de mis videos anteriores, he recibido muchas solicitudes de ustedes para construir un receptor especial para él, así que aquí está.

Puede ver el vídeo a continuación 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 con algunos ejemplos. En el primer ejemplo, utilizamos este receptor Arduino RC para controlar un automóvil sencillo que consta de dos motores de CC. En el segundo ejemplo, le mostraré cómo controlar motores y servos sin escobillas, que son componentes comunes que se encuentran en muchos aviones, barcos, automóviles, etc. comerciales de RC. Si sabemos controlarlos, podremos modificar y controlar fácilmente muchos modelos RC con nuestro propio transmisor Arduino hecho a medida.

Como>

Diagrama del circuito del receptor Arduino RC

Primero, veamos el diagrama del circuito de este sistema. La comunicación por radio se basa en los módulos transceptores NRF24L01.

El>

También podemos señalar aquí que este receptor RC no necesariamente funciona solo con este transmisor en particular que construí. Se puede utilizar con cualquier otra configuración similar que consista en una placa Arduino y un módulo NRF24L01.

Aún>

Puede obtener los componentes necesarios para este receptor Arduino RC en los siguientes enlaces:

• Módulo transceptor NRF24L01…….……… Amazonas / Banggood / AliExpress
• NRF24L01 + PA + LNA …………………..……. Amazonas / Banggood / AliExpress
• Regulador de voltaje AMS1117 3.3V………….. Amazon / Banggood / AliExpress
• Conectores de clavijas enchufe + enchufe ……………….. Amazonas / Banggood / AliExpress
• Arduino Pro Mini………………..……..………….. Amazonas / Banggood / AliExpress
• Arduino Pro Mini como el que usé… Ebay

Divulgación: estos son enlaces de afiliados. Como asociado de Amazon, gano con compras que califican.

Para comunicarse con Arduino, el módulo NRF24L01 utiliza el protocolo SPI y dos pines digitales adicionales. Esto significa que todavía tenemos nueve pines digitales disponibles que pueden usarse como canales de salida, dos de los cuales son los pines RX y TX. Vale la pena señalar que estos pines deben estar desconectados de todo mientras subimos un boceto a la placa Arduino. Es por eso que hice posible conectarlos o desconectarlos usando encabezados de pines separados. De hecho, también podemos utilizar las entradas analógicas como salidas digitales. Así que aunque esta placa Arduino sea bastante pequeña, tenemos a nuestra disposición numerosas salidas o canales.

diseño de PCB

Para mantener este circuito compacto, creé una placa de circuito personalizada utilizando el software gratuito de diseño de circuitos en línea EasyEDA. Aquí he dispuesto los 8 canales justo al lado de un 5V y un riel de tierra para que podamos conectar servos y ECS directamente a ellos. El canal número 9 está en una posición separada, cerca del pin VCC del Arduino, por lo que podemos, por ejemplo, utilizar un regulador para alimentar el Arduino con su función de circuito eliminador de batería que suministra 5V. Por supuesto, también podríamos utilizar otros canales para este fin ya que el pin VCC también está conectado a este carril de 5V.

En>

Otra cosa que podemos tener en cuenta aquí es que algunas placas Arduino Pro Mini pueden tener una disposición de pines diferente. Es por eso que he incluido otra versión de la placa para que puedas elegir la que se adapta a tu placa Arduino Pro Mini.

Aquí>Archivos de proyecto de esta placa de circuito.. Después de completar el diseño, creé el archivo Gerber necesario para hacer la placa de circuito.

Archivos Gerber:

Entonces yo Pedí la placa a JLCPCB quienes también son los patrocinadores de este video.

Aquí>

ensamblaje de PCB

Al cabo de unos días llegaron las tablas. La calidad de las tablas es excelente y todo coincide exactamente con el diseño.

Ahora>

También>

A continuación adjunté todos los demás encabezados de pines. Necesitamos cabezales de clavija tanto macho como hembra. Alternativamente, usted decide qué encabezados de pin utilizar. Sin embargo, es una buena idea utilizar conectores macho para los canales digitales porque los servomotores y los conectores ESC son hembra y por lo tanto podemos conectarlos fácilmente.

El>

Dependiendo>

Para programar el receptor o conectar el Arduino Pro Mini al ordenador, podemos utilizar una interfaz USB a Serial UART que se puede conectar al cabezal de programación.

En>

Y>

Ejemplo 1 – Coche Arduino RC

Bien, ahora podemos continuar y echar un vistazo al primer ejemplo.

Es>

Ver también: Controlador de motor L298N: interfaz Arduino, funcionamiento, códigos, diagramas de circuitos

En esta ocasión usaremos nuestro nuevo receptor Arduino RC para controlarlo. Para accionar los motores de CC utilizamos el controlador de motor L298N y para el suministro de energía utilizamos 3 baterías de iones de litio que proporcionan alrededor de 12 V.

Puede>

• Controlador L298N ……………………………….. Amazon / Banggood / AliExpress
• Motor de alto par de 12 V CC………….. Amazon / Banggood / AliExpress
• Motor DC con rueda de plástico……. Amazon / Banggood / AliExpress
• Cables de puente y placa de pruebas………… Amazon / Banggood / AliExpress

Divulgación: estos son enlaces de afiliados. Como asociado de Amazon, gano con compras que califican.

Así que las conexiones son realmente sencillas: los 12V de las baterías van al pin de 12V de nuestro receptor y los seis pines de control del driver van a los 6 canales. Lo que debemos tener en cuenta aquí es que para controlar la velocidad de los motores, debemos suministrar 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 en este caso conecté los pines de habilitación del controlador a los canales número 2 y 6.

Ahora veamos el código Arduino.

/*
   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 la biblioteca SPI y RF24, definir algunos pines, el objeto de radio y la estructura de datos en la que almacenamos los datos entrantes del transmisor. En la sección de configuración necesitamos definir las salidas de los pines e iniciar la comunicación por radio. Para obtener más información sobre cómo funciona esto y qué hace cada línea, consulte mi tutorial detallado NRF24L01.

En la sección de bucle comprobamos constantemente si estamos recibiendo datos y, de ser así, 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, joysticks, potenciómetros y botones y envía estos datos al receptor como un solo paquete.

Una vez que leemos estos datos, podemos hacer lo que queramos con ellos. En este caso, utilizamos 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 están entre 0 y 255. Entonces, cuando movemos el joystick hacia abajo, ajustamos los pines de control del conductor en consecuencia para que el automóvil se mueva hacia atrás y usamos el valor del acelerador para controlar la velocidad del movimiento. El mismo principio se aplica al desplazamiento hacia adelante, hacia la izquierda y hacia la derecha. Nuevamente, ya tengo un tutorial detallado sobre cómo funciona este auto, así que puedes verlo para comprenderlo mejor. Al final del código podemos ver la función personalizada resetData() que restablece todos los valores a sus valores predeterminados iniciales para que el coche detecte movimiento en caso de pérdida de comunicación por radio.

Ejemplo 2: servos del receptor Arduino RC y controlador de motor sin escobillas

Bueno, ahora podemos pasar al segundo ejemplo, controlar servos y motores sin escobillas con este receptor Arduino RC.

Para>

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

Los servomotores tienen las mismas conexiones que el controlador y se pueden conectar fácilmente a cualquier canal disponible.

Puede>

• Motor sin escobillas……………………….. Amazon / Banggood / AliExpress
• Regulador 30A ……………………………………… Amazon / Banggood / AliExpress
• Batería Li-Po……………………..…… Amazonas / Banggood / AliExpress
• Servomotor MG996R……………… Amazon / Banggood / AliExpress

Divulgación: estos son enlaces de afiliados. Como asociado de Amazon, gano con compras que califican.

Las señales de entrada para controlar servos y 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 utilizando la biblioteca Arduino Servo.

Nota: El uso de servos MG996R con esta configuración puede causar problemas en el circuito y dañar el Arduino Pro Mini. Se puede consumir una corriente más alta, lo que puede causar picos de voltaje en el riel de 5 V. El Arduino Pro Mini debe manejar hasta 5,5 V en el pin de 5 V, pero cuando se producen estos picos de voltaje, el Arduino puede quemarse. Tuve este problema mientras probaba 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 del todo seguro y no lo he probado. Tenga en cuenta este problema.

Por otro lado, en el ejemplo usé otros dos servos MG996R que no dañaron el Arduino, probablemente porque no causaron picos tan altos. También usé este ejemplo con 4 servos S90 más pequeños y no hubo problemas.

Ver también: Cómo funciona el servomotor y cómo controlar los servos con 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)

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 en valores de 1000 a 2000. En este ejemplo, controlamos este ESC desde el centro del joystick número 1 hasta la posición superior, por lo que convertimos los valores desde el centro. a 127 a 255 de 1000 a 2000. Usando la función writeMicrosegundos() de la Servo Biblioteca, enviamos la señal PWM al controlador 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

De esta forma podemos controlar aviones RC, coches, barcos, etc. porque suelen utilizar este tipo de motores, servos y motores brushless.

Ejemplo 3: control del modelo de coche RC

El auto RC viene con su propio controlador, que puede controlar el movimiento de las ruedas delanteras hacia la izquierda y hacia la derecha, así como el movimiento hacia adelante y hacia atrás del auto.

Sin>

Después>

Aparentemente ya sabemos cómo controlar motores de CC, por lo que reemplazar esta placa con nuestro receptor Arduino DIY será bastante fácil. Además de nuestro receptor, todo lo que necesitamos es un controlador de motor que pueda accionar dos motores al mismo tiempo. Hay muchas opciones para este propósito, incluso la que usamos en el primer ejemplo, el controlador L298N.

Sin>

Desoldé>

Entonces>

Puede>

• Coche teledirigido MGRC……………………………… Amazon / Banggood / AliExpress
• Controlador de motor de CC MX1508……………… Amazon / Banggood / AliExpress
• Cables de puente y placa de pruebas………… Amazon / Banggood / AliExpress

Divulgación: estos son enlaces de afiliados. Como asociado de Amazon, gano con compras que califican.

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 el movimiento hacia atrás, utilizamos la función analogWrite() para enviar una señal PWM en el pin de Entrada3 al controlador mientras mantenemos el pin de Entrada4 en BAJO. Para avanzar, lo hacemos al revés. Si el joystick se queda en el medio, le damos al conductor la orden de frenar o parar los motores. Se utiliza el mismo principio para el motor de dirección, sin embargo, aquí no necesitamos 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 caja interior y aseguré las piezas restantes con los tornillos. Volví a conectar el receptor al conductor y lo coloqué debajo de la carcasa exterior del automóvil, lo que proporcionó suficiente espacio para el receptor.

Es>

Espero que hayas disfrutado este tutorial y hayas aprendido algo nuevo. No dudes en hacer tus preguntas en la sección de comentarios a continuación y no olvides echar un vistazo a mi colección de proyectos Arduino.