Tony,
I believe you're hanging up because you're not handling any errors.
At this point, I'll just give you some code snippets from my PIC micro-controller and see if you can figure out the problem before I spend much time on it.
This example code is assuming 8 byte transmit and receive payload data.
nRF library header
// nRF24L01+ Commands
#define nRF_RD_REGISTER 0x00
#define nRF_WR_REGISTER 0x20
#define nRF_RD_RX_PL_WID 0x60
#define nRF_RD_RX_PL 0x61
#define nRF_WR_TX_PL 0xA0
#define nRF_WR_ACK_PL 0xA8
#define nRF_W_TX_PL_NOACK 0xB0
#define nRF_FLUSH_TX 0xE1
#define nRF_FLUSH_RX 0xE2
#define nRF_REUSE_TX_PL 0xE3
#define nRF_NOP 0xFF
// nRF24L01+ Registers
#define nRF_CONFIG 0x00 // Configuration Register
#define nRF_EN_AA 0x01 // Enable Auto_Acknowledgement
#define nRF_EN_RXADDR 0x02 // Enable RX Addresses
#define nRF_SETUP_AW 0x03 // Setup Address Width
#define nRF_SETUP_RETR 0x04 // Setup Automatic Retransmission
#define nRF_RF_CH 0x05 // RF Channel
#define nRF_RF_SETUP 0x06 // RF Setup Register
#define nRF_STATUS 0x07 // Status Register
#define nRF_OBSERVE_TX 0x08 // Transmit Observe Register
#define nRF_RPD 0x09 // Receiver Power Detector
#define nRF_RX_ADDR_P0 0x0A // Receive Address
#define nRF_RX_ADDR_P1 0x0B
#define nRF_RX_ADDR_P2 0x0C
#define nRF_RX_ADDR_P3 0x0D
#define nRF_RX_ADDR_P4 0x0E
#define nRF_RX_ADDR_P5 0x0F
#define nRF_TX_ADDR 0x10 // Transmit Address
#define nRF_RX_PW_P0 0x11 // Payload Length
#define nRF_RX_PW_P1 0x12
#define nRF_RX_PW_P2 0x13
#define nRF_RX_PW_P3 0x14
#define nRF_RX_PW_P4 0x15
#define nRF_RX_PW_P5 0x16
#define nRF_FIFO_STATUS 0x17 // FIFO Status Register
#define nRF_DYNPD 0x1C // Enable Dynamic Payload Length
#define nRF_FEATURE 0x1D // Feature Register
// nRF24L01+ Bits
// Configuration Bits
#define nRF_CRC0 0x00 // CRC Off
#define nRF_CRC1 0x08 // CRC 1 Byte
#define nRF_CRC2 0x0C // CRC 2 Bytes
#define nRF_PwrUp 0x02 // Power Up
#define nRF_PwrDn 0x00 // Power Down
#define nRF_PRX 0x01 // RX Mode
#define nRF_PTX 0x00 // TX Mode
// Address Width Bits
#define nRF_AW3 0x01 // 3 Byte Address
#define nRF_AW4 0x02 // 4 Byte Address
#define nRF_AW5 0x03 // 5 Byte Address
// RF Setup Bits
#define nRF_250Kbps 0x20 // Data Rate 250 Kbps
#define nRF_1Mbps 0x00 // 1 Mbps
#define nRF_2Mbps 0x08 // 2 Mbps
#define nRF_PWR18 0x00 // -18 dBm
#define nRF_PWR12 0x02 // -12 dBm
#define nRF_PWR6 0x04 // -6 dBm
#define nRF_PWR0 0x06 // 0 dBm
// Status Bits
#define nRF_RX_DR 0x40 // Data Ready
#define nRF_TX_DS 0x20 // Data Sent
#define nRF_MAX_RT 0x10 // Max ReTransmit
#define nRF_RX_P_NO 0x0E // RX Pipe Number
#define nRF_TX_FIFO 0x01 // TX FIFO Full
// FIFO Status Bits
#define nRF_TX_REUSE 0x40
#define nRF_TX_FULL 0x20
#define nRF_TX_EMPTY 0x10
#define nRF_RX_FULL 0x02
#define nRF_RX_EMPTY 0x01
// Feature Bits
#define nRF_EN_DPL 0x04 // Enable Dynamic Payload Length
#define nRF_EN_ACK_PAY 0x02 // Enable Payload with ACK
#define nRF_EN_DYN_ACK 0x01 // Enable Dynamic ACK
// Prototypes
uint8_t nrfRead(uint8_t *buf, uint8_t cnt);
uint8_t nrfWrite(uint8_t *buf, uint8_t cnt);
nRF library code
/*------------------------------------------------------------*/
#define WRITE(c, s) \
PIR1bits.SSPIF = 0; \
SSPBUF = c; \
while ( !PIR1bits.SSPIF ) {} \
s = SSPBUF
#define READ(s) \
PIR1bits.SSPIF = 0; \
SSPBUF = 0; \
while ( !PIR1bits.SSPIF ) {} \
s = SSPBUF
/*------------------------------------------------------------*/
uint8_t nrfRead(uint8_t *buf, uint8_t cnt)
{
uint8_t stat;
nRF_CSNpin = 0;
WRITE(buf[0], stat);
for (int i=cnt-1;i>0;i--) {
READ(buf[i]);
}
nRF_CSNpin = 1;
return(stat);
}
uint8_t nrfWrite(uint8_t *buf, uint8_t cnt)
{
uint8_t stat;
uint8_t tmp;
nRF_CSNpin = 0;
WRITE(buf[0], stat);
for (int i=cnt-1;i>0;i--) {
WRITE(buf[i], tmp);
}
nRF_CSNpin = 1;
return(stat);
}
nRF functions and main loop
// Register reads
uint8_t rfAddr[6]= {nRF_RD_REGISTER|nRF_RX_ADDR_P0, 0, 0, 0, 0, 0};
uint8_t rfAux[6]= {nRF_RD_REGISTER|nRF_RX_ADDR_P1, 0, 0, 0, 0, 0};
uint8_t rfCh[2]= {nRF_RD_REGISTER|nRF_RF_CH, 0};
uint8_t rfStatus[2]= {nRF_RD_REGISTER|nRF_STATUS, 0};
uint8_t rfObserve[2]= {nRF_RD_REGISTER|nRF_OBSERVE_TX, 0};
uint8_t rfFIFO[2]= {nRF_RD_REGISTER|nRF_FIFO_STATUS, 0};
//============================================================
void nrfSetup(void)
{
// Configure the radio
// Set addresses
uint8_t rfA0[6]={nRF_WR_REGISTER|nRF_RX_ADDR_P0, 0xd6, 0xd6, 0xd6, 0xd6, 0x11};
nrfWrite(rfA0,6);
rfA0[0]=nRF_WR_REGISTER|nRF_TX_ADDR;
nrfWrite(rfA0,6);
uint8_t rfA1[6]={nRF_WR_REGISTER|nRF_RX_ADDR_P1, 0xb2, 0xb2, 0xb2, 0xb2, 0xb2};
nrfWrite(rfA1,6);
// Set payload width
uint8_t rfPW0[2]={nRF_WR_REGISTER|nRF_RX_PW_P0, 8}; // transmit 8 bytes
nrfWrite(rfPW0,2);
uint8_t rfPW1[2]={nRF_WR_REGISTER|nRF_RX_PW_P1, 8}; // receive 8 bytes
nrfWrite(rfPW1,2);
// Set Auto_Acknowledgement
uint8_t rfAA[2]={nRF_WR_REGISTER|nRF_EN_AA, 0x01};
nrfWrite(rfAA,2);
// Set RF data rate and power level
uint8_t rfSetup[2]={nRF_WR_REGISTER|nRF_RF_SETUP, nRF_1Mbps|nRF_PWR12};
nrfWrite(rfSetup,2);
}
//============================================================
void powerUp(void)
{
uint8_t rfConfig[2];
rfConfig[0] = nRF_RD_REGISTER|nRF_CONFIG;
nrfRead(rfConfig,2);
rfConfig[0] = nRF_WR_REGISTER|nRF_CONFIG;
rfConfig[1] = rfConfig[1] | nRF_PwrUp;
nrfWrite(rfConfig,2);
}
//============================================================
void powerDn(void)
{
uint8_t rfConfig[2];
rfConfig[0] = nRF_RD_REGISTER|nRF_CONFIG;
nrfRead(rfConfig,2);
rfConfig[0] = nRF_WR_REGISTER|nRF_CONFIG;
rfConfig[1] = rfConfig[1] & (~nRF_PwrUp);
nrfWrite(rfConfig,2);
}
//============================================================
void startListening(void)
{
// Set PwrUp and PRX
uint8_t rfRcvMode[2]={nRF_WR_REGISTER|nRF_CONFIG, nRF_CRC1|nRF_PwrUp|nRF_PRX};
nrfWrite(rfRcvMode,2);
// Clear RX_DR, TX_DS, MAX_RT bits
uint8_t rfClear[2]={nRF_WR_REGISTER|nRF_STATUS, nRF_RX_DR|nRF_TX_DS|nRF_MAX_RT};
nrfWrite(rfClear,2);
// Set CE high
nRF_CEpin=1;
delay_us(130);
}
//============================================================
void stopListening(void)
{
// Set CE low
nRF_CEpin=0;
// Flush TX FIFO
uint8_t rfFlush={nRF_FLUSH_TX};
nrfWrite(&rfFlush,1);
}
//============================================================
void writePayload(void)
{
uint8_t stat,timeout;
// Set PwrUp and PTX
uint8_t rfXmtMode[2]={nRF_WR_REGISTER|nRF_CONFIG, nRF_CRC1|nRF_PwrUp|nRF_PTX};
nrfWrite(rfXmtMode,2);
delay_us(150);
// Fill payload
uint8_t rfPayload[9]={nRF_WR_TX_PL};
// TODO:: Fill in the 8 bytes of data to send here.
// rfPayload[1] thru rfPayload[8]
. . .
// Send payload
nrfWrite(rfPayload,9);
// Strobe CE
nRF_CEpin=1;
delay_us(16);
nRF_CEpin=0;
// Wait for complete
timeout=100;
do {
delay_ms(1);
stat = nrfRead(rfObserve,2);
} while ( (stat & 0x30) == 0 && --timeout > 0 );
RxReady = (stat >> 6) & 0x01; // RX_DR
TxOkay = (stat >> 5) & 0x01; // TX_DS
TxFail = (stat >> 4) & 0x01; // MAX_RT
// Clear RX_DR, TX_DS, MAX_RT bits
uint8_t rfClear[2]={nRF_WR_REGISTER|nRF_STATUS, nRF_RX_DR|nRF_TX_DS|nRF_MAX_RT};
nrfWrite(rfClear,2);
if (TxFail) {
uint8_t rfFlush={nRF_FLUSH_TX};
nrfWrite(&rfFlush,1);
}
}
//============================================================
void readPayload(void)
{
uint8_t rfPayload[9]={nRF_RD_RX_PL};
nrfRead(rfPayload,9);
// TODO:: Unpack the 8 bytes of data you received here.
// rfPayload[1] thru rfPayload[8]
. . .
}
//============================================================
//============================================================
void main(void)
{
// Initialization
nrfSetup();
startListening();
// Main loop
while (1) {
// Read FIFO status >>>>> Status <<<<<
stat = nrfRead(rfFIFO,2);
TxFIFO = (rfFIFO[1] >> 4) & 0x03;
RxFIFO = (rfFIFO[1]) & 0x03;
RxReady = (stat >> 6) & 0x01; // RX_DR
TxOkay = (stat >> 5) & 0x01; // TX_DS
TxFail = (stat >> 4) & 0x01; // MAX_RT
// Read available payloads <<<<< Payload <<<<<
while ( (rfFIFO[1] & 0x01) != 1 )
{
readPayload(); // Get payload
nrfRead(rfFIFO,2); // Get FIFO status
}
// Write payload >>>>> Payload >>>>>
if ( anything_to_send )
{
stopListening();
writePayload(); // Send payload
startListening();
}
// 10Hz processing loop
delay_ms(100);
}
}