nRF24L01+ TMRh20 "getting started" example

In the pong-back section of TMRh20 “getting started” program,, sizeof(unsigned long) is in a while (radio.available()) loop that is within an if (radio.available()) statement.

But in the ping-out section,, sizeof(unsigned long)) is not in a while loop.

Also, in the examples in the RF24.h file, the is not in a while loop.

Why is the in the pong-back section in a while loop? Seems like there is no need for the while loop (and in fact the example seems to operate ok without it).

From getting started:

* 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
bool role = 0;

void setup() {
  Serial.println(F("*** PRESS 'T' to begin transmitting to the other node"));

  // 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.
  // Open a writing and reading pipe on each radio, with opposite addresses
  // Start the radio listening for data

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) )){
    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;
    if ( timeout ){                                             // Describe the results
        Serial.println(F("Failed, response timed out."));
        unsigned long got_time;                                 // Grab the response, compare, and send to debugging spew &got_time, sizeof(unsigned long) );
        unsigned long end_time = micros();
        // Spew it
        Serial.print(F("Sent "));
        Serial.print(F(", Got response "));
        Serial.print(F(", Round-trip delay "));
        Serial.println(F(" microseconds"));

    // Try again 1s later

/****************** 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 &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 "));

/****************** Change Roles via Serial Commands ***************************/

  if ( Serial.available() )
    char c = toupper(;
    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)
    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)

} // Loop

from RF24.h:

   * Read the available payload
   * The size of data read is the fixed payload size, see getPayloadSize()
   * @note I specifically chose 'void*' as a data type to make it easier
   * for beginners to use.  No casting needed.
   * @note No longer boolean. Use available to determine if packets are
   * available. Interrupt flags are now cleared during reads instead of
   * when calling available().
   * @param buf Pointer to a buffer where the data should be written
   * @param len Maximum number of bytes to read into the buffer
   * @code
   * if(radio.available()){
   * }
   * @endcode
   * @return No return value. Use available().
  void read( void* buf, uint8_t len );

The while is simply wrong. Because there are only single packets sent and received in the example, it does not hurt.

Reading all received packets into the same buffer and using only the last is not a good idea IMHO.

Thanks for confirming my hunch.

I added this as an "issue" on github and got an interesting response

To me, the while does not make sense in any context.

What are your thoughts on this (other than it doesn't make sense):

"4. At high data rates, it is typically best to use a while() loop to clear the buffer even if using interrupts, which prevents the receiver from locking up due to missed interrupts."

I absolutely disagree.

It is best to process all packets when they are available instead of just throwing them away,
reading them is the time consuming part of the processing.

I have never seen the receiver lock under overload.

I have never seen effects that point to a missing interrupt yet
and I run my variant of the driver interrupt based for a couple of months now.

Thanks. Are you aware of any good tutorials for using the nRF24L01+ that discuss these sorts of things? Most of the ones I've found just say "hook it up and use this code," and they don't get into the details.

No, but I'm not into tutorials, too often it seems to me a one-eyed is lecturing blind people about perspective viewing.

Even the better ones have stuff like the "4. At high data rates, it is typically best to use a while() loop to clear the buffer even if using interrupts, which prevents the receiver from locking up due to missed interrupts." in it.

The datasheet of the nRF has all needed information.

Sigh. I was hoping for something at a more intermediate level. I’ll check out the datasheet…