Henrik Ekblad
2fd948fc66
Upgraded RF24 to latest version which supports SoftSPI. Added DigitalIO and UTFT libraries to support the new example. Fix problem reported in RelayWithButtonActuator example.
1215 lines
41 KiB
C++
Executable File
1215 lines
41 KiB
C++
Executable File
/*
|
|
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.
|
|
*/
|
|
|
|
/**
|
|
* @file RF24.h
|
|
*
|
|
* Class declaration for RF24 and helper enums
|
|
*/
|
|
|
|
#ifndef __RF24_H__
|
|
#define __RF24_H__
|
|
|
|
#include <RF24_config.h>
|
|
#if defined SOFTSPI
|
|
#include <DigitalIO.h>
|
|
#endif
|
|
/**
|
|
* Power Amplifier level.
|
|
*
|
|
* For use with setPALevel()
|
|
*/
|
|
typedef enum { RF24_PA_MIN = 0,RF24_PA_LOW, RF24_PA_HIGH, RF24_PA_MAX, RF24_PA_ERROR } rf24_pa_dbm_e ;
|
|
|
|
/**
|
|
* Data rate. How fast data moves through the air.
|
|
*
|
|
* For use with setDataRate()
|
|
*/
|
|
typedef enum { RF24_1MBPS = 0, RF24_2MBPS, RF24_250KBPS } rf24_datarate_e;
|
|
|
|
/**
|
|
* CRC Length. How big (if any) of a CRC is included.
|
|
*
|
|
* For use with setCRCLength()
|
|
*/
|
|
typedef enum { RF24_CRC_DISABLED = 0, RF24_CRC_8, RF24_CRC_16 } rf24_crclength_e;
|
|
|
|
/**
|
|
* Driver for nRF24L01(+) 2.4GHz Wireless Transceiver
|
|
*/
|
|
|
|
class RF24
|
|
{
|
|
private:
|
|
#ifdef SOFTSPI
|
|
SoftSPI<SOFT_SPI_MISO_PIN, SOFT_SPI_MOSI_PIN, SOFT_SPI_SCK_PIN, SPI_MODE> spi;
|
|
#elif defined (SPI_UART)
|
|
SPIUARTClass uspi;
|
|
#endif
|
|
|
|
uint8_t ce_pin; /**< "Chip Enable" pin, activates the RX or TX role */
|
|
uint8_t csn_pin; /**< SPI Chip select */
|
|
bool p_variant; /* False for RF24L01 and true for RF24L01P */
|
|
uint8_t payload_size; /**< Fixed size of payloads */
|
|
bool dynamic_payloads_enabled; /**< Whether dynamic payloads are enabled. */
|
|
uint8_t pipe0_reading_address[5]; /**< Last address set on pipe 0 for reading. */
|
|
uint8_t addr_width; /**< The address width to use - 3,4 or 5 bytes. */
|
|
uint32_t lastAvailableCheck; /**< Limits the amount of time between reading data, only when switching between modes */
|
|
boolean listeningStarted; /**< Var for delaying available() after start listening */
|
|
|
|
public:
|
|
|
|
/**
|
|
* @name Primary public interface
|
|
*
|
|
* These are the main methods you need to operate the chip
|
|
*/
|
|
/**@{*/
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* Creates a new instance of this driver. Before using, you create an instance
|
|
* and send in the unique pins that this chip is connected to.
|
|
*
|
|
* @param _cepin The pin attached to Chip Enable on the RF module
|
|
* @param _cspin The pin attached to Chip Select
|
|
*/
|
|
RF24(uint8_t _cepin, uint8_t _cspin);
|
|
|
|
/**
|
|
* Begin operation of the chip
|
|
*
|
|
* Call this in setup(), before calling any other methods.
|
|
*/
|
|
void begin(void);
|
|
|
|
/**
|
|
* Start listening on the pipes opened for reading.
|
|
*
|
|
* Be sure to call openReadingPipe() first. Do not call write() while
|
|
* in this mode, without first calling stopListening(). Call
|
|
* Available() to check for incoming traffic, and read() to get it.
|
|
*/
|
|
void startListening(void);
|
|
|
|
/**
|
|
* Stop listening for incoming messages
|
|
*
|
|
* Do this before calling write().
|
|
*/
|
|
void stopListening(void);
|
|
|
|
/**
|
|
* Test whether there are bytes available to be read
|
|
*
|
|
* @return True if there is a payload available, false if none is
|
|
*/
|
|
bool available(void);
|
|
|
|
/**
|
|
* Read the payload
|
|
*
|
|
* The size of data read is the fixed payload size, see getPayloadSize()
|
|
*
|
|
* @note I specifically chose 'void*' as a data type to make it easier
|
|
* for beginners to use. No casting needed.
|
|
*
|
|
* @note No longer boolean. Use available to determine if packets are
|
|
* available. Interrupt flags are now cleared during reads instead of
|
|
* when calling available().
|
|
*
|
|
* @param buf Pointer to a buffer where the data should be written
|
|
* @param len Maximum number of bytes to read into the buffer
|
|
* @return No return value. Use available().
|
|
*/
|
|
void read( void* buf, uint8_t len );
|
|
|
|
/**
|
|
* Be sure to call openWritingPipe() first to set the destination
|
|
* of where to write to.
|
|
*
|
|
* This blocks until the message is successfully acknowledged by
|
|
* the receiver or the timeout/retransmit maxima are reached. In
|
|
* the current configuration, the max delay here is 60-70ms.
|
|
*
|
|
* The maximum size of data written is the fixed payload size, see
|
|
* getPayloadSize(). However, you can write less, and the remainder
|
|
* will just be filled with zeroes.
|
|
*
|
|
* TX/RX/RT interrupt flags will be cleared every time write is called
|
|
*
|
|
* @param buf Pointer to the data to be sent
|
|
* @param len Number of bytes to be sent
|
|
* @return True if the payload was delivered successfully false if not
|
|
*/
|
|
bool write( const void* buf, uint8_t len );
|
|
|
|
/**
|
|
* New: Open a pipe for writing via byte array. Old addressing format retained
|
|
* for compatibility.
|
|
*
|
|
* Only one writing pipe can be open at once, but you can change the address
|
|
* you'll write to. Call stopListening() first.
|
|
*
|
|
* Addresses are assigned via a byte array, default is 5 byte address length
|
|
*
|
|
* Usage is exactly the same as before, except for declaring the array
|
|
*
|
|
* @code
|
|
* uint8_t addresses[][6] = {"1Node","2Node"};
|
|
* openWritingPipe(addresses[0]);
|
|
* @endcode
|
|
* @see setAddressWidth
|
|
*
|
|
* @param address The address of the pipe to open. Coordinate these pipe
|
|
* addresses amongst nodes on the network.
|
|
*/
|
|
|
|
void openWritingPipe(const uint8_t *address);
|
|
|
|
/**
|
|
* Open a pipe for reading
|
|
*
|
|
* Up to 6 pipes can be open for reading at once. Open all the
|
|
* reading pipes, and then call startListening().
|
|
*
|
|
* @see openWritingPipe
|
|
* @see setAddressWidth
|
|
*
|
|
* @warning Pipes 1-5 should share the same address, except the first byte.
|
|
* Only the first byte in the array should be unique, e.g.
|
|
* @code
|
|
* uint8_t addresses[][6] = {"1Node","2Node"};
|
|
* openReadingPipe(1,addresses[0]);
|
|
* openReadingPipe(2,addresses[1]);
|
|
* @endcode
|
|
*
|
|
* @warning Pipe 0 is also used by the writing pipe. So if you open
|
|
* pipe 0 for reading, and then startListening(), it will overwrite the
|
|
* writing pipe. Ergo, do an openWritingPipe() again before write().
|
|
*
|
|
* @param number Which pipe# to open, 0-5.
|
|
* @param address The 24, 32 or 40 bit address of the pipe to open.
|
|
*/
|
|
|
|
void openReadingPipe(uint8_t number, const uint8_t *address);
|
|
|
|
/**@}*/
|
|
/**
|
|
* @name Advanced Operation
|
|
*
|
|
* Methods you can use to drive the chip in more advanced ways
|
|
*/
|
|
/**@{*/
|
|
|
|
/**
|
|
* Print a giant block of debugging information to stdout
|
|
*
|
|
* @warning Does nothing if stdout is not defined. See fdevopen in stdio.h
|
|
*/
|
|
void printDetails(void);
|
|
|
|
/**
|
|
* Test whether there are bytes available to be read in the
|
|
* FIFO buffers. This optimized version does not rely on interrupt
|
|
* flags, but checks the actual FIFO buffers.
|
|
*
|
|
* @param[out] pipe_num Which pipe has the payload available
|
|
* @return True if there is a payload available, false if none is
|
|
*/
|
|
bool available(uint8_t* pipe_num);
|
|
|
|
/**
|
|
* Check if the radio needs to be read. Can be used to prevent data loss
|
|
* @@return True if all three 32-byte radio buffers are full
|
|
*/
|
|
bool rxFifoFull();
|
|
|
|
/**
|
|
* Enter low-power mode
|
|
*
|
|
* To return to normal power mode, either write() some data or
|
|
* startListening, or powerUp().
|
|
*
|
|
* @note After calling startListening(), a basic radio will consume about 13.5mA
|
|
* at max PA level.
|
|
* During active transmission, the radio will consume about 11.5mA, but this will
|
|
* be reduced to 26uA (.026mA) between sending.
|
|
* In full powerDown mode, the radio will consume approximately 900nA (.0009mA)
|
|
*/
|
|
void powerDown(void);
|
|
|
|
/**
|
|
* Leave low-power mode - required for normal radio operation after calling powerDown()
|
|
*
|
|
* To return to low power mode, call powerDown().
|
|
* @note This will take up to 5ms for maximum compatibility
|
|
*/
|
|
void powerUp(void) ;
|
|
|
|
/**
|
|
* Write for single NOACK writes. Optionally disables acknowledgements/autoretries for a single write.
|
|
*
|
|
* @note enableDynamicAck() must be called to enable this feature
|
|
*
|
|
* Can be used with enableAckPayload() to request a response
|
|
* @see enableDynamicAck()
|
|
* @see setAutoAck()
|
|
* @see write()
|
|
*
|
|
* @param buf Pointer to the data to be sent
|
|
* @param len Number of bytes to be sent
|
|
* @param multicast Request ACK (0), NOACK (1)
|
|
*/
|
|
bool write( const void* buf, uint8_t len, const bool multicast );
|
|
|
|
/**
|
|
* This will not block until the 3 FIFO buffers are filled with data.
|
|
* Once the FIFOs are full, writeFast will simply wait for success or
|
|
* timeout, and return 1 or 0 respectively. From a user perspective, just
|
|
* keep trying to send the same data. The library will keep auto retrying
|
|
* the current payload using the built in functionality.
|
|
* @warning It is important to never keep the nRF24L01 in TX mode and FIFO full for more than 4ms at a time. If the auto
|
|
* retransmit is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
|
|
* to clear by issuing txStandBy() or ensure appropriate time between transmissions.
|
|
*
|
|
* ONLY max retry interrupt flags will be cleared when writeFast is called
|
|
*
|
|
* @code
|
|
* Example (Partial blocking):
|
|
*
|
|
* radio.writeFast(&buf,32); // Writes 1 payload to the buffers
|
|
* txStandBy(); // Returns 0 if failed. 1 if success. Blocks only until MAX_RT timeout or success. Data flushed on fail.
|
|
*
|
|
* radio.writeFast(&buf,32); // Writes 1 payload to the buffers
|
|
* txStandBy(1000); // Using extended timeouts, returns 1 if success. Retries failed payloads for 1 seconds before returning 0.
|
|
* @endcode
|
|
*
|
|
* @see txStandBy()
|
|
* @see write()
|
|
* @see writeBlocking()
|
|
*
|
|
* @param buf Pointer to the data to be sent
|
|
* @param len Number of bytes to be sent
|
|
* @return True if the payload was delivered successfully false if not
|
|
*/
|
|
bool writeFast( const void* buf, uint8_t len );
|
|
|
|
/**
|
|
* WriteFast for single NOACK writes. Disables acknowledgements/autoretries for a single write.
|
|
*
|
|
* @note enableDynamicAck() must be called to enable this feature
|
|
* @see enableDynamicAck()
|
|
* @see setAutoAck()
|
|
*
|
|
* @param buf Pointer to the data to be sent
|
|
* @param len Number of bytes to be sent
|
|
* @param multicast Request ACK (0) or NOACK (1)
|
|
*/
|
|
bool writeFast( const void* buf, uint8_t len, const bool multicast );
|
|
|
|
/**
|
|
* This function extends the auto-retry mechanism to any specified duration.
|
|
* It will not block until the 3 FIFO buffers are filled with data.
|
|
* If so the library will auto retry until a new payload is written
|
|
* or the user specified timeout period is reached.
|
|
* @warning It is important to never keep the nRF24L01 in TX mode and FIFO full for more than 4ms at a time. If the auto
|
|
* retransmit is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
|
|
* to clear by issuing txStandBy() or ensure appropriate time between transmissions.
|
|
*
|
|
* ONLY max retry interrupt flags will be cleared when writeBlocking is called
|
|
* @code
|
|
* Example (Full blocking):
|
|
*
|
|
* radio.writeBlocking(&buf,32,1000); //Wait up to 1 second to write 1 payload to the buffers
|
|
* txStandBy(1000); //Wait up to 1 second for the payload to send. Return 1 if ok, 0 if failed.
|
|
* //Blocks only until user timeout or success. Data flushed on fail.
|
|
* @endcode
|
|
* @note If used from within an interrupt, the interrupt should be disabled until completion, and sei(); called to enable millis().
|
|
* @see txStandBy()
|
|
* @see write()
|
|
* @see writeFast()
|
|
*
|
|
* @param buf Pointer to the data to be sent
|
|
* @param len Number of bytes to be sent
|
|
* @param timeout User defined timeout in milliseconds.
|
|
* @return True if the payload was loaded into the buffer successfully false if not
|
|
*/
|
|
bool writeBlocking( const void* buf, uint8_t len, uint32_t timeout );
|
|
|
|
/**
|
|
* This function should be called as soon as transmission is finished to
|
|
* drop the radio back to STANDBY-I mode. If not issued, the radio will
|
|
* remain in STANDBY-II mode which, per the data sheet, is not a recommended
|
|
* operating mode.
|
|
*
|
|
* @note When transmitting data in rapid succession, it is still recommended by
|
|
* the manufacturer to drop the radio out of TX or STANDBY-II mode if there is
|
|
* time enough between sends for the FIFOs to empty.
|
|
*
|
|
* Relies on built-in auto retry functionality.
|
|
*
|
|
* @code
|
|
* Example (Partial blocking):
|
|
*
|
|
* radio.writeFast(&buf,32);
|
|
* radio.writeFast(&buf,32);
|
|
* radio.writeFast(&buf,32); //Fills the FIFO buffers up
|
|
* bool ok = txStandBy(); //Returns 0 if failed. 1 if success.
|
|
* //Blocks only until MAX_RT timeout or success. Data flushed on fail.
|
|
* @endcode
|
|
* @see txStandBy(unsigned long timeout)
|
|
* @return True if transmission is successful
|
|
*
|
|
*/
|
|
bool txStandBy();
|
|
|
|
/**
|
|
* This function allows extended blocking and auto-retries per a user defined timeout
|
|
* @code
|
|
* Fully Blocking Example:
|
|
*
|
|
* radio.writeFast(&buf,32);
|
|
* radio.writeFast(&buf,32);
|
|
* radio.writeFast(&buf,32); //Fills the FIFO buffers up
|
|
* bool ok = txStandBy(1000); //Returns 0 if failed after 1 second of retries. 1 if success.
|
|
* //Blocks only until user defined timeout or success. Data flushed on fail.
|
|
* @endcode
|
|
* @note If used from within an interrupt, the interrupt should be disabled until completion, and sei(); called to enable millis().
|
|
* @param timeout Number of milliseconds to retry failed payloads
|
|
* @return True if transmission is successful
|
|
*
|
|
*/
|
|
bool txStandBy(uint32_t timeout);
|
|
|
|
/**
|
|
* Write an ack payload for the specified pipe
|
|
*
|
|
* The next time a message is received on @p pipe, the data in @p buf will
|
|
* be sent back in the acknowledgement.
|
|
*
|
|
* @warning Only three of these can be pending at any time as there are only 3 FIFO buffers.
|
|
*
|
|
* @param pipe Which pipe# (typically 1-5) will get this response.
|
|
* @param buf Pointer to data that is sent
|
|
* @param len Length of the data to send, up to 32 bytes max. Not affected
|
|
* by the static payload set by setPayloadSize().
|
|
*/
|
|
void writeAckPayload(uint8_t pipe, const void* buf, uint8_t len);
|
|
|
|
/**
|
|
* Enable dynamic ACKs (single write multicasting) for chosen messages
|
|
*
|
|
* @note To enable full multicasting or per-pipe multicast, use setAutoAck()
|
|
*
|
|
* @warning This MUST be called prior to attempting single write NOACK calls
|
|
* @code
|
|
* radio.enableDynamicAck();
|
|
* radio.write(&data,32,1); // Sends a payload with no acknowledgement requested
|
|
* radio.write(&data,32,0); // Sends a payload using auto-retry/autoACK
|
|
* @endcode
|
|
*/
|
|
void enableDynamicAck();
|
|
|
|
/**
|
|
* Determine if an ack payload was received in the most recent call to
|
|
* write(). The regular available() can also be used.
|
|
*
|
|
* Call read() to retrieve the ack payload.
|
|
*
|
|
* @return True if an ack payload is available.
|
|
*/
|
|
bool isAckPayloadAvailable(void);
|
|
|
|
/**
|
|
* Call this when you get an interrupt to find out why
|
|
*
|
|
* Tells you what caused the interrupt, and clears the state of
|
|
* interrupts.
|
|
*
|
|
* @param[out] tx_ok The send was successful (TX_DS)
|
|
* @param[out] tx_fail The send failed, too many retries (MAX_RT)
|
|
* @param[out] rx_ready There is a message waiting to be read (RX_DS)
|
|
*/
|
|
void whatHappened(bool& tx_ok,bool& tx_fail,bool& rx_ready);
|
|
|
|
/**
|
|
* Non-blocking write to the open writing pipe used for buffered writes
|
|
*
|
|
* @note Optimization: This function now leaves the CE pin high, so the radio
|
|
* will remain in TX or STANDBY-II Mode until a txStandBy() command is issued.
|
|
* This allows the chip to be used to its full potential in TX mode.
|
|
* @warning It is important to never keep the nRF24L01 in TX mode with FIFO full for more than 4ms at a time. If the auto
|
|
* retransmit is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO
|
|
* to clear by issuing txStandBy() or ensure appropriate time between transmissions.
|
|
*
|
|
* @see write()
|
|
* @see writeFast()
|
|
* @see startWrite()
|
|
* @see writeBlocking()
|
|
*
|
|
* For single noAck writes see:
|
|
* @see enableDynamicAck()
|
|
* @see setAutoAck()
|
|
*
|
|
* @param buf Pointer to the data to be sent
|
|
* @param len Number of bytes to be sent
|
|
* @param multicast Request ACK (0) or NOACK (1)
|
|
* @return True if the payload was delivered successfully false if not
|
|
*/
|
|
void startFastWrite( const void* buf, uint8_t len, const bool multicast );
|
|
|
|
/**
|
|
* Non-blocking write to the open writing pipe
|
|
*
|
|
* Just like write(), but it returns immediately. To find out what happened
|
|
* to the send, catch the IRQ and then call whatHappened().
|
|
*
|
|
* @see write()
|
|
* @see writeFast()
|
|
* @see startFastWrite()
|
|
* @see whatHappened()
|
|
*
|
|
* For single noAck writes see:
|
|
* @see enableDynamicAck()
|
|
* @see setAutoAck()
|
|
*
|
|
* @param buf Pointer to the data to be sent
|
|
* @param len Number of bytes to be sent
|
|
* @param multicast Request ACK (0) or NOACK (1)
|
|
*
|
|
*/
|
|
void startWrite( const void* buf, uint8_t len, const bool multicast );
|
|
|
|
/**
|
|
* This function is mainly used internally to take advantage of the auto payload
|
|
* re-use functionality of the chip, but can be beneficial to users as well.
|
|
*
|
|
* The function will instruct the radio to re-use the data in the FIFO buffers,
|
|
* and instructs the radio to re-send once the timeout limit has been reached.
|
|
* Used by writeFast and writeBlocking to initiate retries when a TX failure
|
|
* occurs. Retries are automatically initiated except with the standard write().
|
|
* This way, data is not flushed from the buffer until switching between modes.
|
|
*
|
|
* @note This is to be used AFTER auto-retry fails if wanting to resend
|
|
* using the built-in payload reuse features.
|
|
* After issuing reUseTX(), it will keep reending the same payload forever or until
|
|
* a payload is written to the FIFO, or a flush_tx command is given.
|
|
*/
|
|
void reUseTX();
|
|
|
|
/**
|
|
* Empty the transmit buffer
|
|
*
|
|
* @return Current value of status register
|
|
*/
|
|
uint8_t flush_tx(void);
|
|
|
|
/**
|
|
* Test whether there was a carrier on the line for the
|
|
* previous listening period.
|
|
*
|
|
* Useful to check for interference on the current channel.
|
|
*
|
|
* @return true if was carrier, false if not
|
|
*/
|
|
bool testCarrier(void);
|
|
|
|
/**
|
|
* Test whether a signal (carrier or otherwise) greater than
|
|
* or equal to -64dBm is present on the channel. Valid only
|
|
* on nRF24L01P (+) hardware. On nRF24L01, use testCarrier().
|
|
*
|
|
* Useful to check for interference on the current channel and
|
|
* channel hopping strategies.
|
|
*
|
|
* @return true if signal => -64dBm, false if not
|
|
*/
|
|
bool testRPD(void) ;
|
|
|
|
/**
|
|
* Test whether this is a real radio, or a mock shim for
|
|
* debugging. Setting either pin to 0xff is the way to
|
|
* indicate that this is not a real radio.
|
|
*
|
|
* @return true if this is a legitimate radio
|
|
*/
|
|
bool isValid() { return ce_pin != 0xff && csn_pin != 0xff; }
|
|
|
|
/**
|
|
* The radio will generate interrupt signals when a transmission is complete,
|
|
* a transmission fails, or a payload is received. This allows users to mask
|
|
* those interrupts to prevent them from generating a signal on the interrupt
|
|
* pin.
|
|
*
|
|
* @code
|
|
* Mask all interrupts except the receive interrupt:
|
|
*
|
|
* radio.maskIRQ(1,1,0);
|
|
* @endcode
|
|
*
|
|
* @param tx_ok Mask transmission complete interrupts
|
|
* @param tx_fail Mask transmit failure interrupts
|
|
* @param rx_ready Mask payload received interrupts
|
|
*/
|
|
void maskIRQ(bool tx_ok,bool tx_fail,bool rx_ready);
|
|
|
|
/**
|
|
* Set the address width from 3 to 5 bytes (24, 32 or 40 bit)
|
|
*
|
|
* @param a_width The address width to use: 3,4 or 5
|
|
*/
|
|
|
|
void setAddressWidth(uint8_t a_width);
|
|
|
|
|
|
/**
|
|
* Close a pipe after it has been previously opened.
|
|
* Can be safely called without having previously opened a pipe.
|
|
* @param pipe Which pipe # to close, 0-5.
|
|
*/
|
|
void closeReadingPipe( uint8_t pipe ) ;
|
|
|
|
/**@}*/
|
|
|
|
/**@}*/
|
|
/**
|
|
* @name Optional Configurators
|
|
*
|
|
* Methods you can use to get or set the configuration of the chip.
|
|
* None are required. Calling begin() sets up a reasonable set of
|
|
* defaults.
|
|
*/
|
|
/**@{*/
|
|
|
|
/**
|
|
* Set the number and delay of retries upon failed submit
|
|
*
|
|
* @param delay How long to wait between each retry, in multiples of 250us,
|
|
* max is 15. 0 means 250us, 15 means 4000us.
|
|
* @param count How many retries before giving up, max 15
|
|
*/
|
|
void setRetries(uint8_t delay, uint8_t count);
|
|
|
|
/**
|
|
* Set RF communication channel
|
|
*
|
|
* @param channel Which RF channel to communicate on, 0-127
|
|
*/
|
|
void setChannel(uint8_t channel);
|
|
|
|
/**
|
|
* Set Static Payload Size
|
|
*
|
|
* This implementation uses a pre-stablished fixed payload size for all
|
|
* transmissions. If this method is never called, the driver will always
|
|
* transmit the maximum payload size (32 bytes), no matter how much
|
|
* was sent to write().
|
|
*
|
|
* @todo Implement variable-sized payloads feature
|
|
*
|
|
* @param size The number of bytes in the payload
|
|
*/
|
|
void setPayloadSize(uint8_t size);
|
|
|
|
/**
|
|
* Get Static Payload Size
|
|
*
|
|
* @see setPayloadSize()
|
|
*
|
|
* @return The number of bytes in the payload
|
|
*/
|
|
uint8_t getPayloadSize(void);
|
|
|
|
/**
|
|
* Get Dynamic Payload Size
|
|
*
|
|
* For dynamic payloads, this pulls the size of the payload off
|
|
* the chip
|
|
*
|
|
* @note Corrupt packets are now detected and flushed per the
|
|
* manufacturer.
|
|
*
|
|
* @return Payload length of last-received dynamic payload
|
|
*/
|
|
uint8_t getDynamicPayloadSize(void);
|
|
|
|
/**
|
|
* Enable custom payloads on the acknowledge packets
|
|
*
|
|
* Ack payloads are a handy way to return data back to senders without
|
|
* manually changing the radio modes on both units.
|
|
*
|
|
* @see examples/GettingStarted_CallResponse/GettingStarted_CallResponse.ino
|
|
*/
|
|
void enableAckPayload(void);
|
|
|
|
/**
|
|
* Enable dynamically-sized payloads
|
|
*
|
|
* This way you don't always have to send large packets just to send them
|
|
* once in a while. This enables dynamic payloads on ALL pipes.
|
|
*
|
|
* @see examples/pingpair_pl/pingpair_dyn.pde
|
|
*/
|
|
void enableDynamicPayloads(void);
|
|
|
|
/**
|
|
* Determine whether the hardware is an nRF24L01+ or not.
|
|
*
|
|
* @return true if the hardware is nRF24L01+ (or compatible) and false
|
|
* if its not.
|
|
*/
|
|
bool isPVariant(void) ;
|
|
|
|
/**
|
|
* Enable or disable auto-acknowlede packets
|
|
*
|
|
* This is enabled by default, so it's only needed if you want to turn
|
|
* it off for some reason.
|
|
*
|
|
* @param enable Whether to enable (true) or disable (false) auto-acks
|
|
*/
|
|
void setAutoAck(bool enable);
|
|
|
|
/**
|
|
* Enable or disable auto-acknowlede packets on a per pipeline basis.
|
|
*
|
|
* AA is enabled by default, so it's only needed if you want to turn
|
|
* it off/on for some reason on a per pipeline basis.
|
|
*
|
|
* @param pipe Which pipeline to modify
|
|
* @param enable Whether to enable (true) or disable (false) auto-acks
|
|
*/
|
|
void setAutoAck( uint8_t pipe, bool enable ) ;
|
|
|
|
/**
|
|
* Set Power Amplifier (PA) level to one of four levels:
|
|
* RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH and RF24_PA_MAX
|
|
*
|
|
* The power levels correspond to the following output levels respectively:
|
|
* NRF24L01: -18dBm, -12dBm,-6dBM, and 0dBm
|
|
*
|
|
* SI24R1: -6dBm, 0dBm, 3dBM, and 7dBm.
|
|
*
|
|
* @param level Desired PA level.
|
|
*/
|
|
void setPALevel ( uint8_t level );
|
|
|
|
/**
|
|
* Fetches the current PA level.
|
|
*
|
|
* NRF24L01: -18dBm, -12dBm, -6dBm and 0dBm
|
|
* SI24R1: -6dBm, 0dBm, 3dBm, 7dBm
|
|
*
|
|
* @return Returns values 0 to 3 representing the PA Level.
|
|
*/
|
|
uint8_t getPALevel( void );
|
|
|
|
/**
|
|
* Set the transmission data rate
|
|
*
|
|
* @warning setting RF24_250KBPS will fail for non-plus units
|
|
*
|
|
* @param speed RF24_250KBPS for 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS for 2Mbps
|
|
* @return true if the change was successful
|
|
*/
|
|
bool setDataRate(rf24_datarate_e speed);
|
|
|
|
/**
|
|
* Fetches the transmission data rate
|
|
*
|
|
* @return Returns the hardware's currently configured datarate. The value
|
|
* is one of 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS, as defined in the
|
|
* rf24_datarate_e enum.
|
|
*/
|
|
rf24_datarate_e getDataRate( void ) ;
|
|
|
|
/**
|
|
* Set the CRC length
|
|
*
|
|
* @param length RF24_CRC_8 for 8-bit or RF24_CRC_16 for 16-bit
|
|
*/
|
|
void setCRCLength(rf24_crclength_e length);
|
|
|
|
/**
|
|
* Get the CRC length
|
|
*
|
|
* @return RF24_DISABLED if disabled or RF24_CRC_8 for 8-bit or RF24_CRC_16 for 16-bit
|
|
*/
|
|
rf24_crclength_e getCRCLength(void);
|
|
|
|
/**
|
|
* Disable CRC validation
|
|
*
|
|
*/
|
|
void disableCRC( void ) ;
|
|
|
|
/**
|
|
* Enable error detection by un-commenting #define FAILURE_HANDLING in RF24_config.h
|
|
* If a failure has been detected, it usually indicates a hardware issue. By default the library
|
|
* will cease operation when a failure is detected.
|
|
* This should allow advanced users to detect and resolve intermittent hardware issues.
|
|
*
|
|
* In most cases, the radio must be re-enabled via radio.begin(); and the appropriate settings
|
|
* applied after a failure occurs, if wanting to re-enable the device immediately.
|
|
*
|
|
* Usage: (Failure handling must be enabled per above)
|
|
* @code
|
|
* if(radio.failureDetected){
|
|
* radio.begin(); // Attempt to re-configure the radio with defaults
|
|
* radio.failureDetected = 0; // Reset the detection value
|
|
* radio.openWritingPipe(addresses[1]); // Re-configure pipe addresses
|
|
* radio.openReadingPipe(1,addresses[0]);
|
|
* report_failure(); // Blink leds, send a message, etc. to indicate failure
|
|
* }
|
|
* @endcode
|
|
*/
|
|
//#if defined (FAILURE_HANDLING)
|
|
bool failureDetected;
|
|
//#endif
|
|
|
|
|
|
/**@}*/
|
|
/**
|
|
* @name Deprecated
|
|
*
|
|
* Methods provided for backwards compabibility.
|
|
*/
|
|
/**@{*/
|
|
|
|
|
|
/**
|
|
* Open a pipe for reading
|
|
* @note For compatibility with old code only, see new function
|
|
*
|
|
* @warning Pipes 1-5 should share the first 32 bits.
|
|
* Only the least significant byte should be unique, e.g.
|
|
* @code
|
|
* openReadingPipe(1,0xF0F0F0F0AA);
|
|
* openReadingPipe(2,0xF0F0F0F066);
|
|
* @endcode
|
|
*
|
|
* @warning Pipe 0 is also used by the writing pipe. So if you open
|
|
* pipe 0 for reading, and then startListening(), it will overwrite the
|
|
* writing pipe. Ergo, do an openWritingPipe() again before write().
|
|
*
|
|
* @param number Which pipe# to open, 0-5.
|
|
* @param address The 40-bit address of the pipe to open.
|
|
*/
|
|
void openReadingPipe(uint8_t number, uint64_t address);
|
|
|
|
/**
|
|
* Open a pipe for writing
|
|
* @note For compatibility with old code only, see new function
|
|
* Addresses are 40-bit hex values, e.g.:
|
|
*
|
|
* @code
|
|
* openWritingPipe(0xF0F0F0F0F0);
|
|
* @endcode
|
|
*
|
|
* @param address The 40-bit address of the pipe to open.
|
|
*/
|
|
void openWritingPipe(uint64_t address);
|
|
|
|
private:
|
|
|
|
/**
|
|
* @name Low-level internal interface.
|
|
*
|
|
* Protected methods that address the chip directly. Regular users cannot
|
|
* ever call these. They are documented for completeness and for developers who
|
|
* may want to extend this class.
|
|
*/
|
|
/**@{*/
|
|
|
|
/**
|
|
* Set chip select pin
|
|
*
|
|
* Running SPI bus at PI_CLOCK_DIV2 so we don't waste time transferring data
|
|
* and best of all, we make use of the radio's FIFO buffers. A lower speed
|
|
* means we're less likely to effectively leverage our FIFOs and pay a higher
|
|
* AVR runtime cost as toll.
|
|
*
|
|
* @param mode HIGH to take this unit off the SPI bus, LOW to put it on
|
|
*/
|
|
void csn(bool mode);
|
|
|
|
/**
|
|
* Set chip enable
|
|
*
|
|
* @param level HIGH to actively begin transmission or LOW to put in standby. Please see data sheet
|
|
* for a much more detailed description of this pin.
|
|
*/
|
|
void ce(bool level);
|
|
|
|
/**
|
|
* Read a chunk of data in from a register
|
|
*
|
|
* @param reg Which register. Use constants from nRF24L01.h
|
|
* @param buf Where to put the data
|
|
* @param len How many bytes of data to transfer
|
|
* @return Current value of status register
|
|
*/
|
|
uint8_t read_register(uint8_t reg, uint8_t* buf, uint8_t len);
|
|
|
|
/**
|
|
* Read single byte from a register
|
|
*
|
|
* @param reg Which register. Use constants from nRF24L01.h
|
|
* @return Current value of register @p reg
|
|
*/
|
|
uint8_t read_register(uint8_t reg);
|
|
|
|
/**
|
|
* Write a chunk of data to a register
|
|
*
|
|
* @param reg Which register. Use constants from nRF24L01.h
|
|
* @param buf Where to get the data
|
|
* @param len How many bytes of data to transfer
|
|
* @return Current value of status register
|
|
*/
|
|
uint8_t write_register(uint8_t reg, const uint8_t* buf, uint8_t len);
|
|
|
|
/**
|
|
* Write a single byte to a register
|
|
*
|
|
* @param reg Which register. Use constants from nRF24L01.h
|
|
* @param value The new value to write
|
|
* @return Current value of status register
|
|
*/
|
|
uint8_t write_register(uint8_t reg, uint8_t value);
|
|
|
|
/**
|
|
* Write the transmit payload
|
|
*
|
|
* The size of data written is the fixed payload size, see getPayloadSize()
|
|
*
|
|
* @param buf Where to get the data
|
|
* @param len Number of bytes to be sent
|
|
* @return Current value of status register
|
|
*/
|
|
uint8_t write_payload(const void* buf, uint8_t len, const uint8_t writeType);
|
|
|
|
/**
|
|
* Read the receive payload
|
|
*
|
|
* The size of data read is the fixed payload size, see getPayloadSize()
|
|
*
|
|
* @param buf Where to put the data
|
|
* @param len Maximum number of bytes to read
|
|
* @return Current value of status register
|
|
*/
|
|
uint8_t read_payload(void* buf, uint8_t len);
|
|
|
|
/**
|
|
* Empty the receive buffer
|
|
*
|
|
* @return Current value of status register
|
|
*/
|
|
uint8_t flush_rx(void);
|
|
|
|
/**
|
|
* Retrieve the current status of the chip
|
|
*
|
|
* @return Current value of status register
|
|
*/
|
|
uint8_t get_status(void);
|
|
|
|
#if !defined (MINIMAL)
|
|
/**
|
|
* Decode and print the given status to stdout
|
|
*
|
|
* @param status Status value to print
|
|
*
|
|
* @warning Does nothing if stdout is not defined. See fdevopen in stdio.h
|
|
*/
|
|
void print_status(uint8_t status);
|
|
|
|
/**
|
|
* Decode and print the given 'observe_tx' value to stdout
|
|
*
|
|
* @param value The observe_tx value to print
|
|
*
|
|
* @warning Does nothing if stdout is not defined. See fdevopen in stdio.h
|
|
*/
|
|
void print_observe_tx(uint8_t value);
|
|
|
|
/**
|
|
* Print the name and value of an 8-bit register to stdout
|
|
*
|
|
* Optionally it can print some quantity of successive
|
|
* registers on the same line. This is useful for printing a group
|
|
* of related registers on one line.
|
|
*
|
|
* @param name Name of the register
|
|
* @param reg Which register. Use constants from nRF24L01.h
|
|
* @param qty How many successive registers to print
|
|
*/
|
|
void print_byte_register(const char* name, uint8_t reg, uint8_t qty = 1);
|
|
|
|
/**
|
|
* Print the name and value of a 40-bit address register to stdout
|
|
*
|
|
* Optionally it can print some quantity of successive
|
|
* registers on the same line. This is useful for printing a group
|
|
* of related registers on one line.
|
|
*
|
|
* @param name Name of the register
|
|
* @param reg Which register. Use constants from nRF24L01.h
|
|
* @param qty How many successive registers to print
|
|
*/
|
|
void print_address_register(const char* name, uint8_t reg, uint8_t qty = 1);
|
|
#endif
|
|
/**
|
|
* Turn on or off the special features of the chip
|
|
*
|
|
* The chip has certain 'features' which are only available when the 'features'
|
|
* are enabled. See the datasheet for details.
|
|
*/
|
|
void toggle_features(void);
|
|
|
|
/**
|
|
* Built in spi transfer function to simplify repeating code repeating code
|
|
*/
|
|
|
|
uint8_t spiTrans(uint8_t cmd);
|
|
|
|
#if defined (FAILURE_HANDLING)
|
|
void errNotify(void);
|
|
#endif
|
|
|
|
/**@}*/
|
|
|
|
};
|
|
|
|
/**
|
|
* @example GettingStarted.ino
|
|
* <b>Updated: TMRh20 2014 </b><br>
|
|
*
|
|
* This is an example of how to use the RF24 class to communicate on a basic level. Write this sketch to two
|
|
* different nodes. Put one of the nodes into 'transmit' mode by connecting with the serial monitor and <br>
|
|
* sending a 'T'. The ping node sends the current time to the pong node, which responds by sending the value
|
|
* back. The ping node can then see how long the whole cycle took. <br>
|
|
* @note For a more efficient call-response scenario see the GettingStarted_CallResponse.ino example.
|
|
* @note When switching between sketches, the radio may need to be powered down to clear settings that are not "un-set" otherwise
|
|
*/
|
|
|
|
/**
|
|
* @example GettingStarted_CallResponse.ino
|
|
* <b>New: TMRh20 2014</b><br>
|
|
*
|
|
* This example continues to make use of all the normal functionality of the radios including
|
|
* the auto-ack and auto-retry features, but allows ack-payloads to be written optionlly as well. <br>
|
|
* This allows very fast call-response communication, with the responding radio never having to
|
|
* switch out of Primary Receiver mode to send back a payload, but having the option to switch to <br>
|
|
* primary transmitter if wanting to initiate communication instead of respond to a commmunication.
|
|
*/
|
|
|
|
/**
|
|
* @example Transfer.ino
|
|
* <b>New: TMRh20 </b><br>
|
|
* This example demonstrates half-rate transfer using the FIFO buffers<br>
|
|
*
|
|
* It is an example of how to use the RF24 class. Write this sketch to two
|
|
* different nodes. Put one of the nodes into 'transmit' mode by connecting <br>
|
|
* with the serial monitor and sending a 'T'. The data transfer will begin,
|
|
* with the receiver displaying the payload count. (32Byte Payloads) <br>
|
|
*/
|
|
|
|
/**
|
|
* @example TransferTimeouts.ino
|
|
* <b>New: TMRh20 </b><br>
|
|
* This example demonstrates the use of and extended timeout period and
|
|
* auto-retries/auto-reUse to increase reliability in noisy or low signal scenarios. <br>
|
|
*
|
|
* Write this sketch to two different nodes. Put one of the nodes into 'transmit'
|
|
* mode by connecting with the serial monitor and sending a 'T'. The data <br>
|
|
* transfer will begin, with the receiver displaying the payload count and the
|
|
* data transfer rate.
|
|
*/
|
|
|
|
/**
|
|
* @example starping.pde
|
|
*
|
|
* This sketch is a more complex example of using the RF24 library for Arduino.
|
|
* Deploy this on up to six nodes. Set one as the 'pong receiver' by tying the
|
|
* role_pin low, and the others will be 'ping transmit' units. The ping units
|
|
* unit will send out the value of millis() once a second. The pong unit will
|
|
* respond back with a copy of the value. Each ping unit can get that response
|
|
* back, and determine how long the whole cycle took.
|
|
*
|
|
* This example requires a bit more complexity to determine which unit is which.
|
|
* The pong receiver is identified by having its role_pin tied to ground.
|
|
* The ping senders are further differentiated by a byte in eeprom.
|
|
*/
|
|
|
|
/**
|
|
* @example pingpair_ack.ino
|
|
* <b>Update: TMRh20</b><br>
|
|
* This example continues to make use of all the normal functionality of the radios including
|
|
* the auto-ack and auto-retry features, but allows ack-payloads to be written optionlly as well.<br>
|
|
* This allows very fast call-response communication, with the responding radio never having to
|
|
* switch out of Primary Receiver mode to send back a payload, but having the option to if wanting<br>
|
|
* to initiate communication instead of respond to a commmunication.
|
|
*/
|
|
|
|
/**
|
|
* @example pingpair_irq.ino
|
|
* <b>Update: TMRh20</b><br>
|
|
* This is an example of how to user interrupts to interact with the radio, and a demonstration
|
|
* of how to use them to sleep when receiving, and not miss any payloads.<br>
|
|
* The pingpair_sleepy example expands on sleep functionality with a timed sleep option for the transmitter.
|
|
* Sleep functionality is built directly into my fork of the RF24Network library<br>
|
|
*/
|
|
|
|
/**
|
|
* @example pingpair_sleepy.ino
|
|
* <b>Update: TMRh20</b><br>
|
|
* This is an example of how to use the RF24 class to create a battery-
|
|
* efficient system. It is just like the GettingStarted_CallResponse example, but the<br>
|
|
* ping node powers down the radio and sleeps the MCU after every
|
|
* ping/pong cycle, and the receiver sleeps between payloads. <br>
|
|
*/
|
|
|
|
/**
|
|
* @example rf24ping85.ino
|
|
* <b>New: Contributed by https://github.com/tong67</b><br>
|
|
* This is an example of how to use the RF24 class to communicate with ATtiny85 and other node. <br>
|
|
*/
|
|
|
|
/**
|
|
* @example timingSearch3pin.ino
|
|
* <b>New: Contributed by https://github.com/tong67</b><br>
|
|
* This is an example of how to determine the correct timing for ATtiny when using only 3-pins
|
|
*/
|
|
|
|
/**
|
|
* @example pingpair_dyn.ino
|
|
*
|
|
* This is an example of how to use payloads of a varying (dynamic) size.
|
|
*/
|
|
|
|
/**
|
|
* @example pingpair_maple.pde
|
|
*
|
|
* This is an example of how to use the RF24 class on the Maple. For a more
|
|
* detailed explanation, see my blog post:
|
|
* <a href="http://maniacbug.wordpress.com/2011/12/14/nrf24l01-running-on-maple-3/">nRF24L01+ Running on Maple</a>
|
|
*
|
|
* It will communicate well to an Arduino-based unit as well, so it's not for only Maple-to-Maple communication.
|
|
*
|
|
* Write this sketch to two different nodes,
|
|
* connect the role_pin to ground on one. The ping node sends the current time to the pong node,
|
|
* which responds by sending the value back. The ping node can then see how long the whole cycle
|
|
* took.
|
|
*/
|
|
|
|
/**
|
|
* @example nordic_fob.pde
|
|
*
|
|
* This is an example of how to use the RF24 class to receive signals from the
|
|
* Sparkfun Nordic FOB. See http://www.sparkfun.com/products/8602 .
|
|
* Thanks to Kirk Mower for providing test hardware.
|
|
*/
|
|
|
|
/**
|
|
* @example led_remote.pde
|
|
*
|
|
* This is an example of how to use the RF24 class to control a remote
|
|
* bank of LED's using buttons on a remote control.
|
|
*
|
|
* Every time the buttons change on the remote, the entire state of
|
|
* buttons is send to the led board, which displays the state.
|
|
*/
|
|
|
|
/**
|
|
* @example scanner.ino
|
|
*
|
|
* Example to detect interference on the various channels available.
|
|
* This is a good diagnostic tool to check whether you're picking a
|
|
* good channel for your application.
|
|
*
|
|
* Inspired by cpixip.
|
|
* See http://arduino.cc/forum/index.php/topic,54795.0.html
|
|
*/
|
|
|
|
/**
|
|
* @mainpage Optimized High Speed Driver for nRF24L01(+) 2.4GHz Wireless Transceiver
|
|
*
|
|
* @section Goals Design Goals
|
|
*
|
|
* This library fork is designed to be...
|
|
* @li More compliant with the manufacturer specified operation of the chip, while allowing advanced users
|
|
* to work outside the recommended operation.
|
|
* @li Utilize the capabilities of the radio to their full potential via Arduino
|
|
* @li More reliable, responsive and feature rich
|
|
* @li Easy for beginners to use, with well documented examples and features
|
|
* @li Consumed with a public interface that's similiar to other Arduino standard libraries
|
|
*
|
|
* @section News News
|
|
*
|
|
* <b>Main changes: </b><br>
|
|
* - The library has been tweaked to allow full use of the FIFO buffers for maximum transfer speeds
|
|
* - Many issues and bugs have been resolved
|
|
* - Changes to read() and available () functionality have increased reliability and response
|
|
* - Extended timeout periods have been added to aid in noisy or otherwise unreliable environments
|
|
* - Delays have been removed where possible to ensure maximum efficiency
|
|
* - Full Due support with extended SPI functions
|
|
* - ATTiny now supported.
|
|
* - Raspberry Pi now supported
|
|
* - More! See the links below and class documentation for more info.
|
|
*
|
|
* If issues are discovered with the documentation, please report them <a href="https://github.com/TMRh20/tmrh20.github.io/issues"> here</a>
|
|
* @section Useful Useful References
|
|
*
|
|
* Please refer to:
|
|
*
|
|
* @li <a href="http://tmrh20.github.io/">Documentation Main Page</a>
|
|
* @li <a href="http://tmrh20.github.io/RF24/classRF24.html">RF24 Class Documentation</a>
|
|
* @li <a href="http://tmrh20.blogspot.com/2014/03/high-speed-data-transfers-and-wireless.html">My Blog: RF24 Optimization Overview</a>
|
|
* @li <a href="https://github.com/tmrh20/RF24/">Source Code</a>
|
|
* @li <a href="https://github.com/TMRh20/RF24/archive/master.zip">Download</a>
|
|
* @li <a href="http://www.nordicsemi.com/files/Product/data_sheet/nRF24L01_Product_Specification_v2_0.pdf">Chip Datasheet</a>
|
|
* @li <a href="http://tmrh20.github.io/RF24Network/">RF24Network: Easily create a home or long-range RF24 sensor network</a>
|
|
* @li <a href="http://tmrh20.blogspot.com/2014/03/arduino-radiointercomwireless-audio.html">My Blog: RF24 Wireless Audio</a>
|
|
* @li <a href="https://github.com/maniacbug/RF24">Original Library</a>
|
|
*
|
|
* This chip uses the SPI bus, plus two chip control pins. Remember that pin 10 must still remain an output, or
|
|
* the SPI hardware will go into 'slave' mode.
|
|
*
|
|
* @section Board_Support Board Support
|
|
*
|
|
* Most standard Arduino based boards are supported:
|
|
* - ATMega 328 based boards (Uno, Nano, etc)
|
|
* - Mega Boards (1280, 2560, etc)
|
|
* - Arduino Due: Must use one of the hardware SS/CSN pins as extended SPI methods are used.
|
|
* Initial Due support taken from https://github.com/mcrosson/RF24/tree/due
|
|
* - ATTiny board support initially added from https://github.com/jscrane/RF24
|
|
* Note: ATTiny support is built into the library. Do not include SPI.h. <br>
|
|
* See the included examples for more info on using ATTiny with RF24 <br>
|
|
* See https://github.com/TCWORLD/ATTinyCore/tree/master/PCREL%20Patch%20for%20GCC for ATTiny patch
|
|
* - Raspberry Pi Support: See the readme at https://github.com/TMRh20/RF24/tree/master/RPi/RF24
|
|
*
|
|
* @section More More Information
|
|
*
|
|
* @section Info and Projects
|
|
*
|
|
* @li Project blog:
|
|
* @li <a href="http://TMRh20.blogspot.com"> TMRh20.blogspot.com </a>
|
|
* @li <a href="http://tmrh20.github.io/RF24Audio/"> RF24 Wireless Audio Library </a>
|
|
* @li <a href="https://github.com/TMRh20/RF24Network"> Optimized RF24 Network Layer </a>
|
|
* @li <a href="https://github.com/maniacbug/RF24"> ManiacBug on GitHub (Original Library Author)</a>
|
|
*/
|
|
|
|
#endif // __RF24_H__
|
|
|
|
|