Yes, you can build a basic drone transmitter and receiver pair. It takes an Arduino, two nRF24L01 radio modules, a pair of joysticks, and some code. It is a worthwhile learning project. For flying a drone reliably, most pilots use commercial radios or ExpressLRS gear, which offer stronger links, telemetry, and tested failsafes.
What you need
- Two microcontroller boards. Arduino Nano or Pro Mini boards are common choices. Some builders use an Uno.
- Two nRF24L01+ 2.4 GHz modules. Each costs only a few dollars.
- Transmitter parts: two dual-axis joysticks or salvaged gimbals, a few switches, and a battery with a voltage regulator.
- Receiver parts: wires and a way to output the channels, either PWM for servos and an ESC, or PPM or SBUS for a flight controller (see building an FPV drone).
- A capacitor of about 10 µF for each nRF24L01 module, placed across its VCC and GND pins.
- The RF24 library for the Arduino IDE, the common library for these modules.
- A breadboard or perfboard, plus jumper wires.
The parts can cost less than an entry-level commercial radio, but the commercial radio usually has the stronger link. Weigh the cost against what you want the radio to do.
How the link works
The transmitter reads the joysticks, turns them into channel values, and sends those values as a data packet over the nRF24L01 link. Sending the packets many times per second, roughly 50 to 100 times, keeps the control smooth.
The receiver reads each packet and turns the values into outputs. Those outputs can be PWM pulses for servos and an ESC, or a combined PPM or SBUS signal for a flight controller.
Wiring the nRF24L01
The nRF24L01 is a 3.3-volt part. Do not connect its power pin to 5 volts, because that can damage it. Many Arduino boards have a 3.3 V pin, but it supplies limited current. Higher-power modules with a power amplifier and low-noise amplifier (PA+LNA) may need their own regulator.
Place the capacitor close to the module’s power pins, and keep the wires short. Attach the module’s antenna before you power it on. The common wiring for an Arduino Uno or Nano with the RF24 library is shown below:
| nRF24L01 pin | Arduino pin |
|---|---|
| GND | GND |
| VCC | 3.3 V |
| CE | D9 |
| CSN | D8 |
| SCK | D13 |
| MOSI | D11 |
| MISO | D12 |
Check the pin labels on your specific module, because some boards label them differently.
Reading the joysticks
The Arduino’s analog read returns a value from 0 to 1023 for each stick axis. Map those values to the 1000 to 2000 microsecond range that servos and ESCs expect. Record each stick’s minimum and maximum during calibration, because a real stick never rests at the exact ends of its range. Add a deadband around center so small wobbles do not move the servos.
Software outline
- Install the RF24 library.
- Define a small data structure that holds the channel values, such as throttle, roll, pitch, and yaw.
- The transmitter sends this structure at a steady rate. The receiver reads it and updates its outputs.
- Keep the packet small, so it is quick to send and read.
Failsafe in your code
Write a failsafe. If the receiver has not received a valid packet for about half a second to one second, it should set throttle to low and disarm or stop the motor. It should also move the control surfaces to safe positions. The two build guides reviewed for this article do not cover a failsafe, so add one yourself.
Test the failsafe on the bench. Power the receiver, turn off the transmitter, and check that every output moves to its safe state.
Testing with props off
Remove the props for every test until you have verified the following:
- The values change as you move each stick.
- Throttle is low when the throttle stick is low.
- Each control moves its surface in the correct direction. Reverse the direction in code if needed.
- The failsafe puts every output into its safe state.
Use the Arduino serial monitor to watch the values while you move the sticks. A motor on an ESC can arm when power is applied, so keep the props off and disconnect the motor during early tests.
Only after all of this checks out should you think about a flight, and even then, start with a restrained test.
Range and reliability
A basic nRF24L01 module has limited range. Modules with a PA+LNA amplifier can reach roughly 500 meters to 1 kilometer in good line-of-sight conditions. Walls, bodies, and metal parts reduce range, so expect less in real use.
A DIY link usually lacks the telemetry, tested failsafes, and link-quality reporting that commercial systems provide. Phone control over Wi-Fi or Bluetooth usually reaches less than about 100 meters, so it suits only short-range toys.
Easier routes
- Put a tested module in a DIY shell. An off-the-shelf ExpressLRS or multi-protocol module can go inside a radio you build. You keep the build project, and the link is already proven.
- Use open-source ExpressLRS hardware. Open designs exist for ExpressLRS, and you can build and flash them. They use ESP-based chips.
- Try ESP32 for short-range control. An ESP32 with ESP-NOW or Wi-Fi suits short-range toys, not longer-range drones.
For buying gear, see choosing a transmitter and receiver for your RC plane, and for protocol matching, see can you use any RC transmitter with any receiver.
Rules and safety
- The 2.4 GHz band these modules use is license-free in many countries. Power limits and other rules vary, so check your local rules before you transmit.
- Keep bystanders and yourself away from spinning props during tests, and restrain the drone during bench work.
- Do not fly over people, and follow the drone rules that apply where you fly.
Common mistakes
- Connecting the nRF24L01 to 5 volts.
- Leaving out the capacitor.
- Testing with the props on.
- Skipping the failsafe code.
- Expecting kilometers of range from a basic module.