程序如下：
#include <reg52.h>
#include <intrins.h>
typedef unsigned char uchar;
typedef unsigned int uint;

//*IO端口定义***
sbit MISO = P2^3;
sbit MOSI = P2^2;
sbit SCK = P2^1;
sbit CE  = P2^5;
sbit CSN = P2^0;
sbit IRQ = P3^2;

uchar  bdata sta; 
sbit RX_DR  = sta^6;
sbit TX_DS  = sta^5;
sbit MAX_RT = sta^4;

//***************NRF24L01*********
#define TX_ADR_WIDTH    5  
#define RX_ADR_WIDTH    5  
#define TX_PLOAD_WIDTH  32 
#define RX_PLOAD_WIDTH  32 

uchar const TX_ADDRESS[RX_ADR_WIDTH] = {0xb0,0x43,0x10,0x10,0x01}; //本地地址
uchar const RX_ADDRESS[RX_ADR_WIDTH] = {0xb0,0x43,0x10,0x10,0x01}; //接收地址

uchar Tx_Buf[TX_PLOAD_WIDTH] = " ";  //发送缓冲区，定义FIFO长度
uchar Rx_Buf[TX_PLOAD_WIDTH] = " ";  //接收缓冲区

//*********NRF24L01寄存器指令*****************
//******指令名称*******指令格式****指令操作***
#define R_REGISTER      0x00  // 读寄存器指令，指令格式为000* ****，* ****指出读操作的寄存器地址
#define W_REGISTER      0x20  // 写寄存器指令，指令格式为001* ****，* ****指出写操作的寄存器地址
#define R_RX_PAYLOAD    0x61  // 读取接收数据指令，接收模式使用
#define W_RX_PAYLOAD    0xA0  // 写待发数据指令，发射模式使用
#define FLUSH_TX        0xE1  // 清除发送缓存区FIFO的指令，发射模式使用
#define FLUSH_RX        0xE2  // 清除接收缓存区FIFO的指令，接收模式使用
#define REUSE_TX_PL     0xE3  // 重复装载数据指令，当CE=1时数据被不断重新发送
#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栈入栈出状态寄存器设置

uint n = 0,k,nrfFlag;

/**********延时函数***********/
//长延时
void Delay(uint s)
{
uint i,j;
for(i=0;i<1000;i++)
for(j=0;j<s;j++)；
}
//短延时
void delay_ms(uint x)
{
    uint i,j;
    i=0;
    for(i=0;i<x;i++)
    {
       j=108;
       while(j--);
    }
}

//*********IO口模拟SPI总线***********
uchar SPI_RW(uchar byte)//SPI边发送边接收，减少形参
{
    uchar bit_ctr;//位计数器（counter）
    for(bit_ctr=0;bit_ctr<8;bit_ctr++)
  {
    MOSI=(byte&0x80);
    byte=(byte<<1);  
    SCK=1;
    byte|=MISO;
    SCK=0;
  }
  return(byte);
}

uchar SPI_RW_Reg(uchar reg,uchar value) 
{

uchar status;
    CSN=0;
    status=SPI_RW(reg);
    SPI_RW(value);
    CSN=1;
    return(status);
}


{
    uchar reg_val;
    CSN=0;
    SPI_RW(reg);
    reg_val=SPI_RW(0);
    CSN=1;
    return(reg_val); 
}


uchar SPI_Write_Buf(uchar reg, uchar *pBuf, uchar bytes)
{
   uchar status,byte_ctr;
   CSN = 0;             
   status = SPI_RW(reg);  
   for(byte_ctr=0; byte_ctr<bytes; byte_ctr++) 
   SPI_RW(*pBuf++);  
   CSN = 1;              
   return(status);        
}

uchar SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
{
 uchar status,uchar_ctr;
 
 CSN = 0;             
 status = SPI_RW(reg);  
 
 for(uchar_ctr=0;uchar_ctr<uchars;uchar_ctr++)
  pBuf[uchar_ctr] = SPI_RW(0);    
 
 CSN = 1;           
 return(status);       
}

void init_NRF(void)
{
CE = 0;

   SPI_Write_Buf(W_REGISTER + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    // Writes TX_Address to nRF24L01
   SPI_Write_Buf(W_REGISTER + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // RX_Addr0 same as TX_Adr for Auto.Ack
  
SPI_RW_Reg(W_REGISTER + RX_PW_P0, RX_PLOAD_WIDTH); // Select same RX payload width as TX Payload width
   SPI_RW_Reg(W_REGISTER + EN_AA, 0x01);      // 关闭通道0自动应答
   SPI_RW_Reg(W_REGISTER + EN_RXADDR, 0x01);  // Enable Pipe0

SPI_RW_Reg(W_REGISTER + SETUP_RETR, 0x1a); // 500us + 86us, 10 retrans...
   SPI_RW_Reg(W_REGISTER + RF_CH, 0);        // Select RF channel 40
   SPI_RW_Reg(W_REGISTER + RF_SETUP, 0x07);   // TX_PWR:0dBm, Datarate:2Mbps, LNA:HCURR
  
CE=1;
}


void TX_Mode(uchar *Tx_Buf)
{
CE = 0;
  SPI_Write_Buf(W_REGISTER + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);
SPI_Write_Buf(W_RX_PAYLOAD, Tx_Buf, TX_PLOAD_WIDTH);//将从PC机传到单片机中的数据放入发送缓存区中
 
   SPI_RW_Reg(W_REGISTER + CONFIG, 0x0e);//CONFIG设置为0x0e是发射模式！！
CE = 1;
delay_ms(150);
}

 
void RX_Mode(void)
{
 CE=0;
 SPI_RW_Reg(FLUSH_RX,0x00);
 SPI_RW_Reg(W_REGISTER + CONFIG, 0x0f);//CONFIG设置为0f是接收模式，中断产生时IRQ引脚为低电平
 CE=1;
 delay_ms(150);
}


void init_SPI(void)
{
CE = 0; // chip enable
CSN = 1; // Spi disable
SCK = 0; // Spi clock line init high
}

    

//***********串口初始化************
void init_UART(void)
{    //波特率9600
     SCON = 0x50; 
 TMOD = 0x20; 
 TH1 = 0xFD;  
 TL1 = 0xFD;
     PCON = 0x00;//电源控制寄存器，只有SMOD位与串行口有关（波特率倍增）
     TR1 = 1;

 SM0 = 0;
 SM1 = 1;//串口工作于方式1,10位异步收发（1位起始位，8位数据位，1位停止位），波特率由定时器控制

 ES = 1;    //串行口中断允许位；
 EX0 = 1;              // 外部中断0开
   IT0 = 0;              // 外部中断0触发中断控制位(为1则为下降沿触发)

 EA = 1;    //CPU中断允许（总允许）位
}


void Send_Byte_To_PC(uchar R_Byte)//通过串口将数据发送给PC端（数据到SBUF后会自动传递到PC机）
{
ES = 0;
SBUF = R_Byte;
while(!TI);
TI = 0;

ES = 1;
}

void SendReceive_To_PC(uchar *pBuf,char width)
{
uchar byte_ctr;

   for(byte_ctr=0;byte_ctr<width;byte_ctr++)
{
Send_Byte_To_PC(pBuf[byte_ctr]);
}
}

//**********主函数************
void main()
{
int i = 0;
delay_ms(1000);
P0 = 0x88;
init_UART();
init_SPI();
init_NRF();

nrfFlag=0;
   
RX_Mode();
Delay(10);

while(1)
{
if( nrfFlag == 1 )
{
EX0 = 0;
nrfFlag = 0;
SendReceive_To_PC(Rx_Buf,RX_PLOAD_WIDTH);//将接收到的数据传递给PC
EX0 = 1;
P0 = 0x55;
}
else if(nrfFlag == 2)
{
EX0 = 0;
nrfFlag = 0;
Send_Byte_To_PC('A');//向PC端发送一个返回值A，表示发送成功
P0 = 0xf0;
SPI_RW_Reg(FLUSH_TX,0);
RX_Mode();//发送完后置为接收模式
EX0 = 1;
}
else if(nrfFlag == 3)
{
nrfFlag = 0;
Send_Byte_To_PC('C');//向PC端发送一个返回值B，表示重发
P0 = 0xaa;
TX_Mode(Tx_Buf);
}
else if(nrfFlag == 4)
{
 nrfFlag = 0;
 TX_Mode(Tx_Buf);
}
}
}

//-------------------------------------------------------------------
//INT0中断  由P3.2引脚产生

void int_0() interrupt 0 using 0//外部中断标号0
{
sta = SPI_Read(STATUS); // read register STATUS's value

if(RX_DR) // if receive data ready (RX_DR) interrupt
{
SPI_Read_Buf(R_RX_PAYLOAD,Rx_Buf,RX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
SPI_RW_Reg(FLUSH_RX,0);
nrfFlag = 1;
}
else if(MAX_RT)
{
SPI_RW_Reg(FLUSH_TX,0);
nrfFlag = 3;
}
else if(TX_DS)
{
nrfFlag = 2;
}
SPI_RW_Reg(W_REGISTER+STATUS,sta);
}

void ser() interrupt 4 using 3//
{
RI = 0;

while(Tx_Buf[k] != '\0')
{
Tx_Buf[n] = SBUF;
n++;
}
nrfFlag = 4;
}


比如发送一个99，收到32个9，不知道怎么回事

2 个解决方案