STM32上驱动NRF24L01

近期做了一个遥控玩具，采用的无线模块是NRF24L01，SPI通信方式，在这里做一下笔记，方便查看。

一、模块工作流程

1.接口电路

说明：

1. VCC脚接电压范围为1.9V~3.6V之间，不能在这个区间之外，超
   过3.6V将会烧毁模块。推荐电压3.3V左右。
   (2) 除电源VCC和接地端，其余脚都可以直接和普通的5V单片机IO口
   直接相连，无需电平转换。当然对3V左右的单片机更加适用了。
   (3) 硬件上面没有SPI的单片机也可以控制本模块，用普通单片机IO
   口模拟SPI不需要单片机真正的串口介入，只需要普通的单片机IO口
   就可以了，当然用串口也可以了。

2.NRF24L01状态机

（1）主要有以下几个状态：

Power Down Mode：掉电模式
Tx Mode：发射模式
Rx Mode：接收模式
Standby-1Mode：待机 1 模式
Standby-2 Mode：待机 2 模式

（2）对 24L01 的固件编程的基本思路如下：

1） 置 CSN 为低，使能芯片，配置芯片各个参数。（过程见 3.Tx 与 Rx 的配置过程）
配置参数在 Power Down 状态中完成。
2） 如果是 Tx 模式，填充 Tx FIFO。 3） 配置完成以后，通过 CE 与 CONFIG 中的 PWR_UP 与 PRIM_RX 参数确定 24L01
要切换到的状态。
Tx Mode：PWR_UP=1; PRIM_RX=0; CE=1 (保持超过 10us 就可以)；
Rx Mode: PWR_UP=1; PRIM_RX=1; CE=1;
4) IRQ 引脚会在以下三种情况变低：
Tx FIFO 发完并且收到 ACK（使能 ACK 情况下）
Rx FIFO 收到数据
达到最大重发次数
将 IRQ 接到外部中断输入引脚，通过中断程序进行处理。

3.Tx 与 Rx 的配置过程

这里只是叙述了采用ENHANCED SHORT BURST通信方式的Tx 与Rx的配置及通信过程。

（1）Tx 模式初始化过程

Tx 模式初始化过程
1）写 Tx 节点的地址 TX_ADDR
2）写 Rx 节点的地址（主要是为了使能 Auto Ack） RX_ADDR_P0
3）使能 AUTO ACK EN_AA
4）使能 PIPE 0 EN_RXADDR
5）配置自动重发次数 SETUP_RETR
6）选择通信频率 RF_CH
7）配置发射参数（低噪放大器增益、发射功率、无线速率） RF_SETUP
8 ) 选择通道 0 有效数据宽度 Rx_Pw_P0
9）配置 24L01 的基本参数以及切换工作模式 CONFIG。

（2）Rx 模式初始化过程

Rx 模式初始化过程：
初始化步骤 24L01 相关寄存器
1）写 Rx 节点的地址 RX_ADDR_P0
2）使能 AUTO ACK EN_AA
3）使能 PIPE 0 EN_RXADDR
4）选择通信频率 RF_CH
5) 选择通道 0 有效数据宽度 Rx_Pw_P0
6）配置发射参数（低噪放大器增益、发射功率、无线速率） RF_SETUP
7）配置 24L01 的基本参数以及切换工作模式 CONFIG。

二、移植步骤

1、硬件驱动

1、这里首先需要做的是建立起单片机与连接自身NRF24L01连接，采用SPI通讯方式，自然第一步进行SPI的驱动编写，这里可以选用硬件SPI（及STM32外设SPI给提供时钟SCK,MOSI,MISO），也可以选用软件模拟SPI（只是找一个引脚模拟时钟输出），SPI有条线：SCK（时钟）、CSN（片选）、MOSI（主出从入）、MISO（主入从出），找4个引脚配置上，其中MISO配置为输入，其余为输出，程序中可以通过“SelectSpiBspOrSoft”这个宏定义来选择硬件驱动还是软件模拟（一般都是使用软件，随便一个IO就行）。4根SPI线已经配置好了，剩下的需要配置NRF24L01模式控制的引脚CE（芯片的模式控制线、输出）、引脚IRQ（中断信号，输入）。

2、SPI接口函数

2、引脚初始化完成，下一步就是进行最基础的SPI接口函数编写；

//使用硬件外设SPI和软件模拟SPI，就差在SCK/MOSI/MISO三根线上，只需要替换下面函数即可，最基本的按位写数据函数，由SelectSpiBspOrSoft控制硬件驱动或软件模拟SPI。
#if SelectSpiBspOrSoft==0   
/**
  * @brief   用于向NRF读/写一字节数据
  * @param   写入的数据
  * @retval  读取得的数据
  */
u8 SPI_NRF_RW(u8 WriteData)
{  	
   /* 当 SPI发送缓冲器非空时等待 */
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
  
   /* 通过 SPI2发送一字节数据 */
  SPI_I2S_SendData(SPI1, WriteData);		
 
   /* 当SPI接收缓冲器为空时等待 */
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

  /* Return the byte read from the SPI bus */
  return SPI_I2S_ReceiveData(SPI1);
}
#else
/***********************************/
/* 使用标准的固件库控制IO*/
#define SCK(a)	if (a)	\
					GPIO_SetBits(NRF_SCK_GPIO_PORT,NRF_SCK_PIN);\
					else		\
					GPIO_ResetBits(NRF_SCK_GPIO_PORT,NRF_SCK_PIN)
#define MISO GPIO_ReadInputDataBit(NRF_MISO_GPIO_PORT,NRF_MISO_PIN)
#define MOSI(a)	if (a)	\
					GPIO_SetBits(NRF_MOSI_GPIO_PORT,NRF_MOSI_PIN);\
					else		\
					GPIO_ResetBits(NRF_MOSI_GPIO_PORT,NRF_MOSI_PIN)
					
/**
  * @brief   用于向NRF读/写一字节数据
  * @param   写入的数据
  * @retval  读取得的数据
  */
u8 SPI_NRF_RW(u8 WriteData)
{  	
	unsigned char i;
	unsigned char ReadData=0;
	for(i=0;i<8;i++)
	{
		SCK(0);
		if(WriteData & 0x80)
		{
			MOSI(1);
		}
		else
		{
			MOSI(0);
		}
		SCK(1);
		WriteData<<=1;
		ReadData<<=1;
		if(MISO)
		{
			ReadData+=1;
		}
		else
		{
			ReadData+=0;
		}
	}
	SCK(0);
	return ReadData;
}
/***********************************/
#endif

3、函数封装

3、其余便是在SPI_NRF_RW()基础上的逻辑封装函数，详细见代码中。
NRF24L01 的控制程序主要包括以下几个函数
uchar SPI_RW(uchar byte);
uchar SPI_RW_Reg(uchar reg, uchar value);
uchar SPI_Read(uchar reg);
uchar SPI_Read_Buf(uchar reg, uchar *pBuf, uchar bytes);
uchar SPI_Write_Buf(uchar reg, uchar *pBuf, uchar bytes);
void RX_Mode(void);
void TX_Mode(void);

4、模块初始化

4.功能函数全部已经准备好了，接下来便是初始化模块，NRF24L01_Init();

void NRF24L01_Init(void)
{
	SPI_NRF_Init();
  /*检测NRF模块与MCU的连接*/
  NrfStatus = NRF_Check();   		
  if(NrfStatus == SUCCESS)	   
    printf("\r\n      NRF与MCU连接成功\r\n");  
  else	  
    printf("\r\n   请检测NRF与MCU是否正常连接。。。\r\n"); 

  NRF_RX_Mode();     // NRF 进入接收模式
}

5、应用函数、数据处理

5.模块初始化完成后，可以进行应用编写了，应用中不断的进行TX和RX模式的变换，默认RX模式，将NRF24L01Thread（）次函数放进大循环中即可，然后读取NrfRxbuf或写入NrfTxbuf。

u8 i; 
u8 NrfStatus = 0;	//用于判断接收/发送状态
u8 NrfTxbuf[10];	 //发送缓冲
u8 NrfRxbuf[10];	 //接收缓冲
void NRF24L01Thread(void)
{
    /* 等待接收数据 */
    NrfStatus = NRF_Rx_Dat(NrfRxbuf);

    /* 判断接收状态 */
    if(NrfStatus == RX_DR)
    {
      for(i=0;i<10;i++)
      {	
        printf("\r\n 接收数据为：%d \r\n",NrfRxbuf[i]); 
      }
      
      printf("\r\n进入接收模式，按 K1 发送数据\r\n"); 
    }
     
//    if (Key_Scan(KEY1_GPIO_PORT, KEY1_GPIO_PIN) == KEY_ON)    // 按键按下，开始送数据
	if (NRF_SendTime > 20)    // 20ms开始送数据，这里设定一个定时器20ms发送一次。
    { 
			NRF_SendTime=0;

      /* 发送数据 */
      NRF_TX_Mode();
           
      NrfStatus = NRF_Tx_Dat(NrfTxbuf);
      
      /* 发送数据的状态 */
       if(NrfStatus == TX_DS)
      {
        printf("\r\n发送数据成功\r\n");
      }
      else
      {
        printf("\r\n发送数据失败  %d\r\n", NrfStatus);
      }
      
      printf("\r\n 进入接收模式\r\n"); 

      NRF_RX_Mode();
    }
}

三、代码

一共4个文件：
bsp_spi_nrf.c、bsp_spi_nrf.h、app_spi_nrf.c、app_spi_nrf.h

1、bsp_spi_nrf.c

#include "bsp_spi_nrf.h"
#include "bsp_usart1.h"

u8 RX_BUF[RX_PLOAD_WIDTH];		//接收数据缓存
u8 TX_BUF[TX_PLOAD_WIDTH];		//发射数据缓存
u8 TX_ADDRESS[TX_ADR_WIDTH] = {0x34,0x43,0x10,0x10,0x01};  // 定义一个静态发送地址
u8 RX_ADDRESS[RX_ADR_WIDTH] = {0x34,0x43,0x10,0x10,0x01}; 

void Delay(__IO u32 nCount)
{
  for(; nCount != 0; nCount--);
} 

/**
  * @brief  SPI的 I/O配置
  * @param  无
  * @retval 无
  */
void SPI_NRF_Init(void)
{
	#if SelectSpiBspOrSoft==0	
  SPI_InitTypeDef  SPI_InitStructure;
	#endif
  GPIO_InitTypeDef GPIO_InitStructure;
  
 /*开启相应IO端口的时钟*/
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA
                         |NRF_IRQ_GPIO_CLK
                         |NRF_CSN_GPIO_CLK
                         |NRF_CE_GPIO_CLK
									   		 |NRF_SCK_GPIO_CLK
									   		 |NRF_MOSI_GPIO_CLK
									   		 |NRF_MISO_GPIO_CLK,ENABLE);

 /*使能SPI1时钟*/
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);

#if SelectSpiBspOrSoft==0	
	
 /*配置 SPI_NRF_SPI的 SCK,MISO,MOSI引脚，GPIOA^5,GPIOA^6,GPIOA^7 */
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP; //复用功能
  GPIO_Init(GPIOA, &GPIO_InitStructure);  
#else
   /*配置SPI_NRF_SPI的MISO引脚*/
  GPIO_InitStructure.GPIO_Pin = NRF_MISO_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING ;  //浮空输入
  GPIO_Init(NRF_MISO_GPIO_PORT, &GPIO_InitStructure); 
	/*配置SPI_NRF_SPI的SCK引脚*/
	GPIO_InitStructure.GPIO_Pin = NRF_SCK_PIN|NRF_MOSI_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP; //复用功能
  GPIO_Init(GPIOB,&GPIO_InitStructure);  		
#endif

  /*配置SPI_NRF_SPI的CE引脚,和SPI_NRF_SPI的 CSN 引脚*/
  GPIO_InitStructure.GPIO_Pin = NRF_CSN_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(NRF_CSN_GPIO_PORT, &GPIO_InitStructure);
  
  GPIO_InitStructure.GPIO_Pin = NRF_CE_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  GPIO_Init(NRF_CE_GPIO_PORT, &GPIO_InitStructure);
  

   /*配置SPI_NRF_SPI的IRQ引脚*/
  GPIO_InitStructure.GPIO_Pin = NRF_IRQ_PIN;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_10MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU ;  //上拉输入
  GPIO_Init(NRF_IRQ_GPIO_PORT, &GPIO_InitStructure); 
		  
  /* 这是自定义的宏，用于拉高csn引脚，NRF进入空闲状态 */
  NRF_CSN_HIGH(); 
#if SelectSpiBspOrSoft==0	 
  SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex; //双线全双工
  SPI_InitStructure.SPI_Mode = SPI_Mode_Master;	 					//主模式
  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_8;  //8分频，9MHz
  SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;  				//高位在前
  SPI_InitStructure.SPI_CRCPolynomial = 7;
  SPI_Init(SPI1, &SPI_InitStructure);

  /* Enable SPI1  */
  SPI_Cmd(SPI1, ENABLE);
#endif
}

//使用硬件外设SPI和软件模拟SPI，就差在SCK/MOSI/MISO三根线上，只需要替换下面函数即可，最基本的按位写数据函数
#if SelectSpiBspOrSoft==0
/**
  * @brief   用于向NRF读/写一字节数据
  * @param   写入的数据
  *		@arg dat 
  * @retval  读取得的数据
  */
u8 SPI_NRF_RW(u8 WriteData)
{  	
   /* 当 SPI发送缓冲器非空时等待 */
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET);
  
   /* 通过 SPI2发送一字节数据 */
  SPI_I2S_SendData(SPI1, WriteData);		
 
   /* 当SPI接收缓冲器为空时等待 */
  while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET);

  /* Return the byte read from the SPI bus */
  return SPI_I2S_ReceiveData(SPI1);
}
#else
/***********************************/
/* 使用标准的固件库控制IO*/
#define SCK(a)	if (a)	\
					GPIO_SetBits(NRF_SCK_GPIO_PORT,NRF_SCK_PIN);\
					else		\
					GPIO_ResetBits(NRF_SCK_GPIO_PORT,NRF_SCK_PIN)
#define MISO GPIO_ReadInputDataBit(NRF_MISO_GPIO_PORT,NRF_MISO_PIN)
#define MOSI(a)	if (a)	\
					GPIO_SetBits(NRF_MOSI_GPIO_PORT,NRF_MOSI_PIN);\
					else		\
					GPIO_ResetBits(NRF_MOSI_GPIO_PORT,NRF_MOSI_PIN)
					
//u8 SPI_NRF_RW(u8 dat)
//{ 
//	u8 bit_ctr;
//	for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit 
//	{ 
//		SCK(0);
//		if(dat & 0x80)
//		{
//			MOSI(1);
//		}
//		else
//		{
//			MOSI(0);
//		}
//		SCK(1);
//		dat = (dat << 1);
//		dat |= MISO;
//		SCK(0);
//		
		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(dat); // return read byte 
//}


/**
  * @brief   用于向NRF读/写一字节数据
  * @param   写入的数据
  *		@arg dat 
  * @retval  读取得的数据
  */
u8 SPI_NRF_RW(u8 WriteData)
{  	
	unsigned char i;
	unsigned char ReadData=0;
	
	for(i=0;i<8;i++)
	{
		SCK(0);
		if(WriteData & 0x80)
		{
			MOSI(1);
		}
		else
		{
			MOSI(0);
		}
		SCK(1);
		WriteData<<=1;
		ReadData<<=1;
		if(MISO)
		{
			ReadData+=1;
		}
		else
		{
			ReadData+=0;
		}
	}
	SCK(0);
	return ReadData;
}

/***********************************/

#endif

/**
  * @brief   用于向NRF特定的寄存器写入数据
  * @param   
  *		@arg reg:NRF的命令+寄存器地址
  *		@arg dat:将要向寄存器写入的数据
  * @retval  NRF的status寄存器的状态
  */
u8 SPI_NRF_WriteReg(u8 reg,u8 dat)
{
 	u8 status;
	 NRF_CE_LOW();
	/*置低CSN，使能SPI传输*/
    NRF_CSN_LOW();
				
	/*发送命令及寄存器号 */
	status = SPI_NRF_RW(reg);
		 
	 /*向寄存器写入数据*/
    SPI_NRF_RW(dat); 
	          
	/*CSN拉高，完成*/	   
  	NRF_CSN_HIGH();	
		
	/*返回状态寄存器的值*/
   	return(status);
}

/**
  * @brief   用于从NRF特定的寄存器读出数据
  * @param   
  *		@arg reg:NRF的命令+寄存器地址
  * @retval  寄存器中的数据
  */
u8 SPI_NRF_ReadReg(u8 reg)
{
 	u8 reg_val;

	NRF_CE_LOW();
	/*置低CSN，使能SPI传输*/
 	NRF_CSN_LOW();
				
  	 /*发送寄存器号*/
	SPI_NRF_RW(reg); 

	 /*读取寄存器的值 */
	reg_val = SPI_NRF_RW(NOP);
	            
   	/*CSN拉高，完成*/
	NRF_CSN_HIGH();		
   	
	return reg_val;
}	

/**
  * @brief   用于向NRF的寄存器中写入一串数据
  * @param   
  *		@arg reg : NRF的命令+寄存器地址
  *		@arg pBuf：用于存储将被读出的寄存器数据的数组，外部定义
  * 	@arg bytes: pBuf的数据长度
  * @retval  NRF的status寄存器的状态
  */
u8 SPI_NRF_ReadBuf(u8 reg,u8 *pBuf,u8 bytes)
{
 	u8 status, byte_cnt;

	  NRF_CE_LOW();
	/*置低CSN，使能SPI传输*/
	NRF_CSN_LOW();
		
	/*发送寄存器号*/		
	status = SPI_NRF_RW(reg); 

 	/*读取缓冲区数据*/
	 for(byte_cnt=0;byte_cnt<bytes;byte_cnt++)		  
	   pBuf[byte_cnt] = SPI_NRF_RW(NOP); //从NRF24L01读取数据  

	 /*CSN拉高，完成*/
	NRF_CSN_HIGH();	
		
 	return status;		//返回寄存器状态值
}

/**
  * @brief   用于向NRF的寄存器中写入一串数据
  * @param   
  *		@arg reg : NRF的命令+寄存器地址
  *		@arg pBuf：存储了将要写入写寄存器数据的数组，外部定义
  * 	@arg bytes: pBuf的数据长度
  * @retval  NRF的status寄存器的状态
  */
u8 SPI_NRF_WriteBuf(u8 reg ,u8 *pBuf,u8 bytes)
{
	 u8 status,byte_cnt;
	 NRF_CE_LOW();
   	 /*置低CSN，使能SPI传输*/
	 NRF_CSN_LOW();			

	 /*发送寄存器号*/	
  	 status = SPI_NRF_RW(reg); 
 	
  	  /*向缓冲区写入数据*/
	 for(byte_cnt=0;byte_cnt<bytes;byte_cnt++)
		SPI_NRF_RW(*pBuf++);	//写数据到缓冲区 	 
	  	   
	/*CSN拉高，完成*/
	NRF_CSN_HIGH();			
  
  	return (status);	//返回NRF24L01的状态 		
}

/**
  * @brief  配置并进入接收模式
  * @param  无
  * @retval 无
  */
void NRF_RX_Mode(void)

{
	NRF_CE_LOW();	

   SPI_NRF_WriteBuf(NRF_WRITE_REG+RX_ADDR_P0,RX_ADDRESS,RX_ADR_WIDTH);//写RX节点地址

   SPI_NRF_WriteReg(NRF_WRITE_REG+EN_AA,0x01);    //使能通道0的自动应答    

   SPI_NRF_WriteReg(NRF_WRITE_REG+EN_RXADDR,0x01);//使能通道0的接收地址    

   SPI_NRF_WriteReg(NRF_WRITE_REG+RF_CH,CHANAL);      //设置RF通信频率    

   SPI_NRF_WriteReg(NRF_WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);//选择通道0的有效数据宽度      

   SPI_NRF_WriteReg(NRF_WRITE_REG+RF_SETUP,0x0f); //设置TX发射参数,0db增益,2Mbps,低噪声增益开启   

   SPI_NRF_WriteReg(NRF_WRITE_REG+CONFIG, 0x0f);  //配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式 

/*CE拉高，进入接收模式*/	
  NRF_CE_HIGH();

}    

/**
  * @brief  配置发送模式
  * @param  无
  * @retval 无
  */
void NRF_TX_Mode(void)
{  
	NRF_CE_LOW();		

   SPI_NRF_WriteBuf(NRF_WRITE_REG+TX_ADDR,TX_ADDRESS,TX_ADR_WIDTH);    //写TX节点地址 

   SPI_NRF_WriteBuf(NRF_WRITE_REG+RX_ADDR_P0,RX_ADDRESS,RX_ADR_WIDTH); //设置TX节点地址,主要为了使能ACK   

   SPI_NRF_WriteReg(NRF_WRITE_REG+EN_AA,0x01);     //使能通道0的自动应答    

   SPI_NRF_WriteReg(NRF_WRITE_REG+EN_RXADDR,0x01); //使能通道0的接收地址  

   SPI_NRF_WriteReg(NRF_WRITE_REG+SETUP_RETR,0x1a);//设置自动重发间隔时间:500us + 86us;最大自动重发次数:10次

   SPI_NRF_WriteReg(NRF_WRITE_REG+RF_CH,CHANAL);       //设置RF通道为CHANAL

   SPI_NRF_WriteReg(NRF_WRITE_REG+RF_SETUP,0x0f);  //设置TX发射参数,0db增益,2Mbps,低噪声增益开启   
	
   SPI_NRF_WriteReg(NRF_WRITE_REG+CONFIG,0x0e);    //配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,发射模式,开启所有中断

/*CE拉高，进入发送模式*/	
  NRF_CE_HIGH();
    Delay(0xffff); //CE要拉高一段时间才进入发送模式
}

/**
  * @brief  主要用于NRF与MCU是否正常连接
  * @param  无
  * @retval SUCCESS/ERROR 连接正常/连接失败
  */
u8 NRF_Check(void)
{
	u8 buf[5]={0xC2,0xC2,0xC2,0xC2,0xC2};
	u8 buf1[5];
	u8 i; 
	 
	/*写入5个字节的地址.  */  
	SPI_NRF_WriteBuf(NRF_WRITE_REG+TX_ADDR,buf,5);

	/*读出写入的地址 */
	SPI_NRF_ReadBuf(TX_ADDR,buf1,5); 
	 
	/*比较*/               
	for(i=0;i<5;i++)
	{
		if(buf1[i]!=0xC2)
		break;
	} 
	       
	if(i==5)
		return SUCCESS ;        //MCU与NRF成功连接 
	else
		return ERROR ;        //MCU与NRF不正常连接
}

/**
  * @brief   用于向NRF的发送缓冲区中写入数据
  * @param   
  *		@arg txBuf：存储了将要发送的数据的数组，外部定义	
  * @retval  发送结果，成功返回TXDS,失败返回MAXRT或ERROR
  */
u8 NRF_Tx_Dat(u8 *txbuf)
{
	u8 state;  

	 /*ce为低，进入待机模式1*/
	NRF_CE_LOW();

	/*写数据到TX BUF 最大 10个字节*/						
   SPI_NRF_WriteBuf(WR_TX_PLOAD,txbuf,TX_PLOAD_WIDTH);

      /*CE为高，txbuf非空，发送数据包 */   
 	 NRF_CE_HIGH();
	  	
	  /*等待发送完成中断 */                            
	while(NRF_Read_IRQ()!=0); 	
	
	/*读取状态寄存器的值 */                              
	state = SPI_NRF_ReadReg(STATUS);

	 /*清除TX_DS或MAX_RT中断标志*/                  
	SPI_NRF_WriteReg(NRF_WRITE_REG+STATUS,state); 	

	SPI_NRF_WriteReg(FLUSH_TX,NOP);    //清除TX FIFO寄存器 

	 /*判断中断类型*/    
	if(state&MAX_RT)                     //达到最大重发次数
			 return MAX_RT; 

	else if(state&TX_DS)                  //发送完成
		 	return TX_DS;
	 else						  
			return ERROR;                 //其他原因发送失败
} 

/**
  * @brief   用于从NRF的接收缓冲区中读出数据
  * @param   
  *		@arg rxBuf ：用于接收该数据的数组，外部定义	
  * @retval 
  *		@arg 接收结果
  */
u8 NRF_Rx_Dat(u8 *rxbuf)
{
	u8 state; 
	NRF_CE_HIGH();	 //进入接收状态
	 /*等待接收中断*/
//	while(NRF_Read_IRQ()==0)
	if(NRF_Read_IRQ()==0)
  {
    NRF_CE_LOW();  	 //进入待机状态
    /*读取status寄存器的值  */               
    state=SPI_NRF_ReadReg(STATUS);
     
    /* 清除中断标志*/      
    SPI_NRF_WriteReg(NRF_WRITE_REG+STATUS,state);

    /*判断是否接收到数据*/
    if(state&RX_DR)                                 //接收到数据
    {
      SPI_NRF_ReadBuf(RD_RX_PLOAD,rxbuf,RX_PLOAD_WIDTH);//读取数据
         SPI_NRF_WriteReg(FLUSH_RX,NOP);          //清除RX FIFO寄存器
      return RX_DR; 
    }
    else    
      return ERROR;                    //没收到任何数据
  }
	else
	{
		return ERROR;                    //没收到任何数据
	} 
//  return ERROR;                    //没收到任何数据
}

2、bsp_spi_nrf.h

#ifndef __SPI_NRF_H
#define __SPI_NRF_H

#include "stm32f10x.h"

#define SelectSpiBspOrSoft 1   //选择芯片自带外设驱动0，或者选择软件模拟1

#define TX_ADR_WIDTH 	5  	//发射地址宽度
#define TX_PLOAD_WIDTH  10   //发射数据通道有效数据宽度0~32Byte 

#define RX_ADR_WIDTH    5
#define RX_PLOAD_WIDTH  10 

#define CHANAL 40	//频道选择 

// SPI(nRF24L01) commands ,	NRF的SPI命令宏定义，详见NRF功能使用文档
#define NRF_READ_REG    0x00  // Define read command to register
#define NRF_WRITE_REG   0x20  // Define write command to register
#define RD_RX_PLOAD 0x61  // Define RX payload register address
#define WR_TX_PLOAD 0xA0  // Define TX payload register address
#define FLUSH_TX    0xE1  // Define flush TX register command
#define FLUSH_RX    0xE2  // Define flush RX register command
#define REUSE_TX_PL 0xE3  // Define reuse TX payload register command
#define NOP         0xFF  // Define No Operation, might be used to read status register

// SPI(nRF24L01) registers(addresses) ，NRF24L01 相关寄存器地址的宏定义
#define CONFIG      0x00  // 'Config' register address
#define EN_AA       0x01  // 'Enable Auto Acknowledgment' register address
#define EN_RXADDR   0x02  // 'Enabled RX addresses' register address
#define SETUP_AW    0x03  // 'Setup address width' register address
#define SETUP_RETR  0x04  // 'Setup Auto. Retrans' register address
#define RF_CH       0x05  // 'RF channel' register address
#define RF_SETUP    0x06  // 'RF setup' register address
#define STATUS      0x07  // 'Status' register address
#define OBSERVE_TX  0x08  // 'Observe TX' register address
#define CD          0x09  // 'Carrier Detect' register address
#define RX_ADDR_P0  0x0A  // 'RX address pipe0' register address
#define RX_ADDR_P1  0x0B  // 'RX address pipe1' register address
#define RX_ADDR_P2  0x0C  // 'RX address pipe2' register address
#define RX_ADDR_P3  0x0D  // 'RX address pipe3' register address
#define RX_ADDR_P4  0x0E  // 'RX address pipe4' register address
#define RX_ADDR_P5  0x0F  // 'RX address pipe5' register address
#define TX_ADDR     0x10  // 'TX address' register address
#define RX_PW_P0    0x11  // 'RX payload width, pipe0' register address
#define RX_PW_P1    0x12  // 'RX payload width, pipe1' register address
#define RX_PW_P2    0x13  // 'RX payload width, pipe2' register address
#define RX_PW_P3    0x14  // 'RX payload width, pipe3' register address
#define RX_PW_P4    0x15  // 'RX payload width, pipe4' register address
#define RX_PW_P5    0x16  // 'RX payload width, pipe5' register address
#define FIFO_STATUS 0x17  // 'FIFO Status Register' register address

#define MAX_RT      0x10 //达到最大重发次数中断标志位
#define TX_DS		0x20 //发送完成中断标志位	  // 

#define RX_DR		0x40 //接收到数据中断标志位

#define NRF_CSN_GPIO_PORT    GPIOA
#define NRF_CSN_PIN          GPIO_Pin_8
#define NRF_CSN_GPIO_CLK     RCC_APB2Periph_GPIOA

#define NRF_CE_GPIO_PORT    GPIOB
#define NRF_CE_PIN          GPIO_Pin_15
#define NRF_CE_GPIO_CLK     RCC_APB2Periph_GPIOB

#define NRF_IRQ_GPIO_PORT    GPIOB
#define NRF_IRQ_PIN          GPIO_Pin_12
#define NRF_IRQ_GPIO_CLK     RCC_APB2Periph_GPIOB

#define NRF_CSN_HIGH()      GPIO_SetBits(NRF_CSN_GPIO_PORT, NRF_CSN_PIN)
#define NRF_CSN_LOW()       GPIO_ResetBits(NRF_CSN_GPIO_PORT, NRF_CSN_PIN)		        //csn置低

#define NRF_CE_HIGH()	      GPIO_SetBits(NRF_CE_GPIO_PORT,NRF_CE_PIN)
#define NRF_CE_LOW()	      GPIO_ResetBits(NRF_CE_GPIO_PORT,NRF_CE_PIN)			      //CE置低

#define NRF_Read_IRQ()		  GPIO_ReadInputDataBit(NRF_IRQ_GPIO_PORT, NRF_IRQ_PIN)  //中断引脚


#define NRF_SCK_GPIO_PORT    GPIOB
#define NRF_SCK_PIN          GPIO_Pin_13
#define NRF_SCK_GPIO_CLK     RCC_APB2Periph_GPIOB

#define NRF_MOSI_GPIO_PORT   GPIOB
#define NRF_MOSI_PIN         GPIO_Pin_14
#define NRF_MOSI_GPIO_CLK    RCC_APB2Periph_GPIOB

#define NRF_MISO_GPIO_PORT   GPIOB
#define NRF_MISO_PIN         GPIO_Pin_11
#define NRF_MISO_GPIO_CLK    RCC_APB2Periph_GPIOB

void SPI_NRF_Init(void);
u8 SPI_NRF_RW(u8 dat);
u8 SPI_NRF_ReadReg(u8 reg );
u8 SPI_NRF_WriteReg(u8 reg,u8 dat);

u8 SPI_NRF_ReadBuf(u8 reg,u8 *pBuf,u8 bytes);
u8 SPI_NRF_WriteBuf(u8 reg ,u8 *pBuf,u8 bytes);	

void NRF_TX_Mode(void);
void NRF_RX_Mode(void);
u8 NRF_Rx_Dat(u8 *rxbuf);
u8 NRF_Tx_Dat(u8 *txbuf);
u8 NRF_Check(void); 

#endif /* __SPI_NRF_H */ 

3、app_spi_nrf.c

#include "app_spi_nrf.h"
#include "bsp_spi_nrf.h"
#include "bsp_usart1.h"
#include "./key/bsp_key.h" 
#include "bsp_GeneralTim.h" 
u8 i; 
u8 NrfStatus = 0;	//用于判断接收/发送状态
u8 NrfTxbuf[10];	 //发送缓冲
u8 NrfRxbuf[10];	 //接收缓冲

void NRF24L01Thread(void)
{

    /* 等待接收数据 */
    NrfStatus = NRF_Rx_Dat(NrfRxbuf);

    /* 判断接收状态 */
    if(NrfStatus == RX_DR)
    {
      for(i=0;i<10;i++)
      {	
        printf("\r\n 接收数据为：%d \r\n",NrfRxbuf[i]); 
      }
      
      printf("\r\n进入接收模式，按 K1 发送数据\r\n"); 
    }
     
//    if (Key_Scan(KEY1_GPIO_PORT, KEY1_GPIO_PIN) == KEY_ON)    // 按键按下，开始送数据
		if (NRF_SendTime > 20)    // 20ms开始送数据
    { 
			NRF_SendTime=0;

      /* 发送数据 */
      NRF_TX_Mode();
           
      NrfStatus = NRF_Tx_Dat(NrfTxbuf);
      
      /* 发送数据的状态 */
       if(NrfStatus == TX_DS)
      {
        printf("\r\n发送数据成功\r\n");
      }
      else
      {
        printf("\r\n发送数据失败  %d\r\n", NrfStatus);
      }
      
      printf("\r\n 进入接收模式，按 K1 发送数据\r\n"); 

      NRF_RX_Mode();
    }
}

4、app_spi_nrf.h

#ifndef __APP_SPI_NRF_H
#define __APP_SPI_NRF_H
#include "stm32f10x.h"

extern u8 NrfStatus;	//用于判断接收/发送状态
void NRF24L01Thread(void);
#endif