EEPW论坛

设计的项目初衷：作为一个软件工程师，在调试代码时候难免会遇到不同信号之间的转换，例如：485通讯方式，RS232，TTL信号，不同信号之间电平不能直接进行通讯，这时候我们需要进行信号之间的转换，还有就是为了避免调试起来方便，让自己的桌面不再那么脏乱。之前正好研究SPI通讯方式的NRF24L01这款无线芯片，利用业余时间做了一个无线通讯模块。在这里分享一下开发的经验。

1：硬件设计部分：

PCB示意图：

使用主控为STM32F103C8T6芯片，使用该块芯片是因为该款芯片具有USB功能，可以与电脑进行USB数据传输，而且当时设计的时候芯片的价格还是可以接受的。

无线模块采用的是NRF24L01芯片，在实际调试中发现SPI通讯还是比较稳定的（稍后整理一份模块具体的开发手册）。

利用串口1的引脚的接收发送引脚，使用消息队列的方式，可以将USB下发的的数据发送出去。

2:软件配置：使用STM32cube 软件配置生成USB、SPI、串口的底层驱动部分，这样大大减少了开发的时间。

cube软件配置图如下，主要对使用的引脚进行配置

3：软件代码：

消息队列底层驱动函数

QelemType Qusart2SendData[MAXSIZE];	//创建串口1发送MAXSIZE个队列结构体数据帧
squene Qusart2Send;					//创建串口1发送队列

//QelemType QelemData[MAXSIZE];		//创建串口1发送MAXSIZE个队列结构体数据帧
//squene Qusart1Send;				//创建串口1发送队列

/**************************************************************************
 - 功能描述：队列初始化
 - 参数说明：*s 队列句柄		*buf 队列结构体数据地址
 - 返回说明：-1 失败		0 成功
 **************************************************************************/
int8_t Initquene(squene *s, QelemType *buf)
{
	s->base=buf;
	if(!s->base)
		return -1;
	s->front=0;
	s->rear=0;
	return 0;
}

/**************************************************************************
 - 功能描述：入队列
 - 参数说明：*s 队列句柄		*e 要入队列数据的地址
 - 返回说明：无
 **************************************************************************/
void enquene(squene *s,QelemType *e)
{
	if(((s->rear)+1)%MAXSIZE==s->front)
	{
		return ;
	}
	memcpy(&(s->base[s->rear]), e, sizeof(QelemType));
	s->rear=((s->rear)+1)%MAXSIZE;
}

/**************************************************************************
 - 功能描述：队列初始化
 - 参数说明：*s 队列句柄		*e 出队列数据要写入的地址
 - 返回说明：-1 失败		0 成功
 **************************************************************************/
int8_t dequene(squene *s,QelemType *e)
{
	if(s->rear==s->front)
	{
		return -1;
	}
	memcpy(e, &(s->base[s->front]), sizeof(QelemType));
	memset(&(s->base[s->front]), 0, sizeof(QelemType));
	s->front=((s->front)+1) % MAXSIZE;
	return 0;
}

/**************************************************************************
 - 功能描述：队列初始化
 - 参数说明：*s 队列句柄
 - 返回说明：队列中当前数据长度
 **************************************************************************/
int length(squene *s)
{
	return (s->rear - s->front + MAXSIZE) % MAXSIZE;
}

/**************************************************************************
 - 功能描述：初始化所有应用的队列
 - 参数说明：void
 - 返回说明：void
 **************************************************************************/
void Queue_Init(void)
{
	Initquene(&Qusart2Send, Qusart2SendData);
}

无线模块NRF24L01配置部分：

#include "24L01.h"
#include "spi.h"
#include "string.h"
#include "usbd_cdc_if.h"

extern USBD_CDC_LineCodingTypeDef linecoding_old;
extern USBD_CDC_LineCodingTypeDef linecoding;

extern uint16_t shudu;

// SPI总线速度设置 
#define SPI_SPEED_2   0
#define SPI_SPEED_4   1
#define SPI_SPEED_8   2
#define SPI_SPEED_16  3
#define SPI_SPEED_256 4
 
const unsigned char TX_ADDRESS[TX_ADR_WIDTH]={0x34,0x43,0x10,0x10,0x01}; //发送地址
const unsigned char TX1_ADDRESS[TX_ADR_WIDTH]={0x01,0xc2,0xc2,0xc2,0xc2}; //发送地址
const unsigned char RX_ADDRESS[RX_ADR_WIDTH]={0x34,0x43,0x10,0x10,0x01}; //P0接收地址
const unsigned char RX1_ADDRESS[RX_ADR_WIDTH]={0x02,0xc2,0xc2,0xc2,0xc2}; //P1接收地址
const unsigned char RX2_ADDRESS[RX_ADR_WIDTH]={0x01,0xc2,0xc2,0xc2,0xc2}; //P1接收地址
							    
//初始化24L01的IO口
void NRF24L01_Init(void)
{
	Set_NRF24L01_CE
	Set_NRF24L01_CSN; 
	Clr_NRF24L01_CE; 	//使能24L01
	Set_NRF24L01_CSN;	//SPI片选取消	
}

unsigned char SPIx_ReadWriteByte(unsigned char TxData)
{
	
	unsigned int retry=0;		
	__HAL_SPI_ENABLE(&hspi1);	
	while((SPI1->SR&1<<1)==0)//等待发送区空	
	{
		retry++;
		if(retry>2000)return 0;
	}			  
	SPI1->DR=TxData;	 	  //发送一个byte 
	retry=0;
	while((SPI1->SR&1<<0)==0) //等待接收完一个byte  
	{
		retry++;
		if(retry>2000)return 0;
	}	  						    
	return SPI1->DR;          //返回收到的数据	
}
//检测24L01是否存在
//返回值:0，成功;1，失败	
unsigned char NRF24L01_Check(void)
{
	unsigned char buf[5]={0XA5,0XA5,0XA5,0XA5,0XA5};
	
	unsigned char i;
	
	SPIx_SetSpeed(SPI_SPEED_4); //spi速度为9Mhz（24L01的最大SPI时钟为10Mhz）   
	
	NRF24L01_Write_Buf(NRF24L01_WRITE_REG+TX_ADDR,buf,5);//写入5个字节的地址.	
	
	NRF24L01_Read_Buf(TX_ADDR,buf,5); //读出写入的地址  
	
	for(i=0;i<5;i++)
	{
		
	  if(buf[i]!=0XA5)break;	 
		
	}
	if(i!=5)return 1;//检测24L01错误	
	
	return 0;		 //检测到24L01
	
}		 
//SPI写寄存器
//reg:指定寄存器地址
//value:写入的值
unsigned char NRF24L01_Write_Reg(unsigned char reg,unsigned char value)
	{
		unsigned char status;	
		
		Clr_NRF24L01_CSN;                 //使能SPI传输
		
		status =SPIx_ReadWriteByte(reg);//发送寄存器号 
		
		SPIx_ReadWriteByte(value);      //写入寄存器的值
		
		Set_NRF24L01_CSN;                 //禁止SPI传输	 
		
		return(status);       			//返回状态值
	}

//读取SPI寄存器值
//reg:要读的寄存器
unsigned char NRF24L01_Read_Reg(unsigned char reg)
	{
		unsigned char reg_val;	
    
		Clr_NRF24L01_CSN;          //使能SPI传输		
		
		SPIx_ReadWriteByte(reg);   //发送寄存器号
		
		reg_val=SPIx_ReadWriteByte(0XFF);//读取寄存器内容
		
		Set_NRF24L01_CSN;          //禁止SPI传输		    
		
		return(reg_val);           //返回状态值
	}	

//在指定位置读出指定长度的数据
//reg:寄存器(位置)
//*pBuf:数据指针
//len:数据长度
//返回值,此次读到的状态寄存器值 
unsigned char NRF24L01_Read_Buf(unsigned char reg,unsigned char *pBuf,unsigned char len)
	{
		unsigned char status,NUM;	  		
		Clr_NRF24L01_CSN;           //使能SPI传输		
		status=SPIx_ReadWriteByte(reg);//发送寄存器值(位置),并读取状态值  		
		for( NUM=0;NUM<len;NUM++)pBuf[NUM]=SPIx_ReadWriteByte(0XFF);//读出数据		
		Set_NRF24L01_CSN;       //关闭SPI传输		
		return status;        //返回读到的状态值		
	}
//在指定位置写指定长度的数据
//reg:寄存器(位置)
//*pBuf:数据指针
//len:数据长度
//返回值,此次读到的状态寄存器值
unsigned char NRF24L01_Write_Buf(unsigned char reg, unsigned char *pBuf, unsigned char len)
	{		
		unsigned char status,NUM;	 			
		Clr_NRF24L01_CSN;          //使能SPI传输			
		status = SPIx_ReadWriteByte(reg);//发送寄存器值(位置),并读取状态值			
		for(NUM=0; NUM<len; NUM++)SPIx_ReadWriteByte(*pBuf++); //写入数据				
		Set_NRF24L01_CSN;       //关闭SPI传输			
		return status;          //返回读到的状态值		
	}				   		
	//读数据在自动应答中
void NRF24L01_Read_ACKPacket(uint8_t *tx_pload)
{
  NRF24L01_Read_Buf(NRF24L01_RD_RX_PLOAD,tx_pload,RX_PLOAD_WIDTH);//读取数据
}
extern uint16_t shudu;
//启动NRF24L01发送一次数据
//txbuf:待发送数据首地址
//返回值:发送完成状况
unsigned char NRF24L01_TxPacket(unsigned char *txbuf)
	{
	unsigned char sta;
        uint8_t buffer[32] = {0};		
	//SPIx_SetSpeed(SPI_SPEED_8);//spi速度为9Mhz（24L01的最大SPI时钟为10Mhz）   		
	Clr_NRF24L01_CE;		
	NRF24L01_Write_Buf(NRF24L01_WR_TX_PLOAD,txbuf,TX_PLOAD_WIDTH);//写数据到TX BUF  32个字节		
	Set_NRF24L01_CE;//启动发送			
	while(NRF24L01_IRQ!=0);//等待发送完成		
	sta=NRF24L01_Read_Reg(STATUS);  //读取状态寄存器的值	  		
	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+STATUS,sta); //清除TX_DS或MAX_RT中断标志		
	NRF24L01_Write_Reg(NRF24L01_FLUSH_TX,0xff);//清除TX FIFO寄存器 		
	if(sta&MAX_TX)//达到最大重发次数
		{							
		  return MAX_TX; 			
		}
	if(sta&TX_OK)//发送完成
	{
		shudu ++;
		NRF24L01_Read_ACKPacket(buffer);
		if(buffer[0] == 0)
			return TX_OK;
		if(buffer[0] == 33)
		{
			memcpy((void *)&linecoding_old,(void *)(buffer+1),sizeof(linecoding));
			return TX_OK;
		}
		CDC_Transmit_FS(buffer+1, buffer[0]);
		return TX_OK;		
	}
	return 0xff;//其他原因发送失败
	}
//启动NRF24L01接收一次数据
//txbuf:待接收数据首地址
//返回值:0，接收完成；其他，错误代码
unsigned char NRF24L01_RxPacket(unsigned char *rxbuf)
	{
	unsigned char sta;	
		
	//SPIx_SetSpeed(SPI_SPEED_8); //spi速度为9Mhz（24L01的最大SPI时钟为10Mhz）  
		
	sta=NRF24L01_Read_Reg(STATUS);  //读取状态寄存器的值    	 
		
	//NRF24L01_Write_Reg(NRF24L01_WRITE_REG+STATUS,sta|0x40); //清除RX_OK中断标志
		
	if(sta&RX_OK)//接收到数据
		{
			NRF24L01_Write_Reg(NRF24L01_WRITE_REG+STATUS,sta|0x40); //清除RX_OK中断标志
		  NRF24L01_Read_Buf(NRF24L01_RD_RX_PLOAD,rxbuf,RX_PLOAD_WIDTH);//读取数据
			
		  NRF24L01_Write_Reg(NRF24L01_FLUSH_RX,0xff);//清除RX FIFO寄存器 
			
		  return 0; 
		}	
		
	return 1;//没收到任何数据
		
	}						    
//该函数初始化NRF24L01到RX模式
//设置RX地址,写RX数据宽度,选择RF频道,波特率和LNA HCURR
//当CE变高后,即进入RX模式,并可以接收数据了
void RX_Mode(void)
{
	Clr_NRF24L01_CE;
	NRF24L01_Write_Buf(NRF24L01_WRITE_REG+RX_ADDR_P0,(unsigned char*)RX_ADDRESS,RX_ADR_WIDTH);//写RX节点地址
	NRF24L01_Write_Buf(NRF24L01_WRITE_REG+RX_ADDR_P1,(unsigned char*)TX1_ADDRESS,RX_ADR_WIDTH);
	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+EN_AA,0x03);    //使能通道0和1的自动应答    
	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+EN_RXADDR,0x03);//使能通道0和1的接收地址  	 
	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+RF_CH,40);	     //设置RF通信频率		  
	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);//选择通道0的有效数据宽度 	 
	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+RX_PW_P1,RX_PLOAD_WIDTH);//选择通道0的有效数据宽度
	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+RF_SETUP,0x0f);//设置TX发射参数,0db增益,2Mbps,低噪声增益开启   
	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+CONFIG, 0x0f);//配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式 
	Set_NRF24L01_CE; //CE为高,进入接收模式 
//	delay_us(10); //CE要拉高一段时间才进入接收模式
}
							 
//该函数初始化NRF24L01到TX模式
//设置TX地址,写TX数据宽度,设置RX自动应答的地址,填充TX发送数据,选择RF频道,波特率和LNA HCURR
//PWR_UP,CRC使能
//当CE变高后,即进入RX模式,并可以接收数据了		   
//CE为高大于10us,则启动发送.	 
void TX_Mode(void)
	{														 
		Clr_NRF24L01_CE;	  
		
		NRF24L01_Write_Buf(NRF24L01_WRITE_REG+TX_ADDR,(unsigned char*)TX1_ADDRESS,TX_ADR_WIDTH);//写TX节点地址 
		
		NRF24L01_Write_Buf(NRF24L01_WRITE_REG+RX_ADDR_P0,(unsigned char*)TX1_ADDRESS,RX_ADR_WIDTH); //设置RX节点地址,主要为了使能ACK	  
		NRF24L01_Write_Reg(NRF24L01_WRITE_REG+EN_AA,0x01);     //使能通道1的自动应答    
		NRF24L01_Write_Reg(NRF24L01_WRITE_REG+EN_RXADDR,0x01); //使能通道1的接收地址  
		NRF24L01_Write_Reg(NRF24L01_WRITE_REG+SETUP_RETR,0x2a);//设置自动重发间隔时间:750us + 86us;最大自动重发次数:10次
		NRF24L01_Write_Reg(NRF24L01_WRITE_REG+RF_CH,110);       //设置RF通道为120
		NRF24L01_Write_Reg(NRF24L01_WRITE_REG+RF_SETUP,0x0f);  //设置TX发射参数,0db增益,2Mbps,低噪声增益开启   		
		NRF24L01_Write_Reg(NRF24L01_WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);//选择通道0的有效数据宽度 	   	
		NRF24L01_Write_Reg(NRF24L01_WRITE_REG+FEATURE, 0x02);
	
		if(NRF24L01_Read_Reg(FEATURE) == 0x00 && (NRF24L01_Read_Reg(DYNPD) == 0x00))
		{
			Clr_NRF24L01_CSN;                 //使能SPI传输			
			SPIx_ReadWriteByte(LOCK_UNLOCK);//发送寄存器号 			
			SPIx_ReadWriteByte(0x73);      //写入寄存器的值			
			Set_NRF24L01_CSN;                 //禁止SPI传输	 
			NRF24L01_Write_Reg(NRF24L01_WRITE_REG+FEATURE, 0x02);  // Enables payload in ack
		}
		NRF24L01_Write_Reg(NRF24L01_WRITE_REG+FEATURE, (NRF24L01_Read_Reg(FEATURE) | 0x04));
		NRF24L01_Write_Reg(NRF24L01_WRITE_REG+DYNPD, ALL_PIPES & ~0xC0); 		
		NRF24L01_Write_Reg(NRF24L01_WRITE_REG+CONFIG,0x0e);    //配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式,开启所有中断
		Set_NRF24L01_CE;//CE为高,10us后启动发送
		
//		delay_us(10); //CE要拉高一段时间才进入发送模式
		
	}		

void RX_Mode1(uint8_t ch)
{
	Clr_NRF24L01_CE;	  
	NRF24L01_Write_Buf(NRF24L01_WRITE_REG+RX_ADDR_P0,(unsigned char*)RX_ADDRESS,RX_ADR_WIDTH);//写RX节点地址

	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+EN_AA,0x01);    //使能通道0的自动应答    
	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+EN_RXADDR,0x01);//使能通道0的接收地址  	 
	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+RF_CH,ch);	     //设置RF通信频率		  
	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);//选择通道0的有效数据宽度 	    
	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+RF_SETUP,0x0f);//设置TX发射参数,0db增益,2Mbps,低噪声增益开启   
	NRF24L01_Write_Reg(NRF24L01_WRITE_REG+CONFIG, 0x0f);//配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式 
	Set_NRF24L01_CE; //CE为高,进入接收模式 
}		

主程序代码：

  while (1)
  {
		if(	linecoding_old.bitrate != linecoding.bitrate ||
				linecoding_old.datatype != linecoding.datatype ||
				linecoding_old.format != linecoding.format ||
				linecoding_old.paritytype != linecoding.paritytype	)
		{
			buffer[0] = 33;//特殊串口设置指令
			memcpy((void *)(buffer+1),(void *)&linecoding,sizeof(linecoding));
		}
		else if((length(&Qusart2Send) > 0))
		{
			for(i = 1; i < 32; i ++)
			{
				if(dequene(&Qusart2Send,&data) == -1 )
					break;
				buffer[i] = data.buffer;
			}
			buffer[0] = i - 1;	
		}
		NRF24L01_TxPacket(buffer);
		buffer[0] = 0;
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
  }
  /* USER CODE END 3 */
}

实物图片：

在实际使用中发现，硬件功耗大概在130ma左右，在数据交互的时候功耗会增加至170ma左右，不过并不影响模块的使用。

使用该模块的最大好处就是可以让硬件工程师的桌面更加的整洁。

在软件开发时候，有以下的注意事项：

抗干扰能力：NRF24L01工作在2.4GHz频段，该频段易受到WiFi、蓝牙等设备的干扰。在布局布线时要尽量减少干扰源的影响，并合理设置通信参数以提高抗干扰能力。

功耗管理：在不需要通信时及时将NRF24L01置于待机模式或掉电模式以降低功耗。

距离与障碍物：无线通信距离受环境因素影响较大，障碍物会严重影响通信质量。在实际应用中要考虑通信距离和障碍物的影响并采取相应的措施。

NRF24L01的开发过程需要仔细规划硬件连接、合理配置软件参数、掌握调试技巧并关注实际应用中的注意事项。通过不断的实践和总结可以逐渐提高开发效率和应用效果。