Raspberry pi: nRF24L01 and TCP

This time I will describe how I got a Raspberry pi (Wheezy) to work as a Python server that controls a RF-transmitter (nRF24L01). The server takes commands either from a TCP connection (internet) or via the keyboard, and broadcasts the data through the RF-transmitter to the receivers i have set up in my home automation system. See my other posts covering how to use the nRF with an AVR, and the construction of a  multi-functional remote control.

        

Why use a Raspberry pi when i already have a working TCP-server on my PC?

Easy answered:

• I do not like to have my PC up and running 24-7 due to the facts that it's noisy (stationed in my bedroom)
• The RPi takes much less energy (runs on a 1000mA cellphone charger)
• I don't need any other parts other than a RPi, a nRF24L01(+) and cables, since the RPi has a 3,3V power supply!

Setting up SPI on RPi

First of all, you must have a working copy of raspbian, I use Wheezy (made a small tutorial in how to set it up). The RPi has a built in hardware SPI, which we first has to get up and running according to this guide, and here is how i did it:

Start a terminal like the LXTerminal and follow these commands:
$sudo apt-get install git $sudo wget http://goo.gl/1BOfJ -O /usr/bin/rpi-update #(the O is not zero but the letter) $sudo chmod +x /usr/bin/rpi-update $sudo rpi-update $sudo nano /etc/modprobe.d/raspi-blacklist.conf #add '#' in front of 'blacklist spi-bcm2708' (to comment it out) ctr+o (save) then ctrl+x (exit) $ sudo shutdown -h now #(remove power cable and readd it to restart) $cd /dev $ls #(check that ”spidev0.0 and 0.1 is in the list as in picture underneath)


To check if the SPI is working (optional) you can connect the mosi-pin to the miso-pin (GPIO10 and 9, see picture), and run the commands in a terminal:

$wget http://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.git/plain/Documentation/spi/spidev_test.c spidev_test.c $ nano spidev_test.c #(scroll down and change ”*devic = ”/dev/spidev1.1”; to ”/dev/spidev0.0" , press ctrl+o (save) ctrl+x (exit) $gcc spidev_test.c #(creates a runnable file) $sudo ./a.out #(runns the file) #The output should now look like this:

Quick2Wire

Quick2Wire is a tool that makes it possible to control the GPIO and the SPI via python. We need to install quick2wire, download the quick2wire python plugin (API) and gain root access to the spi.
Start by downloading the plugin from there website. Extract the zip-file by right clicking and unzip. Now open a terminal window and change directory so that you are in the extracted folder called "quick2wire-gpio-admin-master" then enter the following commands:

$ make $ sudo make install $ sudo adduser $USER gpio

Now log out from the RPi and back in again. The power button at the bottom right quorner has the option to log out. Log back in by typing your username "pi"/enter, then your code "raspberry"/enter...

To gain root access for the SPI so that you dont have to use the "sudo" command in front of every bit of code, I followed this guide, which tells you to do this:

$ sudo groupadd -f --system spi $ sudo adduser pi spi $ cd /etc/udev/rules.d2/ $ sudo nano 90-spi.rules $ SUBSYSTEM=="spidev", GROUP="spi" $ #press ctrl+o (save), Enter, ctrl+x (exit) $ sudo shutdown -h now
Finnish by remove and reattach the power cable to restart.

Python 3

Now it's time to install python3 which is needed to run the code. Open a terminal and run these commands:
$ sudo apt-get install python3

Now to use quick2wire with python, you need the python API which can be downloaded from this site. Download it, and unpack it to a location on you SD-card (no installation required!)

Setting up the hardware

The setup is very straight forward. Connect the wires like this (see red circles in the picture):
RPi GPIO9     (Pin 21)    to RF  ( MISO )
RPi GPIO10   (Pin 19)    to RF  ( MOSI )
RPi GPIO11   (Pin 23)    to RF  ( SCK )
RPi GPIO8     (Pin 24)    to RF  ( CSN )
RPi GPIO18   (Pin 12)    to RF  ( CE )
RPI 3.3V        (Pin 17)    to RF  ( VCC/3.3V )
RPi Gnd         (Pin 25)    to RF  (GND)
(IRQ-pin on nRF is not used in this example)

nRF24L02+ (top view)

nRF24L01 (only one of each VCC and GND-pin has to be connected!)

I think the CE-pin should work on a different pin (it would be convenient to put it on GPIO25) since it doesn't have anything to do with the SPI, but I haven't tried that yet...

The python programs

I got the basic nrf python code from this program (plus a lot of help with the steps above) from Jussi Kinnunen, all creds to him!
Download  my version of the program, as well as my TCP-server program. which is well commented to make it easy to understand. You see the codes below:

nRF24L01p.py
#!/usr/bin/env python3 from quick2wire.spi import * from quick2wire.gpio import Pin from quick2wire.gpio import In,Out,pi_header_1 import time #import TCP_Server #Uncomment this if you are running a TCP-server!! (this and one more line in the while-loop at the bottom!) PAYLOAD_SIZE = 3 SMALL_PAUSE = 0.05 LONG_PAUSE=0.5 #Define settings variables for nRF: SET_ACK = 0x01 #Auto ack on (EN_AA) SET_ACK_RETR = 0x2F #15 retries, 750us paus in between in auto ack (SETUP_RETR) SET_DATAPIPE = 0x01 #Datapipe 0 is used (EN_RXADDR) SET_ADR_WIDTH = 0x03 #5 byte address (SETUP_AW) SET_FREQ = 0x01 #2,401GHz (RF_CH) SET_SETUP = 0x07 #1Mbps, -0dB, (250kbps = 0x27) (RF_SETUP) ADDRESS = 0x12 SET_RX_ADDR_P0 = [ADDRESS,ADDRESS,ADDRESS,ADDRESS,ADDRESS] #Receiver address( RX_ADDR_P0) SET_TX_ADDR = [ADDRESS,ADDRESS,ADDRESS,ADDRESS,ADDRESS] #Transmitter address (TX_ADDR) SET_PAYLOAD_S = 0x03 #3byte payload size (32byte = 0x20)(RX_PW_P0) SET_CONFIG = 0x1E #1=mask_MAX_RT (IRQ-vector), E=transmitter, F= Receiver (CONFIG) #nRF registers: CONFIG = 0x00 EN_AA = 0x01 EN_RXADDR = 0x02 SETUP_AW = 0x03 SETUP_RETR = 0x04 RF_CH = 0x05 RF_SETUP = 0x06 STATUS = 0x07 OBSERVE_TX = 0x08 CD = 0x09 RX_ADDR_P0 = 0x0A RX_ADDR_P1 = 0x0B RX_ADDR_P2 = 0x0C RX_ADDR_P3 = 0x0D RX_ADDR_P4 = 0x0E RX_ADDR_P5 = 0x0F TX_ADDR = 0x10 RX_PW_P0 = 0x11 RX_PW_P1 = 0x12 RX_PW_P2 = 0x13 RX_PW_P3 = 0x14 RX_PW_P4 = 0x15 RX_PW_P5 = 0x16 FIFO_STATUS = 0x17 READ_REG = 0x00 WRITE_REG = 0x20 RESET_STATUS = 0x70 WR_TX_PLOAD = 0xA0 RD_RX_PLOAD = 0x61 FLUSH_TX = 0xE1 FLUSH_RX = 0xE2 NOP = 0xFF class NRF24L01P: def __init__(self): """__init__ function is allways run first, when the class is called!""" self.nrf24 = SPIDevice(0, 0) #Define SPI-unit (used in doOperation) self.radio_pin = pi_header_1.pin(12, direction=Out) #"CE" on nRF, output def doOperation(self,operation): """Do one SPI operation""" time.sleep(SMALL_PAUSE) #Make sure the nrf is ready toReturn = self.nrf24.transaction(operation) #Sends bytes in "operation" to nRF (first what register, than the bytes) return toReturn #Return bytes received from nRF def ReadPrintReg(self, Register, name, numbers): """Function that grabs "numbers" of bytes from the registry "Register" in the nRF  and writes them out in terminal as "name....[0xAA,0xBB,0xCC]" """ bytes = [READ_REG|Register] #First byte in "bytes" will tell the nRF what register to read from for x in range(0, numbers): #Add "numbers" amount of dummy-bytes to "bytes" to send to nRF bytes.append(NOP) #For each dummy byte sent to nRF later, a return byte will be collected ret = self.doOperation(duplex(bytes)) #Do the SPI operations (returns a byte-array with the bytes collected) #print(ret[0]) #debug #print(hex(ord(ret[0]))) #debug #print(bin(ord(ret[0]))) #debug Res = [hex(z)[2:] for z in ret[0]] #convert byte-array to string list #print(Res) #debug while len(name)<15: #Fill the name with "." so it allways becomes 15 char long (e.g. "STATUS.........") name = name + "." #Print out the register and bytes like this: "STATUS.........[0x0E]" print("{}".format(name), end='') #First print the name, and stay on same line (end='') for x in range(1, numbers+1): #Then print out every collected byte if len(Res[x]) == 1: #if byte started with "0" (ex. "0E") the "0" is gone from previous process => (len == 1) Res[x]= "0" + Res[x] #Readd the "0" if thats the case print("[0x{}]".format(Res[x].upper()), end='') #Print next byte after previous without new line print("") #Finnish with an empty print to contiune on new line and flush the print (no end='') return Res[1].upper() #Returns the first byte (not the zeroth which is allways STATUS) def receiveData(self): """Receive one or None messages from module""" #Reset Status registry bytes = [WRITE_REG|STATUS] #first byte to send tells nRF tat STATUS register is to be Written to bytes.append(RESET_STATUS) #add the byte that will be written to thr nRF (in this case the Reset command) self.doOperation(writing(bytes)) #execute the SPI command to send "bytes" to the nRF try: self.radio_pin.open() #Open the "CE" GPIO pin for access self.radio_pin.value=1 #Set the "CE" pin high (3,3V or 5V) to start listening for data time.sleep(LONG_PAUSE) #Listen 0,5s for incomming data self.radio_pin.value=0 #Ground the "CE" pin again, to stop listening self.radio_pin.close() #Close the CE-pin except(KeyboardInterrupt, SystemExit): #If ctrl+c breaks operation or system shutdown try: self.radio_pin.close() #First close the CE-pin, so that it can be opened again without error! print("\n\ngpio-pin closed!\n") except: pass raise #continue to break or shutdown! ret = self.doOperation(duplex([STATUS])) #Get the status register as byte-array Res = [hex(z)[2:] for z in ret[0]] #convert byte-array to string list Res = Res[0].upper() #Convert the interesting byte to one string, upper case (e.g. "4E") if len(Res) == 1: #if string started with "0" (ex. "0E") the "0" is gone from previous process => (len == 1) Res= "0" + Res #Readd the "0" if thats the case if(Res != "0E"): #If something is flagged in the STATUS-register self.ReadPrintReg(STATUS,"STATUS",1) #Print out the status-register if Res == "4E": #If data is received correctly self.ReadPrintReg(RD_RX_PLOAD,"Received",PAYLOAD_SIZE) #Print out the received bytes else: print(".", end='') #Print out dots to show we are still listening! sys.stdout.flush() #the end='' only puts it in the buffer! def sendData(self,toSend): """Sends x bytes of data""" #Reset Status registry for next transmission bytes = [WRITE_REG|STATUS] #first byte to send tells nRF tat STATUS register is to be Written to bytes.append(RESET_STATUS) #add the byte that will be written to thr nRF (in this case the Reset command) self.doOperation(writing(bytes)) #execute the SPI command to send "bytes" to the nRF #Flush RX Buffer self.doOperation(writing([FLUSH_TX])) #This one is special because it doesn't need any more than one byte SPI-command. #This is because the FLUSH_TX is located on the top level on the nRF, same as the "WRITE_REG" #register or the "READ_REG". (See datasheet Tabel 8) #Print out the STATUS registry before transmission self.ReadPrintReg(STATUS,"STATUS before",1) #Print out the transmitting bytes with quotations ("chr(34)"), Payload cannot be read from the nRF! print("Transmitting...[{}{}{},{}{}{},{}{}{}]".format(chr(34), chr(toSend[0]),chr(34),chr(34), chr(toSend[1]), chr(34), chr(34),chr(toSend[2]),chr(34))) #This checks if the first byte to send is a "9", and if so, changes the address on the nRF. a = "".join([chr(x) for x in toSend]) #print(a) if(a=="009" or a=="019"): self.changeAddress(0x13) #Calls function located further down elif(a=="002" or a=="003" or a=="004"):# self.changeAddress(0x14) #Print out the address one more time, to make sure it is sent to the right receiver. self.ReadPrintReg(RX_ADDR_P0,"To",5) #write bytes to send into tx buffer bytes = [WR_TX_PLOAD] #This one is simular to FLUSH_TX because it is located on the same top level in the nRF, #Even though we want to write to it, we cannot add the "WERITE_REG" command to it! bytes.extend(toSend) #Because we now want to add a byte array to it, we use the "extend(" command instead of "append(" self.doOperation(writing(bytes)) #Write payload to nRF with SPI try: self.radio_pin.open() #Open the "CE" GPIO pin for access self.radio_pin.value=1 #Set the "CE" pin high (3,3V or 5V) to start transmission time.sleep(0.001) #Send for 0,5s to make sure it has time to send it all self.radio_pin.value=0 #Ground the CE pin again, to stop transmission self.radio_pin.close() #Close the CE-pin except(KeyboardInterrupt, SystemExit): #If ctrl+c breaks operation or system shutdown try: self.radio_pin.close() #First close the CE-pin, so that it can be opened again without error! print("\n\ngpio-pin closed!\n") except: pass raise #continue to break or shutdown! self.ReadPrintReg(STATUS,"STATUS after",1) #Read STATUS register that hopefully tells you a successful transmission has occured (0x2E) print("") if(a=="009" or a=="019" or a=="002" or a=="003" or a=="004"): #If you changed address above, change it back to normal self.changeAddress(0x12) #Change back address! def changeAddress(self,Addr): """Function to change address on both RX and """ bytes = [WRITE_REG|RX_ADDR_P0] bytes.extend([Addr,Addr,Addr,Addr,Addr]) self.doOperation(writing(bytes)) bytes = [WRITE_REG|TX_ADDR] bytes.extend([Addr,Addr,Addr,Addr,Addr]) self.doOperation(writing(bytes)) def setupRadio(self): """Function that sets the basic settings in the nRF""" #Setup EN_AA bytes = [WRITE_REG|EN_AA] bytes.append(SET_ACK) self.doOperation(writing(bytes)) #Setup ACK RETRIES bytes = [WRITE_REG|SETUP_RETR] bytes.append(SET_ACK_RETR) self.doOperation(writing(bytes)) #Setup Datapipe bytes = [WRITE_REG|EN_RXADDR] bytes.append(SET_DATAPIPE) self.doOperation(writing(bytes)) #Setup Address width bytes = [WRITE_REG|SETUP_AW] bytes.append(SET_ADR_WIDTH) self.doOperation(writing(bytes)) #Setup Freq bytes = [WRITE_REG|RF_CH] bytes.append(SET_FREQ) self.doOperation(writing(bytes)) #Setup Data speed and power bytes = [WRITE_REG|RF_SETUP] bytes.append(SET_SETUP) self.doOperation(writing(bytes)) #Setup Receive Address bytes = [WRITE_REG|RX_ADDR_P0] bytes.extend(SET_RX_ADDR_P0) #"extend" adds a list to a list, "append" adds one obect to a list self.doOperation(writing(bytes)) #Setup Transmitter Address bytes = [WRITE_REG|TX_ADDR] bytes.extend(SET_TX_ADDR) self.doOperation(writing(bytes)) #Setup Payload size bytes = [WRITE_REG|RX_PW_P0] bytes.append(SET_PAYLOAD_S) self.doOperation(writing(bytes)) #Setup CONFIG registry bytes = [WRITE_REG|CONFIG] bytes.append(SET_CONFIG) self.doOperation(writing(bytes)) time.sleep(LONG_PAUSE) #Collect print out the registers from the nRF to to make sure thay are allright self.ReadPrintReg(STATUS,"STATUS",1) self.ReadPrintReg(EN_AA,"EN_AA",1) self.ReadPrintReg(SETUP_RETR,"SETUP_RETR",1) self.ReadPrintReg(EN_RXADDR,"EN_RXADDR",1) self.ReadPrintReg(SETUP_AW,"SETUP_AW",1) self.ReadPrintReg(RF_CH,"RF_CH",1) self.ReadPrintReg(RF_SETUP,"RF_SETUP",1) self.ReadPrintReg(RX_ADDR_P0,"RX_ADDR_P0",5) self.ReadPrintReg(TX_ADDR,"TX_ADDR",5) self.ReadPrintReg(RX_PW_P0,"RX_PW_P0",1) self.ReadPrintReg(CONFIG,"CONFIG",1) #self.radio_pin.close() def Send(data): """Function that can be called from other files that wants to send data""" SendObj = NRF24L01P() SendObj.sendData(data) print("Enter data to send (3 bytes): ") #Retype the input-text (input is still on form main-loop) if __name__ == "__main__": """Gets called upon when running the file""" rxtx = input("rx or tx? \n") #Receiver or transmitter SendObj = NRF24L01P() #Start class if rxtx == "tx": #nRF transmitter print('\nTransmitter') SET_CONFIG = 0x1E #Transmitter SendObj.setupRadio() #Setting up radio #TCP-Server.Run_func() #Calls the "Run_func()" in a TCP-server (that in termes calls the "Send(data)" function above with the data) while 1: package = input("Enter data to send (3 bytes): ") #If not TCP-server is used, calls for input from user to bee sent print("") #print(package) bytesToSend = [ord(str(x)) for x in package] #Convert input to decimal values #print(bytesToSend) SendObj.sendData(bytesToSend) #calls the sendData() function with the payload else: #nRF receiver print('\nReceiver') SET_CONFIG = 0x1F #Receiver SendObj.setupRadio() print("\nReceiving data") i=0 while 1: SendObj.receiveData() time.sleep(SMALL_PAUSE)

TCP_Server.py
import socket import threading import socketserver import time import nRF24L01p class ThreadedTCPRequestHandler(socketserver.BaseRequestHandler): """Thread class""" def handle(self): while 1: try: data = str(self.request.recv(1024), 'ascii') #Receive bytes to from TCP-client to buffer of 1024 bytes cur_thread = threading.current_thread() #Get thread information print("Received: {} \n in: {}\n".format(data, cur_thread.name)) #Print out received bytes and thread name bytesToSend = [ord(str(x)) for x in data] #Convert received bytes to type: Decimal (ord("1")=49)Convert input to decimal values nRF24L01p.Send(bytesToSend) #Send the bytes to the nRF-program (transmitter) (in decimal form) self.request.sendall(bytes("{}".format(data), 'ascii')) #Resend the data to TCP-client except: break #Break from while-loop print("{} is now closed".format(cur_thread.name)) print("\nEnter data to send (3 bytes): ") #Retype the input-text (input is still on form main-loop) class ThreadedTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer): """Starts a new thread for each request""" pass def Run_func(): """Gets called on from nRF-script""" # HOST='' accepts all incoming ip HOST, PORT = '', 1234 #Setup server on different thread server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler) ip, port = server.server_address # Start a thread with the server -- the function will then start one # more thread for each request server_thread = threading.Thread(target=server.serve_forever) server_thread.daemon = True #Run in background thread = true server_thread.start() print("\nServer loop running in background thread!\n") if __name__ == "__main__": Run_func()


To run the program, create a third file, and name it to something like "a.sh", the ending "sh" means shell file, which is runnable. Fill the file with these commands:
(change the path "/home/pi/" to where you have the quick2wire-folder!)
export QUICK2WIRE_API_HOME=/home/pi/quick2wire-python-api-master export PYTHONPATH=$PYTHONPAT:$QUICK2WIRE_API_HOME python3 nRF24L01p.py
This will make sure the path is imported every time the script is run! If anyone knows how to permanently add the path, please tell me in the comment field!

To run the program, all you have to do now is to set the working path in the terminal to where you store the a.sh-file with the cd-command and type
$ sh a.sh

This is a screenshot from the code running in the terminal:

As you can see, the program starts by asking if you want to run it as "rx" (Receiver) or "tx" (transmitter). I chose transmitter by typing "tx"/enter.
Then it prints out all the registers that the code changes (or sets) and then starts a server loop in a background thread (TCP).
When this is done the program waits for either the user to type in data to send (3 bytes in my example), or for a command from the TCP-server.
In the picture above, you can see that i started by typing "123" on the keyboard, which was sent to the nRF and broadcasted to any nRF-receiver with address 0x12. As you can see the STATUS register after the broadcast tells me that the transmission failed (0x1E), since i don't have a receiver running at the moment... a working transmission would give the result "0x2E" (when the EN_AA is turned on)!

The second thing I did was to send the command "300" to the TCP-server from my home-made android application (can be sent form any TCP-client with the right port number). The TCP-server then calls the nRF24L01p.py and transmits the data like it was inputted with the keyboard.

If a (large) error shows up when you try to run the code, which tells you something about "cannot export the pin number 18 because it is already exported", run the following command in the terminal:

$ gpio-admin unexport 18

If an error shoes up that tells you that the address is occupied, the TCP-server has not closed yet, and you have to sit down and wait for up to 1min before you try again (I know you can change this timing, but haven't come so far)


If you have any questions or just want to tell me what you think of the blog, just give me a comment in the comment field underneath...
/Kalle