怎样去设计两个NRF24L01无线模块实现双向传输的软件呢

NRF24L01双向传输（一对一)

简介

本文章记录两个NRF24L01无线模块实现双向传输的软件设计~
为什么可以双向传输呢？这要归功于它具有Enhanced ShockBurst，可以工作在主接收和主发送模式，在主接收方可以将我们自己的数据附在ACK Packet实现双向传输，所以此次双向传输会将两个NRF分别设置成主接收和主发送。
· 实物（模块非单独芯片）：

网上最便宜的就这种不带运放的模块，大家如果想用NRF24L01的话，建议大家使用加了运放的模块 ，传输距离会比较远一点，没运放的话距离10米就开始出现丢包现象了。另外，进口的和国产的用起来距离一样，所以优先选择国产，因为进口的还贵点。
·芯片引脚定义说明（芯片）：





·**数据包格式 **：





这里没必要介绍NRF24L01了，相信要用这芯片或者模块的朋友应该提前了解过了。
· 寄存器表
该芯片有命令寄存器和功能寄存器。在使用每一款芯片之前，要养成查看数据手册的习惯。这是我自己边看边翻译的，可能有翻译地不对的，见谅哈。
命令寄存器表：
[tr]命令名命令字#数据字节操作[/tr]

R_REGISTER	000A AAAA	1到5，低位在前	读命令/状态寄存器
W_REGISTER	001A AAAA	1到5，低位在前	写命令/状态寄存器
R_RX_PAYLOAD	0110 0001	1到32，低位在前	读RX_Payload(1到32个字节)
W_TX_PAYLOAD	1010 0000	1到32，低位在前	写TX_Payload(1到32个字节)
FLUSH_TX	1110 0001	0	Flush TX FIFO,发送模式使用
FLUSH_RX	1110 0010	0	Flush RX FIFO,接收模式使用
REUSE_TX_PL	1110 0011	0	重用上次发送的载荷（数据包）
R_RX_PL_WID	0110 0000	1	读取RX payload宽度
W_ACK_PAYLOAD	1010 1PPP	1到32，低位在前	写载荷（这些载荷数据同应答包一起从PPP通道发出）
W_TX_PAYLOAD_NO ACK	1011 0000	1到32，低位在前	失能自动应答，用于发送模式
NOP	1111 1111	0	无操作，可用于读取状态寄存器

上面的AAAAA就是后面即将看到的功能寄存器的映射地址。
功能寄存器地址映射表：
[tr]地址助记符位复位值类型描述[/tr]

00	CONFIG				配置寄存器
	Reserved	7	0	R/w	只能为0
	MASK_RX_DR	6	0	R/w	接收中断标志。0：使能
	MASK_TX_D	5	0	R/w	发送中断标志。0：使能
	MASK_MAX_RT	4	0	R/w	最大重发次数中断。0：使能
	EN_CRC	3	1	R/w	使能CRC
	CRCO	2	0	R/w	CRC编码方案选择，1~2bytes
	PWR_UP	1	0	R/w	1：上电，0：下电
	PRIM_RX	0	0	R/w	收发控制。1：PRX；0：PTX
01	EN_AA				使能自动应答
	Reserved	7：6	00	R/w	只能为0
	ENAA_P5	5	1	R/w	使能通道5自动应答机制
	ENAA_P4	4	1	R/w	使能通道4自动应答机制
	ENAA_P3	3	1	R/w	使能通道3自动应答机制
	ENAA_P2	2	1	R/w	使能通道2自动应答机制
	ENAA_P1	1	1	R/w	使能通道1自动应答机制
	ENAA_P0	0	1	R/w	使能通道0自动应答机制
02	EN_RXADDR				使能 RX 地址
	Reserved	7：6	00	R/w	只能为0
	ERX_P5	5	0	R/w	使能通道5
	ERX_P4	4	0	R/w	使能通道4
	ERX_P3	3	0	R/w	使能通道3
	ERX_P2	2	0	R/w	使能通道2
	ERX_P1	1	0	R/w	使能通道1
	ERX_P0	0	0	R/w	使能通道0
03	SETUP_AW				设置地址宽度（所有通道的地址）
	Reserved	7：2	000000	R/w	只能为0
	AW	1：0	11	R/w	收发地址宽度，’11’-5bytes
04	SETUP_RETR				设置自动重发射机制
	ARD	7:4	0000	R/w	自动重发延时’0001’-等待500us
	ARC	3:0	0011	R/w	自动重发计数
05	RF_CH				设置RF频宽
	Reserved	7	0	R/w	只能为0
	RF_CH	6：0	0000010	R/w	设置RF的工作频宽
06	RF_SETUP				RF设置寄存器
	CONT_WAVE	7	0	R/w	为1使能连续传送载波
	Reserved	6	0	R/w	只能为0
	RF_DR_LOW	5	0	R/w	设置RF数据250kbps
	PLL_LOCK	4	0	R/w	仅使用于测试？
	RF_DR_HIGH	3	1	R/w	‘00’-1M，’01’-2M，’10’-250kbps
	RF_PWR	2：1	11	R/w	设置RF输出增益 ’00’-18dbm,’11’-0dbm
	Obsolete	0			无意义
07	STATUS				状态寄存器
	Reserved	7	0	R/w	只能为0
	RX_DR	6	0	R/w	数据就绪RXFIFO中断，写1清除
	TX_DS	5	0	R/w	数据发送RXFIFO中断，写1清除
	MAX_RT	4	0	R/w	最大字节重发中断，写1清除
	RX_P_NO	3：1	111	R	数据通道号
	TX_FULL	0	0	R	TX FIFO满标志(满为1)
08	OBSERVE_TX				发射监测寄存器
	PLOS_CNT	7：4	0	R	丢包计数
	ARC_CNT	3：0	0	R	重发射数据包次数
09	RPD				接收电源检测
	Reserved	7：1	000000	R	只能为0
	RPD	0	0	R	接收电源检测
0A	RX_ADDR_P0	39:0	E7E7E7E7E7	R/W	通道0接收地址（5个字节）
0B	RX_ADDR_P1	39:0	C2C2C2C2C2	R/W	通道1接收地址（5个字节）
0C	RX_ADDR_P2	7:0	C3	R/W	通道2接收地址（1个字节（低））
0D	RX_ADDR_P3	7:0	C4	R/W	通道3接收地址（1个字节（低））
0E	RX_ADDR_P4	7:0	C5	R/W	通道4接收地址（1个字节（低））
0F	RX_ADDR_P5	7:0	C6	R/W	通道5接收地址（1个字节（低））
10	TX_ADDR	39:0	E7E7E7E7E7	R/W	发射地址，仅适用于PTX
11	RX_PW_P0				在通道0中RX_Payload的字节个数
	Reserved	7:6	00	R/W	只能为0
	RX_PW_P0	5:0	0	R/W	接收数据通道0字节数
12	RX_PW_P1	…	…	…	在通道1中RX_Payload的字节个数
13	RX_PW_P2	…	…	…	在通道2中RX_Payload的字节个数
14	RX_PW_P3	…	…	…	在通道3中RX_Payload的字节个数
15	RX_PW_P4	…	…	…	在通道4中RX_Payload的字节个数
16	RX_PW_P5	…	…	…	在通道5中RX_Payload的字节个数
17	FIFO_STATUS				FIFIO状态寄存器
	Reserved	7	0	R/W	只能为0
	TX_REUSE	6	0	R	重用TX Payload
	TX_FULL	5	0	R	TX FIFO满标志
	TX_EMPTY	4	1	R	TX FIFO空标志
	Reserved	3：2	00	R/W	只能为0
	RX_FULL	1	0	R	RX FIFO满标志
	RX_EMPTY	0	1	R	RX FIFO空标志
1C	DYNPD				使能动态数据包长度
	Reserved	7：6	0	R/W	只能为0
	DPL_P5	5	0	R/W	使能pipe 5动态数据包长度
	DPL_P4	4	0	R/W	使能pipe 4动态数据包长度
	DPL_P3	3	0	R/W	使能pipe 3动态数据包长度
	DPL_P2	2	0	R/W	使能pipe 2动态数据包长度
	DPL_P1	1	0	R/W	使能pipe 1动态数据包长度
	DPL_P0	0	0	R/W	使能pipe 0动态数据包长度
1D	FEATURE			R/W	特征寄存器
	Reserved	7:3	0	R/W	只能为0
	EN_DPL	2	0	R/W	使能动态数据包长度
	EN_ACK_PAY	1	0	R/W	使能数据包应答
	EN_DYN_ACK	0	0	R/W	使能写发送数据包非应答命令

如果NRF24L01用作具有Enhanced ShockedBurst 的PTX设备，那么将TX_ADDR寄存器里边的数值（地址）设置成通道0接收地址，使两个相同。
接下来看看该芯片的时序图：
(1) 写时序





(2) 读时序





注：C7-C0 表示命令，S7~S0表示状态，Dx为数据位。
从时序上可以知道，读写时序是：先拉低片选CSN，在SCK的第一个上升沿开始传输数据；SCK在无效的状态下为低电平。这就给我们提示：在配置硬件SPI的时候要配置成SPI模式0（时钟极性0，时钟相位0）。
那么现在根据当前了解到的知识，配置STM32的SPI，这里使用标准库函数：

//初始化24L01的IO口
//这个程序是在开发板正点原子精英板F103上面调试的，SPI2的总线上挂载两个设备，将另一个设备（W25Q）的片选拉高，不选中该设备，防止它的影响
#define W25Q_CSN_PIN GPIO_Pin_12
#define NRF_CSN_PIN GPIO_Pin_7
//初始化相关的IO口(片选以及SPI)
void MySPI2_Init(void)
{        
        GPIO_InitTypeDef GPIO_InitStructure;
          SPI_InitTypeDef  SPI_InitStructure;
       
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOG, ENABLE);         //使能PB,G端口时钟
        RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);//SPI2时钟使能        

       
        GPIO_InitStructure.GPIO_Pin = W25Q_CSN_PIN;                                 //PB12上拉 防止W25X的干扰
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOB, &GPIO_InitStructure);        //初始化指定IO
        GPIO_SetBits(GPIOB,W25Q_CSN_PIN);//上拉                               
       


        GPIO_InitStructure.GPIO_Pin = NRF_CSN_PIN|NRF_CE_PIN;        //PG8 7 推挽           
        GPIO_Init(GPIOG, &GPIO_InitStructure);//初始化指定IO
  
        GPIO_InitStructure.GPIO_Pin  = NRF_IRQ_PIN;   
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //PG6 输入  
        GPIO_Init(GPIOG, &GPIO_InitStructure);


        GPIO_ResetBits(GPIOG,NRF_IRQ_PIN|NRF_CSN_PIN|NRF_CE_PIN);//PG6,7,8上拉                                         
                 
  /****************************SPI2_Init*******************************/
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PB13/14/15复用推挽输出
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB
        GPIO_SetBits(GPIOB,GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);  //PB13/14/15上拉  
        SPI_Cmd(SPI2, DISABLE); // SPI外设不使能


        SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //SPI设置为双线双向全双工
        SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //SPI主机
  SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //发送接收8位帧结构
        SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;                //时钟悬空低
        SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;        //数据捕获于第1个时钟沿
        SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由软件控制
        SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;                //定义波特率预分频的值:波特率预分频值为16
        SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //数据传输从MSB位开始
        SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
        SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器

        SPI_Cmd(SPI2, ENABLE); //使能SPI外设
        /********************************************************************/                          
}
//SPIx 读写一个字节
//TxData:要写入的字节
//返回值:读取到的字节
u8 SPI2_ReadWriteByte(u8 TxData)
{               
        u8 retry=0;                                        
        while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
                {
                retry++;
                if(retry>200)return 0;
                }                          
        SPI_I2S_SendData(SPI2, TxData); //通过外设SPIx发送一个数据
        retry=0;


        while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET)//检查指定的SPI标志位设置与否:接受缓存非空标志位
                {
                retry++;
                if(retry>200)return 0;
                }                                                              
        return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据                                            
}


至此，SPI的初始化配置和通行API函数已经写好，接下来define下片选以及CE使能的IO口：


#define NRF24L01_CE   PGout(8) //24L01片选信号
#define NRF24L01_CSN  PGout(7) //SPI片选信号          
/******下面的中断引脚程序上不用，调试的时候用过而已******/
#define NRF24L01_IRQ  PGin(6)  //IRQ主机数据输入


接下来就进一步根据时序图来编写读写函数了:


/***************************************************************
* 写寄存器
****************************************************************/
uint8_t Write_Reg(uint8_t reg, uint8_t value)
{
        uint8_t status;
        NRF24L01_CSN = 0;                                          /* 选通器件 */
        status = SPI2_ReadWriteByte(reg);  /* 写寄存器地址 */
        SPI2_ReadWriteByte(value);                  /* 写数据 */
        NRF24L01_CSN = 1;                                          /* 禁止该器件 */
  return         status;
}
/***************************************************************
* 读寄存器
****************************************************************/
uint8_t Read_Reg(uint8_t reg)
{
        uint8_t reg_val;
        NRF24L01_CSN = 0;                                          /* 选通器件 */
        SPI2_ReadWriteByte(reg);                          /* 写寄存器地址 */
        reg_val = SPI2_ReadWriteByte(0);          /* 读取该寄存器返回数据 */
        NRF24L01_CSN = 1;                                          /* 禁止该器件 */
   return         reg_val;
}


扩展至连续读连续写，那么还有下面函数：


/****************************************************************
* 写缓冲区----------------------------------
*****************************************************************/
uint8_t Write_Buf(uint8_t reg, uint8_t *pBuf, uint8_t uchars)
{
        uint8_t i;
        uint8_t status;
        NRF24L01_CSN = 0;                                        /* 选通器件 */
        status = SPI2_ReadWriteByte(reg);        /* 写寄存器地址 */
        for(i=0; i         {
                SPI2_ReadWriteByte(pBuf);                /* 写数据 */
        }
        NRF24L01_CSN = 1;                                                /* 禁止该器件 */
  return         status;       
}
/****************************************************************
* 读缓冲区-------------------------------
****************************************************************/
uint8_t Read_Buf(uint8_t reg, uint8_t *pBuf, uint8_t uchars)
{
        uint8_t i;
        uint8_t status;
        NRF24L01_CSN = 0;                                                /* 选通器件 */
        status = SPI2_ReadWriteByte(reg);        /* 写寄存器地址 */
        for(i=0; i         {
                pBuf = SPI2_ReadWriteByte(0); /* 读取返回数据 */        
        }
        NRF24L01_CSN = 1;                                                /* 禁止该器件 */
    return         status;
}

至此，单片机与NRF芯片的通信手段已经搭好了，可以开始配置NRF24L01(+)了。
首先声明寄存器


#define TX_ADR_WIDTH    5                 
#define RX_ADR_WIDTH    5  
#define RX_PLOAD_WIDTH  50  //最大64       
#define TX_PLOAD_WIDTH  50  //最大64       
//***************************************NRF24L01寄存器指令*******************************************************
#define NRF_READ_REG        0x00          // 读寄存器指令
#define NRF_WRITE_REG       0x20         // 写寄存器指令
#define R_RX_PL_WID           0x60    // 读取RX payload宽度指令
#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          // 保留
//*************************************(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 NRFRegSTATUS    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  // 接收频道1接收数据长度
#define RX_PW_P2        0x13  // 接收频道2接收数据长度
#define RX_PW_P3        0x14  // 接收频道3接收数据长度
#define RX_PW_P4        0x15  // 接收频道4接收数据长度
#define RX_PW_P5        0x16  // 接收频道5接收数据长度
#define FIFO_STATUS     0x17  // FIFO栈入栈出状态寄存器设置
#define DYNPD                   0x1C  // 使能动态数据包长度
#define FEATURE                 0x1D  // 主要使能DYNPD


下面就开始写NRF的初始化函数：




void NRF_Init(u8 mode, u8 ch)//初始化,mode=PTX/PRX，ch频宽
{
        MySPI2_Init();
        NRF24L01_CE = 0;
        Write_Reg(NRF_WRITE_REG + SETUP_AW, 0x03);
        Write_Buf(NRF_WRITE_REG+RX_ADDR_P0,(uint8_t *)RX_ADDRESS,5);
        Write_Buf(NRF_WRITE_REG+TX_ADDR,(uint8_t *)TX_ADDRESS,5);
        Write_Reg(NRF_WRITE_REG+EN_AA,0x01);                                                                                                         //使能通道0的自动应答
        Write_Reg(NRF_WRITE_REG+EN_RXADDR,0x01);                                                                                        //使能通道0的接收地址
        Write_Reg(NRF_WRITE_REG+SETUP_RETR,0x1a);                                                                                        //设置自动重发间隔时间:500us;最大自动重发次数:10次 2M波特率下
        Write_Reg(NRF_WRITE_REG+RF_CH,ch);                                                                                                                //设置RF通道为CHANAL
        Write_Reg(NRF_WRITE_REG+RF_SETUP,0x0f);                                                                                                 //设置TX发射参数,0db增益,2Mbps,低噪声增益开启
        if(mode==1)                //PRX
        {
                Write_Reg(NRF_WRITE_REG + CONFIG, 0x0f);                    // IRQ收发完成中断开启,16位CRC,主接收
                Write_Reg(FLUSH_TX,0xff);
                Write_Reg(FLUSH_RX,0xff);
                Write_Reg(NRF_WRITE_REG+0x1c,0x01);
                Write_Reg(NRF_WRITE_REG+0x1d,0x06);
        }
        else if(mode==2)                                                        //TX2
        {
                Write_Reg(NRF_WRITE_REG + CONFIG, 0x0e);                    // IRQ收发完成中断开启,16位CRC,主发送
                Write_Reg(FLUSH_TX,0xff);
                Write_Reg(FLUSH_RX,0xff);
                Write_Reg(NRF_WRITE_REG+0x1c,0x01);
                Write_Reg(NRF_WRITE_REG+0x1d,0x06);
        }
        NRF24L01_CE = 1;
}


数据传输涉及到发射数据包和接收数据包，另外，有必要检测NRF是否初始化正常，还需要检测环节。


//就是试着通过SPI写一串数据，然后再读出来，对比下，没问题返回1
u8 NRF_Check(void)//检查NRF模块是否正常工作
{
        u8 buf1[5];
        u8 i;
        /*写入5个字节的地址. */
        Write_Buf(NRF_WRITE_REG+TX_ADDR,(uint8_t *)TX_ADDRESS,5);
        /*读出写入的地址 */
        Read_Buf(TX_ADDR,buf1,5);
        /*比较*/
        for(i=0;i<5;i++)
        {
                if(buf1!=TX_ADDRESS)
                        break;
        }
        if(i==5)
                return 1; //MCU与NRF成功连接
        else
                return 0; //MCU与NRF不正常连接
}
/****************************************************************
*打包发送
*****************************************************************/
void TxPacket(uint8_t * tx_buf, uint8_t len)
{       
        NRF24L01_CE = 0;       
        //可向别的模块（地址）发射数据
        Write_Buf(NRF_WRITE_REG + RX_ADDR_P0, TX_ADDRESS, 5); // 装载接收端地址
        Write_Buf(WR_TX_PLOAD, tx_buf, len);                          // 装载数据       
        NRF24L01_CE = 1;                 //置高CE，激发数据发送
}
void NRF_Send_Data(u8 *data , u8 length)
{
        TxPacket(data,length);
        //while(NRF24L01_IRQ!=0);
}
void Receive_Data(void)//检查是否有通信事件
{
        u8 sta = Read_Reg(NRF_READ_REG + NRFRegSTATUS);
        //while(NRF24L01_IRQ!=0);//等待发送完成
       
        //接收到数据包后，再对数据进行辨别
        if(sta & (1<         {
                u8 rx_len = Read_Reg(R_RX_PL_WID);
                Read_Buf(RD_RX_PLOAD,NRF24L01RXDATA,rx_len);
                //Data_Receive_PROGRAM
                printf("...");
                Data_Receive_PRO();
        }
        if(sta & (1<         {
                if(sta & 0x01)        //TX FIFO FULL
                {
                        Write_Reg(FLUSH_TX,0xff);
                }
        }
        //很多单片机或者是其他芯片，清除状态为都是往相应位写1
        Write_Reg(NRF_WRITE_REG + NRFRegSTATUS, sta);//写1清除状态寄存器
        sta = Read_Reg(NRF_READ_REG + NRFRegSTATUS);
}
void Data_Receive_PRO(void)
{
        if((NRF24L01RXDATA[0] == 0x01) && (NRF24L01RXDATA[1]==0x02))//帧头
        {
                Rec_ADC_Raw_Val = ((uint16_t)NRF24L01RXDATA[2]<<8) + NRF24L01RXDATA[3];
        }
        else
                return;
}


至此，NRF24L01的驱动程序已经准备好了，接下来主程序调用：
（1）主发送主程序demo：


        #include "led.h"
        #include "sys.h"
        #include "usart.h"         
        #include "24l01.h"        
        uint16_t ms_2=0,ms_10=0,ms_500=0;
        uint8_t Txdata_buffer1[64]={0x01,0x02,0x12,0x34,0x56,0x78,0x9A,0xBC,0xDE};
        uint16_t Rec_ADC_Raw_Val;
        static u8  blink_flag=0;

       
        int main(void)
        {                     
                u8 blink_flag2=0;
                //简单点，省去配置通用定时器的麻烦，直接用滴答定时器
                //注意这里开启滴答定时器中断就不要用正点原子的delay.c了
                //一个完美的程序尽量不去用延时，占用CPU资源
                //不精确延时可以自己写
                SysTick_Config(SystemCoreClock / 1000);//开启滴答定时器中断(72000000/1000)/72MHz = 1ms,即定时1ms中断一次
                uart_init(115200);                 //串口初始化为115200
                LED_Init();                                  //初始化与LED连接的硬件接口
                //下面的函数第一个入口参数为PTX，表示设置为主发送
                //其实，作为两个nRF实现双向通讯，另一方只需要设置为PRX即可。
                NRF_Init(PTX,80);            //初始化NRF24L01
                while(NRF_Check()==0)
                        printf("NRF24L01 disconnected!/n");
                while(1)
                {
                        if(ms_10>100)//每100ms发射一次数据包，闪一次灯，表明正常执行
                        {
                                ms_10 = 0;
                                /*调试用****/
                                if(blink_flag2 == 0)
                                {
                                        PEout(5) = 0;
                                        blink_flag2 = 1;
                                }
                                else if(blink_flag2 == 1)
                                {
                                        PEout(5) = 1;
                                        blink_flag2 = 0;
                                }
                                /*****只自加这个元素*******/
                                Txdata_buffer1[2]++;
                                NRF_Send_Data(Txdata_buffer1,7);
                }
                if(ms_2>2)//每2ms检查NRF是否有通信事件
                {
                        Receive_Data();
                        ms_2 =0;
                }
                if(ms_500>500)//每0.5秒led灯闪一次，串口打印接收到的ADC原始值。
                {
                        if(blink_flag == 0){
                                PBout(5) = 0;
                                blink_flag = 1;
                        }
                        else{
                                PBout(5) = 1;
                                blink_flag = 0;
                        }
                        printf("the Raw ADC val is %d.n",Rec_ADC_Raw_Val);
                        ms_500 = 0;
                }
        }
}


上面的ms_2,ms_10,ms_500在文件stm32f10x_it.c中的滴答定时器中断更新。


void SysTick_Handler(void)
{
        ms_10++;
        ms_500++;
        ms_2++;
}


（2）主接收主程序demo：


//平台用的是潘多拉开发板stm32L475
int main(void)
{
    HAL_Init();
    SystemClock_Config();        //初始化系统时钟为80M
    delay_init(80);                 //初始化延时函数    80M系统时钟
        Usart1_Init(115200);
        ADC1IN3_Init();
    LED_Init();                                //初始化LED
        NRF_Init(PRX,80);
        while(NRF_Check()==0);
        LCD_Init();//IIC接口屏
        LCD_Clear(WHITE);
        TIM2_Init(100 - 1, 8000 - 1);//10ms
        //Iwdg_Init();
    while(1)
    {
                LED_Function();//每0.5秒LED闪一次
                Schedule_100ms();//每100ms在显示屏上面，这里只显示了在主发送方那边自加的Txdata_buffer1[2]
                Schedule_Rec_data();//每10ms检查有没有接收到数据
                Schedule_Send_data();//每50ms发送数据包
    }
}
void Schedule_Send_data(void)
{
        uint8_t temp[10];
        if(count_Send_data>5)
        {
                temp[0] = 0x01;
                temp[1] = 0x02;
                temp[2] = adc_test/256;
                temp[3] = adc_test%256;
                NRF_Send_Data(temp, 4);
                count_Send_data = 0;
        }
}
void Schedule_Rec_data(void)
{
        if(count_Rec_data>1)
        {
                Receive_Data();
                count_Rec_data = 0;
        }
}
void Schedule_100ms(void)
{
        if(counter_100ms > 10)
        {
                Get_ADC();
                Get_AHT10_Data();
                LCD_ShowNum(100, 200, Rec_Test_Buf[0] , 5, 16);
                counter_100ms = 0;
        }
}


总结

• 两个NRF24L01双向通讯，初始化程序除了配置寄存器的最低位不一样之外，其他都一样。（最低位切换PTX和PRX）
  
• 一开始没设置收发地址宽度，导致两个模块通讯不上，查找了挺久，最后看了寄存器表试着设置了就OK了。
  
• 上面的主接收主程序没写全，不过相信大家应该知道怎么写，跟主发送的差不多。
  
• 本程序在两个开发板上已经调试正常运行。