nrf24l01+ setup

#include <bcm2835.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "nRF24L01.h"

#define CE RPI_GPIO_P1_22
#define LED RPI_GPIO_P1_12

void initSPI(){
    /*
     *      Init SPI
     */
    if (!bcm2835_init()){
        exit(1);
    }
    bcm2835_spi_begin();
    bcm2835_spi_setBitOrder(BCM2835_SPI_BIT_ORDER_MSBFIRST);
    bcm2835_spi_setDataMode(BCM2835_SPI_MODE0);
    bcm2835_spi_setClockDivider(BCM2835_SPI_CLOCK_DIVIDER_128);
    bcm2835_spi_chipSelect(BCM2835_SPI_CS0);
    bcm2835_spi_setChipSelectPolarity(BCM2835_SPI_CS0, LOW);


    //STAT led in CE
    bcm2835_gpio_fsel(CE, BCM2835_GPIO_FSEL_OUTP);
    bcm2835_gpio_fsel(LED, BCM2835_GPIO_FSEL_OUTP);
    bcm2835_gpio_write(CE, LOW);
}

void writeSPI(char command, uint8_t reg, uint8_t* payload, int size){
    /*  R - read, W - write, C - command
     *
     */

    uint8_t* buffer;
    int i;
    buffer = (uint8_t*)malloc(sizeof(uint8_t)*(size+1));

    if(command == 'W'){
        reg = W_REGISTER + reg;
    }
    buffer[0] = reg;

    if(command == 'R'){
        for(i = 1; i < size+1; i++){
            buffer[i] = 0xFF; //nop
        }
    }else{
        memcpy(buffer+1, payload, sizeof(uint8_t)*size);
    }

    bcm2835_spi_transfern(buffer, size+1);
    if(command = 'R'){
        memcpy(payload, buffer+1, sizeof(uint8_t)*size);
    }

}

void printOut(){
    uint8_t* stat;
    stat = (uint8_t*)malloc(sizeof(uint8_t)*5);
    writeSPI('R', STATUS, stat, 1);
    printf("Status:\t\t 0x%02X\n",stat[0]);

    writeSPI('R', RX_ADDR_P0, stat, 5);
    printf("RX_ADDR_P0:\t 0x%02X%02X%02X%02X%02X\n",stat[0],stat[1],stat[2],stat[3],stat[4]);

    writeSPI('R', RX_ADDR_P1, stat, 5);
    printf("RX_ADDR_P1:\t 0x%02X%02X%02X%02X%02X\n",stat[0],stat[1],stat[2],stat[3],stat[4]);

    writeSPI('R', TX_ADDR, stat, 5);
    printf("TX_ADDR:\t 0x%02X%02X%02X%02X%02X\n",stat[0],stat[1],stat[2],stat[3],stat[4]);

    writeSPI('R', RX_PW_P0, stat, 1);
    printf("RX_PW_P0:\t 0x%02X\n",stat[0]);

    writeSPI('R', RX_PW_P1, stat, 1);
    printf("RX_PW_P1:\t 0x%02X\n",stat[0]);

    writeSPI('R', EN_AA, stat, 1);
    printf("EN_AA:\t\t 0x%02X\n",stat[0]);

    writeSPI('R', EN_RXADDR, stat, 1);;
    printf("EN_RXADDR:\t 0x%02X\n",stat[0]);

    writeSPI('R', RF_CH, stat, 1);
    printf("RF_CH:\t\t 0x%02X\n",stat[0]);

    writeSPI('R', RF_SETUP, stat, 1);
    printf("RF_SETUP:\t 0x%02X\n",stat[0]);

    writeSPI('R', CONFIG, stat, 1);
    printf("CONFIG:\t\t 0x%02X\n",stat[0]);

    writeSPI('R', DYNPD, stat, 1);
    printf("DYNPD:\t\t 0x%02X\n",stat[0]);

    writeSPI('R', RF_SETUP, stat, 1);
    if((stat[0] & (1<<RF_DR_LOW)) == 0){
        //1/2mbs
        if((stat[0] & (1<<RF_DR_HIGH)) == 0){
            printf("Data Rate:\t 1Mbps\n");
        }else{
            printf("Data Rate:\t 2Mbps\n");
        }
    }else if((stat[0] & (1<<RF_DR_LOW)) == 1){
        printf("Data Rate:\t 250kbps\n");
    }else{
        printf("Data rate ne dela\n");
    }

    if((stat[0] & (1<< RF_PWR_LOW)) == 0){
        if((stat[0] & (1<< RF_PWR_HIGH)) == 0){
            printf("PA Power\t = -18dBm\n");
        }else{
            printf("PA Power\t = -6dBm\n");
        }
    }else{
        if((stat[0] & (1<< RF_PWR_HIGH)) == 0){
            printf("PA Power\t = -12dBm\n");
        }else{
            printf("PA Power\t = -0dBm\n");
        }
    }
}

void init(char* func){
    uint8_t* buffer;
    buffer = (uint8_t*)malloc(sizeof(uint8_t)*5);
    //CONFIG

    buffer[0] = (1<<PWR_UP) | (1<<CRCO) | (1<<EN_CRC);
    writeSPI('W', CONFIG, buffer, 1);

    //Enable EX addr
    buffer[0] = (1<<ERX_P0) | (1<<ERX_P1);
    writeSPI('W', EN_RXADDR, buffer, 1);

    if(strcmp(func, "RX") == 0){
        //TX address
        buffer[0] = 0xf0;
        buffer[1] = 0xf0;
        buffer[2] = 0xf0;
        buffer[3] = 0xf0;
        buffer[4] = 0xd2;
        writeSPI('W', TX_ADDR, buffer, 5);

        //Rx0 address (auto acc)
        buffer[0] = 0xf0;
        buffer[1] = 0xf0;
        buffer[2] = 0xf0;
        buffer[3] = 0xf0;
        buffer[4] = 0xd2; //al pa e1/d2
        writeSPI('W', RX_ADDR_P0, buffer, 5);

        //Rx1 address
        buffer[0] = 0xf0;
        buffer[1] = 0xf0;
        buffer[2] = 0xf0;
        buffer[3] = 0xf0;
        buffer[4] = 0xe1; //al pa e1/d2
        writeSPI('W', RX_ADDR_P1, buffer, 5);

        //Data rate 1mbs
        buffer[0] = 0x03; //-12db
        writeSPI('W', RF_SETUP, buffer, 1);
    }else if(strcmp(func, "TX") == 0){
        //TX address
        buffer[0] = 0xf0;
        buffer[1] = 0xf0;
        buffer[2] = 0xf0;
        buffer[3] = 0xf0;
        buffer[4] = 0xe1;
        writeSPI('W', TX_ADDR, buffer, 5);

        //Rx0 address (auto acc)
        buffer[0] = 0xf0;
        buffer[1] = 0xf0;
        buffer[2] = 0xf0;
        buffer[3] = 0xf0;
        buffer[4] = 0xe1;
        writeSPI('W', RX_ADDR_P0, buffer, 5);

        //Rx1 address
        buffer[0] = 0xf0;
        buffer[1] = 0xf0;
        buffer[2] = 0xf0;
        buffer[3] = 0xf0;
        buffer[4] = 0xd2;
        writeSPI('W', RX_ADDR_P1, buffer, 5);

        //Data rate 1mbs
        buffer[0] = 0x07; ///0db
        writeSPI('W', RF_SETUP, buffer, 1);
    }

    //RF channel frequency
    buffer[0] = 0x4c;
    writeSPI('W', RF_CH, buffer, 1);

    //Enable RX addr 0 & 1
    buffer[0] = (1<<ERX_P0) | (1<<ERX_P1);
    writeSPI('W', EN_RXADDR, buffer, 1);

    //Pipe width
    buffer[0] = 0x20;
    writeSPI('W', RX_PW_P0, buffer, 1);
    buffer[0] = 0x20;
    writeSPI('W', RX_PW_P1, buffer, 1);

    //enable aa
    buffer[0] = (1<<ENAA_P0) | (1<<ENAA_P1) | (1<<ENAA_P2) | (1<<ENAA_P3) | (1<<ENAA_P4) | (1<<ENAA_P5);
    writeSPI('W', EN_AA, buffer, 1);


    //Setup_retr - retransmit and delay times
    buffer[0] = 0xff;
    writeSPI('W', SETUP_RETR, buffer, 1);

    //status -> clear bits
    buffer[0] = (1<<RX_DR) | (1<<TX_DS) | (1<<MAX_RT);
    writeSPI('W', STATUS, buffer, 1);

    writeSPI('C', FLUSH_TX, buffer, 1);
    writeSPI('C', FLUSH_RX, buffer, 1);
}

int main(int argc, char* argv[]){
    /*
     *  argv[1] == RX - receive
     *  argv[1] == TX - transmit
     */
    uint8_t stat;
    uint8_t* buffer;
    char c;
    int i;

    if(argc < 2){
        printf("Missing argument TX/RX\n");
    }

    buffer = (uint8_t*)malloc(sizeof(uint8_t)*20);

    initSPI();
    //READ conf
    writeSPI('R', CONFIG, buffer, 1);
    printf("CONFIG:\t 0x%02X\n",buffer[0]);
    //READ status
    writeSPI('R', STATUS, buffer, 1);
    printf("STATUS:\t 0x%02X\n", buffer[0]);

    buffer[0] = 0x7e;
    writeSPI('W', STATUS, buffer, 1);

    init(argv[1]);
    printOut();

    printf("ENTER to start\n");
    scanf("%c", &c);

    if(strcmp(argv[1], "RX") == 0){
        //RXmode
        //add PRIM_RX = 1 (rx mode) to CONFIG register
        writeSPI('R', CONFIG, buffer, 1);
        buffer[0] |= (1<<PRIM_RX);
        printf("CONFIG 2:\t 0x%02X\n",buffer[0]);
        writeSPI('W', CONFIG, buffer, 1);

        writeSPI('C', FLUSH_RX, buffer, 0);

        bcm2835_gpio_write(CE, HIGH); //CE high -> enable RX mode
        delay(1);
        while(1){
            writeSPI('R', STATUS, buffer, 1);
            printf("STATUS 1:\t 0x%02X\n", buffer[0]);
            if((buffer[0] & (1<<RX_DR)) == 1){
                //Read data
                writeSPI('R', R_RX_PAYLOAD, buffer, 20);
                printf("Read:\n");
                for(i = 0; i<20; i++){
                    printf("0x%02X ");
                }
                printf("\n");
                //write 1 to clear bit
                writeSPI('R', STATUS, buffer, 1);
                buffer[0] |= (1<<RX_DR);
                writeSPI('W', STATUS, buffer, 1);
                break;
            }


            delay(10);
        }
        bcm2835_gpio_write(CE, LOW);

    }else if(strcmp(argv[1], "TX") == 0){
        //TX mode
        writeSPI('R', STATUS, buffer, 1);
        printf("STATUS:\t 0x%02X, %d\n", buffer[0], (buffer[0] & (1<<TX_DS)));
        while((buffer[0] & (1<<TX_DS)) != 1){
            writeSPI('C', FLUSH_TX, buffer, 0);
            for(i = 0; i < 20; i++){
                buffer[i] = 17-(i%2);
            }
            writeSPI('C', W_TX_PAYLOAD, buffer, 20);
            bcm2835_gpio_write(CE, HIGH);
            delay(20);
            bcm2835_gpio_write(CE, LOW);
            printf("sent\n");

            writeSPI('R', STATUS, buffer, 1);
            printf("STATUS:\t 0x%02X, %d\n", buffer[0], (buffer[0] & (1<<TX_DS)));
            delay(10);
        }
    }

    bcm2835_spi_end();
    bcm2835_close();
}