2A16 NRF24L01+PA+LNA Wireless Transceiver RF Transceiver Module with SMA Antenna 2.4G 1100m Compatible with Arduino

Remember, you need to make two such circuits. One will act as a transmitter and the other as a receiver. Both have the same wiring.

Once you have connected everything, you are ready to go!

Library Installation

There are many libraries available for the nRF24L01+ module, but one of the most popular is RF24. This library has been around for a long time. It’s simple to use for beginners while still providing a lot for advanced users. We will use this library in our examples.

To install the library, navigate to Sketch > Include Library > Manage Libraries… Wait for the Library Manager to download the library index and update the list of installed libraries.

Filter your search by entering ‘rf24‘. Look for the library by TmRh20. Click on that entry and then choose Install.

Code – For Transmitter

The examples below demonstrate how to set up a simple one-way link between a transmitter and a receiver. The transmitter simply sends a traditional ‘Hello World’ message to the receiver, which displays it in the Serial Monitor window.

This is the code we’ll use for our transmitter.

//Include Libraries
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

//create an RF24 object
RF24 radio(9, 8);  // CE, CSN

//address through which two modules communicate.
const byte address[6] = "00001";

void setup()
{
  radio.begin();
  
  //set the address
  radio.openWritingPipe(address);
  
  //Set module as transmitter
  radio.stopListening();
}
void loop()
{
  //Send message to receiver
  const char text[] = "Hello World";
  radio.write(&text, sizeof(text));
  
  delay(1000);
}

Code Explanation

The sketch begins by including the necessary libraries. The SPI.h library handles SPI communication, while the nRF24L01.h and RF24.h libraries control the module.

//Include Libraries
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

Next, we create an RF24 object. The constructor of this object accepts two pin numbers as arguments, to which the CE and CSN signals are connected.

//create an RF24 object
RF24 radio(9, 8);  // CE, CSN

Next, we create a byte array to store the pipe address used by the two nRF24L01+ modules to communicate.

//address through which two modules communicate.
const byte address[6] = "00001";

The pipe address does not have to be “00001,” but it can be any 5-character string like “node1.” Simply ensure that both the transmitter and receiver use the same address.

With a pipe address, you can choose a specific module on your network and communicate with it. This is useful if your network contains multiple modules.

In the setup section, we use the begin() function to initialize the radio object, followed by the openWritingPipe() function to set the transmitter address.

radio.begin();

//set the address
radio.openWritingPipe(address);

Finally, we use the stopListening() function to set the module as a transmitter.

//Set module as transmitter
radio.stopListening();

In the loop section, we first create an array of characters and store the message “Hello world” in it.

We use the write() function to send the message to the receiver. This function takes two arguments: the message to be sent and the number of bytes it contains.

const char text[] = "Hello World";
radio.write(&text, sizeof(text));

It is important to note that you can send messages of up to 32 bytes in length, as this is the maximum packet size that the nRF24L01+ can handle.

Code – For Receiver

This is the code we’ll use for our receiver.

//Include Libraries
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

//create an RF24 object
RF24 radio(9, 8);  // CE, CSN

//address through which two modules communicate.
const byte address[6] = "00001";

void setup()
{
  while (!Serial);
    Serial.begin(9600);
  
  radio.begin();
  
  //set the address
  radio.openReadingPipe(0, address);
  
  //Set module as receiver
  radio.startListening();
}

void loop()
{
  //Read the data if available in buffer
  if (radio.available())
  {
    char text[32] = {0};
    radio.read(&text, sizeof(text));
    Serial.println(text);
  }
}

Code Explanation

Except for a few changes, this code is very similar to the transmitter’s code.

At the beginning of the setup function, we initiate the serial communication. Then, using the openReadingPipe() function, we set the same pipe address as the transmitter. This enables the transmitter and receiver to communicate with one another.

The openReadingPipe() function’s first argument specifies which pipe to open for reading. Because up to six pipes can be opened for reading at the same time, the possible range is 0-5. In our case, pipe 0 was opened for reading. The second argument is the 40-bit address of the pipe to open.

 //set the address
  radio.openReadingPipe(0, address);

Following that, we configure the module as a receiver and begin receiving data. We use the startListening() function to accomplish this.

//Set module as receiver
  radio.startListening();

The available() method is used in the loop section to check whether any data is available to be read. This method returns TRUE if data is available, FALSE otherwise.

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

When data is available, an array of 32 characters filled with zeros is created to store it. The data is then read from the buffer and stored in our character array using the read(&text, sizeof(text)) method.

Finally, the received message is printed on the serial monitor. If everything’s fine, your serial monitor should look like this.