STM32上驱动NRF24L01

其他 2020-03-12 12:25:41 阅读次数: 0

文章目录


近期做了一个遥控玩具，采用的无线模块是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
Davidysw
发布了9 篇原创文章 · 获赞 4 · 访问量 865
私信 关注

猜你喜欢

转载自blog.csdn.net/Davidysw/article/details/103857180
今日推荐
《美国对全球网络空间安全与发展的威胁和破坏》报告发布
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
周排行
让自己的头脑极度开放
CentOS 6.5(x64) 和Redhat6.5操作系误删libc
高可用注册中心
【日记】12.28/【题解】AtCoder AGC041
XML（5）_XML 约束_DTD
Java集合Map（四）
树梅派安装桌面环境教程
pipenv 的 使用和安装
小程序白屏问题和内存研究
C语言简单选择排序
每日归档
更多
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022