Connecting a NRF24 board to a Raspberry Pi (TO BE FINISHED)

In this brief article we will learn how to connect the NRF24l01 wireless sensor to the Raspberry Pi (Rpi) PIO using bare cables. In my case I bought a couple of NRF24l01 ready to use boards from eBay at about 1€.

The first thing we should know to accomplish this is what kind of bus the NRF24l01 chip has. In fact, as we can see in the datasheet, it uses the SPI bus which is fully compatible with the Raspberry Pi, although not out of the box. We will cover the wire diagram first, in the following pictures we can see both Rpi and NRF24l01 board pinouts:

The NRF24 CE and CSN can be a bit confusing. The former is not the SPI CE but a global enable line for the whole chip. The latter is indeed the SPI CE line.
As we can see in the Rpi pinout (right picture), the SPI lines are purple. We also need an additional IO line for the NRF24 CE (chip enable) line, we will use GPIO25. So the wire diagram is as follows:

NRF24 board pin                 Rpi pin
1                                           3v3
2                                           Ground
3                                           GPIO25
4                                           GPIO8(CE0)
5                                           GPIO11(SCLK)
6                                           GPIO10(MOSI)
7                                           GPIO9(MISO)
8                                           not used

It is important to know the NRF24l01 supply voltage range is [1.9-3.6]V but it is 5V tolerant input. Also, I am using a Rpi GPIO adapter board for simplicity which I also bought from eBay (Raspberry Pi GPIO kit extension board adapter breadboard 26pin GPIO ribbon cable). So my final setup is as follows:

Once we have successfully connected both boards we can have a look at software. As I said above, usually Rpi linux distributions don't have the SPI support enabled by default, so we have to solve it loading the proper module. In my case executing the following command from a shell is enough:

$ sudo modprobe spi-bcm2708

From this point on a pair of SPI device control files should have been created under /dev directory. Let's check that:

$ ls /dev/spidev*
/dev/spidev0.0  /dev/spidev0.1

Finally we have to download a library and a test program. We will use stanleyseow's library, which is a port of the excellent maniacbug's Arduino library for NRF24. To copy and compile it just do the following:

$ git clone https://github.com/stanleyseow/RF24
$ cd RF24/librf24-rpi
$ make
$ sudo make install

Now we need some code to test the board. The following simple piece of code is taken from the example named GettingStarted found in maniacbugs's library :

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <cstdlib>
#include "RF24.h"

using namespace std;
RF24 radio("/dev/spidev0.0",8000000 , 25);  //spi device, speed and CSN,only CSN is NEEDED in RPI
const uint64_t pipes[2] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL };

void setup(void)
{
  // Print preamble
  printf("\n\rRF24/examples/GettingStarted/\n\r");

  // Setup and configure rf radio
  radio.begin();

  // optionally, increase the delay between retries
  radio.setRetries(15,15);

  // optionally, reduce the payload size.  seems to improve reliability
  radio.openWritingPipe(pipes[1]);
  radio.openReadingPipe(1,pipes[0]);

  // Start listening
  radio.startListening();

  // Dump the configuration of the rf unit for debugging
  radio.printDetails();
}

void loop(void)
{
// First, stop listening so we can talk.
radio.stopListening();

// Take the time, and send it.  This will block until complete
unsigned long time = __millis();
printf("Now sending %lu...",time);
bool ok = radio.write( &time, sizeof(unsigned long) );

if (ok)
printf("ok...");
else
printf("failed.\n\r");

// Now, continue listening
radio.startListening();

// Wait here until we get a response, or timeout (250ms)
unsigned long started_waiting_at = __millis();
bool timeout = false;
while ( ! radio.available() && ! timeout )
if (__millis() - started_waiting_at > 200 )
timeout = true;

// Describe the results
if ( timeout )
printf("Failed, response timed out.\n\r");
else
{
// Grab the response, compare, and send to debugging spew
unsigned long got_time;
radio.read( &got_time, sizeof(unsigned long) );

// Spew it
printf("Got response %lu, round-trip delay: %lu\n\r",got_time,__millis()-got_time);
}

// Try again 1s later
sleep(1);
}

int main()
{
setup();
while(1)
loop();

return 0;
}

To compile it just execute:

$ g++ -o test nrf24_test.cpp -L../RF24/librf24-rpi/librf24  -lrf24 -I../RF24/librf24-rpi/librf24

As we can see, this test is very simple, it just initializes the nrf24 chip an start receiving data and sending it back as an acknowledge. From the Arduino serial console, If we press T(transmit) it starts transmitting and waiting for the acknowledge, if we press R(receive) it goes back to reception.

Since it is a communication test we obviously need an emitter and a receiver. You can use two Rpi, but instead I am using and Arduino (another step by step guide for that) with the same exact piece of code (obviously not ported to Rpi). Next picture shows what I mean:

Finally if everything is working fine we should see something like that for the emitter and receiver:

Emitter:
$ sudo ./test

RF24/examples/GettingStarted/
SPI device  = /dev/spidev0.0
SPI speed  = 8000000
CE GPIO  = 25
STATUS  = 0x0e RX_DR=0 TX_DS=0 MAX_RT=0 RX_P_NO=7 TX_FULL=0
RX_ADDR_P0-1  = 0xf0f0f0f0d2 0xf0f0f0f0e1
RX_ADDR_P2-5  = 0xc3 0xc4 0xc5 0xc6
TX_ADDR  = 0xf0f0f0f0d2
RX_PW_P0-6  = 0x20 0x20 0x00 0x00 0x00 0x00
EN_AA  = 0x3f
EN_RXADDR  = 0x03
RF_CH  = 0x4c
RF_SETUP  = 0x07
CONFIG  = 0x0f
DYNPD/FEATURE  = 0x00 0x00
Data Rate  = 1MBPS
Model  = nRF24L01+
CRC Length  = 16 bits
PA Power  = PA_MAX
Now sending 4192465834...ok...Got response 4192465834, round-trip delay: 30
Now sending 4192466867...ok...Got response 4192466867, round-trip delay: 30
Now sending 4192467900...ok...Got response 4192467900, round-trip delay: 30
Now sending 4192468933...ok...Got response 4192468933, round-trip delay: 30
Now sending 4192469966...ok...Got response 4192469966, round-trip delay: 30
Now sending 4192470999...ok...Got response 4192470999, round-trip delay: 30
Now sending 4192472032...ok...Got response 4192472032, round-trip delay: 30
Now sending 4192473065...ok...Got response 4192473065, round-trip delay: 30
Now sending 4192474098...ok...Got response 4192474098, round-trip delay: 30
Now sending 4192475131...ok...Got response 4192475131, round-trip delay: 30

Receiver:
*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK                                      
Got payload 4192465834...Sent response.                                                        
Got payload 4192466867...Sent response.                                                        
Got payload 4192467900...Sent response.                                                        
Got payload 4192468933...Sent response.                                                        
Got payload 4192469966...Sent response.                                                        
Got payload 4192470999...Sent response.                                                        
Got payload 4192472032...Sent response.                                                        
Got payload 4192473065...Sent response.                                                        
Got payload 4192474098...Sent response.                                                        
Got payload 4192475131...Sent response.

Additional resources:
http://arduino-info.wikispaces.com/Nrf24L01-2.4GHz-HowTo
http://hack.lenotta.com/arduino-raspberry-pi-switching-light-with-nrf24l01/
http://maniacbug.wordpress.com/2011/11/02/getting-started-rf24/