nRF24L01 using sender as receiver and vice versa with RF24 library

Question

I have two nRF24L01 modules (I tried 2 with antenna and 2 without antenna) paired with their power base module and connected to two different Arduino Mega 2560 boards.

I'm able to send from one module to another up to 32 bytes of data and get the acknowledge without any problems. But when I switch them, when I try to send data from receiver and receive it on the sender I have nothing. No data received, no acknowledge sent as response.

As I said before, first part of this code works well, but when it comes to the second part, which is after delay(1000); there's silence.

Here is my code:

**Receiver**
 #include <RF24.h>
 #include <RF24_config.h>
 #include <SPI.h>
 #include "printf.h"
 // Set pipes
 const uint64_t pipe01_ = 0xE8E8F0F0A1LL;
 const uint64_t pipe02_ = 0xE8E8F0F0A2LL; 
 const uint64_t pipe03_ = 0xA3LL;
 const uint64_t pipe04_ = 0xA4LL;
 const uint64_t pipe05_ = 0xA5LL;
 const uint64_t pipe06_ = 0xA6LL;
 RF24 radio(9, 53);
 
 void setup()
 { 
 Serial.begin(115200);
 delay(250);
 radio.begin();
 radio.setChannel(0x57);
 radio.setPALevel(RF24_PA_LOW);
 radio.enableAckPayload();
 radio.openReadingPipe(1, pipe01_);
 radio.openWritingPipe(pipe02_);
 radio.enableDynamicPayloads();
 radio.startListening();
 }
 
 void loop()
 {
 if (radio.available())
 {
 char newMessage[33];
 memset(newMessage, 0, sizeof(byte) * 33);
 while (radio.available()) 
 {radio.read(newMessage, 32);}
 
 Serial.println("newMessage: " + String((const char*)newMessage));
 delay(1000);
 radio.stopListening();
 
 char response[32] = "1234567890qwertyuiopasdfghjklzxc";
 radio.write(response, 32);
 unsigned long ack = 0;
 if (radio.isAckPayloadAvailable())
 {
 radio.read(&ack, sizeof(ack));
 Serial.println("ack: " + String(ack));
 }
 radio.startListening();
 }
 }

**Sender**
 #include <RF24.h>
 #include <RF24_config.h>
 #include <SPI.h>
 #include "printf.h"
 // Set pipes
 const uint64_t pipe01_ = 0xE8E8F0F0A1LL;
 const uint64_t pipe02_ = 0xA2LL; 
 const uint64_t pipe03_ = 0xA3LL;
 const uint64_t pipe04_ = 0xA4LL;
 const uint64_t pipe05_ = 0xA5LL;
 const uint64_t pipe06_ = 0xA6LL;
 RF24 radio(9, 53);
 
 void setup()
 { 
 Serial.begin(115200);
 delay(250);
 radio.begin();
 radio.setChannel(0x57);
 radio.setPALevel(RF24_PA_LOW);
 radio.enableAckPayload();
 radio.openReadingPipe(2, pipe02_);
 radio.openWritingPipe(pipe01_);
 radio.enableDynamicPayloads();
 radio.stopListening();
 
 char message[32] = "qwertyuiopasdfghjklzxc1234567890";
 radio.write(message, 32);
 
 radio.startListening();
 }
 
 void loop()
 {
 if (radio.available())
 {
 char respMessage[33];
 memset(respMessage, 0, sizeof(byte) * 33);
 while (radio.available()) 
 {radio.read(respMessage, 32);}
 
 Serial.println("respMessage: " + String((const char*)respMessage));
 }
 }

Please help me.

• Christian Lindig: The string qwertyuiopasdfghjklzxc1234567890 contains 32 characters plus an implicit null terminator - for which there is no space in the array. It would be safer to declare this as char message[] = "...". You might suffer from corrupted memory here.

Answer 1

Update: It was working yesterday, but today... same thing as with "delay()". What's wrong with these radio-modules??

I have discovered that the delay() function was causing this abnormal behavior.

So I have implemented periods instead of delay() and now I'm able to switch operating mode between "receiver" and "transmitter". Moreover, I have discovered few additional conditions that must be met (read the comments for the code).

Below is working sample code where transmitter sends some large message. Receiver gets it, waits 2 secs, then responds with another large message and gets the acknowledge for this message:

Sender

#include <RF24.h>
#include <RF24_config.h>
#include <SPI.h>
#include "printf.h"
const uint64_t pipe01_ = 0xE8E8F0F0A1LL; //Writing pipe must be full address if acknowledges will be used
const uint64_t pipe02_ = 0xE8E8F0F0A2LL; //At least one of reading pipes must be full adress
const uint64_t pipe03_ = 0xA3LL;
const uint64_t pipe04_ = 0xA4LL;
const uint64_t pipe05_ = 0xA5LL;
const uint64_t pipe06_ = 0xA6LL;
RF24 radio(9, 53);
void setup()
{ 
 Serial.begin(115200);
 delay(250);
 radio.begin();
 radio.setChannel(0x57); //not necessary. But must be equal at both sides
 radio.setPALevel(RF24_PA_LOW); //not necessary. But must be equal at both sides
 radio.enableAckPayload(); //For ability to change the Ack Payload with writeAckPayload()
 radio.openReadingPipe(2, pipe02_); //At least one of reading pipes must be full adress
 radio.openWritingPipe(pipe01_); //Writing pipe must be full address if acknowledges will be used
 radio.enableDynamicPayloads(); //If not set, size will be of fixed length. Default fixed length is 32 bytes
 /*Must run this if "startListening()" will be used anywhere in the code below. 
 nRF24L01 remembers it's state even if Arduino was restarted*/
 radio.stopListening();
 Serial.println("Sending the message...");
 char message[32] = "qwertyuiopasdfghjklzxc1234567890"; //some test message
 radio.write(message, 32); //Send message over the predefined "writing pipe"
 Serial.println("Waiting for response...");
 radio.startListening(); //Resets TX buffer and switches radio module's mode to "receiver"
 uint16_t ack = 123;
 radio.writeAckPayload(2, &ack, sizeof(ack)); //Custom ACK payload must be set after "startListening()". Because "startListening()" resets TX buffer
}
void loop()
{
 if (radio.available())
 {
 char respMessage[33];
 memset(respMessage, 0, sizeof(byte) * 33);
 while (radio.available()) 
 {radio.read(respMessage, 32);}
 Serial.println("respMessage: " + String((const char*)respMessage));
 }
}

Receiver

#include <RF24.h>
#include <RF24_config.h>
#include <SPI.h>
#include "printf.h"
#define period_ 2000
// Set pipes
const uint64_t pipe01_ = 0xE8E8F0F0A1LL; //At least one of reading pipes must be full adress
const uint64_t pipe02_ = 0xE8E8F0F0A2LL; //Writing pipe must be full address if acknowledges will be used
const uint64_t pipe03_ = 0xA3LL;
const uint64_t pipe04_ = 0xA4LL;
const uint64_t pipe05_ = 0xA5LL;
const uint64_t pipe06_ = 0xA6LL;
unsigned long checkPoint = 0;
bool messageReceived = false;
RF24 radio(9, 53);
void setup()
{ 
 Serial.begin(115200);
 delay(250);
 radio.begin();
 radio.setChannel(0x57); //not necessary. But must be equal at both sides
 radio.setPALevel(RF24_PA_LOW); //not necessary. But must be equal at both sides
 radio.enableAckPayload(); //For ability to change the Ack Payload with writeAckPayload()
 radio.openReadingPipe(1, pipe01_); //At least one of reading pipes must be full adress
 radio.openWritingPipe(pipe02_); //Writing pipe must be full address if acknowledges will be used
 radio.enableDynamicPayloads(); //Writing pipe must be full address if acknowledges will be used
 radio.startListening(); //If not set, size will be of fixed length. Default fixed length is 32 bytes
}
void loop()
{
 if (radio.available())
 {
 char newMessage[33];
 memset(newMessage, 0, sizeof(byte) * 33);
 while (radio.available()) 
 {radio.read(newMessage, 32);}
 Serial.println("newMessage: " + String((const char*)newMessage));
 checkPoint = millis(); 
 messageReceived = true;
 }
 unsigned long timePassed = millis() - checkPoint;
 //When it receives, controller waits for 2 seconds then sends the response just one time
 if (messageReceived && timePassed > period_)
 {
 messageReceived = false;
 checkPoint = millis();
 Serial.println("sending response...");
 //This must be called before sending anything (except acknowledges)
 radio.stopListening(); //Resets TX buffer and switches radio module's mode to transmitter
 char response[32] = "1234567890qwertyuiopasdfghjklzxc";
 radio.write(response, 32); 
 unsigned long ack = 0;
 if (radio.isAckPayloadAvailable())
 {
 radio.read(&ack, sizeof(ack));
 Serial.println("ack received: " + String(ack));
 }
 radio.startListening(); //Resets TX buffer and switches radio module's mode to "receiver"
 }
}