MySmartHome/MySensors
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #429 from tekka007/RF24_updates

Browse Source 
RF24 driver update
This commit is contained in:
Olivier
2016-05-06 21:57:59 +02:00
parent 0c8acb0bcf 85153680dd
commit 460ae09811
4 changed files with 153 additions and 150 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/MySensors/MySensor.h
+1 -2
View File
@@ -240,8 +240,7 @@
#if defined(ARDUINO_ARCH_ESP8266) #if defined(ARDUINO_ARCH_ESP8266)
#error Soft SPI is not available on ESP8266 #error Soft SPI is not available on ESP8266
#endif #endif
#include "drivers/AVR/DigitalIO/SoftI2cMaster.cpp" #include "drivers/AVR/DigitalIO/DigitalIO.h"
#include "drivers/AVR/DigitalIO/PinIO.cpp"
#endif #endif
// FLASH // FLASH
libraries/MySensors/core/MyTransportNRF24.cpp
+9 -9
View File
@@ -41,16 +41,16 @@ bool transportInit() {
memset(_psk, 0, 16); memset(_psk, 0, 16);
#endif #endif
return initializeRF24(); return RF24_initialize();
} }
void transportSetAddress(uint8_t address) { void transportSetAddress(uint8_t address) {
setNodeAddress(address); RF24_setNodeAddress(address);
startListening(); RF24_startListening();
} }
uint8_t transportGetAddress() { uint8_t transportGetAddress() {
return getNodeID(); return RF24_getNodeID();
} }
bool transportSend(uint8_t recipient, const void* data, uint8_t len) { bool transportSend(uint8_t recipient, const void* data, uint8_t len) {
@@ -62,21 +62,21 @@ bool transportSend(uint8_t recipient, const void* data, uint8_t len) {
len = len > 16 ? 32 : 16; len = len > 16 ? 32 : 16;
//encrypt data //encrypt data
_aes.cbc_encrypt(_dataenc, _dataenc, len/16); _aes.cbc_encrypt(_dataenc, _dataenc, len/16);
bool status = sendMessage( recipient, _dataenc, len ); bool status = RF24_sendMessage( recipient, _dataenc, len );
#else #else
bool status = sendMessage( recipient, data, len ); bool status = RF24_sendMessage( recipient, data, len );
#endif #endif
return status; return status;
} }
bool transportAvailable(uint8_t *to) { bool transportAvailable(uint8_t *to) {
bool avail = IsDataAvailable(to); bool avail = RF24_isDataAvailable(to);
return avail; return avail;
} }
uint8_t transportReceive(void* data) { uint8_t transportReceive(void* data) {
uint8_t len = readMessage(data); uint8_t len = RF24_readMessage(data);
#if defined(MY_RF24_ENABLE_ENCRYPTION) #if defined(MY_RF24_ENABLE_ENCRYPTION)
// has to be adjusted, WIP! // has to be adjusted, WIP!
_aes.set_IV(0); _aes.set_IV(0);
@@ -87,5 +87,5 @@ uint8_t transportReceive(void* data) {
} }
void transportPowerDown() { void transportPowerDown() {
powerDown(); RF24_powerDown();
} }
libraries/MySensors/drivers/RF24/RF24.cpp
+85 -87
View File
@@ -22,23 +22,23 @@
#include "RF24.h" #include "RF24.h"
uint8_t MY_RF24_BASE_ADDR[MY_RF24_ADDR_WIDTH] = { MY_RF24_BASE_RADIO_ID }; LOCAL uint8_t MY_RF24_BASE_ADDR[MY_RF24_ADDR_WIDTH] = { MY_RF24_BASE_RADIO_ID };
uint8_t MY_RF24_NODE_ADDRESS = AUTO; LOCAL uint8_t MY_RF24_NODE_ADDRESS = AUTO;
void csn(bool level) { LOCAL void RF24_csn(bool level) {
digitalWrite(MY_RF24_CS_PIN, level); digitalWrite(MY_RF24_CS_PIN, level);
} }
void ce(bool level) { LOCAL void RF24_ce(bool level) {
digitalWrite(MY_RF24_CE_PIN, level); digitalWrite(MY_RF24_CE_PIN, level);
} }
uint8_t spiMultiByteTransfer(uint8_t cmd, uint8_t* buf, uint8_t len, bool aReadMode) { LOCAL uint8_t RF24_spiMultiByteTransfer(uint8_t cmd, uint8_t* buf, uint8_t len, bool aReadMode) {
uint8_t* current = buf; uint8_t* current = buf;
#if !defined(MY_SOFTSPI) #if !defined(MY_SOFTSPI)
_SPI.beginTransaction(SPISettings(MY_RF24_SPI_MAX_SPEED, MY_RF24_SPI_DATA_ORDER, MY_RF24_SPI_DATA_MODE)); _SPI.beginTransaction(SPISettings(MY_RF24_SPI_MAX_SPEED, MY_RF24_SPI_DATA_ORDER, MY_RF24_SPI_DATA_MODE));
#endif #endif
csn(LOW); RF24_csn(LOW);
// timing // timing
delayMicroseconds(10); delayMicroseconds(10);
uint8_t status = _SPI.transfer( cmd ); uint8_t status = _SPI.transfer( cmd );
@@ -48,7 +48,7 @@ uint8_t spiMultiByteTransfer(uint8_t cmd, uint8_t* buf, uint8_t len, bool aReadM
if(buf != NULL) *current++ = status; if(buf != NULL) *current++ = status;
} else status = _SPI.transfer(*current++); } else status = _SPI.transfer(*current++);
} }
csn(HIGH); RF24_csn(HIGH);
#if !defined(MY_SOFTSPI) #if !defined(MY_SOFTSPI)
_SPI.endTransaction(); _SPI.endTransaction();
#endif #endif
@@ -57,120 +57,116 @@ uint8_t spiMultiByteTransfer(uint8_t cmd, uint8_t* buf, uint8_t len, bool aReadM
return status; return status;
} }
uint8_t spiByteTransfer(uint8_t cmd) { LOCAL uint8_t RF24_spiByteTransfer(uint8_t cmd) {
return spiMultiByteTransfer( cmd, NULL, 0, false); return RF24_spiMultiByteTransfer( cmd, NULL, 0, false);
} }
uint8_t _readByteRegister(uint8_t cmd) { LOCAL uint8_t RF24_RAW_readByteRegister(uint8_t cmd) {
uint8_t value = spiMultiByteTransfer( cmd, NULL, 1, true); uint8_t value = RF24_spiMultiByteTransfer( cmd, NULL, 1, true);
RF24_DEBUG(PSTR("read register, reg=%d, value=%d\n"), cmd & (R_REGISTER ^ 0xFF), value); RF24_DEBUG(PSTR("read register, reg=%d, value=%d\n"), cmd & (R_REGISTER ^ 0xFF), value);
return value; return value;
} }
uint8_t _writeByteRegister(uint8_t cmd, uint8_t value) { LOCAL uint8_t RF24_RAW_writeByteRegister(uint8_t cmd, uint8_t value) {
RF24_DEBUG(PSTR("write register, reg=%d, value=%d\n"), cmd & (W_REGISTER ^ 0xFF), value); RF24_DEBUG(PSTR("write register, reg=%d, value=%d\n"), cmd & (W_REGISTER ^ 0xFF), value);
return spiMultiByteTransfer( cmd , &value, 1, false); return RF24_spiMultiByteTransfer( cmd , &value, 1, false);
} }
#define readByteRegister(reg) _readByteRegister( R_REGISTER | ( REGISTER_MASK & (reg) ) ) LOCAL void RF24_flushRX(void) {
#define writeByteRegister(reg, value) _writeByteRegister( W_REGISTER | ( REGISTER_MASK & (reg) ), value ) RF24_DEBUG(PSTR("RF24_flushRX\n"));
#define writeMultiByteRegister(reg, buf, len) spiMultiByteTransfer( W_REGISTER | ( REGISTER_MASK & (reg) ), (uint8_t*)buf, len, false ) RF24_spiByteTransfer( FLUSH_RX );
void flushRX(void) {
RF24_DEBUG(PSTR("flushRX\n"));
spiByteTransfer( FLUSH_RX );
} }
void flushTX(void) { LOCAL void RF24_flushTX(void) {
RF24_DEBUG(PSTR("flushTX\n")); RF24_DEBUG(PSTR("RF24_flushTX\n"));
spiByteTransfer( FLUSH_TX ); RF24_spiByteTransfer( FLUSH_TX );
} }
uint8_t getStatus(void) { LOCAL uint8_t RF24_getStatus(void) {
return spiByteTransfer( NOP ); return RF24_spiByteTransfer( NOP );
} }
void openWritingPipe(uint8_t recipient) { LOCAL void RF24_openWritingPipe(uint8_t recipient) {
RF24_DEBUG(PSTR("open writing pipe, recipient=%d\n"), recipient); RF24_DEBUG(PSTR("open writing pipe, recipient=%d\n"), recipient);
// only write LSB of RX0 and TX pipe // only write LSB of RX0 and TX pipe
writeByteRegister(RX_ADDR_P0, recipient); RF24_writeByteRegister(RX_ADDR_P0, recipient);
writeByteRegister(TX_ADDR, recipient); RF24_writeByteRegister(TX_ADDR, recipient);
} }
void startListening(void) { LOCAL void RF24_startListening(void) {
RF24_DEBUG(PSTR("start listening\n")); RF24_DEBUG(PSTR("start listening\n"));
// toggle PRX // toggle PRX
writeByteRegister(NRF_CONFIG, MY_RF24_CONFIGURATION | _BV(PWR_UP) | _BV(PRIM_RX) ); RF24_writeByteRegister(NRF_CONFIG, MY_RF24_CONFIGURATION | _BV(PWR_UP) | _BV(PRIM_RX) );
// all RX pipe addresses must be unique, therefore skip if node ID is 0xFF // all RX pipe addresses must be unique, therefore skip if node ID is 0xFF
if(MY_RF24_NODE_ADDRESS!=AUTO) writeByteRegister(RX_ADDR_P0, MY_RF24_NODE_ADDRESS); if(MY_RF24_NODE_ADDRESS!=AUTO) RF24_writeByteRegister(RX_ADDR_P0, MY_RF24_NODE_ADDRESS);
// start listening // start listening
ce(HIGH); RF24_ce(HIGH);
} }
void stopListening(void) { LOCAL void RF24_stopListening(void) {
RF24_DEBUG(PSTR("stop listening\n")); RF24_DEBUG(PSTR("stop listening\n"));
ce(LOW); RF24_ce(LOW);
// timing // timing
delayMicroseconds(130); delayMicroseconds(130);
writeByteRegister(NRF_CONFIG, MY_RF24_CONFIGURATION | _BV(PWR_UP) ); RF24_writeByteRegister(NRF_CONFIG, MY_RF24_CONFIGURATION | _BV(PWR_UP) );
// timing // timing
delayMicroseconds(100); delayMicroseconds(100);
} }
void powerDown(void) { LOCAL void RF24_powerDown(void) {
ce(LOW); RF24_ce(LOW);
writeByteRegister(NRF_CONFIG, 0x00); RF24_writeByteRegister(NRF_CONFIG, 0x00);
RF24_DEBUG(PSTR("power down\n")); RF24_DEBUG(PSTR("power down\n"));
} }
bool sendMessage( uint8_t recipient, const void* buf, uint8_t len ) { LOCAL bool RF24_sendMessage( uint8_t recipient, const void* buf, uint8_t len ) {
uint8_t status; uint8_t status;
stopListening(); RF24_stopListening();
openWritingPipe( recipient ); RF24_openWritingPipe( recipient );
RF24_DEBUG(PSTR("send message to %d, len=%d\n"),recipient,len); RF24_DEBUG(PSTR("send message to %d, len=%d\n"),recipient,len);
// flush TX FIFO // flush TX FIFO
flushTX(); RF24_flushTX();
// this command is affected in clones (e.g. Si24R1): flipped NoACK bit when using W_TX_PAYLOAD_NO_ACK / W_TX_PAYLOAD // this command is affected in clones (e.g. Si24R1): flipped NoACK bit when using W_TX_PAYLOAD_NO_ACK / W_TX_PAYLOAD
// spiMultiByteTransfer( recipient==BROADCAST_ADDRESS ? W_TX_PAYLOAD_NO_ACK : W_TX_PAYLOAD, (uint8_t*)buf, len, false ); // RF24_spiMultiByteTransfer( recipient==BROADCAST_ADDRESS ? W_TX_PAYLOAD_NO_ACK : W_TX_PAYLOAD, (uint8_t*)buf, len, false );
// we are safe by disabling AutoACK on the broadcasting pipe // we are safe by disabling AutoACK on the broadcasting pipe
spiMultiByteTransfer( W_TX_PAYLOAD, (uint8_t*)buf, len, false ); RF24_spiMultiByteTransfer( W_TX_PAYLOAD, (uint8_t*)buf, len, false );
// go // go
ce(HIGH); RF24_ce(HIGH);
// TX starts after ~10us // TX starts after ~10us
do { do {
status = getStatus(); status = RF24_getStatus();
} while (!(status & ( _BV(MAX_RT) | _BV(TX_DS) ))); } while (!(status & ( _BV(MAX_RT) | _BV(TX_DS) )));
ce(LOW); RF24_ce(LOW);
// reset interrupts // reset interrupts
writeByteRegister(RF24_STATUS, _BV(TX_DS) | _BV(MAX_RT) ); RF24_writeByteRegister(RF24_STATUS, _BV(TX_DS) | _BV(MAX_RT) );
// Max retries exceeded // Max retries exceeded
if( status & _BV(MAX_RT)){ if( status & _BV(MAX_RT)){
// flush packet // flush packet
RF24_DEBUG(PSTR("MAX_RT\n")); RF24_DEBUG(PSTR("MAX_RT\n"));
flushTX(); RF24_flushTX();
} }
startListening(); RF24_startListening();
return (status & _BV(TX_DS)); return (status & _BV(TX_DS));
} }
uint8_t getDynamicPayloadSize(void) { LOCAL uint8_t RF24_getDynamicPayloadSize(void) {
uint8_t result = spiMultiByteTransfer(R_RX_PL_WID,NULL,1,true); uint8_t result = RF24_spiMultiByteTransfer(R_RX_PL_WID,NULL,1,true);
// check if payload size invalid // check if payload size invalid
if(result > 32) { if(result > 32) {
RF24_DEBUG(PSTR("invalid payload length = %d\n"),result); RF24_DEBUG(PSTR("invalid payload length = %d\n"),result);
flushRX(); RF24_flushRX();
result = 0; result = 0;
} }
return result; return result;
} }
bool IsDataAvailable(uint8_t* to) { LOCAL bool RF24_isDataAvailable(uint8_t* to) {
uint8_t pipe_num = ( getStatus() >> RX_P_NO ) & 0b0111; uint8_t pipe_num = ( RF24_getStatus() >> RX_P_NO ) & 0b0111;
#if defined(MY_DEBUG_VERBOSE_RF24) #if defined(MY_DEBUG_VERBOSE_RF24)
if(pipe_num <= 5) if(pipe_num <= 5)
RF24_DEBUG(PSTR("Data available on pipe %d\n"),pipe_num); RF24_DEBUG(PSTR("Data available on pipe %d\n"),pipe_num);
@@ -183,75 +179,77 @@ bool IsDataAvailable(uint8_t* to) {
} }
uint8_t readMessage( void* buf) { LOCAL uint8_t RF24_readMessage( void* buf) {
uint8_t len = getDynamicPayloadSize(); uint8_t len = RF24_getDynamicPayloadSize();
RF24_DEBUG(PSTR("read message, len=%d\n"), len); RF24_DEBUG(PSTR("read message, len=%d\n"), len);
spiMultiByteTransfer( R_RX_PAYLOAD , (uint8_t*)buf, len, true ); RF24_spiMultiByteTransfer( R_RX_PAYLOAD , (uint8_t*)buf, len, true );
// clear RX interrupt // clear RX interrupt
writeByteRegister(RF24_STATUS, _BV(RX_DR) ); RF24_writeByteRegister(RF24_STATUS, _BV(RX_DR) );
return len; return len;
} }
void setNodeAddress(uint8_t address) { LOCAL void RF24_setNodeAddress(uint8_t address) {
MY_RF24_NODE_ADDRESS = address; if(address!=AUTO){
// enable node pipe MY_RF24_NODE_ADDRESS = address;
writeByteRegister(EN_RXADDR, _BV(ERX_P0 + BROADCAST_PIPE) | _BV(ERX_P0) ); // enable node pipe
// enable autoACK on pipe 0 RF24_writeByteRegister(EN_RXADDR, _BV(ERX_P0 + BROADCAST_PIPE) | _BV(ERX_P0) );
writeByteRegister(EN_AA, _BV(ENAA_P0) ); // enable autoACK on pipe 0
RF24_writeByteRegister(EN_AA, _BV(ENAA_P0) );
}
} }
uint8_t getNodeID(void) { LOCAL uint8_t RF24_getNodeID(void) {
return MY_RF24_NODE_ADDRESS; return MY_RF24_NODE_ADDRESS;
} }
bool initializeRF24(void) { LOCAL bool RF24_initialize(void) {
// Initialize pins // Initialize pins
pinMode(MY_RF24_CE_PIN,OUTPUT); pinMode(MY_RF24_CE_PIN,OUTPUT);
pinMode(MY_RF24_CS_PIN,OUTPUT); pinMode(MY_RF24_CS_PIN,OUTPUT);
// Initialize SPI // Initialize SPI
_SPI.begin(); _SPI.begin();
ce(LOW); RF24_ce(LOW);
csn(HIGH); RF24_csn(HIGH);
// CRC and power up // CRC and power up
writeByteRegister(NRF_CONFIG, MY_RF24_CONFIGURATION | _BV(PWR_UP) ) ; RF24_writeByteRegister(NRF_CONFIG, MY_RF24_CONFIGURATION | _BV(PWR_UP) ) ;
// settle >2ms // settle >2ms
delay(5); delay(5);
// set address width // set address width
writeByteRegister(SETUP_AW, MY_RF24_ADDR_WIDTH - 2 ); RF24_writeByteRegister(SETUP_AW, MY_RF24_ADDR_WIDTH - 2 );
// auto retransmit delay 1500us, auto retransmit count 15 // auto retransmit delay 1500us, auto retransmit count 15
writeByteRegister(SETUP_RETR, RF24_ARD << ARD | RF24_ARC << ARC); RF24_writeByteRegister(SETUP_RETR, RF24_ARD << ARD | RF24_ARC << ARC);
// set channel // set channel
writeByteRegister(RF_CH, MY_RF24_CHANNEL); RF24_writeByteRegister(RF_CH, MY_RF24_CHANNEL);
// set data rate and pa level // set data rate and pa level
writeByteRegister(RF_SETUP, MY_RF24_RF_SETUP); RF24_writeByteRegister(RF_SETUP, MY_RF24_RF_SETUP);
// sanity check // sanity check
#if defined(MY_RF24_SANITY_CHECK) #if defined(MY_RF24_SANITY_CHECK)
if(readByteRegister(RF_SETUP)!=MY_RF24_RF_SETUP) { if(RF24_readByteRegister(RF_SETUP)!=MY_RF24_RF_SETUP) {
RF24_DEBUG(PSTR("Sanity check failed: RF_SETUP register=%d instead of %d, check wiring, replace module or non-P version\n"),readByteRegister(RF_SETUP), MY_RF24_RF_SETUP); RF24_DEBUG(PSTR("Sanity check failed: RF_SETUP register=%d instead of %d, check wiring, replace module or non-P version\n"),RF24_readByteRegister(RF_SETUP), MY_RF24_RF_SETUP);
return false; return false;
} }
#endif #endif
// toggle features (necessary on some clones) // toggle features (necessary on some clones)
writeByteRegister(ACTIVATE,0x73); RF24_writeByteRegister(ACTIVATE,0x73);
// enable ACK payload and dynamic payload // enable ACK payload and dynamic payload
writeByteRegister(FEATURE, MY_RF24_FEATURE ); RF24_writeByteRegister(FEATURE, MY_RF24_FEATURE );
// enable broadcasting pipe // enable broadcasting pipe
writeByteRegister(EN_RXADDR, _BV(ERX_P0 + BROADCAST_PIPE) ); RF24_writeByteRegister(EN_RXADDR, _BV(ERX_P0 + BROADCAST_PIPE) );
// disable AA on all pipes, activate when node pipe set // disable AA on all pipes, activate when node pipe set
writeByteRegister(EN_AA, 0x00 ); RF24_writeByteRegister(EN_AA, 0x00 );
// enable dynamic payloads on used pipes // enable dynamic payloads on used pipes
writeByteRegister(DYNPD, _BV(DPL_P0 + BROADCAST_PIPE) | _BV(DPL_P0)); RF24_writeByteRegister(DYNPD, _BV(DPL_P0 + BROADCAST_PIPE) | _BV(DPL_P0));
// listen to broadcast pipe // listen to broadcast pipe
MY_RF24_BASE_ADDR[0] = BROADCAST_ADDRESS; MY_RF24_BASE_ADDR[0] = BROADCAST_ADDRESS;
writeMultiByteRegister(RX_ADDR_P0 + BROADCAST_PIPE, (uint8_t*)&MY_RF24_BASE_ADDR, BROADCAST_PIPE > 1 ? 1 : MY_RF24_ADDR_WIDTH); RF24_writeMultiByteRegister(RX_ADDR_P0 + BROADCAST_PIPE, (uint8_t*)&MY_RF24_BASE_ADDR, BROADCAST_PIPE > 1 ? 1 : MY_RF24_ADDR_WIDTH);
// pipe 0, set full address, later only LSB is updated // pipe 0, set full address, later only LSB is updated
writeMultiByteRegister(RX_ADDR_P0, (uint8_t*)&MY_RF24_BASE_ADDR, MY_RF24_ADDR_WIDTH); RF24_writeMultiByteRegister(RX_ADDR_P0, (uint8_t*)&MY_RF24_BASE_ADDR, MY_RF24_ADDR_WIDTH);
writeMultiByteRegister(TX_ADDR, (uint8_t*)&MY_RF24_BASE_ADDR, MY_RF24_ADDR_WIDTH); RF24_writeMultiByteRegister(TX_ADDR, (uint8_t*)&MY_RF24_BASE_ADDR, MY_RF24_ADDR_WIDTH);
// reset FIFO // reset FIFO
flushRX(); RF24_flushRX();
flushTX(); RF24_flushTX();
// reset interrupts // reset interrupts
writeByteRegister(RF24_STATUS, _BV(TX_DS) | _BV(MAX_RT) | _BV(RX_DR)); RF24_writeByteRegister(RF24_STATUS, _BV(TX_DS) | _BV(MAX_RT) | _BV(RX_DR));
return true; return true;
} }
libraries/MySensors/drivers/RF24/RF24.h
+58 -52
View File
@@ -23,11 +23,7 @@
#ifndef __RF24_H__ #ifndef __RF24_H__
#define __RF24_H__ #define __RF24_H__
#include <Arduino.h> #define LOCAL static
#include <stddef.h>
#if defined SOFTSPI
#include <DigitalIO.h>
#endif
// SPI settings // SPI settings
#if !defined(MY_RF24_SPI_MAX_SPEED) #if !defined(MY_RF24_SPI_MAX_SPEED)
@@ -37,7 +33,35 @@
#define MY_RF24_SPI_DATA_ORDER MSBFIRST #define MY_RF24_SPI_DATA_ORDER MSBFIRST
#define MY_RF24_SPI_DATA_MODE SPI_MODE0 #define MY_RF24_SPI_DATA_MODE SPI_MODE0
// settings #if defined (ARDUINO) && !defined (__arm__) && !defined (_SPI)
#if defined(MY_SOFTSPI)
SoftSPI<MY_SOFT_SPI_MISO_PIN, MY_SOFT_SPI_MOSI_PIN, MY_SOFT_SPI_SCK_PIN, MY_RF24_SPI_DATA_MODE> _SPI;
#elif defined(ARDUINO_ARCH_SAMD)
#include <SPI.h>
#define _SPI SPI1
#else
#include <SPI.h>
#define _SPI SPI
#endif
#else
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#define _BV(x) (1<<(x))
#if defined(__arm__)
#include <SPI.h>
#else
extern HardwareSPI SPI;
#endif
#if !defined(_SPI)
#define _SPI SPI
#endif
#endif
// RF24 settings
#define MY_RF24_CONFIGURATION (uint8_t) (RF24_CRC_16 << 2) #define MY_RF24_CONFIGURATION (uint8_t) (RF24_CRC_16 << 2)
#define MY_RF24_FEATURE (uint8_t)( _BV(EN_DPL) | _BV(EN_ACK_PAY) ) #define MY_RF24_FEATURE (uint8_t)( _BV(EN_DPL) | _BV(EN_ACK_PAY) )
#define MY_RF24_RF_SETUP (uint8_t)( ((MY_RF24_DATARATE & 0b10 ) << 4) | ((MY_RF24_DATARATE & 0b01 ) << 3) | (MY_RF24_PA_LEVEL << 1) ) + 1 // +1 for Si24R1 #define MY_RF24_RF_SETUP (uint8_t)( ((MY_RF24_DATARATE & 0b10 ) << 4) | ((MY_RF24_DATARATE & 0b01 ) << 3) | (MY_RF24_PA_LEVEL << 1) ) + 1 // +1 for Si24R1
@@ -75,52 +99,6 @@
// ARD, auto retry count // ARD, auto retry count
#define RF24_ARC 15 #define RF24_ARC 15
#if defined (ARDUINO) && !defined (__arm__) && !defined (_SPI)
#if defined(SPI_UART)
#include <SPI_UART.h>
#define _SPI uspi
#elif defined(MY_SOFTSPI)
#include "drivers/AVR/DigitalIO/DigitalIO.h"
// change these pins to your liking
const uint8_t SOFT_SPI_MISO_PIN = MY_SOFT_SPI_MOSI_PIN;
const uint8_t SOFT_SPI_MOSI_PIN = MY_SOFT_SPI_MISO_PIN;
const uint8_t SOFT_SPI_SCK_PIN = MY_SOFT_SPI_SCK_PIN;
const uint8_t SPI_MODE = 0;
#define _SPI spi
#elif defined(ARDUINO_ARCH_SAMD)
#include <SPI.h>
#define _SPI SPI1
#else
#include <SPI.h>
#define _SPI SPI
#endif
#else
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#if defined(__arm__) || defined (CORE_TEENSY)
#include <SPI.h>
#endif
#if !defined(CORE_TEENSY)
#define _BV(x) (1<<(x))
#if !defined(__arm__)
extern HardwareSPI SPI;
#endif
#else
#define printf MY_SERIALDEVICE.printf
#endif
#if !defined(_SPI)
#define _SPI SPI
#endif
#endif
#if defined(MY_SOFTSPI)
SoftSPI<MY_SOFT_SPI_MISO_PIN, MY_SOFT_SPI_MOSI_PIN, MY_SOFT_SPI_SCK_PIN, SPI_MODE> spi;
#elif defined (SPI_UART)
SPIUARTClass uspi;
#endif
// nRF24L01(+) register definitions // nRF24L01(+) register definitions
#define NRF_CONFIG 0x00 #define NRF_CONFIG 0x00
#define EN_AA 0x01 #define EN_AA 0x01
@@ -228,6 +206,34 @@
#define RF_PWR_LOW 1 #define RF_PWR_LOW 1
#define RF_PWR_HIGH 2 #define RF_PWR_HIGH 2
// functions
LOCAL void RF24_csn(bool level);
LOCAL void RF24_ce(bool level);
LOCAL uint8_t RF24_spiMultiByteTransfer(uint8_t cmd, uint8_t* buf, uint8_t len, bool aReadMode);
LOCAL uint8_t RF24_spiByteTransfer(uint8_t cmd);
LOCAL uint8_t RF24_RAW_readByteRegister(uint8_t cmd);
LOCAL uint8_t RF24_RAW_writeByteRegister(uint8_t cmd, uint8_t value);
#define RF24_readByteRegister(reg) RF24_RAW_readByteRegister( R_REGISTER | ( REGISTER_MASK & (reg) ) )
#define RF24_writeByteRegister(reg, value) RF24_RAW_writeByteRegister( W_REGISTER | ( REGISTER_MASK & (reg) ), value )
#define RF24_writeMultiByteRegister(reg, buf, len) RF24_spiMultiByteTransfer( W_REGISTER | ( REGISTER_MASK & (reg) ), (uint8_t*)buf, len, false )
LOCAL void RF24_flushRX(void);
LOCAL void RF24_flushTX(void);
LOCAL uint8_t RF24_getStatus(void);
LOCAL void RF24_openWritingPipe(uint8_t recipient);
LOCAL void RF24_startListening(void);
LOCAL void RF24_stopListening(void);
LOCAL void RF24_powerDown(void);
LOCAL bool RF24_sendMessage(uint8_t recipient, const void* buf, uint8_t len);
LOCAL uint8_t RF24_getDynamicPayloadSize(void);
LOCAL bool RF24_isDataAvailable(uint8_t* to);
LOCAL uint8_t RF24_readMessage(void* buf);
LOCAL void RF24_setNodeAddress(uint8_t address);
LOCAL uint8_t RF24_getNodeID(void);
LOCAL bool RF24_initialize(void);
#endif // __RF24_H__ #endif // __RF24_H__