NRF24L01数据通信C程序

NRF24l01

产品性能：

1） 2.4GHZ全球开放ISM频段免许可使用

2） 最高工作速率2Mbps,GFSK高效调制

3） 125个频道满足多点通讯和跳频通讯需求

4） 1.9-3.6V工作，低功耗，待机模式仅1uA.

5） 双通道数据接收，内置环行天线，体积仅17*34mm,通信距离在100m之内，软件编简单。

7） 内置硬件8/16位CRC校验，收发中断标志，每次可发28字节

备注：1。免费提供开发源代码

           2。提供廉价开发套件

          3。提供全面技术支持和即使方案

         4。任何单片机都可实现对NRF系列模块的数据收发控制，

#define uchar unsigned char

#define TX_ADR_WIDTH    5   // 5 bytes TX(RX) address width

#define TX_PLOAD_WIDTH  20  // 20 bytes TX payload

uchar const TX_ADDRESS[TX_ADR_WIDTH]  = {0x34,0x43,0x10,0x10,0x01}; // Define a static TX address

uchar rx_buf[TX_PLOAD_WIDTH];     //接收缓冲区

uchar tx_buf[TX_PLOAD_WIDTH];      //发送缓冲区

uchar flag;

/**************************************************/

//管脚定义

sbit CE =  P1^0;

sbit CSN=  P1^1;

sbit SCK=  P1^2;

sbit MOSI= P1^3;

sbit MISO= P1^4;

sbit IRQ = P1^5;

/**************************************************/

uchar  bdata sta;

sbit RX_DR =sta^6;

sbit TX_DS =sta^5;

sbit MAX_RT =sta^4;

/**************************************************/

/**************************************************

Function: init_io();

Description:

  flash led one time,chip enable(ready to TX or RX Mode),

  Spi disable,Spi clock line init high

/**************************************************/

#define KEY 0xaa

void init_io(void)

{

 P0=KEY;  // led light

 CE=0;   // chip enable

 CSN=1;   // Spi disable

 SCK=0;   // Spi clock line init high

 P0=0xff;  // led close

}

/**************************************************/

/**************************************************

Function: Inituart();

Description:

  set uart working mode

/**************************************************/

void Inituart(void)

{

 TMOD = 0x20;    //timer1 working mode 1

 TL1 = 0xfd;     //f7=9600 for 16mhz Fosc,and ...

 TH1 = 0xfd;     //...fd=19200 for 11.0592mhz Fosc

 SCON = 0xd8;    //uart mode 3,ren==1

 PCON = 0x80;    //smod=0

 TR1 = 1;     //start timer1

}

/**************************************************/

/**************************************************

Function: init_int0();

Description:

  enable int0 interrupt;

/**************************************************/

void init_int0(void)

{

 EA=1;

 EX0=1;      // Enable int0 interrupt.

}

/**************************************************/

/**************************************************

Function: delay100();

Description:

  delay 100ms

/**************************************************

void delay(uchar )

{

 uchar  x;

 uchar  y;

 for(x=0;x<100;x++)

 {

  for(y=0;y<100;y++)

  _nop_();

 }

}

/**************************************************/

void delay_ms(unsigned int x)

{

    unsigned int i,j;

    i=0;

    for(i=0;i<x;i++)

    {

       j=108;

           ;

       while(j--);

    }

}

/**************************************************/

/**************************************************

Function: SPI_RW();

Description:

  Writes one byte to nRF24L01, and return the byte read

  from nRF24L01 during write, according to SPI protocol

/**************************************************/

uchar SPI_RW(uchar byte)

{

 uchar bit_ctr;

    for(bit_ctr=0;bit_ctr<8;bit_ctr++)   // output 8-bit

    {

     MOSI = (byte & 0x80);         // output 'byte', MSB to MOSI

     byte = (byte << 1);           // shift next bit into MSB..

     SCK = 1;                      // Set SCK high..

     byte |= MISO;           // capture current MISO bit

     SCK = 0;                // ..then set SCK low again

    }

    return(byte);               // return read byte

}

/**************************************************/

/**************************************************

Function: SPI_RW_Reg();

Description:

  Writes value 'value' to register 'reg'

/**************************************************/

uchar SPI_RW_Reg(BYTE reg, BYTE value)

{

 uchar status;

   CSN = 0;                   // CSN low, init SPI transaction

   status = SPI_RW(reg);      // select register

   SPI_RW(value);             // ..and write value to it..

   CSN = 1;                   // CSN high again

   return(status);            // return nRF24L01 status byte

}

/**************************************************/

/**************************************************

Function: SPI_Read();

Description:

  Read one byte from nRF24L01 register, 'reg'

/**************************************************/

BYTE SPI_Read(BYTE reg)

{

 BYTE reg_val;

   CSN = 0;                // CSN low, initialize SPI communication...

   SPI_RW(reg);            // Select register to read from..

   reg_val = SPI_RW(0);    // ..then read registervalue

   CSN = 1;                // CSN high, terminate SPI communication

   return(reg_val);        // return register value

}

/**************************************************/

/**************************************************

Function: SPI_Read_Buf();

Description:

  Reads 'bytes' #of bytes from register 'reg'

  Typically used to read RX payload, Rx/Tx address

/**************************************************/

uchar SPI_Read_Buf(BYTE reg, BYTE *pBuf, BYTE bytes)

{

 uchar status,byte_ctr;

   CSN = 0;                      // Set CSN low, init SPI tranaction

   status = SPI_RW(reg);         // Select register to write to and read status byte

   for(byte_ctr=0;byte_ctr<bytes;byte_ctr++)

     pBuf[byte_ctr] = SPI_RW(0);    // Perform SPI_RW to read byte from nRF24L01

   CSN = 1;                           // Set CSN high again

   return(status);                    // return nRF24L01 status byte

}

/**************************************************/

/**************************************************

Function: SPI_Write_Buf();

Description:

  Writes contents of buffer '*pBuf' to nRF24L01

  Typically used to write TX payload, Rx/Tx address

/**************************************************/

uchar SPI_Write_Buf(BYTE reg, BYTE *pBuf, BYTE bytes)

{

 uchar status,byte_ctr;

   CSN = 0;                   // Set CSN low, init SPI tranaction

   status = SPI_RW(reg);    // Select register to write to and read status byte

   for(byte_ctr=0; byte_ctr<bytes; byte_ctr++) // then write all byte in buffer(*pBuf)

     SPI_RW(*pBuf++);

   CSN = 1;                 // Set CSN high again

   return(status);          // return nRF24L01 status byte

}

/**************************************************/

/**************************************************

Function: RX_Mode();

Description:

  This function initializes one nRF24L01 device to

  RX Mode, set RX address, writes RX payload width,

  select RF channel, datarate & LNA HCURR.

  After init, CE is toggled high, which means that

  this device is now ready to receive a datapacket.

/**************************************************/

void RX_Mode(void)

{

 CE=0;

   SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // Use the same address on the RX device as the TX device

   SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      // Enable Auto.Ack:Pipe0

   SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  // Enable Pipe0

   SPI_RW_Reg(WRITE_REG + RF_CH, 40);        // Select RF channel 40

   SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH); // Select same RX payload width as TX Payload width

   SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);   // TX_PWR:0dBm, Datarate:2Mbps, LNA:HCURR

   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);     // Set PWR_UP bit, enable CRC(2 bytes) & Prim:RX. RX_DR enabled..

   CE = 1; // Set CE pin high to enable RX device

  //  This device is now ready to receive one packet of 16 bytes payload from a TX device sending to address

  //  '3443101001', with auto acknowledgment, retransmit count of 10, RF channel 40 and datarate = 2Mbps.

}

/**************************************************/

/**************************************************

Function: TX_Mode();

Description:

  This function initializes one nRF24L01 device to

  TX mode, set TX address, set RX address for auto.ack,

  fill TX payload, select RF channel, datarate & TX pwr.

  PWR_UP is set, CRC(2 bytes) is enabled, & PRIM:TX.

  ToDo: One high pulse(>10us) on CE will now send this

  packet and expext an acknowledgment from the RX device.

/**************************************************/

void TX_Mode(void)

{

 CE=0;

  

   SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    // Writes TX_Address to nRF24L01

   SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // RX_Addr0 same as TX_Adr for Auto.Ack

   SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH); // Writes data to TX payload

   SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      // Enable Auto.Ack:Pipe0

   SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  // Enable Pipe0

   SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x1a); // 500us + 86us, 10 retrans...

   SPI_RW_Reg(WRITE_REG + RF_CH, 40);        // Select RF channel 40

   SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);   // TX_PWR:0dBm, Datarate:2Mbps, LNA:HCURR

   SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);     // Set PWR_UP bit, enable CRC(2 bytes) & Prim:TX. MAX_RT & TX_DS enabled..

 CE=1;

}

/**************************************************/

/**************************************************

Function: check_ACK();

Description:

  check if have "Data sent TX FIFO interrupt",if TX_DS=1,

  all led light and after delay 100ms all led close

/**************************************************

void check_ACK()

{

 uchar test;

 test=SPI_Read(READ_REG+STATUS); // read register STATUS's

 test=test&0x20;     // check if have Data sent TX FIFO interrupt (TX_DS=1)

 if(test==0x20)     // TX_DS =1

 {

  P0=0x00;     // turn on all led

     delay100();     // delay 100ms

  P0=0xff;

 }

}

/**************************************************/

/**************************************************

Function: TxData();

Description:

  write data x to SBUF

/**************************************************/

void TxData (uchar x)

{

 SBUF=x;   // write data x to SBUF

 while(TI==0);

  TI=0;

}

/**************************************************/

/**************************************************

Function: CheckButtons();

Description:

  check buttons ,if have press,read the key values,

  turn on led and transmit it;  after transmition,

  if received ACK, clear TX_DS interrupt and enter RX Mode;

  turn off the led

/**************************************************/

void CheckButtons()

{

 uchar Temp,xx,Tempi;

 P0=0xff;

 Temp=P0&KEY;            //read key value from port P0

 if (Temp!=KEY)

 {

  delay_ms(10);

  Temp=P0&KEY;    // read key value from port P0

  if (Temp!=KEY)

  {

    xx=Temp;

    Tempi=Temp>>1;  // Left shift 4 bits

    P0=Tempi;      // Turn On the led

    tx_buf[0]=Tempi; // Save to tx_buf[0]

    TX_Mode();   // set TX Mode and transmitting

    TxData(xx);   // send data to uart

    //check_ACK();  // if have acknowledgment from RX device,turn on all led

    SPI_RW_Reg(WRITE_REG+STATUS,SPI_Read(READ_REG+STATUS)); // clear interrupt flag(TX_DS)

    delay_ms(500);

    P0=0xff;   // Turn off the led   

    RX_Mode();   // set receive mode

    while((P0&KEY)!=KEY);

  }

 }

}

/**************************************************/

/**************************************************

Function: main();

Description:

  control all subprogrammes;

/**************************************************/

void main(void)

{

 uchar xx;

 init_io();  // Initialize IO port

 Inituart();  // initialize 232 uart

 //init_int0(); // enable int0 interrupt

 RX_Mode();  // set RX mode

 while(1)

 {

  CheckButtons(); // scan key value and transmit

  sta=SPI_Read(STATUS); // read register STATUS's value

     if(RX_DR)    // if receive data ready (RX_DR) interrupt

       {

     SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer

     flag=1;

          }

     if(MAX_RT)

       {

     SPI_RW_Reg(FLUSH_TX,0);

          }

  SPI_RW_Reg(WRITE_REG+STATUS,sta);// clear RX_DR or TX_DS or MAX_RT interrupt flag

  if(flag)  // finish received

  {

   flag=0;  // set flag=0

   P0=rx_buf[0]; // turn on led

   delay_ms(500);

     P0=0xff;  // turn off led

   xx=rx_buf[0]>>1;// right shift 4 bits

   TxData(xx);  // send data to uart

  }

 }

}

/**************************************************/

/**************************************************

Function: ISR_int0() interrupt 0;

Description:

  if RX_DR=1 or TX_DS or MAX_RT=1,enter this subprogram;

  if RX_DR=1,read the payload from RX_FIFO and set flag;

/**************************************************/

void ISR_int0(void) interrupt 0

{

 sta=SPI_Read(STATUS); // read register STATUS's value

 if(RX_DR)    // if receive data ready (RX_DR) interrupt

 {

  SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer

  flag=1;

 }

 if(MAX_RT)

 {

  SPI_RW_Reg(FLUSH_TX,0);

 }

  SPI_RW_Reg(WRITE_REG+STATUS,sta);// clear RX_DR or TX_DS or MAX_RT interrupt flag

}

/**************************************************/