关于nrf2401收发的问题

郭佳YI

请各位大神看一下我的程序，我想实现的是键盘按一下改变Txbuf【1】的值然后导致另一个板子Rxbuf【1】值改变 导致判断LED灯亮我的逻辑是 按一下键盘后 小灯就一直亮 可是事实是我只有按一下小灯才亮一下，这是为什么啊！！ 我按一下Txbuf【1】的值不久变为1，且固定住 以后每次循环发送都是发送Txbuf【1】=1 过去 接受的也是1吗。。。？




下面是我的接受程序：
#include <reg52.h>
#include <intrins.h>
#include <stdio.h>

typedef unsigned char uchar;
typedef unsigned char uint;

sbit        CE          =P1^0;
sbit        CSN                =P1^1;
sbit        SCK          =P1^2;
sbit         MOSI        =P1^3;
sbit         MISO        =P1^4;
sbit        IRQ                =P1^5;

sbit  key1 = P3^4;
sbit  key2 = P3^5;

sbit beep = P2^3;
sbit LED=P1^7;

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

#define TX_ADR_WIDTH    5           // 5 个字节的发送地址长度
#define RX_ADR_WIDTH    5           // 5个字节的接收地址长度
#define TX_PLOAD_WIDTH  32          // 32个字节的发送数据长度
#define RX_PLOAD_WIDTH  32     //

uint const TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};        //本地地址
uint const RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01};        //接收地址
uchar M[8];
float v,h;
uchar flag;
uchar a;
uchar RxBuf[32];

#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(uint s);
void Delay_us(uchar n);
void init_NRF24L01(void);
uint SPI_RW(uint uchar);
uchar SPI_Read(uchar reg);
void RX_mode();
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);
uchar nRF24L01_RxPacket(uchar* rx_buf);

void Delay(uint s)
{
        uint i;
        for(i=0; i<s; i++);
        for(i=0; i<s; i++);
}

//微秒延时
void Delay_us(uchar n)
{
        for(;n>0;n--)
                _nop_();
}
//SPI写时序
uint SPI_RW(uint uchar)
{
        uint bit_ctr;
           for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit
           {
                MOSI = (uchar & 0x80);         // output 'uchar', MSB to MOSI
                uchar = (uchar << 1);           // shift next bit into MSB..
                SCK = 1;                      // Set SCK high..
                uchar |= MISO;                         // capture current MISO bit
                SCK = 0;                              // ..then set SCK low again
           }
    return(uchar);                             // return read uchar
}
//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
}
//SPI读写寄存器
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
}
//用于读数据，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
}
//功能: 用于写数据：为寄存器地址，
//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);    //
}


//2401初始化
void init_NRF24L01(void)
{
        Delay_us(100);
        CE=0;
        CSN=1;
        SCK=0;
        SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    // 写本地地址
        SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // 写接收端地址
        SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      //  频道0自动 ACK应答允许
        SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  //  允许接收地址只有频道0，如果需要多频道可以参考Page21  
        SPI_RW_Reg(WRITE_REG + RF_CH, 0);        //   设置信道工作为2.4GHZ，收发必须一致
        SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为32字节
        SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);     //设置发射速率为1MHZ，发射功率为最大值0dB
}

//接收模式初始化
void RX_mode()
{
        CE=0;
  SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);     //配置基本工作模式的参数WR_UP,EN_CRC,16BIT_CRC,接收模式
  CE = 1; // 使能发送
        Delay_us(130);
}
//数据接收包
uchar nRF24L01_RxPacket(unsigned char* rx_buf)
{
//        uchar flag;
        flag=0;
        sta=SPI_Read(STATUS);        // 读取寄存器
        if(RX_DR)                                // 判断是否收到数据
        {
                CE=0;
                SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);//读取数据                flag=1;        //读取完成标志
                flag=1;
       
        }
                SPI_RW_Reg(WRITE_REG+STATUS,sta);  
        return flag;
}

// void Beep()
// {
//         beep=0;
//         Delay_us(10);
//         beep=1;
// }
       
void  SendChar(uchar t)
{
    SBUF=t;
    while(TI==0);
    TI=0;            
}
  void SendStrings(uchar *str)
{
     while(*str)
         {
          SendChar(*str);
          str++;
         }
}
void T2_init()//串口
{
          RCAP2H=0xff;   
                RCAP2L=0xdc;
                TH2=RCAP2H;
                TL2=RCAP2L;
                T2CON=0x34;   
                SCON=0x50;   
                PCON=0x00;
          EA=1;
                ES=1;
}
//主函数
void main()
{
       
//        uchar RxBuf[32];
        T2_init();
        init_NRF24L01();
        RX_mode();
        Delay(6000);

        while(1)
        {
                RX_mode();
               
         nRF24L01_RxPacket(RxBuf);
                if(RxBuf[1]==1)
                {
                LED=0;
               
                }
                else
                LED=1;


这是我的发送程序：
#include <reg52.h>
#include <intrins.h>
#include <stdio.h>

typedef unsigned char uchar;
typedef unsigned char uint;


sbit        CE          =P1^0;
sbit        CSN                =P1^1;
sbit        SCK          =P1^2;
sbit         MOSI        =P1^3;
sbit         MISO        =P1^4;
sbit        IRQ                =P1^5;

sbit count = P2^0;

sbit  key1 = P3^4;
sbit  key2 = P3^5;
sbit  key3 = P2^4;
sbit  key4 = P2^5;

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

float v,flag;
char M[3];
//uchar TxBuf[32];

uchar TxBuf[32]=
{
0x01,0x02,0x03,0x4,0x05,0x06,0x07,0x08,
0x09,0x10,0x11,0x12,0x13,0x14,0x15,0x16,
0x17,0x18,0x19,0x20,0x21,0x22,0x23,0x24,
0x25,0x26,0x27,0x28,0x29,0x30,0x31,0x32,
};

#define TX_ADR_WIDTH    5           // 5 个字节的发送地址长度
#define RX_ADR_WIDTH    5           // 5个字节的接收地址长度
#define TX_PLOAD_WIDTH  32          // 32个字节的发送数据长度
#define RX_PLOAD_WIDTH  32     //

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

#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栈入栈出状态寄存器设

// #define MAX_TX                  0x10  //达到最大发送次数中断
// #define TX_OK                   0x20  //TX发送完成中断

void Delay(uint s);
void Delay_us(uchar n);
void Delay_ms(uint uchar);
void init_NRF24L01(void);
uint SPI_RW(uint uchar);
// uchar SPI_Read(uchar reg);
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);
void nRF24L01_TxPacket(uchar * tx_buf);


void T2_init()//串口
{
          RCAP2H=0xff;   
                RCAP2L=0xdc;
                TH2=RCAP2H;
                TL2=RCAP2L;
                T2CON=0x34;   
                SCON=0x50;   
                PCON=0x00;
          EA=1;
}
void  SendChar(uchar t)
{
    SBUF=t;
    while(TI==0);
    TI=0;            
}
  void SendStrings(uchar *str)
{
     while(*str)
         {
          SendChar(*str);
          str++;
         }
}
void Delay(uint s)
{
        uint i;
        for(i=0; i<s; i++);
        for(i=0; i<s; i++);
}
//毫秒延时
void Delay_ms(uint s)
{
        unsigned int i;
        for(i=0; i<s; i++);
          for(i=110; i>0; i--);
}

//微秒延时
void Delay_us(uchar n)
{
        for(;n>0;n--)
                _nop_();
}
//SPI写时序
uint SPI_RW(uint uchar)
{
        uint bit_ctr;
           for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit
           {
                MOSI = (uchar & 0x80);         // output 'uchar', MSB to MOSI
                uchar = (uchar << 1);           // shift next bit into MSB..
                SCK = 1;                      // Set SCK high..
                uchar |= MISO;                         // capture current MISO bit
                SCK = 0;                              // ..then set SCK low again
           }
    return(uchar);                             // return read uchar
}
//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
// }
//SPI读写寄存器
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
}
//用于读数据，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
// }
//功能: 用于写数据：为寄存器地址，
//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);    //
}


//2401初始化
void init_NRF24L01(void)
{
        Delay_us(100);
        CE=0;
        CSN=1;
        SCK=0;
        SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);    // 写本地地址
        SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // 写接收端地址
//         SPI_Write_Buf(WRITE_REG + SETUP_RETR,0x04); // 写接收端地址
        SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);      //  频道0自动 ACK应答允许
        SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);  //  允许接收地址只有频道0，如果需要多频道可以参考Page21  
        SPI_RW_Reg(WRITE_REG + RF_CH, 0);        //   设置信道工作为2.4GHZ，收发必须一致
        SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为32字节
        SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);     //设置发射速率为1MHZ，发射功率为最大值0dB
        SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);    //发送模式
}

//发送数据包
void nRF24L01_TxPacket(uchar * tx_buf)
{
        CE=0;                        //StandBy I模式       
  SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH);     // 写本地地址       
        SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // 装载接收端地址                          // 装载数据
          
        CE=1;                 //置高CE，激发数据发送
        Delay_us(100);
//        sta = SPI_RW_Reg(STATUS);
//        SPI_RW_Reg(WRITE_REG+STATUS,sta);

}


//主函数
void main()
{
        //char flag2=0;
//         int c[4],i;
int flag;
        count = 0;
        init_NRF24L01();
        T2_init();
        nRF24L01_TxPacket(TxBuf);       
        Delay(6000);
        P0=0xed;
        while(1)
        {
//                 for(i=0;i<5;i++)
//                 {
//                if((count==1))
//                {
//                        while(count);
//                        while(!count)
//                        {
//                                flag++;
//                        }
//                        v=1+(1/flag)*1000;    //如果转速大于2倍播放速度则等于2
//
//                        if(v>2)
//                                v=1.8;
//                        flag=0;          //取多次测量的平均值
//                }       
//         
//                         v=v*1000000;
//                         v=v/100000;
//                sprintf(M,"%f\n",v);
//                  SendStrings(M);       
        //        TxBuf[1]= (char)(v);
        if(key3==0)
        {
            Delay_ms(5);
                   if(key3==0)
                {
                TxBuf[1]=1;
                  //flag=!flag;
                  while(!key3);
                }
        }
//        if(flag==1)
//        TxBuf[1]=1;
//        else
//        TxBuf[1]=0;

/*                if(key4==0)
        {
            Delay_ms(5);
                   if(key4==0)
                {
                  TxBuf[1]=1;
                  while(!key4);
                }
        }
        */
               
//         TxBuf[1]=1;

                nRF24L01_TxPacket(TxBuf);       
                Delay(20000);
        SPI_RW_Reg(WRITE_REG+STATUS,0xff);
    Delay_ms(50000);
               
               
                }
}

郭佳YI

顶顶顶，大家都来看看啊 我已经卡了好长时间了这里

天冰天降

软仿真试试看