nrfl2041 NOT WORKING

Dependencies:   mbed

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 //Bryan Edelman
00002 //edelmanb@colorado.edu
00003 //2/24/2010
00004 #include "mbed.h"
00005 #include "nRF24L01.h"
00006 //spi comms with nrf24l01+ chip. ms bit first, LSbyte first!
00007 //or with below to get correct code
00008 //--------------------------------------------------------------------------------------
00009 
00010 //---------------------------Settable Configurations---------------------------------------
00011 #define PAYLOAD_LENGTH 1 // Byte data packet length
00012 #define CHANNEL 0x10 //Channel to transmit on
00013 #define regCONFIG ( (1 << MASK_TX_DS) | (1<<EN_CRC) | (1<<CRCO) | (1<<MASK_MAX_RT) ) //defualt config
00014 #define regRF_SETUP ( (0<<RF_DR_HIGH)|(3<<RF_PWR))
00015 #define ADDRESS_LENGTH 0x01
00016 
00017 //------------------------------------------------------------------------------------------
00018 volatile int temp_byte1=0,temp_byte2=0,temp_byte3=0,temp_byte4=0,temp_byte5=0,temp_byte=0; //for reading spi results
00019 SPI spi(p5, p6, p7); // mosi, miso, sclk
00020 //RX Module
00021 DigitalOut rx_cs(p29);
00022 DigitalOut rx_ce(p30);
00023 DigitalIn rx_irq(p28);
00024 //TX Module
00025 DigitalOut tx_cs(p23);
00026 DigitalOut tx_ce(p24);
00027 DigitalIn tx_irq(p22);
00028 
00029 DigitalOut led1(LED1); //debug led
00030 Serial pc(USBTX, USBRX); // tx, rx
00031 
00032 bool PTX0 = 0;
00033 bool PTX1 = 1;
00034 
00035 //*****************************Function Definitions**********************
00036 void setup_rx();
00037 void setup_tx();
00038 void setup();
00039 uint8_t getStatusRX();
00040 uint8_t getStatusTX();
00041 bool dataReady(); //working
00042 void configRegTX(uint8_t reg, uint8_t value); //working
00043 void configRegRX(uint8_t reg, uint8_t value); //working
00044 uint8_t readRegTX(uint8_t reg); //working
00045 uint8_t readRegRX(uint8_t reg); //working
00046 void sendData(uint8_t  data_byte);
00047 void transmitSync(uint8_t * dataout,uint8_t len); //not implemented yet
00048 uint8_t getData();
00049 //************************************************************************
00050 
00051 //****************************Funciton Implementations********************
00052 void setup() {
00053     //setup pins, SPI format and speed....
00054     rx_ce =0; // rx chip enable low
00055     rx_cs =1; // rx cs line high please
00056     tx_ce = 0;// tx chip enable low
00057     tx_cs =1; // tx cs line high please
00058     spi.format(8,0); // 8 bits per write, mode 0
00059     spi.frequency(1000000); //1 megahurtz note: doesnt work lower
00060     led1=0;
00061     wait(.1); //startup time
00062    /* pc.printf(" RX Registers \nConfig = %x \n",readRegRX(CONFIG));
00063     pc.printf("enaa = %x \n",readRegRX(EN_AA));
00064     */pc.printf("enrxadr = %x \n",readRegRX(EN_RXADDR));
00065     /*pc.printf("aw= %x \n",readRegRX(SETUP_AW));
00066     pc.printf("retr = %x \n",readRegRX(SETUP_RETR));
00067     pc.printf("rf ch = %x \n",readRegRX(RF_CH));
00068     pc.printf("rf setup = %x \n",readRegRX(RF_SETUP));
00069     pc.printf("rx pw 0 = %x \n",readRegRX(RX_PW_P0));
00070     pc.printf("rx pw 1 = %x \n\n",readRegRX(RX_PW_P1));
00071     
00072     pc.printf(" TX Registers \nConfig = %x \n",readRegTX(CONFIG));
00073     pc.printf("enaa = %x \n",readRegTX(EN_AA));
00074     pc.printf("aw= %x \n",readRegTX(SETUP_AW));
00075     pc.printf("retr = %x \n",readRegTX(SETUP_RETR));
00076     pc.printf("rf ch = %x \n",readRegTX(RF_CH));
00077     pc.printf("rf setup = %x \n",readRegTX(RF_SETUP));
00078     pc.printf("tx addy = %x \n",readRegTX(TX_ADDR));*/
00079 
00080 }
00081 void setup_rx() {
00082     uint8_t regConfig =0, regRfChan=0, regRfSetup=0, status=0;
00083 
00084     configRegRX(CONFIG,regCONFIG|(1<<PWR_UP)|(1<<PRIM_RX)); ///setup to receive, irq on recieve, CRC 2 byte, power up
00085     configRegRX(RF_CH, CHANNEL); //set channel #
00086     configRegRX(RF_SETUP,regRF_SETUP); //no continuos carrier, 250Kbps, 0dBm
00087 
00088     rx_cs =0;
00089     spi.write(WRITE|RX_ADDR_P0);
00090     spi.write(0x51);
00091     spi.write(0x51);
00092     spi.write(0x51);
00093     spi.write(0x51);
00094     spi.write(0x51);
00095     rx_cs =1;
00096 
00097     regConfig =readRegRX(CONFIG);
00098     regRfChan =readRegRX(RF_CH);
00099     regRfSetup =readRegRX(RF_SETUP);
00100     
00101     rx_cs =0;
00102     spi.write(READ|RX_ADDR_P0);
00103     temp_byte1=spi.write(NOP);
00104     temp_byte2=spi.write(NOP);
00105     temp_byte3=spi.write(NOP);
00106     temp_byte4=spi.write(NOP);
00107     temp_byte5=spi.write(NOP);
00108     rx_cs =1;
00109 
00110     rx_cs =0;
00111     spi.write(FLUSH_RX);
00112     rx_cs =1;
00113 
00114     status=getStatusRX();
00115     configRegRX(STATUS, status|(1 << TX_DS) | (1 << MAX_RT));
00116     status=getStatusRX();
00117     
00118     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);
00119     pc.printf("RX address = %x%x%x%x%x \n", temp_byte5,temp_byte4,temp_byte3,temp_byte2,temp_byte1);
00120     rx_ce=1; //set to recieve mode
00121     return;
00122 }
00123 
00124 void setup_tx() {
00125     uint8_t regConfig =0, regRfChan=0, regRfSetup=0, status=0;
00126 
00127     configRegTX(CONFIG,regCONFIG|(1<<PWR_UP)|(0<<PRIM_RX));
00128     configRegTX(RF_CH,CHANNEL);
00129     configRegTX(RF_SETUP,regRF_SETUP);
00130 
00131     regConfig =readRegTX(CONFIG);
00132     regRfChan =readRegTX(RF_CH);
00133     regRfSetup =readRegTX(RF_SETUP);
00134 
00135     tx_cs =0;
00136     spi.write(WRITE|TX_ADDR);
00137     spi.write(0x51);
00138     spi.write(0x51);
00139     spi.write(0x51);
00140     spi.write(0x51);
00141     spi.write(0x51);
00142     tx_cs =1;
00143 
00144     tx_cs =0;
00145     spi.write(READ|TX_ADDR);
00146     temp_byte1=spi.write(NOP);
00147     temp_byte2=spi.write(NOP);
00148     temp_byte3=spi.write(NOP);
00149     temp_byte4=spi.write(NOP);
00150     temp_byte5=spi.write(NOP);
00151     tx_cs =1;
00152 
00153     status=getStatusTX();
00154     configRegTX(STATUS, status|(1 << TX_DS) | (1 << MAX_RT));
00155 
00156     tx_cs =0;
00157     spi.write(FLUSH_TX);
00158     tx_cs =1;
00159 
00160     status=getStatusTX();
00161 
00162     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);
00163     pc.printf("TX address = %x%x%x%x%x \n", temp_byte5,temp_byte4,temp_byte3,temp_byte2,temp_byte1);
00164 
00165     tx_ce=0;
00166     return;
00167 }
00168 
00169 uint8_t getStatusTX() {
00170     uint8_t status=0;
00171     tx_cs = 0;
00172     spi.write(READ|STATUS);
00173     status =spi.write(NOP);
00174     tx_cs =1;
00175     return status;
00176 }
00177 uint8_t getStatusRX() {
00178     uint8_t status=0;
00179     rx_cs = 0;
00180     spi.write(READ|STATUS);
00181     status =spi.write(NOP);
00182     rx_cs =1;
00183     return status;
00184 }
00185 bool dataReady() {
00186     uint8_t status = getStatusRX();
00187     return (status & (1 << RX_DR));
00188 }
00189 void configRegTX(uint8_t reg, uint8_t value) {
00190     tx_cs=0;
00191     spi.write(WRITE|reg);
00192     spi.write(WRITE|value);
00193     tx_cs=1;
00194 }
00195 void configRegRX(uint8_t reg, uint8_t value) {
00196     rx_cs=0;
00197     spi.write(WRITE|reg);
00198     spi.write(WRITE|value);
00199     rx_cs=1;
00200 }
00201 void sendData(uint8_t data) {
00202     uint8_t status;
00203     status = getStatusTX();
00204     PTX1=1;
00205     while (PTX1) {
00206         status = getStatusTX();
00207 
00208         if ((status & ((1 << TX_DS)  | (1 << MAX_RT)))) {
00209             PTX1 = 0;
00210             break;
00211         }
00212         tx_ce=0;
00213 
00214         PTX1 = 1;
00215         configRegTX(CONFIG, regCONFIG | ( (1<<PWR_UP) | (0<<PRIM_RX) ) );      // Set to transmitter mode , Power up
00216 
00217         tx_cs = 0;                    // Pull down chip select
00218         spi.write( FLUSH_TX );     // Write cmd to flush tx fifo
00219         tx_cs = 1;                    // Pull up chip select
00220         
00221         //pc.printf("TX status before = %x \n", getStatusTX());
00222         //pc.printf("data to be sent = %x \n", data);
00223         tx_cs = 0;                     // Pull down chip select
00224         spi.write(W_TX_PAYLOAD);       // Write cmd to write payload
00225         spi.write(data);   // Write payload
00226         tx_cs = 1;                    // Pull up chip select
00227        // pc.printf("TX FIFO status = %x \n", readRegTX(FIFO_STATUS));//
00228         tx_ce=1;                     // Start transmission
00229         wait(.005); //50uS delay
00230         tx_ce=0;
00231        // wait(1);//
00232        //  pc.printf("TX FIFO status = %x \n", readRegTX(FIFO_STATUS));//
00233        // pc.printf("TX status after = %x \n", getStatusTX());
00234         configRegTX(STATUS,getStatusTX()|(1 << TX_DS) | (1 << MAX_RT)); //clear sent bit
00235         return;
00236     }
00237 }
00238 void transmitSync(uint8_t * dataout,uint8_t len) { //later....
00239     uint8_t i;   //test me!
00240     pc.printf("length = %i \n", len);
00241     for (i = 0;i < len;i++) {
00242         spi.write(dataout[i]);
00243         
00244     }
00245     pc.printf("i = %i \n",i);
00246     return;
00247 }
00248 uint8_t getData() 
00249 // Reads payload bytes into data array
00250 {
00251     uint8_t data_byte=0;
00252     rx_cs = 0;                               // Pull down chip select
00253     spi.write(R_RX_PAYLOAD);            // Send cmd to read rx payload
00254     data_byte=spi.write(NOP); // Read payload
00255     rx_cs = 1;                               // Pull up chip select
00256     configRegTX(STATUS,(1<<RX_DR));   // Reset status register
00257     return data_byte;
00258 }
00259 uint8_t readRegTX(uint8_t reg)
00260 {
00261     uint8_t reg_value=0;
00262     tx_cs = 0;                             
00263     spi.write(READ|reg);            
00264     reg_value=spi.write(NOP); 
00265     tx_cs = 1;  
00266     return reg_value;
00267 }
00268 uint8_t readRegRX(uint8_t reg)
00269 {
00270     uint8_t reg_value=0;
00271     rx_cs = 0;                             
00272     spi.write(READ|reg);            
00273     reg_value = spi.write(NOP); 
00274     rx_cs = 1;  
00275     return reg_value;
00276 }
00277 //************************************************************************
00278 int main() {
00279     uint8_t data_to_send =0x55;
00280     setup();
00281     setup_rx();
00282     setup_tx();
00283     wait(.1);
00284     pc.printf("Setup Complete \n");
00285 
00286     configRegRX(RX_PW_P0,PAYLOAD_LENGTH);
00287     configRegRX(RX_PW_P1,PAYLOAD_LENGTH);
00288     //address widths
00289     configRegTX(SETUP_AW,0x03);
00290     configRegRX(SETUP_AW,0x03);
00291     
00292     configRegTX(SETUP_RETR,0<<ARC);
00293     configRegRX(ENAA_P0,0x00); //Disable all AA
00294     configRegRX(EN_RXADDR, 0x3F); //ENable only pipe 0
00295     
00296     
00297     //send some data
00298     //pc.printf("data sent \n\n");
00299     configRegTX(RF_CH,0x00);
00300     uint8_t i =0;
00301     while (!dataReady()) {
00302     pc.printf("FIFO status = %x \n i = %i \n", readRegRX(FIFO_STATUS), i);
00303     wait(.01);
00304     sendData(data_to_send);
00305     ++i;
00306     configRegTX(RF_CH,i);
00307     }
00308     led1=1;
00309     pc.printf("This is data recieved: %x \n", getData());
00310 }