FINAL EDIT: Forget it, I had connected CE and CS to pins 9 and 10 from a previous tutorial and the random values were the result of the floating pin states... Sorry.
Hi, I have the same or a similar problem here. I'm using an Arduino Uno and an Arduino Nano with a slightly modified version of the official Getting-Started sketch of the RF24 library:
/*
* Getting Started example sketch for nRF24L01+ radios
* This is a very basic example of how to send data from one node to another
* Updated: Dec 2014 by TMRh20
*/
#include <SPI.h>
#include "RF24.h"
/****************** User Config ***************************/
/*** Set this radio as radio number 0 or 1 ***/
bool radioNumber = 0;
/* Hardware configuration: Set up nRF24L01 radio on SPI bus plus pins 7 & 8 */
RF24 radio(7,8);
/**********************************************************/
byte addresses[][6] = {"1Node","2Node"};
// Used to control whether this node is sending or receiving (1=sender, 0=receiver)
bool role = 0;
void setup() {
Serial.begin(9600);
Serial.println(F("RF24/examples/GettingStarted"));
Serial.println(F("*** PRESS 'T' to begin transmitting to the other node"));
radio.begin();
// Set the PA Level low to prevent power supply related issues since this is a
// getting_started sketch, and the likelihood of close proximity of the devices. RF24_PA_MAX is default.
radio.setPALevel(RF24_PA_LOW);
// Open a writing and reading pipe on each radio, with opposite addresses
if(radioNumber){
radio.openWritingPipe(addresses[1]);
radio.openReadingPipe(1,addresses[0]);
}else{
radio.openWritingPipe(addresses[0]);
radio.openReadingPipe(1,addresses[1]);
}
// Start the radio listening for data
radio.startListening();
}
void loop() {
/****************** Ping Out Role ***************************/
if (role == 1) {
radio.stopListening(); // First, stop listening so we can talk.
Serial.println(F("Now sending"));
unsigned long start_time = micros(); // Take the time, and send it. This will block until complete
if (!radio.write( &start_time, sizeof(unsigned long) )){
Serial.println(F("failed"));
}
radio.startListening(); // Now, continue listening
unsigned long started_waiting_at = micros(); // Set up a timeout period, get the current microseconds
boolean timeout = false; // Set up a variable to indicate if a response was received or not
while ( ! radio.available() ){ // While nothing is received
if (micros() - started_waiting_at > 200000 ){ // If waited longer than 200ms, indicate timeout and exit while loop
timeout = true;
break;
}
}
if ( timeout ){ // Describe the results
Serial.println(F("Failed, response timed out."));
}else{
unsigned long got_time; // Grab the response, compare, and send to debugging spew
radio.read( &got_time, sizeof(unsigned long) );
unsigned long end_time = micros();
// Spew it
Serial.print(F("Sent "));
Serial.print(start_time);
Serial.print(F(", Got response "));
Serial.print(got_time);
Serial.print(F(", Round-trip delay "));
Serial.print(end_time-start_time);
Serial.println(F(" microseconds"));
}
// Try again 1s later
delay(1000);
}
/****************** Pong Back Role ***************************/
if ( role == 0 )
{
unsigned long got_time;
if( radio.available()){
// Variable for the received timestamp
while (radio.available()) { // While there is data ready
radio.read( &got_time, sizeof(unsigned long) ); // Get the payload
}
radio.stopListening(); // First, stop listening so we can talk
radio.write( &got_time, sizeof(unsigned long) ); // Send the final one back.
radio.startListening(); // Now, resume listening so we catch the next packets.
Serial.print(F("Sent response "));
Serial.println(got_time);
}
}
/****************** Change Roles via Serial Commands ***************************/
if ( Serial.available() )
{
char c = toupper(Serial.read());
if ( c == 'T' && role == 0 ){
Serial.println(F("*** CHANGING TO TRANSMIT ROLE -- PRESS 'R' TO SWITCH BACK"));
role = 1; // Become the primary transmitter (ping out)
}else
if ( c == 'R' && role == 1 ){
Serial.println(F("*** CHANGING TO RECEIVE ROLE -- PRESS 'T' TO SWITCH BACK"));
role = 0; // Become the primary receiver (pong back)
radio.startListening();
}
}
} // Loop
The role and radioNumber variables are adjusted for each board to either being both 1 or both 0.
The output I get for the receiving (Nano) board looks like this snippet:
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 2139062143
Sent response 4294967295
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 2139062143
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 4294934399
Sent response 0
Sent response 0
Sent response 0
Sent response 2139062143
Sent response 2147450751
Sent response 0
Sent response 0
Sent response 520093696
Sent response 2139062047
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 0
Sent response 2139062143
Sent response 0
Sent response 0
Sent response 0
Has anyone an idea what I'm doing wrong?
Thanks in advance!
EDIT:
After I completely disconnected the sending Arduino UNO and still receiving similar data as posted above on the Arduino NANO, I wondered if it was because of an already occupied channel. So I introduced a new global variable channel initially set to 0 and the following code at its respective position:
if ( role == 0 )
{
unsigned long got_time;
if( radio.available()){
// Variable for the received timestamp
while (radio.available()) { // While there is data ready
radio.read( &got_time, sizeof(unsigned long) ); // Get the payload
}
// Try out a new channel if the current one is in use
radio.setChannel(channel++);
Serial.print("Switched to channel ");
Serial.println(channel);
if (channel == 126) channel = 0;
// radio.stopListening(); // First, stop listening so we can talk
// radio.write( &got_time, sizeof(unsigned long) ); // Send the final one back.
// radio.startListening(); // Now, resume listening so we catch the next packets.
// Serial.print(F("Sent response "));
// Serial.println(got_time);
}
}
Now, it iterates through all available channels, seemingly receiving data on each of them as shown in this snippet:
Switched to channel 123
Switched to channel 124
Switched to channel 125
Switched to channel 126
Switched to channel 1
Switched to channel 2
Switched to channel 3
Switched to channel 4
EDIT2:
I used the following simplified code I wrote by myself and uploaded it to both the UNO and NANO while switching the other board off respectively. The result is a constant output of "Radio has data", sparingly followed by a "random" number. Any ideas why this could be happening?
#include <SPI.h>
#include "RF24.h"
RF24 radio(7, 8);
byte address[6] = "foobar";
const byte channel = 10;
void setup() {
radio.begin();
radio.setPALevel(RF24_PA_MIN);
radio.setChannel(channel);
radio.openReadingPipe(1, address);
radio.startListening();
Serial.begin(9600);
Serial.println("Receiver started");
}
void loop() {
if (radio.available()) {
Serial.println("Radio has data");
byte msg;
while (radio.available()) {
radio.read(&msg, sizeof(msg));
if (msg != 0) {
Serial.println(msg);
}
}
}
}
The receiver would only work successfully when powered by the Nano directly, otherwise radio.available() always returns true