Merge pull request arduino#429 from tekka007/RF24_updates

RF24 driver update

Author: tekka007

libraries/MySensors/MySensor.h

@@ -240,8 +240,7 @@
 		#if defined(ARDUINO_ARCH_ESP8266)
 			#error Soft SPI is not available on ESP8266
 		#endif
-		#include "drivers/AVR/DigitalIO/SoftI2cMaster.cpp"
-		#include "drivers/AVR/DigitalIO/PinIO.cpp"
+		#include "drivers/AVR/DigitalIO/DigitalIO.h"
 	#endif
 
 	// FLASH

libraries/MySensors/core/MyTransportNRF24.cpp

@@ -41,16 +41,16 @@ bool transportInit() {
 		memset(_psk, 0, 16);
 	#endif
 
-	return initializeRF24();
+	return RF24_initialize();
 }
 
 void transportSetAddress(uint8_t address) {
-	setNodeAddress(address);
-	startListening();
+	RF24_setNodeAddress(address);
+	RF24_startListening();
 }
 
 uint8_t transportGetAddress() {
-	return getNodeID();
+	return RF24_getNodeID();
 }
 
 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;
 		//encrypt data
 		_aes.cbc_encrypt(_dataenc, _dataenc, len/16); 
-		bool status = sendMessage( recipient, _dataenc, len );
+		bool status = RF24_sendMessage( recipient, _dataenc, len );
 	#else
-		bool status = sendMessage( recipient, data, len );
+		bool status = RF24_sendMessage( recipient, data, len );
 	#endif
 
 	return status;
 }
 
 bool transportAvailable(uint8_t *to) {
-	bool avail = IsDataAvailable(to);
+	bool avail = RF24_isDataAvailable(to);
 	return avail;
 }
 
 uint8_t transportReceive(void* data) {
-	uint8_t len = readMessage(data);
+	uint8_t len = RF24_readMessage(data);
 	#if defined(MY_RF24_ENABLE_ENCRYPTION)
 		// has to be adjusted, WIP!
 		_aes.set_IV(0);
@@ -87,5 +87,5 @@ uint8_t transportReceive(void* data) {
 }
 
 void transportPowerDown() {
-	powerDown();
+	RF24_powerDown();
 }

libraries/MySensors/drivers/RF24/RF24.cpp

@@ -22,23 +22,23 @@
 
 #include "RF24.h"
 
-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_BASE_ADDR[MY_RF24_ADDR_WIDTH] = { MY_RF24_BASE_RADIO_ID };
+LOCAL uint8_t MY_RF24_NODE_ADDRESS = AUTO;
 
-void csn(bool level) {
+LOCAL void RF24_csn(bool level) {
 	digitalWrite(MY_RF24_CS_PIN, level);		
 }
 
-void ce(bool level) {
+LOCAL void RF24_ce(bool 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;
 	#if !defined(MY_SOFTSPI)
 		_SPI.beginTransaction(SPISettings(MY_RF24_SPI_MAX_SPEED, MY_RF24_SPI_DATA_ORDER, MY_RF24_SPI_DATA_MODE));
 	#endif
-	csn(LOW);
+	RF24_csn(LOW);
 	// timing
 	delayMicroseconds(10);
 	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;
 		} else status = _SPI.transfer(*current++);
 	}
-	csn(HIGH);
+	RF24_csn(HIGH);
 	#if !defined(MY_SOFTSPI)
 		_SPI.endTransaction();
 	#endif
@@ -57,120 +57,116 @@ uint8_t spiMultiByteTransfer(uint8_t cmd, uint8_t* buf, uint8_t len, bool aReadM
 	return status;
 } 
 
-uint8_t spiByteTransfer(uint8_t cmd) {
-	return spiMultiByteTransfer( cmd, NULL, 0, false);
+LOCAL uint8_t RF24_spiByteTransfer(uint8_t cmd) {
+	return RF24_spiMultiByteTransfer( cmd, NULL, 0, false);
 }
 
-uint8_t _readByteRegister(uint8_t cmd) {
-	uint8_t value = spiMultiByteTransfer( cmd, NULL, 1, true);
+LOCAL uint8_t RF24_RAW_readByteRegister(uint8_t cmd) {
+	uint8_t value = RF24_spiMultiByteTransfer( cmd, NULL, 1, true);
 	RF24_DEBUG(PSTR("read register, reg=%d, value=%d\n"), cmd & (R_REGISTER ^ 0xFF), 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);
-	return spiMultiByteTransfer( cmd , &value, 1, false);
+	return RF24_spiMultiByteTransfer( cmd , &value, 1, false);
 }
 
-#define readByteRegister(reg) _readByteRegister( R_REGISTER | ( REGISTER_MASK & (reg) ) )
-#define writeByteRegister(reg, value) _writeByteRegister( W_REGISTER | ( REGISTER_MASK & (reg) ), value )
-#define writeMultiByteRegister(reg, buf, len) spiMultiByteTransfer( W_REGISTER | ( REGISTER_MASK & (reg) ), (uint8_t*)buf, len, false )
-
-void flushRX(void) {
-	RF24_DEBUG(PSTR("flushRX\n"));
-	spiByteTransfer( FLUSH_RX );
+LOCAL void RF24_flushRX(void) {
+	RF24_DEBUG(PSTR("RF24_flushRX\n"));
+	RF24_spiByteTransfer( FLUSH_RX );
 }
 
-void flushTX(void) {
-	RF24_DEBUG(PSTR("flushTX\n"));
-	spiByteTransfer( FLUSH_TX );
+LOCAL void RF24_flushTX(void) {
+	RF24_DEBUG(PSTR("RF24_flushTX\n"));
+	RF24_spiByteTransfer( FLUSH_TX );
 }
 
-uint8_t getStatus(void) {
-	return spiByteTransfer( NOP );
+LOCAL uint8_t RF24_getStatus(void) {
+	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);	
 	// only write LSB of RX0 and TX pipe
-	writeByteRegister(RX_ADDR_P0, recipient);
-	writeByteRegister(TX_ADDR, recipient);		
+	RF24_writeByteRegister(RX_ADDR_P0, recipient);
+	RF24_writeByteRegister(TX_ADDR, recipient);		
 }
 
-void startListening(void) {
+LOCAL void RF24_startListening(void) {
 	RF24_DEBUG(PSTR("start listening\n"));
 	// 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
-	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
-	ce(HIGH);
+	RF24_ce(HIGH);
 }
 
-void stopListening(void) {
+LOCAL void RF24_stopListening(void) {
 	RF24_DEBUG(PSTR("stop listening\n"));
-	ce(LOW);
+	RF24_ce(LOW);
 	// timing
 	delayMicroseconds(130);
-	writeByteRegister(NRF_CONFIG, MY_RF24_CONFIGURATION | _BV(PWR_UP) );
+	RF24_writeByteRegister(NRF_CONFIG, MY_RF24_CONFIGURATION | _BV(PWR_UP) );
 	// timing
 	delayMicroseconds(100);
 }
 
-void powerDown(void) {
-	ce(LOW);
-	writeByteRegister(NRF_CONFIG, 0x00);
+LOCAL void RF24_powerDown(void) {
+	RF24_ce(LOW);
+	RF24_writeByteRegister(NRF_CONFIG, 0x00);
 	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;
 
-	stopListening();
-	openWritingPipe( recipient );		
+	RF24_stopListening();
+	RF24_openWritingPipe( recipient );		
 	RF24_DEBUG(PSTR("send message to %d, len=%d\n"),recipient,len);
 	// 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
-	// 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
-	spiMultiByteTransfer( W_TX_PAYLOAD, (uint8_t*)buf, len, false );
+	RF24_spiMultiByteTransfer( W_TX_PAYLOAD, (uint8_t*)buf, len, false );
 	// go
-	ce(HIGH);
+	RF24_ce(HIGH);
 	// TX starts after ~10us
 	do {
-		status = getStatus();
+		status = RF24_getStatus();
 	} while  (!(status & ( _BV(MAX_RT) | _BV(TX_DS) )));
 
-	ce(LOW);
+	RF24_ce(LOW);
 	// reset interrupts
-	writeByteRegister(RF24_STATUS, _BV(TX_DS) | _BV(MAX_RT) );
+	RF24_writeByteRegister(RF24_STATUS, _BV(TX_DS) | _BV(MAX_RT) );
 	// Max retries exceeded
 	if( status & _BV(MAX_RT)){
 		// flush packet
 		RF24_DEBUG(PSTR("MAX_RT\n"));
-		flushTX();
+		RF24_flushTX();
 	}
 
-	startListening();
+	RF24_startListening();
 
 	return (status & _BV(TX_DS));
 }
 
-uint8_t getDynamicPayloadSize(void) {
-	uint8_t result = spiMultiByteTransfer(R_RX_PL_WID,NULL,1,true);
+LOCAL uint8_t RF24_getDynamicPayloadSize(void) {
+	uint8_t result = RF24_spiMultiByteTransfer(R_RX_PL_WID,NULL,1,true);
 	// check if payload size invalid
 	if(result > 32) { 
 		RF24_DEBUG(PSTR("invalid payload length = %d\n"),result);
-		flushRX(); 
+		RF24_flushRX(); 
 		result = 0; 
 	}
 	return result;
 }
 
 
-bool IsDataAvailable(uint8_t* to) {
-	uint8_t pipe_num = ( getStatus() >> RX_P_NO ) & 0b0111;
+LOCAL bool RF24_isDataAvailable(uint8_t* to) {
+	uint8_t pipe_num = ( RF24_getStatus() >> RX_P_NO ) & 0b0111;
 	#if defined(MY_DEBUG_VERBOSE_RF24)
 		if(pipe_num <= 5)
 			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) {
-	uint8_t len = getDynamicPayloadSize();
+LOCAL uint8_t RF24_readMessage( void* buf) {
+	uint8_t len = RF24_getDynamicPayloadSize();
 	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
-	writeByteRegister(RF24_STATUS, _BV(RX_DR) );
+	RF24_writeByteRegister(RF24_STATUS, _BV(RX_DR) );
 	return len;
 }
 
-void setNodeAddress(uint8_t address) {
-	MY_RF24_NODE_ADDRESS = address;
-	// enable node pipe
-	writeByteRegister(EN_RXADDR, _BV(ERX_P0 + BROADCAST_PIPE) | _BV(ERX_P0) );
-	// enable autoACK on pipe 0
-	writeByteRegister(EN_AA, _BV(ENAA_P0) );
+LOCAL void RF24_setNodeAddress(uint8_t address) {
+	if(address!=AUTO){
+		MY_RF24_NODE_ADDRESS = address;
+		// enable node pipe
+		RF24_writeByteRegister(EN_RXADDR, _BV(ERX_P0 + BROADCAST_PIPE) | _BV(ERX_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;
 }
 
-bool initializeRF24(void) {
+LOCAL bool RF24_initialize(void) {
 	// Initialize pins
 	pinMode(MY_RF24_CE_PIN,OUTPUT);
 	pinMode(MY_RF24_CS_PIN,OUTPUT);
 	// Initialize SPI
 	_SPI.begin();
-	ce(LOW);
-	csn(HIGH);
+	RF24_ce(LOW);
+	RF24_csn(HIGH);
 	// 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
 	delay(5);
 	// 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
-	writeByteRegister(SETUP_RETR, RF24_ARD << ARD | RF24_ARC << ARC);
+	RF24_writeByteRegister(SETUP_RETR, RF24_ARD << ARD | RF24_ARC << ARC);
 	// set channel
-	writeByteRegister(RF_CH, MY_RF24_CHANNEL);
+	RF24_writeByteRegister(RF_CH, MY_RF24_CHANNEL);
 	// set data rate and pa level
-	writeByteRegister(RF_SETUP, MY_RF24_RF_SETUP);
+	RF24_writeByteRegister(RF_SETUP, MY_RF24_RF_SETUP);
 	// sanity check
 	#if defined(MY_RF24_SANITY_CHECK)
-		if(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);
+		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"),RF24_readByteRegister(RF_SETUP), MY_RF24_RF_SETUP);
 			return false;
 		}
 	#endif
 	// toggle features (necessary on some clones)
-	writeByteRegister(ACTIVATE,0x73);
+	RF24_writeByteRegister(ACTIVATE,0x73);
 	// enable ACK payload and dynamic payload
-	writeByteRegister(FEATURE, MY_RF24_FEATURE );
+	RF24_writeByteRegister(FEATURE, MY_RF24_FEATURE );
     // 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
-	writeByteRegister(EN_AA, 0x00 );
+	RF24_writeByteRegister(EN_AA, 0x00 );
 	// 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
 	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
-	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(RX_ADDR_P0, (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
-	flushRX();
-	flushTX();
+	RF24_flushRX();
+	RF24_flushTX();
 	// 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;
 }