nRF24L01 –Interface, Code, Schematic

Content
nRF24L01 –Interface, Code, Schematic ................................................................................................... 1
Several variations of the NRF24L01 modules...................................................................................... 3
NRF24L01 Module Pinout.................................................................................................................... 3
Wireless One-directional Comm with two NRF24L01 modules .............................................................. 3
Circuit Diagram .................................................................................................................................... 3
Arduino and NRF24L01 Code .............................................................................................................. 5
Transmitter Code ............................................................................................................................. 5
Receiver Code .................................................................................................................................. 5
Description ...................................................................................................................................... 6
Troubleshooting .............................................................................................................................. 8
Wireless Bi-directional Comm with two NRF24L01 modules.................................................................. 9
Source Code....................................................................................................................................... 10
Transmitter Code ........................................................................................................................... 10
Receiver Code ................................................................................................................................ 10
Description .................................................................................................................................... 11
Source .................................................................................................................................................... 13

For explaining the wireless communication, we will

make two examples, the first one will be sending a
simple “Hello World” message from one Arduino to
another, and in the second example we will have a bi-
directional communication between the Arduino
boards, where using the Joystick at the first Arduino
we will control the servo motor at the second Arduino,
and vice versa, using the push button at the second
Arduino we will control the LED at the first Arduino.

Let’s take a closer look at the NRF24L01 transceiver module. It uses the 2.4 GHz band and it can
operate with baud rates from 250 kbps up to 2 Mbps. If used in open space and with lower baud rate
its range can reach up to 100 meters.

The module can use 125 different channels which gives a

possibility to have a network of 125 independently working
modems in one place. Each channel can have up to 6
addresses, or each unit can communicate with up to 6 other
units at the same time.
The power consumption of this module is just around 12mA during transmission, which is even lower
than a single LED. The operating voltage of the module is from 1.9 to 3.6V, but the good thing is that
the other pins tolerate 5V logic, so we can easily connect it to an Arduino without using any logic
level converters.

Three of these pins are for the SPI communication and

they need to be connected to the SPI pins of the
Arduino, but note that each Arduino board has
different SPI pins. The pins CSN and CE can be
connected to any digital pin of the Arduino board and
they are used for setting the module in standby or
active mode, as well as for switching between transmit
or command mode. The last pin is an interrupt pin
which doesn’t have to be used.
Several variations of the NRF24L01 modules
The most popular is the one with on-board antenna. This
makes the module to be more compact, but on the other
hand, lowers the transmission range to a distance of
about 100 meters.

The second variation, instead of on-board antenna, it has

a SMA connector and which we can attach a duck
antenna for better transmission range.

The third variation shown here, in addition to the duck antenna, it has a RFX2401C chip which
includes PA (Power Amplifier) and LNA (Low-Noise Amplifier). This amplifies the NRF24L01 signal and
enables even better transmission range of up to 1000 meters in open space.

NRF24L01 Module Pinout

Here’s a detailed look at the NRF24L01 pinout, as well as the NRF24L01+ PA/LNA module.

Both modules, the NRF24L01 and the NRF24L01+ PA/LNA have the same pinout, so we can connect
them in our circuit the same way.

Wireless One-directional Comm with two NRF24L01 modules

Description of the library (functions, syntax, etc): click here

Circuit Diagram
Here’s how we need to connect the NRF24L01 modules to the Arduino boards.
As I already mentioned, each Arduino board has different SPI pins, so keep that in mind when
connecting the modules to your Arduino board.

Warning: connecting to 5v instead of 3,3v will make the NRF-modules instable…

Arduino and NRF24L01 Code
Once we connect the NRF24L01 modules to the Arduino boards we are ready to make the codes for
both the transmitter and the receiver.

First, we need to download and install the RF24 library which makes the programming less difficult.
Here are the two codes for the wireless communication and below is the description of them.

Transmitter Code

/*
* Arduino Wireless Communication Tutorial
* Example 1 - Transmitter Code
*
*
* Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(7, 8); // CE, CSN
const byte address[6] = "00001";
void setup() {
radio.begin();
radio.openWritingPipe(address);
radio.setPALevel(RF24_PA_MIN);
radio.stopListening();
}
void loop() {
const char text[] = "Hello World";
radio.write(&text, sizeof(text));
delay(1000);
}

Receiver Code

/*
* Arduino Wireless Communication Tutorial
* Example 1 - Receiver Code
*
* Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
RF24 radio(7, 8); // CE, CSN
const byte address[6] = "00001";
void setup() {
Serial.begin(9600);
radio.begin();
radio.openReadingPipe(0, address);
radio.setPALevel(RF24_PA_MIN);
radio.startListening();
}
void loop() {
if (radio.available()) {
char text[32] = "";
radio.read(&text, sizeof(text));
Serial.println(text);
}
}

Description

So, we need to include the basic SPI and the newly installed RF24 libraries and create an RF24 object.
The two arguments here are the CSN and CE pins.

RF24 radio(7, 8); // CE, CSN

Next we need to create a byte array which will represent the address, or the so called pipe through
which the two modules will communicate.

const byte address[6] = "00001";

We can change the value of this address to any 5-letter string and this enables to choose to which
receiver we will talk, so in our case we will have the same address at both the receiver and the
transmitter.

In the setup section we need to initialize the radio object and using the radio.openWritingPipe()
function we set the address of the receiver to which we will send data, the 5 letter string we
previously set.

radio.openWritingPipe(address);

On the other side, at the receiver, using the radio.setReadingPipe() function we set the same address
and in that way we enable the communication between the two modules.

radio.openReadingPipe(0, address);

Then using the radio.setPALevel() function we set the Power Amplifier level, in our case I will set it to
minimum as my modules are very close to each other.

radio.setPALevel(RF24_PA_MIN);

Note that if using a higher level, it is recommended to use a bypass capacitor across GND and 3.3V of
the modules so that they have more stable voltage while operating.

Next we have the radio.stopListening() function which sets module as transmitter, and on the other
side, we have the radio.startListening() function which sets the module as receiver.

// at the Transmitter
radio.stopListening();
// at the Receiver
radio.startListening();

In the loop section, at the transmitter, we create an array of characters to which we assign the
message “Hello World”. Using the radio.write() function we will send that message to the receiver.
The first argument here is the variable that we want to be sent.

void loop() {
const char text[] = "Hello World";
radio.write(&text, sizeof(text));
delay(1000);
}

By using the “&” before the variable name we actually set an indicating of the variable that stores the
data that we want to be sent and using the second argument we set the number of bytes that we
want to take from that variable. In this case the sizeof() function gets all bytes of the strings “text”. At
the end of the program, we will add 1 second delay.

On the other side, at the receiver, in the loop section using the radio.available() function we check
whether there is data to be received. If that’s true, first we create an array of 32 elements, called
“text”, in which we will save the incoming data.

void loop() {
if (radio.available()) {
char text[32] = "";
radio.read(&text, sizeof(text));
Serial.println(text);
}
}

Using the radion.read() function we read and store the data into the “text” variable. At the end we
just print text on the serial monitor. So, once we upload both programs, we can run the serial
monitor at the receiver and we will notice the message “Hello World” gets printed each second.
Troubleshooting
It’s worth noting that power supply noise is one of the most common issues people experience when
trying to make successful communication with the NRF24L01 modules. Generally, RF circuits or radio
frequency signals are sensitive to power supply noise. Therefore, it’s always a good idea to include a
decoupling capacitor across the power supply line. The capacitor can be anything from 10uF to
100uF.

Another common issue is that the 3.3V pin of the Arduino boards, cannot always supply enough
power to the NRF24L01 module. So, powering the module with an external power source is also a
good idea.
Wireless Bi-directional Comm with two NRF24L01 modules
Let’s see the second example, a bi-directional wireless communication between two Arduino boards.
Here’s the circuit schematics:
Source Code

Transmitter Code

/*
* Arduino Wireless Communication Tutorial
* Example 2 - Transmitter Code
*
*
* Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#define led 12
RF24 radio(7, 8); // CE, CSN
const byte addresses[][6] = {"00001", "00002"};
boolean buttonState = 0;
void setup() {
pinMode(12, OUTPUT);
radio.begin();
radio.openWritingPipe(addresses[1]); // 00002
radio.openReadingPipe(1, addresses[0]); // 00001
radio.setPALevel(RF24_PA_MIN);
}
void loop() {
delay(5);
radio.stopListening();
int potValue = analogRead(A0);
int angleValue = map(potValue, 0, 1023, 0, 180);
radio.write(&angleValue, sizeof(angleValue));
delay(5);
radio.startListening();
while (!radio.available());
radio.read(&buttonState, sizeof(buttonState));
if (buttonState == HIGH) {
digitalWrite(led, HIGH);
}
else {
digitalWrite(led, LOW);
}
}

Receiver Code

/*
* Arduino Wireless Communication Tutorial
* Example 2 - Receiver Code
*
*
* Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
*/
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <Servo.h>
#define button 4
RF24 radio(7, 8); // CE, CSN
const byte addresses[][6] = {"00001", "00002"};
Servo myServo;
boolean buttonState = 0;
void setup() {
pinMode(button, INPUT);
myServo.attach(5);
radio.begin();
radio.openWritingPipe(addresses[0]); // 00001
radio.openReadingPipe(1, addresses[1]); // 00002
radio.setPALevel(RF24_PA_MIN);
}
void loop() {
delay(5);
radio.startListening();
if ( radio.available()) {
while (radio.available()) {
int angleV = 0;
radio.read(&angleV, sizeof(angleV));
myServo.write(angleV);
}
delay(5);
radio.stopListening();
buttonState = digitalRead(button);
radio.write(&buttonState, sizeof(buttonState));
}
}

Description
What’s different here from the previous example is that we need to create two pipes or addresses
for the bi-directional communication.

const byte addresses[][6] = {"00001", "00002"};

In the setup section we need to define both pipes, and note that the writing address at the first
Arduino needs to be the reading address at the second Arduino, and vice versa, the reading address
at the first Arduino needs to be the writing address at the second Arduino.

// at the Transmitter
radio.openWritingPipe(addresses[1]); // 00001
radio.openReadingPipe(1, addresses[0]); // 00002
// at the Receiver
radio.openWritingPipe(addresses[0]); // 00002
radio.openReadingPipe(1, addresses[1]); // 00001
In the loop section using the radio.stopListening() function we set the first Arduino as transmitter,
read and map the value of Joystick from 0 to 180, and using the radio.write() function send the data
to the receiver.

radio.stopListening();
int potValue = analogRead(A0);
int angleValue = map(potValue, 0, 1023, 0, 180);
radio.write(&angleValue, sizeof(angleValue));

On the other side, using the radio.startListening() function we set the second Arduino as receiver and
we check whether there is available data. While there is data available, we will read it, save it to the
“angleV” variable and then use that value to rotate the servo motor.

radio.startListening();
if ( radio.available()) {
while (radio.available()) {
int angleV = 0;
radio.read(&angleV, sizeof(angleV));
myServo.write(angleV);
}

Next, at the transmitter, we set the first Arduino as receiver and with an empty “while” loop we wait
for the second Arduino the send data, and that’s the data for the state of the push button whether is
pressed or not. If the button is pressed the LED will light up. So these process constantly repeats and
both Arduino boards are constantly sending and receiving data.
Source
https://howtomechatronics.com/tutorials/arduino/arduino-wireless-communication-nrf24l01-
tutorial/