原创 NRF24l01

NRF24l01

产品性能：
1） 2.4GHZ全球开放ISM频段免许可使用
2） 最高工作速率1Mbps,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
}

QQ:1002421875 MSN:yunjiakeji@hotmail.com
Skype:yunjiakeji EMAIL:myb33695@163.com
PHONE:13430970167    http://shop35991384.taobao.com