nRF24L01 Rpi Python Programming

nRF24L01 Rpi Python Programming


Wireless RF Communication using nRF24L01 Module


ByAbhiemanyu Pandit 0

Wireless RF Communication between Raspberry Pi and Arduino UNO using nRF24L01 ModuleWireless RF Communication between Raspberry Pi and Arduino UNO using nRF24L01 Module

Designers use many wireless communication systems like Bluetooth Low Energy (BLE 4.0)ZigbeeESP8266 Wi-Fi Modules433MHz RF ModulesLoranRF etc. And the selection of medium depends on the type of application it is being used in.

Among all, one popular wireless medium for local network communication is the nRF24L01. These modules operate on 2.4GHz (ISM band) with baud rate from 250Kbps to 2Mbps which is legal in many countries and can be used in industrial and medical applications. It is also claimed that with proper antennas these modules can transmit and receive signals upto a distance of 100 meters between them. We previously used nRF24L01 with Arduino to control servo motor and create a Chat Room.

Here we will use nRF24L01 – 2.4GHz RF Transceiver module with Arduino UNO and Raspberry Pi to establish a wireless communication between them. The Raspberry pi will act as a transmitter and Arduino Uno will listen to Raspberry Pi and print the message sent by Raspberry Pi using nRF24L01 on a 16×2 LCD. nRF24L01 also have inbuilt BLE capabilities and it can also communicate wirelessly using BLE.

The tutorial is divided into two sections. The first section will include the interfacing of nRF24L01 with Arduino to act as Receiver and the second section will include the

 interfacing of nRF24L01 with Raspberry Pi to act as Transmitter.

The complete code for both of the section with working video will be attached at the end of this tutorial.

The nRF24L01 RF Module

The nRF24L01 modules are transceiver modules, meaning each module can both send and receive data but since they are half-duplex they can either send or receive data at a time.

The module has the generic nRF24L01 IC from Nordic semi-conductors which is responsible for transmission and reception of data.

The IC communicates using the SPI protocol and hence can be easily interfaced with any microcontrollers. It gets a lot easier with Arduino since the libraries are readily available.

The pinouts of a standard nRF24L01 module is shown below

The module has on operating voltage from1.9V to 3.6V (typically 3.3V) and consumes very less current of only 12mA during normal operation which makes it battery efficient and hence can even run on coin cells.

Even though the operating voltage is 3.3V most of the pins are 5V tolerant and hence can be directly interfaced with 5V microcontrollers like Arduino.

Another advantage of using these modules is that, each module has 6 Pipelines. Meaning, each module can communicate with 6 other modules to transmit or receive data. This makes the module suitable for creating star or mesh networks in IoT applications. Also they have a wide address range of 125 unique ID’s, hence in a closed area we can use 125 of these modules without interfering with each other.

Circuit Diagram

nRF24L01 with Arduino: 

The circuit diagram for connecting nRF24L01 with Arduino is easy and doesn’t have much components. The nRF24l01 will be connected by SPI interfaceand the 16×2 LCD is interfaced with I2C protocol which uses only two wires.

Circuit Diagram for Interfacing nRF24L01 with Arduino

Circuit Hardware for Interfacing nRF24L01 with Arduino

nRF24L01 with Raspberry Pi:

The circuit diagram for connecting nRF24L01 with Raspberry Pi is also very simple and only the SPI interface is used to connect Raspberry Pi and nRF24l01.

Circuit Diagram for Interfacing nRF24L01 with Raspberry PiCircuit Hardware for Interfacing nRF24L01 with Raspberry Pi

Programming Raspberry Pi to Send Message using nRF24l01

Programming of the Raspberry Pi will be done using Python3. You can also use C/C++ as Arduino.

But there is already a library available for nRF24l01 in python which can be downloaded from github page.

Note that the python program and the library should be on the same folder or the python program will not be able to find the library. After downloading the library just extract and make a folder where all programs and library files will be stores. When library installation is done, just start writing the program. The program start with the inclusion of libraries which will be used in code like import GPIO library for accessing the Raspberry Pi GPIOs and import time for accessing the time related functions. If you are new to Raspberry Pi then fall back to getting started with Raspberry pi.

import RPi.GPIO as GPIO 
import time     
import spidev
from lib_nrf24 import NRF24 

Set the GPIO mode in “Broadcom SOC channel”. This means that you are referring to the pins by the “Broadcom SOC channel” number, these are the numbers after “GPIO”( for e.g. GPIO01,GPIO02…). These are not the Board Numbers.


Next we will set it up the pipe address. This address is important in order to communicate with the Arduino receiver. The address will be in the hex code.

pipes = [[0xE0, 0xE0, 0xF1, 0xF1, 0xE0], [0xF1, 0xF1, 0xF0, 0xF0, 0xE0]]

Begin the radio using GPIO08 as CE and GPIO25 as CSN pins.

radio.begin(0, 25)  

Set payload size as 32 bit, channel address as 76, data rate of 1 mbps and power levels as minimum.


Open the pipes to start writing the data and print the basic details of nRF24l01.


Prepare a message in the string form. This message will be sent to Arduino UNO.

sendMessage = list("Hi..Arduino UNO")  
while len(sendMessage) < 32:    

Start writing to the radio and keep on writing the complete string till the radio is available. Along with it, note down the time and print a debug statement of message delivery.

while True:
    start = time.time()      
    print("Sent the message: {}".format(sendMessage))  

If the string is completed and pipe is closed then print a debug message of timed out.

while not radio.available(0):
        if time.time() - start > 2:
            print("Timed out.")  # print error message if radio disconnected or not functioning anymore

Stop listening to the radio and close the communication and restart the communication after 3 seconds to send another message.

  radio.stopListening()     # close radio
    time.sleep(3)  # give delay of 3 seconds

The Raspberry program is simple to understand if you know the basics of python. Complete Python program is given at the end of tutorial.

Executing the Python Program in Raspberry Pi:

Executing the program is very easy after following the below steps:

  • Save the Python Program and Library files in the same folder.

Executing the Python Program in Raspberry Pi

  • My program file name for Sender is nrfsend.py and also every files are in the same folder

Setup the Python Program in Raspberry Pi

  • Go to Command Terminal of Raspberry Pi. And locate the python program file by using “cd” command.

Command Terminal of Raspberry Pi

  • Then open the folder and write command “sudo python3 your_program.py” and hit enter. You will be able to see the basic details of nRf24 and the radio will start sending the messages after every 3 seconds. The message debug will display after sending is done with all characters sent.

Programming Raspberry Pi to Send Message using nRF24l01

Now we will see the same program as receiver in the Arduino UNO.

Programming Arduino UNO to Receive Message using nRF24l01

Programming the Arduino UNO is similar to programming the Raspberry Pi. We will follow similar methods but with different programming language and steps. The steps will include the reading part of nRF24l01. The library for nRF24l01 for Arduino can be downloaded from github page. Start with including necessary libraries. We are using 16×2 LCD using I2C Shield so include Wire.h library and also the nRF24l01 is interfaced with SPI so include SPI library.

#include <Wire.h>

Include RF24 and LCD library for accessing the RF24 and LCD functions.

#include <LiquidCrystal_I2C.h>

The LCD address for I2C is 27 and it is a 16×2 LCD so write this into the function.

LiquidCrystal_I2C lcd(0x27, 16, 2);

The RF24 is connected with standard SPI pins along with CE in pin 9 and CSN in pin 10.

RF24 radio(9, 10) ;  

Start the radio, set the power level and set channel to 76. Also set the pipe address same as Raspberry Pi and open the pipe to read.

  radio.setPALevel(RF24_PA_MAX) ;   
  radio.setChannel(0x76) ;            
  const uint64_t pipe = 0xE0E0F1F1E0LL ;    
  radio.openReadingPipe(1, pipe) ;

Begin the I2C communication and initialise the LCD display.

  lcd.print("Ready to Receive");

Start listening to the radio for incoming messages and set the message length as 32 bytes.

radio.startListening() ;        
  char receivedMessage[32] = {0}

If radio is attached then start reading the message and save it. Print the message to serial monitor and also print to the display until the next message arrives. Stop the radio to listen and retry after some interval. Here it is 10 micro seconds.

if (radio.available()) {       
    radio.read(receivedMessage, sizeof(receivedMessage));        Serial.println(receivedMessage) ;    
    Serial.println("Turning off the radio.") ;   
    radio.stopListening() ;   
    String stringMessage(receivedMessage) ;     

Upload the complete code given at the end to the Arduino UNO and wait for the message to be received.

Wireless RF Communication between Raspberry Pi and Arduino UNO using nRF24L01 Module

This finishes the complete tutorial on sending a message using Raspberry Pi & nRf24l01 and receiving it using Arduino UNO & nRF24l01. The message will be printed to the 16×2 LCD. The pipe addresses are very important in both Arduino UNO and Raspberry Pi. If you face any difficulty while doing this project then please comment below or reach to out forum for more detailed discussion.

Also check the demonstration video below.



NRF Transmitter Side Code (Raspberry Pi):

import RPi.GPIO as GPIO  # import gpio
import time      #import time library
import spidev
from lib_nrf24 import NRF24   #import NRF24 library

GPIO.setmode(GPIO.BCM)       # set the gpio mode

# set the pipe address. this address shoeld be entered on the receiver alo
pipes = [[0xE0, 0xE0, 0xF1, 0xF1, 0xE0], [0xF1, 0xF1, 0xF0, 0xF0, 0xE0]]
radio = NRF24(GPIO, spidev.SpiDev())   # use the gpio pins
radio.begin(0, 25)   # start the radio and set the ce,csn pin ce= GPIO08, csn= GPIO25
radio.setPayloadSize(32)  #set the payload size as 32 bytes
radio.setChannel(0x76) # set the channel as 76 hex
radio.setDataRate(NRF24.BR_1MBPS)    # set radio data rate
radio.setPALevel(NRF24.PA_MIN)  # set PA level

radio.setAutoAck(True)       # set acknowledgement as true

radio.openWritingPipe(pipes[0])     # open the defined pipe for writing
radio.printDetails()      # print basic detals of radio

sendMessage = list(“Hi..Arduino UNO”)  #the message to be sent
while len(sendMessage) < 32:

while True:
start = time.time()      #start the time for checking delivery time
radio.write(sendMessage)   # just write the message to radio
print(“Sent the message: {}”.format(sendMessage))  # print a message after succesfull send
radio.startListening()        # Start listening the radio

while not radio.available(0):
if time.time() – start > 2:
print(“Timed out.”)  # print errror message if radio disconnected or not functioning anymore

radio.stopListening()     # close radio
time.sleep(3)  # give delay of 3 seconds

# >

NRF Receiver Side Code (Arduino):

#include<SPI.h>                   // spi library for connecting nrf
#include <Wire.h>                             // i2c libary fro 16×2 lcd display
#include<RF24.h>                  // nrf library
#include <LiquidCrystal_I2C.h>     // 16×2 lcd display library

LiquidCrystal_I2C lcd(0x27, 16, 2);         // i2c address is 0x27

RF24 radio(9, 10) ;  // ce, csn pins
void setup(void) {
while (!Serial) ;
Serial.begin(9600) ;     // start serial monitor baud rate
Serial.println(“Starting.. Setting Up.. Radio on..”) ; // debug message
radio.begin();        // start radio at ce csn pin 9 and 10
radio.setPALevel(RF24_PA_MAX) ;   // set power level
radio.setChannel(0x76) ;            // set chanel at 76
const uint64_t pipe = 0xE0E0F1F1E0LL ;    // pipe address same as sender i.e. raspberry pi
radio.openReadingPipe(1, pipe) ;        // start reading pipe
radio.enableDynamicPayloads() ;
radio.powerUp() ;
Wire.begin();                 //start i2c address
lcd.begin();                    // start lcd
lcd.print(“Ready to Receive”);  // print starting message on lcd

void loop(void) {

radio.startListening() ;        // start listening forever
char receivedMessage[32] = {0} ;   // set incmng message for 32 bytes
if (radio.available()) {       // check if message is coming
radio.read(receivedMessage, sizeof(receivedMessage));    // read the message and save
Serial.println(receivedMessage) ;    // print message on serial monitor
Serial.println(“Turning off the radio.”) ;   // print message on serial monitor
radio.stopListening() ;   // stop listening radio
String stringMessage(receivedMessage) ;     // change char to string
lcd.clear();    // clear screen for new message
delay(1000);    // delay of 1 second
lcd.print(stringMessage);   // print received mesage




Categories: Uncategorized

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s

This site uses Akismet to reduce spam. Learn how your comment data is processed.

%d bloggers like this: