File content as of revision 0:da73b7c64384:

//Bryan Edelman
//edelmanb@colorado.edu
//2/24/2010
#include "mbed.h"
#include "nRF24L01.h"
//spi comms with nrf24l01+ chip. ms bit first, LSbyte first!
//or with below to get correct code
//--------------------------------------------------------------------------------------

//---------------------------Settable Configurations---------------------------------------
#define PAYLOAD_LENGTH 1 // Byte data packet length
#define CHANNEL 0x10 //Channel to transmit on
#define regCONFIG ( (1 << MASK_TX_DS) | (1<<EN_CRC) | (1<<CRCO) | (1<<MASK_MAX_RT) ) //defualt config
#define regRF_SETUP ( (0<<RF_DR_HIGH)|(3<<RF_PWR))
#define ADDRESS_LENGTH 0x01

//------------------------------------------------------------------------------------------
volatile int temp_byte1=0,temp_byte2=0,temp_byte3=0,temp_byte4=0,temp_byte5=0,temp_byte=0; //for reading spi results
SPI spi(p5, p6, p7); // mosi, miso, sclk
//RX Module
DigitalOut rx_cs(p29);
DigitalOut rx_ce(p30);
DigitalIn rx_irq(p28);
//TX Module
DigitalOut tx_cs(p23);
DigitalOut tx_ce(p24);
DigitalIn tx_irq(p22);

DigitalOut led1(LED1); //debug led
Serial pc(USBTX, USBRX); // tx, rx

bool PTX0 = 0;
bool PTX1 = 1;

//*****************************Function Definitions**********************
void setup_rx();
void setup_tx();
void setup();
uint8_t getStatusRX();
uint8_t getStatusTX();
bool dataReady(); //working
void configRegTX(uint8_t reg, uint8_t value); //working
void configRegRX(uint8_t reg, uint8_t value); //working
uint8_t readRegTX(uint8_t reg); //working
uint8_t readRegRX(uint8_t reg); //working
void sendData(uint8_t  data_byte);
void transmitSync(uint8_t * dataout,uint8_t len); //not implemented yet
uint8_t getData();
//************************************************************************

//****************************Funciton Implementations********************
void setup() {
    //setup pins, SPI format and speed....
    rx_ce =0; // rx chip enable low
    rx_cs =1; // rx cs line high please
    tx_ce = 0;// tx chip enable low
    tx_cs =1; // tx cs line high please
    spi.format(8,0); // 8 bits per write, mode 0
    spi.frequency(1000000); //1 megahurtz note: doesnt work lower
    led1=0;
    wait(.1); //startup time
   /* pc.printf(" RX Registers \nConfig = %x \n",readRegRX(CONFIG));
    pc.printf("enaa = %x \n",readRegRX(EN_AA));
    */pc.printf("enrxadr = %x \n",readRegRX(EN_RXADDR));
    /*pc.printf("aw= %x \n",readRegRX(SETUP_AW));
    pc.printf("retr = %x \n",readRegRX(SETUP_RETR));
    pc.printf("rf ch = %x \n",readRegRX(RF_CH));
    pc.printf("rf setup = %x \n",readRegRX(RF_SETUP));
    pc.printf("rx pw 0 = %x \n",readRegRX(RX_PW_P0));
    pc.printf("rx pw 1 = %x \n\n",readRegRX(RX_PW_P1));
    
    pc.printf(" TX Registers \nConfig = %x \n",readRegTX(CONFIG));
    pc.printf("enaa = %x \n",readRegTX(EN_AA));
    pc.printf("aw= %x \n",readRegTX(SETUP_AW));
    pc.printf("retr = %x \n",readRegTX(SETUP_RETR));
    pc.printf("rf ch = %x \n",readRegTX(RF_CH));
    pc.printf("rf setup = %x \n",readRegTX(RF_SETUP));
    pc.printf("tx addy = %x \n",readRegTX(TX_ADDR));*/

}
void setup_rx() {
    uint8_t regConfig =0, regRfChan=0, regRfSetup=0, status=0;

    configRegRX(CONFIG,regCONFIG|(1<<PWR_UP)|(1<<PRIM_RX)); ///setup to receive, irq on recieve, CRC 2 byte, power up
    configRegRX(RF_CH, CHANNEL); //set channel #
    configRegRX(RF_SETUP,regRF_SETUP); //no continuos carrier, 250Kbps, 0dBm

    rx_cs =0;
    spi.write(WRITE|RX_ADDR_P0);
    spi.write(0x51);
    spi.write(0x51);
    spi.write(0x51);
    spi.write(0x51);
    spi.write(0x51);
    rx_cs =1;

    regConfig =readRegRX(CONFIG);
    regRfChan =readRegRX(RF_CH);
    regRfSetup =readRegRX(RF_SETUP);
    
    rx_cs =0;
    spi.write(READ|RX_ADDR_P0);
    temp_byte1=spi.write(NOP);
    temp_byte2=spi.write(NOP);
    temp_byte3=spi.write(NOP);
    temp_byte4=spi.write(NOP);
    temp_byte5=spi.write(NOP);
    rx_cs =1;

    rx_cs =0;
    spi.write(FLUSH_RX);
    rx_cs =1;

    status=getStatusRX();
    configRegRX(STATUS, status|(1 << TX_DS) | (1 << MAX_RT));
    status=getStatusRX();
    
    pc.printf("RX Config Register = %x \n RX Channel # = %x \n RX RF Setup Reg = %x \n RX Status Reg = %x \n ", regConfig, regRfChan, regRfSetup, status);
    pc.printf("RX address = %x%x%x%x%x \n", temp_byte5,temp_byte4,temp_byte3,temp_byte2,temp_byte1);
    rx_ce=1; //set to recieve mode
    return;
}

void setup_tx() {
    uint8_t regConfig =0, regRfChan=0, regRfSetup=0, status=0;

    configRegTX(CONFIG,regCONFIG|(1<<PWR_UP)|(0<<PRIM_RX));
    configRegTX(RF_CH,CHANNEL);
    configRegTX(RF_SETUP,regRF_SETUP);

    regConfig =readRegTX(CONFIG);
    regRfChan =readRegTX(RF_CH);
    regRfSetup =readRegTX(RF_SETUP);

    tx_cs =0;
    spi.write(WRITE|TX_ADDR);
    spi.write(0x51);
    spi.write(0x51);
    spi.write(0x51);
    spi.write(0x51);
    spi.write(0x51);
    tx_cs =1;

    tx_cs =0;
    spi.write(READ|TX_ADDR);
    temp_byte1=spi.write(NOP);
    temp_byte2=spi.write(NOP);
    temp_byte3=spi.write(NOP);
    temp_byte4=spi.write(NOP);
    temp_byte5=spi.write(NOP);
    tx_cs =1;

    status=getStatusTX();
    configRegTX(STATUS, status|(1 << TX_DS) | (1 << MAX_RT));

    tx_cs =0;
    spi.write(FLUSH_TX);
    tx_cs =1;

    status=getStatusTX();

    pc.printf("TX Config Register = %x \n TX Channel # = %x \n TX RF Setup Reg = %x \n TX Status Reg = %x \n ", regConfig, regRfChan, regRfSetup, status);
    pc.printf("TX address = %x%x%x%x%x \n", temp_byte5,temp_byte4,temp_byte3,temp_byte2,temp_byte1);

    tx_ce=0;
    return;
}

uint8_t getStatusTX() {
    uint8_t status=0;
    tx_cs = 0;
    spi.write(READ|STATUS);
    status =spi.write(NOP);
    tx_cs =1;
    return status;
}
uint8_t getStatusRX() {
    uint8_t status=0;
    rx_cs = 0;
    spi.write(READ|STATUS);
    status =spi.write(NOP);
    rx_cs =1;
    return status;
}
bool dataReady() {
    uint8_t status = getStatusRX();
    return (status & (1 << RX_DR));
}
void configRegTX(uint8_t reg, uint8_t value) {
    tx_cs=0;
    spi.write(WRITE|reg);
    spi.write(WRITE|value);
    tx_cs=1;
}
void configRegRX(uint8_t reg, uint8_t value) {
    rx_cs=0;
    spi.write(WRITE|reg);
    spi.write(WRITE|value);
    rx_cs=1;
}
void sendData(uint8_t data) {
    uint8_t status;
    status = getStatusTX();
    PTX1=1;
    while (PTX1) {
        status = getStatusTX();

        if ((status & ((1 << TX_DS)  | (1 << MAX_RT)))) {
            PTX1 = 0;
            break;
        }
        tx_ce=0;

        PTX1 = 1;
        configRegTX(CONFIG, regCONFIG | ( (1<<PWR_UP) | (0<<PRIM_RX) ) );      // Set to transmitter mode , Power up

        tx_cs = 0;                    // Pull down chip select
        spi.write( FLUSH_TX );     // Write cmd to flush tx fifo
        tx_cs = 1;                    // Pull up chip select
        
        //pc.printf("TX status before = %x \n", getStatusTX());
        //pc.printf("data to be sent = %x \n", data);
        tx_cs = 0;                     // Pull down chip select
        spi.write(W_TX_PAYLOAD);       // Write cmd to write payload
        spi.write(data);   // Write payload
        tx_cs = 1;                    // Pull up chip select
       // pc.printf("TX FIFO status = %x \n", readRegTX(FIFO_STATUS));//
        tx_ce=1;                     // Start transmission
        wait(.005); //50uS delay
        tx_ce=0;
       // wait(1);//
       //  pc.printf("TX FIFO status = %x \n", readRegTX(FIFO_STATUS));//
       // pc.printf("TX status after = %x \n", getStatusTX());
        configRegTX(STATUS,getStatusTX()|(1 << TX_DS) | (1 << MAX_RT)); //clear sent bit
        return;
    }
}
void transmitSync(uint8_t * dataout,uint8_t len) { //later....
    uint8_t i;   //test me!
    pc.printf("length = %i \n", len);
    for (i = 0;i < len;i++) {
        spi.write(dataout[i]);
        
    }
    pc.printf("i = %i \n",i);
    return;
}
uint8_t getData() 
// Reads payload bytes into data array
{
    uint8_t data_byte=0;
    rx_cs = 0;                               // Pull down chip select
    spi.write(R_RX_PAYLOAD);            // Send cmd to read rx payload
    data_byte=spi.write(NOP); // Read payload
    rx_cs = 1;                               // Pull up chip select
    configRegTX(STATUS,(1<<RX_DR));   // Reset status register
    return data_byte;
}
uint8_t readRegTX(uint8_t reg)
{
    uint8_t reg_value=0;
    tx_cs = 0;                             
    spi.write(READ|reg);            
    reg_value=spi.write(NOP); 
    tx_cs = 1;  
    return reg_value;
}
uint8_t readRegRX(uint8_t reg)
{
    uint8_t reg_value=0;
    rx_cs = 0;                             
    spi.write(READ|reg);            
    reg_value = spi.write(NOP); 
    rx_cs = 1;  
    return reg_value;
}
//************************************************************************
int main() {
    uint8_t data_to_send =0x55;
    setup();
    setup_rx();
    setup_tx();
    wait(.1);
    pc.printf("Setup Complete \n");

    configRegRX(RX_PW_P0,PAYLOAD_LENGTH);
    configRegRX(RX_PW_P1,PAYLOAD_LENGTH);
    //address widths
    configRegTX(SETUP_AW,0x03);
    configRegRX(SETUP_AW,0x03);
    
    configRegTX(SETUP_RETR,0<<ARC);
    configRegRX(ENAA_P0,0x00); //Disable all AA
    configRegRX(EN_RXADDR, 0x3F); //ENable only pipe 0
    
    
    //send some data
    //pc.printf("data sent \n\n");
    configRegTX(RF_CH,0x00);
    uint8_t i =0;
    while (!dataReady()) {
    pc.printf("FIFO status = %x \n i = %i \n", readRegRX(FIFO_STATUS), i);
    wait(.01);
    sendData(data_to_send);
    ++i;
    configRegTX(RF_CH,i);
    }
    led1=1;
    pc.printf("This is data recieved: %x \n", getData());
}