// RH_NRF24.h // Author: Mike McCauley // Copyright (C) 2012 Mike McCauley // $Id: RH_NRF24.h,v 1.19 2016/07/07 00:02:53 mikem Exp mikem $ // #ifndef RH_NRF24_h #define RH_NRF24_h #include "RHGenericSPI.h" #include "RHNRFSPIDriver.h" // This is the maximum number of bytes that can be carried by the nRF24. // We use some for headers, keeping fewer for RadioHead messages #define RH_NRF24_MAX_PAYLOAD_LEN 32 // The length of the headers we add. // The headers are inside the nRF24 payload #define RH_NRF24_HEADER_LEN 4 // This is the maximum RadioHead user message length that can be supported by this library. Limited by // the supported message lengths in the nRF24 #define RH_NRF24_MAX_MESSAGE_LEN (RH_NRF24_MAX_PAYLOAD_LEN-RH_NRF24_HEADER_LEN) // SPI Command names #define RH_NRF24_COMMAND_R_REGISTER 0x00 #define RH_NRF24_COMMAND_W_REGISTER 0x20 #define RH_NRF24_COMMAND_ACTIVATE 0x50 // only on RFM73 ? #define RH_NRF24_COMMAND_R_RX_PAYLOAD 0x61 #define RH_NRF24_COMMAND_W_TX_PAYLOAD 0xa0 #define RH_NRF24_COMMAND_FLUSH_TX 0xe1 #define RH_NRF24_COMMAND_FLUSH_RX 0xe2 #define RH_NRF24_COMMAND_REUSE_TX_PL 0xe3 #define RH_NRF24_COMMAND_R_RX_PL_WID 0x60 #define RH_NRF24_COMMAND_W_ACK_PAYLOAD(pipe) (0xa8|(pipe&0x7)) #define RH_NRF24_COMMAND_W_TX_PAYLOAD_NOACK 0xb0 #define RH_NRF24_COMMAND_NOP 0xff // Register names #define RH_NRF24_REGISTER_MASK 0x1f #define RH_NRF24_REG_00_CONFIG 0x00 #define RH_NRF24_REG_01_EN_AA 0x01 #define RH_NRF24_REG_02_EN_RXADDR 0x02 #define RH_NRF24_REG_03_SETUP_AW 0x03 #define RH_NRF24_REG_04_SETUP_RETR 0x04 #define RH_NRF24_REG_05_RF_CH 0x05 #define RH_NRF24_REG_06_RF_SETUP 0x06 #define RH_NRF24_REG_07_STATUS 0x07 #define RH_NRF24_REG_08_OBSERVE_TX 0x08 #define RH_NRF24_REG_09_RPD 0x09 #define RH_NRF24_REG_0A_RX_ADDR_P0 0x0a #define RH_NRF24_REG_0B_RX_ADDR_P1 0x0b #define RH_NRF24_REG_0C_RX_ADDR_P2 0x0c #define RH_NRF24_REG_0D_RX_ADDR_P3 0x0d #define RH_NRF24_REG_0E_RX_ADDR_P4 0x0e #define RH_NRF24_REG_0F_RX_ADDR_P5 0x0f #define RH_NRF24_REG_10_TX_ADDR 0x10 #define RH_NRF24_REG_11_RX_PW_P0 0x11 #define RH_NRF24_REG_12_RX_PW_P1 0x12 #define RH_NRF24_REG_13_RX_PW_P2 0x13 #define RH_NRF24_REG_14_RX_PW_P3 0x14 #define RH_NRF24_REG_15_RX_PW_P4 0x15 #define RH_NRF24_REG_16_RX_PW_P5 0x16 #define RH_NRF24_REG_17_FIFO_STATUS 0x17 #define RH_NRF24_REG_1C_DYNPD 0x1c #define RH_NRF24_REG_1D_FEATURE 0x1d // These register masks etc are named wherever possible // corresponding to the bit and field names in the nRF24L01 Product Specification // #define RH_NRF24_REG_00_CONFIG 0x00 #define RH_NRF24_MASK_RX_DR 0x40 #define RH_NRF24_MASK_TX_DS 0x20 #define RH_NRF24_MASK_MAX_RT 0x10 #define RH_NRF24_EN_CRC 0x08 #define RH_NRF24_CRCO 0x04 #define RH_NRF24_PWR_UP 0x02 #define RH_NRF24_PRIM_RX 0x01 // #define RH_NRF24_REG_01_EN_AA 0x01 #define RH_NRF24_ENAA_P5 0x20 #define RH_NRF24_ENAA_P4 0x10 #define RH_NRF24_ENAA_P3 0x08 #define RH_NRF24_ENAA_P2 0x04 #define RH_NRF24_ENAA_P1 0x02 #define RH_NRF24_ENAA_P0 0x01 // #define RH_NRF24_REG_02_EN_RXADDR 0x02 #define RH_NRF24_ERX_P5 0x20 #define RH_NRF24_ERX_P4 0x10 #define RH_NRF24_ERX_P3 0x08 #define RH_NRF24_ERX_P2 0x04 #define RH_NRF24_ERX_P1 0x02 #define RH_NRF24_ERX_P0 0x01 // #define RH_NRF24_REG_03_SETUP_AW 0x03 #define RH_NRF24_AW_3_BYTES 0x01 #define RH_NRF24_AW_4_BYTES 0x02 #define RH_NRF24_AW_5_BYTES 0x03 // #define RH_NRF24_REG_04_SETUP_RETR 0x04 #define RH_NRF24_ARD 0xf0 #define RH_NRF24_ARC 0x0f // #define RH_NRF24_REG_05_RF_CH 0x05 #define RH_NRF24_RF_CH 0x7f // #define RH_NRF24_REG_06_RF_SETUP 0x06 #define RH_NRF24_CONT_WAVE 0x80 #define RH_NRF24_RF_DR_LOW 0x20 #define RH_NRF24_PLL_LOCK 0x10 #define RH_NRF24_RF_DR_HIGH 0x08 #define RH_NRF24_PWR 0x06 #define RH_NRF24_PWR_m18dBm 0x00 #define RH_NRF24_PWR_m12dBm 0x02 #define RH_NRF24_PWR_m6dBm 0x04 #define RH_NRF24_PWR_0dBm 0x06 #define RH_NRF24_LNA_HCURR 0x01 // #define RH_NRF24_REG_07_STATUS 0x07 #define RH_NRF24_RX_DR 0x40 #define RH_NRF24_TX_DS 0x20 #define RH_NRF24_MAX_RT 0x10 #define RH_NRF24_RX_P_NO 0x0e #define RH_NRF24_STATUS_TX_FULL 0x01 // #define RH_NRF24_REG_08_OBSERVE_TX 0x08 #define RH_NRF24_PLOS_CNT 0xf0 #define RH_NRF24_ARC_CNT 0x0f // #define RH_NRF24_REG_09_RPD 0x09 #define RH_NRF24_RPD 0x01 // #define RH_NRF24_REG_17_FIFO_STATUS 0x17 #define RH_NRF24_TX_REUSE 0x40 #define RH_NRF24_TX_FULL 0x20 #define RH_NRF24_TX_EMPTY 0x10 #define RH_NRF24_RX_FULL 0x02 #define RH_NRF24_RX_EMPTY 0x01 // #define RH_NRF24_REG_1C_DYNPD 0x1c #define RH_NRF24_DPL_ALL 0x3f #define RH_NRF24_DPL_P5 0x20 #define RH_NRF24_DPL_P4 0x10 #define RH_NRF24_DPL_P3 0x08 #define RH_NRF24_DPL_P2 0x04 #define RH_NRF24_DPL_P1 0x02 #define RH_NRF24_DPL_P0 0x01 // #define RH_NRF24_REG_1D_FEATURE 0x1d #define RH_NRF24_EN_DPL 0x04 #define RH_NRF24_EN_ACK_PAY 0x02 #define RH_NRF24_EN_DYN_ACK 0x01 ///////////////////////////////////////////////////////////////////// /// \class RH_NRF24 RH_NRF24.h /// \brief Send and receive addressed, reliable, acknowledged datagrams by nRF24L01 and compatible transceivers. /// /// Supported transceivers include: /// - Nordic nRF24 based 2.4GHz radio modules, such as nRF24L01 http://www.nordicsemi.com/eng/Products/2.4GHz-RF/nRF24L01 /// and other compatible transceivers. /// - nRF24L01p with PA and LNA modules that produce a higher power output similar to this one: /// http://www.elecfreaks.com/wiki/index.php?title=2.4G_Wireless_nRF24L01p_with_PA_and_LNA /// - Sparkfun WRL-00691 module with nRF24L01 https://www.sparkfun.com/products/691 /// or WRL-00705 https://www.sparkfun.com/products/705 etc. /// - Hope-RF RFM73 http://www.hoperf.com/rf/2.4g_module/RFM73.htm and /// http://www.anarduino.com/details.jsp?pid=121 /// and compatible devices (such as BK2423). nRF24L01 and RFM73 can interoperate /// with each other. /// /// This base class provides basic functions for sending and receiving unaddressed, unreliable datagrams /// of arbitrary length to 28 octets per packet. Use one of the Manager classes to get addressing and /// acknowledgement reliability, routing, meshes etc. /// /// The nRF24L01 (http://www.sparkfun.com/datasheets/Wireless/Nordic/nRF24L01P_Product_Specification_1_0.pdf) /// is a low-cost 2.4GHz ISM transceiver module. It supports a number of channel frequencies in the 2.4GHz band /// and a range of data rates. /// /// This library provides functions for sending and receiving messages of up to 28 octets on any /// frequency supported by the nRF24L01, at a selected data rate. /// /// Several nRF24L01 modules can be connected to an Arduino, permitting the construction of translators /// and frequency changers, etc. /// /// The nRF24 transceiver is configured to use Enhanced Shockburst with no acknowledgement and no retransmits. /// TX_ADDR and RX_ADDR_P0 are set to the network address. If you need the low level auto-acknowledgement /// feature supported by this chip, you can use our original NRF24 library /// at http://www.airspayce.com/mikem/arduino/NRF24 /// /// Naturally, for any 2 radios to communicate that must be configured to use the same frequency and /// data rate, and with identical network addresses. /// /// Example Arduino programs are included to show the main modes of use. /// /// \par Packet Format /// /// All messages sent and received by this class conform to this packet format, as specified by /// the nRF24L01 product specification: /// /// - 1 octets PREAMBLE /// - 3 to 5 octets NETWORK ADDRESS /// - 9 bits packet control field /// - 0 to 32 octets PAYLOAD, consisting of: /// - 1 octet TO header /// - 1 octet FROM header /// - 1 octet ID header /// - 1 octet FLAGS header /// - 0 to 28 octets of user message /// - 2 octets CRC /// /// \par Connecting nRF24L01 to Arduino /// /// The electrical connection between the nRF24L01 and the Arduino require 3.3V, the 3 x SPI pins (SCK, SDI, SDO), /// a Chip Enable pin and a Slave Select pin. /// If you are using the Sparkfun WRL-00691 module, it has a voltage regulator on board and /// can be should with 5V VCC if possible. /// The examples below assume the Sparkfun WRL-00691 module /// /// Connect the nRF24L01 to most Arduino's like this (Caution, Arduino Mega has different pins for SPI, /// see below). Use these same connections for Teensy 3.1 (use 3.3V not 5V Vcc). /// \code /// Arduino Sparkfun WRL-00691 /// 5V-----------VCC (3.3V to 7V in) /// pin D8-----------CE (chip enable in) /// SS pin D10----------CSN (chip select in) /// SCK pin D13----------SCK (SPI clock in) /// MOSI pin D11----------SDI (SPI Data in) /// MISO pin D12----------SDO (SPI data out) /// IRQ (Interrupt output, not connected) /// GND----------GND (ground in) /// \endcode /// /// For an Arduino Leonardo (the SPI pins do not come out on the Digital pins as for normal Arduino, but only /// appear on the ICSP header) /// \code /// Leonardo Sparkfun WRL-00691 /// 5V-----------VCC (3.3V to 7V in) /// pin D8-----------CE (chip enable in) /// SS pin D10----------CSN (chip select in) /// SCK ICSP pin 3----------SCK (SPI clock in) /// MOSI ICSP pin 4----------SDI (SPI Data in) /// MISO ICSP pin 1----------SDO (SPI data out) /// IRQ (Interrupt output, not connected) /// GND----------GND (ground in) /// \endcode /// and initialise the NRF24 object like this to explicitly set the SS pin /// NRF24 nrf24(8, 10); /// /// For an Arduino Due (the SPI pins do not come out on the Digital pins as for normal Arduino, but only /// appear on the SPI header). Use the same connections for Yun with 5V or 3.3V. /// \code /// Due Sparkfun WRL-00691 /// 3.3V-----------VCC (3.3V to 7V in) /// pin D8-----------CE (chip enable in) /// SS pin D10----------CSN (chip select in) /// SCK SPI pin 3----------SCK (SPI clock in) /// MOSI SPI pin 4----------SDI (SPI Data in) /// MISO SPI pin 1----------SDO (SPI data out) /// IRQ (Interrupt output, not connected) /// GND----------GND (ground in) /// \endcode /// and initialise the NRF24 object with the default constructor /// NRF24 nrf24; /// /// For an Arduino Mega: /// \code /// Mega Sparkfun WRL-00691 /// 5V-----------VCC (3.3V to 7V in) /// pin D8-----------CE (chip enable in) /// SS pin D53----------CSN (chip select in) /// SCK pin D52----------SCK (SPI clock in) /// MOSI pin D51----------SDI (SPI Data in) /// MISO pin D50----------SDO (SPI data out) /// IRQ (Interrupt output, not connected) /// GND----------GND (ground in) /// \endcode /// and you can then use the constructor RH_NRF24(8, 53). /// /// For an Itead Studio IBoard Pro http://imall.iteadstudio.com/iboard-pro.html, connected by hardware SPI to the /// ITDB02 Parallel LCD Module Interface pins: /// \code /// IBoard Signal=ITDB02 pin Sparkfun WRL-00691 /// 3.3V 37-----------VCC (3.3V to 7V in) /// D2 28-----------CE (chip enable in) /// D29 27----------CSN (chip select in) /// SCK D52 32----------SCK (SPI clock in) /// MOSI D51 34----------SDI (SPI Data in) /// MISO D50 30----------SDO (SPI data out) /// IRQ (Interrupt output, not connected) /// GND 39----------GND (ground in) /// \endcode /// And initialise like this: /// \code /// RH_NRF24 nrf24(2, 29); /// \endcode /// /// For an Itead Studio IBoard Pro http://imall.iteadstudio.com/iboard-pro.html, connected by software SPI to the /// nRF24L01+ Module Interface pins. CAUTION: performance of software SPI is very slow and is not /// compatible with other modules running hardware SPI. /// \code /// IBoard Signal=Module pin Sparkfun WRL-00691 /// 3.3V 2----------VCC (3.3V to 7V in) /// D12 3-----------CE (chip enable in) /// D29 4----------CSN (chip select in) /// D9 5----------SCK (SPI clock in) /// D8 6----------SDI (SPI Data in) /// D7 7----------SDO (SPI data out) /// IRQ (Interrupt output, not connected) /// GND 1----------GND (ground in) /// \endcode /// And initialise like this: /// \code /// #include /// #include /// #include /// Singleton instance of the radio driver /// RHSoftwareSPI spi; /// RH_NRF24 nrf24(12, 11, spi); /// void setup() { /// spi.setPins(7, 8, 9); /// .... /// \endcode /// /// /// For Raspberry Pi with Sparkfun WRL-00691 /// \code /// Raspberry Pi P1 pin Sparkfun WRL-00691 /// 5V 2-----------VCC (3.3V to 7V in) /// GPIO25 22-----------CE (chip enable in) /// GPIO8 24----------CSN (chip select in) /// GPIO11 23----------SCK (SPI clock in) /// GPIO10 19----------SDI (SPI Data in) /// GPIO9 21----------SDO (SPI data out) /// IRQ (Interrupt output, not connected) /// GND 6----------GND (ground in) /// \endcode /// and initialise like this: /// \code /// RH_NRF24 nrf24(RPI_V2_GPIO_P1_22, RPI_V2_GPIO_P1_24); /// \endcode /// See the example program and Makefile in examples/raspi. Requires bcm2835 library to be previously installed. /// \code /// cd examples/raspi /// make /// sudo ./RasPiRH /// \endcode /// \code /// /// You can override the default settings for the CSN and CE pins /// in the NRF24() constructor if you wish to connect the slave select CSN to other than the normal one for your /// Arduino (D10 for Diecimila, Uno etc and D53 for Mega) /// /// Caution: on some Arduinos such as the Mega 2560, if you set the slave select pin to be other than the usual SS /// pin (D53 on Mega 2560), you may need to set the usual SS pin to be an output to force the Arduino into SPI /// master mode. /// /// Caution: this module has not been proved to work with Leonardo, at least without level /// shifters between the nRF24 and the Leonardo. Tests seem to indicate that such level shifters would be required /// with Leonardo to make it work. /// /// It is possible to have 2 radios conected to one arduino, provided each radio has its own /// CSN and CE line (SCK, SDI and SDO are common to both radios) /// /// \par SPI Interface /// /// You can interface to nRF24L01 with with hardware or software SPI. Use of software SPI with the RHSoftwareSPI /// class depends on a fast enough processor and digitalOut() functions to achieve a high enough SPI bus frequency. /// If you observe reliable behaviour with the default hardware SPI RHHardwareSPI, but unreliable behaviour /// with Software SPI RHSoftwareSPI, it may be due to slow CPU performance. /// /// Initialisation example with hardware SPI /// \code /// #include /// RH_NRF24 driver; /// RHReliableDatagram manager(driver, CLIENT_ADDRESS); /// \endcode /// /// Initialisation example with software SPI /// \code /// #include /// #include /// RHSoftwareSPI spi; /// RH_NRF24 driver(8, 10, spi); /// RHReliableDatagram manager(driver, CLIENT_ADDRESS); /// \endcode /// /// \par Example programs /// /// Several example programs are provided. /// /// \par Radio Performance /// /// Frequency accuracy may be debatable. For nominal frequency of 2401.000 MHz (ie channel 1), /// my Yaesu VR-5000 receiver indicated the center frequency for my test radios /// was 2401.121 MHz. Its not clear to me if the Yaesu /// is the source of the error, but I tend to believe it, which would make the nRF24l01 frequency out by 121kHz. /// /// The measured power output for a nRF24L01p with PA and LNA set to 0dBm output is about 18dBm. /// /// \par Radio operating strategy and defaults /// /// The radio is enabled all the time, and switched between TX and RX modes depending on /// whether there is any data to send. Sending data sets the radio to TX mode. /// After data is sent, the radio automatically returns to Standby II mode. Calling waitAvailable() or /// waitAvailableTimeout() starts the radio in RX mode. /// /// The radio is configured by default to Channel 2, 2Mbps, 0dBm power, 5 bytes address, payload width 1, CRC enabled /// 2 byte CRC, No Auto-Ack mode. Enhanced shockburst is used. /// TX and P0 are set to the Network address. Node addresses and decoding are handled with the RH_NRF24 module. /// /// \par Memory /// /// Memory usage of this class is minimal. The compiled client and server sketches are about 6000 bytes on Arduino. /// The reliable client and server sketches compile to about 8500 bytes on Arduino. /// RAM requirements are minimal. /// class RH_NRF24 : public RHNRFSPIDriver { public: /// \brief Defines convenient values for setting data rates in setRF() typedef enum { DataRate1Mbps = 0, ///< 1 Mbps DataRate2Mbps, ///< 2 Mbps DataRate250kbps ///< 250 kbps } DataRate; /// \brief Convenient values for setting transmitter power in setRF() /// These are designed to agree with the values for RF_PWR in RH_NRF24_REG_06_RF_SETUP /// To be passed to setRF(); typedef enum { // Add 20dBm for nRF24L01p with PA and LNA modules TransmitPowerm18dBm = 0, ///< On nRF24, -18 dBm TransmitPowerm12dBm, ///< On nRF24, -12 dBm TransmitPowerm6dBm, ///< On nRF24, -6 dBm TransmitPower0dBm, ///< On nRF24, 0 dBm // Sigh, different power levels for the same bit patterns on RFM73: // On RFM73P-S, there is a Tx power amp, so expect higher power levels, up to 20dBm. Alas // there is no clear documentation on the power for different settings :-( RFM73TransmitPowerm10dBm = 0, ///< On RFM73, -10 dBm RFM73TransmitPowerm5dBm, ///< On RFM73, -5 dBm RFM73TransmitPowerm0dBm, ///< On RFM73, 0 dBm RFM73TransmitPower5dBm ///< On RFM73, 5 dBm. 20dBm on RFM73P-S2 ? } TransmitPower; /// Constructor. You can have multiple instances, but each instance must have its own /// chip enable and slave select pin. /// After constructing, you must call init() to initialise the interface /// and the radio module /// \param[in] chipEnablePin the Arduino pin to use to enable the chip for transmit/receive /// \param[in] slaveSelectPin the Arduino pin number of the output to use to select the NRF24 before /// accessing it. Defaults to the normal SS pin for your Arduino (D10 for Diecimila, Uno etc, D53 for Mega, /// D10 for Maple) /// \param[in] spi Pointer to the SPI interface object to use. /// Defaults to the standard Arduino hardware SPI interface RH_NRF24(uint8_t chipEnablePin = 8, uint8_t slaveSelectPin = SS, RHGenericSPI& spi = hardware_spi); /// Initialises this instance and the radio module connected to it. /// The following steps are taken:g /// - Set the chip enable and chip select pins to output LOW, HIGH respectively. /// - Initialise the SPI output pins /// - Initialise the SPI interface library to 8MHz (Hint, if you want to lower /// the SPI frequency (perhaps where you have other SPI shields, low voltages etc), /// call SPI.setClockDivider() after init()). /// -Flush the receiver and transmitter buffers /// - Set the radio to receive with powerUpRx(); /// \return true if everything was successful bool init(); /// Reads a single register from the NRF24 /// \param[in] reg Register number, one of RH_NRF24_REG_* /// \return The value of the register uint8_t spiReadRegister(uint8_t reg); /// Writes a single byte to the NRF24, and at the same time reads the current STATUS register /// \param[in] reg Register number, one of RH_NRF24_REG_* /// \param[in] val The value to write /// \return the current STATUS (read while the command is sent) uint8_t spiWriteRegister(uint8_t reg, uint8_t val); /// Reads a number of consecutive registers from the NRF24 using burst read mode /// \param[in] reg Register number of the first register, one of RH_NRF24_REG_* /// \param[in] dest Array to write the register values to. Must be at least len bytes /// \param[in] len Number of bytes to read /// \return the current STATUS (read while the command is sent) uint8_t spiBurstReadRegister(uint8_t reg, uint8_t* dest, uint8_t len); /// Write a number of consecutive registers using burst write mode /// \param[in] reg Register number of the first register, one of RH_NRF24_REG_* /// \param[in] src Array of new register values to write. Must be at least len bytes /// \param[in] len Number of bytes to write /// \return the current STATUS (read while the command is sent) uint8_t spiBurstWriteRegister(uint8_t reg, uint8_t* src, uint8_t len); /// Reads and returns the device status register NRF24_REG_02_DEVICE_STATUS /// \return The value of the device status register uint8_t statusRead(); /// Sets the transmit and receive channel number. /// The frequency used is (2400 + channel) MHz /// \return true on success bool setChannel(uint8_t channel); /// Sets the chip configuration that will be used to set /// the NRF24 NRF24_REG_00_CONFIG register when in Idle mode. This allows you to change some /// chip configuration for compatibility with libraries other than this one. /// You should not normally need to call this. /// Defaults to NRF24_EN_CRC| RH_NRF24_CRCO, which is the standard configuration for this library /// (2 byte CRC enabled). /// \param[in] mode The chip configuration to be used whe in Idle mode. /// \return true on success bool setOpMode(uint8_t mode); /// Sets the Network address. /// Only nodes with the same network address can communicate with each other. You /// can set different network addresses in different sets of nodes to isolate them from each other. /// Internally, this sets the nRF24 TX_ADDR and RX_ADDR_P0 to be the given network address. /// The default network address is 0xE7E7E7E7E7 /// \param[in] address The new network address. Must match the network address of any receiving node(s). /// \param[in] len Number of bytes of address to set (3 to 5). /// \return true on success, false if len is not in the range 3-5 inclusive. bool setNetworkAddress(uint8_t* address, uint8_t len); /// Sets the data rate and transmitter power to use. Note that the nRF24 and the RFM73 have different /// available power levels, and for convenience, 2 different sets of values are available in the /// RH_NRF24::TransmitPower enum. The ones with the RFM73 only have meaning on the RFM73 and compatible /// devces. The others are for the nRF24. /// \param [in] data_rate The data rate to use for all packets transmitted and received. One of RH_NRF24::DataRate. /// \param [in] power Transmitter power. One of RH_NRF24::TransmitPower. /// \return true on success bool setRF(DataRate data_rate, TransmitPower power); /// Sets the radio in power down mode, with the configuration set to the /// last value from setOpMode(). /// Sets chip enable to LOW. void setModeIdle(); /// Sets the radio in RX mode. /// Sets chip enable to HIGH to enable the chip in RX mode. void setModeRx(); /// Sets the radio in TX mode. /// Pulses the chip enable LOW then HIGH to enable the chip in TX mode. void setModeTx(); /// Sends data to the address set by setTransmitAddress() /// Sets the radio to TX mode /// \param [in] data Data bytes to send. /// \param [in] len Number of data bytes to send /// \return true on success (which does not necessarily mean the receiver got the message, only that the message was /// successfully transmitted). bool send(const uint8_t* data, uint8_t len); /// Blocks until the current message (if any) /// has been transmitted /// \return true on success, false if the chip is not in transmit mode or other transmit failure virtual bool waitPacketSent(); /// Indicates if the chip is in transmit mode and /// there is a packet currently being transmitted /// \return true if the chip is in transmit mode and there is a transmission in progress bool isSending(); /// Prints the value of all chip registers /// to the Serial device if RH_HAVE_SERIAL is defined for the current platform /// For debugging purposes only. /// \return true on success bool printRegisters(); /// Checks whether a received message is available. /// This can be called multiple times in a timeout loop /// \return true if a complete, valid message has been received and is able to be retrieved by /// recv() bool available(); /// Turns the receiver on if it not already on. /// If there is a valid message available, copy it to buf and return true /// else return false. /// If a message is copied, *len is set to the length (Caution, 0 length messages are permitted). /// You should be sure to call this function frequently enough to not miss any messages /// It is recommended that you call it in your main loop. /// \param[in] buf Location to copy the received message /// \param[in,out] len Pointer to available space in buf. Set to the actual number of octets copied. /// \return true if a valid message was copied to buf bool recv(uint8_t* buf, uint8_t* len); /// The maximum message length supported by this driver /// \return The maximum message length supported by this driver uint8_t maxMessageLength(); /// Sets the radio into Power Down mode. /// If successful, the radio will stay in Power Down mode until woken by /// changing mode it idle, transmit or receive (eg by calling send(), recv(), available() etc) /// Caution: there is a time penalty as the radio takes a finite time to wake from sleep mode. /// \return true if sleep mode was successfully entered. virtual bool sleep(); protected: /// Flush the TX FIFOs /// \return the value of the device status register uint8_t flushTx(); /// Flush the RX FIFOs /// \return the value of the device status register uint8_t flushRx(); /// Examine the receive buffer to determine whether the message is for this node void validateRxBuf(); /// Clear our local receive buffer void clearRxBuf(); private: /// This idle mode chip configuration uint8_t _configuration; /// the number of the chip enable pin uint8_t _chipEnablePin; /// Number of octets in the buffer uint8_t _bufLen; /// The receiver/transmitter buffer uint8_t _buf[RH_NRF24_MAX_PAYLOAD_LEN]; /// True when there is a valid message in the buffer bool _rxBufValid; }; /// @example nrf24_client.pde /// @example nrf24_server.pde /// @example nrf24_reliable_datagram_client.pde /// @example nrf24_reliable_datagram_server.pde /// @example RasPiRH.cpp #endif