Using the NRF24L01+ with the Arduino

Downloads

Arduino IDE Software

NRF24L01 Library

printf.h (right-click on this file and save it to your sketch directory)

Menu

NRF24L01 Basic Transmit from p.56

NRF24L01 Basic Receive from p.61

Basic Transmit with Dynamic Payloads(Send) from p.67

Basic Transmit with Dynamic Payloads(Receive) from p.68

Receiving Data from Multiple Modules (Transmitting Sketch) from p.73

Receiving Data from Multiple Modules (Receiving Sketch) from p.74

Bidirectional Transmissions and Acknowledgments (Transmitting Sketch) from p.81

Bidirectional Transmissions and Acknowledgments (Receiving Sketch) from p.85

Printing details with printf from p.89

Printing details without printf from p.90

Frequency Sniffer (Send) from p.93

Frequency Sniffer (Receive) from p.94

Read and Write Registers from p.98

Read the Status Register from p.106

Standard Acknowledgement Packets (Transmit) from p.112

Standard Acknowledgement Packets (Receive) from p.115

IRQ Wakeup Call (Transmit) from p.121

IRQ Wakeup Call (Receive) from p.124

NRF24L01 Basic Transmit from p.56
	Select All
/* NRF24L01 Basic Transmit Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLK to pin 13 IRQ (not connected) */ #include <SPI.h> //www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> RF24 radio(9,10); String msg; void setup(){ Serial.begin(115200); radio.begin(); radio.openWritingPipe(0x0000000001); radio.setDataRate(RF24_2MBPS); } void loop(){ msg="More books at Y2KLeader.com"; //max of 32 chars int msg_len = msg.length()+1; char char_array[msg_len]; msg.toCharArray(char_array, msg_len); Serial.println(msg); radio.write(char_array,msg_len ); }

NRF24L01 Basic Receive from p.61
	Select All
/* NRF24L01 Basic Receive Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLK to pin 13 IRQ (not connected) */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> char msg[32]; RF24 radio(9,10); void setup(){ Serial.begin(115200); radio.begin(); radio.openReadingPipe(1,0x0000000001); radio.setDataRate(RF24_2MBPS); radio.startListening(); } void loop(){ if (radio.available()){ radio.read(msg,32); for (int i=0;i<33;i++){ Serial.print(msg[i]); } Serial.println(); } }

Basic Transmit with Dynamic Payloads(Send) from p.67
	Select All
/* Basic Transmit with Dynamic Payloads(Send) Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLI to pin 13 IRQ (not connected) */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> RF24 radio(9,10); String msg; int msg_len; void setup(){ Serial.begin(115200); radio.begin(); radio.enableDynamicPayloads(); radio.openWritingPipe(0x000000000A); } void loop(){ msg="test"; //max of 32 chars //convert string to array int msg_len = msg.length()+1; char char_array[msg_len]; msg.toCharArray(char_array,msg_len); radio.write(char_array,msg.length()); }

Basic Transmit with Dynamic Payloads(Receive) from p.68
	Select All
/* Basic Transmit with Dynamic Payloads(Receive) Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLI to pin 13 IRQ (not connected) */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> char msg[32]; RF24 radio(9,10); void setup(){ Serial.begin(115200); radio.begin(); radio.enableDynamicPayloads(); //set to the same # of bytes of the transmitter's msg radio.setPayloadSize(4); radio.openReadingPipe(1,0x000000000A); radio.startListening(); } void loop(){ if (radio.available()){ radio.read(msg,radio.getPayloadSize()); Serial.println(String(msg)); } }

Receiving Data from Multiple Modules (Transmitting Sketch) from p.73
	Select All
/* Receiving Data from Multiple Modules (Transmitting Sketch) Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLK to pin 13 IRQ (not connected) */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> RF24 radio(9,10); String msg; void setup(){ Serial.begin(115200); radio.begin(); radio.openWritingPipe(0x000000000A); radio.setDataRate(RF24_2MBPS); } void loop(){ msg="Hello From Mars."; //max of 32 chars int msg_len = msg.length()+1; char char_array[msg_len]; msg.toCharArray(char_array, msg_len); Serial.println(msg); radio.write(char_array,msg_len ); }

Receiving Data from Multiple Modules (Receiving Sketch) from p.74
	Select All
/* Receiving Data from Multiple Modules (Receiving Sketch) Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLK to pin 13 IRQ (not connected) */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> char msg[32]; byte pipe_number; RF24 radio(9,10); void setup(){ Serial.begin(115200); radio.begin(); //assign a pipe number to each pipe radio.openReadingPipe(0,0x000000000A); radio.openReadingPipe(1,0x000000000B); radio.openReadingPipe(2,0x000000000C); //radio.openReadingPipe(3,0x000000000D); //radio.openReadingPipe(4,0x000000000E); //radio.openReadingPipe(5,0x000000000F); radio.setDataRate(RF24_2MBPS); radio.startListening(); } void loop(){ //---------------------------------- //Receive transmissions from pipe #0 //---------------------------------- pipe_number=0; if (radio.available(&pipe_number)){ radio.read(msg,32); for (int i=0;i<33;i++){ Serial.print(msg[i]); } Serial.println(); }//end if //---------------------------------- //Receive transmissions from pipe #1 //---------------------------------- pipe_number=1; if (radio.available(&pipe_number)){ radio.read(msg,32); for (int i=0;i<33;i++){ Serial.print(msg[i]); } Serial.println(); }//end if //---------------------------------- //Receive transmissions from pipe 2 //---------------------------------- pipe_number=2; if (radio.available(&pipe_number)){ radio.read(msg,32); for (int i=0;i<33;i++){ Serial.print(msg[i]); } Serial.println(); }//end if //---------------------------------- //Receive transmissions from pipe #3 //---------------------------------- pipe_number=3; if (radio.available(&pipe_number)){ radio.read(msg,32); for (int i=0;i<33;i++){ Serial.print(msg[i]); } Serial.println(); }//end if //---------------------------------- //Receive transmissions from pipe #4 //---------------------------------- pipe_number=4; if (radio.available(&pipe_number)){ radio.read(msg,32); for (int i=0;i<33;i++){ Serial.print(msg[i]); } Serial.println(); }//end if //---------------------------------- //Receive transmissions from pipe #5 //---------------------------------- pipe_number=5; if (radio.available(&pipe_number)){ radio.read(msg,32); for (int i=0;i<33;i++){ Serial.print(msg[i]); } Serial.println(); }//end if }

Bidirectional Transmissions and Acknowledgments (Transmitting Sketch) from p.81
	Select All
/* Bidirectional Transmissions and Acknowledgments (Transmitting Sketch) Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLK to pin 13 IRQ (not connected) */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> RF24 radio(9,10); String msg; char reply[32]; byte rx_pipe_number; int time_between_sends=2000; void setup(){ Serial.begin(115200); radio.begin(); radio.openReadingPipe(1,0x000000000A); radio.openReadingPipe(2,0x000000000C); radio.openWritingPipe(0x000000000B); radio.setDataRate(RF24_2MBPS); } void loop(){ delay(time_between_sends); //Send the elapsed milliseconds msg=String(millis()); //32 chars max int msg_len = msg.length()+1; char char_array[msg_len]; msg.toCharArray(char_array, msg_len); radio.write(char_array,msg_len ); Serial.println("Sent "+msg); //stop and wait for response radio.startListening(); delay(50); rx_pipe_number=1; if (radio.available(&rx_pipe_number)){ radio.read(&reply,32); Serial.println(String(reply)); } delay(50); rx_pipe_number=2; if (radio.available(&rx_pipe_number)){ radio.read(&reply,32); Serial.println(String(reply)); } radio.stopListening(); }

Bidirectional Transmissions and Acknowledgments (Receiving Sketch) from p.85
	Select All
/* Bidirectional Transmissions and Acknowledgments (Receiving Sketch) Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLK to pin 13 IRQ (not connected) */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> char msg[32]; byte rx_pipe_number=1; String reply; int module_number=3; int timer_delay=60; RF24 radio(9,10); void setup(){ Serial.begin(115200); radio.begin(); radio.openReadingPipe(1,0x000000000B); radio.openWritingPipe(0x000000000C); radio.setDataRate(RF24_2MBPS); radio.startListening(); } void loop(){ if (radio.available(&rx_pipe_number)){ radio.read(msg,32); Serial.println("Received "+String(msg)); //now send reply (32 characters max) delay(timer_delay); radio.stopListening(); reply="Module #"+String(module_number)+" received "+String(msg); int reply_len = reply.length()+1; char reply_array[reply_len]; reply.toCharArray(reply_array, reply_len); radio.write(reply_array,reply_len); Serial.println("Replied - "+reply); radio.startListening(); delay(timer_delay); }//end if }

Printing details with printf from p.89
	Select All
//Printing details with printf #include <SPI.h> #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> //printf.h file must be in this sketch’s folder #include "printf.h"; RF24 radio(9,10); void setup(void){ Serial.begin(115200); radio.begin(); printf_begin(); radio.printDetails(); } void loop(void){}

Printing details without printf from p.90
	Select All
//printing details without printf #include <SPI.h> #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> RF24 radio(9,10); int my_putc(char c,FILE *t) { Serial.write(c); } void setup(void){ Serial.begin(115200); fdevopen(&my_putc,0); radio.begin(); radio.printDetails(); } void loop(void){}

Frequency Sniffer (Send) from p.93
	Select All
/* Frequency Sniffer (Send) Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLI to pin 13 IRQ (not connected) */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> RF24 radio(9,10); String msg; void setup(){ Serial.begin(115200); radio.begin(); radio.setChannel(80); //0-127 radio.openWritingPipe(0x0000000001); } void loop(){ msg="Visit Y2KLeader.com"; //max of 32 chars int msg_len = msg.length()+1; char char_array[msg_len]; msg.toCharArray(char_array, msg_len); radio.write(char_array,msg_len ); }

Frequency Sniffer (Receive) from p.94
	Select All
/* Frequency Sniffer (Receive) Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLI to pin 13 IRQ (not connected) */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> RF24 radio(9,10); String GHz; void setup(){ Serial.begin(115200); radio.begin(); radio.startListening(); } void loop(){ for (int i=0;i<128;i++){ radio.setChannel(i); //use radio.testCarrier() if not the plus model instead of testRPD if (radio.testRPD()){ GHz=String(2400+i); GHz=GHz.substring(0,1)+"."+GHz.substring(1,4); Serial.println("Signal found at "+String(GHz)+"GHz("+String(i)+")"); } } delay(100); }

Read and Write Registers from p.98
	Select All
/* Read and Write Registers Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLI to pin 13 IRQ (not connected) */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> char data[32]; char msg[32]; byte reply[2]; RF24 radio(9,10); int CE_pin=9; int CS_pin=10; int mydata[5]; void setup(){ Serial.begin(115200); radio.begin(); radio.enableAckPayload(); radio.enableDynamicPayloads(); //same as radio.setAutoAck(0,true) and radio.setAutoAck(1,true) register_write(0x01,3); ///Below reads the setup register and extracts the datarate from bit 3 //The default is 1MBPS, buyou can test it like this: //radio.setDataRate(RF24_250KBPS); //sets to 250KBPS //radio.setDataRate(RF24_1MBPS); //sets to 1MPBS //radio.setDataRate(RF24_2MBPS); //sets to 2MPBS int v=register_read(0x06); int datarate=bitRead(v,3); //read the bit in the 3rd position int ext250=bitRead(v,5); //read the bit in the 5th position Serial.println("Bits 3 & 5 from Register 0x06:"); Serial.println("Bit 3 = "+String(datarate)); //0=1MPBS & 250KBPS, 1=2MPBS Serial.println("Bit 5 = "+String(ext250)); //If set to 1 then 250KBPS is active if (datarate==0 && ext250==0){ Serial.println("The speed is 1MPBS"); } if (datarate==1){ Serial.println("The speed is 2MPBS"); } if (datarate==0 && ext250==1){ Serial.println("The speed is 250KBPS"); } //Write the address for reading pipe 1 to the register //Same as radio.openReadingPipe(1,0xA1B2C3D4E5); //these bytes must be written in reverse order mydata[4]=0xA1; mydata[3]=0xB2; mydata[2]=0xC3; mydata[1]=0xD4; mydata[0]=0xE5; write_bytes(0x0B,mydata,5); //Get the reading pipe address for pipe 1 from the register //You can test this by changing it in the previous code or by writing: //radio.openReadingPipe(1,0xA1B2C3D4E5); //uncomment and change to whatever *mydata=read_bytes(0x0B,5); Serial.println("Pipe 1 address in the order read is:"); for (int i=0;i<5;i++){ Serial.print(mydata[i],HEX); } Serial.println(); Serial.println("Pipe 1 address in reverse order is:"); //since the data pipe address is recorded backwards in the register, //print it in reverse for (int i=4;i>-1;i--){ Serial.print(mydata[i],HEX); } radio.startListening(); } //end of setup function void loop(){ if (radio.available()){ radio.read(msg,sizeof(msg)); //Serial.println(String(msg)); reply[0]=79; //Ascii code for letter O reply[1]=75; //Ascii code for letter K radio.read(msg,sizeof(msg)); radio.writeAckPayload(1,reply,sizeof(reply)); } } int read_bytes(byte register_address,int bytes){ //Read many bytes from a register //Works just like register_read but reads many bytes instead of just one //You can also read just one byte using this method int return_data[bytes]; digitalWrite(CS_pin, LOW); SPI.transfer(register_address); for (int i=0;i<bytes;i++){ return_data[i]=SPI.transfer(0); } digitalWrite(CS_pin, HIGH); return *return_data; } void write_bytes(byte register_address,int bytedata[],int bytes){ //write many bytes to a register //Works just like register_write but writes many bytes instead of just one //You can also just write one byte using this method digitalWrite(CS_pin, LOW); //int w=32+register_address; //add 32 to command a write SPI.transfer(32+register_address); for (int i=0;i<bytes;i++){ SPI.transfer(bytedata[i]); } digitalWrite(CS_pin, HIGH); } int register_read(byte register_address){ //reads a single byte from the desired registar address int register_data; digitalWrite(CS_pin, LOW); SPI.transfer(register_address); register_data=SPI.transfer(0); //get data byte digitalWrite(CS_pin, HIGH); return register_data; } void register_write(byte register_address,char data_to_write){ //writes a single byte to the desired registar address digitalWrite(CS_pin, LOW); int w=32+register_address; //add 32 to command a write SPI.transfer(w); SPI.transfer(data_to_write); digitalWrite(CS_pin, HIGH); }

Read the Status Register from p.106
	Select All
/* Read the Status Register Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLK to pin 13 IRQ (not connected) */ #include <SPI.h> int CE_pin=9; int CS_pin=10; int MOSI_pin=11; int MISO_pin=12; int SCLK_pin=13; int IRQ_pin=8; //not normally connected #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> RF24 radio(9,10); int data; void setup(){ Serial.begin(115200); SPI.begin(); radio.begin(); //------------------------------------------ //read the bits from the status register (0x07) //------------------------------------------ //Bit 0 = TX FIFO full flag //Bits 1-3 = Data pipe number for the an available payload //Bit 4 = Max # of TX retries interrupt flag. Must be reset to zero to continue xmitting //Bit 5 = Data sent TX FIFO interrupt flag. Write 1 to clear bit. //Bit 6 = Data available. Must clear after reading from FIFO int stat=register_read(0x07); Serial.println("STATUS REGISTER:"); Serial.println("-------"); Serial.println("Binary value of Status is "+String(stat,BIN)); int tx_full=0; int rx_p_no=0; int max_rt=0; int tx_ds=0; int rx_dr=0; if(bitRead(stat,0)){bitSet(tx_full,0);} if(bitRead(stat,1)){bitSet(rx_p_no,0);} if(bitRead(stat,2)){bitSet(rx_p_no,1);} if(bitRead(stat,3)){bitSet(rx_p_no,2);} if(bitRead(stat,4)){bitSet(max_rt,0);} if(bitRead(stat,5)){bitSet(tx_ds,0);} if(bitRead(stat,6)){bitSet(rx_dr,0);} Serial.println("TX FIFO Full = "+String(tx_full)); Serial.println("Payload Availble on = "+String(rx_p_no)+" (7=Empty)"); Serial.println("Max Retries Achieved = "+String(max_rt)); Serial.println("Data Sent = "+String(tx_ds)); Serial.println("Ready to Receive = "+String(rx_dr)); //------------------------------------------ //Clear the interrupts //------------------------------------------ //You must clear the interrupts to reset them. //writing 1 to a bit will clear it and reset it to 0 register_write(0x08,16); //clear max_rt register_write(0x08,32); //clear tx_ds register_write(0x08,64); //clear rx_dr } void loop(){} int register_read(byte register_address){ //reads a single byte from the desired register address int register_data; digitalWrite(CS_pin, LOW); SPI.transfer(register_address); register_data=SPI.transfer(0); //get data byte digitalWrite(CS_pin, HIGH); return register_data; } void register_write(byte register_address,char data_to_write){ //writes a single byte to the desired register address digitalWrite(CS_pin, LOW); int w=32+register_address; //add 32 to command a write SPI.transfer(w); SPI.transfer(data_to_write); digitalWrite(CS_pin, HIGH); }

Standard Acknowledgement Packets (Transmit) from p.112
	Select All
/* Standard Acknowledgement Packets (Transmit) Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLI to pin 13 IRQ (not connected) */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> RF24 radio(9,10); String msg; byte ackmsg[2]; int CS_pin=10; void setup(){ Serial.begin(115200); radio.begin(); //this is supposed to work but does't always: //radio.setAutoAck(0,true); //radio.enableDynamicPayloads(); //instead, use this: //enable dynamic payloads for pipe 0 register_write(0x1C,1); //enable dynmic payload length & ack packets register_write(0x1D,6); radio.openWritingPipe(0xA1B2C3D4E5); } void loop(){ msg=String(millis()); //max of 32 chars Serial.println(msg); int msg_len = msg.length()+1; char char_array[msg_len]; msg.toCharArray(char_array, msg_len); radio.write(char_array,msg_len ); if ( radio.isAckPayloadAvailable()){ radio.read(ackmsg,sizeof(ackmsg)); Serial.print("ackmsg[0]="); Serial.print(ackmsg[0]); Serial.print (" "); Serial.print("ackmsg[1]="); Serial.print(ackmsg[1]); Serial.print (" String="); Serial.println(String(char(ackmsg[0]))+String(char(ackmsg[1]))); } } int register_read(byte register_address){ //reads a single byte from the desired registar address int register_data; digitalWrite(CS_pin, LOW); SPI.transfer(register_address); register_data=SPI.transfer(0); //get data byte digitalWrite(CS_pin, HIGH); return register_data; } void register_write(byte register_address,char data_to_write){ //writes a single byte to the desired registar address digitalWrite(CS_pin, LOW); int w=32+register_address; //add 32 to command a write SPI.transfer(w); SPI.transfer(data_to_write); digitalWrite(CS_pin, HIGH); }

Standard Acknowledgement Packets (Receive) from p.115
	Select All
/* Standard Acknowledgement Packets (Receive) Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLI to pin 13 IRQ (not connected) */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> char msg[32]; byte reply[2]; int CS_pin=10; RF24 radio(9,10); void setup(){ Serial.begin(115200); radio.begin(); //this is supposed to work but does't always: //radio.setAutoAck(1,true); //radio.enableDynamicPayloads(); //instead, use this: //enable dynamic payloads for pipe 1 register_write(0x1C,2); //enable dynmic payload length & ack packets register_write(0x1D,6); radio.openReadingPipe(1,0xA1B2C3D4E5); radio.startListening(); } void loop(){ if (radio.available()){ radio.read(msg,sizeof(msg)); Serial.println(String(msg)); reply[0]=79; //Ascii code for letter O reply[1]=75; //Ascii code for letter K //writes acknowledge of OK to pipe 1 radio.writeAckPayload(1,reply,2); } } int register_read(byte register_address){ //reads a single byte from the desired registar address int register_data; digitalWrite(CS_pin, LOW); SPI.transfer(register_address); register_data=SPI.transfer(0); //get data byte digitalWrite(CS_pin, HIGH); return register_data; } void register_write(byte register_address,char data_to_write){ //writes a single byte to the desired registar address digitalWrite(CS_pin, LOW); int w=32+register_address; //add 32 to command a write SPI.transfer(w); SPI.transfer(data_to_write); digitalWrite(CS_pin, HIGH); }

IRQ Wakeup Call (Transmit) from p.121
	Select All
/* IRQ Wakeup Call (Transmit) Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLI to pin 13 IRQ not used */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> RF24 radio(9,10); String msg; byte ackmsg[2]; int CS_pin=10; //int interruptPin=2; //int conf; void setup(){ Serial.begin(115200); radio.begin(); //enable dynamic payloads for pipe 0 register_write(0x1C,1); //enable dynmic payload length & ack packets register_write(0x1D,6); radio.openWritingPipe(0xAABBCCDDEE); } void loop(){ msg="Good morning!"; //max of 32 chars //Serial.println(msg); int msg_len = msg.length()+1; char char_array[msg_len]; msg.toCharArray(char_array, msg_len); radio.write(char_array,msg_len ); if (radio.isAckPayloadAvailable()){ //acknowledgment received from receiver radio.read(ackmsg,sizeof(ackmsg)); Serial.print("ackmsg[0]="); Serial.print(ackmsg[0]); Serial.print (" "); Serial.print("ackmsg[1]="); Serial.print(ackmsg[1]); Serial.print (" String="); Serial.println(String(char(ackmsg[0]))+String(char(ackmsg[1]))); } } int register_read(byte register_address){ //reads a single byte from the desired registar address int register_data; digitalWrite(CS_pin, LOW); SPI.transfer(register_address); register_data=SPI.transfer(0); //get data byte digitalWrite(CS_pin, HIGH); return register_data; } void register_write(byte register_address,char data_to_write){ //writes a single byte to the desired registar address digitalWrite(CS_pin, LOW); int w=32+register_address; //add 32 to command a write SPI.transfer(w); SPI.transfer(data_to_write); digitalWrite(CS_pin, HIGH); }

IRQ Wakeup Call (Receive) from p.124
	Select All
/* IRQ Wakeup Call (Receive) Written by Michael Wright, www.Y2kLeader.com GND to ground VCC to 3.3 volts CE to pin 9 CS to pin 10 MOSI to pin 11 MISO to pin 12 SCLI to pin 13 IRQ to pin 2 */ #include <SPI.h> //check www.y2KLeader.com to download these libraries: #include <nRF24L01.h> #include <RF24.h> #include <RF24_config.h> char msg[32]; byte reply[2]; int CS_pin=10; int interruptPin=2; int conf; bool tx_ok; bool tx_fail; bool rx_ready; //These variables are used for the interrupt //when using the library bool max_rt; //send failed after max retries flag bool tx_ds; //data sent flag bool rx_dr; //data arrived in receive buffer flag RF24 radio(9,10); void setup(){ Serial.begin(115200); pinMode(interruptPin, INPUT); radio.begin(); //enable dynamic payloads for pipe 1 register_write(0x1C,2); //63 enables all pipes //enable dynmic payload length & ack packets register_write(0x1D,6); radio.setPALevel(RF24_PA_MIN);//set to minimum power mode //read the configuration register conf=register_read(0x00); //Mask the max_rt and tx_ds interrupts (ignore them) //Only listen to rx_dr bitWrite(conf, 4, 1); //mask max_rt flag bitWrite(conf, 5, 1); //mask tx_ds flag bitWrite(conf, 6, 0); //set RX_DR to be read register_write(0x00,conf); //write the reconfigured byte radio.openReadingPipe(1,0xAABBCCDDEE); //open reading pipe #1 Serial.println("Listening in min pwr mode for wakeup command."); //send control to the read_interrupt() function when the IRQ pin //is brought LOW. attachInterrupt(digitalPinToInterrupt(interruptPin), read_interrupt, FALLING); radio.startListening(); //wait for an incoming signal } void loop(){ if (radio.available()){ radio.read(msg,32); //read message from buffer Serial.println(String(msg)); reply[0]=79; //Ascii code for letter O reply[1]=75; //Ascii code for letter K radio.writeAckPayload(1,reply,2); } } void read_interrupt(){ Serial.println("Signal detected."); int stat=register_read(0x07); //read the status register byte Serial.println("Status Register = "+String(stat,BIN)); //read bits 4, 5 and 6 to get interrupt status //only bit 6 is needed is needed for this sketch //if(bitRead(stat,4)){Serial.println("Max retries reached.");} //if(bitRead(stat,5)){Serial.println("Data was sent.");} if(bitRead(stat,6)){Serial.println("Data arrived.");} //This does the same thing as above but uses the library: //radio.whatHappened(tx_ok, tx_fail,rx_ready); //Serial.println("tx_ok = "+String(tx_ok)); //Serial.println("tx_fail = "+String(tx_fail)); //Serial.println("rx_ready = "+String(rx_ready)); //Next, clear all the registers //the lines commented out are not necessary becaused those //interrupts have been masked in the setup function //bitWrite(stat, 4, 0); //set the MAX_RT bit to 0 //bitWrite(stat, 5, 0); //set the TX_DS to 0 bitWrite(stat, 6, 0); //set RX_DR to 0 register_write(0x07,stat); //write the config byte Serial.println("Interrupt bits cleared."); Serial.println("Status Register now = "+String(stat,BIN)); radio.setPALevel(RF24_PA_HIGH); //set the power level to high Serial.println("Commence normal receiving operation."); radio.startListening(); //wait for more data //stop checking the interrupt pin detachInterrupt(digitalPinToInterrupt(interruptPin)); } int register_read(byte register_address){ //reads a single byte from the desired registar address int register_data; digitalWrite(CS_pin, LOW); SPI.transfer(register_address); register_data=SPI.transfer(0); //get data byte digitalWrite(CS_pin, HIGH); return register_data; } void register_write(byte register_address,char data_to_write){ //writes a single byte to the desired registar address digitalWrite(CS_pin, LOW); int w=32+register_address; //add 32 to command a write SPI.transfer(w); SPI.transfer(data_to_write); digitalWrite(CS_pin, HIGH); }