640 lines
30 KiB
C++
640 lines
30 KiB
C++
// 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 <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 <SPI.h>
|
|
/// #include <RH_NRF24.h>
|
|
/// #include <RHSoftwareSPI.h>
|
|
/// 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.h>
|
|
/// RH_NRF24 driver;
|
|
/// RHReliableDatagram manager(driver, CLIENT_ADDRESS);
|
|
/// \endcode
|
|
///
|
|
/// Initialisation example with software SPI
|
|
/// \code
|
|
/// #include <RH_NRF24.h>
|
|
/// #include <RHSoftwareSPI.h>
|
|
/// 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
|