关于NRF24L01的问题。。。求指导。。。

言午 · 发表于 2011-8-1 19:21:18

#include<reg51.h> 
 #include<intrins.h> 
 #define uchar unsigned char 
 #define uint unsigned int 
 sbit k1=P3^2; 
 sbit k2=P3^3; 
 sbit k3=P3^4; 
 sbit LED0=P0^0; 
 sbit LED1=P0^1; 
 sbit LED2=P0^2;
 uchar Txbuf[]={0x01,0x03,0x03,0x01}; 
  /************************************** 
  ********延时*********** 
  void Delay(uint i) 
  { 
       uint j; 
    for(;i>0;i--) 
    for(j=0;j++;j<125) 
    {;} 
    }  */ 
/**************************************** 
**********NRF24L01 端口定义**********************/ 
sbit IRQ=P2^7; 
sbit SCK=P2^1; 
sbit CE=P2^2; 
sbit CSN=P2^5; 
sbit MOSI=P2^6; 
sbit MISO=P2^0;
#define TX_ADR_WIDTH    5    // 5 uints TX address width 
#define RX_ADR_WIDTH    5    // 5 uints RX address width 
#define TX_PLOAD_WIDTH  32  // 20 uints TX payload 
#define RX_PLOAD_WIDTH  32   // 20 uints TX payload 
uint const TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01}; //本地地址 
uint const RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01}; //接收地址 
//***************************************NRF24L01寄存器指令******************************************************* 
#define READ_REG        0x00   // 读寄存器指令 
#define WRITE_REG       0x20  // 写寄存器指令 
#define RD_RX_PLOAD     0x61   // 读取接收数据指令 
#define WR_TX_PLOAD     0xA0   // 写待发数据指令 
#define FLUSH_TX        0xE1  // 冲洗发送 FIFO指令 
#define FLUSH_RX        0xE2   // 冲洗接收 FIFO指令 
#define REUSE_TX_PL     0xE3   // 定义重复装载数据指令 
#define NOP             0xFF   // 保留 
//*************************************SPI(nRF24L01)寄存器地址**************************************************** 
#define CONFIG          0x00  // 配置收发状态，CRC校验模式以及收发状态响应方式 
#define EN_AA           0x01  // 自动应答功能设置 
#define EN_RXADDR       0x02  // 可用信道设置 
#define SETUP_AW        0x03  // 收发地址宽度设置 
#define SETUP_RETR      0x04  // 自动重发功能设置 
#define RF_CH           0x05  // 工作频率设置 
#define RF_SETUP        0x06  // 发射速率、功耗功能设置 
#define STATUS          0x07  // 状态寄存器 
#define OBSERVE_TX      0x08  // 发送监测功能 
#define CD              0x09  // 地址检测           
#define RX_ADDR_P0      0x0A  // 频道0接收数据地址 
#define RX_ADDR_P1      0x0B  // 频道1接收数据地址 
#define RX_ADDR_P2      0x0C  // 频道2接收数据地址 
#define RX_ADDR_P3      0x0D  // 频道3接收数据地址 
#define RX_ADDR_P4      0x0E  // 频道4接收数据地址 
#define RX_ADDR_P5      0x0F  // 频道5接收数据地址 
#define TX_ADDR         0x10  // 发送地址寄存器 
#define RX_PW_P0        0x11  // 接收频道0接收数据长度 
#define RX_PW_P1        0x12  // 接收频道0接收数据长度 
#define RX_PW_P2        0x13  // 接收频道0接收数据长度 
#define RX_PW_P3        0x14  // 接收频道0接收数据长度 
#define RX_PW_P4        0x15  // 接收频道0接收数据长度 
#define RX_PW_P5        0x16  // 接收频道0接收数据长度 
#define FIFO_STATUS     0x17  // FIFO栈入栈出状态寄存器设置 
//************************************************************************************** 
void Delay(unsigned int s); 
void inerDelay_us(unsigned char n); 
void init_NRF24L01(void); 
uint SPI_RW(uint uhar); 
uchar SPI_Read(uchar reg); 
void SetRX_Mode(void); 
uint SPI_RW_Reg(uchar reg, uchar value); 
uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars); 
uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars); 
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf); 
int nRF24L01_TxPacket(unsigned char * tx_buf); 
//*****************************************长延时***************************************** 
void Delay(unsigned int s) 
{ 
 unsigned int i; 
 for(i=0; i<s; i++); 
 for(i=0; i<s; i++); 
} 
//****************************************************************************************** 
uint  bdata sta;   //状态标志 
sbit RX_DR =sta^6; 
sbit TX_DS =sta^5; 
sbit MAX_RT =sta^4; 
/****************************************************************************************** 
/*延时函数 
/******************************************************************************************/ 
void inerDelay_us(unsigned char n) 
{ 
 for(;n>0;n--) 
  _nop_(); 
} 
//**************************************************************************************** 
/*NRF24L01初始化 
//***************************************************************************************/ 
void init_NRF24L01(void) 
{ 
   // inerDelay_us(100); 
  CE=0;    // chip enable 
  CSN=1;   // Spi disable 
  SCK=0;   // Spi clock line init high 
    IRQ = 1;        // 中断复位 
} 
/**************************************************************************************************** 
/*函数：uint SPI_RW(uint uchar) 
/*功能：NRF24L01的SPI写时序 
/****************************************************************************************************/ 
uint SPI_RW(uint uhar) 
{ 
 uint bit_ctr; 
    for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit 
    { 
  MOSI = (uhar & 0x80);         // output 'uchar', MSB to MOSI 
  uhar = (uhar << 1);           // shift next bit into MSB.. 
  SCK = 1;                      // Set SCK high.. 
  uhar |= MISO;           // capture current MISO bit 
  SCK = 0;                // ..then set SCK low again 
    } 
    return(uhar);               // return read uchar 
} 
/**************************************************************************************************** 
/*函数：uchar SPI_Read(uchar reg) 
/*功能：NRF24L01的SPI时序 
/****************************************************************************************************/ 
uchar SPI_Read(uchar reg) 
{ 
 uchar 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 
} 
/****************************************************************************************************/ 
/*功能：NRF24L01读写寄存器函数 
/****************************************************************************************************/ 
uint SPI_RW_Reg(uchar reg, uchar value) 
{ 
 uint 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 uchar 
} 
/****************************************************************************************************/ 
/*函数：uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars) 
/*功能: 用于读数据，reg：为寄存器地址，pBuf：为待读出数据地址，uchars：读出数据的个数 
/****************************************************************************************************/ 
uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars) 
{ 
 uint status,uchar_ctr; 
  
 CSN = 0;                      // Set CSN low, init SPI tranaction 
 status = SPI_RW(reg);         // Select register to write to and read status uchar 
  
 for(uchar_ctr=0;uchar_ctr<uchars;uchar_ctr++) 
  pBuf[uchar_ctr] = SPI_RW(0);    // 
  
 CSN = 1;                           
  
 return(status);                    // return nRF24L01 status uchar 
} 
/********************************************************************************************************* 
/*函数：uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars) 
/*功能: 用于写数据：为寄存器地址，pBuf：为待写入数据地址，uchars：写入数据的个数 
/*********************************************************************************************************/ 
uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars) 
{ 
 uint status,uchar_ctr; 
  
 CSN = 0;            //SPI使能       
 status = SPI_RW(reg);   
 for(uchar_ctr=0; uchar_ctr<uchars; uchar_ctr++) // 
  SPI_RW(*pBuf++); 
 CSN = 1;           //关闭SPI 
 return(status);    // 
} 
/****************************************************************************************************/ 
/*函数：void SetRX_Mode(void) 
/*功能：数据接收配置 
/****************************************************************************************************/ 
void SetRX_Mode(void) 
{ 
 CE=0; 
// SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);     // IRQ收发完成中断响应，16位CRC ，主接收 
 CE = 1; 
 inerDelay_us(200); 
} 
/*************************************************     / 
/************************发送设置*******************************/ 
void SetTX_Mode() 
{
CE=0; 
SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH); 
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); 
//SPI_Write_Buf(WR_TX_PLOAD, Txbuf, TX_PLOAD_WIDTH); // Writes data to TX payload 
SPI_RW_Reg(WRITE_REG + EN_AA, 0x01); // Enable Auto.Ack

ipe0 
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, 0x0F); // 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; 
inerDelay_us(20); 
}
 
/******************************************************************************************************/ 
/*函数：unsigned char nRF24L01_RxPacket(unsigned char* rx_buf) 
/*功能：数据读取后放如rx_buf接收缓冲区中 
/******************************************************************************************************/ 
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf) 
{ 
    unsigned char revale=0; 
 sta=SPI_Read(STATUS); // 读取状态寄存其来判断数据接收状况 
 if(RX_DR)    // 判断是否接收到数据 
 { 
     CE = 0;    //SPI使能 
  SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer 
  revale =1;   //读取数据完成标志 
 } 
 SPI_RW_Reg(WRITE_REG+STATUS,sta);   //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志 
 return revale; 
} 
/*********************************************************************************************************** 
/*函数：void nRF24L01_TxPacket(unsigned char * tx_buf) 
/*功能：发送 tx_buf中数据 
/**********************************************************************************************************/ 
void Test(uchar R_Byte); 
///////////////////////////////////////////////////////// 
int nRF24L01_TxPacket(unsigned char * tx_buf) 
{ 
 CE=0;   //StandBy I模式 
 SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH);     // 装载数据 
 CE=1;   //置高CE，激发数据发送 
 Delay(10); 
 while(IRQ);  
 sta = SPI_RW(STATUS);                    // 返回状态寄存器 
//   Test(sta); 
      SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志 
 if(MAX_RT) 
                          // 是否清除TX FIFO，没有清除在复位MAX_RT中断标志后重发 
  { //  SPI_RW(FLUSH_TX); 
 SPI_RW_Reg(FLUSH_TX,0xff); 
 LED2=0; 
 } 
 Delay(50); 
// IRQ = 1; 
 if(TX_DS) 
 { 
 SPI_RW_Reg(WRITE_REG + STATUS, sta); 
  return(1); 
  } 
 else 
  return(0); 
}
//检测24L01是否存在 
//返回值:0，成功;1，失败  
int NRF24L01_Check(void) 
{ 
 uchar buf[5]={0XA5,0XA5,0XA5,0XA5,0XA5}; 
 uchar i; 
     
 SPI_Write_Buf(WRITE_REG+TX_ADDR,buf,5);//写入5个字节的地址.  
 SPI_Read_Buf(TX_ADDR,buf,5); //读出写入的地址  
 for(i=0;i<5;i++)if(buf!=0XA5)break;            
 if(i!=5)return 1;//检测24L01错误  
 return 0;   //检测到24L01 
}    
//************************************串口初始化********************************************************* 
void StartUART( void ) 
{         //波特率4800 
     SCON = 0x50; 
     TMOD = 0x20; 
     TH1 = 0xFA; 
     TL1 = 0xFA; 
     PCON = 0x00; 
     TR1 = 1; 
} 
//************************************通过串口将接收到数据发送给PC端************************************** 
void Test(uchar R_Byte) 
{  
  SBUF = R_Byte;  
     while( TI == 0 );    //查询法 
    TI = 0;    
} 
//************************************主函数************************************************************ 
void main(void) 
{ 
    
 uchar i,temp; 
// uchar RxBuf[32];  
    init_NRF24L01(); 
// led0=0;led1=0;led2=0;led3=0; 
 StartUART(); 
 Delay(100); 
 SetTX_Mode();  P0=0xff; 
 while(1) 
 {
  while(NRF24L01_Check()!=0) //不在位 
       {LED2=~LED2; 
     Delay(1000); 
     
   }      
    if(nRF24L01_TxPacket(Txbuf)==1) // 发送成功 
    { 
       LED0=~LED0; 
    Delay(1000); 
    
    }
    if(nRF24L01_TxPacket(Txbuf)==0)  //发送失败 
    { 
       LED1=~LED1; 
    Delay(1000); 
    } 
  
      Delay(50000); 
  } 
 
}  
 
 
这个代码哪里出问题了？咋就是发送不成功？