Akash Vibhute
Maniacbug's RF24 arduino library ported to mbed. Tested, it works for Nucleo F411
Dependents: RF24Network_Send RF24Network_Receive WeatherStation maple_chotobot_rf_motores ... more
Embed:
(wiki syntax)
Show/hide line numbers
RF24.h
Go to the documentation of this file.
00001 /* 00002 Copyright (C) 2011 J. Coliz <maniacbug@ymail.com> 00003 00004 This program is free software; you can redistribute it and/or 00005 modify it under the terms of the GNU General Public License 00006 version 2 as published by the Free Software Foundation. 00007 */ 00008 00009 /** 00010 * @file RF24.h 00011 * 00012 * Class declaration for RF24 and helper enums 00013 */ 00014 00015 /* 00016 * Mbed support added by Akash Vibhute <akash.roboticist@gmail.com> 00017 * Porting completed on Nov/05/2015 00018 * 00019 * Updated 1: Synced with TMRh20's RF24 library on Nov/04/2015 from https://github.com/TMRh20 00020 * Updated 2: Synced with TMRh20's RF24 library on Apr/18/2015 from https://github.com/TMRh20 00021 * 00022 */ 00023 00024 #ifndef __RF24_H__ 00025 #define __RF24_H__ 00026 00027 #include "RF24_config.h" 00028 #include <mbed.h> 00029 00030 00031 00032 00033 00034 00035 /** 00036 * Power Amplifier level. 00037 * 00038 * For use with setPALevel() 00039 */ 00040 typedef enum { RF24_PA_MIN = 0,RF24_PA_LOW, RF24_PA_HIGH, RF24_PA_MAX, RF24_PA_ERROR } rf24_pa_dbm_e ; 00041 00042 /** 00043 * Data rate. How fast data moves through the air. 00044 * 00045 * For use with setDataRate() 00046 */ 00047 typedef enum { RF24_1MBPS = 0, RF24_2MBPS, RF24_250KBPS } rf24_datarate_e; 00048 00049 /** 00050 * CRC Length. How big (if any) of a CRC is included. 00051 * 00052 * For use with setCRCLength() 00053 */ 00054 typedef enum { RF24_CRC_DISABLED = 0, RF24_CRC_8, RF24_CRC_16 } rf24_crclength_e; 00055 00056 /** 00057 * Driver for nRF24L01(+) 2.4GHz Wireless Transceiver 00058 */ 00059 00060 class RF24 00061 { 00062 private: 00063 00064 00065 00066 00067 00068 00069 00070 00071 00072 00073 00074 00075 00076 DigitalOut ce_pin; /**< "Chip Enable" pin, activates the RX or TX role */ 00077 DigitalOut csn_pin; /**< SPI Chip select */ 00078 uint16_t spi_speed; /**< SPI Bus Speed */ 00079 00080 SPI spi; 00081 Timer mainTimer; 00082 00083 bool p_variant; /* False for RF24L01 and true for RF24L01P */ 00084 uint8_t payload_size; /**< Fixed size of payloads */ 00085 bool dynamic_payloads_enabled; /**< Whether dynamic payloads are enabled. */ 00086 uint8_t pipe0_reading_address[5]; /**< Last address set on pipe 0 for reading. */ 00087 uint8_t addr_width; /**< The address width to use - 3,4 or 5 bytes. */ 00088 uint32_t txRxDelay; /**< Var for adjusting delays depending on datarate */ 00089 00090 00091 protected: 00092 /** 00093 * SPI transactions 00094 * 00095 * Common code for SPI transactions including CSN toggle 00096 * 00097 */ 00098 inline void beginTransaction(); 00099 00100 inline void endTransaction(); 00101 00102 public: 00103 00104 /** 00105 * @name Primary public interface 00106 * 00107 * These are the main methods you need to operate the chip 00108 */ 00109 /**@{*/ 00110 00111 /** 00112 * Arduino Constructor 00113 * 00114 * Creates a new instance of this driver. Before using, you create an instance 00115 * and send in the unique pins that this chip is connected to. 00116 * 00117 * @param _cepin The pin attached to Chip Enable on the RF module 00118 * @param _cspin The pin attached to Chip Select 00119 */ 00120 RF24(PinName mosi, PinName miso, PinName sck, PinName _cepin, PinName _csnpin); 00121 00122 00123 00124 00125 00126 00127 00128 00129 00130 00131 00132 00133 00134 00135 00136 00137 00138 00139 00140 00141 /** 00142 * Begin operation of the chip 00143 * 00144 * Call this in setup(), before calling any other methods. 00145 * @code radio.begin() @endcode 00146 */ 00147 bool begin(void); 00148 00149 /** 00150 * Start listening on the pipes opened for reading. 00151 * 00152 * 1. Be sure to call openReadingPipe() first. 00153 * 2. Do not call write() while in this mode, without first calling stopListening(). 00154 * 3. Call available() to check for incoming traffic, and read() to get it. 00155 * 00156 * @code 00157 * Open reading pipe 1 using address CCCECCCECC 00158 * 00159 * byte address[] = { 0xCC,0xCE,0xCC,0xCE,0xCC }; 00160 * radio.openReadingPipe(1,address); 00161 * radio.startListening(); 00162 * @endcode 00163 */ 00164 void startListening(void); 00165 00166 /** 00167 * Stop listening for incoming messages, and switch to transmit mode. 00168 * 00169 * Do this before calling write(). 00170 * @code 00171 * radio.stopListening(); 00172 * radio.write(&data,sizeof(data)); 00173 * @endcode 00174 */ 00175 void stopListening(void); 00176 00177 /** 00178 * Check whether there are bytes available to be read 00179 * @code 00180 * if(radio.available()){ 00181 * radio.read(&data,sizeof(data)); 00182 * } 00183 * @endcode 00184 * @return True if there is a payload available, false if none is 00185 */ 00186 bool available(void); 00187 00188 /** 00189 * Read the available payload 00190 * 00191 * The size of data read is the fixed payload size, see getPayloadSize() 00192 * 00193 * @note I specifically chose 'void*' as a data type to make it easier 00194 * for beginners to use. No casting needed. 00195 * 00196 * @note No longer boolean. Use available to determine if packets are 00197 * available. Interrupt flags are now cleared during reads instead of 00198 * when calling available(). 00199 * 00200 * @param buf Pointer to a buffer where the data should be written 00201 * @param len Maximum number of bytes to read into the buffer 00202 * 00203 * @code 00204 * if(radio.available()){ 00205 * radio.read(&data,sizeof(data)); 00206 * } 00207 * @endcode 00208 * @return No return value. Use available(). 00209 */ 00210 void read( void* buf, uint8_t len ); 00211 00212 /** 00213 * Be sure to call openWritingPipe() first to set the destination 00214 * of where to write to. 00215 * 00216 * This blocks until the message is successfully acknowledged by 00217 * the receiver or the timeout/retransmit maxima are reached. In 00218 * the current configuration, the max delay here is 60-70ms. 00219 * 00220 * The maximum size of data written is the fixed payload size, see 00221 * getPayloadSize(). However, you can write less, and the remainder 00222 * will just be filled with zeroes. 00223 * 00224 * TX/RX/RT interrupt flags will be cleared every time write is called 00225 * 00226 * @param buf Pointer to the data to be sent 00227 * @param len Number of bytes to be sent 00228 * 00229 * @code 00230 * radio.stopListening(); 00231 * radio.write(&data,sizeof(data)); 00232 * @endcode 00233 * @return True if the payload was delivered successfully false if not 00234 */ 00235 bool write( const void* buf, uint8_t len ); 00236 00237 /** 00238 * New: Open a pipe for writing via byte array. Old addressing format retained 00239 * for compatibility. 00240 * 00241 * Only one writing pipe can be open at once, but you can change the address 00242 * you'll write to. Call stopListening() first. 00243 * 00244 * Addresses are assigned via a byte array, default is 5 byte address length 00245 s * 00246 * @code 00247 * uint8_t addresses[][6] = {"1Node","2Node"}; 00248 * radio.openWritingPipe(addresses[0]); 00249 * @endcode 00250 * @code 00251 * uint8_t address[] = { 0xCC,0xCE,0xCC,0xCE,0xCC }; 00252 * radio.openWritingPipe(address); 00253 * address[0] = 0x33; 00254 * radio.openReadingPipe(1,address); 00255 * @endcode 00256 * @see setAddressWidth 00257 * 00258 * @param address The address of the pipe to open. Coordinate these pipe 00259 * addresses amongst nodes on the network. 00260 */ 00261 00262 void openWritingPipe(const uint8_t *address); 00263 00264 /** 00265 * Open a pipe for reading 00266 * 00267 * Up to 6 pipes can be open for reading at once. Open all the required 00268 * reading pipes, and then call startListening(). 00269 * 00270 * @see openWritingPipe 00271 * @see setAddressWidth 00272 * 00273 * @note Pipes 0 and 1 will store a full 5-byte address. Pipes 2-5 will technically 00274 * only store a single byte, borrowing up to 4 additional bytes from pipe #1 per the 00275 * assigned address width. 00276 * @warning Pipes 1-5 should share the same address, except the first byte. 00277 * Only the first byte in the array should be unique, e.g. 00278 * @code 00279 * uint8_t addresses[][6] = {"1Node","2Node"}; 00280 * openReadingPipe(1,addresses[0]); 00281 * openReadingPipe(2,addresses[1]); 00282 * @endcode 00283 * 00284 * @warning Pipe 0 is also used by the writing pipe. So if you open 00285 * pipe 0 for reading, and then startListening(), it will overwrite the 00286 * writing pipe. Ergo, do an openWritingPipe() again before write(). 00287 * 00288 * @param number Which pipe# to open, 0-5. 00289 * @param address The 24, 32 or 40 bit address of the pipe to open. 00290 */ 00291 00292 void openReadingPipe(uint8_t number, const uint8_t *address); 00293 00294 /**@}*/ 00295 /** 00296 * @name Advanced Operation 00297 * 00298 * Methods you can use to drive the chip in more advanced ways 00299 */ 00300 /**@{*/ 00301 00302 /** 00303 * Print a giant block of debugging information to stdout 00304 * 00305 * @warning Does nothing if stdout is not defined. See fdevopen in stdio.h 00306 * The printf.h file is included with the library for Arduino. 00307 * @code 00308 * #include <printf.h> 00309 * setup(){ 00310 * Serial.begin(115200); 00311 * printf_begin(); 00312 * ... 00313 * } 00314 * @endcode 00315 */ 00316 void printDetails(void); 00317 00318 /** 00319 * Test whether there are bytes available to be read in the 00320 * FIFO buffers. 00321 * 00322 * @param[out] pipe_num Which pipe has the payload available 00323 * 00324 * @code 00325 * uint8_t pipeNum; 00326 * if(radio.available(&pipeNum)){ 00327 * radio.read(&data,sizeof(data)); 00328 * Serial.print("Got data on pipe"); 00329 * Serial.println(pipeNum); 00330 * } 00331 * @endcode 00332 * @return True if there is a payload available, false if none is 00333 */ 00334 bool available(uint8_t* pipe_num); 00335 00336 /** 00337 * Check if the radio needs to be read. Can be used to prevent data loss 00338 * @return True if all three 32-byte radio buffers are full 00339 */ 00340 bool rxFifoFull(); 00341 00342 /** 00343 * Enter low-power mode 00344 * 00345 * To return to normal power mode, call powerUp(). 00346 * 00347 * @note After calling startListening(), a basic radio will consume about 13.5mA 00348 * at max PA level. 00349 * During active transmission, the radio will consume about 11.5mA, but this will 00350 * be reduced to 26uA (.026mA) between sending. 00351 * In full powerDown mode, the radio will consume approximately 900nA (.0009mA) 00352 * 00353 * @code 00354 * radio.powerDown(); 00355 * avr_enter_sleep_mode(); // Custom function to sleep the device 00356 * radio.powerUp(); 00357 * @endcode 00358 */ 00359 void powerDown(void); 00360 00361 /** 00362 * Leave low-power mode - required for normal radio operation after calling powerDown() 00363 * 00364 * To return to low power mode, call powerDown(). 00365 * @note This will take up to 5ms for maximum compatibility 00366 */ 00367 void powerUp(void) ; 00368 00369 /** 00370 * Write for single NOACK writes. Optionally disables acknowledgements/autoretries for a single write. 00371 * 00372 * @note enableDynamicAck() must be called to enable this feature 00373 * 00374 * Can be used with enableAckPayload() to request a response 00375 * @see enableDynamicAck() 00376 * @see setAutoAck() 00377 * @see write() 00378 * 00379 * @param buf Pointer to the data to be sent 00380 * @param len Number of bytes to be sent 00381 * @param multicast Request ACK (0), NOACK (1) 00382 */ 00383 bool write( const void* buf, uint8_t len, const bool multicast ); 00384 00385 /** 00386 * This will not block until the 3 FIFO buffers are filled with data. 00387 * Once the FIFOs are full, writeFast will simply wait for success or 00388 * timeout, and return 1 or 0 respectively. From a user perspective, just 00389 * keep trying to send the same data. The library will keep auto retrying 00390 * the current payload using the built in functionality. 00391 * @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 00392 * retransmit is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO 00393 * to clear by issuing txStandBy() or ensure appropriate time between transmissions. 00394 * 00395 * @code 00396 * Example (Partial blocking): 00397 * 00398 * radio.writeFast(&buf,32); // Writes 1 payload to the buffers 00399 * txStandBy(); // Returns 0 if failed. 1 if success. Blocks only until MAX_RT timeout or success. Data flushed on fail. 00400 * 00401 * radio.writeFast(&buf,32); // Writes 1 payload to the buffers 00402 * txStandBy(1000); // Using extended timeouts, returns 1 if success. Retries failed payloads for 1 seconds before returning 0. 00403 * @endcode 00404 * 00405 * @see txStandBy() 00406 * @see write() 00407 * @see writeBlocking() 00408 * 00409 * @param buf Pointer to the data to be sent 00410 * @param len Number of bytes to be sent 00411 * @return True if the payload was delivered successfully false if not 00412 */ 00413 bool writeFast( const void* buf, uint8_t len ); 00414 00415 /** 00416 * WriteFast for single NOACK writes. Disables acknowledgements/autoretries for a single write. 00417 * 00418 * @note enableDynamicAck() must be called to enable this feature 00419 * @see enableDynamicAck() 00420 * @see setAutoAck() 00421 * 00422 * @param buf Pointer to the data to be sent 00423 * @param len Number of bytes to be sent 00424 * @param multicast Request ACK (0) or NOACK (1) 00425 */ 00426 bool writeFast( const void* buf, uint8_t len, const bool multicast ); 00427 00428 /** 00429 * This function extends the auto-retry mechanism to any specified duration. 00430 * It will not block until the 3 FIFO buffers are filled with data. 00431 * If so the library will auto retry until a new payload is written 00432 * or the user specified timeout period is reached. 00433 * @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 00434 * retransmit is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO 00435 * to clear by issuing txStandBy() or ensure appropriate time between transmissions. 00436 * 00437 * @code 00438 * Example (Full blocking): 00439 * 00440 * radio.writeBlocking(&buf,32,1000); //Wait up to 1 second to write 1 payload to the buffers 00441 * txStandBy(1000); //Wait up to 1 second for the payload to send. Return 1 if ok, 0 if failed. 00442 * //Blocks only until user timeout or success. Data flushed on fail. 00443 * @endcode 00444 * @note If used from within an interrupt, the interrupt should be disabled until completion, and sei(); called to enable millis(). 00445 * @see txStandBy() 00446 * @see write() 00447 * @see writeFast() 00448 * 00449 * @param buf Pointer to the data to be sent 00450 * @param len Number of bytes to be sent 00451 * @param timeout User defined timeout in milliseconds. 00452 * @return True if the payload was loaded into the buffer successfully false if not 00453 */ 00454 bool writeBlocking( const void* buf, uint8_t len, uint32_t timeout ); 00455 00456 /** 00457 * This function should be called as soon as transmission is finished to 00458 * drop the radio back to STANDBY-I mode. If not issued, the radio will 00459 * remain in STANDBY-II mode which, per the data sheet, is not a recommended 00460 * operating mode. 00461 * 00462 * @note When transmitting data in rapid succession, it is still recommended by 00463 * the manufacturer to drop the radio out of TX or STANDBY-II mode if there is 00464 * time enough between sends for the FIFOs to empty. This is not required if auto-ack 00465 * is enabled. 00466 * 00467 * Relies on built-in auto retry functionality. 00468 * 00469 * @code 00470 * Example (Partial blocking): 00471 * 00472 * radio.writeFast(&buf,32); 00473 * radio.writeFast(&buf,32); 00474 * radio.writeFast(&buf,32); //Fills the FIFO buffers up 00475 * bool ok = txStandBy(); //Returns 0 if failed. 1 if success. 00476 * //Blocks only until MAX_RT timeout or success. Data flushed on fail. 00477 * @endcode 00478 * @see txStandBy(unsigned long timeout) 00479 * @return True if transmission is successful 00480 * 00481 */ 00482 bool txStandBy(); 00483 00484 /** 00485 * This function allows extended blocking and auto-retries per a user defined timeout 00486 * @code 00487 * Fully Blocking Example: 00488 * 00489 * radio.writeFast(&buf,32); 00490 * radio.writeFast(&buf,32); 00491 * radio.writeFast(&buf,32); //Fills the FIFO buffers up 00492 * bool ok = txStandBy(1000); //Returns 0 if failed after 1 second of retries. 1 if success. 00493 * //Blocks only until user defined timeout or success. Data flushed on fail. 00494 * @endcode 00495 * @note If used from within an interrupt, the interrupt should be disabled until completion, and sei(); called to enable millis(). 00496 * @param timeout Number of milliseconds to retry failed payloads 00497 * @return True if transmission is successful 00498 * 00499 */ 00500 bool txStandBy(uint32_t timeout, bool startTx = 0); 00501 00502 /** 00503 * Write an ack payload for the specified pipe 00504 * 00505 * The next time a message is received on @p pipe, the data in @p buf will 00506 * be sent back in the acknowledgement. 00507 * @see enableAckPayload() 00508 * @see enableDynamicPayloads() 00509 * @warning Only three of these can be pending at any time as there are only 3 FIFO buffers.<br> Dynamic payloads must be enabled. 00510 * @note Ack payloads are handled automatically by the radio chip when a payload is received. Users should generally 00511 * write an ack payload as soon as startListening() is called, so one is available when a regular payload is received. 00512 * @note Ack payloads are dynamic payloads. This only works on pipes 0&1 by default. Call 00513 * enableDynamicPayloads() to enable on all pipes. 00514 * 00515 * @param pipe Which pipe# (typically 1-5) will get this response. 00516 * @param buf Pointer to data that is sent 00517 * @param len Length of the data to send, up to 32 bytes max. Not affected 00518 * by the static payload set by setPayloadSize(). 00519 */ 00520 void writeAckPayload(uint8_t pipe, const void* buf, uint8_t len); 00521 00522 /** 00523 * Determine if an ack payload was received in the most recent call to 00524 * write(). The regular available() can also be used. 00525 * 00526 * Call read() to retrieve the ack payload. 00527 * 00528 * @return True if an ack payload is available. 00529 */ 00530 bool isAckPayloadAvailable(void); 00531 00532 /** 00533 * Call this when you get an interrupt to find out why 00534 * 00535 * Tells you what caused the interrupt, and clears the state of 00536 * interrupts. 00537 * 00538 * @param[out] tx_ok The send was successful (TX_DS) 00539 * @param[out] tx_fail The send failed, too many retries (MAX_RT) 00540 * @param[out] rx_ready There is a message waiting to be read (RX_DS) 00541 */ 00542 void whatHappened(bool& tx_ok,bool& tx_fail,bool& rx_ready); 00543 00544 /** 00545 * Non-blocking write to the open writing pipe used for buffered writes 00546 * 00547 * @note Optimization: This function now leaves the CE pin high, so the radio 00548 * will remain in TX or STANDBY-II Mode until a txStandBy() command is issued. Can be used as an alternative to startWrite() 00549 * if writing multiple payloads at once. 00550 * @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 00551 * retransmit/autoAck is enabled, the nRF24L01 is never in TX mode long enough to disobey this rule. Allow the FIFO 00552 * to clear by issuing txStandBy() or ensure appropriate time between transmissions. 00553 * 00554 * @see write() 00555 * @see writeFast() 00556 * @see startWrite() 00557 * @see writeBlocking() 00558 * 00559 * For single noAck writes see: 00560 * @see enableDynamicAck() 00561 * @see setAutoAck() 00562 * 00563 * @param buf Pointer to the data to be sent 00564 * @param len Number of bytes to be sent 00565 * @param multicast Request ACK (0) or NOACK (1) 00566 * @return True if the payload was delivered successfully false if not 00567 */ 00568 void startFastWrite( const void* buf, uint8_t len, const bool multicast, bool startTx = 1 ); 00569 00570 /** 00571 * Non-blocking write to the open writing pipe 00572 * 00573 * Just like write(), but it returns immediately. To find out what happened 00574 * to the send, catch the IRQ and then call whatHappened(). 00575 * 00576 * @see write() 00577 * @see writeFast() 00578 * @see startFastWrite() 00579 * @see whatHappened() 00580 * 00581 * For single noAck writes see: 00582 * @see enableDynamicAck() 00583 * @see setAutoAck() 00584 * 00585 * @param buf Pointer to the data to be sent 00586 * @param len Number of bytes to be sent 00587 * @param multicast Request ACK (0) or NOACK (1) 00588 * 00589 */ 00590 void startWrite( const void* buf, uint8_t len, const bool multicast ); 00591 00592 /** 00593 * This function is mainly used internally to take advantage of the auto payload 00594 * re-use functionality of the chip, but can be beneficial to users as well. 00595 * 00596 * The function will instruct the radio to re-use the data in the FIFO buffers, 00597 * and instructs the radio to re-send once the timeout limit has been reached. 00598 * Used by writeFast and writeBlocking to initiate retries when a TX failure 00599 * occurs. Retries are automatically initiated except with the standard write(). 00600 * This way, data is not flushed from the buffer until switching between modes. 00601 * 00602 * @note This is to be used AFTER auto-retry fails if wanting to resend 00603 * using the built-in payload reuse features. 00604 * After issuing reUseTX(), it will keep reending the same payload forever or until 00605 * a payload is written to the FIFO, or a flush_tx command is given. 00606 */ 00607 void reUseTX(); 00608 00609 /** 00610 * Empty the transmit buffer. This is generally not required in standard operation. 00611 * May be required in specific cases after stopListening() , if operating at 250KBPS data rate. 00612 * 00613 * @return Current value of status register 00614 */ 00615 uint8_t flush_tx(void); 00616 00617 /** 00618 * Test whether there was a carrier on the line for the 00619 * previous listening period. 00620 * 00621 * Useful to check for interference on the current channel. 00622 * 00623 * @return true if was carrier, false if not 00624 */ 00625 bool testCarrier(void); 00626 00627 /** 00628 * Test whether a signal (carrier or otherwise) greater than 00629 * or equal to -64dBm is present on the channel. Valid only 00630 * on nRF24L01P (+) hardware. On nRF24L01, use testCarrier(). 00631 * 00632 * Useful to check for interference on the current channel and 00633 * channel hopping strategies. 00634 * 00635 * @code 00636 * bool goodSignal = radio.testRPD(); 00637 * if(radio.available()){ 00638 * Serial.println(goodSignal ? "Strong signal > 64dBm" : "Weak signal < 64dBm" ); 00639 * radio.read(0,0); 00640 * } 00641 * @endcode 00642 * @return true if signal => -64dBm, false if not 00643 */ 00644 bool testRPD(void) ; 00645 00646 /** 00647 * Test whether this is a real radio, or a mock shim for 00648 * debugging. Setting either pin to 0xff is the way to 00649 * indicate that this is not a real radio. 00650 * 00651 * @return true if this is a legitimate radio 00652 */ 00653 bool isValid() { return ce_pin != 0xff && csn_pin != 0xff; } 00654 00655 /** 00656 * Close a pipe after it has been previously opened. 00657 * Can be safely called without having previously opened a pipe. 00658 * @param pipe Which pipe # to close, 0-5. 00659 */ 00660 void closeReadingPipe( uint8_t pipe ) ; 00661 00662 /** 00663 * Enable error detection by un-commenting #define FAILURE_HANDLING in RF24_config.h 00664 * If a failure has been detected, it usually indicates a hardware issue. By default the library 00665 * will cease operation when a failure is detected. 00666 * This should allow advanced users to detect and resolve intermittent hardware issues. 00667 * 00668 * In most cases, the radio must be re-enabled via radio.begin(); and the appropriate settings 00669 * applied after a failure occurs, if wanting to re-enable the device immediately. 00670 * 00671 * Usage: (Failure handling must be enabled per above) 00672 * @code 00673 * if(radio.failureDetected){ 00674 * radio.begin(); // Attempt to re-configure the radio with defaults 00675 * radio.failureDetected = 0; // Reset the detection value 00676 * radio.openWritingPipe(addresses[1]); // Re-configure pipe addresses 00677 * radio.openReadingPipe(1,addresses[0]); 00678 * report_failure(); // Blink leds, send a message, etc. to indicate failure 00679 * } 00680 * @endcode 00681 */ 00682 //#if defined (FAILURE_HANDLING) 00683 bool failureDetected; 00684 //#endif 00685 00686 /**@}*/ 00687 00688 /**@}*/ 00689 /** 00690 * @name Optional Configurators 00691 * 00692 * Methods you can use to get or set the configuration of the chip. 00693 * None are required. Calling begin() sets up a reasonable set of 00694 * defaults. 00695 */ 00696 /**@{*/ 00697 00698 /** 00699 * Set the address width from 3 to 5 bytes (24, 32 or 40 bit) 00700 * 00701 * @param a_width The address width to use: 3,4 or 5 00702 */ 00703 00704 void setAddressWidth(uint8_t a_width); 00705 00706 /** 00707 * Set the number and delay of retries upon failed submit 00708 * 00709 * @param delay How long to wait between each retry, in multiples of 250us, 00710 * max is 15. 0 means 250us, 15 means 4000us. 00711 * @param count How many retries before giving up, max 15 00712 */ 00713 void setRetries(uint8_t delay, uint8_t count); 00714 00715 /** 00716 * Set RF communication channel 00717 * 00718 * @param channel Which RF channel to communicate on, 0-125 00719 */ 00720 void setChannel(uint8_t channel); 00721 00722 /** 00723 * Get RF communication channel 00724 * 00725 * @return The currently configured RF Channel 00726 */ 00727 uint8_t getChannel(void); 00728 00729 /** 00730 * Set Static Payload Size 00731 * 00732 * This implementation uses a pre-stablished fixed payload size for all 00733 * transmissions. If this method is never called, the driver will always 00734 * transmit the maximum payload size (32 bytes), no matter how much 00735 * was sent to write(). 00736 * 00737 * @todo Implement variable-sized payloads feature 00738 * 00739 * @param size The number of bytes in the payload 00740 */ 00741 void setPayloadSize(uint8_t size); 00742 00743 /** 00744 * Get Static Payload Size 00745 * 00746 * @see setPayloadSize() 00747 * 00748 * @return The number of bytes in the payload 00749 */ 00750 uint8_t getPayloadSize(void); 00751 00752 /** 00753 * Get Dynamic Payload Size 00754 * 00755 * For dynamic payloads, this pulls the size of the payload off 00756 * the chip 00757 * 00758 * @note Corrupt packets are now detected and flushed per the 00759 * manufacturer. 00760 * @code 00761 * if(radio.available()){ 00762 * if(radio.getDynamicPayloadSize() < 1){ 00763 * // Corrupt payload has been flushed 00764 * return; 00765 * } 00766 * radio.read(&data,sizeof(data)); 00767 * } 00768 * @endcode 00769 * 00770 * @return Payload length of last-received dynamic payload 00771 */ 00772 uint8_t getDynamicPayloadSize(void); 00773 00774 /** 00775 * Enable custom payloads on the acknowledge packets 00776 * 00777 * Ack payloads are a handy way to return data back to senders without 00778 * manually changing the radio modes on both units. 00779 * 00780 * @note Ack payloads are dynamic payloads. This only works on pipes 0&1 by default. Call 00781 * enableDynamicPayloads() to enable on all pipes. 00782 */ 00783 void enableAckPayload(void); 00784 00785 /** 00786 * Enable dynamically-sized payloads 00787 * 00788 * This way you don't always have to send large packets just to send them 00789 * once in a while. This enables dynamic payloads on ALL pipes. 00790 * 00791 */ 00792 void enableDynamicPayloads(void); 00793 00794 /** 00795 * Enable dynamic ACKs (single write multicast or unicast) for chosen messages 00796 * 00797 * @note To enable full multicast or per-pipe multicast, use setAutoAck() 00798 * 00799 * @warning This MUST be called prior to attempting single write NOACK calls 00800 * @code 00801 * radio.enableDynamicAck(); 00802 * radio.write(&data,32,1); // Sends a payload with no acknowledgement requested 00803 * radio.write(&data,32,0); // Sends a payload using auto-retry/autoACK 00804 * @endcode 00805 */ 00806 void enableDynamicAck(); 00807 00808 /** 00809 * Determine whether the hardware is an nRF24L01+ or not. 00810 * 00811 * @return true if the hardware is nRF24L01+ (or compatible) and false 00812 * if its not. 00813 */ 00814 bool isPVariant(void) ; 00815 00816 /** 00817 * Enable or disable auto-acknowlede packets 00818 * 00819 * This is enabled by default, so it's only needed if you want to turn 00820 * it off for some reason. 00821 * 00822 * @param enable Whether to enable (true) or disable (false) auto-acks 00823 */ 00824 void setAutoAck(bool enable); 00825 00826 /** 00827 * Enable or disable auto-acknowlede packets on a per pipeline basis. 00828 * 00829 * AA is enabled by default, so it's only needed if you want to turn 00830 * it off/on for some reason on a per pipeline basis. 00831 * 00832 * @param pipe Which pipeline to modify 00833 * @param enable Whether to enable (true) or disable (false) auto-acks 00834 */ 00835 void setAutoAck( uint8_t pipe, bool enable ) ; 00836 00837 /** 00838 * Set Power Amplifier (PA) level to one of four levels: 00839 * RF24_PA_MIN, RF24_PA_LOW, RF24_PA_HIGH and RF24_PA_MAX 00840 * 00841 * The power levels correspond to the following output levels respectively: 00842 * NRF24L01: -18dBm, -12dBm,-6dBM, and 0dBm 00843 * 00844 * SI24R1: -6dBm, 0dBm, 3dBM, and 7dBm. 00845 * 00846 * @param level Desired PA level. 00847 */ 00848 void setPALevel ( uint8_t level ); 00849 00850 /** 00851 * Fetches the current PA level. 00852 * 00853 * NRF24L01: -18dBm, -12dBm, -6dBm and 0dBm 00854 * SI24R1: -6dBm, 0dBm, 3dBm, 7dBm 00855 * 00856 * @return Returns values 0 to 3 representing the PA Level. 00857 */ 00858 uint8_t getPALevel( void ); 00859 00860 /** 00861 * Set the transmission data rate 00862 * 00863 * @warning setting RF24_250KBPS will fail for non-plus units 00864 * 00865 * @param speed RF24_250KBPS for 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS for 2Mbps 00866 * @return true if the change was successful 00867 */ 00868 bool setDataRate(rf24_datarate_e speed); 00869 00870 /** 00871 * Fetches the transmission data rate 00872 * 00873 * @return Returns the hardware's currently configured datarate. The value 00874 * is one of 250kbs, RF24_1MBPS for 1Mbps, or RF24_2MBPS, as defined in the 00875 * rf24_datarate_e enum. 00876 */ 00877 rf24_datarate_e getDataRate( void ) ; 00878 00879 /** 00880 * Set the CRC length 00881 * <br>CRC checking cannot be disabled if auto-ack is enabled 00882 * @param length RF24_CRC_8 for 8-bit or RF24_CRC_16 for 16-bit 00883 */ 00884 void setCRCLength(rf24_crclength_e length); 00885 00886 /** 00887 * Get the CRC length 00888 * <br>CRC checking cannot be disabled if auto-ack is enabled 00889 * @return RF24_DISABLED if disabled or RF24_CRC_8 for 8-bit or RF24_CRC_16 for 16-bit 00890 */ 00891 rf24_crclength_e getCRCLength(void); 00892 00893 /** 00894 * Disable CRC validation 00895 * 00896 * @warning CRC cannot be disabled if auto-ack/ESB is enabled. 00897 */ 00898 void disableCRC( void ) ; 00899 00900 /** 00901 * The radio will generate interrupt signals when a transmission is complete, 00902 * a transmission fails, or a payload is received. This allows users to mask 00903 * those interrupts to prevent them from generating a signal on the interrupt 00904 * pin. Interrupts are enabled on the radio chip by default. 00905 * 00906 * @code 00907 * Mask all interrupts except the receive interrupt: 00908 * 00909 * radio.maskIRQ(1,1,0); 00910 * @endcode 00911 * 00912 * @param tx_ok Mask transmission complete interrupts 00913 * @param tx_fail Mask transmit failure interrupts 00914 * @param rx_ready Mask payload received interrupts 00915 */ 00916 void maskIRQ(bool tx_ok,bool tx_fail,bool rx_ready); 00917 00918 /**@}*/ 00919 /** 00920 * @name Deprecated 00921 * 00922 * Methods provided for backwards compabibility. 00923 */ 00924 /**@{*/ 00925 00926 00927 /** 00928 * Open a pipe for reading 00929 * @note For compatibility with old code only, see new function 00930 * 00931 * @warning Pipes 1-5 should share the first 32 bits. 00932 * Only the least significant byte should be unique, e.g. 00933 * @code 00934 * openReadingPipe(1,0xF0F0F0F0AA); 00935 * openReadingPipe(2,0xF0F0F0F066); 00936 * @endcode 00937 * 00938 * @warning Pipe 0 is also used by the writing pipe. So if you open 00939 * pipe 0 for reading, and then startListening(), it will overwrite the 00940 * writing pipe. Ergo, do an openWritingPipe() again before write(). 00941 * 00942 * @param number Which pipe# to open, 0-5. 00943 * @param address The 40-bit address of the pipe to open. 00944 */ 00945 void openReadingPipe(uint8_t number, uint64_t address); 00946 00947 /** 00948 * Open a pipe for writing 00949 * @note For compatibility with old code only, see new function 00950 * 00951 * Addresses are 40-bit hex values, e.g.: 00952 * 00953 * @code 00954 * openWritingPipe(0xF0F0F0F0F0); 00955 * @endcode 00956 * 00957 * @param address The 40-bit address of the pipe to open. 00958 */ 00959 void openWritingPipe(uint64_t address); 00960 00961 private: 00962 00963 /** 00964 * @name Low-level internal interface. 00965 * 00966 * Protected methods that address the chip directly. Regular users cannot 00967 * ever call these. They are documented for completeness and for developers who 00968 * may want to extend this class. 00969 */ 00970 /**@{*/ 00971 00972 /** 00973 * Set chip select pin 00974 * 00975 * Running SPI bus at PI_CLOCK_DIV2 so we don't waste time transferring data 00976 * and best of all, we make use of the radio's FIFO buffers. A lower speed 00977 * means we're less likely to effectively leverage our FIFOs and pay a higher 00978 * AVR runtime cost as toll. 00979 * 00980 * @param mode HIGH to take this unit off the SPI bus, LOW to put it on 00981 */ 00982 void csn(bool mode); 00983 00984 /** 00985 * Set chip enable 00986 * 00987 * @param level HIGH to actively begin transmission or LOW to put in standby. Please see data sheet 00988 * for a much more detailed description of this pin. 00989 */ 00990 void ce(bool level); 00991 00992 /** 00993 * Read a chunk of data in from a register 00994 * 00995 * @param reg Which register. Use constants from nRF24L01.h 00996 * @param buf Where to put the data 00997 * @param len How many bytes of data to transfer 00998 * @return Current value of status register 00999 */ 01000 uint8_t read_register(uint8_t reg, uint8_t* buf, uint8_t len); 01001 01002 /** 01003 * Read single byte from a register 01004 * 01005 * @param reg Which register. Use constants from nRF24L01.h 01006 * @return Current value of register @p reg 01007 */ 01008 uint8_t read_register(uint8_t reg); 01009 01010 /** 01011 * Write a chunk of data to a register 01012 * 01013 * @param reg Which register. Use constants from nRF24L01.h 01014 * @param buf Where to get the data 01015 * @param len How many bytes of data to transfer 01016 * @return Current value of status register 01017 */ 01018 uint8_t write_register(uint8_t reg, const uint8_t* buf, uint8_t len); 01019 01020 /** 01021 * Write a single byte to a register 01022 * 01023 * @param reg Which register. Use constants from nRF24L01.h 01024 * @param value The new value to write 01025 * @return Current value of status register 01026 */ 01027 uint8_t write_register(uint8_t reg, uint8_t value); 01028 01029 /** 01030 * Write the transmit payload 01031 * 01032 * The size of data written is the fixed payload size, see getPayloadSize() 01033 * 01034 * @param buf Where to get the data 01035 * @param len Number of bytes to be sent 01036 * @return Current value of status register 01037 */ 01038 uint8_t write_payload(const void* buf, uint8_t len, const uint8_t writeType); 01039 01040 /** 01041 * Read the receive payload 01042 * 01043 * The size of data read is the fixed payload size, see getPayloadSize() 01044 * 01045 * @param buf Where to put the data 01046 * @param len Maximum number of bytes to read 01047 * @return Current value of status register 01048 */ 01049 uint8_t read_payload(void* buf, uint8_t len); 01050 01051 /** 01052 * Empty the receive buffer 01053 * 01054 * @return Current value of status register 01055 */ 01056 uint8_t flush_rx(void); 01057 01058 /** 01059 * Retrieve the current status of the chip 01060 * 01061 * @return Current value of status register 01062 */ 01063 uint8_t get_status(void); 01064 01065 #if !defined (MINIMAL) 01066 /** 01067 * Decode and print the given status to stdout 01068 * 01069 * @param status Status value to print 01070 * 01071 * @warning Does nothing if stdout is not defined. See fdevopen in stdio.h 01072 */ 01073 void print_status(uint8_t status); 01074 01075 /** 01076 * Decode and print the given 'observe_tx' value to stdout 01077 * 01078 * @param value The observe_tx value to print 01079 * 01080 * @warning Does nothing if stdout is not defined. See fdevopen in stdio.h 01081 */ 01082 void print_observe_tx(uint8_t value); 01083 01084 /** 01085 * Print the name and value of an 8-bit register to stdout 01086 * 01087 * Optionally it can print some quantity of successive 01088 * registers on the same line. This is useful for printing a group 01089 * of related registers on one line. 01090 * 01091 * @param name Name of the register 01092 * @param reg Which register. Use constants from nRF24L01.h 01093 * @param qty How many successive registers to print 01094 */ 01095 void print_byte_register(const char* name, uint8_t reg, uint8_t qty = 1); 01096 01097 /** 01098 * Print the name and value of a 40-bit address register to stdout 01099 * 01100 * Optionally it can print some quantity of successive 01101 * registers on the same line. This is useful for printing a group 01102 * of related registers on one line. 01103 * 01104 * @param name Name of the register 01105 * @param reg Which register. Use constants from nRF24L01.h 01106 * @param qty How many successive registers to print 01107 */ 01108 void print_address_register(const char* name, uint8_t reg, uint8_t qty = 1); 01109 #endif 01110 /** 01111 * Turn on or off the special features of the chip 01112 * 01113 * The chip has certain 'features' which are only available when the 'features' 01114 * are enabled. See the datasheet for details. 01115 */ 01116 void toggle_features(void); 01117 01118 /** 01119 * Built in spi transfer function to simplify repeating code repeating code 01120 */ 01121 01122 uint8_t spiTrans(uint8_t cmd); 01123 01124 #if defined (FAILURE_HANDLING) || defined (RF24_LINUX) 01125 void errNotify(void); 01126 #endif 01127 01128 /**@}*/ 01129 01130 }; 01131 01132 01133 /** 01134 * @example GettingStarted.ino 01135 * <b>For Arduino</b><br> 01136 * <b>Updated: TMRh20 2014 </b><br> 01137 * 01138 * This is an example of how to use the RF24 class to communicate on a basic level. Configure and write this sketch to two 01139 * different nodes. Put one of the nodes into 'transmit' mode by connecting with the serial monitor and <br> 01140 * sending a 'T'. The ping node sends the current time to the pong node, which responds by sending the value 01141 * back. The ping node can then see how long the whole cycle took. <br> 01142 * @note For a more efficient call-response scenario see the GettingStarted_CallResponse.ino example. 01143 * @note When switching between sketches, the radio may need to be powered down to clear settings that are not "un-set" otherwise 01144 */ 01145 01146 /** 01147 * @example GettingStarted.cpp 01148 * <b>For Raspberry Pi</b><br> 01149 * <b>Updated: TMRh20 2014 </b><br> 01150 * 01151 * This is an example of how to use the RF24 class to communicate on a basic level. Configure and write this sketch to two 01152 * different nodes. Put one of the nodes into 'transmit' mode by connecting with the serial monitor and <br> 01153 * sending a 'T'. The ping node sends the current time to the pong node, which responds by sending the value 01154 * back. The ping node can then see how long the whole cycle took. <br> 01155 * @note For a more efficient call-response scenario see the GettingStarted_CallResponse.ino example. 01156 */ 01157 01158 /** 01159 * @example GettingStarted_CallResponse.ino 01160 * <b>For Arduino</b><br> 01161 * <b>New: TMRh20 2014</b><br> 01162 * 01163 * This example continues to make use of all the normal functionality of the radios including 01164 * the auto-ack and auto-retry features, but allows ack-payloads to be written optionlly as well. <br> 01165 * This allows very fast call-response communication, with the responding radio never having to 01166 * switch out of Primary Receiver mode to send back a payload, but having the option to switch to <br> 01167 * primary transmitter if wanting to initiate communication instead of respond to a commmunication. 01168 */ 01169 01170 /** 01171 * @example GettingStarted_Call_Response.cpp 01172 * <b>For Raspberry Pi</b><br> 01173 * <b>New: TMRh20 2014</b><br> 01174 * 01175 * This example continues to make use of all the normal functionality of the radios including 01176 * the auto-ack and auto-retry features, but allows ack-payloads to be written optionlly as well. <br> 01177 * This allows very fast call-response communication, with the responding radio never having to 01178 * switch out of Primary Receiver mode to send back a payload, but having the option to switch to <br> 01179 * primary transmitter if wanting to initiate communication instead of respond to a commmunication. 01180 */ 01181 01182 /** 01183 * @example GettingStarted_HandlingData.ino 01184 * <b>Dec 2014 - TMRh20</b><br> 01185 * 01186 * This example demonstrates how to send multiple variables in a single payload and work with data. As usual, it is 01187 * generally important to include an incrementing value like millis() in the payloads to prevent errors. 01188 */ 01189 01190 /** 01191 * @example Transfer.ino 01192 * <b>For Arduino</b><br> 01193 * This example demonstrates half-rate transfer using the FIFO buffers<br> 01194 * 01195 * It is an example of how to use the RF24 class. Write this sketch to two 01196 * different nodes. Put one of the nodes into 'transmit' mode by connecting <br> 01197 * with the serial monitor and sending a 'T'. The data transfer will begin, 01198 * with the receiver displaying the payload count. (32Byte Payloads) <br> 01199 */ 01200 01201 /** 01202 * @example Transfer.cpp 01203 * <b>For Raspberry Pi</b><br> 01204 * This example demonstrates half-rate transfer using the FIFO buffers<br> 01205 * 01206 * It is an example of how to use the RF24 class. Write this sketch to two 01207 * different nodes. Put one of the nodes into 'transmit' mode by connecting <br> 01208 * with the serial monitor and sending a 'T'. The data transfer will begin, 01209 * with the receiver displaying the payload count. (32Byte Payloads) <br> 01210 */ 01211 01212 /** 01213 * @example TransferTimeouts.ino 01214 * <b>New: TMRh20 </b><br> 01215 * This example demonstrates the use of and extended timeout period and 01216 * auto-retries/auto-reUse to increase reliability in noisy or low signal scenarios. <br> 01217 * 01218 * Write this sketch to two different nodes. Put one of the nodes into 'transmit' 01219 * mode by connecting with the serial monitor and sending a 'T'. The data <br> 01220 * transfer will begin, with the receiver displaying the payload count and the 01221 * data transfer rate. 01222 */ 01223 01224 /** 01225 * @example starping.pde 01226 * 01227 * This sketch is a more complex example of using the RF24 library for Arduino. 01228 * Deploy this on up to six nodes. Set one as the 'pong receiver' by tying the 01229 * role_pin low, and the others will be 'ping transmit' units. The ping units 01230 * unit will send out the value of millis() once a second. The pong unit will 01231 * respond back with a copy of the value. Each ping unit can get that response 01232 * back, and determine how long the whole cycle took. 01233 * 01234 * This example requires a bit more complexity to determine which unit is which. 01235 * The pong receiver is identified by having its role_pin tied to ground. 01236 * The ping senders are further differentiated by a byte in eeprom. 01237 */ 01238 01239 /** 01240 * @example pingpair_ack.ino 01241 * <b>Update: TMRh20</b><br> 01242 * This example continues to make use of all the normal functionality of the radios including 01243 * the auto-ack and auto-retry features, but allows ack-payloads to be written optionlly as well.<br> 01244 * This allows very fast call-response communication, with the responding radio never having to 01245 * switch out of Primary Receiver mode to send back a payload, but having the option to if wanting<br> 01246 * to initiate communication instead of respond to a commmunication. 01247 */ 01248 01249 /** 01250 * @example pingpair_irq.ino 01251 * <b>Update: TMRh20</b><br> 01252 * This is an example of how to user interrupts to interact with the radio, and a demonstration 01253 * of how to use them to sleep when receiving, and not miss any payloads.<br> 01254 * The pingpair_sleepy example expands on sleep functionality with a timed sleep option for the transmitter. 01255 * Sleep functionality is built directly into my fork of the RF24Network library<br> 01256 */ 01257 01258 /** 01259 * @example pingpair_irq_simple.ino 01260 * <b>Dec 2014 - TMRh20</b><br> 01261 * This is an example of how to user interrupts to interact with the radio, with bidirectional communication. 01262 */ 01263 01264 /** 01265 * @example pingpair_sleepy.ino 01266 * <b>Update: TMRh20</b><br> 01267 * This is an example of how to use the RF24 class to create a battery- 01268 * efficient system. It is just like the GettingStarted_CallResponse example, but the<br> 01269 * ping node powers down the radio and sleeps the MCU after every 01270 * ping/pong cycle, and the receiver sleeps between payloads. <br> 01271 */ 01272 01273 /** 01274 * @example rf24ping85.ino 01275 * <b>New: Contributed by https://github.com/tong67</b><br> 01276 * This is an example of how to use the RF24 class to communicate with ATtiny85 and other node. <br> 01277 */ 01278 01279 /** 01280 * @example timingSearch3pin.ino 01281 * <b>New: Contributed by https://github.com/tong67</b><br> 01282 * This is an example of how to determine the correct timing for ATtiny when using only 3-pins 01283 */ 01284 01285 /** 01286 * @example pingpair_dyn.ino 01287 * 01288 * This is an example of how to use payloads of a varying (dynamic) size on Arduino. 01289 */ 01290 01291 /** 01292 * @example pingpair_dyn.cpp 01293 * 01294 * This is an example of how to use payloads of a varying (dynamic) size on Raspberry Pi. 01295 */ 01296 01297 /** 01298 * @example pingpair_dyn.py 01299 * 01300 * This is a python example for RPi of how to use payloads of a varying (dynamic) size. 01301 */ 01302 01303 /** 01304 * @example pingpair_dyn.ino 01305 * 01306 * This is an example of how to use payloads of a varying (dynamic) size. 01307 */ 01308 01309 /** 01310 * @example pingpair_dyn.ino 01311 * 01312 * This is an example of how to use payloads of a varying (dynamic) size. 01313 */ 01314 01315 /** 01316 * @example scanner.ino 01317 * 01318 * Example to detect interference on the various channels available. 01319 * This is a good diagnostic tool to check whether you're picking a 01320 * good channel for your application. 01321 * 01322 * Inspired by cpixip. 01323 * See http://arduino.cc/forum/index.php/topic,54795.0.html 01324 */ 01325 01326 /** 01327 * @mainpage Optimized High Speed Driver for nRF24L01(+) 2.4GHz Wireless Transceiver 01328 * 01329 * @section Goals Design Goals 01330 * 01331 * This library fork is designed to be... 01332 * @li More compliant with the manufacturer specified operation of the chip, while allowing advanced users 01333 * to work outside the recommended operation. 01334 * @li Utilize the capabilities of the radio to their full potential via Arduino 01335 * @li More reliable, responsive, bug-free and feature rich 01336 * @li Easy for beginners to use, with well documented examples and features 01337 * @li Consumed with a public interface that's similar to other Arduino standard libraries 01338 * 01339 * @section News News 01340 * 01341 * **Dec 2015**<br> 01342 * - ESP8266 support via Arduino IDE 01343 * - <a href="https://github.com/stewarthou/Particle-RF24">Particle Photon/Core</a> fork available 01344 * - ATTiny2313/4313 support added 01345 * - Python 3 support added 01346 * - RF24 added to Arduino library manager 01347 * - RF24 added to PlatformIO library manager 01348 * 01349 * **March 2015**<br> 01350 * - Uses SPI transactions on Arduino 01351 * - New layout for <a href="Portability.html">easier portability:</a> Break out defines & includes for individual platforms to RF24/utility 01352 * - <a href="MRAA.html">MRAA</a> support added ( Galileo, Edison, etc) 01353 * - <a href="BBB.html">BBB/Generic Linux </a> support via spidev & MRAA 01354 * - Support for RPi 2 added 01355 * - Major Documentation cleanup & update (Move all docs to github.io) 01356 * 01357 * 01358 * If issues are discovered with the documentation, please report them <a href="https://github.com/TMRh20/tmrh20.github.io/issues"> here</a> 01359 * 01360 * <br> 01361 * @section Useful Useful References 01362 * 01363 * 01364 * @li <a href="http://tmrh20.github.io/RF24/classRF24.html"><b>RF24</b> Class Documentation</a> 01365 * @li <a href="https://github.com/TMRh20/RF24/archive/master.zip"><b>Download</b></a> 01366 * @li <a href="https://github.com/tmrh20/RF24/"><b>Source Code</b></a> 01367 * @li <a href="http://tmrh20.blogspot.com/2014/03/high-speed-data-transfers-and-wireless.html"><b>My Blog:</b> RF24 Optimization Overview</a> 01368 * @li <a href="http://www.nordicsemi.com/files/Product/data_sheet/nRF24L01_Product_Specification_v2_0.pdf">Chip Datasheet</a> 01369 * 01370 * **Additional Information and Add-ons** 01371 * 01372 * @li <a href="http://tmrh20.github.io/RF24Network"> <b>RF24Network:</b> OSI Network Layer for multi-device communication. Create a home sensor network.</a> 01373 * @li <a href="http://tmrh20.github.io/RF24Mesh"> <b>RF24Mesh:</b> Dynamic Mesh Layer for RF24Network</a> 01374 * @li <a href="http://tmrh20.github.io/RF24Ethernet"> <b>RF24Ethernet:</b> TCP/IP Radio Mesh Networking (shares Arduino Ethernet API)</a> 01375 * @li <a href="http://tmrh20.github.io/RF24Audio"> <b>RF24Audio:</b> Realtime Wireless Audio streaming</a> 01376 * @li <a href="http://tmrh20.github.io/">All TMRh20 Documentation Main Page</a> 01377 * 01378 * **More Information and RF24 Based Projects** 01379 * 01380 * @li <a href="http://TMRh20.blogspot.com"> Project Blog: TMRh20.blogspot.com </a> 01381 * @li <a href="http://maniacalbits.blogspot.ca/"> Maniacal Bits Blog</a> 01382 * @li <a href="http://www.mysensors.org/">MySensors.org (User friendly sensor networks/IoT)</a> 01383 * @li <a href="https://github.com/mannkind/RF24Node_MsgProto"> RF24Node_MsgProto (MQTT)</a> 01384 * @li <a href="https://bitbucket.org/pjhardy/rf24sensornet/"> RF24SensorNet </a> 01385 * @li <a href="http://www.homeautomationforgeeks.com/rf24software.shtml">Home Automation for Geeks</a> 01386 * @li <a href="https://maniacbug.wordpress.com/2012/03/30/rf24network/"> Original Maniacbug RF24Network Blog Post</a> 01387 * @li <a href="https://github.com/maniacbug/RF24"> ManiacBug on GitHub (Original Library Author)</a> 01388 * 01389 * 01390 * <br> 01391 * 01392 * @section Platform_Support Platform Support Pages 01393 * 01394 * @li <a href="Arduino.html"><b>Arduino</b></a> (Uno, Nano, Mega, Due, Galileo, etc) 01395 * @li <a href="ATTiny.html"><b>ATTiny</b></a> 01396 * @li Linux ( <a href="RPi.html"><b>RPi</b></a> , <a href="BBB.html"><b>BBB</b></a>, <a href="MRAA.html"><b>MRAA</b></a> supported boards ( Galileo, Edison, etc)) 01397 * @li <a href="Python.html"><b>Python</b></a> wrapper available for RPi 01398 * 01399 * <br> 01400 * **General µC Pin layout** (See the individual board support pages for more info) 01401 * 01402 * The table below shows how to connect the the pins of the NRF24L01(+) to different boards. 01403 * CE and CSN are configurable. 01404 * 01405 * | PIN | NRF24L01 | Arduino UNO | ATtiny25/45/85 [0] | ATtiny44/84 [1] | LittleWire [2] | RPI | RPi -P1 Connector | 01406 * |-----|----------|-------------|--------------------|-----------------|-------------------------|------------|-------------------| 01407 * | 1 | GND | GND | pin 4 | pin 14 | GND | rpi-gnd | (25) | 01408 * | 2 | VCC | 3.3V | pin 8 | pin 1 | regulator 3.3V required | rpi-3v3 | (17) | 01409 * | 3 | CE | digIO 7 | pin 2 | pin 12 | pin to 3.3V | rpi-gpio22 | (15) | 01410 * | 4 | CSN | digIO 8 | pin 3 | pin 11 | RESET | rpi-gpio8 | (24) | 01411 * | 5 | SCK | digIO 13 | pin 7 | pin 9 | SCK | rpi-sckl | (23) | 01412 * | 6 | MOSI | digIO 11 | pin 6 | pin 7 | MOSI | rpi-mosi | (19) | 01413 * | 7 | MISO | digIO 12 | pin 5 | pin 8 | MISO | rpi-miso | (21) | 01414 * | 8 | IRQ | - | - | - | - | - | - | 01415 * 01416 * @li [0] https://learn.sparkfun.com/tutorials/tiny-avr-programmer-hookup-guide/attiny85-use-hints 01417 * @li [1] http://highlowtech.org/?p=1695 01418 * @li [2] http://littlewire.cc/ 01419 * <br><br><br> 01420 * 01421 * 01422 * 01423 * 01424 * @page Arduino Arduino 01425 * 01426 * RF24 is fully compatible with Arduino boards <br> 01427 * See <b> http://www.arduino.cc/en/Reference/Board </b> and <b> http://arduino.cc/en/Reference/SPI </b> for more information 01428 * 01429 * RF24 makes use of the standard hardware SPI pins (MISO,MOSI,SCK) and requires two additional pins, to control 01430 * the chip-select and chip-enable functions.<br> 01431 * These pins must be chosen and designated by the user, in RF24 radio(ce_pin,cs_pin); and can use any 01432 * available pins. 01433 * 01434 * <br> 01435 * @section ARD_DUE Arduino Due 01436 * 01437 * RF24 makes use of the extended SPI functionality available on the Arduino Due, and requires one of the 01438 * defined hardware SS/CS pins to be designated in RF24 radio(ce_pin,cs_pin);<br> 01439 * See http://arduino.cc/en/Reference/DueExtendedSPI for more information 01440 * 01441 * Initial Due support taken from https://github.com/mcrosson/RF24/tree/due 01442 * 01443 * <br> 01444 * @section Alternate_SPI Alternate SPI Support 01445 * 01446 * RF24 supports alternate SPI methods, in case the standard hardware SPI pins are otherwise unavailable. 01447 * 01448 * <br> 01449 * **Software Driven SPI** 01450 * 01451 * Software driven SPI is provided by the <a href=https://github.com/greiman/DigitalIO>DigitalIO</a> library 01452 * 01453 * Setup:<br> 01454 * 1. Install the digitalIO library<br> 01455 * 2. Open RF24_config.h in a text editor. Uncomment the line #define SOFTSPI<br> 01456 * 3. In your sketch, add #include DigitalIO.h 01457 * 01458 * @note Note: Pins are listed as follows and can be modified by editing the RF24_config.h file<br> 01459 * 01460 * const uint8_t SOFT_SPI_MISO_PIN = 16; 01461 * const uint8_t SOFT_SPI_MOSI_PIN = 15; 01462 * const uint8_t SOFT_SPI_SCK_PIN = 14; 01463 * 01464 * <br> 01465 * **Alternate Hardware (UART) Driven SPI** 01466 * 01467 * The Serial Port (UART) on Arduino can also function in SPI mode, and can double-buffer data, while the 01468 * default SPI hardware cannot. 01469 * 01470 * The SPI_UART library is available at https://github.com/TMRh20/Sketches/tree/master/SPI_UART 01471 * 01472 * Enabling: 01473 * 1. Install the SPI_UART library 01474 * 2. Edit RF24_config.h and uncomment #define SPI_UART 01475 * 3. In your sketch, add @code #include <SPI_UART.h> @endcode 01476 * 01477 * SPI_UART SPI Pin Connections: 01478 * | NRF |Arduino Uno Pin| 01479 * |-----|---------------| 01480 * | MOSI| TX(0) | 01481 * | MISO| RX(1) | 01482 * | SCK | XCK(4) | 01483 * | CE | User Specified| 01484 * | CSN | User Specified| 01485 * 01486 * 01487 * @note SPI_UART on Mega boards requires soldering to an unused pin on the chip. <br>See 01488 * https://github.com/TMRh20/RF24/issues/24 for more information on SPI_UART. 01489 * 01490 * @page ATTiny ATTiny 01491 * 01492 * ATTiny support is built into the library, so users are not required to include SPI.h in their sketches<br> 01493 * See the included rf24ping85 example for pin info and usage 01494 * 01495 * Some versions of Arduino IDE may require a patch to allow use of the full program space on ATTiny<br> 01496 * See https://github.com/TCWORLD/ATTinyCore/tree/master/PCREL%20Patch%20for%20GCC for ATTiny patch 01497 * 01498 * ATTiny board support initially added from https://github.com/jscrane/RF24 01499 * 01500 * @section Hardware Hardware Configuration 01501 * By tong67 ( https://github.com/tong67 ) 01502 * 01503 * **ATtiny25/45/85 Pin map with CE_PIN 3 and CSN_PIN 4** 01504 * @code 01505 * +-\/-+ 01506 * NC PB5 1|o |8 Vcc --- nRF24L01 VCC, pin2 --- LED --- 5V 01507 * nRF24L01 CE, pin3 --- PB3 2| |7 PB2 --- nRF24L01 SCK, pin5 01508 * nRF24L01 CSN, pin4 --- PB4 3| |6 PB1 --- nRF24L01 MOSI, pin6 01509 * nRF24L01 GND, pin1 --- GND 4| |5 PB0 --- nRF24L01 MISO, pin7 01510 * +----+ 01511 * @endcode 01512 * 01513 * <br> 01514 * **ATtiny25/45/85 Pin map with CE_PIN 3 and CSN_PIN 3** => PB3 and PB4 are free to use for application <br> 01515 * Circuit idea from http://nerdralph.blogspot.ca/2014/01/nrf24l01-control-with-3-attiny85-pins.html <br> 01516 * Original RC combination was 1K/100nF. 22K/10nF combination worked better. <br> 01517 * For best settletime delay value in RF24::csn() the timingSearch3pin.ino sketch can be used. <br> 01518 * This configuration is enabled when CE_PIN and CSN_PIN are equal, e.g. both 3 <br> 01519 * Because CE is always high the power consumption is higher than for 5 pins solution <br> 01520 * @code 01521 * ^^ 01522 * +-\/-+ nRF24L01 CE, pin3 ------| // 01523 * PB5 1|o |8 Vcc --- nRF24L01 VCC, pin2 ------x----------x--|<|-- 5V 01524 * NC PB3 2| |7 PB2 --- nRF24L01 SCK, pin5 --|<|---x-[22k]--| LED 01525 * NC PB4 3| |6 PB1 --- nRF24L01 MOSI, pin6 1n4148 | 01526 * nRF24L01 GND, pin1 -x- GND 4| |5 PB0 --- nRF24L01 MISO, pin7 | 01527 * | +----+ | 01528 * |-----------------------------------------------||----x-- nRF24L01 CSN, pin4 01529 * 10nF 01530 * @endcode 01531 * 01532 * <br> 01533 * **ATtiny24/44/84 Pin map with CE_PIN 8 and CSN_PIN 7** <br> 01534 * Schematic provided and successfully tested by Carmine Pastore (https://github.com/Carminepz) <br> 01535 * @code 01536 * +-\/-+ 01537 * nRF24L01 VCC, pin2 --- VCC 1|o |14 GND --- nRF24L01 GND, pin1 01538 * PB0 2| |13 AREF 01539 * PB1 3| |12 PA1 01540 * PB3 4| |11 PA2 --- nRF24L01 CE, pin3 01541 * PB2 5| |10 PA3 --- nRF24L01 CSN, pin4 01542 * PA7 6| |9 PA4 --- nRF24L01 SCK, pin5 01543 * nRF24L01 MISO, pin7 --- PA6 7| |8 PA5 --- nRF24L01 MOSI, pin6 01544 * +----+ 01545 * @endcode 01546 * 01547 * <br> 01548 * **ATtiny2313/4313 Pin map with CE_PIN 12 and CSN_PIN 13** <br> 01549 * @code 01550 * +-\/-+ 01551 * PA2 1|o |20 VCC --- nRF24L01 VCC, pin2 01552 * PD0 2| |19 PB7 --- nRF24L01 SCK, pin5 01553 * PD1 3| |18 PB6 --- nRF24L01 MOSI, pin6 01554 * PA1 4| |17 PB5 --- nRF24L01 MISO, pin7 01555 * PA0 5| |16 PB4 --- nRF24L01 CSN, pin4 01556 * PD2 6| |15 PB3 --- nRF24L01 CE, pin3 01557 * PD3 7| |14 PB2 01558 * PD4 8| |13 PB1 01559 * PD5 9| |12 PB0 01560 * nRF24L01 GND, pin1 --- GND 10| |11 PD6 01561 * +----+ 01562 * @endcode 01563 * 01564 * <br><br><br> 01565 * 01566 * 01567 * 01568 * 01569 * 01570 * 01571 * @page BBB BeagleBone Black 01572 * 01573 * BeagleBone Black is supported via MRAA or SPIDEV. 01574 * 01575 * @note The SPIDEV option should work with most Linux systems supporting SPIDEV. <br> 01576 * Users may need to edit the RF24/utility/BBB/spi.cpp file to configure the spi device. (Defaults: "/dev/spidev1.0"; or "/dev/spidev1.1"; ) 01577 * 01578 * <br> 01579 * @section AutoInstall Automated Install 01580 *(**Designed & Tested on RPi** - Defaults to SPIDEV on BBB) 01581 * 01582 * 01583 * 1. Download the install.sh file from http://tmrh20.github.io/RF24Installer/RPi/install.sh 01584 * @code wget http://tmrh20.github.io/RF24Installer/RPi/install.sh @endcode 01585 * 2. Make it executable: 01586 * @code chmod +x install.sh @endcode 01587 * 3. Run it and choose your options 01588 * @code ./install.sh @endcode 01589 * 4. Run an example from one of the libraries 01590 * @code 01591 * cd rf24libs/RF24/examples_RPi 01592 * @endcode 01593 * Edit the gettingstarted example, to set your pin configuration 01594 * @code nano gettingstarted.cpp 01595 * make 01596 * sudo ./gettingstarted 01597 * @endcode 01598 * 01599 * <br> 01600 * @section ManInstall Manual Install 01601 * 1. Make a directory to contain the RF24 and possibly RF24Network lib and enter it: 01602 * @code 01603 * mkdir ~/rf24libs 01604 * cd ~/rf24libs 01605 * @endcode 01606 * 2. Clone the RF24 repo: 01607 * @code git clone https://github.com/tmrh20/RF24.git RF24 @endcode 01608 * 3. Change to the new RF24 directory 01609 * @code cd RF24 @endcode 01610 * 4. Build the library, and run an example file: 01611 * **Note:** See the <a href="http://iotdk.intel.com/docs/master/mraa/index.html">MRAA </a> documentation for more info on installing MRAA 01612 * @code sudo make install OR sudo make install RF24_MRAA=1 @endcode 01613 * @code 01614 * cd examples_RPi 01615 * @endcode 01616 * Edit the gettingstarted example, to set your pin configuration 01617 * @code nano gettingstarted.cpp 01618 * make 01619 * sudo ./gettingstarted 01620 * @endcode 01621 * 01622 * <br><br> 01623 * 01624 * @page MRAA MRAA 01625 * 01626 * MRAA is a Low Level Skeleton Library for Communication on GNU/Linux platforms <br> 01627 * See http://iotdk.intel.com/docs/master/mraa/index.html for more information 01628 * 01629 * RF24 supports all MRAA supported platforms, but might not be tested on each individual platform due to the wide range of hardware support:<br> 01630 * <a href="https://github.com/TMRh20/RF24/issues">Report an RF24 bug or issue </a> 01631 * 01632 * @section Setup Setup 01633 * 1. Install the MRAA lib 01634 * 2. As per your device, SPI may need to be enabled 01635 * 01636 * @section MRAA_Install Install 01637 * 01638 * 1. Make a directory to contain the RF24 and possibly RF24Network lib and enter it: 01639 * @code 01640 * mkdir ~/rf24libs 01641 * cd ~/rf24libs 01642 * @endcode 01643 * 2. Clone the RF24 repo: 01644 * @code git clone https://github.com/tmrh20/RF24.git RF24 @endcode 01645 * 3. Change to the new RF24 directory 01646 * @code cd RF24 @endcode 01647 * 4. Build the library: 01648 * @code sudo make install -B RF24_MRAA=1 @endcode 01649 * 5. Configure the correct pins in gettingstarted.cpp (See http://iotdk.intel.com/docs/master/mraa/index.html ) 01650 * @code 01651 * cd examples_RPi 01652 * nano gettingstarted.cpp 01653 * @endcode 01654 * 6. Build an example 01655 * @code 01656 * make 01657 * sudo ./gettingstarted 01658 * @endcode 01659 * 01660 * <br><br><br> 01661 * 01662 * 01663 * 01664 * 01665 * @page RPi Raspberry Pi 01666 * 01667 * RF24 supports a variety of Linux based devices via various drivers. Some boards like RPi can utilize multiple methods 01668 * to drive the GPIO and SPI functionality. 01669 * 01670 * <br> 01671 * @section PreConfig Potential PreConfiguration 01672 * 01673 * If SPI is not already enabled, load it on boot: 01674 * @code sudo raspi-config @endcode 01675 * A. Update the tool via the menu as required<br> 01676 * B. Select **Advanced** and **enable the SPI kernel module** <br> 01677 * C. Update other software and libraries: 01678 * @code sudo apt-get update @endcode 01679 * @code sudo apt-get upgrade @endcode 01680 * <br> 01681 * @section AutoInstall Automated Install 01682 * 01683 * 1. Download the install.sh file from http://tmrh20.github.io/RF24Installer/RPi/install.sh 01684 * @code wget http://tmrh20.github.io/RF24Installer/RPi/install.sh @endcode 01685 * 2. Make it executable: 01686 * @code chmod +x install.sh @endcode 01687 * 3. Run it and choose your options 01688 * @code ./install.sh @endcode 01689 * 4. Run an example from one of the libraries 01690 * @code 01691 * cd rf24libs/RF24/examples_RPi 01692 * make 01693 * sudo ./gettingstarted 01694 * @endcode 01695 * <br><br> 01696 * @section ManInstall Manual Install 01697 * 1. Make a directory to contain the RF24 and possibly RF24Network lib and enter it: 01698 * @code 01699 * mkdir ~/rf24libs 01700 * cd ~/rf24libs 01701 * @endcode 01702 * 2. Clone the RF24 repo: 01703 * @code git clone https://github.com/tmrh20/RF24.git RF24 @endcode 01704 * 3. Change to the new RF24 directory 01705 * @code cd RF24 @endcode 01706 * 4. Build the library, and run an example file: 01707 * @code sudo make install 01708 * cd examples_RPi 01709 * make 01710 * sudo ./gettingstarted 01711 * @endcode 01712 * 01713 * <br><br> 01714 * @section Build Build Options 01715 * The default build on Raspberry Pi utilizes the included **BCM2835** driver from http://www.airspayce.com/mikem/bcm2835 01716 * 1. @code sudo make install -B @endcode 01717 * 01718 * Build using the **MRAA** library from http://iotdk.intel.com/docs/master/mraa/index.html <br> 01719 * MRAA is not included. See the <a href="MRAA.html">MRAA</a> platform page for more information. 01720 * 01721 * 1. Install, and build MRAA: 01722 * @code 01723 * git clone https://github.com/intel-iot-devkit/mraa.git 01724 * cd mraa 01725 * mkdir build 01726 * cd build 01727 * cmake .. -DBUILDSWIGNODE=OFF 01728 * sudo make install 01729 * @endcode 01730 * 01731 * 2. Complete the install <br> 01732 * @code nano /etc/ld.so.conf @endcode 01733 * Add the line @code /usr/local/lib/arm-linux-gnueabihf @endcode 01734 * Run @code sudo ldconfig @endcode 01735 * 01736 * 3. Install RF24, using MRAA 01737 * @code sudo make install -B RF24_MRAA=1 @endcode 01738 * See the gettingstarted example for an example of pin configuration 01739 * 01740 * Build using **spidev**: 01741 * 01742 * 1. Edit the RF24/utility/BBB/spi.cpp file 01743 * 2. Change the default device definition to @code this->device = "/dev/spidev0.0";; @endcode 01744 * 3. Run @code sudo make install -B RF24_SPIDEV=1 @endcode 01745 * 4. See the gettingstarted example for an example of pin configuration 01746 * 01747 * <br> 01748 * @section Pins Connections and Pin Configuration 01749 * 01750 * 01751 * Using pin 15/GPIO 22 for CE, pin 24/GPIO8 (CE0) for CSN 01752 * 01753 * Can use either RPi CE0 or CE1 pins for radio CSN.<br> 01754 * Choose any RPi output pin for radio CE pin. 01755 * 01756 * **BCM2835 Constructor:** 01757 * @code 01758 * RF24 radio(RPI_V2_GPIO_P1_15,BCM2835_SPI_CS0, BCM2835_SPI_SPEED_8MHZ); 01759 * or 01760 * RF24 radio(RPI_V2_GPIO_P1_15,BCM2835_SPI_CS1, BCM2835_SPI_SPEED_8MHZ); 01761 * 01762 * RPi B+: 01763 * RF24 radio(RPI_BPLUS_GPIO_J8_15,RPI_BPLUS_GPIO_J8_24, BCM2835_SPI_SPEED_8MHZ); 01764 * or 01765 * RF24 radio(RPI_BPLUS_GPIO_J8_15,RPI_BPLUS_GPIO_J8_26, BCM2835_SPI_SPEED_8MHZ); 01766 * 01767 * General: 01768 * RF24 radio(22,0); 01769 * or 01770 * RF24 radio(22,1); 01771 * 01772 * @endcode 01773 * See the gettingstarted example for an example of pin configuration 01774 * 01775 * See http://www.airspayce.com/mikem/bcm2835/index.html for BCM2835 class documentation. 01776 * <br><br> 01777 * **MRAA Constructor:** 01778 * 01779 * @code RF24 radio(15,0); @endcode 01780 * 01781 * See http://iotdk.intel.com/docs/master/mraa/rasppi.html 01782 * <br><br> 01783 * **SPI_DEV Constructor** 01784 * 01785 * @code RF24 radio(22,0); @endcode 01786 * 01787 * See http://pi.gadgetoid.com/pinout 01788 * 01789 * **Pins:** 01790 * 01791 * | PIN | NRF24L01 | RPI | RPi -P1 Connector | 01792 * |-----|----------|------------|-------------------| 01793 * | 1 | GND | rpi-gnd | (25) | 01794 * | 2 | VCC | rpi-3v3 | (17) | 01795 * | 3 | CE | rpi-gpio22 | (15) | 01796 * | 4 | CSN | rpi-gpio8 | (24) | 01797 * | 5 | SCK | rpi-sckl | (23) | 01798 * | 6 | MOSI | rpi-mosi | (19) | 01799 * | 7 | MISO | rpi-miso | (21) | 01800 * | 8 | IRQ | - | - | 01801 * 01802 * 01803 * 01804 * 01805 * <br><br> 01806 **************** 01807 * 01808 * Based on the arduino lib from J. Coliz <maniacbug@ymail.com> <br> 01809 * the library was berryfied by Purinda Gunasekara <purinda@gmail.com> <br> 01810 * then forked from github stanleyseow/RF24 to https://github.com/jscrane/RF24-rpi <br> 01811 * Network lib also based on https://github.com/farconada/RF24Network 01812 * 01813 * 01814 * 01815 * 01816 * <br><br><br> 01817 * 01818 * 01819 * 01820 * @page Python Python Wrapper (by https://github.com/mz-fuzzy) 01821 * 01822 * @section Install Installation: 01823 * 01824 * Install the boost libraries: (Note: Only the python libraries should be needed, this is just for simplicity) 01825 * 01826 * @code sudo apt-get install libboost1.50-all @endcode 01827 * 01828 * Build the library: 01829 * 01830 * @code ./setup.py build @endcode 01831 * 01832 * Install the library 01833 * 01834 * @code sudo ./setup.py install @endcode 01835 * 01836 * 01837 * See the additional <a href="pages.html">Platform Support</a> pages for information on connecting your hardware <br> 01838 * See the included <a href="pingpair_dyn_8py-example.html">example </a> for usage information. 01839 * 01840 * Running the Example: 01841 * 01842 * Edit the pingpair_dyn.py example to configure the appropriate pins per the above documentation: 01843 * 01844 * @code nano pingpair_dyn.py @endcode 01845 * 01846 * Configure another device, Arduino or RPi with the <a href="pingpair_dyn_8py-example.html">pingpair_dyn</a> example 01847 * 01848 * Run the example 01849 * 01850 * @code sudo ./pingpair_dyn.py @endcode 01851 * 01852 * <br><br><br> 01853 * 01854 * 01855 * @page Portability RF24 Portability 01856 * 01857 * The RF24 radio driver mainly utilizes the <a href="http://arduino.cc/en/reference/homePage">Arduino API</a> for GPIO, SPI, and timing functions, which are easily replicated 01858 * on various platforms. <br>Support files for these platforms are stored under RF24/utility, and can be modified to provide 01859 * the required functionality. 01860 * 01861 * <br> 01862 * @section Hardware_Templates Basic Hardware Template 01863 * 01864 * **RF24/utility** 01865 * 01866 * The RF24 library now includes a basic hardware template to assist in porting to various platforms. <br> The following files can be included 01867 * to replicate standard Arduino functions as needed, allowing devices from ATTiny to Raspberry Pi to utilize the same core RF24 driver. 01868 * 01869 * | File | Purpose | 01870 * |--------------------|------------------------------------------------------------------------------| 01871 * | RF24_arch_config.h | Basic Arduino/AVR compatibility, includes for remaining support files, etc | 01872 * | includes.h | Linux only. Defines specific platform, include correct RF24_arch_config file | 01873 * | spi.h | Provides standardized SPI ( transfer() ) methods | 01874 * | gpio.h | Provides standardized GPIO ( digitalWrite() ) methods | 01875 * | compatibility.h | Provides standardized timing (millis(), delay()) methods | 01876 * | your_custom_file.h | Provides access to custom drivers for spi,gpio, etc | 01877 * 01878 * <br> 01879 * Examples are provided via the included hardware support templates in **RF24/utility** <br> 01880 * See the <a href="modules.html">modules</a> page for examples of class declarations 01881 * 01882 *<br> 01883 * @section Device_Detection Device Detection 01884 * 01885 * 1. The main detection for Linux devices is done in the Makefile, with the includes.h from the proper hardware directory copied to RF24/utility/includes.h <br> 01886 * 2. Secondary detection is completed in RF24_config.h, causing the include.h file to be included for all supported Linux devices <br> 01887 * 3. RF24.h contains the declaration for SPI and GPIO objects 'spi' and 'gpio' to be used for porting-in related functions. 01888 * 01889 * <br> 01890 * @section Ported_Code Code 01891 * To have your ported code included in this library, or for assistance in porting, create a pull request or open an issue at https://github.com/TMRh20/RF24 01892 * 01893 * 01894 *<br><br><br> 01895 */ 01896 01897 #endif // __RF24_H__ 01898
Generated on Tue Jul 12 2022 18:10:10 by
1.7.2