TMRh20 ported to MBED

Fork of TMRh20 by BME SmartLab

Files at this revision

API Documentation at this revision

Comitter:
gume
Date:
Fri Oct 06 20:20:33 2017 +0000
Parent:
5:836f5c6da243
Commit message:
Initial release

Changed in this revision

RF24.cpp Show annotated file Show diff for this revision Revisions of this file
RF24.h Show annotated file Show diff for this revision Revisions of this file
RF24_config.h Show annotated file Show diff for this revision Revisions of this file
nRF24L01.h Show annotated file Show diff for this revision Revisions of this file
diff -r 836f5c6da243 -r 15a3bbf90fe9 RF24.cpp
--- a/RF24.cpp	Mon Mar 28 18:13:17 2016 +0000
+++ b/RF24.cpp	Fri Oct 06 20:20:33 2017 +0000
@@ -12,238 +12,218 @@
 
 /****************************************************************************/
 
-void RF24::csn(int mode)
+void RF24::csn(bool mode)
 {
     csn_pin = mode;
-//    wait_us(5);
-}
-
-/****************************************************************************/
-
-void RF24::ce(int level)
-{
-    ce_pin = level;
+    wait_us(csDelay);
 }
 
 /****************************************************************************/
 
-void RF24::beginTransaction()
+void RF24::ce(bool level)
 {
-    //#if defined (RF24_SPI_TRANSACTIONS)
-    //_SPI.beginTransaction(SPISettings(RF24_SPI_SPEED, MSBFIRST, SPI_MODE0));
-    //#endif
-        
-    csn(LOW);
-    wait_us(5);
+  ce_pin = level;
 }
+
 /****************************************************************************/
 
-void RF24::endTransaction()
-{
+  inline void RF24::beginTransaction() {
+    csn(LOW);
+  }
 
-//    wait_us(5);
+/****************************************************************************/
+
+  inline void RF24::endTransaction() {
     csn(HIGH);
-
-    //#if defined (RF24_SPI_TRANSACTIONS)
-    //_SPI.endTransaction();
-    //#endif
-}
+  }
 
 /****************************************************************************/
 
 uint8_t RF24::read_register(uint8_t reg, uint8_t* buf, uint8_t len)
 {
-    uint8_t status;
-
-    beginTransaction(); //configures the spi settings for RPi, locks mutex and setting csn low
+  uint8_t status;
 
-    status = spi.write( R_REGISTER | ( REGISTER_MASK & reg ) );
-    while ( len-- )
-        *buf++ = spi.write(0x55); // 0xff
+  beginTransaction();
+  status = spi->write( R_REGISTER | ( REGISTER_MASK & reg ) );
+  while ( len-- ){
+    *buf++ = spi->write(0xff);
+  }
+  endTransaction();
 
-    endTransaction(); //unlocks mutex and setting csn high
-
-    return status;
+  return status;
 }
 
 /****************************************************************************/
 
 uint8_t RF24::read_register(uint8_t reg)
 {
-    uint8_t result;
-
-    beginTransaction();
+  uint8_t result;
+  
+  beginTransaction();
+  spi->write( R_REGISTER | ( REGISTER_MASK & reg ) );
+  result = spi->write(0xff);
+  endTransaction();
 
-    spi.write( R_REGISTER | ( REGISTER_MASK & reg ) );
-    result = spi.write(0x55); // 0xff
-
-    endTransaction();
-
-    //printf_P(PSTR("read_register(%02x,%02x)\r\n"),reg,result);
-
-    return result;
+  return result;
 }
 
 /****************************************************************************/
 
 uint8_t RF24::write_register(uint8_t reg, const uint8_t* buf, uint8_t len)
 {
-    uint8_t status;
-
-    //printf_P(PSTR("write_register_more(%02x,%d)\r\n"), reg, len);
-
-    beginTransaction();
+  uint8_t status;
 
-    status = spi.write( W_REGISTER | ( REGISTER_MASK & reg ) );
-    while ( len-- )
-        spi.write(*buf++);
+  beginTransaction();
+  status = spi->write( W_REGISTER | ( REGISTER_MASK & reg ) );
+  while ( len-- )
+    spi->write(*buf++);
+  endTransaction();
 
-    endTransaction();
-
-    return status;
+  return status;
 }
 
 /****************************************************************************/
 
 uint8_t RF24::write_register(uint8_t reg, uint8_t value)
 {
-    uint8_t status;
+  uint8_t status;
 
-    //printf_P(PSTR("write_register(%02x,%02x)\r\n"),reg,value);
-
-    beginTransaction();
+  IF_SERIAL_DEBUG(printf_P(PSTR("write_register(%02x,%02x)\r\n"),reg,value));
 
-    status = spi.write( W_REGISTER | ( REGISTER_MASK & reg ) );
-    spi.write(value);
+  beginTransaction();
+  status = spi->write( W_REGISTER | ( REGISTER_MASK & reg ) );
+  spi->write(value);
+  endTransaction();
 
-    endTransaction();
-
-    return status;
+  return status;
 }
 
 /****************************************************************************/
 
 uint8_t RF24::write_payload(const void* buf, uint8_t data_len, const uint8_t writeType)
 {
-    uint8_t status;
-    const uint8_t* current = reinterpret_cast<const uint8_t*>(buf);
-
-    data_len = rf24_min(data_len, payload_size);
-    uint8_t blank_len = dynamic_payloads_enabled ? 0 : payload_size - data_len;
-
-    //printf_P("[Writing %u bytes %u blanks]\n",data_len,blank_len);
-
-    beginTransaction();
+  uint8_t status;
+  const uint8_t* current = reinterpret_cast<const uint8_t*>(buf);
 
-    status = spi.write( W_TX_PAYLOAD );
-    while ( data_len-- )
-        spi.write(*current++);
-    while ( blank_len-- )
-        spi.write(0);
+   data_len = rf24_min(data_len, payload_size);
+   uint8_t blank_len = dynamic_payloads_enabled ? 0 : payload_size - data_len;
+  
+  //printf("[Writing %u bytes %u blanks]",data_len,blank_len);
+  IF_SERIAL_DEBUG( printf("[Writing %u bytes %u blanks]\n",data_len,blank_len); );
+  
+  beginTransaction();
+  status = spi->write( writeType );
+  while ( data_len-- ) {
+    spi->write(*current++);
+  }
+  while ( blank_len-- ) {
+    spi->write(0);
+  }  
+  endTransaction();
 
-    endTransaction();
-
-    return status;
+  return status;
 }
 
 /****************************************************************************/
 
 uint8_t RF24::read_payload(void* buf, uint8_t data_len)
 {
-    uint8_t status;
-    uint8_t* current = reinterpret_cast<uint8_t*>(buf);
+  uint8_t status;
+  uint8_t* current = reinterpret_cast<uint8_t*>(buf);
 
-    if(data_len > payload_size) data_len = payload_size;
-    uint8_t blank_len = dynamic_payloads_enabled ? 0 : payload_size - data_len;
-
-    //printf_P("[Reading %u bytes %u blanks]\n",data_len,blank_len);
-
-    beginTransaction();
+  if(data_len > payload_size) data_len = payload_size;
+  uint8_t blank_len = dynamic_payloads_enabled ? 0 : payload_size - data_len;
+  
+  //printf("[Reading %u bytes %u blanks]",data_len,blank_len);
 
-    status = spi.write( R_RX_PAYLOAD );
-    while ( data_len-- )
-        *current++ = spi.write(0xff);
-    while ( blank_len-- )
-        spi.write(0xff);
+  IF_SERIAL_DEBUG( printf("[Reading %u bytes %u blanks]\n",data_len,blank_len); );
+  
+  beginTransaction();
+  status = spi->write( R_RX_PAYLOAD );
+  while ( data_len-- ) {
+    *current++ = spi->write(0xFF);
+  }
+  while ( blank_len-- ) {
+    spi->write(0xff);
+  }
+  endTransaction();
 
-    endTransaction();
-
-    return status;
+  return status;
 }
 
 /****************************************************************************/
 
 uint8_t RF24::flush_rx(void)
 {
-    return spiTrans( FLUSH_RX );
+  return spiTrans( FLUSH_RX );
 }
 
 /****************************************************************************/
 
 uint8_t RF24::flush_tx(void)
 {
-    return spiTrans( FLUSH_TX );
+  return spiTrans( FLUSH_TX );
 }
 
 /****************************************************************************/
 
-uint8_t RF24::spiTrans(uint8_t cmd)
-{
-
-    uint8_t status;
+uint8_t RF24::spiTrans(uint8_t cmd){
 
-    //printf_P(PSTR("spiTrans(%02x)\r\n"), cmd);
-
-    beginTransaction();
-    status = spi.write(cmd);
-    endTransaction();
-
-    return status;
+  uint8_t status;
+  
+  beginTransaction();
+  status = spi->write( cmd );
+  endTransaction();
+  
+  return status;
 }
 
 /****************************************************************************/
 
 uint8_t RF24::get_status(void)
 {
-    return spiTrans(NOP);
+  return spiTrans(NOP);
 }
 
 /****************************************************************************/
 #if !defined (MINIMAL)
 void RF24::print_status(uint8_t status)
 {
-    printf_P(PSTR("STATUS\t\t = 0x%02x RX_DR=%x TX_DS=%x MAX_RT=%x RX_P_NO=%x TX_FULL=%x\r\n"),
-             status,
-             (status & _BV(RX_DR))?1:0,
-             (status & _BV(TX_DS))?1:0,
-             (status & _BV(MAX_RT))?1:0,
-             ((status >> RX_P_NO) & 0b111),
-             (status & _BV(TX_FULL))?1:0
-            );
+  printf_P(PSTR("STATUS\t\t = 0x%02x RX_DR=%x TX_DS=%x MAX_RT=%x RX_P_NO=%x TX_FULL=%x\r\n"),
+           status,
+           (status & _BV(RX_DR))?1:0,
+           (status & _BV(TX_DS))?1:0,
+           (status & _BV(MAX_RT))?1:0,
+           ((status >> RX_P_NO) & 0x07),
+           (status & _BV(TX_FULL))?1:0
+          );
 }
 
 /****************************************************************************/
 
 void RF24::print_observe_tx(uint8_t value)
 {
-    printf_P(PSTR("OBSERVE_TX=%02x: POLS_CNT=%x ARC_CNT=%x\r\n"),
-             value,
-             (value >> PLOS_CNT) & 0b1111,
-             (value >> ARC_CNT) & 0b1111
-            );
+  printf_P(PSTR("OBSERVE_TX=%02x: POLS_CNT=%x ARC_CNT=%x\r\n"),
+           value,
+           (value >> PLOS_CNT) & 0x0F,
+           (value >> ARC_CNT) & 0x0F
+          );
 }
 
 /****************************************************************************/
 
 void RF24::print_byte_register(const char* name, uint8_t reg, uint8_t qty)
 {
-    //char extra_tab = strlen_P(name) < 8 ? '\t' : 0;
+  //char extra_tab = strlen_P(name) < 8 ? '\t' : 0;
+  //printf_P(PSTR(PRIPSTR"\t%c ="),name,extra_tab);
+  #if defined (RF24_LINUX)
     printf("%s\t =", name);
-
-    while (qty--)
-        printf_P(PSTR(" 0x%02x"),read_register(reg++));
-
-    printf_P(PSTR("\r\n"));
+  #else
+    printf_P(PSTR(PRIPSTR"\t ="),name);
+  #endif
+  while (qty--)
+    printf_P(PSTR(" 0x%02x"),read_register(reg++));
+  printf_P(PSTR("\r\n"));
 }
 
 /****************************************************************************/
@@ -251,64 +231,59 @@
 void RF24::print_address_register(const char* name, uint8_t reg, uint8_t qty)
 {
 
-    printf("%s\t =",name);
+    printf_P(PSTR(PRIPSTR"\t ="),name);
 
-    while (qty--) {
-        uint8_t buffer[addr_width];
-        read_register(reg++,buffer,sizeof buffer);
+  while (qty--)
+  {
+    uint8_t buffer[addr_width];
+    read_register(reg++,buffer,sizeof buffer);
 
-        printf_P(PSTR(" 0x"));
-        uint8_t* bufptr = buffer + sizeof buffer;
-        while( --bufptr >= buffer )
-            printf_P(PSTR("%02x"),*bufptr);
-    }
+    printf_P(PSTR(" 0x"));
+    uint8_t* bufptr = buffer + sizeof buffer;
+    while( --bufptr >= buffer )
+      printf_P(PSTR("%02x"),*bufptr);
+  }
 
-    printf_P(PSTR("\r\n"));
+  printf_P(PSTR("\r\n"));
 }
-#endif // MINIMAL
+
+#endif
 
 /****************************************************************************/
 
-RF24::RF24(PinName mosi, PinName miso, PinName sck, PinName _cspin, PinName _cepin):
-    ce_pin(_cepin), csn_pin(_cspin), p_variant(false),
-    payload_size(32), dynamic_payloads_enabled(false), addr_width(5), //,pipe0_reading_address(0)
-    spi(mosi, miso, sck)
+RF24::RF24(SPI *spi, PinName _cepin, PinName _cspin):
+  ce_pin(_cepin),csn_pin(_cspin),p_variant(false),
+  payload_size(32), dynamic_payloads_enabled(false),addr_width(5),csDelay(5)//,pipe0_reading_address(0) 
 {
-    //_SPI.begin(csn_pin);
-    spi.frequency(RF24_SPI_SPEED);
-    spi.format(8,0);
-
-    pipe0_reading_address[0]=0;
-
-    mainTimer.start();
-
+  this->spi = spi;
+  pipe0_reading_address[0]=0;
 }
 
 /****************************************************************************/
 
 void RF24::setChannel(uint8_t channel)
 {
-    const uint8_t max_channel = 125;
-    write_register(RF_CH, rf24_min(channel,max_channel));
+  const uint8_t max_channel = 125;
+  write_register(RF_CH,rf24_min(channel,max_channel));
 }
 
 uint8_t RF24::getChannel()
 {
-
-    return read_register(RF_CH);
+  
+  return read_register(RF_CH);
 }
 /****************************************************************************/
 
 void RF24::setPayloadSize(uint8_t size)
 {
-    payload_size = rf24_min(size,32);
+  payload_size = rf24_min(size,32);
 }
 
 /****************************************************************************/
 
 uint8_t RF24::getPayloadSize(void)
 {
-    return payload_size;
+  return payload_size;
 }
 
 /****************************************************************************/
@@ -319,185 +294,115 @@
 static const char rf24_datarate_e_str_1[] PROGMEM = "2MBPS";
 static const char rf24_datarate_e_str_2[] PROGMEM = "250KBPS";
 static const char * const rf24_datarate_e_str_P[] PROGMEM = {
-    rf24_datarate_e_str_0,
-    rf24_datarate_e_str_1,
-    rf24_datarate_e_str_2,
+  rf24_datarate_e_str_0,
+  rf24_datarate_e_str_1,
+  rf24_datarate_e_str_2,
 };
 static const char rf24_model_e_str_0[] PROGMEM = "nRF24L01";
 static const char rf24_model_e_str_1[] PROGMEM = "nRF24L01+";
 static const char * const rf24_model_e_str_P[] PROGMEM = {
-    rf24_model_e_str_0,
-    rf24_model_e_str_1,
+  rf24_model_e_str_0,
+  rf24_model_e_str_1,
 };
 static const char rf24_crclength_e_str_0[] PROGMEM = "Disabled";
 static const char rf24_crclength_e_str_1[] PROGMEM = "8 bits";
 static const char rf24_crclength_e_str_2[] PROGMEM = "16 bits" ;
 static const char * const rf24_crclength_e_str_P[] PROGMEM = {
-    rf24_crclength_e_str_0,
-    rf24_crclength_e_str_1,
-    rf24_crclength_e_str_2,
+  rf24_crclength_e_str_0,
+  rf24_crclength_e_str_1,
+  rf24_crclength_e_str_2,
 };
 static const char rf24_pa_dbm_e_str_0[] PROGMEM = "PA_MIN";
 static const char rf24_pa_dbm_e_str_1[] PROGMEM = "PA_LOW";
 static const char rf24_pa_dbm_e_str_2[] PROGMEM = "PA_HIGH";
 static const char rf24_pa_dbm_e_str_3[] PROGMEM = "PA_MAX";
 static const char * const rf24_pa_dbm_e_str_P[] PROGMEM = {
-    rf24_pa_dbm_e_str_0,
-    rf24_pa_dbm_e_str_1,
-    rf24_pa_dbm_e_str_2,
-    rf24_pa_dbm_e_str_3,
+  rf24_pa_dbm_e_str_0,
+  rf24_pa_dbm_e_str_1,
+  rf24_pa_dbm_e_str_2,
+  rf24_pa_dbm_e_str_3,
 };
 
 void RF24::printDetails(void)
 {
 
-    print_status(get_status());
+  print_status(get_status());
 
-    print_address_register(PSTR("RX_ADDR_P0-1"),RX_ADDR_P0,2);
-    print_byte_register(PSTR("RX_ADDR_P2-5"),RX_ADDR_P2,4);
-    print_address_register(PSTR("TX_ADDR\t"),TX_ADDR);
+  print_address_register(PSTR("RX_ADDR_P0-1"),RX_ADDR_P0,2);
+  print_byte_register(PSTR("RX_ADDR_P2-5"),RX_ADDR_P2,4);
+  print_address_register(PSTR("TX_ADDR\t"),TX_ADDR);
 
-    print_byte_register(PSTR("RX_PW_P0-6"),RX_PW_P0,6);
-    print_byte_register(PSTR("EN_AA\t"),EN_AA);
-    print_byte_register(PSTR("EN_RXADDR"),EN_RXADDR);
-    print_byte_register(PSTR("RF_CH\t"),RF_CH);
-    print_byte_register(PSTR("RF_SETUP"),RF_SETUP);
-    print_byte_register(PSTR("CONFIG\t"),CONFIG);
-    print_byte_register(PSTR("DYNPD/FEATURE"),DYNPD,2);
+  print_byte_register(PSTR("RX_PW_P0-6"),RX_PW_P0,6);
+  print_byte_register(PSTR("EN_AA\t"),EN_AA);
+  print_byte_register(PSTR("EN_RXADDR"),EN_RXADDR);
+  print_byte_register(PSTR("RF_CH\t"),RF_CH);
+  print_byte_register(PSTR("RF_SETUP"),RF_SETUP);
+  print_byte_register(PSTR("CONFIG\t"),NRF_CONFIG);
+  print_byte_register(PSTR("DYNPD/FEATURE"),DYNPD,2);
 
-    printf_P(PSTR("Data Rate\t = " PRIPSTR "\r\n"),pgm_read_word(&rf24_datarate_e_str_P[getDataRate()]));
-    printf_P(PSTR("Model\t\t = " PRIPSTR "\r\n"),pgm_read_word(&rf24_model_e_str_P[isPVariant()]));
-    printf_P(PSTR("CRC Length\t = " PRIPSTR "\r\n"),pgm_read_word(&rf24_crclength_e_str_P[getCRCLength()]));
-    printf_P(PSTR("PA Power\t = " PRIPSTR "\r\n"),  pgm_read_word(&rf24_pa_dbm_e_str_P[getPALevel()]));
+  printf_P(PSTR("Data Rate\t = " PRIPSTR "\r\n"),pgm_read_word(&rf24_datarate_e_str_P[getDataRate()]));
+  printf_P(PSTR("Model\t\t = " PRIPSTR "\r\n"),pgm_read_word(&rf24_model_e_str_P[isPVariant()]));
+  printf_P(PSTR("CRC Length\t = " PRIPSTR "\r\n"),pgm_read_word(&rf24_crclength_e_str_P[getCRCLength()]));
+  printf_P(PSTR("PA Power\t = " PRIPSTR "\r\n"),  pgm_read_word(&rf24_pa_dbm_e_str_P[getPALevel()]));
 
 }
 
 #endif
+
 /****************************************************************************/
 
 bool RF24::begin(void)
 {
-    //printf("RF24::begin\n");
 
-    uint8_t setup=0;
-
-    ce(LOW);
-    csn(HIGH);  // extra
-
-    //wait_ms(100);
-
-    // Must allow the radio time to settle else configuration bits will not necessarily stick.
-    // This is actually only required following power up but some settling time also appears to
-    // be required after resets too. For full coverage, we'll always assume the worst.
-    // Enabling 16b CRC is by far the most obvious case if the wrong timing is used - or skipped.
-    // Technically we require 4.5ms + 14us as a worst case. We'll just call it 5ms for good measure.
-    // WARNING: Delay is based on P-variant whereby non-P *may* require different timing.
-    wait_ms( 5 ) ;
-
-    // Reset CONFIG and enable 16-bit CRC.
-    write_register( CONFIG, 0b00001100 ) ;
-
-    // Set 1500uS (minimum for 32B payload in ESB@250KBPS) timeouts, to make testing a little easier
-    // WARNING: If this is ever lowered, either 250KBS mode with AA is broken or maximum packet
-    // sizes must never be used. See documentation for a more complete explanation.
-    setRetries(5,15);
-
-    // Reset value is MAX
-    //setPALevel( RF24_PA_MAX ) ;
-
-    // check for connected module and if this is a p nRF24l01 variant
-    //
-    if( setDataRate( RF24_250KBPS ) ) {
-        p_variant = true ;
-    }
-    setup = read_register(RF_SETUP);
-    /*if( setup == 0b00001110 )     // register default for nRF24L01P
-    {
-      p_variant = true ;
-    }*/
-
-    // Then set the data rate to the slowest (and most reliable) speed supported by all
-    // hardware.
-    setDataRate( RF24_1MBPS ) ;
-
-    // Initialize CRC and request 2-byte (16bit) CRC
-    //setCRCLength( RF24_CRC_16 ) ;
-
-    // Disable dynamic payloads, to match dynamic_payloads_enabled setting - Reset value is 0
-    toggle_features();
-    write_register(FEATURE,0 );
-    write_register(DYNPD,0);
-
-    // Reset current status
-    // Notice reset and flush is the last thing we do
-    write_register(NRF_STATUS,_BV(RX_DR) | _BV(TX_DS) | _BV(MAX_RT) );
-
-    // Set up default configuration.  Callers can always change it later.
-    // This channel should be universally safe and not bleed over into adjacent
-    // spectrum.
-    setChannel(76);
-
-    // Flush buffers
-    flush_rx();
-    flush_tx();
-
-    powerUp(); //Power up by default when begin() is called
-
-    // Enable PTX, do not write CE high so radio will remain in standby I mode ( 130us max to transition to RX or TX instead of 1500us from powerUp )
-    // PTX should use only 22uA of power
-    write_register(CONFIG, ( read_register(CONFIG) ) & ~_BV(PRIM_RX) );
-
-    // if setup is 0 or ff then there was no response from module
-    return ( setup != 0 && setup != 0xff );
-}
-
-void RF24::begin_MB(void)
-{
-  // Initialize pins
-//  pinMode(ce_pin,OUTPUT);
-//  pinMode(csn_pin,OUTPUT);
-
-  // Initialize spi bus
-  //spi.begin();
-  mainTimer.start();
+  uint8_t setup=0;
 
   ce(LOW);
   csn(HIGH);
+  //wait_ms(100);
 
   // Must allow the radio time to settle else configuration bits will not necessarily stick.
   // This is actually only required following power up but some settling time also appears to
   // be required after resets too. For full coverage, we'll always assume the worst.
   // Enabling 16b CRC is by far the most obvious case if the wrong timing is used - or skipped.
   // Technically we require 4.5ms + 14us as a worst case. We'll just call it 5ms for good measure.
-  // WARNING: wait_ms is based on P-variant whereby non-P *may* require different timing.
+  // WARNING: Delay is based on P-variant whereby non-P *may* require different timing.
   wait_ms( 5 ) ;
 
+  // Reset NRF_CONFIG and enable 16-bit CRC.
+  write_register( NRF_CONFIG, 0x0C ) ;
+
   // Set 1500uS (minimum for 32B payload in ESB@250KBPS) timeouts, to make testing a little easier
   // WARNING: If this is ever lowered, either 250KBS mode with AA is broken or maximum packet
   // sizes must never be used. See documentation for a more complete explanation.
-  write_register(SETUP_RETR,(4 << ARD) | (15 << ARC));
-
-  // Restore our default PA level
-  setPALevel( RF24_PA_MAX ) ;
+  setRetries(5,15);
 
-  // Determine if this is a p or non-p RF24 module and then
-  // reset our data rate back to default value. This works
-  // because a non-P variant won't allow the data rate to
-  // be set to 250Kbps.
+  // Reset value is MAX
+  //setPALevel( RF24_PA_MAX ) ;
+
+  // check for connected module and if this is a p nRF24l01 variant
+  //
   if( setDataRate( RF24_250KBPS ) )
   {
     p_variant = true ;
   }
+  setup = read_register(RF_SETUP);
+  /*if( setup == 0b00001110 )     // register default for nRF24L01P
+  {
+    p_variant = true ;
+  }*/
   
   // Then set the data rate to the slowest (and most reliable) speed supported by all
   // hardware.
   setDataRate( RF24_1MBPS ) ;
 
   // Initialize CRC and request 2-byte (16bit) CRC
-  setCRCLength( RF24_CRC_16 ) ;
-  
-  // Disable dynamic payloads, to match dynamic_payloads_enabled setting
+  //setCRCLength( RF24_CRC_16 ) ;
+
+  // Disable dynamic payloads, to match dynamic_payloads_enabled setting - Reset value is 0
+  toggle_features();
+  write_register(FEATURE,0 );
   write_register(DYNPD,0);
+  dynamic_payloads_enabled = false;
 
   // Reset current status
   // Notice reset and flush is the last thing we do
@@ -511,60 +416,79 @@
   // Flush buffers
   flush_rx();
   flush_tx();
-  
-  // set EN_RXADDRR to 0 to fix pipe 0 from receiving
-  write_register(EN_RXADDR, 0);
+
+  powerUp(); //Power up by default when begin() is called
+
+  // Enable PTX, do not write CE high so radio will remain in standby I mode ( 130us max to transition to RX or TX instead of 1500us from powerUp )
+  // PTX should use only 22uA of power
+  write_register(NRF_CONFIG, ( read_register(NRF_CONFIG) ) & ~_BV(PRIM_RX) );
+
+  // if setup is 0 or ff then there was no response from module
+  return ( setup != 0 && setup != 0xff );
 }
 
+/****************************************************************************/
 
+bool RF24::isChipConnected()
+{
+  uint8_t setup = read_register(SETUP_AW);
+  if(setup >= 1 && setup <= 3)
+  {
+    return true;
+  }
+
+  return false;
+}
 
 /****************************************************************************/
 
 void RF24::startListening(void)
 {
-
-    powerUp();
+ #if !defined (RF24_TINY) && ! defined(LITTLEWIRE)
+  powerUp();
+ #endif
+  write_register(NRF_CONFIG, read_register(NRF_CONFIG) | _BV(PRIM_RX));
+  write_register(NRF_STATUS, _BV(RX_DR) | _BV(TX_DS) | _BV(MAX_RT) );
+  ce(HIGH);
+  // Restore the pipe0 adddress, if exists
+  if (pipe0_reading_address[0] > 0){
+    write_register(RX_ADDR_P0, pipe0_reading_address, addr_width);  
+  }else{
+    closeReadingPipe(0);
+  }
 
-    write_register(CONFIG, read_register(CONFIG) | _BV(PRIM_RX));
-    write_register(NRF_STATUS, _BV(RX_DR) | _BV(TX_DS) | _BV(MAX_RT) );
-    ce(HIGH);
-    // Restore the pipe0 adddress, if exists
-    if (pipe0_reading_address[0] > 0) {
-        write_register(RX_ADDR_P0, pipe0_reading_address, addr_width);
-    } else {
-        closeReadingPipe(0);
-    }
+  // Flush buffers
+  //flush_rx();
+  if(read_register(FEATURE) & _BV(EN_ACK_PAY)){
+    flush_tx();
+  }
 
-    // Flush buffers
-    //flush_rx();
-    if(read_register(FEATURE) & _BV(EN_ACK_PAY)) {
-        flush_tx();
-    }
-
-    // Go!
-    //delayMicroseconds(100);
+  // Go!
+  //delayMicroseconds(100);
 }
 
 /****************************************************************************/
-static const uint8_t child_pipe_enable[] PROGMEM = {
-    ERX_P0, ERX_P1, ERX_P2, ERX_P3, ERX_P4, ERX_P5
+static const uint8_t child_pipe_enable[] PROGMEM =
+{
+  ERX_P0, ERX_P1, ERX_P2, ERX_P3, ERX_P4, ERX_P5
 };
 
 void RF24::stopListening(void)
-{
-    ce(LOW);
-
-    wait_us(txRxDelay);
+{  
+  ce(LOW);
 
-    if(read_register(FEATURE) & _BV(EN_ACK_PAY)) {
-        wait_us(txRxDelay); //200
-        flush_tx();
-    }
-    //flush_rx();
-    write_register(CONFIG, ( read_register(CONFIG) ) & ~_BV(PRIM_RX) );
-    write_register(EN_RXADDR,read_register(EN_RXADDR) | _BV(pgm_read_byte(&child_pipe_enable[0]))); // Enable RX on pipe0
-
-    //delayMicroseconds(100);
+  wait_us(txDelay);
+  
+  if(read_register(FEATURE) & _BV(EN_ACK_PAY)){
+    wait_us(txDelay); //200
+    flush_tx();
+  }
+  //flush_rx();
+  write_register(NRF_CONFIG, ( read_register(NRF_CONFIG) ) & ~_BV(PRIM_RX) );
+ 
+  write_register(EN_RXADDR,read_register(EN_RXADDR) | _BV(pgm_read_byte(&child_pipe_enable[0]))); // Enable RX on pipe0
+  
+  //delayMicroseconds(100);
 
 }
 
@@ -572,8 +496,8 @@
 
 void RF24::powerDown(void)
 {
-    ce(LOW); // Guarantee CE is low on powerDown
-    write_register(CONFIG,read_register(CONFIG) & ~_BV(PWR_UP));
+  ce(LOW); // Guarantee CE is low on powerDown
+  write_register(NRF_CONFIG,read_register(NRF_CONFIG) & ~_BV(PWR_UP));
 }
 
 /****************************************************************************/
@@ -581,29 +505,30 @@
 //Power up now. Radio will not power down unless instructed by MCU for config changes etc.
 void RF24::powerUp(void)
 {
-    uint8_t cfg = read_register(CONFIG);
+   uint8_t cfg = read_register(NRF_CONFIG);
 
-    // if not powered up then power up and wait for the radio to initialize
-    if (!(cfg & _BV(PWR_UP))) {
-        write_register(CONFIG,read_register(CONFIG) | _BV(PWR_UP));
+   // if not powered up then power up and wait for the radio to initialize
+   if (!(cfg & _BV(PWR_UP))){
+      write_register(NRF_CONFIG, cfg | _BV(PWR_UP));
 
-        // For nRF24L01+ to go from power down mode to TX or RX mode it must first pass through stand-by mode.
-        // There must be a delay of Tpd2stby (see Table 16.) after the nRF24L01+ leaves power down mode before
-        // the CEis set high. - Tpd2stby can be up to 5ms per the 1.0 datasheet
-        wait_ms(5);
-    }
+      // For nRF24L01+ to go from power down mode to TX or RX mode it must first pass through stand-by mode.
+      // There must be a delay of Tpd2stby (see Table 16.) after the nRF24L01+ leaves power down mode before
+      // the CEis set high. - Tpd2stby can be up to 5ms per the 1.0 datasheet
+      wait_ms(5);
+   }
 }
 
 /******************************************************************/
-#if defined (FAILURE_HANDLING)
-void RF24::errNotify()
-{
-    printf_P(PSTR("RF24 HARDWARE FAIL: Radio not responding, verify pin connections, wiring, etc.\r\n"));
-#if defined (FAILURE_HANDLING)
+#if defined (FAILURE_HANDLING) || defined (RF24_LINUX)
+void RF24::errNotify(){
+    #if defined (SERIAL_DEBUG) || defined (RF24_LINUX)
+      printf_P(PSTR("RF24 HARDWARE FAIL: Radio not responding, verify pin connections, wiring, etc.\r\n"));
+    #endif
+    #if defined (FAILURE_HANDLING)
     failureDetected = 1;
-#else
+    #else
     delay(5000);
-#endif
+    #endif
 }
 #endif
 /******************************************************************/
@@ -615,38 +540,37 @@
     startFastWrite(buf,len,multicast);
 
     //Wait until complete or failed
-#if defined (FAILURE_HANDLING)
-    uint32_t timer = millis();
-#endif
-
-    while( ! ( get_status()  & ( _BV(TX_DS) | _BV(MAX_RT) ))) {
-#if defined (FAILURE_HANDLING)
-        if(millis() - timer > 85) {
-            errNotify();
-#if defined (FAILURE_HANDLING)
-            return 0;
-#else
-            delay(100);
-#endif
-        }
-#endif
+    #if defined (FAILURE_HANDLING) || defined (RF24_LINUX)
+        uint32_t timer = millis();
+    #endif 
+    
+    while( ! ( get_status()  & ( _BV(TX_DS) | _BV(MAX_RT) ))) { 
+        #if defined (FAILURE_HANDLING) || defined (RF24_LINUX)
+            if(millis() - timer > 95){          
+                errNotify();
+                #if defined (FAILURE_HANDLING)
+                  return 0;     
+                #else
+                  delay(100);
+                #endif
+            }
+        #endif
     }
-
+    
     ce(LOW);
 
     uint8_t status = write_register(NRF_STATUS,_BV(RX_DR) | _BV(TX_DS) | _BV(MAX_RT) );
 
-    //Max retries exceeded
-    if( status & _BV(MAX_RT)) {
-        flush_tx(); //Only going to be 1 packet int the FIFO at a time using this method, so just flush
-        return 0;
-    }
+  //Max retries exceeded
+  if( status & _BV(MAX_RT)){
+    flush_tx(); //Only going to be 1 packet int the FIFO at a time using this method, so just flush
+    return 0;
+  }
     //TX OK 1 or 0
-    return 1;
+  return 1;
 }
 
-bool RF24::write( const void* buf, uint8_t len )
-{
+bool RF24::write( const void* buf, uint8_t len ){
     return write(buf,len,0);
 }
 /****************************************************************************/
@@ -659,24 +583,22 @@
     //This way the FIFO will fill up and allow blocking until packets go through
     //The radio will auto-clear everything in the FIFO as long as CE remains high
 
-    uint32_t timer = mainTimer.read_ms();                            //Get the time that the payload transmission started
+    uint32_t timer = millis();                            //Get the time that the payload transmission started
 
     while( ( get_status()  & ( _BV(TX_FULL) ))) {         //Blocking only if FIFO is full. This will loop and block until TX is successful or timeout
 
-        if( get_status() & _BV(MAX_RT)) {                     //If MAX Retries have been reached
+        if( get_status() & _BV(MAX_RT)){                      //If MAX Retries have been reached
             reUseTX();                                        //Set re-transmit and clear the MAX_RT interrupt flag
-            if(mainTimer.read_ms() - timer > timeout) {
-                return 0;    //If this payload has exceeded the user-defined timeout, exit and return 0
-            }
+            if(millis() - timer > timeout){ return 0; }       //If this payload has exceeded the user-defined timeout, exit and return 0
         }
-#if defined (FAILURE_HANDLING)
-        if(mainTimer.read_ms() - timer > (timeout+85) ) {
-            errNotify();
-#if defined (FAILURE_HANDLING)
-            return 0;
-#endif
-        }
-#endif
+        #if defined (FAILURE_HANDLING) || defined (RF24_LINUX)
+            if(millis() - timer > (timeout+95) ){           
+                errNotify();
+                #if defined (FAILURE_HANDLING)
+                return 0;           
+                #endif              
+            }
+        #endif
 
     }
 
@@ -688,8 +610,7 @@
 
 /****************************************************************************/
 
-void RF24::reUseTX()
-{
+void RF24::reUseTX(){
     write_register(NRF_STATUS,_BV(MAX_RT) );              //Clear max retry flag
     spiTrans( REUSE_TX_PL );
     ce(LOW);                                          //Re-Transfer packet
@@ -705,35 +626,34 @@
     //Return 0 so the user can control the retrys and set a timer or failure counter if required
     //The radio will auto-clear everything in the FIFO as long as CE remains high
 
-#if defined (FAILURE_HANDLING)
-    uint32_t timer = millis();
-#endif
-
+    #if defined (FAILURE_HANDLING) || defined (RF24_LINUX)
+        uint32_t timer = millis();
+    #endif
+    
     while( ( get_status()  & ( _BV(TX_FULL) ))) {             //Blocking only if FIFO is full. This will loop and block until TX is successful or fail
 
-        if( get_status() & _BV(MAX_RT)) {
+        if( get_status() & _BV(MAX_RT)){
             //reUseTX();                                          //Set re-transmit
             write_register(NRF_STATUS,_BV(MAX_RT) );              //Clear max retry flag
             return 0;                                         //Return 0. The previous payload has been retransmitted
-            //From the user perspective, if you get a 0, just keep trying to send the same payload
+                                                              //From the user perspective, if you get a 0, just keep trying to send the same payload
         }
-#if defined (FAILURE_HANDLING)
-        if(millis() - timer > 85 ) {
-            errNotify();
-#if defined (FAILURE_HANDLING)
-            return 0;
-#endif
-        }
-#endif
+        #if defined (FAILURE_HANDLING) || defined (RF24_LINUX)
+            if(millis() - timer > 95 ){         
+                errNotify();
+                #if defined (FAILURE_HANDLING)
+                return 0;                           
+                #endif
+            }
+        #endif
     }
-    //Start Writing
+             //Start Writing
     startFastWrite(buf,len,multicast);
 
     return 1;
 }
 
-bool RF24::writeFast( const void* buf, uint8_t len )
-{
+bool RF24::writeFast( const void* buf, uint8_t len ){
     return writeFast(buf,len,0);
 }
 
@@ -744,12 +664,11 @@
 //Otherwise we enter Standby-II mode, which is still faster than standby mode
 //Also, we remove the need to keep writing the config register over and over and delaying for 150 us each time if sending a stream of data
 
-void RF24::startFastWrite( const void* buf, uint8_t len, const bool multicast, bool startTx)  //TMRh20
-{
+void RF24::startFastWrite( const void* buf, uint8_t len, const bool multicast, bool startTx){ //TMRh20
 
     //write_payload( buf,len);
     write_payload( buf, len,multicast ? W_TX_PAYLOAD_NO_ACK : W_TX_PAYLOAD ) ;
-    if(startTx) {
+    if(startTx){
         ce(HIGH);
     }
 
@@ -759,50 +678,48 @@
 
 //Added the original startWrite back in so users can still use interrupts, ack payloads, etc
 //Allows the library to pass all tests
-void RF24::startWrite( const void* buf, uint8_t len, const bool multicast )
-{
+void RF24::startWrite( const void* buf, uint8_t len, const bool multicast ){
 
-    // Send the payload
+  // Send the payload
 
-    //write_payload( buf, len );
-    write_payload( buf, len,multicast? W_TX_PAYLOAD_NO_ACK : W_TX_PAYLOAD ) ;
-    ce(HIGH);
-    // Maybe wait for 10 us
-    //  delayMicroseconds(10);
-    ce(LOW);
+  //write_payload( buf, len );
+  write_payload( buf, len,multicast? W_TX_PAYLOAD_NO_ACK : W_TX_PAYLOAD ) ;
+  ce(HIGH);
+  #if defined(CORE_TEENSY) || !defined(ARDUINO) || defined (RF24_SPIDEV) || defined (RF24_DUE)
+    delayMicroseconds(10);
+  #endif
+  ce(LOW);
 
 
 }
 
 /****************************************************************************/
 
-bool RF24::rxFifoFull()
-{
+bool RF24::rxFifoFull(){
     return read_register(FIFO_STATUS) & _BV(RX_FULL);
 }
 /****************************************************************************/
 
-bool RF24::txStandBy()
-{
+bool RF24::txStandBy(){
 
-#if defined (FAILURE_HANDLING)
-    uint32_t timeout = millis();
-#endif
-    while( ! (read_register(FIFO_STATUS) & _BV(TX_EMPTY)) ) {
-        if( get_status() & _BV(MAX_RT)) {
+    #if defined (FAILURE_HANDLING) || defined (RF24_LINUX)
+        uint32_t timeout = millis();
+    #endif
+    while( ! (read_register(FIFO_STATUS) & _BV(TX_EMPTY)) ){
+        if( get_status() & _BV(MAX_RT)){
             write_register(NRF_STATUS,_BV(MAX_RT) );
             ce(LOW);
             flush_tx();    //Non blocking, flush the data
             return 0;
         }
-#if defined (FAILURE_HANDLING)
-        if( millis() - timeout > 85) {
-            errNotify();
-#if defined (FAILURE_HANDLING)
-            return 0;
-#endif
-        }
-#endif
+        #if defined (FAILURE_HANDLING) || defined (RF24_LINUX)
+            if( millis() - timeout > 95){
+                errNotify();
+                #if defined (FAILURE_HANDLING)
+                return 0;   
+                #endif
+            }
+        #endif
     }
 
     ce(LOW);               //Set STANDBY-I mode
@@ -811,36 +728,34 @@
 
 /****************************************************************************/
 
-bool RF24::txStandBy(uint32_t timeout, bool startTx)
-{
+bool RF24::txStandBy(uint32_t timeout, bool startTx){
 
-    if(startTx) {
-        stopListening();
-        ce(HIGH);
+    if(startTx){
+      stopListening();
+      ce(HIGH);
     }
-    uint32_t start = mainTimer.read_ms();
+    uint32_t start = millis();
 
-    while( ! (read_register(FIFO_STATUS) & _BV(TX_EMPTY)) ) {
-        if( get_status() & _BV(MAX_RT)) {
+    while( ! (read_register(FIFO_STATUS) & _BV(TX_EMPTY)) ){
+        if( get_status() & _BV(MAX_RT)){
             write_register(NRF_STATUS,_BV(MAX_RT) );
-            ce(LOW);                                          //Set re-transmit
-            ce(HIGH);
-            if(mainTimer.read_ms() - start >= timeout) {
-                ce(LOW);
-                flush_tx();
-                return 0;
-            }
+                ce(LOW);                                          //Set re-transmit
+                ce(HIGH);
+                if(millis() - start >= timeout){
+                    ce(LOW); flush_tx(); return 0;
+                }
         }
-#if defined (FAILURE_HANDLING)
-        if( mainTimer.read_ms() - start > (timeout+85)) {
-            errNotify();
-#if defined (FAILURE_HANDLING)
-            return 0;
-#endif
-        }
-#endif
+        #if defined (FAILURE_HANDLING) || defined (RF24_LINUX)
+            if( millis() - start > (timeout+95)){
+                errNotify();
+                #if defined (FAILURE_HANDLING)
+                return 0;   
+                #endif
+            }
+        #endif
     }
 
+    
     ce(LOW);                   //Set STANDBY-I mode
     return 1;
 
@@ -848,70 +763,67 @@
 
 /****************************************************************************/
 
-void RF24::maskIRQ(bool tx, bool fail, bool rx)
-{
+void RF24::maskIRQ(bool tx, bool fail, bool rx){
 
-    uint8_t config = read_register(CONFIG);
+    uint8_t config = read_register(NRF_CONFIG);
     /* clear the interrupt flags */
     config &= ~(1 << MASK_MAX_RT | 1 << MASK_TX_DS | 1 << MASK_RX_DR);
     /* set the specified interrupt flags */
     config |= fail << MASK_MAX_RT | tx << MASK_TX_DS | rx << MASK_RX_DR;
-    write_register(CONFIG, config);
+    write_register(NRF_CONFIG, config);
 }
 
 /****************************************************************************/
 
 uint8_t RF24::getDynamicPayloadSize(void)
 {
-    uint8_t result = 0;
-
-    beginTransaction();
+  uint8_t result = 0;
 
-    spi.write( R_RX_PL_WID );
-    result = spi.write(0xff);
+  beginTransaction();
+  spi->write( R_RX_PL_WID );
+  result = spi->write(0xff);
+  endTransaction();
 
-    endTransaction();
-
-    return result;
+  if(result > 32) { flush_rx(); delay(2); return 0; }
+  return result;
 }
 
 /****************************************************************************/
 
 bool RF24::available(void)
 {
-    return available(NULL);
+  return available(NULL);
 }
 
 /****************************************************************************/
 
 bool RF24::available(uint8_t* pipe_num)
 {
-    if (!( read_register(FIFO_STATUS) & _BV(RX_EMPTY) )) {
+  if (!( read_register(FIFO_STATUS) & _BV(RX_EMPTY) )){
 
-        // If the caller wants the pipe number, include that
-        if ( pipe_num ) {
-            uint8_t status = get_status();
-            *pipe_num = ( status >> RX_P_NO ) & 0b111;
-        }
-        return 1;
+    // If the caller wants the pipe number, include that
+    if ( pipe_num ){
+      uint8_t status = get_status();
+      *pipe_num = ( status >> RX_P_NO ) & 0x07;
     }
+    return 1;
+  }
 
 
-    return 0;
+  return 0;
 
 
 }
 
 /****************************************************************************/
 
-void RF24::read( void* buf, uint8_t len )
-{
+void RF24::read( void* buf, uint8_t len ){
 
-    // Fetch the payload
-    read_payload( buf, len );
+  // Fetch the payload
+  read_payload( buf, len );
 
-    //Clear the two possible interrupt flags with one command
-    write_register(NRF_STATUS,_BV(RX_DR) | _BV(MAX_RT) | _BV(TX_DS) );
+  //Clear the two possible interrupt flags with one command
+  write_register(NRF_STATUS,_BV(RX_DR) | _BV(MAX_RT) | _BV(TX_DS) );
 
 }
 
@@ -919,87 +831,92 @@
 
 void RF24::whatHappened(bool& tx_ok,bool& tx_fail,bool& rx_ready)
 {
-    // Read the status & reset the status in one easy call
-    // Or is that such a good idea?
-    uint8_t status = write_register(NRF_STATUS,_BV(RX_DR) | _BV(TX_DS) | _BV(MAX_RT) );
+  // Read the status & reset the status in one easy call
+  // Or is that such a good idea?
+  uint8_t status = write_register(NRF_STATUS,_BV(RX_DR) | _BV(TX_DS) | _BV(MAX_RT) );
 
-    // Report to the user what happened
-    tx_ok = status & _BV(TX_DS);
-    tx_fail = status & _BV(MAX_RT);
-    rx_ready = status & _BV(RX_DR);
+  // Report to the user what happened
+  tx_ok = status & _BV(TX_DS);
+  tx_fail = status & _BV(MAX_RT);
+  rx_ready = status & _BV(RX_DR);
 }
 
 /****************************************************************************/
 
 void RF24::openWritingPipe(uint64_t value)
 {
-    // Note that AVR 8-bit uC's store this LSB first, and the NRF24L01(+)
-    // expects it LSB first too, so we're good.
+  // Note that AVR 8-bit uC's store this LSB first, and the NRF24L01(+)
+  // expects it LSB first too, so we're good.
 
-    write_register(RX_ADDR_P0, reinterpret_cast<uint8_t*>(&value), addr_width);
-    write_register(TX_ADDR, reinterpret_cast<uint8_t*>(&value), addr_width);
-
-
-    //const uint8_t max_payload_size = 32;
-    //write_register(RX_PW_P0,rf24_min(payload_size,max_payload_size));
-    write_register(RX_PW_P0,payload_size);
+  write_register(RX_ADDR_P0, reinterpret_cast<uint8_t*>(&value), addr_width);
+  write_register(TX_ADDR, reinterpret_cast<uint8_t*>(&value), addr_width);
+  
+  
+  //const uint8_t max_payload_size = 32;
+  //write_register(RX_PW_P0,rf24_min(payload_size,max_payload_size));
+  write_register(RX_PW_P0,payload_size);
 }
 
 /****************************************************************************/
 void RF24::openWritingPipe(const uint8_t *address)
 {
-    // Note that AVR 8-bit uC's store this LSB first, and the NRF24L01(+)
-    // expects it LSB first too, so we're good.
+  // Note that AVR 8-bit uC's store this LSB first, and the NRF24L01(+)
+  // expects it LSB first too, so we're good.
 
-    write_register(RX_ADDR_P0,address, addr_width);
-    write_register(TX_ADDR, address, addr_width);
+  write_register(RX_ADDR_P0,address, addr_width);
+  write_register(TX_ADDR, address, addr_width);
 
-    //const uint8_t max_payload_size = 32;
-    //write_register(RX_PW_P0,rf24_min(payload_size,max_payload_size));
-    write_register(RX_PW_P0,payload_size);
+  //const uint8_t max_payload_size = 32;
+  //write_register(RX_PW_P0,rf24_min(payload_size,max_payload_size));
+  write_register(RX_PW_P0,payload_size);
 }
 
 /****************************************************************************/
-static const uint8_t child_pipe[] PROGMEM = {
-    RX_ADDR_P0, RX_ADDR_P1, RX_ADDR_P2, RX_ADDR_P3, RX_ADDR_P4, RX_ADDR_P5
+static const uint8_t child_pipe[] PROGMEM =
+{
+  RX_ADDR_P0, RX_ADDR_P1, RX_ADDR_P2, RX_ADDR_P3, RX_ADDR_P4, RX_ADDR_P5
 };
-static const uint8_t child_payload_size[] PROGMEM = {
-    RX_PW_P0, RX_PW_P1, RX_PW_P2, RX_PW_P3, RX_PW_P4, RX_PW_P5
+static const uint8_t child_payload_size[] PROGMEM =
+{
+  RX_PW_P0, RX_PW_P1, RX_PW_P2, RX_PW_P3, RX_PW_P4, RX_PW_P5
 };
 
 
 void RF24::openReadingPipe(uint8_t child, uint64_t address)
 {
-    // If this is pipe 0, cache the address.  This is needed because
-    // openWritingPipe() will overwrite the pipe 0 address, so
-    // startListening() will have to restore it.
-    if (child == 0) {
-        memcpy(pipe0_reading_address,&address,addr_width);
-    }
+  // If this is pipe 0, cache the address.  This is needed because
+  // openWritingPipe() will overwrite the pipe 0 address, so
+  // startListening() will have to restore it.
+  if (child == 0){
+    memcpy(pipe0_reading_address,&address,addr_width);
+  }
 
-    if (child <= 6) {
-        // For pipes 2-5, only write the LSB
-        if ( child < 2 )
-            write_register(pgm_read_byte(&child_pipe[child]), reinterpret_cast<const uint8_t*>(&address), addr_width);
-        else
-            write_register(pgm_read_byte(&child_pipe[child]), reinterpret_cast<const uint8_t*>(&address), 1);
+  if (child <= 6)
+  {
+    // For pipes 2-5, only write the LSB
+    if ( child < 2 )
+      write_register(pgm_read_byte(&child_pipe[child]), reinterpret_cast<const uint8_t*>(&address), addr_width);
+    else
+      write_register(pgm_read_byte(&child_pipe[child]), reinterpret_cast<const uint8_t*>(&address), 1);
 
-        write_register(pgm_read_byte(&child_payload_size[child]),payload_size);
+    write_register(pgm_read_byte(&child_payload_size[child]),payload_size);
 
-        // Note it would be more efficient to set all of the bits for all open
-        // pipes at once.  However, I thought it would make the calling code
-        // more simple to do it this way.
-        write_register(EN_RXADDR,read_register(EN_RXADDR) | _BV(pgm_read_byte(&child_pipe_enable[child])));
-    }
+    // Note it would be more efficient to set all of the bits for all open
+    // pipes at once.  However, I thought it would make the calling code
+    // more simple to do it this way.
+    write_register(EN_RXADDR,read_register(EN_RXADDR) | _BV(pgm_read_byte(&child_pipe_enable[child])));
+  }
 }
 
 /****************************************************************************/
-void RF24::setAddressWidth(uint8_t a_width)
-{
+void RF24::setAddressWidth(uint8_t a_width){
 
-    if(a_width -= 2) {
+    if(a_width -= 2){
         write_register(SETUP_AW,a_width%4);
         addr_width = (a_width%4) + 2;
+    }else{
+        write_register(SETUP_AW,0);
+        addr_width = 2;
     }
 
 }
@@ -1008,47 +925,44 @@
 
 void RF24::openReadingPipe(uint8_t child, const uint8_t *address)
 {
-    // If this is pipe 0, cache the address.  This is needed because
-    // openWritingPipe() will overwrite the pipe 0 address, so
-    // startListening() will have to restore it.
-    if (child == 0) {
-        memcpy(pipe0_reading_address,address,addr_width);
+  // If this is pipe 0, cache the address.  This is needed because
+  // openWritingPipe() will overwrite the pipe 0 address, so
+  // startListening() will have to restore it.
+  if (child == 0){
+    memcpy(pipe0_reading_address,address,addr_width);
+  }
+  if (child <= 6)
+  {
+    // For pipes 2-5, only write the LSB
+    if ( child < 2 ){
+      write_register(pgm_read_byte(&child_pipe[child]), address, addr_width);
+    }else{
+      write_register(pgm_read_byte(&child_pipe[child]), address, 1);
     }
-    if (child <= 6) {
-        // For pipes 2-5, only write the LSB
-        if ( child < 2 ) {
-            write_register(pgm_read_byte(&child_pipe[child]), address, addr_width);
-        } else {
-            write_register(pgm_read_byte(&child_pipe[child]), address, 1);
-        }
-        write_register(pgm_read_byte(&child_payload_size[child]),payload_size);
+    write_register(pgm_read_byte(&child_payload_size[child]),payload_size);
 
-        // Note it would be more efficient to set all of the bits for all open
-        // pipes at once.  However, I thought it would make the calling code
-        // more simple to do it this way.
-        write_register(EN_RXADDR,read_register(EN_RXADDR) | _BV(pgm_read_byte(&child_pipe_enable[child])));
+    // Note it would be more efficient to set all of the bits for all open
+    // pipes at once.  However, I thought it would make the calling code
+    // more simple to do it this way.
+    write_register(EN_RXADDR,read_register(EN_RXADDR) | _BV(pgm_read_byte(&child_pipe_enable[child])));
 
-    }
+  }
 }
 
 /****************************************************************************/
 
 void RF24::closeReadingPipe( uint8_t pipe )
 {
-    write_register(EN_RXADDR,read_register(EN_RXADDR) & ~_BV(pgm_read_byte(&child_pipe_enable[pipe])));
+  write_register(EN_RXADDR,read_register(EN_RXADDR) & ~_BV(pgm_read_byte(&child_pipe_enable[pipe])));
 }
 
 /****************************************************************************/
 
 void RF24::toggle_features(void)
 {
-    //printf_P("ACTIVATE");
-    
     beginTransaction();
-
-    spi.write( ACTIVATE );
-    spi.write( 0x73 );
-
+    spi->write( ACTIVATE );
+    spi->write( 0x73 );
     endTransaction();
 }
 
@@ -1056,54 +970,74 @@
 
 void RF24::enableDynamicPayloads(void)
 {
-    // Enable dynamic payload throughout the system
+  // Enable dynamic payload throughout the system
 
     //toggle_features();
     write_register(FEATURE,read_register(FEATURE) | _BV(EN_DPL) );
 
-    //printf_P("FEATURE=%i\r\n",read_register(FEATURE));
+
+  IF_SERIAL_DEBUG(printf("FEATURE=%i\r\n",read_register(FEATURE)));
+
+  // Enable dynamic payload on all pipes
+  //
+  // Not sure the use case of only having dynamic payload on certain
+  // pipes, so the library does not support it.
+  write_register(DYNPD,read_register(DYNPD) | _BV(DPL_P5) | _BV(DPL_P4) | _BV(DPL_P3) | _BV(DPL_P2) | _BV(DPL_P1) | _BV(DPL_P0));
+
+  dynamic_payloads_enabled = true;
+}
 
-    // Enable dynamic payload on all pipes
-    //
-    // Not sure the use case of only having dynamic payload on certain
-    // pipes, so the library does not support it.
-    write_register(DYNPD,read_register(DYNPD) | _BV(DPL_P5) | _BV(DPL_P4) | _BV(DPL_P3) | _BV(DPL_P2) | _BV(DPL_P1) | _BV(DPL_P0));
+/****************************************************************************/
+void RF24::disableDynamicPayloads(void)
+{
+  // Disables dynamic payload throughout the system.  Also disables Ack Payloads
+
+  //toggle_features();
+  write_register(FEATURE, 0);
+
 
-    dynamic_payloads_enabled = true;
+  IF_SERIAL_DEBUG(printf("FEATURE=%i\r\n",read_register(FEATURE)));
+
+  // Disable dynamic payload on all pipes
+  //
+  // Not sure the use case of only having dynamic payload on certain
+  // pipes, so the library does not support it.
+  write_register(DYNPD, 0);
+
+  dynamic_payloads_enabled = false;
 }
 
 /****************************************************************************/
 
 void RF24::enableAckPayload(void)
 {
-    //
-    // enable ack payload and dynamic payload features
-    //
+  //
+  // enable ack payload and dynamic payload features
+  //
 
     //toggle_features();
     write_register(FEATURE,read_register(FEATURE) | _BV(EN_ACK_PAY) | _BV(EN_DPL) );
 
-    //printf_P("FEATURE=%i\r\n",read_register(FEATURE));
+  IF_SERIAL_DEBUG(printf("FEATURE=%i\r\n",read_register(FEATURE)));
 
-    //
-    // Enable dynamic payload on pipes 0 & 1
-    //
+  //
+  // Enable dynamic payload on pipes 0 & 1
+  //
 
-    write_register(DYNPD,read_register(DYNPD) | _BV(DPL_P1) | _BV(DPL_P0));
-    dynamic_payloads_enabled = true;
+  write_register(DYNPD,read_register(DYNPD) | _BV(DPL_P1) | _BV(DPL_P0));
+  dynamic_payloads_enabled = true;
 }
 
 /****************************************************************************/
 
-void RF24::enableDynamicAck(void)
-{
-    //
-    // enable dynamic ack features
-    //
+void RF24::enableDynamicAck(void){
+  //
+  // enable dynamic ack features
+  //
     //toggle_features();
     write_register(FEATURE,read_register(FEATURE) | _BV(EN_DYN_ACK) );
 
-    //printf_P("FEATURE=%i\r\n",read_register(FEATURE));
+  IF_SERIAL_DEBUG(printf("FEATURE=%i\r\n",read_register(FEATURE)));
 
 
 }
@@ -1112,72 +1046,74 @@
 
 void RF24::writeAckPayload(uint8_t pipe, const void* buf, uint8_t len)
 {
-    const uint8_t* current = reinterpret_cast<const uint8_t*>(buf);
+  const uint8_t* current = reinterpret_cast<const uint8_t*>(buf);
 
-    const uint8_t max_payload_size = 32;
-    uint8_t data_len = rf24_min(len, max_payload_size);
-
-    beginTransaction();
+  uint8_t data_len = rf24_min(len,32);
 
-    spi.write( W_ACK_PAYLOAD | ( pipe & 7 ) );
-    while ( data_len-- )
-        spi.write(*current++);
+  beginTransaction();
+  spi->write(W_ACK_PAYLOAD | ( pipe & 0x07 ) );
 
-    endTransaction();
-
+  while ( data_len-- )
+    spi->write(*current++);
+  endTransaction();
+    
 }
 
 /****************************************************************************/
 
 bool RF24::isAckPayloadAvailable(void)
 {
-    return ! (read_register(FIFO_STATUS) & _BV(RX_EMPTY));
+  return ! (read_register(FIFO_STATUS) & _BV(RX_EMPTY));
 }
 
 /****************************************************************************/
 
 bool RF24::isPVariant(void)
 {
-    return p_variant ;
+  return p_variant ;
 }
 
 /****************************************************************************/
 
 void RF24::setAutoAck(bool enable)
 {
-    if ( enable )
-        write_register(EN_AA, 0b111111);
-    else
-        write_register(EN_AA, 0);
+  if ( enable )
+    write_register(EN_AA, 0x3F);
+  else
+    write_register(EN_AA, 0);
 }
 
 /****************************************************************************/
 
 void RF24::setAutoAck( uint8_t pipe, bool enable )
 {
-    if ( pipe <= 6 ) {
-        uint8_t en_aa = read_register( EN_AA ) ;
-        if( enable ) {
-            en_aa |= _BV(pipe) ;
-        } else {
-            en_aa &= ~_BV(pipe) ;
-        }
-        write_register( EN_AA, en_aa ) ;
+  if ( pipe <= 6 )
+  {
+    uint8_t en_aa = read_register( EN_AA ) ;
+    if( enable )
+    {
+      en_aa |= _BV(pipe) ;
     }
+    else
+    {
+      en_aa &= ~_BV(pipe) ;
+    }
+    write_register( EN_AA, en_aa ) ;
+  }
 }
 
 /****************************************************************************/
 
 bool RF24::testCarrier(void)
 {
-    return ( read_register(CD) & 1 );
+  return ( read_register(CD) & 1 );
 }
 
 /****************************************************************************/
 
 bool RF24::testRPD(void)
 {
-    return ( read_register(RPD) & 1 ) ;
+  return ( read_register(RPD) & 1 ) ;
 }
 
 /****************************************************************************/
@@ -1185,16 +1121,16 @@
 void RF24::setPALevel(uint8_t level)
 {
 
-    uint8_t setup = read_register(RF_SETUP) & 0b11111000;
+  uint8_t setup = read_register(RF_SETUP) & 0xF8;
 
-    if(level > 3) {                       // If invalid level, go to max PA
-        level = (RF24_PA_MAX << 1) + 1;       // +1 to support the SI24R1 chip extra bit
-    } else {
-        level = (level << 1) + 1;         // Else set level as requested
-    }
+  if(level > 3){                        // If invalid level, go to max PA
+      level = (RF24_PA_MAX << 1) + 1;       // +1 to support the SI24R1 chip extra bit
+  }else{
+      level = (level << 1) + 1;         // Else set level as requested
+  }
 
 
-    write_register( RF_SETUP, setup |= level ) ;  // Write it to the chip
+  write_register( RF_SETUP, setup |= level ) ;  // Write it to the chip
 }
 
 /****************************************************************************/
@@ -1202,112 +1138,139 @@
 uint8_t RF24::getPALevel(void)
 {
 
-    return (read_register(RF_SETUP) & (_BV(RF_PWR_LOW) | _BV(RF_PWR_HIGH))) >> 1 ;
+  return (read_register(RF_SETUP) & (_BV(RF_PWR_LOW) | _BV(RF_PWR_HIGH))) >> 1 ;
 }
 
 /****************************************************************************/
 
 bool RF24::setDataRate(rf24_datarate_e speed)
 {
-    bool result = false;
-    uint8_t setup = read_register(RF_SETUP) ;
-
-    // HIGH and LOW '00' is 1Mbs - our default
-    setup &= ~(_BV(RF_DR_LOW) | _BV(RF_DR_HIGH)) ;
-
-    txRxDelay=250;
+  bool result = false;
+  uint8_t setup = read_register(RF_SETUP) ;
 
-    if( speed == RF24_250KBPS ) {
-        // Must set the RF_DR_LOW to 1; RF_DR_HIGH (used to be RF_DR) is already 0
-        // Making it '10'.
-        setup |= _BV( RF_DR_LOW ) ;
-        txRxDelay=450;
-    } else {
-        // Set 2Mbs, RF_DR (RF_DR_HIGH) is set 1
-        // Making it '01'
-        if ( speed == RF24_2MBPS ) {
-            setup |= _BV(RF_DR_HIGH);
-            txRxDelay=190;
-        }
+  // HIGH and LOW '00' is 1Mbs - our default
+  setup &= ~(_BV(RF_DR_LOW) | _BV(RF_DR_HIGH)) ;
+  
+  #if defined(__arm__) || defined (RF24_LINUX) || defined (__ARDUINO_X86__)
+    txDelay=250;
+  #else //16Mhz Arduino
+    txDelay=85;
+  #endif
+  if( speed == RF24_250KBPS )
+  {
+    // Must set the RF_DR_LOW to 1; RF_DR_HIGH (used to be RF_DR) is already 0
+    // Making it '10'.
+    setup |= _BV( RF_DR_LOW ) ;
+  #if defined(__arm__) || defined (RF24_LINUX) || defined (__ARDUINO_X86__)
+    txDelay=450;
+  #else //16Mhz Arduino
+    txDelay=155;
+  #endif
+  }
+  else
+  {
+    // Set 2Mbs, RF_DR (RF_DR_HIGH) is set 1
+    // Making it '01'
+    if ( speed == RF24_2MBPS )
+    {
+      setup |= _BV(RF_DR_HIGH);
+      #if defined(__arm__) || defined (RF24_LINUX) || defined (__ARDUINO_X86__)
+      txDelay=190;
+      #else //16Mhz Arduino   
+      txDelay=65;
+      #endif
     }
-    write_register(RF_SETUP,setup);
+  }
+  write_register(RF_SETUP,setup);
 
-    // Verify our result
-    if ( read_register(RF_SETUP) == setup ) {
-        result = true;
-    }
-    return result;
+  // Verify our result
+  if ( read_register(RF_SETUP) == setup )
+  {
+    result = true;
+  }
+  return result;
 }
 
 /****************************************************************************/
 
 rf24_datarate_e RF24::getDataRate( void )
 {
-    rf24_datarate_e result ;
-    uint8_t dr = read_register(RF_SETUP) & (_BV(RF_DR_LOW) | _BV(RF_DR_HIGH));
+  rf24_datarate_e result ;
+  uint8_t dr = read_register(RF_SETUP) & (_BV(RF_DR_LOW) | _BV(RF_DR_HIGH));
 
-    // switch uses RAM (evil!)
-    // Order matters in our case below
-    if ( dr == _BV(RF_DR_LOW) ) {
-        // '10' = 250KBPS
-        result = RF24_250KBPS ;
-    } else if ( dr == _BV(RF_DR_HIGH) ) {
-        // '01' = 2MBPS
-        result = RF24_2MBPS ;
-    } else {
-        // '00' = 1MBPS
-        result = RF24_1MBPS ;
-    }
-    return result ;
+  // switch uses RAM (evil!)
+  // Order matters in our case below
+  if ( dr == _BV(RF_DR_LOW) )
+  {
+    // '10' = 250KBPS
+    result = RF24_250KBPS ;
+  }
+  else if ( dr == _BV(RF_DR_HIGH) )
+  {
+    // '01' = 2MBPS
+    result = RF24_2MBPS ;
+  }
+  else
+  {
+    // '00' = 1MBPS
+    result = RF24_1MBPS ;
+  }
+  return result ;
 }
 
 /****************************************************************************/
 
 void RF24::setCRCLength(rf24_crclength_e length)
 {
-    uint8_t config = read_register(CONFIG) & ~( _BV(CRCO) | _BV(EN_CRC)) ;
+  uint8_t config = read_register(NRF_CONFIG) & ~( _BV(CRCO) | _BV(EN_CRC)) ;
 
-    // switch uses RAM (evil!)
-    if ( length == RF24_CRC_DISABLED ) {
-        // Do nothing, we turned it off above.
-    } else if ( length == RF24_CRC_8 ) {
-        config |= _BV(EN_CRC);
-    } else {
-        config |= _BV(EN_CRC);
-        config |= _BV( CRCO );
-    }
-    write_register( CONFIG, config ) ;
+  // switch uses RAM (evil!)
+  if ( length == RF24_CRC_DISABLED )
+  {
+    // Do nothing, we turned it off above.
+  }
+  else if ( length == RF24_CRC_8 )
+  {
+    config |= _BV(EN_CRC);
+  }
+  else
+  {
+    config |= _BV(EN_CRC);
+    config |= _BV( CRCO );
+  }
+  write_register( NRF_CONFIG, config ) ;
 }
 
 /****************************************************************************/
 
 rf24_crclength_e RF24::getCRCLength(void)
 {
-    rf24_crclength_e result = RF24_CRC_DISABLED;
-
-    uint8_t config = read_register(CONFIG) & ( _BV(CRCO) | _BV(EN_CRC)) ;
-    uint8_t AA = read_register(EN_AA);
+  rf24_crclength_e result = RF24_CRC_DISABLED;
+  
+  uint8_t config = read_register(NRF_CONFIG) & ( _BV(CRCO) | _BV(EN_CRC)) ;
+  uint8_t AA = read_register(EN_AA);
+  
+  if ( config & _BV(EN_CRC ) || AA)
+  {
+    if ( config & _BV(CRCO) )
+      result = RF24_CRC_16;
+    else
+      result = RF24_CRC_8;
+  }
 
-    if ( config & _BV(EN_CRC ) || AA) {
-        if ( config & _BV(CRCO) )
-            result = RF24_CRC_16;
-        else
-            result = RF24_CRC_8;
-    }
-
-    return result;
+  return result;
 }
 
 /****************************************************************************/
 
 void RF24::disableCRC( void )
 {
-    uint8_t disable = read_register(CONFIG) & ~_BV(EN_CRC) ;
-    write_register( CONFIG, disable ) ;
+  uint8_t disable = read_register(NRF_CONFIG) & ~_BV(EN_CRC) ;
+  write_register( NRF_CONFIG, disable ) ;
 }
 
 /****************************************************************************/
 void RF24::setRetries(uint8_t delay, uint8_t count)
 {
-    write_register(SETUP_RETR,(delay&0xf)<<ARD | (count&0xf)<<ARC);
+ write_register(SETUP_RETR,(delay&0xf)<<ARD | (count&0xf)<<ARC);
 }
diff -r 836f5c6da243 -r 15a3bbf90fe9 RF24.h
--- a/RF24.h	Mon Mar 28 18:13:17 2016 +0000
+++ b/RF24.h	Fri Oct 06 20:20:33 2017 +0000
@@ -15,8 +15,8 @@
 #ifndef __RF24_H__
 #define __RF24_H__
 
+#include "RF24_config.h"
 #include "mbed.h"
-#include "RF24_config.h"
 
 /**
  * Power Amplifier level.
@@ -47,1052 +47,1082 @@
 {
 private:
 
-    DigitalOut ce_pin; /**< "Chip Enable" pin, activates the RX or TX role */
-    DigitalOut csn_pin; /**< SPI Chip select */
-    //uint16_t spi_speed; /**< SPI Bus Speed */
+  SPI *spi;
 
-    uint8_t spi_rxbuff[32+1] ; //SPI receive buffer (payload max 32 bytes)
-    uint8_t spi_txbuff[32+1] ; //SPI transmit buffer (payload max 32 bytes + 1 byte for the command)
+  DigitalOut ce_pin; /**< "Chip Enable" pin, activates the RX or TX role */
+  DigitalOut csn_pin; /**< SPI Chip select */
 
-    bool p_variant; /* False for RF24L01 and true for RF24L01P */
-    uint8_t payload_size; /**< Fixed size of payloads */
-    bool dynamic_payloads_enabled; /**< Whether dynamic payloads are enabled. */
-    uint8_t pipe0_reading_address[5]; /**< Last address set on pipe 0 for reading. */
-    uint8_t addr_width; /**< The address width to use - 3,4 or 5 bytes. */
-    uint32_t txRxDelay; /**< Var for adjusting delays depending on datarate */
-
-    SPI spi;
-
-    Timer mainTimer;
-
+  bool p_variant; /* False for RF24L01 and true for RF24L01P */
+  uint8_t payload_size; /**< Fixed size of payloads */
+  bool dynamic_payloads_enabled; /**< Whether dynamic payloads are enabled. */
+  uint8_t pipe0_reading_address[5]; /**< Last address set on pipe 0 for reading. */
+  uint8_t addr_width; /**< The address width to use - 3,4 or 5 bytes. */
+  
 
 protected:
-    /**
-     * SPI transactions
-     *
-     * Common code for SPI transactions including CSN toggle
-     *
-     */
-    void beginTransaction(); // inline removed
+  /**
+   * SPI transactions
+   *
+   * Common code for SPI transactions including CSN toggle
+   *
+   */
+  inline void beginTransaction();
 
-    void endTransaction(); // inline removed
+  inline void endTransaction();
 
 public:
 
-    /**
-     * @name Primary public interface
-     *
-     *  These are the main methods you need to operate the chip
-     */
-    /**@{*/
+  /**
+   * @name Primary public interface
+   *
+   *  These are the main methods you need to operate the chip
+   */
+  /**@{*/
+  
+  /**
+  * MBED Constructor
+  *
+  * Creates a new instance of this driver.  Before using, you create an instance
+  * and send in the unique pins that this chip is connected to.
+  *
+  * @param _cepin The pin attached to Chip Enable on the RF module
+  * @param _cspin The pin attached to Chip Select
+  * @param spispeed For RPi, the SPI speed in MHZ ie: BCM2835_SPI_SPEED_8MHZ
+  */
+  
+  RF24(SPI *spi, PinName _cepin, PinName _cspin);
 
-    /**
-     * Arduino Constructor
-     *
-     * Creates a new instance of this driver.  Before using, you create an instance
-     * and send in the unique pins that this chip is connected to.
-     *
-     * @param _cepin The pin attached to Chip Enable on the RF module
-     * @param _cspin The pin attached to Chip Select
-     */
-    RF24(PinName mosi, PinName miso, PinName sck, PinName _cspin, PinName _cepin);
+  /**
+   * Begin operation of the chip
+   * 
+   * Call this in setup(), before calling any other methods.
+   * @code radio.begin() @endcode
+   */
+  bool begin(void);
 
-    virtual ~RF24() {};
+  /**
+   * Checks if the chip is connected to the SPI bus
+   */
+  bool isChipConnected();
 
-    /**
-     * Begin operation of the chip
-     *
-     * Call this in setup(), before calling any other methods.
-     * @code radio.begin() @endcode
-     */
-    bool begin(void);
-    void begin_MB(void);
+  /**
+   * Start listening on the pipes opened for reading.
+   *
+   * 1. Be sure to call openReadingPipe() first.  
+   * 2. Do not call write() while in this mode, without first calling stopListening().
+   * 3. Call available() to check for incoming traffic, and read() to get it. 
+   *  
+   * @code
+   * Open reading pipe 1 using address CCCECCCECC
+   *  
+   * byte address[] = { 0xCC,0xCE,0xCC,0xCE,0xCC };
+   * radio.openReadingPipe(1,address);
+   * radio.startListening();
+   * @endcode
+   */
+  void startListening(void);
 
-    /**
-     * Start listening on the pipes opened for reading.
-     *
-     * 1. Be sure to call openReadingPipe() first.
-     * 2. Do not call write() while in this mode, without first calling stopListening().
-     * 3. Call available() to check for incoming traffic, and read() to get it.
-     *
-     * @code
-     * Open reading pipe 1 using address CCCECCCECC
-     *
-     * byte address[] = { 0xCC,0xCE,0xCC,0xCE,0xCC };
-     * radio.openReadingPipe(1,address);
-     * radio.startListening();
-     * @endcode
-     */
-    void startListening(void);
+  /**
+   * Stop listening for incoming messages, and switch to transmit mode.
+   *
+   * Do this before calling write().
+   * @code
+   * radio.stopListening();
+   * radio.write(&data,sizeof(data));
+   * @endcode
+   */
+  void stopListening(void);
+
+  /**
+   * Check whether there are bytes available to be read
+   * @code
+   * if(radio.available()){
+   *   radio.read(&data,sizeof(data));
+   * }
+   * @endcode
+   * @return True if there is a payload available, false if none is
+   */
+  bool available(void);
 
-    /**
-     * Stop listening for incoming messages, and switch to transmit mode.
-     *
-     * Do this before calling write().
-     * @code
-     * radio.stopListening();
-     * radio.write(&data,sizeof(data));
-     * @endcode
-     */
-    void stopListening(void);
-
-    /**
-     * Check whether there are bytes available to be read
-     * @code
-     * if(radio.available()){
-     *   radio.read(&data,sizeof(data));
-     * }
-     * @endcode
-     * @return True if there is a payload available, false if none is
-     */
-    bool available(void);
+  /**
+   * 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()){
+   *   radio.read(&data,sizeof(data));
+   * }
+   * @endcode
+   * @return No return value. Use available().
+   */
+  void read( void* buf, uint8_t len );
 
-    /**
-     * 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()){
-     *   radio.read(&data,sizeof(data));
-     * }
-     * @endcode
-     * @return No return value. Use available().
-     */
-    void read( void* buf, uint8_t len );
+  /**
+   * Be sure to call openWritingPipe() first to set the destination
+   * of where to write to.
+   *
+   * This blocks until the message is successfully acknowledged by
+   * the receiver or the timeout/retransmit maxima are reached.  In
+   * the current configuration, the max delay here is 60-70ms.
+   *
+   * The maximum size of data written is the fixed payload size, see
+   * getPayloadSize().  However, you can write less, and the remainder
+   * will just be filled with zeroes.
+   *
+   * TX/RX/RT interrupt flags will be cleared every time write is called
+   *
+   * @param buf Pointer to the data to be sent
+   * @param len Number of bytes to be sent
+   *
+   * @code
+   * radio.stopListening();
+   * radio.write(&data,sizeof(data));
+   * @endcode
+   * @return True if the payload was delivered successfully false if not
+   */
+  bool write( const void* buf, uint8_t len );
+
+  /**
+   * New: Open a pipe for writing via byte array. Old addressing format retained
+   * for compatibility.
+   *
+   * Only one writing pipe can be open at once, but you can change the address
+   * you'll write to. Call stopListening() first.
+   *
+   * Addresses are assigned via a byte array, default is 5 byte address length
+s   *
+   * @code
+   *   uint8_t addresses[][6] = {"1Node","2Node"};
+   *   radio.openWritingPipe(addresses[0]);
+   * @endcode
+   * @code
+   *  uint8_t address[] = { 0xCC,0xCE,0xCC,0xCE,0xCC };
+   *  radio.openWritingPipe(address);
+   *  address[0] = 0x33;
+   *  radio.openReadingPipe(1,address);
+   * @endcode
+   * @see setAddressWidth
+   *
+   * @param address The address of the pipe to open. Coordinate these pipe
+   * addresses amongst nodes on the network.
+   */
+
+  void openWritingPipe(const uint8_t *address);
 
-    /**
-     * Be sure to call openWritingPipe() first to set the destination
-     * of where to write to.
-     *
-     * This blocks until the message is successfully acknowledged by
-     * the receiver or the timeout/retransmit maxima are reached.  In
-     * the current configuration, the max delay here is 60-70ms.
-     *
-     * The maximum size of data written is the fixed payload size, see
-     * getPayloadSize().  However, you can write less, and the remainder
-     * will just be filled with zeroes.
-     *
-     * TX/RX/RT interrupt flags will be cleared every time write is called
-     *
-     * @param buf Pointer to the data to be sent
-     * @param len Number of bytes to be sent
-     *
-     * @code
-     * radio.stopListening();
-     * radio.write(&data,sizeof(data));
-     * @endcode
-     * @return True if the payload was delivered successfully false if not
-     */
-    bool write( const void* buf, uint8_t len );
+  /**
+   * Open a pipe for reading
+   *
+   * Up to 6 pipes can be open for reading at once.  Open all the required
+   * reading pipes, and then call startListening().
+   *
+   * @see openWritingPipe
+   * @see setAddressWidth
+   *
+   * @note Pipes 0 and 1 will store a full 5-byte address. Pipes 2-5 will technically 
+   * only store a single byte, borrowing up to 4 additional bytes from pipe #1 per the
+   * assigned address width.
+   * @warning Pipes 1-5 should share the same address, except the first byte.
+   * Only the first byte in the array should be unique, e.g.
+   * @code
+   *   uint8_t addresses[][6] = {"1Node","2Node"};
+   *   openReadingPipe(1,addresses[0]);
+   *   openReadingPipe(2,addresses[1]);
+   * @endcode
+   *
+   * @warning Pipe 0 is also used by the writing pipe.  So if you open
+   * pipe 0 for reading, and then startListening(), it will overwrite the
+   * writing pipe.  Ergo, do an openWritingPipe() again before write().
+   *
+   * @param number Which pipe# to open, 0-5.
+   * @param address The 24, 32 or 40 bit address of the pipe to open.
+   */
+
+  void openReadingPipe(uint8_t number, const uint8_t *address);
 
-    /**
-     * New: Open a pipe for writing via byte array. Old addressing format retained
-     * for compatibility.
-     *
-     * Only one writing pipe can be open at once, but you can change the address
-     * you'll write to. Call stopListening() first.
-     *
-     * Addresses are assigned via a byte array, default is 5 byte address length
-    s   *
-     * @code
-     *   uint8_t addresses[][6] = {"1Node","2Node"};
-     *   radio.openWritingPipe(addresses[0]);
-     * @endcode
-     * @code
-     *  uint8_t address[] = { 0xCC,0xCE,0xCC,0xCE,0xCC };
-     *  radio.openWritingPipe(address);
-     *  address[0] = 0x33;
-     *  radio.openReadingPipe(1,address);
-     * @endcode
-     * @see setAddressWidth
-     *
-     * @param address The address of the pipe to open. Coordinate these pipe
-     * addresses amongst nodes on the network.
-     */
+   /**@}*/
+  /**
+   * @name Advanced Operation
+   *
+   *  Methods you can use to drive the chip in more advanced ways
+   */
+  /**@{*/
 
-    void openWritingPipe(const uint8_t *address);
+  /**
+   * Print a giant block of debugging information to stdout
+   *
+   * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+   * The printf.h file is included with the library for Arduino.
+   * @code
+   * #include <printf.h>
+   * setup(){
+   *  Serial.begin(115200);
+   *  printf_begin();
+   *  ...
+   * }
+   * @endcode
+   */
+  void printDetails(void);
+
+  /**
+   * Test whether there are bytes available to be read in the
+   * FIFO buffers. 
+   *
+   * @param[out] pipe_num Which pipe has the payload available
+   *  
+   * @code
+   * uint8_t pipeNum;
+   * if(radio.available(&pipeNum)){
+   *   radio.read(&data,sizeof(data));
+   *   Serial.print("Got data on pipe");
+   *   Serial.println(pipeNum);
+   * }
+   * @endcode
+   * @return True if there is a payload available, false if none is
+   */
+  bool available(uint8_t* pipe_num);
 
-    /**
-     * Open a pipe for reading
-     *
-     * Up to 6 pipes can be open for reading at once.  Open all the required
-     * reading pipes, and then call startListening().
-     *
-     * @see openWritingPipe
-     * @see setAddressWidth
-     *
-     * @note Pipes 0 and 1 will store a full 5-byte address. Pipes 2-5 will technically
-     * only store a single byte, borrowing up to 4 additional bytes from pipe #1 per the
-     * assigned address width.
-     * @warning Pipes 1-5 should share the same address, except the first byte.
-     * Only the first byte in the array should be unique, e.g.
-     * @code
-     *   uint8_t addresses[][6] = {"1Node","2Node"};
-     *   openReadingPipe(1,addresses[0]);
-     *   openReadingPipe(2,addresses[1]);
-     * @endcode
-     *
-     * @warning Pipe 0 is also used by the writing pipe.  So if you open
-     * pipe 0 for reading, and then startListening(), it will overwrite the
-     * writing pipe.  Ergo, do an openWritingPipe() again before write().
-     *
-     * @param number Which pipe# to open, 0-5.
-     * @param address The 24, 32 or 40 bit address of the pipe to open.
-     */
+  /**
+   * Check if the radio needs to be read. Can be used to prevent data loss
+   * @return True if all three 32-byte radio buffers are full
+   */
+  bool rxFifoFull();
+
+  /**
+   * Enter low-power mode
+   *
+   * To return to normal power mode, call powerUp().
+   *
+   * @note After calling startListening(), a basic radio will consume about 13.5mA
+   * at max PA level.
+   * During active transmission, the radio will consume about 11.5mA, but this will
+   * be reduced to 26uA (.026mA) between sending.
+   * In full powerDown mode, the radio will consume approximately 900nA (.0009mA)   
+   *
+   * @code
+   * radio.powerDown();
+   * avr_enter_sleep_mode(); // Custom function to sleep the device
+   * radio.powerUp();
+   * @endcode
+   */
+  void powerDown(void);
+
+  /**
+   * Leave low-power mode - required for normal radio operation after calling powerDown()
+   * 
+   * To return to low power mode, call powerDown().
+   * @note This will take up to 5ms for maximum compatibility 
+   */
+  void powerUp(void) ;
 
-    void openReadingPipe(uint8_t number, const uint8_t *address);
-
-    /**@}*/
-    /**
-     * @name Advanced Operation
-     *
-     *  Methods you can use to drive the chip in more advanced ways
-     */
-    /**@{*/
+  /**
+  * Write for single NOACK writes. Optionally disables acknowledgements/autoretries for a single write.
+  *
+  * @note enableDynamicAck() must be called to enable this feature
+  *
+  * Can be used with enableAckPayload() to request a response
+  * @see enableDynamicAck()
+  * @see setAutoAck()
+  * @see write()
+  *
+  * @param buf Pointer to the data to be sent
+  * @param len Number of bytes to be sent
+  * @param multicast Request ACK (0), NOACK (1)
+  */
+  bool write( const void* buf, uint8_t len, const bool multicast );
 
-    /**
-     * Print a giant block of debugging information to stdout
-     *
-     * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
-     * The printf.h file is included with the library for Arduino.
-     * @code
-     * #include <printf.h>
-     * setup(){
-     *  Serial.begin(115200);
-     *  printf_begin();
-     *  ...
-     * }
-     * @endcode
-     */
-    void printDetails(void);
+  /**
+   * This will not block until the 3 FIFO buffers are filled with data.
+   * Once the FIFOs are full, writeFast will simply wait for success or
+   * timeout, and return 1 or 0 respectively. From a user perspective, just
+   * keep trying to send the same data. The library will keep auto retrying
+   * the current payload using the built in functionality.
+   * @warning It is important to never keep the nRF24L01 in TX mode and FIFO full for more than 4ms at a time. If the auto
+   * retransmit is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
+   * to clear by issuing txStandBy() or ensure appropriate time between transmissions.
+   *
+   * @code
+   * Example (Partial blocking):
+   *
+   *            radio.writeFast(&buf,32);  // Writes 1 payload to the buffers
+   *            txStandBy();               // Returns 0 if failed. 1 if success. Blocks only until MAX_RT timeout or success. Data flushed on fail.
+   *
+   *            radio.writeFast(&buf,32);  // Writes 1 payload to the buffers
+   *            txStandBy(1000);           // Using extended timeouts, returns 1 if success. Retries failed payloads for 1 seconds before returning 0.
+   * @endcode
+   *
+   * @see txStandBy()
+   * @see write()
+   * @see writeBlocking()
+   *
+   * @param buf Pointer to the data to be sent
+   * @param len Number of bytes to be sent
+   * @return True if the payload was delivered successfully false if not
+   */
+  bool writeFast( const void* buf, uint8_t len );
 
-    /**
-     * Test whether there are bytes available to be read in the
-     * FIFO buffers.
-     *
-     * @param[out] pipe_num Which pipe has the payload available
-     *
-     * @code
-     * uint8_t pipeNum;
-     * if(radio.available(&pipeNum)){
-     *   radio.read(&data,sizeof(data));
-     *   Serial.print("Got data on pipe");
-     *   Serial.println(pipeNum);
-     * }
-     * @endcode
-     * @return True if there is a payload available, false if none is
-     */
-    bool available(uint8_t* pipe_num);
+  /**
+  * WriteFast for single NOACK writes. Disables acknowledgements/autoretries for a single write.
+  *
+  * @note enableDynamicAck() must be called to enable this feature
+  * @see enableDynamicAck()
+  * @see setAutoAck()
+  *
+  * @param buf Pointer to the data to be sent
+  * @param len Number of bytes to be sent
+  * @param multicast Request ACK (0) or NOACK (1)
+  */
+  bool writeFast( const void* buf, uint8_t len, const bool multicast );
 
-    /**
-     * Check if the radio needs to be read. Can be used to prevent data loss
-     * @return True if all three 32-byte radio buffers are full
-     */
-    bool rxFifoFull();
-
-    /**
-     * Enter low-power mode
-     *
-     * To return to normal power mode, call powerUp().
-     *
-     * @note After calling startListening(), a basic radio will consume about 13.5mA
-     * at max PA level.
-     * During active transmission, the radio will consume about 11.5mA, but this will
-     * be reduced to 26uA (.026mA) between sending.
-     * In full powerDown mode, the radio will consume approximately 900nA (.0009mA)
-     *
-     * @code
-     * radio.powerDown();
-     * avr_enter_sleep_mode(); // Custom function to sleep the device
-     * radio.powerUp();
-     * @endcode
-     */
-    void powerDown(void);
+  /**
+   * This function extends the auto-retry mechanism to any specified duration.
+   * It will not block until the 3 FIFO buffers are filled with data.
+   * If so the library will auto retry until a new payload is written
+   * or the user specified timeout period is reached.
+   * @warning It is important to never keep the nRF24L01 in TX mode and FIFO full for more than 4ms at a time. If the auto
+   * retransmit is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
+   * to clear by issuing txStandBy() or ensure appropriate time between transmissions.
+   *
+   * @code
+   * Example (Full blocking):
+   *
+   *            radio.writeBlocking(&buf,32,1000); //Wait up to 1 second to write 1 payload to the buffers
+   *            txStandBy(1000);                   //Wait up to 1 second for the payload to send. Return 1 if ok, 0 if failed.
+   *                                               //Blocks only until user timeout or success. Data flushed on fail.
+   * @endcode
+   * @note If used from within an interrupt, the interrupt should be disabled until completion, and sei(); called to enable millis().
+   * @see txStandBy()
+   * @see write()
+   * @see writeFast()
+   *
+   * @param buf Pointer to the data to be sent
+   * @param len Number of bytes to be sent
+   * @param timeout User defined timeout in milliseconds.
+   * @return True if the payload was loaded into the buffer successfully false if not
+   */
+  bool writeBlocking( const void* buf, uint8_t len, uint32_t timeout );
 
-    /**
-     * Leave low-power mode - required for normal radio operation after calling powerDown()
-     *
-     * To return to low power mode, call powerDown().
-     * @note This will take up to 5ms for maximum compatibility
-     */
-    void powerUp(void) ;
-
-    /**
-    * Write for single NOACK writes. Optionally disables acknowledgements/autoretries for a single write.
-    *
-    * @note enableDynamicAck() must be called to enable this feature
-    *
-    * Can be used with enableAckPayload() to request a response
-    * @see enableDynamicAck()
-    * @see setAutoAck()
-    * @see write()
-    *
-    * @param buf Pointer to the data to be sent
-    * @param len Number of bytes to be sent
-    * @param multicast Request ACK (0), NOACK (1)
-    */
-    bool write( const void* buf, uint8_t len, const bool multicast );
+  /**
+   * This function should be called as soon as transmission is finished to
+   * drop the radio back to STANDBY-I mode. If not issued, the radio will
+   * remain in STANDBY-II mode which, per the data sheet, is not a recommended
+   * operating mode.
+   *
+   * @note When transmitting data in rapid succession, it is still recommended by
+   * the manufacturer to drop the radio out of TX or STANDBY-II mode if there is
+   * time enough between sends for the FIFOs to empty. This is not required if auto-ack
+   * is enabled.
+   *
+   * Relies on built-in auto retry functionality.
+   *
+   * @code
+   * Example (Partial blocking):
+   *
+   *            radio.writeFast(&buf,32);
+   *            radio.writeFast(&buf,32);
+   *            radio.writeFast(&buf,32);  //Fills the FIFO buffers up
+   *            bool ok = txStandBy();     //Returns 0 if failed. 1 if success.
+   *                                       //Blocks only until MAX_RT timeout or success. Data flushed on fail.
+   * @endcode
+   * @see txStandBy(unsigned long timeout)
+   * @return True if transmission is successful
+   *
+   */
+   bool txStandBy();
 
-    /**
-     * This will not block until the 3 FIFO buffers are filled with data.
-     * Once the FIFOs are full, writeFast will simply wait for success or
-     * timeout, and return 1 or 0 respectively. From a user perspective, just
-     * keep trying to send the same data. The library will keep auto retrying
-     * the current payload using the built in functionality.
-     * @warning It is important to never keep the nRF24L01 in TX mode and FIFO full for more than 4ms at a time. If the auto
-     * retransmit is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
-     * to clear by issuing txStandBy() or ensure appropriate time between transmissions.
-     *
-     * @code
-     * Example (Partial blocking):
-     *
-     *            radio.writeFast(&buf,32);  // Writes 1 payload to the buffers
-     *            txStandBy();               // Returns 0 if failed. 1 if success. Blocks only until MAX_RT timeout or success. Data flushed on fail.
-     *
-     *            radio.writeFast(&buf,32);  // Writes 1 payload to the buffers
-     *            txStandBy(1000);           // Using extended timeouts, returns 1 if success. Retries failed payloads for 1 seconds before returning 0.
-     * @endcode
-     *
-     * @see txStandBy()
-     * @see write()
-     * @see writeBlocking()
-     *
-     * @param buf Pointer to the data to be sent
-     * @param len Number of bytes to be sent
-     * @return True if the payload was delivered successfully false if not
-     */
-    bool writeFast( const void* buf, uint8_t len );
+  /**
+   * This function allows extended blocking and auto-retries per a user defined timeout
+   * @code
+   *    Fully Blocking Example:
+   *
+   *            radio.writeFast(&buf,32);
+   *            radio.writeFast(&buf,32);
+   *            radio.writeFast(&buf,32);   //Fills the FIFO buffers up
+   *            bool ok = txStandBy(1000);  //Returns 0 if failed after 1 second of retries. 1 if success.
+   *                                        //Blocks only until user defined timeout or success. Data flushed on fail.
+   * @endcode
+   * @note If used from within an interrupt, the interrupt should be disabled until completion, and sei(); called to enable millis().
+   * @param timeout Number of milliseconds to retry failed payloads
+   * @return True if transmission is successful
+   *
+   */
+   bool txStandBy(uint32_t timeout, bool startTx = 0);
+
+  /**
+   * Write an ack payload for the specified pipe
+   *
+   * The next time a message is received on @p pipe, the data in @p buf will
+   * be sent back in the acknowledgement.
+   * @see enableAckPayload()
+   * @see enableDynamicPayloads()
+   * @warning Only three of these can be pending at any time as there are only 3 FIFO buffers.<br> Dynamic payloads must be enabled.
+   * @note Ack payloads are handled automatically by the radio chip when a payload is received. Users should generally
+   * write an ack payload as soon as startListening() is called, so one is available when a regular payload is received.
+   * @note Ack payloads are dynamic payloads. This only works on pipes 0&1 by default. Call 
+   * enableDynamicPayloads() to enable on all pipes.
+   *
+   * @param pipe Which pipe# (typically 1-5) will get this response.
+   * @param buf Pointer to data that is sent
+   * @param len Length of the data to send, up to 32 bytes max.  Not affected
+   * by the static payload set by setPayloadSize().
+   */
+  void writeAckPayload(uint8_t pipe, const void* buf, uint8_t len);
+
+  /**
+   * Determine if an ack payload was received in the most recent call to
+   * write(). The regular available() can also be used.
+   *
+   * Call read() to retrieve the ack payload.
+   *
+   * @return True if an ack payload is available.
+   */
+  bool isAckPayloadAvailable(void);
+
+  /**
+   * Call this when you get an interrupt to find out why
+   *
+   * Tells you what caused the interrupt, and clears the state of
+   * interrupts.
+   *
+   * @param[out] tx_ok The send was successful (TX_DS)
+   * @param[out] tx_fail The send failed, too many retries (MAX_RT)
+   * @param[out] rx_ready There is a message waiting to be read (RX_DS)
+   */
+  void whatHappened(bool& tx_ok,bool& tx_fail,bool& rx_ready);
 
-    /**
-    * WriteFast for single NOACK writes. Disables acknowledgements/autoretries for a single write.
-    *
-    * @note enableDynamicAck() must be called to enable this feature
-    * @see enableDynamicAck()
-    * @see setAutoAck()
-    *
-    * @param buf Pointer to the data to be sent
-    * @param len Number of bytes to be sent
-    * @param multicast Request ACK (0) or NOACK (1)
-    */
-    bool writeFast( const void* buf, uint8_t len, const bool multicast );
+  /**
+   * Non-blocking write to the open writing pipe used for buffered writes
+   *
+   * @note Optimization: This function now leaves the CE pin high, so the radio
+   * will remain in TX or STANDBY-II Mode until a txStandBy() command is issued. Can be used as an alternative to startWrite()
+   * if writing multiple payloads at once.
+   * @warning It is important to never keep the nRF24L01 in TX mode with FIFO full for more than 4ms at a time. If the auto
+   * retransmit/autoAck is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
+   * to clear by issuing txStandBy() or ensure appropriate time between transmissions.
+   *
+   * @see write()
+   * @see writeFast()
+   * @see startWrite()
+   * @see writeBlocking()
+   *
+   * For single noAck writes see:
+   * @see enableDynamicAck()
+   * @see setAutoAck()
+   *
+   * @param buf Pointer to the data to be sent
+   * @param len Number of bytes to be sent
+   * @param multicast Request ACK (0) or NOACK (1)
+   * @return True if the payload was delivered successfully false if not
+   */
+  void startFastWrite( const void* buf, uint8_t len, const bool multicast, bool startTx = 1 );
 
-    /**
-     * This function extends the auto-retry mechanism to any specified duration.
-     * It will not block until the 3 FIFO buffers are filled with data.
-     * If so the library will auto retry until a new payload is written
-     * or the user specified timeout period is reached.
-     * @warning It is important to never keep the nRF24L01 in TX mode and FIFO full for more than 4ms at a time. If the auto
-     * retransmit is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
-     * to clear by issuing txStandBy() or ensure appropriate time between transmissions.
-     *
-     * @code
-     * Example (Full blocking):
-     *
-     *            radio.writeBlocking(&buf,32,1000); //Wait up to 1 second to write 1 payload to the buffers
-     *            txStandBy(1000);                   //Wait up to 1 second for the payload to send. Return 1 if ok, 0 if failed.
-     *                                               //Blocks only until user timeout or success. Data flushed on fail.
-     * @endcode
-     * @note If used from within an interrupt, the interrupt should be disabled until completion, and sei(); called to enable millis().
-     * @see txStandBy()
-     * @see write()
-     * @see writeFast()
-     *
-     * @param buf Pointer to the data to be sent
-     * @param len Number of bytes to be sent
-     * @param timeout User defined timeout in milliseconds.
-     * @return True if the payload was loaded into the buffer successfully false if not
-     */
-    bool writeBlocking( const void* buf, uint8_t len, uint32_t timeout );
+  /**
+   * Non-blocking write to the open writing pipe
+   *
+   * Just like write(), but it returns immediately. To find out what happened
+   * to the send, catch the IRQ and then call whatHappened().
+   *
+   * @see write()
+   * @see writeFast()
+   * @see startFastWrite()
+   * @see whatHappened()
+   *
+   * For single noAck writes see:
+   * @see enableDynamicAck()
+   * @see setAutoAck()
+   *
+   * @param buf Pointer to the data to be sent
+   * @param len Number of bytes to be sent
+   * @param multicast Request ACK (0) or NOACK (1)
+   *
+   */
+  void startWrite( const void* buf, uint8_t len, const bool multicast );
+  
+  /**
+   * This function is mainly used internally to take advantage of the auto payload
+   * re-use functionality of the chip, but can be beneficial to users as well.
+   *
+   * The function will instruct the radio to re-use the data in the FIFO buffers,
+   * and instructs the radio to re-send once the timeout limit has been reached.
+   * Used by writeFast and writeBlocking to initiate retries when a TX failure
+   * occurs. Retries are automatically initiated except with the standard write().
+   * This way, data is not flushed from the buffer until switching between modes.
+   *
+   * @note This is to be used AFTER auto-retry fails if wanting to resend
+   * using the built-in payload reuse features.
+   * After issuing reUseTX(), it will keep reending the same payload forever or until
+   * a payload is written to the FIFO, or a flush_tx command is given.
+   */
+   void reUseTX();
+
+  /**
+   * Empty the transmit buffer. This is generally not required in standard operation.
+   * May be required in specific cases after stopListening() , if operating at 250KBPS data rate.
+   *
+   * @return Current value of status register
+   */
+  uint8_t flush_tx(void);
+
+  /**
+   * Test whether there was a carrier on the line for the
+   * previous listening period.
+   *
+   * Useful to check for interference on the current channel.
+   *
+   * @return true if was carrier, false if not
+   */
+  bool testCarrier(void);
 
-    /**
-     * This function should be called as soon as transmission is finished to
-     * drop the radio back to STANDBY-I mode. If not issued, the radio will
-     * remain in STANDBY-II mode which, per the data sheet, is not a recommended
-     * operating mode.
-     *
-     * @note When transmitting data in rapid succession, it is still recommended by
-     * the manufacturer to drop the radio out of TX or STANDBY-II mode if there is
-     * time enough between sends for the FIFOs to empty. This is not required if auto-ack
-     * is enabled.
-     *
-     * Relies on built-in auto retry functionality.
-     *
-     * @code
-     * Example (Partial blocking):
-     *
-     *            radio.writeFast(&buf,32);
-     *            radio.writeFast(&buf,32);
-     *            radio.writeFast(&buf,32);  //Fills the FIFO buffers up
-     *            bool ok = txStandBy();     //Returns 0 if failed. 1 if success.
-     *                                       //Blocks only until MAX_RT timeout or success. Data flushed on fail.
-     * @endcode
-     * @see txStandBy(unsigned long timeout)
-     * @return True if transmission is successful
-     *
-     */
-    bool txStandBy();
+  /**
+   * Test whether a signal (carrier or otherwise) greater than
+   * or equal to -64dBm is present on the channel. Valid only
+   * on nRF24L01P (+) hardware. On nRF24L01, use testCarrier().
+   *
+   * Useful to check for interference on the current channel and
+   * channel hopping strategies.
+   *
+   * @code
+   * bool goodSignal = radio.testRPD();
+   * if(radio.available()){
+   *    Serial.println(goodSignal ? "Strong signal > 64dBm" : "Weak signal < 64dBm" );
+   *    radio.read(0,0);
+   * }
+   * @endcode
+   * @return true if signal => -64dBm, false if not
+   */
+  bool testRPD(void) ;
+
+  /**
+   * Test whether this is a real radio, or a mock shim for
+   * debugging.  Setting either pin to 0xff is the way to
+   * indicate that this is not a real radio.
+   *
+   * @return true if this is a legitimate radio
+   */
+  bool isValid() { return ce_pin != 0xff && csn_pin != 0xff; }
+  
+   /**
+   * Close a pipe after it has been previously opened.
+   * Can be safely called without having previously opened a pipe.
+   * @param pipe Which pipe # to close, 0-5.
+   */
+  void closeReadingPipe( uint8_t pipe ) ;
 
-    /**
-     * This function allows extended blocking and auto-retries per a user defined timeout
-     * @code
-     *    Fully Blocking Example:
-     *
-     *            radio.writeFast(&buf,32);
-     *            radio.writeFast(&buf,32);
-     *            radio.writeFast(&buf,32);   //Fills the FIFO buffers up
-     *            bool ok = txStandBy(1000);  //Returns 0 if failed after 1 second of retries. 1 if success.
-     *                                        //Blocks only until user defined timeout or success. Data flushed on fail.
-     * @endcode
-     * @note If used from within an interrupt, the interrupt should be disabled until completion, and sei(); called to enable millis().
-     * @param timeout Number of milliseconds to retry failed payloads
-     * @return True if transmission is successful
-     *
-     */
-    bool txStandBy(uint32_t timeout, bool startTx = 0);
+   /**
+   * Enable error detection by un-commenting #define FAILURE_HANDLING in RF24_config.h
+   * If a failure has been detected, it usually indicates a hardware issue. By default the library
+   * will cease operation when a failure is detected.  
+   * This should allow advanced users to detect and resolve intermittent hardware issues.  
+   *   
+   * In most cases, the radio must be re-enabled via radio.begin(); and the appropriate settings
+   * applied after a failure occurs, if wanting to re-enable the device immediately.
+   * 
+   * Usage: (Failure handling must be enabled per above)
+   *  @code
+   *  if(radio.failureDetected){ 
+   *    radio.begin();                       // Attempt to re-configure the radio with defaults
+   *    radio.failureDetected = 0;           // Reset the detection value
+   *    radio.openWritingPipe(addresses[1]); // Re-configure pipe addresses
+   *    radio.openReadingPipe(1,addresses[0]);
+   *    report_failure();                    // Blink leds, send a message, etc. to indicate failure
+   *  }
+   * @endcode
+  */
+  //#if defined (FAILURE_HANDLING)
+    bool failureDetected; 
+  //#endif
+    
+  /**@}*/
 
-    /**
-     * Write an ack payload for the specified pipe
-     *
-     * The next time a message is received on @p pipe, the data in @p buf will
-     * be sent back in the acknowledgement.
-     * @see enableAckPayload()
-     * @see enableDynamicPayloads()
-     * @warning Only three of these can be pending at any time as there are only 3 FIFO buffers.<br> Dynamic payloads must be enabled.
-     * @note Ack payloads are handled automatically by the radio chip when a payload is received. Users should generally
-     * write an ack payload as soon as startListening() is called, so one is available when a regular payload is received.
-     * @note Ack payloads are dynamic payloads. This only works on pipes 0&1 by default. Call
-     * enableDynamicPayloads() to enable on all pipes.
-     *
-     * @param pipe Which pipe# (typically 1-5) will get this response.
-     * @param buf Pointer to data that is sent
-     * @param len Length of the data to send, up to 32 bytes max.  Not affected
-     * by the static payload set by setPayloadSize().
-     */
-    void writeAckPayload(uint8_t pipe, const void* buf, uint8_t len);
+  /**@}*/
+  /**
+   * @name Optional Configurators
+   *
+   *  Methods you can use to get or set the configuration of the chip.
+   *  None are required.  Calling begin() sets up a reasonable set of
+   *  defaults.
+   */
+  /**@{*/
+
+  /**
+  * Set the address width from 3 to 5 bytes (24, 32 or 40 bit)
+  *
+  * @param a_width The address width to use: 3,4 or 5
+  */
 
+  void setAddressWidth(uint8_t a_width);
+  
+  /**
+   * Set the number and delay of retries upon failed submit
+   *
+   * @param delay How long to wait between each retry, in multiples of 250us,
+   * max is 15.  0 means 250us, 15 means 4000us.
+   * @param count How many retries before giving up, max 15
+   */
+  void setRetries(uint8_t delay, uint8_t count);
+
+  /**
+   * Set RF communication channel
+   *
+   * @param channel Which RF channel to communicate on, 0-125
+   */
+  void setChannel(uint8_t channel);
+  
     /**
-     * Determine if an ack payload was received in the most recent call to
-     * write(). The regular available() can also be used.
-     *
-     * Call read() to retrieve the ack payload.
-     *
-     * @return True if an ack payload is available.
-     */
-    bool isAckPayloadAvailable(void);
-
-    /**
-     * Call this when you get an interrupt to find out why
-     *
-     * Tells you what caused the interrupt, and clears the state of
-     * interrupts.
-     *
-     * @param[out] tx_ok The send was successful (TX_DS)
-     * @param[out] tx_fail The send failed, too many retries (MAX_RT)
-     * @param[out] rx_ready There is a message waiting to be read (RX_DS)
-     */
-    void whatHappened(bool& tx_ok,bool& tx_fail,bool& rx_ready);
+   * Get RF communication channel
+   *
+   * @return The currently configured RF Channel
+   */
+  uint8_t getChannel(void);
 
-    /**
-     * Non-blocking write to the open writing pipe used for buffered writes
-     *
-     * @note Optimization: This function now leaves the CE pin high, so the radio
-     * will remain in TX or STANDBY-II Mode until a txStandBy() command is issued. Can be used as an alternative to startWrite()
-     * if writing multiple payloads at once.
-     * @warning It is important to never keep the nRF24L01 in TX mode with FIFO full for more than 4ms at a time. If the auto
-     * retransmit/autoAck is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
-     * to clear by issuing txStandBy() or ensure appropriate time between transmissions.
-     *
-     * @see write()
-     * @see writeFast()
-     * @see startWrite()
-     * @see writeBlocking()
-     *
-     * For single noAck writes see:
-     * @see enableDynamicAck()
-     * @see setAutoAck()
-     *
-     * @param buf Pointer to the data to be sent
-     * @param len Number of bytes to be sent
-     * @param multicast Request ACK (0) or NOACK (1)
-     * @return True if the payload was delivered successfully false if not
-     */
-    void startFastWrite( const void* buf, uint8_t len, const bool multicast, bool startTx = 1 );
+  /**
+   * Set Static Payload Size
+   *
+   * This implementation uses a pre-stablished fixed payload size for all
+   * transmissions.  If this method is never called, the driver will always
+   * transmit the maximum payload size (32 bytes), no matter how much
+   * was sent to write().
+   *
+   * @todo Implement variable-sized payloads feature
+   *
+   * @param size The number of bytes in the payload
+   */
+  void setPayloadSize(uint8_t size);
 
-    /**
-     * Non-blocking write to the open writing pipe
-     *
-     * Just like write(), but it returns immediately. To find out what happened
-     * to the send, catch the IRQ and then call whatHappened().
-     *
-     * @see write()
-     * @see writeFast()
-     * @see startFastWrite()
-     * @see whatHappened()
-     *
-     * For single noAck writes see:
-     * @see enableDynamicAck()
-     * @see setAutoAck()
-     *
-     * @param buf Pointer to the data to be sent
-     * @param len Number of bytes to be sent
-     * @param multicast Request ACK (0) or NOACK (1)
-     *
-     */
-    void startWrite( const void* buf, uint8_t len, const bool multicast );
+  /**
+   * Get Static Payload Size
+   *
+   * @see setPayloadSize()
+   *
+   * @return The number of bytes in the payload
+   */
+  uint8_t getPayloadSize(void);
 
-    /**
-     * This function is mainly used internally to take advantage of the auto payload
-     * re-use functionality of the chip, but can be beneficial to users as well.
-     *
-     * The function will instruct the radio to re-use the data in the FIFO buffers,
-     * and instructs the radio to re-send once the timeout limit has been reached.
-     * Used by writeFast and writeBlocking to initiate retries when a TX failure
-     * occurs. Retries are automatically initiated except with the standard write().
-     * This way, data is not flushed from the buffer until switching between modes.
-     *
-     * @note This is to be used AFTER auto-retry fails if wanting to resend
-     * using the built-in payload reuse features.
-     * After issuing reUseTX(), it will keep reending the same payload forever or until
-     * a payload is written to the FIFO, or a flush_tx command is given.
-     */
-    void reUseTX();
-
-    /**
-     * Empty the transmit buffer. This is generally not required in standard operation.
-     * May be required in specific cases after stopListening() , if operating at 250KBPS data rate.
-     *
-     * @return Current value of status register
-     */
-    uint8_t flush_tx(void);
+  /**
+   * Get Dynamic Payload Size
+   *
+   * For dynamic payloads, this pulls the size of the payload off
+   * the chip
+   *
+   * @note Corrupt packets are now detected and flushed per the
+   * manufacturer.
+   * @code
+   * if(radio.available()){
+   *   if(radio.getDynamicPayloadSize() < 1){
+   *     // Corrupt payload has been flushed
+   *     return; 
+   *   }
+   *   radio.read(&data,sizeof(data));
+   * }
+   * @endcode
+   *
+   * @return Payload length of last-received dynamic payload
+   */
+  uint8_t getDynamicPayloadSize(void);
 
-    /**
-     * Test whether there was a carrier on the line for the
-     * previous listening period.
-     *
-     * Useful to check for interference on the current channel.
-     *
-     * @return true if was carrier, false if not
-     */
-    bool testCarrier(void);
-
-    /**
-     * Test whether a signal (carrier or otherwise) greater than
-     * or equal to -64dBm is present on the channel. Valid only
-     * on nRF24L01P (+) hardware. On nRF24L01, use testCarrier().
-     *
-     * Useful to check for interference on the current channel and
-     * channel hopping strategies.
-     *
-     * @code
-     * bool goodSignal = radio.testRPD();
-     * if(radio.available()){
-     *    Serial.println(goodSignal ? "Strong signal > 64dBm" : "Weak signal < 64dBm" );
-     *    radio.read(0,0);
-     * }
-     * @endcode
-     * @return true if signal => -64dBm, false if not
-     */
-    bool testRPD(void) ;
-
-    /**
-     * Test whether this is a real radio, or a mock shim for
-     * debugging.  Setting either pin to 0xff is the way to
-     * indicate that this is not a real radio.
-     *
-     * @return true if this is a legitimate radio
-     */
-    bool isValid() {
-        return ce_pin != 0xff && csn_pin != 0xff;
-    }
-
-    /**
-    * Close a pipe after it has been previously opened.
-    * Can be safely called without having previously opened a pipe.
-    * @param pipe Which pipe # to close, 0-5.
-    */
-    void closeReadingPipe( uint8_t pipe ) ;
+  /**
+   * Enable custom payloads on the acknowledge packets
+   *
+   * Ack payloads are a handy way to return data back to senders without
+   * manually changing the radio modes on both units.
+   *
+   * @note Ack payloads are dynamic payloads. This only works on pipes 0&1 by default. Call 
+   * enableDynamicPayloads() to enable on all pipes.
+   */
+  void enableAckPayload(void);
 
-    /**
-    * Enable error detection by un-commenting #define FAILURE_HANDLING in RF24_config.h
-    * If a failure has been detected, it usually indicates a hardware issue. By default the library
-    * will cease operation when a failure is detected.
-    * This should allow advanced users to detect and resolve intermittent hardware issues.
-    *
-    * In most cases, the radio must be re-enabled via radio.begin(); and the appropriate settings
-    * applied after a failure occurs, if wanting to re-enable the device immediately.
-    *
-    * Usage: (Failure handling must be enabled per above)
-    *  @code
-    *  if(radio.failureDetected){
-    *    radio.begin();                       // Attempt to re-configure the radio with defaults
-    *    radio.failureDetected = 0;           // Reset the detection value
-    *    radio.openWritingPipe(addresses[1]); // Re-configure pipe addresses
-    *    radio.openReadingPipe(1,addresses[0]);
-    *    report_failure();                    // Blink leds, send a message, etc. to indicate failure
-    *  }
-    * @endcode
-    */
-    //#if defined (FAILURE_HANDLING)
-    bool failureDetected;
-    //#endif
-
-    /**@}*/
+  /**
+   * Enable dynamically-sized payloads
+   *
+   * This way you don't always have to send large packets just to send them
+   * once in a while.  This enables dynamic payloads on ALL pipes.
+   *
+   */
+  void enableDynamicPayloads(void);
+  
+  /**
+   * Disable dynamically-sized payloads
+   *
+   * This disables dynamic payloads on ALL pipes. Since Ack Payloads
+   * requires Dynamic Payloads, Ack Payloads are also disabled.
+   * If dynamic payloads are later re-enabled and ack payloads are desired
+   * then enableAckPayload() must be called again as well.
+   *
+   */
+  void disableDynamicPayloads(void);
+  
+  /**
+   * Enable dynamic ACKs (single write multicast or unicast) for chosen messages
+   *
+   * @note To enable full multicast or per-pipe multicast, use setAutoAck()
+   *
+   * @warning This MUST be called prior to attempting single write NOACK calls
+   * @code
+   * radio.enableDynamicAck();
+   * radio.write(&data,32,1);  // Sends a payload with no acknowledgement requested
+   * radio.write(&data,32,0);  // Sends a payload using auto-retry/autoACK
+   * @endcode
+   */
+  void enableDynamicAck();
+  
+  /**
+   * Determine whether the hardware is an nRF24L01+ or not.
+   *
+   * @return true if the hardware is nRF24L01+ (or compatible) and false
+   * if its not.
+   */
+  bool isPVariant(void) ;
 
-    /**@}*/
-    /**
-     * @name Optional Configurators
-     *
-     *  Methods you can use to get or set the configuration of the chip.
-     *  None are required.  Calling begin() sets up a reasonable set of
-     *  defaults.
-     */
-    /**@{*/
-
-    /**
-    * Set the address width from 3 to 5 bytes (24, 32 or 40 bit)
-    *
-    * @param a_width The address width to use: 3,4 or 5
-    */
-
-    void setAddressWidth(uint8_t a_width);
-
-    /**
-     * Set the number and delay of retries upon failed submit
-     *
-     * @param delay How long to wait between each retry, in multiples of 250us,
-     * max is 15.  0 means 250us, 15 means 4000us.
-     * @param count How many retries before giving up, max 15
-     */
-    void setRetries(uint8_t delay, uint8_t count);
-
-    /**
-     * Set RF communication channel
-     *
-     * @param channel Which RF channel to communicate on, 0-125
-     */
-    void setChannel(uint8_t channel);
+  /**
+   * Enable or disable auto-acknowlede packets
+   *
+   * This is enabled by default, so it's only needed if you want to turn
+   * it off for some reason.
+   *
+   * @param enable Whether to enable (true) or disable (false) auto-acks
+   */
+  void setAutoAck(bool enable);
 
-    /**
-    * Get RF communication channel
-    *
-    * @return The currently configured RF Channel
-    */
-    uint8_t getChannel(void);
+  /**
+   * Enable or disable auto-acknowlede packets on a per pipeline basis.
+   *
+   * AA is enabled by default, so it's only needed if you want to turn
+   * it off/on for some reason on a per pipeline basis.
+   *
+   * @param pipe Which pipeline to modify
+   * @param enable Whether to enable (true) or disable (false) auto-acks
+   */
+  void setAutoAck( uint8_t pipe, bool enable ) ;
 
-    /**
-     * Set Static Payload Size
-     *
-     * This implementation uses a pre-stablished fixed payload size for all
-     * transmissions.  If this method is never called, the driver will always
-     * transmit the maximum payload size (32 bytes), no matter how much
-     * was sent to write().
-     *
-     * @todo Implement variable-sized payloads feature
-     *
-     * @param size The number of bytes in the payload
-     */
-    void setPayloadSize(uint8_t size);
-
-    /**
-     * Get Static Payload Size
-     *
-     * @see setPayloadSize()
-     *
-     * @return The number of bytes in the payload
-     */
-    uint8_t getPayloadSize(void);
+  /**
+   * Set Power Amplifier (PA) level to one of four levels:
+   * RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH and RF24_PA_MAX
+   *
+   * The power levels correspond to the following output levels respectively:
+   * NRF24L01: -18dBm, -12dBm,-6dBM, and 0dBm
+   *
+   * SI24R1: -6dBm, 0dBm, 3dBM, and 7dBm.
+   *
+   * @param level Desired PA level.
+   */
+  void setPALevel ( uint8_t level );
 
-    /**
-     * Get Dynamic Payload Size
-     *
-     * For dynamic payloads, this pulls the size of the payload off
-     * the chip
-     *
-     * @note Corrupt packets are now detected and flushed per the
-     * manufacturer.
-     * @code
-     * if(radio.available()){
-     *   if(radio.getDynamicPayloadSize() < 1){
-     *     // Corrupt payload has been flushed
-     *     return;
-     *   }
-     *   radio.read(&data,sizeof(data));
-     * }
-     * @endcode
-     *
-     * @return Payload length of last-received dynamic payload
-     */
-    uint8_t getDynamicPayloadSize(void);
+  /**
+   * Fetches the current PA level.
+   *
+   * NRF24L01: -18dBm, -12dBm, -6dBm and 0dBm
+   * SI24R1:   -6dBm, 0dBm, 3dBm, 7dBm
+   *
+   * @return Returns values 0 to 3 representing the PA Level.
+   */
+   uint8_t getPALevel( void );
 
-    /**
-     * Enable custom payloads on the acknowledge packets
-     *
-     * Ack payloads are a handy way to return data back to senders without
-     * manually changing the radio modes on both units.
-     *
-     * @note Ack payloads are dynamic payloads. This only works on pipes 0&1 by default. Call
-     * enableDynamicPayloads() to enable on all pipes.
-     */
-    void enableAckPayload(void);
-
-    /**
-     * Enable dynamically-sized payloads
-     *
-     * This way you don't always have to send large packets just to send them
-     * once in a while.  This enables dynamic payloads on ALL pipes.
-     *
-     */
-    void enableDynamicPayloads(void);
+  /**
+   * Set the transmission data rate
+   *
+   * @warning setting RF24_250KBPS will fail for non-plus units
+   *
+   * @param speed RF24_250KBPS for 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS for 2Mbps
+   * @return true if the change was successful
+   */
+  bool setDataRate(rf24_datarate_e speed);
 
-    /**
-     * Enable dynamic ACKs (single write multicast or unicast) for chosen messages
-     *
-     * @note To enable full multicast or per-pipe multicast, use setAutoAck()
-     *
-     * @warning This MUST be called prior to attempting single write NOACK calls
-     * @code
-     * radio.enableDynamicAck();
-     * radio.write(&data,32,1);  // Sends a payload with no acknowledgement requested
-     * radio.write(&data,32,0);  // Sends a payload using auto-retry/autoACK
-     * @endcode
-     */
-    void enableDynamicAck();
+  /**
+   * Fetches the transmission data rate
+   *
+   * @return Returns the hardware's currently configured datarate. The value
+   * is one of 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS, as defined in the
+   * rf24_datarate_e enum.
+   */
+  rf24_datarate_e getDataRate( void ) ;
 
-    /**
-     * Determine whether the hardware is an nRF24L01+ or not.
-     *
-     * @return true if the hardware is nRF24L01+ (or compatible) and false
-     * if its not.
-     */
-    bool isPVariant(void) ;
+  /**
+   * Set the CRC length
+   * <br>CRC checking cannot be disabled if auto-ack is enabled
+   * @param length RF24_CRC_8 for 8-bit or RF24_CRC_16 for 16-bit
+   */
+  void setCRCLength(rf24_crclength_e length);
 
-    /**
-     * Enable or disable auto-acknowlede packets
-     *
-     * This is enabled by default, so it's only needed if you want to turn
-     * it off for some reason.
-     *
-     * @param enable Whether to enable (true) or disable (false) auto-acks
-     */
-    void setAutoAck(bool enable);
-
-    /**
-     * Enable or disable auto-acknowlede packets on a per pipeline basis.
-     *
-     * AA is enabled by default, so it's only needed if you want to turn
-     * it off/on for some reason on a per pipeline basis.
-     *
-     * @param pipe Which pipeline to modify
-     * @param enable Whether to enable (true) or disable (false) auto-acks
-     */
-    void setAutoAck( uint8_t pipe, bool enable ) ;
+  /**
+   * Get the CRC length
+   * <br>CRC checking cannot be disabled if auto-ack is enabled
+   * @return RF24_CRC_DISABLED if disabled or RF24_CRC_8 for 8-bit or RF24_CRC_16 for 16-bit
+   */
+  rf24_crclength_e getCRCLength(void);
 
-    /**
-     * Set Power Amplifier (PA) level to one of four levels:
-     * RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH and RF24_PA_MAX
-     *
-     * The power levels correspond to the following output levels respectively:
-     * NRF24L01: -18dBm, -12dBm,-6dBM, and 0dBm
-     *
-     * SI24R1: -6dBm, 0dBm, 3dBM, and 7dBm.
-     *
-     * @param level Desired PA level.
-     */
-    void setPALevel ( uint8_t level );
-
-    /**
-     * Fetches the current PA level.
-     *
-     * NRF24L01: -18dBm, -12dBm, -6dBm and 0dBm
-     * SI24R1:   -6dBm, 0dBm, 3dBm, 7dBm
-     *
-     * @return Returns values 0 to 3 representing the PA Level.
-     */
-    uint8_t getPALevel( void );
-
-    /**
-     * Set the transmission data rate
-     *
-     * @warning setting RF24_250KBPS will fail for non-plus units
-     *
-     * @param speed RF24_250KBPS for 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS for 2Mbps
-     * @return true if the change was successful
-     */
-    bool setDataRate(rf24_datarate_e speed);
+  /**
+   * Disable CRC validation
+   * 
+   * @warning CRC cannot be disabled if auto-ack/ESB is enabled.
+   */
+  void disableCRC( void ) ;
 
-    /**
-     * Fetches the transmission data rate
-     *
-     * @return Returns the hardware's currently configured datarate. The value
-     * is one of 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS, as defined in the
-     * rf24_datarate_e enum.
-     */
-    rf24_datarate_e getDataRate( void ) ;
-
-    /**
-     * Set the CRC length
-     * <br>CRC checking cannot be disabled if auto-ack is enabled
-     * @param length RF24_CRC_8 for 8-bit or RF24_CRC_16 for 16-bit
-     */
-    void setCRCLength(rf24_crclength_e length);
-
-    /**
-     * Get the CRC length
-     * <br>CRC checking cannot be disabled if auto-ack is enabled
-     * @return RF24_DISABLED if disabled or RF24_CRC_8 for 8-bit or RF24_CRC_16 for 16-bit
-     */
-    rf24_crclength_e getCRCLength(void);
+  /**
+  * The radio will generate interrupt signals when a transmission is complete,
+  * a transmission fails, or a payload is received. This allows users to mask
+  * those interrupts to prevent them from generating a signal on the interrupt
+  * pin. Interrupts are enabled on the radio chip by default.
+  *
+  * @code
+  *     Mask all interrupts except the receive interrupt:
+  *
+  *     radio.maskIRQ(1,1,0);
+  * @endcode
+  *
+  * @param tx_ok  Mask transmission complete interrupts
+  * @param tx_fail  Mask transmit failure interrupts
+  * @param rx_ready Mask payload received interrupts
+  */
+  void maskIRQ(bool tx_ok,bool tx_fail,bool rx_ready);
+  
+  /**
+  * 
+  * The driver will delay for this duration when stopListening() is called
+  * 
+  * When responding to payloads, faster devices like ARM(RPi) are much faster than Arduino:
+  * 1. Arduino sends data to RPi, switches to RX mode
+  * 2. The RPi receives the data, switches to TX mode and sends before the Arduino radio is in RX mode
+  * 3. If AutoACK is disabled, this can be set as low as 0. If AA/ESB enabled, set to 100uS minimum on RPi
+  *
+  * @warning If set to 0, ensure 130uS delay after stopListening() and before any sends
+  */
+  
+  uint32_t txDelay;
 
-    /**
-     * Disable CRC validation
-     *
-     * @warning CRC cannot be disabled if auto-ack/ESB is enabled.
-     */
-    void disableCRC( void ) ;
-
-    /**
-    * The radio will generate interrupt signals when a transmission is complete,
-    * a transmission fails, or a payload is received. This allows users to mask
-    * those interrupts to prevent them from generating a signal on the interrupt
-    * pin. Interrupts are enabled on the radio chip by default.
-    *
-    * @code
-    *     Mask all interrupts except the receive interrupt:
-    *
-    *     radio.maskIRQ(1,1,0);
-    * @endcode
-    *
-    * @param tx_ok  Mask transmission complete interrupts
-    * @param tx_fail  Mask transmit failure interrupts
-    * @param rx_ready Mask payload received interrupts
-    */
-    void maskIRQ(bool tx_ok,bool tx_fail,bool rx_ready);
-
-    /**@}*/
-    /**
-     * @name Deprecated
-     *
-     *  Methods provided for backwards compabibility.
-     */
-    /**@{*/
+  /**
+  * 
+  * On all devices but Linux and ATTiny, a small delay is added to the CSN toggling function
+  * 
+  * This is intended to minimise the speed of SPI polling due to radio commands
+  *
+  * If using interrupts or timed requests, this can be set to 0 Default:5
+  */
+  
+  uint32_t csDelay;
+  
+  /**@}*/
+  /**
+   * @name Deprecated
+   *
+   *  Methods provided for backwards compabibility.
+   */
+  /**@{*/
 
 
-    /**
-     * Open a pipe for reading
-     * @note For compatibility with old code only, see new function
-     *
-     * @warning Pipes 1-5 should share the first 32 bits.
-     * Only the least significant byte should be unique, e.g.
-     * @code
-     *   openReadingPipe(1,0xF0F0F0F0AA);
-     *   openReadingPipe(2,0xF0F0F0F066);
-     * @endcode
-     *
-     * @warning Pipe 0 is also used by the writing pipe.  So if you open
-     * pipe 0 for reading, and then startListening(), it will overwrite the
-     * writing pipe.  Ergo, do an openWritingPipe() again before write().
-     *
-     * @param number Which pipe# to open, 0-5.
-     * @param address The 40-bit address of the pipe to open.
-     */
-    void openReadingPipe(uint8_t number, uint64_t address);
+  /**
+   * Open a pipe for reading
+   * @note For compatibility with old code only, see new function
+   *
+   * @warning Pipes 1-5 should share the first 32 bits.
+   * Only the least significant byte should be unique, e.g.
+   * @code
+   *   openReadingPipe(1,0xF0F0F0F0AA);
+   *   openReadingPipe(2,0xF0F0F0F066);
+   * @endcode
+   *
+   * @warning Pipe 0 is also used by the writing pipe.  So if you open
+   * pipe 0 for reading, and then startListening(), it will overwrite the
+   * writing pipe.  Ergo, do an openWritingPipe() again before write().
+   *
+   * @param number Which pipe# to open, 0-5.
+   * @param address The 40-bit address of the pipe to open.
+   */
+  void openReadingPipe(uint8_t number, uint64_t address);
 
-    /**
-     * Open a pipe for writing
-     * @note For compatibility with old code only, see new function
-     *
-     * Addresses are 40-bit hex values, e.g.:
-     *
-     * @code
-     *   openWritingPipe(0xF0F0F0F0F0);
-     * @endcode
-     *
-     * @param address The 40-bit address of the pipe to open.
-     */
-    void openWritingPipe(uint64_t address);
+  /**
+   * Open a pipe for writing
+   * @note For compatibility with old code only, see new function
+   *
+   * Addresses are 40-bit hex values, e.g.:
+   *
+   * @code
+   *   openWritingPipe(0xF0F0F0F0F0);
+   * @endcode
+   *
+   * @param address The 40-bit address of the pipe to open.
+   */
+  void openWritingPipe(uint64_t address);
+
+  /**
+   * Empty the receive buffer
+   *
+   * @return Current value of status register
+   */
+  uint8_t flush_rx(void);
 
 private:
 
-    /**
-     * @name Low-level internal interface.
-     *
-     *  Protected methods that address the chip directly.  Regular users cannot
-     *  ever call these.  They are documented for completeness and for developers who
-     *  may want to extend this class.
-     */
-    /**@{*/
+  /**
+   * @name Low-level internal interface.
+   *
+   *  Protected methods that address the chip directly.  Regular users cannot
+   *  ever call these.  They are documented for completeness and for developers who
+   *  may want to extend this class.
+   */
+  /**@{*/
 
-    /**
-     * Set chip select pin
-     *
-     * Running SPI bus at PI_CLOCK_DIV2 so we don't waste time transferring data
-     * and best of all, we make use of the radio's FIFO buffers. A lower speed
-     * means we're less likely to effectively leverage our FIFOs and pay a higher
-     * AVR runtime cost as toll.
-     *
-     * @param level HIGH to actively begin transmission or LOW to put in standby.  Please see data sheet
-     * for a much more detailed description of this pin.
-     */
-    void csn(int mode);
+  /**
+   * Set chip select pin
+   *
+   * Running SPI bus at PI_CLOCK_DIV2 so we don't waste time transferring data
+   * and best of all, we make use of the radio's FIFO buffers. A lower speed
+   * means we're less likely to effectively leverage our FIFOs and pay a higher
+   * AVR runtime cost as toll.
+   *
+   * @param mode HIGH to take this unit off the SPI bus, LOW to put it on
+   */
+  void csn(bool mode);
 
-    /**
-     * Set chip enable
-     *
-     * @param mode HIGH to take this unit off the SPI bus, LOW to put it on
-     */
-    void ce(int level);
+  /**
+   * Set chip enable
+   *
+   * @param level HIGH to actively begin transmission or LOW to put in standby.  Please see data sheet
+   * for a much more detailed description of this pin.
+   */
+  void ce(bool level);
 
-    /**
-     * Read a chunk of data in from a register
-     *
-     * @param reg Which register. Use constants from nRF24L01.h
-     * @param buf Where to put the data
-     * @param len How many bytes of data to transfer
-     * @return Current value of status register
-     */
-    uint8_t read_register(uint8_t reg, uint8_t* buf, uint8_t len);
+  /**
+   * Read a chunk of data in from a register
+   *
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param buf Where to put the data
+   * @param len How many bytes of data to transfer
+   * @return Current value of status register
+   */
+  uint8_t read_register(uint8_t reg, uint8_t* buf, uint8_t len);
 
-    /**
-     * Read single byte from a register
-     *
-     * @param reg Which register. Use constants from nRF24L01.h
-     * @return Current value of register @p reg
-     */
-    uint8_t read_register(uint8_t reg);
+  /**
+   * Read single byte from a register
+   *
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @return Current value of register @p reg
+   */
+  uint8_t read_register(uint8_t reg);
 
-    /**
-     * Write a chunk of data to a register
-     *
-     * @param reg Which register. Use constants from nRF24L01.h
-     * @param buf Where to get the data
-     * @param len How many bytes of data to transfer
-     * @return Current value of status register
-     */
-    uint8_t write_register(uint8_t reg, const uint8_t* buf, uint8_t len);
+  /**
+   * Write a chunk of data to a register
+   *
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param buf Where to get the data
+   * @param len How many bytes of data to transfer
+   * @return Current value of status register
+   */
+  uint8_t write_register(uint8_t reg, const uint8_t* buf, uint8_t len);
 
-    /**
-     * Write a single byte to a register
-     *
-     * @param reg Which register. Use constants from nRF24L01.h
-     * @param value The new value to write
-     * @return Current value of status register
-     */
-    uint8_t write_register(uint8_t reg, uint8_t value);
+  /**
+   * Write a single byte to a register
+   *
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param value The new value to write
+   * @return Current value of status register
+   */
+  uint8_t write_register(uint8_t reg, uint8_t value);
 
-    /**
-     * Write the transmit payload
-     *
-     * The size of data written is the fixed payload size, see getPayloadSize()
-     *
-     * @param buf Where to get the data
-     * @param len Number of bytes to be sent
-     * @return Current value of status register
-     */
-    uint8_t write_payload(const void* buf, uint8_t len, const uint8_t writeType);
+  /**
+   * Write the transmit payload
+   *
+   * The size of data written is the fixed payload size, see getPayloadSize()
+   *
+   * @param buf Where to get the data
+   * @param len Number of bytes to be sent
+   * @return Current value of status register
+   */
+  uint8_t write_payload(const void* buf, uint8_t len, const uint8_t writeType);
 
-    /**
-     * Read the receive payload
-     *
-     * The size of data read is the fixed payload size, see getPayloadSize()
-     *
-     * @param buf Where to put the data
-     * @param len Maximum number of bytes to read
-     * @return Current value of status register
-     */
-    uint8_t read_payload(void* buf, uint8_t len);
+  /**
+   * Read the receive payload
+   *
+   * The size of data read is the fixed payload size, see getPayloadSize()
+   *
+   * @param buf Where to put the data
+   * @param len Maximum number of bytes to read
+   * @return Current value of status register
+   */
+  uint8_t read_payload(void* buf, uint8_t len);
 
-    /**
-     * Empty the receive buffer
-     *
-     * @return Current value of status register
-     */
-    uint8_t flush_rx(void);
+  /**
+   * Retrieve the current status of the chip
+   *
+   * @return Current value of status register
+   */
+  uint8_t get_status(void);
 
-    /**
-     * Retrieve the current status of the chip
-     *
-     * @return Current value of status register
-     */
-    uint8_t get_status(void);
+  #if !defined (MINIMAL)
+  /**
+   * Decode and print the given status to stdout
+   *
+   * @param status Status value to print
+   *
+   * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+   */
+  void print_status(uint8_t status);
 
-#if !defined (MINIMAL)
-    /**
-     * Decode and print the given status to stdout
-     *
-     * @param status Status value to print
-     *
-     * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
-     */
-    void print_status(uint8_t status);
-
-    /**
-     * Decode and print the given 'observe_tx' value to stdout
-     *
-     * @param value The observe_tx value to print
-     *
-     * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
-     */
-    void print_observe_tx(uint8_t value);
+  /**
+   * Decode and print the given 'observe_tx' value to stdout
+   *
+   * @param value The observe_tx value to print
+   *
+   * @warning Does nothing if stdout is not defined.  See fdevopen in stdio.h
+   */
+  void print_observe_tx(uint8_t value);
 
-    /**
-     * Print the name and value of an 8-bit register to stdout
-     *
-     * Optionally it can print some quantity of successive
-     * registers on the same line.  This is useful for printing a group
-     * of related registers on one line.
-     *
-     * @param name Name of the register
-     * @param reg Which register. Use constants from nRF24L01.h
-     * @param qty How many successive registers to print
-     */
-    void print_byte_register(const char* name, uint8_t reg, uint8_t qty = 1);
+  /**
+   * Print the name and value of an 8-bit register to stdout
+   *
+   * Optionally it can print some quantity of successive
+   * registers on the same line.  This is useful for printing a group
+   * of related registers on one line.
+   *
+   * @param name Name of the register
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param qty How many successive registers to print
+   */
+  void print_byte_register(const char* name, uint8_t reg, uint8_t qty = 1);
 
-    /**
-     * Print the name and value of a 40-bit address register to stdout
-     *
-     * Optionally it can print some quantity of successive
-     * registers on the same line.  This is useful for printing a group
-     * of related registers on one line.
-     *
-     * @param name Name of the register
-     * @param reg Which register. Use constants from nRF24L01.h
-     * @param qty How many successive registers to print
-     */
-    void print_address_register(const char* name, uint8_t reg, uint8_t qty = 1);
+  /**
+   * Print the name and value of a 40-bit address register to stdout
+   *
+   * Optionally it can print some quantity of successive
+   * registers on the same line.  This is useful for printing a group
+   * of related registers on one line.
+   *
+   * @param name Name of the register
+   * @param reg Which register. Use constants from nRF24L01.h
+   * @param qty How many successive registers to print
+   */
+  void print_address_register(const char* name, uint8_t reg, uint8_t qty = 1);
 #endif
-    /**
-     * Turn on or off the special features of the chip
-     *
-     * The chip has certain 'features' which are only available when the 'features'
-     * are enabled.  See the datasheet for details.
-     */
-    void toggle_features(void);
+  /**
+   * Turn on or off the special features of the chip
+   *
+   * The chip has certain 'features' which are only available when the 'features'
+   * are enabled.  See the datasheet for details.
+   */
+  void toggle_features(void);
 
-    /**
-     * Built in spi transfer function to simplify repeating code repeating code
-     */
-
-    uint8_t spiTrans(uint8_t cmd);
+  /**
+   * Built in spi transfer function to simplify repeating code repeating code
+   */
 
-#if defined (FAILURE_HANDLING)
+  uint8_t spiTrans(uint8_t cmd);
+  
+  #if defined (FAILURE_HANDLING) || defined (RF24_LINUX)
     void errNotify(void);
-#endif
-
-    /**@}*/
+  #endif
+  
+  /**@}*/
 
 };
 
 
 #endif // __RF24_H__
-
diff -r 836f5c6da243 -r 15a3bbf90fe9 RF24_config.h
--- a/RF24_config.h	Mon Mar 28 18:13:17 2016 +0000
+++ b/RF24_config.h	Fri Oct 06 20:20:33 2017 +0000
@@ -6,9 +6,9 @@
  modify it under the terms of the GNU General Public License
  version 2 as published by the Free Software Foundation.
  */
-
-/* spaniakos <spaniakos@gmail.com>
- Added __ARDUINO_X86__ support
+ 
+ /* spaniakos <spaniakos@gmail.com>
+  Added __ARDUINO_X86__ support
 */
 
 #ifndef __RF24_CONFIG_H__
@@ -16,29 +16,51 @@
 
 #include <stdint.h>
 
-#define rf24_max(a,b) (a>b?a:b)
-#define rf24_min(a,b) (a<b?a:b)
-
-#define RF24_SPI_TRANSACTIONS
+  /*** USER DEFINES:  ***/  
+  //#define FAILURE_HANDLING
+  //#define SERIAL_DEBUG
+  //#define MINIMAL
+  
+  /**********************/
+  #define rf24_max(a,b) (a>b?a:b)
+  #define rf24_min(a,b) (a<b?a:b)
 
-// RF modules support 10 Mhz SPI bus speed
-const uint32_t RF24_SPI_SPEED = 8000000;
-
-//typedef char const char;
+  #if defined SPI_HAS_TRANSACTION && !defined SPI_UART && !defined SOFTSPI
+    #define RF24_SPI_TRANSACTIONS
+  #endif
+ 
 
-typedef uint16_t prog_uint16_t;
-#define PSTR(x) (x)
-#define printf_P printf
-#define strlen_P strlen
-#define PROGMEM
-#define pgm_read_byte(addr) (*(const unsigned char *)(addr))
-#define pgm_read_word(p) (*(p))
+  #define RF24_MBED
+   
+  #define HIGH 1
+  #define LOW 0
+  
+  // Define _BV for non-Arduino platforms and for Arduino DUE
+  #include <stdint.h>
+  #include <stdio.h>
+  #include <string.h>
+ 
+  #define _BV(x) (1<<(x))
 
-#define PRIPSTR "%s"
+  #ifdef SERIAL_DEBUG
+    #define IF_SERIAL_DEBUG(x) ({x;})
+  #else
+    #define IF_SERIAL_DEBUG(x)
+  #endif
+    
+  #define PSTR(x) (x)
+  //#define printf Serial.printf
+  //#define sprintf(...) os_sprintf( __VA_ARGS__ )
+  #define printf_P printf
+  #define strlen_P strlen  
+  #define PROGMEM
+  #define pgm_read_byte(addr) (*(const unsigned char *)(addr))
+  #define pgm_read_word(p) (*(p))
+  #define PRIPSTR "%s"
 
-#define HIGH        1
-#define LOW         0
-#define _BV(n) (1 << n)
+  #define millis() (us_ticker_read() / 1000)
+  #define delay(t) wait_ms(t)
+  #define delayMicroseconds(t) wait_us(t) 
 
 #endif // __RF24_CONFIG_H__
 
diff -r 836f5c6da243 -r 15a3bbf90fe9 nRF24L01.h
--- a/nRF24L01.h	Mon Mar 28 18:13:17 2016 +0000
+++ b/nRF24L01.h	Fri Oct 06 20:20:33 2017 +0000
@@ -24,7 +24,7 @@
 */
 
 /* Memory Map */
-#define CONFIG      0x00
+#define NRF_CONFIG      0x00
 #define EN_AA       0x01
 #define EN_RXADDR   0x02
 #define SETUP_AW    0x03