diff options
Diffstat (limited to '.pio/libdeps/esp32-s3-n16r8/RF24/RF24.cpp')
| -rw-r--r-- | .pio/libdeps/esp32-s3-n16r8/RF24/RF24.cpp | 2209 |
1 files changed, 0 insertions, 2209 deletions
diff --git a/.pio/libdeps/esp32-s3-n16r8/RF24/RF24.cpp b/.pio/libdeps/esp32-s3-n16r8/RF24/RF24.cpp deleted file mode 100644 index 3b923b2..0000000 --- a/.pio/libdeps/esp32-s3-n16r8/RF24/RF24.cpp +++ /dev/null @@ -1,2209 +0,0 @@ -/* - Copyright (C) 2011 J. Coliz <maniacbug@ymail.com> - - This program is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License - version 2 as published by the Free Software Foundation. - */ - -#include "nRF24L01.h" -#include "RF24_config.h" -#include "RF24.h" - -/****************************************************************************/ - -void RF24::csn(bool mode) -{ -#if defined(RF24_TINY) - if (ce_pin != csn_pin) { - digitalWrite(csn_pin, mode); - } - else { - if (mode == HIGH) { - PORTB |= (1 << PINB2); // SCK->CSN HIGH - delayMicroseconds(RF24_CSN_SETTLE_HIGH_DELAY); // allow csn to settle. - } - else { - PORTB &= ~(1 << PINB2); // SCK->CSN LOW - delayMicroseconds(RF24_CSN_SETTLE_LOW_DELAY); // allow csn to settle - } - } - // Return, CSN toggle complete - return; - -#elif defined(ARDUINO) && !defined(RF24_SPI_TRANSACTIONS) - // Minimum ideal SPI bus speed is 2x data rate - // If we assume 2Mbs data rate and 16Mhz clock, a - // divider of 4 is the minimum we want. - // CLK:BUS 8Mhz:2Mhz, 16Mhz:4Mhz, or 20Mhz:5Mhz - - #if !defined(SOFTSPI) - // applies to SPI_UART and inherent hardware SPI - #if defined(RF24_SPI_PTR) - _spi->setBitOrder(MSBFIRST); - _spi->setDataMode(SPI_MODE0); - - #if !defined(F_CPU) || F_CPU < 20000000 - _spi->setClockDivider(SPI_CLOCK_DIV2); - #elif F_CPU < 40000000 - _spi->setClockDivider(SPI_CLOCK_DIV4); - #elif F_CPU < 80000000 - _spi->setClockDivider(SPI_CLOCK_DIV8); - #elif F_CPU < 160000000 - _spi->setClockDivider(SPI_CLOCK_DIV16); - #elif F_CPU < 320000000 - _spi->setClockDivider(SPI_CLOCK_DIV32); - #elif F_CPU < 640000000 - _spi->setClockDivider(SPI_CLOCK_DIV64); - #elif F_CPU < 1280000000 - _spi->setClockDivider(SPI_CLOCK_DIV128); - #else // F_CPU >= 1280000000 - #error "Unsupported CPU frequency. Please set correct SPI divider." - #endif // F_CPU to SPI_CLOCK_DIV translation - - #else // !defined(RF24_SPI_PTR) - _SPI.setBitOrder(MSBFIRST); - _SPI.setDataMode(SPI_MODE0); - - #if !defined(F_CPU) || F_CPU < 20000000 - _SPI.setClockDivider(SPI_CLOCK_DIV2); - #elif F_CPU < 40000000 - _SPI.setClockDivider(SPI_CLOCK_DIV4); - #elif F_CPU < 80000000 - _SPI.setClockDivider(SPI_CLOCK_DIV8); - #elif F_CPU < 160000000 - _SPI.setClockDivider(SPI_CLOCK_DIV16); - #elif F_CPU < 320000000 - _SPI.setClockDivider(SPI_CLOCK_DIV32); - #elif F_CPU < 640000000 - _SPI.setClockDivider(SPI_CLOCK_DIV64); - #elif F_CPU < 1280000000 - _SPI.setClockDivider(SPI_CLOCK_DIV128); - #else // F_CPU >= 1280000000 - #error "Unsupported CPU frequency. Please set correct SPI divider." - #endif // F_CPU to SPI_CLOCK_DIV translation - #endif // !defined(RF24_SPI_PTR) - #endif // !defined(SOFTSPI) - -#elif defined(RF24_RPi) - if (!mode) - _SPI.chipSelect(csn_pin); -#endif // defined(RF24_RPi) - -#if !defined(RF24_LINUX) - digitalWrite(csn_pin, mode); - delayMicroseconds(csDelay); -#else - static_cast<void>(mode); // ignore -Wunused-parameter -#endif // !defined(RF24_LINUX) -} - -/****************************************************************************/ - -void RF24::ce(bool level) -{ -#ifndef RF24_LINUX - //Allow for 3-pin use on ATTiny - if (ce_pin != csn_pin) { -#endif - digitalWrite(ce_pin, level); -#ifndef RF24_LINUX - } -#endif -} - -/****************************************************************************/ - -inline void RF24::beginTransaction() -{ -#if defined(RF24_SPI_TRANSACTIONS) - #if defined(RF24_SPI_PTR) - #if defined(RF24_RP2) - _spi->beginTransaction(spi_speed); - #else // ! defined (RF24_RP2) - _spi->beginTransaction(SPISettings(spi_speed, MSBFIRST, SPI_MODE0)); - #endif // ! defined (RF24_RP2) - #else // !defined(RF24_SPI_PTR) - _SPI.beginTransaction(SPISettings(spi_speed, MSBFIRST, SPI_MODE0)); - #endif // !defined(RF24_SPI_PTR) -#endif // defined (RF24_SPI_TRANSACTIONS) - csn(LOW); -} - -/****************************************************************************/ - -inline void RF24::endTransaction() -{ - csn(HIGH); -#if defined(RF24_SPI_TRANSACTIONS) - #if defined(RF24_SPI_PTR) - _spi->endTransaction(); - #else // !defined(RF24_SPI_PTR) - _SPI.endTransaction(); - #endif // !defined(RF24_SPI_PTR) -#endif // defined (RF24_SPI_TRANSACTIONS) -} - -/****************************************************************************/ - -void RF24::read_register(uint8_t reg, uint8_t* buf, uint8_t len) -{ -#if defined(RF24_LINUX) || defined(RF24_RP2) - beginTransaction(); //configures the spi settings for RPi, locks mutex and setting csn low - uint8_t* prx = spi_rxbuff; - uint8_t* ptx = spi_txbuff; - uint8_t size = static_cast<uint8_t>(len + 1); // Add register value to transmit buffer - - *ptx++ = reg; - - while (len--) { - *ptx++ = nRF24L01::NOP; // Dummy operation, just for reading - } - - #if defined(RF24_RP2) - _spi->transfernb((const uint8_t*)spi_txbuff, spi_rxbuff, size); - #else // !defined (RF24_RP2) - _SPI.transfernb(reinterpret_cast<char*>(spi_txbuff), reinterpret_cast<char*>(spi_rxbuff), size); - #endif // !defined (RF24_RP2) - - status = *prx++; // status is 1st byte of receive buffer - - // decrement before to skip status byte - while (--size) { - *buf++ = *prx++; - } - - endTransaction(); // unlocks mutex and setting csn high - -#else // !defined(RF24_LINUX) && !defined(RF24_RP2) - - beginTransaction(); - #if defined(RF24_SPI_PTR) - status = _spi->transfer(reg); - while (len--) { - *buf++ = _spi->transfer(0xFF); - } - - #else // !defined(RF24_SPI_PTR) - status = _SPI.transfer(reg); - while (len--) { - *buf++ = _SPI.transfer(0xFF); - } - - #endif // !defined(RF24_SPI_PTR) - endTransaction(); -#endif // !defined(RF24_LINUX) && !defined(RF24_RP2) -} - -/****************************************************************************/ - -uint8_t RF24::read_register(uint8_t reg) -{ - uint8_t result; - -#if defined(RF24_LINUX) || defined(RF24_RP2) - beginTransaction(); - - uint8_t* prx = spi_rxbuff; - uint8_t* ptx = spi_txbuff; - *ptx++ = reg; - *ptx++ = nRF24L01::NOP; // Dummy operation, just for reading - - #if defined(RF24_RP2) - _spi->transfernb((const uint8_t*)spi_txbuff, spi_rxbuff, 2); - #else // !defined(RF24_RP2) - _SPI.transfernb(reinterpret_cast<char*>(spi_txbuff), reinterpret_cast<char*>(spi_rxbuff), 2); - #endif // !defined(RF24_RP2) - - status = *prx; // status is 1st byte of receive buffer - result = *++prx; // result is 2nd byte of receive buffer - - endTransaction(); -#else // !defined(RF24_LINUX) && !defined(RF24_RP2) - - beginTransaction(); - #if defined(RF24_SPI_PTR) - status = _spi->transfer(reg); - result = _spi->transfer(0xff); - - #else // !defined(RF24_SPI_PTR) - status = _SPI.transfer(reg); - result = _SPI.transfer(0xff); - - #endif // !defined(RF24_SPI_PTR) - endTransaction(); -#endif // !defined(RF24_LINUX) && !defined(RF24_RP2) - - return result; -} - -/****************************************************************************/ - -void RF24::write_register(uint8_t reg, const uint8_t* buf, uint8_t len) -{ -#if defined(RF24_LINUX) || defined(RF24_RP2) - beginTransaction(); - uint8_t* prx = spi_rxbuff; - uint8_t* ptx = spi_txbuff; - uint8_t size = static_cast<uint8_t>(len + 1); // Add register value to transmit buffer - - *ptx++ = (nRF24L01::W_REGISTER | reg); - while (len--) { - *ptx++ = *buf++; - } - - #if defined(RF24_RP2) - _spi->transfernb((const uint8_t*)spi_txbuff, spi_rxbuff, size); - #else // !defined(RF24_RP2) - _SPI.transfernb(reinterpret_cast<char*>(spi_txbuff), reinterpret_cast<char*>(spi_rxbuff), size); - #endif // !defined(RF24_RP2) - - status = *prx; // status is 1st byte of receive buffer - endTransaction(); -#else // !defined(RF24_LINUX) && !defined(RF24_RP2) - - beginTransaction(); - #if defined(RF24_SPI_PTR) - status = _spi->transfer(nRF24L01::W_REGISTER | reg); - while (len--) { - _spi->transfer(*buf++); - } - - #else // !defined(RF24_SPI_PTR) - status = _SPI.transfer(nRF24L01::W_REGISTER | reg); - while (len--) { - _SPI.transfer(*buf++); - } - - #endif // !defined(RF24_SPI_PTR) - endTransaction(); -#endif // !defined(RF24_LINUX) && !defined(RF24_RP2) -} - -/****************************************************************************/ - -void RF24::write_register(uint8_t reg, uint8_t value) -{ - IF_RF24_DEBUG(printf_P(PSTR("write_register(%02x,%02x)\r\n"), reg, value)); -#if defined(RF24_LINUX) || defined(RF24_RP2) - beginTransaction(); - uint8_t* prx = spi_rxbuff; - uint8_t* ptx = spi_txbuff; - *ptx++ = (nRF24L01::W_REGISTER | reg); - *ptx = value; - - #if defined(RF24_RP2) - _spi->transfernb((const uint8_t*)spi_txbuff, spi_rxbuff, 2); - #else // !defined(RF24_RP2) - _SPI.transfernb(reinterpret_cast<char*>(spi_txbuff), reinterpret_cast<char*>(spi_rxbuff), 2); - #endif // !defined(RF24_RP2) - - status = *prx++; // status is 1st byte of receive buffer - endTransaction(); -#else // !defined(RF24_LINUX) && !defined(RF24_RP2) - - beginTransaction(); - #if defined(RF24_SPI_PTR) - status = _spi->transfer(nRF24L01::W_REGISTER | reg); - _spi->transfer(value); - #else // !defined(RF24_SPI_PTR) - status = _SPI.transfer(nRF24L01::W_REGISTER | reg); - _SPI.transfer(value); - #endif // !defined(RF24_SPI_PTR) - endTransaction(); -#endif // !defined(RF24_LINUX) && !defined(RF24_RP2) -} - -/****************************************************************************/ - -void RF24::write_payload(const void* buf, uint8_t data_len, const uint8_t writeType) -{ - const uint8_t* current = reinterpret_cast<const uint8_t*>(buf); - - uint8_t blank_len = !data_len ? 1 : 0; - if (!dynamic_payloads_enabled) { - data_len = rf24_min(data_len, payload_size); - blank_len = static_cast<uint8_t>(payload_size - data_len); - } - else { - data_len = rf24_min(data_len, static_cast<uint8_t>(32)); - } - - //printf("[Writing %u bytes %u blanks]",data_len,blank_len); - IF_RF24_DEBUG(printf_P("[Writing %u bytes %u blanks]\n", data_len, blank_len);); - -#if defined(RF24_LINUX) || defined(RF24_RP2) - beginTransaction(); - uint8_t* prx = spi_rxbuff; - uint8_t* ptx = spi_txbuff; - uint8_t size; - size = static_cast<uint8_t>(data_len + blank_len + 1); // Add register value to transmit buffer - - *ptx++ = writeType; - while (data_len--) { - *ptx++ = *current++; - } - - while (blank_len--) { - *ptx++ = 0; - } - - #if defined(RF24_RP2) - _spi->transfernb((const uint8_t*)spi_txbuff, spi_rxbuff, size); - #else // !defined(RF24_RP2) - _SPI.transfernb(reinterpret_cast<char*>(spi_txbuff), reinterpret_cast<char*>(spi_rxbuff), size); - #endif // !defined(RF24_RP2) - - status = *prx; // status is 1st byte of receive buffer - endTransaction(); - -#else // !defined(RF24_LINUX) && !defined(RF24_RP2) - - beginTransaction(); - #if defined(RF24_SPI_PTR) - status = _spi->transfer(writeType); - while (data_len--) { - _spi->transfer(*current++); - } - - while (blank_len--) { - _spi->transfer(0); - } - - #else // !defined(RF24_SPI_PTR) - status = _SPI.transfer(writeType); - while (data_len--) { - _SPI.transfer(*current++); - } - - while (blank_len--) { - _SPI.transfer(0); - } - - #endif // !defined(RF24_SPI_PTR) - endTransaction(); -#endif // !defined(RF24_LINUX) && !defined(RF24_RP2) -} - -/****************************************************************************/ - -void RF24::read_payload(void* buf, uint8_t data_len) -{ - uint8_t* current = reinterpret_cast<uint8_t*>(buf); - - uint8_t blank_len = 0; - if (!dynamic_payloads_enabled) { - data_len = rf24_min(data_len, payload_size); - blank_len = static_cast<uint8_t>(payload_size - data_len); - } - else { - data_len = rf24_min(data_len, static_cast<uint8_t>(32)); - } - - //printf("[Reading %u bytes %u blanks]",data_len,blank_len); - - IF_RF24_DEBUG(printf_P("[Reading %u bytes %u blanks]\n", data_len, blank_len);); - -#if defined(RF24_LINUX) || defined(RF24_RP2) - beginTransaction(); - uint8_t* prx = spi_rxbuff; - uint8_t* ptx = spi_txbuff; - uint8_t size; - size = static_cast<uint8_t>(data_len + blank_len + 1); // Add register value to transmit buffer - - *ptx++ = nRF24L01::R_RX_PAYLOAD; - while (--size) { - *ptx++ = nRF24L01::NOP; - } - - size = static_cast<uint8_t>(data_len + blank_len + 1); // Size has been lost during while, re affect - - #if defined(RF24_RP2) - _spi->transfernb((const uint8_t*)spi_txbuff, spi_rxbuff, size); - #else // !defined(RF24_RP2) - _SPI.transfernb(reinterpret_cast<char*>(spi_txbuff), reinterpret_cast<char*>(spi_rxbuff), size); - #endif // !defined(RF24_RP2) - - status = *prx++; // 1st byte is status - - if (data_len > 0) { - // Decrement before to skip 1st status byte - while (--data_len) { - *current++ = *prx++; - } - - *current = *prx; - } - endTransaction(); -#else // !defined(RF24_LINUX) && !defined(RF24_RP2) - - beginTransaction(); - #if defined(RF24_SPI_PTR) - status = _spi->transfer(nRF24L01::R_RX_PAYLOAD); - while (data_len--) { - *current++ = _spi->transfer(0xFF); - } - - while (blank_len--) { - _spi->transfer(0xFF); - } - - #else // !defined(RF24_SPI_PTR) - status = _SPI.transfer(nRF24L01::R_RX_PAYLOAD); - while (data_len--) { - *current++ = _SPI.transfer(0xFF); - } - - while (blank_len--) { - _SPI.transfer(0xff); - } - - #endif // !defined(RF24_SPI_PTR) - endTransaction(); - -#endif // !defined(RF24_LINUX) && !defined(RF24_RP2) -} - -/****************************************************************************/ - -uint8_t RF24::flush_rx(void) -{ - read_register(nRF24L01::FLUSH_RX, (uint8_t*)nullptr, 0); - IF_RF24_DEBUG(printf_P("[Flushing RX FIFO]");); - return status; -} - -/****************************************************************************/ - -uint8_t RF24::flush_tx(void) -{ - read_register(nRF24L01::FLUSH_TX, (uint8_t*)nullptr, 0); - IF_RF24_DEBUG(printf_P("[Flushing RX FIFO]");); - return status; -} - -/****************************************************************************/ -#if !defined(MINIMAL) - -void RF24::printStatus(uint8_t flags) -{ - printf_P(PSTR("RX_DR=%x TX_DS=%x TX_DF=%x RX_PIPE=%x TX_FULL=%x\r\n"), - (flags & RF24_RX_DR) ? 1 : 0, - (flags & RF24_TX_DS) ? 1 : 0, - (flags & RF24_TX_DF) ? 1 : 0, - (flags >> nRF24L01::RX_P_NO) & 0x07, - (flags & _BV(nRF24L01::TX_FULL)) ? 1 : 0); -} - -/****************************************************************************/ - -void RF24::print_observe_tx(uint8_t value) -{ - printf_P(PSTR("OBSERVE_TX=%02x: PLOS_CNT=%x ARC_CNT=%x\r\n"), value, (value >> nRF24L01::PLOS_CNT) & 0x0F, (value >> nRF24L01::ARC_CNT) & 0x0F); -} - -/****************************************************************************/ - -void RF24::print_byte_register(const char* name, uint8_t reg, uint8_t qty) -{ - printf_P(PSTR(PRIPSTR - "\t="), - name); - while (qty--) { - printf_P(PSTR(" 0x%02x"), read_register(reg++)); - } - printf_P(PSTR("\r\n")); -} - -/****************************************************************************/ - -void RF24::print_address_register(const char* name, uint8_t reg, uint8_t qty) -{ - - printf_P(PSTR(PRIPSTR - "\t="), - name); - while (qty--) { - uint8_t* buffer = new uint8_t[addr_width]; - read_register(reg++, buffer, addr_width); - - printf_P(PSTR(" 0x")); - uint8_t* bufptr = buffer + addr_width; - while (--bufptr >= buffer) { - printf_P(PSTR("%02x"), *bufptr); // NOLINT: clang-tidy seems to emit a false positive about zero-allocated memory here (*bufptr) - } - delete[] buffer; - } - printf_P(PSTR("\r\n")); -} - -/****************************************************************************/ - -uint8_t RF24::sprintf_address_register(char* out_buffer, uint8_t reg, uint8_t qty) -{ - uint8_t offset = 0; - uint8_t* read_buffer = new uint8_t[addr_width]; - while (qty--) { - read_register(reg++, read_buffer, addr_width); - uint8_t* bufptr = read_buffer + addr_width; - while (--bufptr >= read_buffer) { - offset += sprintf_P(out_buffer + offset, PSTR("%02X"), *bufptr); // NOLINT(clang-analyzer-cplusplus.NewDelete) - } - } - delete[] read_buffer; - return offset; -} -#endif // !defined(MINIMAL) - -/****************************************************************************/ - -RF24::RF24(rf24_gpio_pin_t _cepin, rf24_gpio_pin_t _cspin, uint32_t _spi_speed) - : ce_pin(_cepin), - csn_pin(_cspin), - spi_speed(_spi_speed), - payload_size(32), - _is_p_variant(false), - _is_p0_rx(false), - addr_width(5), - dynamic_payloads_enabled(true), -#if defined FAILURE_HANDLING - failureDetected(0), -#endif - csDelay(5) -{ - _init_obj(); -} - -/****************************************************************************/ - -RF24::RF24(uint32_t _spi_speed) - : ce_pin(RF24_PIN_INVALID), - csn_pin(RF24_PIN_INVALID), - spi_speed(_spi_speed), - payload_size(32), - _is_p_variant(false), - _is_p0_rx(false), - addr_width(5), - dynamic_payloads_enabled(true), -#if defined FAILURE_HANDLING - failureDetected(0), -#endif - csDelay(5) -{ - _init_obj(); -} - -/****************************************************************************/ - -void RF24::_init_obj() -{ - // Use a pointer on the Arduino platform - -#if defined(RF24_SPI_PTR) && !defined(RF24_RP2) - _spi = &SPI; -#endif // defined (RF24_SPI_PTR) - - if (spi_speed <= 35000) { //Handle old BCM2835 speed constants, default to RF24_SPI_SPEED - spi_speed = RF24_SPI_SPEED; - } -} - -/****************************************************************************/ - -void RF24::setChannel(uint8_t channel) -{ - const uint8_t max_channel = 125; - write_register(nRF24L01::RF_CH, rf24_min(channel, max_channel)); -} - -uint8_t RF24::getChannel() -{ - return read_register(nRF24L01::RF_CH); -} - -/****************************************************************************/ - -void RF24::setPayloadSize(uint8_t size) -{ - // payload size must be in range [1, 32] - payload_size = static_cast<uint8_t>(rf24_max(1, rf24_min(32, size))); - - // write static payload size setting for all pipes - for (uint8_t i = 0; i < 6; ++i) { - write_register(static_cast<uint8_t>(nRF24L01::RX_PW_P0 + i), payload_size); - } -} - -/****************************************************************************/ - -uint8_t RF24::getPayloadSize(void) -{ - return payload_size; -} - -/****************************************************************************/ - -#if !defined(MINIMAL) - -static const PROGMEM char rf24_datarate_e_str_0[] = "= 1 MBPS"; -static const PROGMEM char rf24_datarate_e_str_1[] = "= 2 MBPS"; -static const PROGMEM char rf24_datarate_e_str_2[] = "= 250 KBPS"; -static const PROGMEM char* const rf24_datarate_e_str_P[] = { - rf24_datarate_e_str_0, - rf24_datarate_e_str_1, - rf24_datarate_e_str_2, -}; -static const PROGMEM char rf24_model_e_str_0[] = "nRF24L01"; -static const PROGMEM char rf24_model_e_str_1[] = "nRF24L01+"; -static const PROGMEM char* const rf24_model_e_str_P[] = { - rf24_model_e_str_0, - rf24_model_e_str_1, -}; -static const PROGMEM char rf24_crclength_e_str_0[] = "= Disabled"; -static const PROGMEM char rf24_crclength_e_str_1[] = "= 8 bits"; -static const PROGMEM char rf24_crclength_e_str_2[] = "= 16 bits"; -static const PROGMEM char* const rf24_crclength_e_str_P[] = { - rf24_crclength_e_str_0, - rf24_crclength_e_str_1, - rf24_crclength_e_str_2, -}; -static const PROGMEM char rf24_pa_dbm_e_str_0[] = "= PA_MIN"; -static const PROGMEM char rf24_pa_dbm_e_str_1[] = "= PA_LOW"; -static const PROGMEM char rf24_pa_dbm_e_str_2[] = "= PA_HIGH"; -static const PROGMEM char rf24_pa_dbm_e_str_3[] = "= PA_MAX"; -static const PROGMEM char* const rf24_pa_dbm_e_str_P[] = { - rf24_pa_dbm_e_str_0, - rf24_pa_dbm_e_str_1, - rf24_pa_dbm_e_str_2, - rf24_pa_dbm_e_str_3, -}; - -static const PROGMEM char rf24_feature_e_str_on[] = "= Enabled"; -static const PROGMEM char rf24_feature_e_str_allowed[] = "= Allowed"; -static const PROGMEM char rf24_feature_e_str_open[] = " open "; -static const PROGMEM char rf24_feature_e_str_closed[] = "closed"; -static const PROGMEM char* const rf24_feature_e_str_P[] = { - rf24_crclength_e_str_0, - rf24_feature_e_str_on, - rf24_feature_e_str_allowed, - rf24_feature_e_str_closed, - rf24_feature_e_str_open, -}; - -void RF24::printDetails(void) -{ - - #if defined(RF24_LINUX) - printf("================ SPI Configuration ================\n"); - uint8_t bus_ce = static_cast<uint8_t>(csn_pin % 10); - uint8_t bus_numb = static_cast<uint8_t>((csn_pin - bus_ce) / 10); - printf("CSN Pin\t\t= /dev/spidev%d.%d\n", bus_numb, bus_ce); - printf("CE Pin\t\t= Custom GPIO%d\n", ce_pin); - #endif - printf_P(PSTR("SPI Speedz\t= %d Mhz\n"), static_cast<uint8_t>(spi_speed / 1000000)); //Print the SPI speed on non-Linux devices - #if defined(RF24_LINUX) - printf("================ NRF Configuration ================\n"); - #endif // defined(RF24_LINUX) - - uint8_t status = update(); - printf_P(PSTR("STATUS\t\t= 0x%02x "), status); - printStatus(status); - - print_address_register(PSTR("RX_ADDR_P0-1"), nRF24L01::RX_ADDR_P0, 2); - print_byte_register(PSTR("RX_ADDR_P2-5"), nRF24L01::RX_ADDR_P2, 4); - print_address_register(PSTR("TX_ADDR\t"), nRF24L01::TX_ADDR); - - print_byte_register(PSTR("RX_PW_P0-6"), nRF24L01::RX_PW_P0, 6); - print_byte_register(PSTR("EN_AA\t"), nRF24L01::EN_AA); - print_byte_register(PSTR("EN_RXADDR"), nRF24L01::EN_RXADDR); - print_byte_register(PSTR("RF_CH\t"), nRF24L01::RF_CH); - print_byte_register(PSTR("RF_SETUP"), nRF24L01::RF_SETUP); - print_byte_register(PSTR("CONFIG\t"), nRF24L01::CONFIG); - print_byte_register(PSTR("DYNPD/FEATURE"), nRF24L01::DYNPD, 2); - - printf_P(PSTR("Data Rate\t" PRIPSTR - "\r\n"), - (char*)(pgm_read_ptr(&rf24_datarate_e_str_P[getDataRate()]))); - printf_P(PSTR("Model\t\t= " PRIPSTR - "\r\n"), - (char*)(pgm_read_ptr(&rf24_model_e_str_P[isPVariant()]))); - printf_P(PSTR("CRC Length\t" PRIPSTR - "\r\n"), - (char*)(pgm_read_ptr(&rf24_crclength_e_str_P[getCRCLength()]))); - printf_P(PSTR("PA Power\t" PRIPSTR - "\r\n"), - (char*)(pgm_read_ptr(&rf24_pa_dbm_e_str_P[getPALevel()]))); - printf_P(PSTR("ARC\t\t= %d\r\n"), getARC()); -} - -void RF24::printPrettyDetails(void) -{ - - #if defined(RF24_LINUX) - printf("================ SPI Configuration ================\n"); - uint8_t bus_ce = static_cast<uint8_t>(csn_pin % 10); - uint8_t bus_numb = static_cast<uint8_t>((csn_pin - bus_ce) / 10); - printf("CSN Pin\t\t\t= /dev/spidev%d.%d\n", bus_numb, bus_ce); - printf("CE Pin\t\t\t= Custom GPIO%d\n", ce_pin); - #endif - printf_P(PSTR("SPI Frequency\t\t= %d Mhz\n"), static_cast<uint8_t>(spi_speed / 1000000)); //Print the SPI speed on non-Linux devices - #if defined(RF24_LINUX) - printf("================ NRF Configuration ================\n"); - #endif // defined(RF24_LINUX) - - uint8_t channel = getChannel(); - uint16_t frequency = static_cast<uint16_t>(channel + 2400); - printf_P(PSTR("Channel\t\t\t= %u (~ %u MHz)\r\n"), channel, frequency); - printf_P(PSTR("Model\t\t\t= " PRIPSTR - "\r\n"), - (char*)(pgm_read_ptr(&rf24_model_e_str_P[isPVariant()]))); - - printf_P(PSTR("RF Data Rate\t\t" PRIPSTR - "\r\n"), - (char*)(pgm_read_ptr(&rf24_datarate_e_str_P[getDataRate()]))); - printf_P(PSTR("RF Power Amplifier\t" PRIPSTR - "\r\n"), - (char*)(pgm_read_ptr(&rf24_pa_dbm_e_str_P[getPALevel()]))); - printf_P(PSTR("RF Low Noise Amplifier\t" PRIPSTR - "\r\n"), - (char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>((read_register(nRF24L01::RF_SETUP) & 1) * 1)]))); - printf_P(PSTR("CRC Length\t\t" PRIPSTR - "\r\n"), - (char*)(pgm_read_ptr(&rf24_crclength_e_str_P[getCRCLength()]))); - printf_P(PSTR("Address Length\t\t= %d bytes\r\n"), (read_register(nRF24L01::SETUP_AW) & 3) + 2); - printf_P(PSTR("Static Payload Length\t= %d bytes\r\n"), getPayloadSize()); - - uint8_t setupRetry = read_register(nRF24L01::SETUP_RETR); - printf_P(PSTR("Auto Retry Delay\t= %d microseconds\r\n"), (setupRetry >> nRF24L01::ARD) * 250 + 250); - printf_P(PSTR("Auto Retry Attempts\t= %d maximum\r\n"), setupRetry & 0x0F); - - uint8_t observeTx = read_register(nRF24L01::OBSERVE_TX); - printf_P(PSTR("Packets lost on\n current channel\t= %d\r\n"), observeTx >> 4); - printf_P(PSTR("Retry attempts made for\n last transmission\t= %d\r\n"), observeTx & 0x0F); - - uint8_t features = read_register(nRF24L01::FEATURE); - printf_P(PSTR("Multicast\t\t" PRIPSTR - "\r\n"), - (char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>(static_cast<bool>(features & _BV(nRF24L01::EN_DYN_ACK)) * 2)]))); - printf_P(PSTR("Custom ACK Payload\t" PRIPSTR - "\r\n"), - (char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>(static_cast<bool>(features & _BV(nRF24L01::EN_ACK_PAY)) * 1)]))); - - uint8_t dynPl = read_register(nRF24L01::DYNPD); - printf_P(PSTR("Dynamic Payloads\t" PRIPSTR - "\r\n"), - (char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>((dynPl && (features & _BV(nRF24L01::EN_DPL))) * 1)]))); - - uint8_t autoAck = read_register(nRF24L01::EN_AA); - if (autoAck == 0x3F || autoAck == 0) { - // all pipes have the same configuration about auto-ack feature - printf_P(PSTR("Auto Acknowledgment\t" PRIPSTR - "\r\n"), - (char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>(static_cast<bool>(autoAck) * 1)]))); - } - else { - // representation per pipe - printf_P(PSTR("Auto Acknowledgment\t= 0b%c%c%c%c%c%c\r\n"), - static_cast<char>(static_cast<bool>(autoAck & _BV(nRF24L01::ENAA_P5)) + 48), - static_cast<char>(static_cast<bool>(autoAck & _BV(nRF24L01::ENAA_P4)) + 48), - static_cast<char>(static_cast<bool>(autoAck & _BV(nRF24L01::ENAA_P3)) + 48), - static_cast<char>(static_cast<bool>(autoAck & _BV(nRF24L01::ENAA_P2)) + 48), - static_cast<char>(static_cast<bool>(autoAck & _BV(nRF24L01::ENAA_P1)) + 48), - static_cast<char>(static_cast<bool>(autoAck & _BV(nRF24L01::ENAA_P0)) + 48)); - } - - config_reg = read_register(nRF24L01::CONFIG); - printf_P(PSTR("Primary Mode\t\t= %cX\r\n"), config_reg & _BV(nRF24L01::PRIM_RX) ? 'R' : 'T'); - print_address_register(PSTR("TX address\t"), nRF24L01::TX_ADDR); - - uint8_t openPipes = read_register(nRF24L01::EN_RXADDR); - for (uint8_t i = 0; i < 6; ++i) { - bool isOpen = openPipes & _BV(i); - printf_P(PSTR("pipe %u (" PRIPSTR - ") bound"), - i, (char*)(pgm_read_ptr(&rf24_feature_e_str_P[isOpen + 3]))); - if (i < 2) { - print_address_register(PSTR(""), static_cast<uint8_t>(nRF24L01::RX_ADDR_P0 + i)); - } - else { - print_byte_register(PSTR(""), static_cast<uint8_t>(nRF24L01::RX_ADDR_P0 + i)); - } - } -} - -/****************************************************************************/ - -uint16_t RF24::sprintfPrettyDetails(char* debugging_information) -{ - const char* format_string = PSTR( - "================ SPI Configuration ================\n" - "CSN Pin\t\t\t= %d\n" - "CE Pin\t\t\t= %d\n" - "SPI Frequency\t\t= %d Mhz\n" - "================ NRF Configuration ================\n" - "Channel\t\t\t= %u (~ %u MHz)\n" - "RF Data Rate\t\t" PRIPSTR "\n" - "RF Power Amplifier\t" PRIPSTR "\n" - "RF Low Noise Amplifier\t" PRIPSTR "\n" - "CRC Length\t\t" PRIPSTR "\n" - "Address Length\t\t= %d bytes\n" - "Static Payload Length\t= %d bytes\n" - "Auto Retry Delay\t= %d microseconds\n" - "Auto Retry Attempts\t= %d maximum\n" - "Packets lost on\n current channel\t= %d\r\n" - "Retry attempts made for\n last transmission\t= %d\r\n" - "Multicast\t\t" PRIPSTR "\n" - "Custom ACK Payload\t" PRIPSTR "\n" - "Dynamic Payloads\t" PRIPSTR "\n" - "Auto Acknowledgment\t"); - const char* format_str2 = PSTR("\nPrimary Mode\t\t= %cX\nTX address\t\t= 0x"); - const char* format_str3 = PSTR("\nPipe %d (" PRIPSTR ") bound\t= 0x"); - - uint16_t offset = sprintf_P( - debugging_information, format_string, csn_pin, ce_pin, - static_cast<uint8_t>(spi_speed / 1000000), getChannel(), - static_cast<uint16_t>(getChannel() + 2400), - (char*)(pgm_read_ptr(&rf24_datarate_e_str_P[getDataRate()])), - (char*)(pgm_read_ptr(&rf24_pa_dbm_e_str_P[getPALevel()])), - (char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>((read_register(nRF24L01::RF_SETUP) & 1) * 1)])), - (char*)(pgm_read_ptr(&rf24_crclength_e_str_P[getCRCLength()])), - ((read_register(nRF24L01::SETUP_AW) & 3) + 2), getPayloadSize(), - ((read_register(nRF24L01::SETUP_RETR) >> nRF24L01::ARD) * 250 + 250), - (read_register(nRF24L01::SETUP_RETR) & 0x0F), (read_register(nRF24L01::OBSERVE_TX) >> 4), - (read_register(nRF24L01::OBSERVE_TX) & 0x0F), - (char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>(static_cast<bool>(read_register(nRF24L01::FEATURE) & _BV(nRF24L01::EN_DYN_ACK)) * 2)])), - (char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>(static_cast<bool>(read_register(nRF24L01::FEATURE) & _BV(nRF24L01::EN_ACK_PAY)) * 1)])), - (char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>((read_register(nRF24L01::DYNPD) && (read_register(nRF24L01::FEATURE) & _BV(nRF24L01::EN_DPL))) * 1)]))); - uint8_t autoAck = read_register(nRF24L01::EN_AA); - if (autoAck == 0x3F || autoAck == 0) { - // all pipes have the same configuration about auto-ack feature - offset += sprintf_P( - debugging_information + offset, PSTR("" PRIPSTR ""), - (char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<uint8_t>(static_cast<bool>(autoAck) * 1)]))); - } - else { - // representation per pipe - offset += sprintf_P( - debugging_information + offset, PSTR("= 0b%c%c%c%c%c%c"), - static_cast<char>(static_cast<bool>(autoAck & _BV(nRF24L01::ENAA_P5)) + 48), - static_cast<char>(static_cast<bool>(autoAck & _BV(nRF24L01::ENAA_P4)) + 48), - static_cast<char>(static_cast<bool>(autoAck & _BV(nRF24L01::ENAA_P3)) + 48), - static_cast<char>(static_cast<bool>(autoAck & _BV(nRF24L01::ENAA_P2)) + 48), - static_cast<char>(static_cast<bool>(autoAck & _BV(nRF24L01::ENAA_P1)) + 48), - static_cast<char>(static_cast<bool>(autoAck & _BV(nRF24L01::ENAA_P0)) + 48)); - } - offset += sprintf_P( - debugging_information + offset, format_str2, - (read_register(nRF24L01::CONFIG) & _BV(nRF24L01::PRIM_RX) ? 'R' : 'T')); - offset += sprintf_address_register(debugging_information + offset, nRF24L01::TX_ADDR); - uint8_t openPipes = read_register(nRF24L01::EN_RXADDR); - for (uint8_t i = 0; i < 6; ++i) { - offset += sprintf_P( - debugging_information + offset, format_str3, - i, ((char*)(pgm_read_ptr(&rf24_feature_e_str_P[static_cast<bool>(openPipes & _BV(i)) + 3])))); - if (i < 2) { - offset += sprintf_address_register( - debugging_information + offset, static_cast<uint8_t>(nRF24L01::RX_ADDR_P0 + i)); - } - else { - offset += sprintf_P( - debugging_information + offset, PSTR("%02X"), - read_register(static_cast<uint8_t>(nRF24L01::RX_ADDR_P0 + i))); - } - } - return offset; -} - -/****************************************************************************/ - -void RF24::encodeRadioDetails(uint8_t* encoded_details) -{ - uint8_t end = nRF24L01::FEATURE + 1; - for (uint8_t i = nRF24L01::CONFIG; i < end; ++i) { - if (i == nRF24L01::RX_ADDR_P0 || i == nRF24L01::RX_ADDR_P1 || i == nRF24L01::TX_ADDR) { - // get 40-bit registers - read_register(i, encoded_details, 5); - encoded_details += 5; - } - else if (i != 0x18 && i != 0x19 && i != 0x1a && i != 0x1b) { // skip undocumented registers - // get single byte registers - *encoded_details++ = read_register(i); - } - } - *encoded_details++ = ce_pin >> 4; - *encoded_details++ = ce_pin & 0xFF; - *encoded_details++ = csn_pin >> 4; - *encoded_details++ = csn_pin & 0xFF; - *encoded_details = static_cast<uint8_t>((spi_speed / 1000000) | _BV(_is_p_variant * 4)); -} -#endif // !defined(MINIMAL) - -/****************************************************************************/ -#if defined(RF24_SPI_PTR) || defined(DOXYGEN_FORCED) -// does not apply to RF24_LINUX - -bool RF24::begin(_SPI* spiBus) -{ - _spi = spiBus; - return _init_pins() && _init_radio(); -} - -/****************************************************************************/ - -bool RF24::begin(_SPI* spiBus, rf24_gpio_pin_t _cepin, rf24_gpio_pin_t _cspin) -{ - ce_pin = _cepin; - csn_pin = _cspin; - return begin(spiBus); -} - -#endif // defined (RF24_SPI_PTR) || defined (DOXYGEN_FORCED) - -/****************************************************************************/ - -bool RF24::begin(rf24_gpio_pin_t _cepin, rf24_gpio_pin_t _cspin) -{ - ce_pin = _cepin; - csn_pin = _cspin; - return begin(); -} - -/****************************************************************************/ - -bool RF24::begin(void) -{ -#if defined(RF24_LINUX) - #if defined(RF24_RPi) - switch (csn_pin) { // Ensure valid hardware CS pin - case 0: break; - case 1: break; - // Allow BCM2835 enums for RPi - case 8: csn_pin = 0; break; - case 7: csn_pin = 1; break; - case 18: csn_pin = 10; break; // to make it work on SPI1 - case 17: csn_pin = 11; break; - case 16: csn_pin = 12; break; - default: csn_pin = 0; break; - } - #endif // RF24_RPi - - _SPI.begin(csn_pin, spi_speed); - -#elif defined(XMEGA_D3) - _spi->begin(csn_pin); - -#elif defined(RF24_RP2) - _spi = new SPI(); - _spi->begin(PICO_DEFAULT_SPI ? spi1 : spi0); - -#else // using an Arduino platform || defined (LITTLEWIRE) - - #if defined(RF24_SPI_PTR) - _spi->begin(); - #else // !defined(RF24_SPI_PTR) - _SPI.begin(); - #endif // !defined(RF24_SPI_PTR) - -#endif // !defined(XMEGA_D3) && !defined(RF24_LINUX) - - return _init_pins() && _init_radio(); -} - -/****************************************************************************/ - -bool RF24::_init_pins() -{ - if (!isValid()) { - // didn't specify the CSN & CE pins to c'tor nor begin() - return false; - } - -#if defined(RF24_LINUX) - - pinMode(ce_pin, OUTPUT); - ce(LOW); - delay(100); - -#elif defined(LITTLEWIRE) - pinMode(csn_pin, OUTPUT); - csn(HIGH); - -#elif defined(XMEGA_D3) - if (ce_pin != csn_pin) { - pinMode(ce_pin, OUTPUT); - }; - ce(LOW); - csn(HIGH); - delay(200); - -#else // using an Arduino platform - - // Initialize pins - if (ce_pin != csn_pin) { - pinMode(ce_pin, OUTPUT); - pinMode(csn_pin, OUTPUT); - } - - ce(LOW); - csn(HIGH); - - #if defined(__ARDUINO_X86__) - delay(100); - #endif -#endif // !defined(XMEGA_D3) && !defined(LITTLEWIRE) && !defined(RF24_LINUX) - - return true; // assuming pins are connected properly -} - -/****************************************************************************/ - -bool RF24::_init_radio() -{ - // 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. - delay(5); - - // 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 datasheet for a more complete explanation. - setRetries(5, 15); - - // Then set the data rate to the slowest (and most reliable) speed supported by all hardware. - setDataRate(RF24_1MBPS); - - // detect if is a plus variant & use old toggle features command accordingly - uint8_t before_toggle = read_register(nRF24L01::FEATURE); - toggle_features(); - uint8_t after_toggle = read_register(nRF24L01::FEATURE); - _is_p_variant = before_toggle == after_toggle; - if (after_toggle) { - if (_is_p_variant) { - // module did not experience power-on-reset (#401) - toggle_features(); - } - // allow use of multicast parameter and dynamic payloads by default - write_register(nRF24L01::FEATURE, 0); - } - ack_payloads_enabled = false; // ack payloads disabled by default - write_register(nRF24L01::DYNPD, 0); // disable dynamic payloads by default (for all pipes) - dynamic_payloads_enabled = false; - write_register(nRF24L01::EN_AA, 0x3F); // enable auto-ack on all pipes - write_register(nRF24L01::EN_RXADDR, 3); // only open RX pipes 0 & 1 - setPayloadSize(32); // set static payload size to 32 (max) bytes by default - setAddressWidth(5); // set default address length to (max) 5 bytes - - // 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); - - // Reset current status - // Notice reset and flush is the last thing we do - write_register(nRF24L01::STATUS, RF24_IRQ_ALL); - - // Flush buffers - flush_rx(); - flush_tx(); - - // Clear CONFIG register: - // Reflect NO IRQ events on IRQ pin - // Enable PTX - // Power Up - // 16-bit CRC (CRC required by auto-ack) - // Do not write CE high so radio will remain in standby I mode - // PTX should use only 22uA of power - write_register(nRF24L01::CONFIG, (_BV(nRF24L01::EN_CRC) | _BV(nRF24L01::CRCO) | _BV(nRF24L01::MASK_RX_DR) | _BV(nRF24L01::MASK_TX_DS) | _BV(nRF24L01::MASK_MAX_RT))); - config_reg = read_register(nRF24L01::CONFIG); - - powerUp(); - - // if config is not set correctly then there was a bad response from module - return config_reg == (_BV(nRF24L01::EN_CRC) | _BV(nRF24L01::CRCO) | _BV(nRF24L01::PWR_UP) | _BV(nRF24L01::MASK_RX_DR) | _BV(nRF24L01::MASK_TX_DS) | _BV(nRF24L01::MASK_MAX_RT)) ? true : false; -} - -/****************************************************************************/ - -bool RF24::isChipConnected() -{ - return read_register(nRF24L01::SETUP_AW) == (addr_width - static_cast<uint8_t>(2)); -} - -/****************************************************************************/ - -bool RF24::isValid() -{ - return ce_pin != RF24_PIN_INVALID && csn_pin != RF24_PIN_INVALID; -} - -/****************************************************************************/ - -void RF24::startListening(void) -{ -#if !defined(RF24_TINY) && !defined(LITTLEWIRE) - powerUp(); -#endif - config_reg |= _BV(nRF24L01::PRIM_RX); - write_register(nRF24L01::CONFIG, config_reg); - write_register(nRF24L01::STATUS, RF24_IRQ_ALL); - ce(HIGH); - - // Restore the pipe0 address, if exists - if (_is_p0_rx) { - write_register(nRF24L01::RX_ADDR_P0, pipe0_reading_address, addr_width); - } - else { - closeReadingPipe(0); - } -} - -/****************************************************************************/ - -static const PROGMEM uint8_t child_pipe_enable[] = {nRF24L01::ERX_P0, nRF24L01::ERX_P1, nRF24L01::ERX_P2, - nRF24L01::ERX_P3, nRF24L01::ERX_P4, nRF24L01::ERX_P5}; - -void RF24::stopListening(void) -{ - ce(LOW); - - //delayMicroseconds(100); - delayMicroseconds(static_cast<int>(txDelay)); - if (ack_payloads_enabled) { - flush_tx(); - } - - config_reg = static_cast<uint8_t>(config_reg & ~_BV(nRF24L01::PRIM_RX)); - write_register(nRF24L01::CONFIG, config_reg); - -#if defined(RF24_TINY) || defined(LITTLEWIRE) - // for 3 pins solution TX mode is only left with additional powerDown/powerUp cycle - if (ce_pin == csn_pin) { - powerDown(); - powerUp(); - } -#endif - write_register(nRF24L01::RX_ADDR_P0, pipe0_writing_address, addr_width); - write_register(nRF24L01::EN_RXADDR, static_cast<uint8_t>(read_register(nRF24L01::EN_RXADDR) | _BV(pgm_read_byte(&child_pipe_enable[0])))); // Enable RX on pipe0 -} - -/****************************************************************************/ - -void RF24::stopListening(const uint64_t txAddress) -{ - memcpy(pipe0_writing_address, &txAddress, addr_width); - stopListening(); - write_register(nRF24L01::TX_ADDR, pipe0_writing_address, addr_width); -} - -/****************************************************************************/ - -void RF24::stopListening(const uint8_t* txAddress) -{ - memcpy(pipe0_writing_address, txAddress, addr_width); - stopListening(); - write_register(nRF24L01::TX_ADDR, pipe0_writing_address, addr_width); -} - -/****************************************************************************/ - -void RF24::powerDown(void) -{ - ce(LOW); // Guarantee CE is low on powerDown - config_reg = static_cast<uint8_t>(config_reg & ~_BV(nRF24L01::PWR_UP)); - write_register(nRF24L01::CONFIG, config_reg); -} - -/****************************************************************************/ - -//Power up now. Radio will not power down unless instructed by MCU for config changes etc. -void RF24::powerUp(void) -{ - // if not powered up then power up and wait for the radio to initialize - if (!(config_reg & _BV(nRF24L01::PWR_UP))) { - config_reg |= _BV(nRF24L01::PWR_UP); - write_register(nRF24L01::CONFIG, config_reg); - - // 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 - delayMicroseconds(RF24_POWERUP_DELAY); - } -} - -/******************************************************************/ -#if defined(FAILURE_HANDLING) || defined(RF24_LINUX) - -void RF24::errNotify() -{ - #if defined(RF24_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 - delay(5000); - #endif -} - -/******************************************************************/ - -int8_t RF24::errHandler(bool* doRecovery) -{ - - //Wait until complete or failed - uint32_t timer = millis(); - - while (!(update() & (RF24_TX_DS | RF24_TX_DF))) { - if (millis() - timer > 95) { - #if defined(FAILURE_HANDLING) - flush_rx(); - flush_tx(); - if (doRecovery) { - *doRecovery = false; - failureRecoveryAttempts++; - ce(LOW); - return -1; - } - else { - #endif - errNotify(); - #if defined(FAILURE_HANDLING) - } - return 0; - #else - delay(100); - #endif - } - } - return 0; -} - -/******************************************************************/ - -void RF24::errHandler() -{ - - #if defined(FAILURE_HANDLING) - flush_tx(); - flush_rx(); - if (!failureFlushed) { - failureFlushed = true; - failureRecoveryAttempts++; - } - else { - #endif - errNotify(); - #if defined(FAILURE_HANDLING) - failureFlushed = false; - } - ce(LOW); - #endif -} - -#endif - -/******************************************************************/ - -//Similar to the previous write, clears the interrupt flags -bool RF24::write(const void* buf, uint8_t len, const bool multicast) -{ - - //Start Writing -#if defined(FAILURE_HANDLING) || defined(RF24_LINUX) - bool doRecovery = true; - do { -#endif - startFastWrite(buf, len, multicast); -#if defined(FAILURE_HANDLING) || defined(RF24_LINUX) - } while (errHandler(&doRecovery) < 0); -#endif - - ce(LOW); - - write_register(nRF24L01::STATUS, RF24_IRQ_ALL); - - //Max retries exceeded - if (status & RF24_TX_DF) { - flush_tx(); // Only going to be 1 packet in the FIFO at a time using this method, so just flush - return 0; - } - //TX OK 1 or 0 - return 1; -} - -/****************************************************************************/ - -bool RF24::write(const void* buf, uint8_t len) -{ - return write(buf, len, 0); -} - -/****************************************************************************/ - -//For general use, the interrupt flags are not important to clear -bool RF24::writeBlocking(const void* buf, uint8_t len, uint32_t timeout) -{ - //Block until the FIFO is NOT full. - //Keep track of the MAX retries and set auto-retry if seeing failures - //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 -#if defined(FAILURE_HANDLING) - bool timeoutInvoked = false; -#endif - - uint32_t timer = millis(); // Get the time that the payload transmission started - - while (update() & _BV(nRF24L01::TX_FULL)) { // Blocking only if FIFO is full. This will loop and block until TX is successful or timeout - - if (status & RF24_TX_DF) { // If MAX Retries have been reached - reUseTX(); // Set re-transmit and clear the MAX_RT interrupt flag - if (millis() - timer > timeout) { -#if defined(FAILURE_HANDLING) - failureFlushed = false; -#endif - return 0; // If this payload has exceeded the user-defined timeout, exit and return 0 - } - } -#if defined(FAILURE_HANDLING) || defined(RF24_LINUX) - if (millis() - timer > (timeout + 95)) { - errHandler(); - #if defined(FAILURE_HANDLING) - timeoutInvoked = true; - if (!failureFlushed) { - #endif - return 0; - #if defined(FAILURE_HANDLING) - } - #endif - } -#endif - } - - //Start Writing - startFastWrite(buf, len, 0); // Write the payload if a buffer is clear -#if defined(FAILURE_HANDLING) - if (!timeoutInvoked) { - failureFlushed = false; - } -#endif - return 1; // Return 1 to indicate successful transmission -} - -/****************************************************************************/ - -void RF24::reUseTX() -{ - ce(LOW); - write_register(nRF24L01::STATUS, RF24_TX_DF); //Clear max retry flag - read_register(nRF24L01::REUSE_TX_PL, (uint8_t*)nullptr, 0); - IF_RF24_DEBUG(printf_P("[Reusing payload in TX FIFO]");); - ce(HIGH); //Re-Transfer packet -} - -/****************************************************************************/ - -bool RF24::writeFast(const void* buf, uint8_t len, const bool multicast) -{ - //Block until the FIFO is NOT full. - //Keep track of the MAX retries and set auto-retry if seeing failures - //Return 0 so the user can control the retries 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) || defined(RF24_LINUX) - uint32_t timer = millis(); - bool timeoutInvoked = false; -#endif - - //Blocking only if FIFO is full. This will loop and block until TX is successful or fail - while (update() & _BV(nRF24L01::TX_FULL)) { - if (status & RF24_TX_DF) { -#if defined(FAILURE_HANDLING) - failureFlushed = false; -#endif - return 0; //Return 0. The previous payload has not been retransmitted - // From the user perspective, if you get a 0, call txStandBy() - } -#if defined(FAILURE_HANDLING) || defined(RF24_LINUX) - if (millis() - timer > 95) { - timeoutInvoked = true; - errHandler(); - #if defined(FAILURE_HANDLING) - if (!failureFlushed) { - #endif - return 0; - #if defined(FAILURE_HANDLING) - } - #endif - } -#endif - } - startFastWrite(buf, len, multicast); // Start Writing -#if defined(FAILURE_HANDLING) - if (!timeoutInvoked) { - failureFlushed = false; - } -#endif - return 1; -} - -bool RF24::writeFast(const void* buf, uint8_t len) -{ - return writeFast(buf, len, 0); -} - -/****************************************************************************/ - -//Per the documentation, we want to set PTX Mode when not listening. Then all we do is write data and set CE high -//In this mode, if we can keep the FIFO buffers loaded, packets will transmit immediately (no 130us delay) -//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 - - write_payload(buf, len, multicast ? nRF24L01::W_TX_PAYLOAD_NO_ACK : nRF24L01::W_TX_PAYLOAD); - if (startTx) { - ce(HIGH); - } -} - -/****************************************************************************/ - -//Added the original startWrite back in so users can still use interrupts, ack payloads, etc -//Allows the library to pass all tests -bool RF24::startWrite(const void* buf, uint8_t len, const bool multicast) -{ - - // Send the payload - write_payload(buf, len, multicast ? nRF24L01::W_TX_PAYLOAD_NO_ACK : nRF24L01::W_TX_PAYLOAD); - ce(HIGH); -#if !defined(F_CPU) || F_CPU > 20000000 - delayMicroseconds(10); -#endif -#ifdef ARDUINO_ARCH_STM32 - if (F_CPU > 20000000) { - delayMicroseconds(10); - } -#endif - ce(LOW); - return !(status & _BV(nRF24L01::TX_FULL)); -} - -/****************************************************************************/ - -bool RF24::rxFifoFull() -{ - return read_register(nRF24L01::FIFO_STATUS) & _BV(nRF24L01::RX_FULL); -} - -/****************************************************************************/ - -rf24_fifo_state_e RF24::isFifo(bool about_tx) -{ - uint8_t state = (read_register(nRF24L01::FIFO_STATUS) >> (4 * about_tx)) & 3; - return static_cast<rf24_fifo_state_e>(state); -} - -/****************************************************************************/ - -bool RF24::isFifo(bool about_tx, bool check_empty) -{ - return static_cast<bool>(static_cast<uint8_t>(isFifo(about_tx)) & _BV(!check_empty)); -} - -/****************************************************************************/ - -bool RF24::txStandBy() -{ - -#if defined(FAILURE_HANDLING) || defined(RF24_LINUX) - uint32_t timeout = millis(); -#endif - while (!(read_register(nRF24L01::FIFO_STATUS) & _BV(nRF24L01::TX_EMPTY))) { - if (status & RF24_TX_DF) { - write_register(nRF24L01::STATUS, RF24_TX_DF); - ce(LOW); - flush_tx(); //Non blocking, flush the data -#if defined(FAILURE_HANDLING) - failureFlushed = false; -#endif - return 0; - } -#if defined(FAILURE_HANDLING) || defined(RF24_LINUX) - if (millis() - timeout > 95) { - errHandler(); - return 0; - } -#endif - } - - ce(LOW); //Set STANDBY-I mode -#if defined(FAILURE_HANDLING) - failureFlushed = false; -#endif - return 1; -} - -/****************************************************************************/ - -bool RF24::txStandBy(uint32_t timeout, bool startTx) -{ - - if (startTx) { - stopListening(); - ce(HIGH); - } - uint32_t start = millis(); - - while (!(read_register(nRF24L01::FIFO_STATUS) & _BV(nRF24L01::TX_EMPTY))) { - if (status & RF24_TX_DF) { - write_register(nRF24L01::STATUS, RF24_TX_DF); - ce(LOW); // Set re-transmit - ce(HIGH); - if (millis() - start >= timeout) { - ce(LOW); - flush_tx(); -#if defined(FAILURE_HANDLING) - failureFlushed = false; -#endif - return 0; - } - } -#if defined(FAILURE_HANDLING) || defined(RF24_LINUX) - if (millis() - start > timeout + 95) { - errHandler(); - return 0; - } -#endif - } - - ce(LOW); //Set STANDBY-I mode -#if defined(FAILURE_HANDLING) - failureFlushed = false; -#endif - return 1; -} - -/****************************************************************************/ - -void RF24::maskIRQ(bool tx, bool fail, bool rx) -{ - /* clear the interrupt flags */ - config_reg = static_cast<uint8_t>(config_reg & ~(1 << nRF24L01::MASK_MAX_RT | 1 << nRF24L01::MASK_TX_DS | 1 << nRF24L01::MASK_RX_DR)); - /* set the specified interrupt flags */ - config_reg = static_cast<uint8_t>(config_reg | fail << nRF24L01::MASK_MAX_RT | tx << nRF24L01::MASK_TX_DS | rx << nRF24L01::MASK_RX_DR); - write_register(nRF24L01::CONFIG, config_reg); -} - -/****************************************************************************/ - -uint8_t RF24::getDynamicPayloadSize(void) -{ - uint8_t result = read_register(nRF24L01::R_RX_PL_WID); - - if (result > 32 || !result) { - flush_rx(); - return 0; - } - return result; -} - -/****************************************************************************/ - -bool RF24::available(void) -{ - return (read_register(nRF24L01::FIFO_STATUS) & 1) == 0; -} - -/****************************************************************************/ - -bool RF24::available(uint8_t* pipe_num) -{ - if (available()) { // if RX FIFO is not empty - *pipe_num = (update() >> nRF24L01::RX_P_NO) & 0x07; - return 1; - } - return 0; -} - -/****************************************************************************/ - -void RF24::read(void* buf, uint8_t len) -{ - - // Fetch the payload - read_payload(buf, len); - - //Clear the only applicable interrupt flags - write_register(nRF24L01::STATUS, RF24_RX_DR); -} - -/****************************************************************************/ - -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? - write_register(nRF24L01::STATUS, RF24_IRQ_ALL); - - // Report to the user what happened - tx_ok = status & RF24_TX_DS; - tx_fail = status & RF24_TX_DF; - rx_ready = status & RF24_RX_DR; -} - -/****************************************************************************/ - -uint8_t RF24::clearStatusFlags(uint8_t flags) -{ - write_register(nRF24L01::STATUS, flags & RF24_IRQ_ALL); - return status; -} - -/****************************************************************************/ - -void RF24::setStatusFlags(uint8_t flags) -{ - // flip the `flags` to translate from "human understanding" - config_reg = (config_reg & ~RF24_IRQ_ALL) | (~flags & RF24_IRQ_ALL); - write_register(nRF24L01::CONFIG, config_reg); -} - -/****************************************************************************/ - -uint8_t RF24::getStatusFlags() -{ - return status; -} - -/****************************************************************************/ - -uint8_t RF24::update() -{ - read_register(nRF24L01::NOP, (uint8_t*)nullptr, 0); - return status; -} - -/****************************************************************************/ - -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. - - write_register(nRF24L01::RX_ADDR_P0, reinterpret_cast<uint8_t*>(&value), addr_width); - write_register(nRF24L01::TX_ADDR, reinterpret_cast<uint8_t*>(&value), addr_width); - memcpy(pipe0_writing_address, &value, addr_width); -} - -/****************************************************************************/ - -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. - write_register(nRF24L01::RX_ADDR_P0, address, addr_width); - write_register(nRF24L01::TX_ADDR, address, addr_width); - memcpy(pipe0_writing_address, address, addr_width); -} - -/****************************************************************************/ - -static const PROGMEM uint8_t child_pipe[] = {nRF24L01::RX_ADDR_P0, nRF24L01::RX_ADDR_P1, nRF24L01::RX_ADDR_P2, - nRF24L01::RX_ADDR_P3, nRF24L01::RX_ADDR_P4, nRF24L01::RX_ADDR_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); - _is_p0_rx = true; - } - - if (child <= 5) { - // For pipes 2-5, only write the LSB - if (child > 1) { - write_register(pgm_read_byte(&child_pipe[child]), reinterpret_cast<const uint8_t*>(&address), 1); - } - // avoid overwriting the TX address on pipe 0 while still in TX mode. - // NOTE, the cached RX address on pipe 0 is written when startListening() is called. - else if (static_cast<bool>(config_reg & _BV(nRF24L01::PRIM_RX)) || child != 0) { - write_register(pgm_read_byte(&child_pipe[child]), reinterpret_cast<const uint8_t*>(&address), addr_width); - } - - // 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(nRF24L01::EN_RXADDR, static_cast<uint8_t>(read_register(nRF24L01::EN_RXADDR) | _BV(pgm_read_byte(&child_pipe_enable[child])))); - } -} - -/****************************************************************************/ - -void RF24::setAddressWidth(uint8_t a_width) -{ - a_width = static_cast<uint8_t>(a_width - 2); - if (a_width) { - write_register(nRF24L01::SETUP_AW, static_cast<uint8_t>(a_width % 4)); - addr_width = static_cast<uint8_t>((a_width % 4) + 2); - } - else { - write_register(nRF24L01::SETUP_AW, static_cast<uint8_t>(0)); - addr_width = static_cast<uint8_t>(2); - } -} - -/****************************************************************************/ - -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); - _is_p0_rx = true; - } - if (child <= 5) { - // For pipes 2-5, only write the LSB - if (child > 1) { - write_register(pgm_read_byte(&child_pipe[child]), address, 1); - } - // avoid overwriting the TX address on pipe 0 while still in TX mode. - // NOTE, the cached RX address on pipe 0 is written when startListening() is called. - else if (static_cast<bool>(config_reg & _BV(nRF24L01::PRIM_RX)) || child != 0) { - write_register(pgm_read_byte(&child_pipe[child]), address, addr_width); - } - - // 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(nRF24L01::EN_RXADDR, static_cast<uint8_t>(read_register(nRF24L01::EN_RXADDR) | _BV(pgm_read_byte(&child_pipe_enable[child])))); - } -} - -/****************************************************************************/ - -void RF24::closeReadingPipe(uint8_t pipe) -{ - write_register(nRF24L01::EN_RXADDR, static_cast<uint8_t>(read_register(nRF24L01::EN_RXADDR) & ~_BV(pgm_read_byte(&child_pipe_enable[pipe])))); - if (!pipe) { - // keep track of pipe 0's RX state to avoid null vs 0 in addr cache - _is_p0_rx = false; - } -} - -/****************************************************************************/ - -void RF24::toggle_features(void) -{ - beginTransaction(); -#if defined(RF24_SPI_PTR) - status = _spi->transfer(nRF24L01::ACTIVATE); - _spi->transfer(0x73); -#else - status = _SPI.transfer(nRF24L01::ACTIVATE); - _SPI.transfer(0x73); -#endif - endTransaction(); -} - -/****************************************************************************/ - -void RF24::enableDynamicPayloads(void) -{ - // Enable dynamic payload throughout the system - - //toggle_features(); - write_register(nRF24L01::FEATURE, read_register(nRF24L01::FEATURE) | _BV(nRF24L01::EN_DPL)); - - IF_RF24_DEBUG(printf_P("FEATURE=%i\r\n", read_register(nRF24L01::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(nRF24L01::DYNPD, read_register(nRF24L01::DYNPD) | _BV(nRF24L01::DPL_P5) | _BV(nRF24L01::DPL_P4) | _BV(nRF24L01::DPL_P3) | _BV(nRF24L01::DPL_P2) | _BV(nRF24L01::DPL_P1) | _BV(nRF24L01::DPL_P0)); - - dynamic_payloads_enabled = true; -} - -/****************************************************************************/ - -void RF24::disableDynamicPayloads(void) -{ - // Disables dynamic payload throughout the system. Also disables Ack Payloads - - //toggle_features(); - write_register(nRF24L01::FEATURE, 0); - - IF_RF24_DEBUG(printf_P("FEATURE=%i\r\n", read_register(nRF24L01::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(nRF24L01::DYNPD, 0); - - dynamic_payloads_enabled = false; - ack_payloads_enabled = false; -} - -/****************************************************************************/ - -void RF24::enableAckPayload(void) -{ - // enable ack payloads and dynamic payload features - - if (!ack_payloads_enabled) { - write_register(nRF24L01::FEATURE, read_register(nRF24L01::FEATURE) | _BV(nRF24L01::EN_ACK_PAY) | _BV(nRF24L01::EN_DPL)); - - IF_RF24_DEBUG(printf_P("FEATURE=%i\r\n", read_register(nRF24L01::FEATURE))); - - // Enable dynamic payload on pipes 0 & 1 - write_register(nRF24L01::DYNPD, read_register(nRF24L01::DYNPD) | _BV(nRF24L01::DPL_P1) | _BV(nRF24L01::DPL_P0)); - dynamic_payloads_enabled = true; - ack_payloads_enabled = true; - } -} - -/****************************************************************************/ - -void RF24::disableAckPayload(void) -{ - // disable ack payloads (leave dynamic payload features as is) - if (ack_payloads_enabled) { - write_register(nRF24L01::FEATURE, static_cast<uint8_t>(read_register(nRF24L01::FEATURE) & ~_BV(nRF24L01::EN_ACK_PAY))); - - IF_RF24_DEBUG(printf_P("FEATURE=%i\r\n", read_register(nRF24L01::FEATURE))); - - ack_payloads_enabled = false; - } -} - -/****************************************************************************/ - -void RF24::enableDynamicAck(void) -{ - // - // enable dynamic ack features - // - //toggle_features(); - write_register(nRF24L01::FEATURE, read_register(nRF24L01::FEATURE) | _BV(nRF24L01::EN_DYN_ACK)); - - IF_RF24_DEBUG(printf_P("FEATURE=%i\r\n", read_register(nRF24L01::FEATURE))); -} - -/****************************************************************************/ - -bool RF24::writeAckPayload(uint8_t pipe, const void* buf, uint8_t len) -{ - if (ack_payloads_enabled) { - const uint8_t* current = reinterpret_cast<const uint8_t*>(buf); - - write_register(nRF24L01::W_ACK_PAYLOAD | (pipe & 0x07), current, rf24_min(len, static_cast<uint8_t>(32))); - return !(status & _BV(nRF24L01::TX_FULL)); - } - return 0; -} - -/****************************************************************************/ - -bool RF24::isAckPayloadAvailable(void) -{ - return available(); -} - -/****************************************************************************/ - -bool RF24::isPVariant(void) -{ - return _is_p_variant; -} - -/****************************************************************************/ - -void RF24::setAutoAck(bool enable) -{ - if (enable) { - write_register(nRF24L01::EN_AA, 0x3F); - } - else { - write_register(nRF24L01::EN_AA, 0); - // accommodate ACK payloads feature - if (ack_payloads_enabled) { - disableAckPayload(); - } - } -} - -/****************************************************************************/ - -void RF24::setAutoAck(uint8_t pipe, bool enable) -{ - if (pipe < 6) { - uint8_t en_aa = read_register(nRF24L01::EN_AA); - if (enable) { - en_aa |= static_cast<uint8_t>(_BV(pipe)); - } - else { - en_aa = static_cast<uint8_t>(en_aa & ~_BV(pipe)); - if (ack_payloads_enabled && !pipe) { - disableAckPayload(); - } - } - write_register(nRF24L01::EN_AA, en_aa); - } -} - -/****************************************************************************/ - -bool RF24::testCarrier(void) -{ - return (read_register(nRF24L01::CD) & 1); -} - -/****************************************************************************/ - -bool RF24::testRPD(void) -{ - return (read_register(nRF24L01::RPD) & 1); -} - -/****************************************************************************/ - -void RF24::setPALevel(uint8_t level, bool lnaEnable) -{ - uint8_t setup = read_register(nRF24L01::RF_SETUP) & static_cast<uint8_t>(0xF8); - setup |= _pa_level_reg_value(level, lnaEnable); - write_register(nRF24L01::RF_SETUP, setup); -} - -/****************************************************************************/ - -uint8_t RF24::getPALevel(void) -{ - return (read_register(nRF24L01::RF_SETUP) & (_BV(nRF24L01::RF_PWR_LOW) | _BV(nRF24L01::RF_PWR_HIGH))) >> 1; -} - -/****************************************************************************/ - -uint8_t RF24::getARC(void) -{ - return read_register(nRF24L01::OBSERVE_TX) & 0x0F; -} - -/****************************************************************************/ - -bool RF24::setDataRate(rf24_datarate_e speed) -{ - bool result = false; - uint8_t setup = read_register(nRF24L01::RF_SETUP); - - // HIGH and LOW '00' is 1Mbs - our default - setup = static_cast<uint8_t>(setup & ~(_BV(nRF24L01::RF_DR_LOW) | _BV(nRF24L01::RF_DR_HIGH))); - setup |= _data_rate_reg_value(speed); - - write_register(nRF24L01::RF_SETUP, setup); - - // Verify our result - if (read_register(nRF24L01::RF_SETUP) == setup) { - result = true; - } - return result; -} - -/****************************************************************************/ - -rf24_datarate_e RF24::getDataRate(void) -{ - rf24_datarate_e result; - uint8_t dr = read_register(nRF24L01::RF_SETUP) & (_BV(nRF24L01::RF_DR_LOW) | _BV(nRF24L01::RF_DR_HIGH)); - - // switch uses RAM (evil!) - // Order matters in our case below - if (dr == _BV(nRF24L01::RF_DR_LOW)) { - // '10' = 250KBPS - result = RF24_250KBPS; - } - else if (dr == _BV(nRF24L01::RF_DR_HIGH)) { - // '01' = 2MBPS - result = RF24_2MBPS; - } - else { - // '00' = 1MBPS - result = RF24_1MBPS; - } - return result; -} - -/****************************************************************************/ - -void RF24::setCRCLength(rf24_crclength_e length) -{ - config_reg = static_cast<uint8_t>(config_reg & ~(_BV(nRF24L01::CRCO) | _BV(nRF24L01::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_reg |= _BV(nRF24L01::EN_CRC); - } - else { - config_reg |= _BV(nRF24L01::EN_CRC); - config_reg |= _BV(nRF24L01::CRCO); - } - write_register(nRF24L01::CONFIG, config_reg); -} - -/****************************************************************************/ - -rf24_crclength_e RF24::getCRCLength(void) -{ - rf24_crclength_e result = RF24_CRC_DISABLED; - uint8_t AA = read_register(nRF24L01::EN_AA); - config_reg = read_register(nRF24L01::CONFIG); - - if (config_reg & _BV(nRF24L01::EN_CRC) || AA) { - if (config_reg & _BV(nRF24L01::CRCO)) { - result = RF24_CRC_16; - } - else { - result = RF24_CRC_8; - } - } - - return result; -} - -/****************************************************************************/ - -void RF24::disableCRC(void) -{ - config_reg = static_cast<uint8_t>(config_reg & ~_BV(nRF24L01::EN_CRC)); - write_register(nRF24L01::CONFIG, config_reg); -} - -/****************************************************************************/ -void RF24::setRetries(uint8_t delay, uint8_t count) -{ - write_register(nRF24L01::SETUP_RETR, static_cast<uint8_t>(rf24_min(15, delay) << nRF24L01::ARD | rf24_min(15, count))); -} - -/****************************************************************************/ -void RF24::startConstCarrier(rf24_pa_dbm_e level, uint8_t channel) -{ - stopListening(); - write_register(nRF24L01::RF_SETUP, read_register(nRF24L01::RF_SETUP) | _BV(nRF24L01::CONT_WAVE) | _BV(nRF24L01::PLL_LOCK)); - if (isPVariant()) { - setAutoAck(0); - setRetries(0, 0); - uint8_t dummy_buf[32]; - for (uint8_t i = 0; i < 32; ++i) - dummy_buf[i] = 0xFF; - - // use write_register() instead of openWritingPipe() to bypass - // truncation of the address with the current RF24::addr_width value - write_register(nRF24L01::TX_ADDR, reinterpret_cast<uint8_t*>(&dummy_buf), 5); - flush_tx(); // so we can write to top level - - // use write_register() instead of write_payload() to bypass - // truncation of the payload with the current RF24::payload_size value - write_register(nRF24L01::W_TX_PAYLOAD, reinterpret_cast<const uint8_t*>(&dummy_buf), 32); - - disableCRC(); - } - setPALevel(level); - setChannel(channel); - IF_RF24_DEBUG(printf_P(PSTR("RF_SETUP=%02x\r\n"), read_register(nRF24L01::RF_SETUP))); - ce(HIGH); - if (isPVariant()) { - delay(1); // datasheet says 1 ms is ok in this instance - reUseTX(); // CE gets toggled here - } -} - -/****************************************************************************/ - -void RF24::stopConstCarrier() -{ - /* - * A note from the datasheet: - * Do not use REUSE_TX_PL together with CONT_WAVE=1. When both these - * registers are set the chip does not react when setting CE low. If - * however, both registers are set PWR_UP = 0 will turn TX mode off. - */ - powerDown(); // per datasheet recommendation (just to be safe) - write_register(nRF24L01::RF_SETUP, static_cast<uint8_t>(read_register(nRF24L01::RF_SETUP) & ~_BV(nRF24L01::CONT_WAVE) & ~_BV(nRF24L01::PLL_LOCK))); - ce(LOW); - flush_tx(); - if (isPVariant()) { - // restore the cached TX address - write_register(nRF24L01::TX_ADDR, pipe0_writing_address, addr_width); - } -} - -/****************************************************************************/ - -void RF24::toggleAllPipes(bool isEnabled) -{ - write_register(nRF24L01::EN_RXADDR, static_cast<uint8_t>(isEnabled ? 0x3F : 0)); -} - -/****************************************************************************/ - -uint8_t RF24::_data_rate_reg_value(rf24_datarate_e speed) -{ -#if !defined(F_CPU) || F_CPU > 20000000 - txDelay = 280; -#else //16Mhz Arduino - txDelay = 85; -#endif - if (speed == RF24_250KBPS) { -#if !defined(F_CPU) || F_CPU > 20000000 - txDelay = 505; -#else //16Mhz Arduino - txDelay = 155; -#endif - // Must set the RF_DR_LOW to 1; RF_DR_HIGH (used to be RF_DR) is already 0 - // Making it '10'. - return static_cast<uint8_t>(_BV(nRF24L01::RF_DR_LOW)); - } - else if (speed == RF24_2MBPS) { -#if !defined(F_CPU) || F_CPU > 20000000 - txDelay = 240; -#else // 16Mhz Arduino - txDelay = 65; -#endif - // Set 2Mbs, RF_DR (RF_DR_HIGH) is set 1 - // Making it '01' - return static_cast<uint8_t>(_BV(nRF24L01::RF_DR_HIGH)); - } - // HIGH and LOW '00' is 1Mbs - our default - return static_cast<uint8_t>(0); -} - -/****************************************************************************/ - -uint8_t RF24::_pa_level_reg_value(uint8_t level, bool lnaEnable) -{ - // If invalid level, go to max PA - // Else set level as requested - // + lnaEnable (1 or 0) to support the SI24R1 chip extra bit - return static_cast<uint8_t>(((level > RF24_PA_MAX ? static_cast<uint8_t>(RF24_PA_MAX) : level) << 1) + lnaEnable); -} - -/****************************************************************************/ - -void RF24::setRadiation(uint8_t level, rf24_datarate_e speed, bool lnaEnable) -{ - uint8_t setup = _data_rate_reg_value(speed); - setup |= _pa_level_reg_value(level, lnaEnable); - write_register(nRF24L01::RF_SETUP, setup); -} |