DIY Arduino RC Transmitter

In tutorial we will learn how to build a DIY Arduino RC transmitter. Very often I need wireless control for the projects that I make, so therefore I built this multifunctional radio controller which can be used for pretty much everything.

Overview


Now I can wirelessly control any Arduino project with just some small adjustments at the receiver side. This transmitter can be also used as any commercial RC transmitter for controlling RC toys, cars, drones and so on. For that purpose it just needs a simple Arduino receiver which then generates the appropriate signals for controlling those commercial RC devices. I will explain how everything works in this video through few examples of controlling an Arduino robot car, controlling the Arduino Ant Robot from my previous video and controlling a brushless DC motor using an ESC and some servo motors.

DIY Arduino RC Transmitter Robot Car Control

The radio communication of this controller is based on the NRF24L01 transceiver module which if used with an amplified antenna it can have a stable range of up to 700 meters in open space. It features 14 channels, 6 of which are analog inputs and 8 digital inputs.

Arduino RC Controller with 14 channels and MPU6050 Accelerometer and Gyro

It has two joysticks, two potentiometers, two toggle switches, six buttons and additionally an internal measuring unit consisting of an accelerometer and a gyroscope which can be also used for controlling things with just moving around or tilting the controller.

Arduino RC Transmitter Circuit Diagram

To begin with, let’s take a look at the circuit diagram. The brain of this RC controller is an Arduino Pro Mini which is powered using 2 LiPo batteries producing around 7.4 volts. We can connect them directly to the RAW pin of the Pro Mini which has a voltage regulator that reduced the voltage to 5V. Note that there are two versions of the Arduino Pro Mini, like the one I have that operates at 5V and the other operates at 3.3V.

DIY Arduino based RC Transmitter Circuit Diagram

On the other hand, the NRF24L01 module strictly needs 3.3V and it’s recommended to come from a dedicated source. Therefore we need to use a 3.3V voltage regulator which is connected to the batteries and convert the 7.4V to 3.3V. Also we need to use a decoupling capacitor right next to the module in order to keep the voltage more stable, thus the radio communication will be more stable as well. The NRF24L01 module communicates with the Arduino using SPI protocol, while the MPU6050 accelerometer and gyro module uses the I2C protocol.

You can get the components needed for this Arduino Tutorial from the links below:

  • NRF24L01 Transceiver Module……….. Amazon / Banggood
  • NRF24L01 + PA + LNA ……………………. Amazon / Banggood
  • Potentiometer ……………………………….. Amazon / Banggood
  • Servo Motor …………………………………… Amazon / Banggood
  • Toggle Switch …………………………….….. Amazon / Banggood
  • Joystick ………………………………………….. Amazon / Banggood – this Joystick comes with a breakout board so you will have to desolder the Joystick from it
  • Joystick without breakout board ………… Ebay
  • Arduino Pro Mini…………………………….. Amazon / Banggood
  • Arduino Pro Mini like the one I used….. Ebay

*Please note: These are affiliate links. I may make a commission if you buy the components through these links. I would appreciate your support in this way!

PCB Design

I actually ended up utilizing all analog and digital pins of the Arduino Pro Mini. So now if I try to connect everything together using jump wires it will be quite a mess. Therefore I designed a custom PCB using the EasyEDA free online circuit design software.

Here I took into consideration the ergonomics of the controller and designed it to be easily held by two hands, while all controls are within the range of the fingers. I made the edges round and added some 3mm holes so I can mount the PCB onto something later. I placed the pins for programming the Arduino Pro Mini at the top side of the controller so they can be easily accessed in case we want to reprogram the Arduino. We can also notice here that I used the RX and TX pins of the Arduino for the joystick buttons. However these two lines needs to be disconnected from anything while we are uploading the sketch to the Arduino. So therefore they are interrupted with two pins which can be then easily connected using simple jumper caps.

Please note: Make sure you have the right Arduino Pro Mini version to mach the PCB or modify the PCB design according to it.

Here’s a link to the project files of this PCB design. So once I finished the design, I generated the Gerber file needed for manufacturing the PCB.

Gerber file:

Then I ordered the PCB from JLCPCB which are also the sponsor of this video.

Here we can simply drag and drop the Gerber file and once uploaded, we can review our PCB in the Gerber viewer. If everything is all right then we can go on and select the properties that we want for our PCB. This time I chose the PCB color to be black. And that’s it, now we can simply order our PCB at a reasonable price. Note that if it’s your first order from JLCPCB, you can get up to 10 PCBs for only $2.

And here it is. I just really love how this PCB turned out in this black color. The quality of the PCB is great, and everything is exactly the same as in the design.

RC Controller Black Color PCB from JLCPCB

Assembling the PCB

Ok now we can move on with assembling the PCB. I started with a soldering the pin headers of the Arduino Pro Mini. An easy and good way to do that is to place them onto a breadboard and so they will stay firmly in place while soldering.

DIY Arduino based RC Transmitter required components

The Pro Mini also have pins on the sides, but note that these pins location might vary depending on the manufacturer.

Soldering the Arduino Pro Mini to the PCB

For the particular model that I have, I need 5 pins for each side, while leaving one GND pin empty because I used its area below on the PCB for running some traces. I soldered the Arduino Pro Mini directly onto the PCB and cut the execs length of the headers. Right next to it goes the MPU6050 accelerometer and gyroscope module.

HT7333 3.3v voltage regulator for powering NRF24l01

Then I soldered the 3.3V voltage regulator with a capacitor next to it, and another capacitor near the NRF24L01 module. This module have three different versions and we can use any of them here.

NRF24L01 +pla +nla three different verions

I continued with the pins for programming the Arduino, the RX and TX pins, the power supply pins and the power switch.

Next for soldering the potentiometers to the PCB I had to extend their pins using some pin headers.

Extending the potentiometer pins using pin headers

We can note here that I previously cut the length of the knobs so I can properly fit some caps onto them. However, we will solder the potentiometers to the PCB a bit later.

Then I inserted and soldered the two toggle switches and the two joysticks in place.

Extending the push button pins

Finally what’s left is to solder the four push buttons. However they don’t have the proper height, so again I used pin headers to extend their pins a little bit.

And that’s it, our PCB is now ready so we can continue with making the cover for it. Because I like how the PCB looks and I want to be visible I decided to use transparent acrylic for the cover.

Arduino RC Controller PCB

Here I have 4 mm tick transparent acrylic which currently have a protective foil and appears to be blue. The idea for the cover is to make two plates with the shape of the PCB and secure one of them at the top side and the other at the bottom side of the PCB.

Making a cover for the RC Transmitter using transparent acrylic

So I marked PCB shape and using a metal hand saw I cut the acrylic according to it.Shaping acrylic using a metal hand saw

Then using a simple rasp I fine-tuned the shape of the acrylic. The two plates came out great and they perfectly match with the PCB.

Fine tuning the acrylic covers using a rasp

Next I marked the locations where I need to make openings for the components to pass through. Using a 3mm drill I first made the 4 holes for securing the plates to the PCB. For these holes I also made counter sinks so that the bolts can be placed flash with the plates.

making counter sinks on the acrylic plate

For the openings for the toggle switches and the potentiometers I used 6mm drill, and for the joystick openings I used 25mm Forstner bit. Again, using a rasp, I fine-tuned all the openings.

making a 25mm hole on the acrylic plate using a Forstner bit

Before assembling the cover, just a quite note that I actually soldered the pin header for the power supply upside down so it can be reached from the back side where the battery will be located.

Ok now we can start with assembling the cover. I started with peeling off the protective foil from the acrylic which I must admit was quite satisfying because the acrylic was so clean now. So first I secured the two potentiometers on the top plate, inserted the 3mm mounting bolts and placed the 11mm distance rings in place.

inserting the acrylic cover to the pbc

Then I carefully merged and secured the top plate and the PCB using some bolts. At this point I finally soldered the potentiometers to the PCB because earlier I didn’t know exactly at what height they will be placed.

soldering the potentiometers to the pcb

Next on the back plate I attached the battery holder using 2 bolts. I finished the cover assembly by securing the back plate to the back side of the PCB using the four mounting bolts.

Finally, we can attach the battery lines to the power supply pins, insert and secure the knobs on the potentiometers, insert the joysticks knobs and attach the antenna to the NRF24l01 module. And that’s it, we are finally done with the DIY Arduino RC transmitter.

NRF24L01 +pla +nla - amplified antenna - range up to 700m

What’s left now is to program the Arduino. For programming a Pro Mini board we need an USB to serial UART interface which can be hooked up to the programing header located on the top side of our controller.

Programming Arduino Pro Mini using an USB to serial UART interface

Then in the Arduino IDE tools menu we need to select the Arduino Pro or Pro Mini board, select the proper version of the processor, select the port and select the programming method to “USBasp”.

Programming an Arduino pro mini Arduino IDE settings

And so now we are able to upload the code to the Arduino.

DIY Arduino based RC Transmitter Code

Let’s explain how the transmitter code works. So first we need to include the SPI and RF24 library for the wireless communication, and the I2C library for the accelerometer module.  Then we need to define the digital inputs, some variables needed for the program below, define the radio object and the communication address.

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


// Define the digital inputs
#define jB1 1  // Joystick button 1
#define jB2 0  // Joystick button 2
#define t1 7   // Toggle switch 1
#define t2 4   // Toggle switch 1
#define b1 8   // Button 1
#define b2 9   // Button 2
#define b3 2   // Button 3
#define b4 3   // Button 4

const int MPU = 0x68; // MPU6050 I2C address
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"; // Address

Then we need to define a structure where we will store the 14 input values of the controller. The maximum size of this structure can be 32 bytes because that’s the NRF24L01 buffer limit or the amount of data the module can send at once.

/ 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

In the setup section we need to initialize the MPU6050 module and we can also calculate the IMU error which is a values that is later used when calculating the correct angles of the module.

void initialize_MPU6050() {
  Wire.begin();                      // Initialize comunication
  Wire.beginTransmission(MPU);       // Start communication with MPU6050 // MPU=0x68
  Wire.write(0x6B);                  // Talk to the register 6B
  Wire.write(0x00);                  // Make reset - place a 0 into the 6B register
  Wire.endTransmission(true);        //end the transmission
  // Configure Accelerometer
  Wire.beginTransmission(MPU);
  Wire.write(0x1C);                  //Talk to the ACCEL_CONFIG register
  Wire.write(0x10);                  //Set the register bits as 00010000 (+/- 8g full scale range)
  Wire.endTransmission(true);
  // Configure Gyro
  Wire.beginTransmission(MPU);
  Wire.write(0x1B);                   // Talk to the GYRO_CONFIG register (1B hex)
  Wire.write(0x10);                   // Set the register bits as 00010000 (1000dps full scale)
  Wire.endTransmission(true);
}

You can find more details how MEMS accelerometer and gyro work here. A dedicated tutorial for the MPU6050 is coming soon.

Then we need to initialize the radio communication, activate the Arduino internal pull-up resistors for all digital inputs and set the initial default values for all variables.

// Define the radio communication
  radio.begin();
  radio.openWritingPipe(address);
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  
  // Activate the Arduino internal pull-up resistors
  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);

In the loop section start by reading the all analog inputs, map their values from 0 to 1023 into byte values from 0 to 255 because we already defined the variables in our structure as bytes. Each input is stored in the particular data variable from the structure.

// Read all analog inputs and map them to one Byte value
  data.j1PotX = map(analogRead(A1), 0, 1023, 0, 255); // Convert the analog read value from 0 to 1023 into a BYTE value from 0 to 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);

We should just note that because we use the pull-up resistors the digital pins readings are 0 when the buttons are pressed.

// Read all digital inputs
  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);

So using the radio.write() function we simple send the values from all 14 channels to the receiver.

// Send the whole data from the structure to the receiver
  radio.write(&data, sizeof(Data_Package));

In case the toggle switch 1 is switched on, then we use the accelerometer and gyro data instead for the control.

if (digitalRead(t1) == 0) {
    read_IMU();    // Use MPU6050 instead of Joystick 1 for controling left, right, forward and backward movements
  }

So instead of the joystick 1 X and Y values we are using the angle values we are getting from the IMU, which we previously convert them from values from -90 to +90 degrees into byte values from 0 to 255 appropriately.

// Map the angle values from -90deg to +90 deg into values from 0 to 255, like the values we are getting from the Joystick
  data.j1PotX = map(angleX, -90, +90, 255, 0);
  data.j1PotY = map(angleY, -90, +90, 0, 255);

So that’s how the transmitter code, the most important things were defining the radio communication and sending the data to the receiver.

Here’s the complete Arduino code for this DIY Arduino RC Transmitter:

/*
        DIY Arduino based RC Transmitter
  by Dejan Nedelkovski, www.HowToMechatronics.com
  Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/

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


// Define the digital inputs
#define jB1 1  // Joystick button 1
#define jB2 0  // Joystick button 2
#define t1 7   // Toggle switch 1
#define t2 4   // Toggle switch 1
#define b1 8   // Button 1
#define b2 9   // Button 2
#define b3 2   // Button 3
#define b4 3   // Button 4

const int MPU = 0x68; // MPU6050 I2C address
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"; // Address

// 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);
  
  // Initialize interface to the MPU6050
  initialize_MPU6050();

  // Call this function if you need to get the IMU error values for your module
  //calculate_IMU_error();
  
  // Define the radio communication
  radio.begin();
  radio.openWritingPipe(address);
  radio.setAutoAck(false);
  radio.setDataRate(RF24_250KBPS);
  radio.setPALevel(RF24_PA_LOW);
  
  // Activate the Arduino internal pull-up resistors
  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);
  
  // Set initial default values
  data.j1PotX = 127; // Values from 0 to 255. When Joystick is in resting position, the value is in the middle, or 127. We actually map the pot value from 0 to 1023 to 0 to 255 because that's one BYTE value
  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;
}
void loop() {
  // Read all analog inputs and map them to one Byte value
  data.j1PotX = map(analogRead(A1), 0, 1023, 0, 255); // Convert the analog read value from 0 to 1023 into a BYTE value from 0 to 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);
  // Read all digital inputs
  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);
  // If toggle switch 1 is switched on
  if (digitalRead(t1) == 0) {
    read_IMU();    // Use MPU6050 instead of Joystick 1 for controling left, right, forward and backward movements
  }
  // Send the whole data from the structure to the receiver
  radio.write(&data, sizeof(Data_Package));
}

void initialize_MPU6050() {
  Wire.begin();                      // Initialize comunication
  Wire.beginTransmission(MPU);       // Start communication with MPU6050 // MPU=0x68
  Wire.write(0x6B);                  // Talk to the register 6B
  Wire.write(0x00);                  // Make reset - place a 0 into the 6B register
  Wire.endTransmission(true);        //end the transmission
  // Configure Accelerometer
  Wire.beginTransmission(MPU);
  Wire.write(0x1C);                  //Talk to the ACCEL_CONFIG register
  Wire.write(0x10);                  //Set the register bits as 00010000 (+/- 8g full scale range)
  Wire.endTransmission(true);
  // Configure Gyro
  Wire.beginTransmission(MPU);
  Wire.write(0x1B);                   // Talk to the GYRO_CONFIG register (1B hex)
  Wire.write(0x10);                   // Set the register bits as 00010000 (1000dps full scale)
  Wire.endTransmission(true);
}

void calculate_IMU_error() {
  // We can call this funtion in the setup section to calculate the accelerometer and gury data error. From here we will get the error values used in the above equations printed on the Serial Monitor.
  // Note that we should place the IMU flat in order to get the proper values, so that we then can the correct values
  // Read accelerometer values 200 times
  while (c < 200) {
    Wire.beginTransmission(MPU);
    Wire.write(0x3B);
    Wire.endTransmission(false);
    Wire.requestFrom(MPU, 6, true);
    AccX = (Wire.read() << 8 | Wire.read()) / 4096.0 ;
    AccY = (Wire.read() << 8 | Wire.read()) / 4096.0 ;
    AccZ = (Wire.read() << 8 | Wire.read()) / 4096.0 ;
    // Sum all readings
    AccErrorX = AccErrorX + ((atan((AccY) / sqrt(pow((AccX), 2) + pow((AccZ), 2))) * 180 / PI));
    AccErrorY = AccErrorY + ((atan(-1 * (AccX) / sqrt(pow((AccY), 2) + pow((AccZ), 2))) * 180 / PI));
    c++;
  }
  //Divide the sum by 200 to get the error value
  AccErrorX = AccErrorX / 200;
  AccErrorY = AccErrorY / 200;
  c = 0;
  // Read gyro values 200 times
  while (c < 200) {
    Wire.beginTransmission(MPU);
    Wire.write(0x43);
    Wire.endTransmission(false);
    Wire.requestFrom(MPU, 4, true);
    GyroX = Wire.read() << 8 | Wire.read();
    GyroY = Wire.read() << 8 | Wire.read();
    // Sum all readings
    GyroErrorX = GyroErrorX + (GyroX / 32.8);
    GyroErrorY = GyroErrorY + (GyroY / 32.8);
    c++;
  }
  //Divide the sum by 200 to get the error value
  GyroErrorX = GyroErrorX / 200;
  GyroErrorY = GyroErrorY / 200;
  // Print the error values on the Serial Monitor
  Serial.print("AccErrorX: ");
  Serial.println(AccErrorX);
  Serial.print("AccErrorY: ");
  Serial.println(AccErrorY);
  Serial.print("GyroErrorX: ");
  Serial.println(GyroErrorX);
  Serial.print("GyroErrorY: ");
  Serial.println(GyroErrorY);
}

void read_IMU() {
  // === Read acceleromter data === //
  Wire.beginTransmission(MPU);
  Wire.write(0x3B); // Start with register 0x3B (ACCEL_XOUT_H)
  Wire.endTransmission(false);
  Wire.requestFrom(MPU, 6, true); // Read 6 registers total, each axis value is stored in 2 registers
  //For a range of +-8g, we need to divide the raw values by 4096, according to the datasheet
  AccX = (Wire.read() << 8 | Wire.read()) / 4096.0; // X-axis value
  AccY = (Wire.read() << 8 | Wire.read()) / 4096.0; // Y-axis value
  AccZ = (Wire.read() << 8 | Wire.read()) / 4096.0; // Z-axis value

  // Calculating angle values using
  accAngleX = (atan(AccY / sqrt(pow(AccX, 2) + pow(AccZ, 2))) * 180 / PI) + 1.15; // AccErrorX ~(-1.15) See the calculate_IMU_error()custom function for more details
  accAngleY = (atan(-1 * AccX / sqrt(pow(AccY, 2) + pow(AccZ, 2))) * 180 / PI) - 0.52; // AccErrorX ~(0.5)

  // === Read gyro data === //
  previousTime = currentTime;        // Previous time is stored before the actual time read
  currentTime = millis();            // Current time actual time read
  elapsedTime = (currentTime - previousTime) / 1000;   // Divide by 1000 to get seconds
  Wire.beginTransmission(MPU);
  Wire.write(0x43); // Gyro data first register address 0x43
  Wire.endTransmission(false);
  Wire.requestFrom(MPU, 4, true); // Read 4 registers total, each axis value is stored in 2 registers
  GyroX = (Wire.read() << 8 | Wire.read()) / 32.8; // For a 1000dps range we have to divide first the raw value by 32.8, according to the datasheet
  GyroY = (Wire.read() << 8 | Wire.read()) / 32.8;
  GyroX = GyroX + 1.85; //// GyroErrorX ~(-1.85)
  GyroY = GyroY - 0.15; // GyroErrorY ~(0.15)
  // Currently the raw values are in degrees per seconds, deg/s, so we need to multiply by sendonds (s) to get the angle in degrees
  gyroAngleX = GyroX * elapsedTime;
  gyroAngleY = GyroY * elapsedTime;

  // Complementary filter - combine acceleromter and gyro angle values
  angleX = 0.98 * (angleX + gyroAngleX) + 0.02 * accAngleX;
  angleY = 0.98 * (angleY + gyroAngleY) + 0.02 * accAngleY;
  // Map the angle values from -90deg to +90 deg into values from 0 to 255, like the values we are getting from the Joystick
  data.j1PotX = map(angleX, -90, +90, 255, 0);
  data.j1PotY = map(angleY, -90, +90, 0, 255);
}

Receiver Code

Now let’s take a look at how we can receive this data. Here’s a simple Arduino and NRF24L01 receiver schematic. Of course you can use any other Arduino board.

DIY Arduino RC Transmitter and Receiver

And here’s a simple receiver code where we will receive the data and simply print it on the serial monitor so that we know that the communication works properly. Again we need to include the RF24 library and define the objects and the structure the same way as in the transmitter code. In the setup section when defining the radio communication we need to use the same settings as the transmitter and set the module as receiver using the radio.startListening() function.

/*
    DIY Arduino based RC Transmitter Project
              == Receiver Code ==

  by Dejan Nedelkovski, www.HowToMechatronics.com
  Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(10, 9);   // nRF24L01 (CE, CSN)
const byte address[6] = "00001";

unsigned long lastReceiveTime = 0;
unsigned long currentTime = 0;

// 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();
}
void loop() {
  // 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
  }
  // 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 has a throttle up and we lose connection, it can keep flying unless we reset the values
  }
  // Print the data in the 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() {
  // 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;
}

In the main loop using the available() function we check whether there is an incoming data. If true we simply read the data and store it into the variables of the structure. Now we can print the data on the serial monitor to check whether the transmission work properly. Also using the millis() function and an if statement we check whether we keep receiving data, or if we don’t receive data for a period longer than 1 second, then we reset variables to their default values. We use this to prevent unwanted behavior, for example if a drone has a throttle up and we lose connection it can keep flying away unless we reset the values.

So that’s it. Now we can implement this method of receiving the data for any Arduino project. For example here the code for controlling the Arduino robot car from one of my previous videos.

Arduino Robot Car Wireless Control using RC Transmitter

DIY Arduino RC Transmitter - Arduino Robot Car Wireless Control

Arduino Code:

Here we need to define the libraries, the structure and the radio communication as explained earlier. Then in the main loop we just need read the incoming data and use any of it for whatever we want. In this case I use the joystick 1 values for driving the car.

Arduino Ant Robot / Hexapod  control using Arduino RC Transmitter

Arduino RC Transmitter - Ant Robot wireless control

Arduino Code:

In the exact same way I made the Arduino Ant Robot from my previous video to be wirelessly controlled using this Arduino RC Transmitter. We just need to read the data, and according to it execute the appropriate functions, like moving forward, left, right, bite, attack and so on.

ESC and Servo Control using RC Transmitter

Lastly, let’s take a look how can this transmitter be used for controlling commercial RC devices.

ESC and brushless motor wireless control

Usually for these devices we need to control their servos or brushless motors. So after receiving the data from the transmitter, for controlling servo we simply use the Arduino Servo library and use values from 0 to 180 degrees. For controlling brushless motor using ESC, we can again use the servo library for generating the 50Hz PWM signal used for controlling the ESC. By varying the duty cycle from 1000 to 2000 microseconds we control the RPM of the motor from zero to maximum. However, more on controlling brushless motors using ESC in my next tutorial.

Please note that we actually cannot bind the standard RC receiver system with this NRF24L01 2.4GHz system. Instead, we need to modify or create our own receiver consisting of an Arduino and NRF24L01 Module. From there we can than generate the appropriate PWM or PPM signals for controlling the RC device.

DIY Arduino RC Transmitter and Receiver controlling commercial RC devices

 

 

/*
    DIY Arduino based RC Transmitter Project
   == Receiver Code - ESC and Servo Control ==

  by Dejan Nedelkovski, 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(10, 9);   // 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(9);
  servo1.attach(3);
  servo2.attach(4);
}
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);
  servo2Value = map(data.j2PotY, 0, 255, 0, 180);
  servo1.write(servo1Value);
  servo2.write(servo2Value);
  // Controlling brushless motor with ESC
  escValue = map(data.pot1, 0, 255, 1000, 2000); // Map the receiving value form 0 to 255 to 0 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;
}

So that’s it. I hope you enjoyed this video and learned something new. Feel free to ask any question in the comments section below and check my Arduino Projects Collection.

61 Responses

  1. COCOtheMajstor

    radio.setPALevel(RF24_PA_LOW);
    Can I set this to HIGH or MAX to extended range ?

    Reply
      • Baris Guler

        Hello again:)
        I’m not a programmer or electronic engineer. I hope this is not a silly question. Wouldn’t we use both “NRF24L01 + PA + LNA” instead of using “NRF24L01” with more/high power on tx side? Doesn’t the coverage of the flat logic be doubled? or more strong/stable?

      • Dejan

        Well yes, it’s possible. The Arduino I2C bus can be used by multiple devices at the same time, the MPU6050 module is currently using but still you should be able to use the OLED display as well.

  2. Peter

    This is awesome! Do you have any schematic for the Receiver? I’m mainly interested in a general ESC and Servo setup.

    Going based on this…
    esc.attach(9);
    servo1.attach(3);
    servo2.attach(4);
    Does 9, 3 and 4 refer to Digital Pins D9, D3 and D4? D9 should be pin 13 on the Atmega328 chip, D3 = pin1 and D4 = pin2. Correct?

    Reply
    • Dejan

      Thank you! Yes that’s correct, 9, 3 and 4 refer to the digital pins, of course they can be any other digital pins. I updated the article with a schematic for the receiver, check it out. Also I would recommend to check my other detailed tutorial for the NRF24L01 module and the Arduino.

      Reply
  3. Tony Larner

    Dejan, I am interested in your design for controlling rc cars. Couple of questions.
    Is there any provision for binding 2.4 gHz standard rc receivers with you system?
    Can this be used with brushed motors?
    Thanks,
    Tony

    Reply
    • Dejan

      Hey Tony, we actually cannot bind the two systems, but you will have to make a receiver for the RC car consisting of an Arduino and NRF24L01 module. Then you just have to generate the standard 50Hz PWM signal that controls the servo motors for example or a brushless motor, as explained in the last example. Sure, you can drive brushed motors, for example like I did on the second example, controlling two brushed DC motors using the L298N for driving the robot car. Sorry but I didn’t have a standard RC car so I could demonstrate this method, but it should work.

      Reply
  4. bdsmith

    Looks nice. I’ve been going in the direction of using the ESP8266 and MQTT protocal for my home wireless and network projects. Your Arduino wireless game/everything controller, with just a ESP8266 module replacing the RF module you’re using, looks perfect for my projects too. Thanks for the explosion of ideas your project has had on me 🙂

    Reply
  5. madmardn

    Hi – this is exactly what i was looking for. Can you help me this question please?

    Which decoupling capacitor can i use?

    Thanks for your help, your channel is great!

    Reply
  6. Baris Guler

    Hello.

    First of all thank you for your share. Great Project.
    your banggood link for toggle switch refer to 2 pin toggle switch. I think it should be 3 pin? one more thing. I release that we need to remove PCB of joystick, right?

    Reply
    • Dejan

      Hey, thanks for the remarks. I’ve just updated the article with the 3 pins toggle switch and also added links to Joystick modules without PCBs. Yes, you are right, in case you have the ones with PCB you will have to desolder them, and I did so. It’s a bit harder to find those without PCB.

      Reply
  7. Paul

    Wow. This is exactly what i was looking for and it flew just into my website visiting.
    Great Tutorial. Great details. And funky looking.
    So now i will have to weigh my options between a 4 ch rc transmitter and receiver pair from china or this totally funky looking more expensive one, but for me better understable one here, to control and old rc car.

    Reply
  8. Vdm

    Great project! Thanks for sharing! Can I change MPU50060 to the 0.96″ OLED?
    Of course, I have to change sketch, but, as I can see, MPU have same point for connection with arduino

    Reply
    • Dejan

      Thanks. Well the MPU6050 uses I2C communication, so you can probably do that if the 0.96″ OLED uses the same I2C communication.

      Reply
  9. Florent

    Will it work with both the link for the arduino pro mini you paste ?
    Thank you

    Reply
  10. Enes

    Hi, this is awesome project. We will use it for our uav prototipies. But we have some problems. First we cant find ht7333 🙁 What can we solve that?

    And the other problem is as i see you use 2 capacitors. What are they?

    We are living in Turkey and we cant find everything here. If you can help us we will be really happy 🙂

    Thanx from now..

    Reply
    • Dejan

      Hey, thanks! Well you can use different 3.3V voltage regulator, for example the AMS1117. The capacitors are used for stabilizing the input voltage for the NRF24L01 module, they can be anything from 1uF to 100uF.

      Reply
  11. Alexandre Figueiredo

    hi im trying to change the arduino you used to the sparkfun pro mini 5v but it doesn’t have the dtr pin for auto reset function will this cause any problems ?

    Reply
    • Dejan

      Well it should’t be a problem as long as you have the right FTDI Basic Breakout board to upload the sketch to the Arduino. Other than that, if everything wired as properly it should all work fine.

      Reply
  12. Kros lairenjam

    First of all thank you for making such an interesting thing and may god bless you to make more in future.I also don’t have much knowledge about electronics so my question might be silly.Can i use the arduino board as you have given in the link.The arduino which you’ve given in the link is not same as in the video.won’t there be any problem in using that board.And if yes do we need to left the pin as it is without soldering.Thank you.

    Reply
    • Dejan

      Thank you! Well you can notice that there are two links to the Arduino, the one from Ebay is exactly the same as I used in the project.

      Reply
  13. mhon

    Hi there,, Thank you for sharing your tutorials to us, specially to newbies on electronics like me 🙂
    im just wondering,, your tact switch doen’st have resistors on it,, is it okay to design without it? or i have to put resistors on other side of tact switches? and if ever what values do i have to put? 1k ohms?
    and another thing can i add a slide switch for the connection of tx0 and dxi for easy dosconnecting the buttons 🙂
    once again thank you very much sir 🙂

    Reply
    • Dejan

      Well I didn’t include any resistor for the switches because I’m using the internal pull-up resistors of the Arduino pins. You can see that in the code, when defining the pin modes. As for the tx0 and dxi pins, yeah, you could probably make such a modification.

      Reply
  14. Roy

    Really great job. Thank you!! You teach me a lot of wireless connection.
    Hope one day I will fly a arduino drone without another receiver through this controller.

    Reply
  15. Alex

    Why at your circuid diogram has 2 decoupling capacitors? (one near NRF24, and second near HT7333)

    Reply
    • Dejan

      One is for the NRF24 module, and the other is for the HT7333 module. They both need a decoupling capacitors to work properly.

      Reply
  16. Davor Levstek

    Hello Dejan,
    I already tried leaving you a comment few times but it doesn’t show so ill try once again.
    Great job, I’m in the process of making one transmitter and few receivers but with few modifications (not using arduino board, just atmega328 IC for TX and atmega88 for RX).
    I see you used jumpers on TX and RX for programming, but I’m not sure why, lines are not connected to anything until you push the button, so jumpers are not really necessary, it won’t interfere with anything. Or did I get something wrong?

    Also I was wondering, is it possible to make some kind of auto bind function? For example, when I turn on the transmitter, it binds to first receiver it finds and ignores all the others? Receivers should have unique addresses and transmitter when turned on should connect to the first one, get his address and then only talk to that one and ignore the others. I tried something, but not sure where to start. Maybe have the same address for all on start in the setup, then connect to first receiver, get his unique ID and change it to that?

    Reply
    • Dejan

      Hey Davor,
      My point with the jumpers was that, if you use a jumper, connect the line, you would be able to use the Joystick push button which are connected to digital pin 0 and 1. These pins are also the RX and TX pins, and when uploading a sketch to the Arduino, these two pins must be disconnected from anything, otherwise the sketch might fail to be uploaded to the Arduino.
      As for you second question, I haven’t experiment with such examples so I couldn’t help you much.

      Reply
  17. Stephan

    Hi Dejan,
    your tutorial is really great and i was able to build a transmitter and reciever based on this.
    But now i encountered the problem that when i use the reciever with an esc, the system seems to snap from time to time and putting the minmal values for any servo or esc connected.
    Have you encountered a similar behavior?
    I am quite puzzled about that.

    Reply
    • Dejan

      Hey thanks, nice to hear that!
      Well no, I haven’t experienced such a problem. You should try to identify what is causing the problem, whether the potentiometers or joysticks, or the wireless communication is messing up the data. Try, using the serial monitor, to track the values at the transmitter, and also at the receiver and you might find out.

      Reply
  18. Mumtaj Ali

    Dear sir
    Can I use Arduino nano v3 In place of pro mini
    What is the pin Txo and RxI in arduino nano
    Can I use same transmitter code without Mpu5060
    Please help me sir
    Thanking you

    Reply
  19. João Adriano

    This is a Great, Great project!!! Thank you very much for sharing it! I’m trying to make it. I ordered all the stuff from the affiliated links, and I got the pcb’s already. It’s a great remote control, fully programmable, I’m looking forward for having it done. Thank You very much for sharing it with us!

    Reply
  20. NERVIS TETSOP

    Hello sir! thanks for sharing your project. I want to implement the same project. Please, I wish to ask instead of using Arduino pro mini, can I use Arduino nano in place of it??

    Reply
    • Dejan

      Hey, you could use an Arduino Nano, if you connect everything the same, the code would also be the same. However, in this PCB design you can’t use Nano because it has a different footprint compared to the Pro Mini.

      Reply
  21. Michele Albano

    Is it possible to know the value of the two electrolytic capacitors used in this project?
    Thank you

    Reply
  22. Glen gibbs

    I substituted an AMS1117 for the 3v regulator. Is this a big enough change to make the transmitter not work?

    Reply
  23. Eric C

    Wow such awesome detailed tutorial ! Based on your work i can (should be) able to make an application specific RC control for my project.
    I’m planning to build one with 5 buttons, 2 pots and a display for feedback and other info like battery soc. Your work makes that a hell of a lot easier for me so a big thank you !!!

    Reply
  24. Hans ter Hart

    Hi Dejan,
    Great project, I love it and plan to build it. Onze question, on your parts list you show a link to joysticks without breakout board. If you follow the link, you end up with ps4 joysticks. They will not fit on your pcb. You need PS2 joysticks for that. They are slightly larger. Am I right? Thanks a lot for your help.

    Reply
    • Dejan

      Hey, thanks! Well I think you are right. Someone already reported that the links to the joysticks without breakout board don’t fit 100% to the PCB. The problem is that I cannot find links to the correct PS2 joysticks which are without a breakout board. So you could either modify a the PCB (change the joysticks pads) or get the joysticks with the breakout board. However, please note that desoldering the joystick from the breakout board is a bit hard, especially if you don’t have proper desoldering tools.

      Reply
  25. Eric C

    Hi Dejan

    Thx so much for sharing this seldom clearly and inspiring documented project, just awesome !

    I’m building my own RC controller based on ( and boosted by ) your work and it is going superb thanks to your guidance ! (and google)

    I have taken your notes seriously to provide the radio module with a dedicated power source to achieve maximum performance. I assumed it was valid for both TX an RC ends…

    So to power the radio modules in my project i use :

    – adjustable bucket DC/DC step down converters. on the transmitter side, taking in power from a battery pack consisting of 2 series of 3pcs 18650 batteries in parrallel ( totaling 6 batteries; providing 10.2V 4400mAh) , the arduino board connects trough its barrel jack to this battery pack well whitin the comfort zone of its internal voltage regulation circuitry.

    – On the reciever side i opted for dedicated bucket DC/DC convertors for both the arduino board and the radio module because the main power source on that side is a 24V DC power grid ( fed by a 24V DC 800Ah battery pack connected with 140Amp/5kW charger-inverter combo’s, a recipe for fluctuating voltage )

    questions
    – How come you did NOT use a dedicated power source for the radio module on the reciever end of your project but powered it from the board against your own advice ? I intend to have feedback to the transmitter and my primary power source on the reciever end is unstable, so for maximum redundancy i decided to use dedicated adjustabl bucket DC/DC step down convertors to power my modules on the RC end.

    – Is your TX power source autonomy satisfying ? Since the internal voltage circuitry on most 5V Arduino boards require > 6V to insure stability of the board, a 7.2V battery pack’s state of charge would be quickly (?) insufficient for stability ? (thats why i designed a larger/higher voltage battery TX pack) .

    For those among us who are just like me, lacking Dejans design and engineering capabilities but still want to engage in Arduino based RC projects, i have a few tips :

    – if youre not familiar with crowtail shields and cables google them !! This is prototypers dream material !!! Even a beginner can make projects with this dirt cheap components that would pass a survey and certification for application ! Soldering minimised.

    – Mounting, attaching, fixing boards and peripheralis… They have become so small that even M3 screws look monstuous… Holes on a arduino board are only suitable for self-adhesive plastic standoffs because any M3 screw would touch headers and/or circuitry…. peripheral boards often do not even have holes to fix them firmly… I have very satisfying eperience with Tesa powerstrips (google ! ) and hotglue. ( Note on powerstrips : they are VERY powerfull, and availabale in different load capacity versions, they need however SURFACE to hold on to and a arduino board WITH headers has pins sticking out beyond thickness of powerstrips, use common sense and this strips will hold boards to whatever surface with tremedous force)

    Thx again Dejan, you helped a lot bringing a much needed RC application here to reality !

    Reply
  26. Nick

    Hello Dejan,
    Thanks for this project, I am confused with the capacitor C2.
    On the diagram one trace comes from ground and the other from the ht7333 output (3.3V)
    BUT
    on the pcb file and on the real pcb i have on my hands now and testing it
    C2 is connected to the ground and on the input of the ht7333 (8V about or 7.4V as you say depending on the batteries).
    What is the correct and why?
    Please reply.
    Thanks in advance
    Nick

    Reply
    • Dejan

      Hey, that’s a good remark. It’s true, on the circuit diagram the C2 capacitor positive pin is connected to the HT7333 Vout pin and on the PCB to the Vin pin. Actually the recommended setup for the HT7333 is to use two capacitors, one at the Vin pin and the other at the Vout pin. These capacitors are used for stabilizing the voltage output of the HT7333 voltage regulator.

      Reply
  27. Nick

    Hello (again) Dejan,
    Although I created the project and works fine with the joysticks, I have problems with the mpu6050. It cannot been scanned on the i2c adresses. The soldering is fine. The arduino pro mini can scan other device on the i2c that i connected to it. Is anything else I must pay attention before changing the mpu6050?
    Two things I have to notice:
    1. The joysticks are not so sensitive..the change their values quite rapidly
    2.The joystick buttons are reversed. you can change them on the code as I did.I also think D0 and D1 are printed wrong on the board but …it doesnt matter
    Thanks

    Reply

Leave a Reply

Your email address will not be published.