NRF24L01 大数据分包组包传输

NRF24L01一个数据包最大32字节，对于视频音频不适用，定义一个应用层协议对传输数据进行分包组包，应用层数据收发队列存储，向对方发送数据进行拆包，每发一包应答确认超时重发，接收完整大数据包向应用层提交

协议

typedef union _SEG_STA{
	uint8_t		byte;
	struct{
		uint8_t		data_len:5;
		uint8_t		reserve:3;
	}transmit;
	struct{
		uint8_t		reserve:6;
		uint8_t		status:2;			///<0:seg_ok,1:frame_ok,2:seg_no error,3:crc error
	}reply;
}SEG_STA_T;

typedef struct MSG_T{
	uint8_t		seg_no;					///<当前段号
	uint8_t		seg_total;				///<总段数
	uint8_t		source_addr;			///<源地址
	SEG_STA_T	seg_sta;				///<段状态
	uint8_t		seg_data[MSG_DATA_LEN];	///<分段数据
	
}MSG_T;

源文件

/** 
* @file         rf_module.c 
* @brief        NRF24L01模块驱动. 
* @details  	数据分包及组包，重发处理,校验处理. 
* @author       ken deng 
* @date     	2019-07-29 
* @version  	A001 
* @par Copyright (c):  
*       
* @par History:          
*   version: ken deng, 2019-07-29, 建立\n 
*/  
#include "rf_module.h"
#include "tm_stm32_delay.h"
#include "tm_stm32_nrf24l01.h"
#include "tm_stm32_exti.h"
#include "system.h"
#include "daemon.h"
#include "protocol.h"
#include "comm.h"
#include "crc32.h"
#include "config.h"
#include "main.h"
#include "config.h"
/*
rf24L01配置注意:
地址，地址宽度，频道，开启或关闭CRC，CRC8bit或16bit
*/

RF_MODULE_T		rf_module;

//#undef RF_MODULE_DEBUG

#ifdef RF_MODULE_DEBUG
    #define rf_module_log(...) do{if(DEBUG(DEBUG_ENABLE)){DBG_LOG("[RF_MODULE](%ld) ",__LINE__);DBG_LOG(__VA_ARGS__);}}while(0)
    #define rf_module_usr(...) do{if(DEBUG(DEBUG_ENABLE)){DBG_LOG("[RF_MODULE] ");DBG_USR(__VA_ARGS__);}}while(0)
    #define rf_module_err(...) do{if(DEBUG(DEBUG_ENABLE)){DBG_LOG("[RF_MODULE] ");DBG_ERR(__VA_ARGS__);}}while(0)
    #define rf_module_dump(...) if(DEBUG(DEBUG_ENABLE)){DBG_DUMP(__VA_ARGS__);}
#else
    #define rf_module_log(...)
    #define rf_module_usr(...)
    #define rf_module_err(...)
    #define rf_module_dump(...)
#endif
	
/* NRF24L01+ registers*/
#define NRF24L01_REG_CONFIG			0x00	//Configuration Register
#define NRF24L01_REG_EN_AA			0x01	//Enable 慉uto Acknowledgment?Function
#define NRF24L01_REG_EN_RXADDR		0x02	//Enabled RX Addresses
#define NRF24L01_REG_SETUP_AW		0x03	//Setup of Address Widths (common for all data pipes)
#define NRF24L01_REG_SETUP_RETR		0x04	//Setup of Automatic Retransmission
#define NRF24L01_REG_RF_CH			0x05	//RF Channel
#define NRF24L01_REG_RF_SETUP		0x06	//RF Setup Register	
#define NRF24L01_REG_STATUS			0x07	//Status Register
#define NRF24L01_REG_OBSERVE_TX		0x08	//Transmit observe registerf
#define NRF24L01_REG_RPD			0x09	
#define NRF24L01_REG_RX_ADDR_P0		0x0A	//Receive address data pipe 0. 5 Bytes maximum length.
#define NRF24L01_REG_RX_ADDR_P1		0x0B	//Receive address data pipe 1. 5 Bytes maximum length.
#define NRF24L01_REG_RX_ADDR_P2		0x0C	//Receive address data pipe 2. Only LSB
#define NRF24L01_REG_RX_ADDR_P3		0x0D	//Receive address data pipe 3. Only LSB
#define NRF24L01_REG_RX_ADDR_P4		0x0E	//Receive address data pipe 4. Only LSB
#define NRF24L01_REG_RX_ADDR_P5		0x0F	//Receive address data pipe 5. Only LSB
#define NRF24L01_REG_TX_ADDR		0x10	//Transmit address. Used for a PTX device only
#define NRF24L01_REG_RX_PW_P0		0x11	
#define NRF24L01_REG_RX_PW_P1		0x12	
#define NRF24L01_REG_RX_PW_P2		0x13	
#define NRF24L01_REG_RX_PW_P3		0x14	
#define NRF24L01_REG_RX_PW_P4		0x15	
#define NRF24L01_REG_RX_PW_P5		0x16	
#define NRF24L01_REG_FIFO_STATUS	0x17	//FIFO Status Register
#define NRF24L01_REG_DYNPD			0x1C	//Enable dynamic payload length
#define NRF24L01_REG_FEATURE		0x1D

	
EventGroupHandle_t rf_module_event_handler = NULL;    /*定义事件标志组*/
#define EVENTBIT_TRANSMIT_OK  		(1<<0)              
#define EVENTBIT_TRANSMIT_TIMEOUT  	(1<<1)
#define EVENTBIT_TRANSMIT_BIT    	(EVENTBIT_TRANSMIT_OK|EVENTBIT_TRANSMIT_TIMEOUT)

/** 
* 分别设置3个通道的接收地址. 
* 无. 
* @param[in]   addr:地址，pipe:通道号. 
* @param[out]  无.  
* @retval  无  
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      ken deng于2019-07-29创建 
*/
void rf_module_set_rx_addr(uint32_t addr, uint8_t pipe){
	
	uint8_t buf[5]={0};
	buf[0] = pipe;
	buf[1] = (addr&0xff);
	buf[2] = ((addr>>8)&0xff);
	buf[3] = ((addr>>16)&0xff);
	buf[4] = ((addr>>24)&0xff);
	switch( pipe ){
		case 1:
			NRF24L01_CE_LOW;
			TM_NRF24L01_WriteRegisterMulti(NRF24L01_REG_RX_ADDR_P1, buf, 5);
			NRF24L01_CE_HIGH;
			break;
		case 2:
			NRF24L01_CE_LOW;
			TM_NRF24L01_WriteRegisterMulti(NRF24L01_REG_RX_ADDR_P2, &pipe, 1);
			NRF24L01_CE_HIGH;
			break;
		case 3:
			NRF24L01_CE_LOW;
			TM_NRF24L01_WriteRegisterMulti(NRF24L01_REG_RX_ADDR_P3, &pipe, 1);
			NRF24L01_CE_HIGH;
			break;
		case 4:
			NRF24L01_CE_LOW;
			TM_NRF24L01_WriteRegisterMulti(NRF24L01_REG_RX_ADDR_P4, &pipe, 1);
			NRF24L01_CE_HIGH;
			break;
		case 5:
			NRF24L01_CE_LOW;
			TM_NRF24L01_WriteRegisterMulti(NRF24L01_REG_RX_ADDR_P5, &pipe, 1);
			NRF24L01_CE_HIGH;
			break;
	}
}

/** 
* 设置发送通道的发送地址. 
* 无. 
* @param[in]   addr:地址. 
* @param[out]  无.  
* @retval  无  
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      ken deng于2019-07-29创建 
*/
void rf_module_set_tx_addr(uint32_t addr, uint8_t pipe){
	
	uint8_t buf[5]={0};
	buf[0] = pipe;
	buf[1] = (addr&0xff);
	buf[2] = ((addr>>8)&0xff);
	buf[3] = ((addr>>16)&0xff);
	buf[4] = ((addr>>24)&0xff);
	TM_NRF24L01_SetTxAddress(buf);
}

/** 
* 写队列. 
* 申请内存成功后，写入队列. 
* @param[in]   queue:队，addr：地址指针，data：数据指针，len：数据长度，isr：是否在中断调用. 
* @param[out]  无.  
* @retval  无  
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      ken deng于2019-07-29创建 
*/
FUN_STATUS_T rf_module_write_queue(QueueHandle_t queue, RF_MSG_T *rf_msg_ptr, void *data, uint8_t isr)
{	
	rf_msg_ptr->data = (uint8_t*)malloc(rf_msg_ptr->len);
		
	if( (rf_msg_ptr->data != NULL) && (queue != NULL) ){
		
		memcpy(rf_msg_ptr->data,data,rf_msg_ptr->len);

		BaseType_t xReturn;
		
		if( isr )
			xReturn = xQueueSendFromISR(queue,rf_msg_ptr,0);
		else
			xReturn = xQueueSend(queue,rf_msg_ptr,0);
				
		if( xReturn == pdTRUE )
			return FUN_OK;
		else{
			free(rf_msg_ptr->data);
			return FUN_ERROR;
		}
	}
	else{
		if( rf_msg_ptr->data != NULL ){
			free(rf_msg_ptr->data);
		}
		return FUN_ERROR;
	}
}

/** 
* 读队列. 
* 拷贝数据到数据指针，并释放内存区.
* @param[in]   queue:队，addr：返回地址，data：返回数据指针. 
* @param[out]  无.  
* @retval  无  
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      ken deng于2019-07-29创建 
*/
uint16_t rf_module_read_queue(QueueHandle_t queue, uint32_t *addr, uint8_t *pipe, void *data){
	
	RF_MSG_T	recv_msg;
	if( queue != NULL ){
		if( xQueueReceive(queue,&recv_msg,0)==pdPASS ){
			
			memcpy(data,recv_msg.data,recv_msg.len);
			*addr = recv_msg.addr;
			*pipe = recv_msg.pipe;
			free(recv_msg.data);
					
			return recv_msg.len;
		}
		else{
			return 0;
		}
	}
	else{
		return 0;
	}
}

/** 
* NRF24L01中断处理函数. 
* 处理发送完成中断，发送超时中断，接收成功中断.
* @param[in]   无. 
* @param[out]  无.  
* @retval  无  
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      ken deng于2019-07-29创建 
*/
void rf_module_isr_handle(void){
	
	TM_NRF24L01_IRQ_t NRF_IRQ;
	
	/* Read interrupts */
	TM_NRF24L01_Read_Interrupts(&NRF_IRQ);
	
	/* Check if transmitted OK */
	if (NRF_IRQ.F.DataSent) {
		/* Save transmission status */
		rf_module.transmissionStatus = TM_NRF24L01_Transmit_Status_Ok;
		
		/* Go back to RX mode */
		TM_NRF24L01_PowerUpRx();
		
		xEventGroupSetBits(rf_module_event_handler,EVENTBIT_TRANSMIT_OK);
		
//		rf_module_log("transmitted OK\r\n");
	}
	
	/* Check if max retransmission reached and last transmission failed */
	if (NRF_IRQ.F.MaxRT) {
		/* Save transmission status */
		rf_module.transmissionStatus = TM_NRF24L01_Transmit_Status_Lost;
		
		/* Go back to RX mode */
		TM_NRF24L01_PowerUpRx();
		
		xEventGroupSetBits(rf_module_event_handler,EVENTBIT_TRANSMIT_TIMEOUT);
		
		rf_module_log("last transmission failed\r\n");
	}
	
	/* If data is ready on NRF24L01+ */
	if (NRF_IRQ.F.DataReady) {
		/* Get data from NRF24L01+ */
		uint8_t dataIn[32];
//		uint32_t cnt;
		TM_NRF24L01_GetData(dataIn);
		uint32_t addr;
		addr = dataIn[3];
		
		RF_MSG_T	rf_msg;
		rf_msg.len = dataIn[0];
		rf_msg.wait_reply = 0;
		rf_msg.addr = dataIn[3];
		rf_msg.pipe = 0;
		
		if( FUN_OK != rf_module_write_queue(rf_module.recv_queue, &rf_msg, &dataIn[1], 1) ){
			rf_module_log("Recv data enqueue Error\r\n");
		}
//		rf_module_log("Get data from NRF24L01+\r\n");
		
		rf_module.send_sta.delay_time = 0;
				
//			rf_module_dump((uint8_t*)dataIn,32);
	}
}

/** 
* 将RF发送队列的数据读出并向NRF24L01模块写入. 
* 最大重发3次.
* @param[in]   pvParameters：线程参数. 
* @param[out]  无.  
* @retval  无  
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      ken deng于2019-07-29创建 
*/
void rf_module_send_task( void *pvParameters )
{
	wait_for_startup();
	
	TickType_t ticks = xTaskGetTickCount();
	MSG_T		msg;
//	uint8_t		wait_reply;
	
	while(1){
		
		if( rf_module.send_sta.delay_time < 255 ){
			rf_module.send_sta.delay_time++;
		}
		if( (rf_module.send_sta.delay_time >= RF_SEND_DELAY_TIME) && is_rf_on() ){
			
			uint16_t len;
			len=rf_module_read_queue(rf_module.send_queue, &rf_module.send_sta.addr, &rf_module.send_sta.pipe, &msg);
			if( len>0 ){
				
				uint8_t		dataOut[32];
				
//				uint8_t cd;
				
				rf_module_set_target(rf_module.send_sta.addr, rf_module.send_sta.pipe);

				#if defined(USE_USB_RF_MODULE)
				memcpy(&dataOut[1],&msg,len);
				dataOut[0] = len;
				#else
				memcpy(dataOut,&msg,len);
				#endif
				
				EventBits_t event_bits=0;
				rf_module.send_sta.resend_times = 0;
				
				do{
//					do{
//						cd = TM_NRF24L01_ReadRegister(NRF24L01_REG_RPD);
//					}while( cd==1 );
//					rf_module_log("seg send %d\r\n",rf_module.send_sta.resend_times);
										
					TM_NRF24L01_Transmit(dataOut);
					event_bits = xEventGroupWaitBits(rf_module_event_handler,EVENTBIT_TRANSMIT_BIT,pdTRUE,pdFALSE,50);
					rf_module.send_sta.resend_times++;
					
				}while(rf_module.send_sta.resend_times<=RESEND_TIMES && (event_bits&EVENTBIT_TRANSMIT_OK)!=EVENTBIT_TRANSMIT_OK );
				
				if( rf_module.send_sta.resend_times>=RESEND_TIMES ){
					rf_module_log("resend times maxim\r\n");
				}	
				
			}
			rf_module.send_sta.delay_time = 0;
		}
		vTaskDelayUntil( &ticks, 10 );
	}
}

/** 
* 根据接收的地址，初始化接收缓冲区. 
* 最大重发3次.
* @param[in]   addr：接收的数据包地址. 
* @param[out]  无.  
* @retval  RF_RECV_STA_T *:返回接收数据处理数据句柄  
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      ken deng于2019-08-19创建 
*/
RF_RECV_STA_T * rf_module_find_recv_ptr( uint32_t addr )
{
	for( uint8_t i=0; i<EVT_NUM; i++ ){
		if( rf_module.recv_sta[i].sur_addr == addr ){
			return &rf_module.recv_sta[i];
		}
	}
	
	for( uint8_t i=0; i<EVT_NUM; i++ ){
		if( rf_module.recv_sta[i].sur_addr == 0 ){
			memset( &rf_module.recv_sta[i], 0, sizeof(RF_RECV_STA_T) );
			rf_module.recv_sta[i].sur_addr = addr;
			return &rf_module.recv_sta[i];
		}
	}
	
	return NULL;
}

/** 
* 将RF发送队列的数据读出并向NRF24L01模块写入. 
* 最大重发3次.
* @param[in]   pvParameters：线程参数. 
* @param[out]  无.  
* @retval  无  
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      ken deng于2019-07-29创建 
*/
/*
void rf_module_recv_task( void *pvParameters ){
	
	TickType_t ticks = xTaskGetTickCount();
	MSG_T		msg;
//	uint8_t		wait_reply;
	uint8_t		seg_cnt=0,total_cnt=0;
	while(1){
		
		if( rf_module_read_queue(rf_module.recv_queue, &rf_module.recv_sta.sur_addr, &msg) ){
			
			switch(rf_module.recv_sta.step){
				
				case 0:
					
					if( msg.seg_no==1 && msg.seg_total<=RECV_QUEUE_LENGTH ){
						rf_module.recv_sta.buf = malloc(MSG_DATA_LEN*msg.seg_total);
						if( rf_module.recv_sta.buf!=NULL ){
							rf_module.recv_sta.len = 0;
							memcpy((void*)(rf_module.recv_sta.buf + rf_module.recv_sta.len),msg.seg_data,msg.seg_sta.transmit.data_len);
							rf_module.recv_sta.len += msg.seg_sta.transmit.data_len;
							
							rf_module.recv_sta.step = 1;
							rf_module.recv_sta.timeout = 0;
							seg_cnt = 1;
							total_cnt = msg.seg_total;
						}
					}
					break;
					
				case 1:
					if( seg_cnt<total_cnt ){
						seg_cnt++;
						memcpy(rf_module.recv_sta.buf + rf_module.recv_sta.len,msg.seg_data,msg.seg_sta.transmit.data_len);
						rf_module.recv_sta.len += msg.seg_sta.transmit.data_len;					
						
						rf_module.recv_sta.timeout = 0;
					}
					else{
						free(rf_module.recv_sta.buf);
						rf_module.recv_sta.step=0;
					}
					break;
			}
			
			if( msg.seg_no == msg.seg_total ){
						
				int cnt;
				uint32_t crc,*recv_crc;
				recv_crc = (uint32_t*)(rf_module.recv_sta.buf+rf_module.recv_sta.len-4);
				crc = crc32(rf_module.recv_sta.buf,rf_module.recv_sta.len-4);
				if( crc == *recv_crc ){
//					cbuf_clear(&rf_module.cbsta);
//					cbuf_writebk(&rf_module.cbsta,rf_module.recv_sta.buf,rf_module.recv_sta.len-4,&cnt);
					comm_recv_in_queue(rf_module.recv_sta.buf, rf_module.recv_sta.len-4);
//					comm_recv_complete();
					rf_module.recv_sta.step = 0;
//					free(rf_module.recv_sta.buf);
					rf_module.recv_sta.buf = NULL;
					
				}
			}
		}
		
		///<receive timout reset receive process
		if( rf_module.recv_sta.step!=0 ){
			
			if( rf_module.recv_sta.timeout++ > RF_RECV_TIMEOUT_TIME ){
				free(rf_module.recv_sta.buf);
				rf_module.recv_sta.step=0;
			}
		}
		vTaskDelayUntil( &ticks, 10 );
	}
}
*/
void rf_module_recv_task( void *pvParameters )
{

	wait_for_startup();
	
	TickType_t ticks = xTaskGetTickCount();
	MSG_T		msg;
//	uint8_t		wait_reply;
	uint8_t		seg_cnt=0,total_cnt=0,pipe;
	uint32_t 	recv_addr;
	RF_RECV_STA_T * recv_ptr;
	while(1){
		
		if( rf_module_read_queue(rf_module.recv_queue, &recv_addr, &pipe, &msg) ){
			
			recv_ptr = rf_module_find_recv_ptr(recv_addr);
			
			if( recv_ptr!=NULL ){
			
				switch(recv_ptr->step){
					
					case 0:
						
						if( msg.seg_no==1 && msg.seg_total<=RECV_QUEUE_LENGTH ){
							recv_ptr->buf = malloc(MSG_DATA_LEN*msg.seg_total);
							if( recv_ptr->buf!=NULL ){
								recv_ptr->len = 0;
								memcpy((void*)(recv_ptr->buf + recv_ptr->len),msg.seg_data,msg.seg_sta.transmit.data_len);
								recv_ptr->len += msg.seg_sta.transmit.data_len;
								
								recv_ptr->step = 1;
								recv_ptr->timeout = 0;
								seg_cnt = 1;
								total_cnt = msg.seg_total;
							}
						}
						break;
						
					case 1:
						if( seg_cnt<total_cnt ){
							seg_cnt++;
							memcpy(recv_ptr->buf + recv_ptr->len,msg.seg_data,msg.seg_sta.transmit.data_len);
							recv_ptr->len += msg.seg_sta.transmit.data_len;					
							
							recv_ptr->timeout = 0;
						}
						else{
							free(recv_ptr->buf);
							recv_ptr->step=0;
							//段错误计数
							recv_ptr->err_sta.seg_err++;
						}
						break;
				}
				
				if( msg.seg_no == msg.seg_total ){
							
					int cnt;
					uint32_t crc,*recv_crc;
					recv_crc = (uint32_t*)(recv_ptr->buf+recv_ptr->len-4);
					//rf_module_log("len=%d\r\n",recv_ptr->len);
					if( recv_ptr->len > 4 ){
						crc = crc32(recv_ptr->buf,recv_ptr->len-4);
						if( crc == *recv_crc ){
							comm_recv_in_queue(recv_ptr->buf, recv_ptr->len-4);
							
	//						rf_module_dump(recv_ptr->buf, recv_ptr->len-4);
	//						char buf[20];
	//						memcpy(buf,recv_ptr->buf,recv_ptr->len-4);
	//						rf_module_log("%s",buf);
							
							//memset( recv_ptr, 0, sizeof(RF_RECV_STA_T) );
							recv_ptr->step = 0;
							recv_ptr->buf = NULL;
							recv_ptr->len= 0;
							recv_ptr->timeout = 0;
						}
						else{
							//CRC错误计数
							recv_ptr->err_sta.crc_err++;
						}
					}
					else{
						recv_ptr->err_sta.size_err++;
					}
				}
			}
		}
		
		for( uint8_t i=0; i<EVT_NUM; i++ ){
			if( rf_module.recv_sta[i].sur_addr != 0 ){
				if( rf_module.recv_sta[i].timeout++ > RF_RECV_TIMEOUT_TIME ){
					free(rf_module.recv_sta[i].buf);
					memset( &rf_module.recv_sta[i], 0, sizeof(RF_RECV_STA_T) );
				}
			}
		}
		
		vTaskDelayUntil( &ticks, 10 );
	}
}

/** 
* 向RF模块发送队列写入发送数据. 
* 将数据分包写入RF模块发送队列. 
* @param[in]   addr:发送地址,ptr:发送数据指针,size;发送数据大小. 
* @param[out]  无.  
* @retval  成功发送数据大小
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      ken deng于2019-07-29创建 
*/
uint32_t rf_module_send(uint32_t target_addr, uint32_t source_addr,  uint8_t chn, uint8_t *ptr, uint16_t size )
{	
	uint16_t 	send_len,seg=0,send_ptr=0;
	uint32_t	crc;

	MSG_T		msg;
	memset(&msg,0,sizeof(MSG_T));
	
	crc = crc32(ptr,size);
	
	void *data;
	data = malloc(size+4);
	if( data!=NULL ){
		memcpy(data,ptr, size);
		memcpy((void*)(data+size),(void*)&crc, 4);
		
		size += 4;
		
		msg.seg_total = size/MSG_DATA_LEN;
		if( size%MSG_DATA_LEN )
			msg.seg_total += 1;
		///<发送EBB8位地址
		msg.source_addr = source_addr&0xff;
		
		while( send_ptr<size ){
			
			if( (size-send_ptr)>MSG_DATA_LEN ){
				memcpy((void*)msg.seg_data,(void*)(data+send_ptr),MSG_DATA_LEN);
				send_ptr += MSG_DATA_LEN;
				msg.seg_no = ++seg;
				msg.seg_sta.transmit.data_len= MSG_DATA_LEN;
				
				send_len = sizeof(MSG_T);
			}
			else{
				memcpy((void*)msg.seg_data,(void*)(data+send_ptr),(size-send_ptr));
				send_len = sizeof(MSG_T);
				send_len = sizeof(MSG_T) - MSG_DATA_LEN + (size-send_ptr);
				msg.seg_sta.transmit.data_len= (size-send_ptr);
				send_ptr += (size-send_ptr);
				msg.seg_no = ++seg;
				size = 0;
			}
			
			RF_MSG_T	rf_msg;
			rf_msg.len = send_len;
			rf_msg.wait_reply = 0;
			rf_msg.addr = target_addr;
			rf_msg.pipe = chn;
			
			if( FUN_OK != rf_module_write_queue(rf_module.send_queue, &rf_msg, &msg, 0) ){
				rf_module_log("Send data enqueue Error\r\n");
			}
		}
		
		free(data);
		return size;
	}
	return 0;
}

/** 
* 计算的目标的地址，并设置发送通道地目标地址. 
* 无. 
* @param[in]   target:目标地址. 
* @param[out]  无.  
* @retval  成功发送数据大小
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      ken deng于2019-07-29创建 
*/
void rf_module_set_target(uint32_t target, uint8_t pipe){
	
	rf_module_set_tx_addr(target,pipe);
}

/** 
* 初始化NRF24L01模块，并启动中断检测，启动发送及接收线程,建立发送队列及接收队列. 
* 无. 
* @param[in]   target:目标地址. 
* @param[out]  无.  
* @retval  1：初始化成功，0：初始化失败
* @par 标识符 
*      保留 
* @par 其它 
*      无 
* @par 修改日志 
*      ken deng于2019-07-29创建 
*/
FUN_STATUS_T rf_module_init(void){
	
	memset(&rf_module,0,sizeof(RF_MODULE_T));
	
	/* Initialize NRF24L01+ on channel 15 and 32bytes of payload */
	/* By default 2Mbps data rate and 0dBm output power */
	/* NRF24L01 goes to RX mode by default */
	TM_NRF24L01_Init(0, 32);
	
	/* Set 2MBps data rate and -18dBm output power */
	TM_NRF24L01_SetRF(TM_NRF24L01_DataRate_2M, TM_NRF24L01_OutputPower_0dBm);
	
	TM_NRF24L01_WriteRegister(NRF24L01_REG_SETUP_AW, 	3);
	
	rf_module_set_rx_addr(EBB_RF_DEFAULT_ADDR, RF_EBB_CHN_REQ);
	rf_module_set_rx_addr(EBB_RF_DEFAULT_ADDR, RF_EBB_CHN_REG1);
	rf_module_set_rx_addr(EBB_RF_DEFAULT_ADDR, RF_EBB_CHN_POLL);
	rf_module_set_rx_addr(EBB_RF_DEFAULT_ADDR, RF_EBB_CHN_REG2);
	rf_module_set_rx_addr(EBB_RF_DEFAULT_ADDR, RF_EBB_CHN_REG3);
	
	TM_NRF24L01_PowerUpRx();
//	rf_module_set_target(0);
	
//	if( config.comm_process>=PROCESS_INIT ){
//		uint32_t addr;
//		addr = RF_DEFAULT_ADDR+config.rf_id;
//		rf_module_set_rx_addr(addr,2);
		comm_state.local_addr = addr;
//	}
//	else{
//		rf_module_set_rx_addr(0xffffffff, 2);
//	}
	
	/* Attach interrupt for NRF IRQ pin */
	TM_EXTI_Attach(RF_IRQ_PORT, RF_IRQ_PIN, TM_EXTI_Trigger_Falling);
	
	rf_module.send_queue = xQueueCreate(SEND_QUEUE_LENGTH,sizeof(RF_MSG_T));
	if( rf_module.send_queue ==0 ){
		
		rf_module_log("can not create rf send queue!!!\r\n");
		return FUN_ERROR;
	}
	
	rf_module.recv_queue = xQueueCreate(RECV_QUEUE_LENGTH,sizeof(RF_MSG_T));
	if( rf_module.recv_queue ==0 ){
		
		rf_module_log("can not create rf recv queue!!!\r\n");
		return FUN_ERROR;
	}
	
	rf_module_event_handler=xEventGroupCreate();      /*创建事件标志组*/
	
	xTaskCreate( rf_module_send_task, "RF SEND", RF_MODULE_SEND_STACK_SIZE, NULL, RF_MODULE_SEND_TASK_PRIORITY, daemon_from_create );
	xTaskCreate( rf_module_recv_task, "RF RECV", RF_MODULE_RECV_STACK_SIZE, NULL, RF_MODULE_RECV_TASK_PRIORITY, daemon_from_create );
	
	sys_status.have_rf_module = 1;
	
	return FUN_OK;
}

头文件

#ifndef __RF_MODULE_H__
#define __RF_MODULE_H__

#include "stdint.h"
#include "tm_stm32_nrf24l01.h"
#include "system.h"
#include "comm.h"
#include "macro_def.h"

#define USE_USB_RF_MODULE

#define RF_EBB_CHN_REQ		1
#define RF_EBB_CHN_REG1		2
#define RF_EBB_CHN_POLL		3
#define RF_EBB_CHN_REG2		4
#define RF_EBB_CHN_REG3		5

#define RF_EVT_CHN_REQ		1
#define RF_EVT_CHN_REG		2
#define RF_EVT_CHN_POLL		3
#define RF_EVT_CHN_PC		4
#define RF_EVT_CHN_REV		5

typedef struct{
	uint32_t	seg_err;
	uint32_t	crc_err;
	uint32_t	size_err;
}RF_ERR_STA_T;

typedef struct{
	uint8_t 	step;
	void 		*buf;
	uint16_t	len;
	uint16_t 	timeout;
	uint32_t	sur_addr;
	RF_ERR_STA_T		err_sta;
}RF_RECV_STA_T;

typedef struct{
	uint8_t		msg_id;
	uint32_t	addr;
	uint8_t		pipe;
	uint8_t		delay_time;
	uint8_t		resend_times;
}RF_SEND_STA_T;

typedef struct{
	uint8_t				msg_id;
	
	TM_NRF24L01_Transmit_Status_t transmissionStatus;
	
	QueueHandle_t		recv_queue;						///<receive queue
	QueueHandle_t		send_queue;						///<receive queue
	
	uint8_t				send_msg_id;
	
	RF_RECV_STA_T		recv_sta[EVT_NUM];
	RF_SEND_STA_T		send_sta;

}RF_MODULE_T;

typedef struct{
	
	void 		*data;				///<·¢ËÍÊý¾ÝµØÖ·
	uint32_t	addr;				///send or receive address
	uint8_t		pipe;
	uint8_t		len;
	uint8_t		wait_reply;
}RF_MSG_T;

/* Interrupt pin settings */
#define RF_IRQ_PORT    GPIOA
#define RF_IRQ_PIN     GPIO_PIN_3

#define RF_RECV_TIMEOUT_TIME		1000
#define RF_SEND_DELAY_TIME			3
#define SEND_QUEUE_LENGTH			36
#define RECV_QUEUE_LENGTH			36
#define RESEND_TIMES				3

extern RF_MODULE_T		rf_module;

extern FUN_STATUS_T rf_module_init(void);
extern void rf_module_test(void);
extern void rf_module_isr_handle(void);
extern uint32_t rf_module_recv_len(void);
extern uint32_t rf_module_read(uint8_t *ptr,uint16_t size);
extern uint32_t rf_module_send(uint32_t target_addr, uint32_t source_addr,  uint8_t chn, uint8_t *ptr, uint16_t size );
extern void rf_module_set_rx_addr(uint32_t addr, uint8_t pipe);
extern void rf_module_set_target(uint32_t target, uint8_t pipe);
#endif