一、MCU与NRF24L01通讯
采用SPI通讯协议，速率最大为10M，与普通SPI元器件稍有不同的是，多了一个CE引脚，用来开启接收、发送，以及使器件进入待机模式。具体看IC DATASHEET说明。
写寄存器指令格式为：1、SPI写寄存器地址 + 0x20
2、SPI写参数
读寄存器指令格式为：1、SPI写寄存器地址
2、SPI读参数
但少数几个指令，只需写入一个参数，如：
读STATUS寄存器： 不能使用NOP指令，读取出来参数不正确。
应使用读普通寄存器的方式，STATUS寄存器地址为0x07；
二、数据的发送
当设置芯片的寄存器，“CE”引脚需要为低电平。
用到以下几个寄存器：
1、将接收端地址写入发送地址寄存器“TX_ADDR”
2、将接收端地址写入PIPE0通道地址寄存器“RX_ADDR_P0”，开启自动应答后，PIPE0将接收接收端的应答信号。
3、使能“EN_AA”寄存器开启自动应答，使能“EN_RXADDR”中PIPE0对应的bit。
4、设置重发寄存器“SETUP_RETR”，设置重发次数以及时间间隔。
5、设置发送频道的频率“RF_CH”，以及发送功率、速率“RF_SETUP”
6、设置配置寄存器“CONFIG”，开启中断以及设置发送。
如果以上寄存器设置完毕，拉低“CE”将需要发送的数据通过“WR_TX_PLOAD”指令写入TX_FIFO，"CE"拉高“10us”以上即可
开启发送。以上寄存器设置完后，不必每次设置，接下来的发送只要不断通过“WR_TX_PLOAD”写数据至TX_FIFO即可。
发送完毕后，根据发送情况产生2种中断：“TX_DS”中断以及“MAX_RT”中断。
1、对于“TX_DS”中断，可在处理标志位后，开启下一帧传输或进行其他处理。
2、对于“MAX_RT”中断，需清除TX_FIFO。
三、数据的接收
1、设置接收通道，以及通道的地址“RX_ADDR_P0”~“RX_ADDR_P5”
2、设置接收通道接收数据的字节数“RX_PW_P0”~“RX_PW_P5”
3、设置“EN_AA”、“EN_RXADDR”、“RF_CH”、“RF_SETUP”、“CONFIG”等寄存器
4、拉高“CE”开启接收。
注意：1、假设需要开启PIPE3,接收数据。那么PIPE0~2也必须开启。即，不能单独开启后面的通道，而关闭前面的通道。
2、地址传入芯片是低字节先行。例如：
设定P0地址为：0x01，0x02，0x03，0x04，0x05
写入地址的顺序为：0x05，0x04，0x03，0x02，0x01
3、单对单传输，在“RX_DR”中断中接收数据一般不会有问题，如果是6发送，1接收。可能会出现，中断中数据尚
未接收完毕，再次产生RX_DR中断。第二次产生的中断MCU是检测不到的。此时应将接收数据的操作放于中
断外。
四、程序
1、FREERTOS模块
/**
******************************************************************************
* File Name : freertos.c
* Description : Code for freertos applications
******************************************************************************
* This notice applies to any and all portions of this file
* that are not between comment pairs USER CODE BEGIN and
* USER CODE END. Other portions of this file, whether
* inserted by the user or by software development tools
* are owned by their respective copyright owners.
*
* Copyright (c) 2018 STMicroelectronics International N.V.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted, provided that the following conditions are met:
*
* 1. Redistribution of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of STMicroelectronics nor the names of other
* contributors to this software may be used to endorse or promote products
* derived from this software without specific written permission.
* 4. This software, including modifications and/or derivative works of this
* software, must execute solely and exclusively on microcontroller or
* microprocessor devices manufactured by or for STMicroelectronics.
* 5. Redistribution and use of this software other than as permitted under
* this license is void and will automatically terminate your rights under
* this license.
*
* THIS SOFTWARE IS PROVIDED BY STMICROELECTRONICS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS, IMPLIED OR STATUTORY WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
* PARTICULAR PURPOSE AND NON-INFRINGEMENT OF THIRD PARTY INTELLECTUAL PROPERTY
* RIGHTS ARE DISCLAIMED TO THE FULLEST EXTENT PERMITTED BY LAW. IN NO EVENT
* SHALL STMICROELECTRONICS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
* OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
* LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
* NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
* EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "FreeRTOS.h"
#include "task.h"
#include "cmsis_os.h"
/* USER CODE BEGIN Includes */
#include "stdio.h"
#include "usart.h"
#include "bsp_NRF24L01.h"
#include "bsp_key.h"
/* USER CODE END Includes */
/* Variables -----------------------------------------------------------------*/
osThreadId defaultTaskHandle;
osThreadId Task_KEYSCANHandle;
osThreadId Task_NRF2401Handle;
osMutexId Mutex_USARTHandle;
/* USER CODE BEGIN Variables */
/* USER CODE END Variables */
/* Function prototypes -------------------------------------------------------*/
void StartDefaultTask(void const * argument);
void Task_KEYSCAN(void const * argument);
void Task_NRF2401(void const * argument);
void MX_FREERTOS_Init(void); /* (MISRA C 2004 rule 8.1) */
/* USER CODE BEGIN FunctionPrototypes */
/* USER CODE END FunctionPrototypes */
int fputc(int c, FILE * f)
{
HAL_UART_Transmit(&huart1,(uint8_t *)&c,1,1000);//发送串口
return c;
}
void MX_FREERTOS_Init(void) {
osMutexDef(Mutex_USART);
Mutex_USARTHandle = osMutexCreate(osMutex(Mutex_USART));
/* Create the thread(s) */
/* definition and creation of defaultTask */
osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 128);
defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);
/* definition and creation of Task_KEYSCAN */
osThreadDef(Task_KEYSCAN, Task_KEYSCAN, osPriorityLow, 0, 128);
Task_KEYSCANHandle = osThreadCreate(osThread(Task_KEYSCAN), NULL);
/* definition and creation of Task_NRF2401 */
osThreadDef(Task_NRF2401, Task_NRF2401, osPriorityBelowNormal, 0, 256);
Task_NRF2401Handle = osThreadCreate(osThread(Task_NRF2401), NULL);
}
//GPIO_9外部中断回调函数
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
uint8_t STATUS_Temp;
if(GPIO_Pin == NRF2401_IRQ_Pin)
{
STATUS_Temp = NRF24L01_Read_REG(NRF24_RREG + STATUS);
if(NRF_Dev->Mode == NRF_RXMode)
{
if(STATUS_Temp&0x40) //接收数据中断
{
RX_Handle( STATUS_Temp>>1&0x07 );
}
}
else
{
if(STATUS_Temp&0x20) //数据发送成功中断
{
TX_DSHandle();
}
else //此次中断为发送失败中断
{
TX_RTHandle();
}
}
NRF24L01_Write_REG(NRF24_WREG + STATUS,STATUS_Temp); //清除STATUS寄存器中
//的中断位
}
}
/* StartDefaultTask function */
void StartDefaultTask(void const * argument)
{
NRFStructInit(); //初始化NRF24L01
for(;;)
{
osDelay(1);
}
/* USER CODE END StartDefaultTask */
}
/* StartTask02 function */
void Task_KEYSCAN(void const * argument)
{
for(;;)
{
ScanKey();
osDelay(50);
}
}
/* NRF2401_TXRX function */
void Task_NRF2401(void const * argument)
{
uint32_t i;
for(;;)
{
if(KeySingle(KEY_0)) //KEY0被单次触发，发送数据
{
printf("\r\n发送模式\r\n");
for(i=0;i<6;i++)
{
printf("发送数据至接收端通道：%d\r\n",i);
NRF_Dev->TX_S->TXPIPE = i;
TX_Mode();
TX_Package();
osDelay(10); //等待printf函数输出完毕，实际发送数据可取消此延时
while(NRF_Dev->IRQ_S->TxFinish == 0 && NRF_Dev->IRQ_S->TxMAXRT == 0);
NRF_Dev->IRQ_S->TxMAXRT = 0;
NRF_Dev->IRQ_S->TxFinish = 0;
}
}
if(KeySingle(KEY_1)) //KEY1被单次触发，切换为接收模式
{
printf("接收模式");
RX_Mode();
}
osDelay(1);
}
}
/* USER CODE BEGIN Application */
/* USER CODE END Application */
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
2、NRF24L01模块
/**************************************************************
* NRF24L01程序模块
*
* 测试板为原子战舰V3，使用外设为SPI1，SPI分频系数为8分频
*
**************************************************************/
#include "bsp_NRF24L01.h"
//收发端地址相反，否则由于地址问题无法通讯
//#define TX_Device
#ifdef TX_Device
//接收端6通道地址
uint8_t NRF_TXAddr[TXADRR_NUM][5] =
{
{0x0,0x11,0x11,0x11,0x11},
{0x1,0x11,0x11,0x11,0x11},
{0x2,0x11,0x11,0x11,0x11},
{0x3,0x11,0x11,0x11,0x11},
{0x4,0x11,0x11,0x11,0x11},
{0x5,0x11,0x11,0x11,0x11},
};
//发送端（本机）6通道接收地址
uint8_t NRF_RXAddr[6][5] =
{
{0x0,0x22,0x22,0x22,0x22},
{0x1,0x22,0x22,0x22,0x22},
{0x2,0x22,0x22,0x22,0x22},
{0x3,0x22,0x22,0x22,0x22},
{0x4,0x22,0x22,0x22,0x22},
{0x5,0x22,0x22,0x22,0x22},
};
#else
uint8_t NRF_TXAddr[TXADRR_NUM][5] =
{
{0x0,0x22,0x22,0x22,0x22},
{0x1,0x22,0x22,0x22,0x22},
{0x2,0x22,0x22,0x22,0x22},
{0x3,0x22,0x22,0x22,0x22},
{0x4,0x22,0x22,0x22,0x22},
{0x5,0x22,0x22,0x22,0x22},
};
uint8_t NRF_RXAddr[6][5] =
{
{0x0,0x11,0x11,0x11,0x11},
{0x1,0x11,0x11,0x11,0x11},
{0x2,0x11,0x11,0x11,0x11},
{0x3,0x11,0x11,0x11,0x11},
{0x4,0x11,0x11,0x11,0x11},
{0x5,0x11,0x11,0x11,0x11},
};
#endif
//数据发送缓冲数组
uint8_t NRF_TXBuff[32] = "NRF24L01通讯测试";
//发送数据size管理数组
uint8_t NRF_TXPxSize[TXADRR_NUM] = {32,32,32,32,32,32};
//接收数据缓存数组
uint8_t NRF_RXBuff[6][32];
//接收数据size管理数组
uint8_t NRF_RXPxSize[6] = {32,32,32,32,32,32};
//NRF管理结构体
NRF_Struct NRF_S, *NRF_Dev = &NRF_S;
NRF_TXStruct NRF_TXS;
NRF_RXStruct NRF_RXS;
NRF_IRQStruct NRF_IRQS;
/**
* @brief NRF24L01管理结构体初始化
*
* @Note 默认开启6个通道,
* 发送字节数为32字节
* 6个通道接收字节数位32字节
*
* @retval None
*/
void NRFStructInit(void)
{
NRF_Dev->RX_S = &NRF_RXS;
NRF_Dev->TX_S = &NRF_TXS;
NRF_Dev->IRQ_S = &NRF_IRQS;
NRF_Dev->Mode = NRF_RXMode;
NRF_Dev->RX_S->PIPEx = 5;
NRF_Dev->RX_S->Size = NRF_RXPxSize;
NRF_Dev->RX_S->ADDR = (uint8_t *)&NRF_RXAddr;
NRF_Dev->RX_S->Buff = (uint8_t *)&NRF_RXBuff;
NRF_Dev->TX_S->TXPIPE = 0;
NRF_Dev->TX_S->ReCount = 15;
NRF_Dev->TX_S->ReTime = 1;
NRF_Dev->TX_S->Size = NRF_TXPxSize;
NRF_Dev->TX_S->RF_Ch = 40;
NRF_Dev->TX_S->RF_DR = DR_2Mbps;
NRF_Dev->TX_S->RF_PWR = PWR_0dBm;
NRF_Dev->TX_S->ADDR = (uint8_t *)&NRF_TXAddr;
NRF_Dev->TX_S->Buff = NRF_TXBuff;
NRF_Dev->IRQ_S->TxFinish = 0;
NRF_Dev->IRQ_S->TxMAXRT = 0;
RX_Mode(); //初始化为接收模式
}
//SPI与NRF2401读写通信
uint8_t NRF24L01_RW(uint8_t d_send)
{
uint8_t d_read;
if(HAL_SPI_TransmitReceive(&hspi1,&d_send,&d_read,1,0xFFFFFF)!=HAL_OK)
d_read=0xff;
return d_read;
}
// NRF24L01写SPI指令
void SPI_WReg(uint8_t reg)
{
NRF24L01_CE_L
NRF24L01_Write_REG(reg, 0);
NRF24L01_CE_H
}
//SPI读取NRF2401寄存器数据
uint8_t NRF24L01_Read_REG(uint8_t reg)
{
uint8_t status;
NRF24L01_CS_L
NRF24L01_RW(reg);
status = NRF24L01_RW(0);
NRF24L01_CS_H
return status;
}
//SPI写NRF2401寄存器数据
uint8_t NRF24L01_Write_REG(uint8_t reg,uint8_t value)
{
uint8_t status;
NRF24L01_CS_L
status = NRF24L01_RW(reg);
NRF24L01_RW(value);
NRF24L01_CS_H
return status;
}
//SPI连续读取NRF2401寄存器数据
uint8_t NRF24L01_Read_Buff(uint8_t reg,uint8_t *pBuf,uint8_t Count)
{
uint8_t status,i;
NRF24L01_CS_L
status = NRF24L01_RW(reg);
for(i=0;i<Count;i++)
{
pBuf[i] = NRF24L01_RW(0);
}
NRF24L01_CS_H
return status;
}
//SPI连续写NRF2401寄存器数据
uint8_t NRF24L01_Write_Buff(uint8_t reg,uint8_t *pBuf,uint8_t Count)
{
uint16_t j = 720;
uint8_t status,i;
NRF24L01_CS_L
status = NRF24L01_RW(reg);
while(j--); //短暂延时
for(i=0;i<Count;i++)
{
status = NRF24L01_RW(*pBuf++);
}
NRF24L01_CS_H
return status;
}
//SPI与NRF2401通讯自检
//通过则代表MCU SPI通讯NRF2401成功
//可用于测试器件之间的连接
uint8_t NRF24L01_Check(void)
{
uint8_t buf[5]={0x01,0x02,0x03,0x04,0x05};
uint8_t buf1[5];
uint8_t i;
NRF24L01_Write_Buff(NRF24_WREG+TX_ADDRReg,buf,5); //开机第一次写入不成功
NRF24L01_Write_Buff(NRF24_WREG+TX_ADDRReg,buf,5); /*写入5个字节的地址. */
NRF24L01_Read_Buff(TX_ADDRReg,buf1,5); /*读出写入的地址 */
for(i=0;i<5;i++) /*比较*/
{
if(buf1[i] != i+1)
break;
}
if(i==5)
return SUCCESS ; //MCU与NRF成功连接
else
return ERROR ; //MCU与NRF不正常连接
}
/**
* @brief NRF24L01设置为发送模式
*
* @retval None
*/
void TX_Mode(void)
{
//发送地址不能大于发送地址二维数组个数上限，发送size不能大于32
if( NRF_Dev->TX_S->TXPIPE > TXADRR_NUM -1 || \
NRF_Dev->TX_S->Size[NRF_Dev->TX_S->TXPIPE] > 32 ) return ;
NRF_Dev->Mode = NRF_TXMode;
NRF24L01_CE_L
NRF24L01_Write_Buff(NRF24_WREG + TX_ADDRReg, \
(uint8_t *)NRF_Dev->TX_S->ADDR + NRF_Dev->TX_S->TXPIPE*5, 5); //设置发送地址
NRF24L01_Write_Buff(NRF24_WREG + RX_ADDR_P0, \
(uint8_t *)NRF_Dev->TX_S->ADDR + NRF_Dev->TX_S->TXPIPE*5, 5); //设置本机地址,P0接收应答
NRF24L01_Write_REG(NRF24_WREG + EN_AA, 0x01); // Enable Auto.Ack:Pipe0
NRF24L01_Write_REG(NRF24_WREG + EN_RXADDR, 0x01); // Enable Pipe0
NRF24L01_Write_REG(NRF24_WREG + SETUP_RETR, \
NRF_Dev->TX_S->ReCount + (NRF_Dev->TX_S->ReTime<<4)); // 500us + 86us, 10 retrans...
NRF24L01_Write_REG(NRF24_WREG + RF_CH, NRF_Dev->TX_S->RF_Ch); // Select RF channel
NRF24L01_Write_REG(NRF24_WREG + RF_SETUP, \
NRF_Dev->TX_S->RF_DR<<3 | NRF_Dev->TX_S->RF_PWR<<1); // TX_PWR:0dBm, Datarate:2Mbps,
NRF24L01_Write_REG(NRF24_WREG + CONFIG, 0x0e); // Set PWR_UP bit, enable CRC(2 bytes)
}
void TX_Package(void)
{
NRF_Dev->Mode = NRF_TXMode;
NRF24L01_CE_L
NRF24L01_Write_Buff(WR_TX_PLOAD,
(uint8_t *)NRF_Dev->TX_S->Buff , \
NRF_Dev->TX_S->Size[NRF_Dev->TX_S->TXPIPE]); // Writes data to TX payload
NRF24L01_CE_H
}
/**
* @brief NRF24L01设置为接收模式
*
* @retval None
*/
void RX_Mode(void)
{
uint8_t i,j = 5;
NRF_Dev->Mode = NRF_RXMode;
NRF24L01_CE_L
for(i=0;i<NRF_Dev->RX_S->PIPEx+1;i++)
{
if(i>1) j = 1;
NRF24L01_Write_Buff(NRF24_WREG + RX_ADDR_P0 + i, \
(uint8_t *)NRF_Dev->RX_S->ADDR + 5*i, j); //设置接收通道以及通道的地址
NRF24L01_Write_REG(NRF24_WREG + RX_PW_P0 + i, \
NRF_Dev->RX_S->Size[i]); //设置接收通道接收数据的长度
}
NRF24L01_Write_REG(NRF24_WREG + EN_AA, ( 2<<NRF_Dev->RX_S->PIPEx) - 1 ); // Enable Auto.Ack:PipeX
NRF24L01_Write_REG(NRF24_WREG + EN_RXADDR, ( 2<<NRF_Dev->RX_S->PIPEx) - 1 ); // Enable PipeX
NRF24L01_Write_REG(NRF24_WREG + RF_CH, NRF_Dev->TX_S->RF_Ch); // Select RF channel
NRF24L01_Write_REG(NRF24_WREG + RF_SETUP, \
NRF_Dev->TX_S->RF_DR<<3 | NRF_Dev->TX_S->RF_PWR<<1); // TX_PWR:0dBm, Datarate:2Mbps,
NRF24L01_Write_REG(NRF24_WREG + CONFIG, 0x0f); // Set PWR_UP bit, enable CRC(2 bytes)
NRF24L01_CE_H
}
/**
* @brief NRF24L01接收处理函数
*
* @param reg: NRF2401状态寄存器的值
* @arg 0 - 5
* @retval None
*/
void RX_Handle(uint8_t reg)
{
if( reg < 6 ) //获取接收数据pipe编号,溢出则不进行接收处理
{
NRF24L01_Read_Buff(NRF24_RREG + RD_RX_PLOAD, \
(uint8_t *)NRF_Dev->RX_S->Buff + reg*32, \
NRF_Dev->RX_S->Size[reg]); //接收数据
SPI_WReg(FLUSH_RX); //清除RX FIFO
printf("\r\n数据来自通道%d\r\n",reg);
printf("%s\r\n",(uint8_t *)NRF_Dev->RX_S->Buff + reg*32);
}
}
/**
* @brief NRF24L01发送成功处理函数
*
* @retval None
*/
void TX_DSHandle(void)
{
NRF_Dev->IRQ_S->TxFinish = 1;
}
/**
* @brief NRF24L01达到最大重发数处理函数
*
* @retval None
*/
void TX_RTHandle(void)
{
SPI_WReg(FLUSH_TX); //重发送溢出，需清除TX FIFO，否则再次触发发送
NRF_Dev->IRQ_S->TxMAXRT = 1;
}
3、NRF24L01头文件定义
#ifndef __bsp_NRF24L01_H__
#define __bsp_NRF24L01_H__
#include "stm32f1xx_hal.h"
#include "main.h"
#include "spi.h"
#define TXADRR_NUM 6
#define vu8 volatile uint8_t
#define vu16 volatile uint16_t
#define vu32 volatile uint32_t
#define DR_1Mbps 0
#define DR_2Mbps 1
#define PWR_0dBm 3
#define PWR_6dBm 2
#define PWR_16dBm 1
#define PWR_18dBm 0
typedef struct
{
vu8 RF_PWR; //发射功率
vu8 RF_DR; //发射速率
vu8 RF_Ch; //发射通道
vu8 TXPIPE; //发送地址
vu8 ReCount; //重发送次数
vu8 ReTime; //重发送时间
vu8 *Size; //发送数据字节数
vu8 *Buff; //发送数据指针
vu8 *ADDR; //发送地址指针
}NRF_TXStruct;
typedef struct
{
vu8 PIPEx; //接收通道开启 0~5
vu8 *Size; //接收字节数
vu8 *Buff; //接收缓存指针
vu8 *ADDR; //接收通道地址指针
}NRF_RXStruct;
typedef struct
{
vu8 TxMAXRT; //重发送中断标志位
vu8 TxFinish; //发送完成中断标志位
}NRF_IRQStruct;
typedef struct
{
vu8 Mode;
NRF_IRQStruct *IRQ_S;
NRF_TXStruct *TX_S;
NRF_RXStruct *RX_S;
}NRF_Struct;
extern NRF_Struct *NRF_Dev;
#define NRF_TXMode 0
#define NRF_RXMode 1
/************************NRF引脚定义*********************/
#define NRF24L01_CS_L HAL_GPIO_WritePin(SPI1_CS_GPIO_Port, SPI1_CS_Pin, GPIO_PIN_RESET);
#define NRF24L01_CS_H HAL_GPIO_WritePin(SPI1_CS_GPIO_Port, SPI1_CS_Pin, GPIO_PIN_SET);
#define NRF24L01_CE_L HAL_GPIO_WritePin(NRF2401_CSN_GPIO_Port, NRF2401_CSN_Pin, GPIO_PIN_RESET);
#define NRF24L01_CE_H HAL_GPIO_WritePin(NRF2401_CSN_GPIO_Port, NRF2401_CSN_Pin, GPIO_PIN_SET);
/************************SPI 接口寄存器定义*********************/
#define NRF24_RREG 0x00 // Define read command to register
#define NRF24_WREG 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
/**********************NRF2401功能寄存器定义********************/
#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_ADDRReg 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
void NRFStructInit(void);
uint8_t NRF24L01_RW(uint8_t d_send);
uint8_t NRF24L01_Read_REG(uint8_t reg);
uint8_t NRF24L01_Write_REG(uint8_t reg,uint8_t value);
uint8_t NRF24L01_Read_Buff(uint8_t reg,uint8_t *pBuf,uint8_t Count);
uint8_t NRF24L01_Write_Buff(uint8_t reg,uint8_t *pBuf,uint8_t Count);
uint8_t NRF24L01_Check(void);
void RX_Mode(void);
void TX_Mode(void);
void SPI_WReg(uint8_t reg);
void RX_Handle(uint8_t reg);
void TX_DSHandle(void);
void TX_RTHandle(void);
void TX_Package(void);
#endif
注意：1、程序基于STM32CUBEMX生成，编译环境为MDK，硬件环境为F1原子战舰V3。
2、使用程序，接收与发送端地址不同，具体使用宏定义“#define TX_Device”即可切换地址。
3、两块板子烧好程序，上电后，先按下KEY1，将其中一个板子转换为接收模式，另一个板子开启发送。
开启两个串口助手，观察到现象为：
五、速度测试
器件本身选定的是2Mbps的速度，那么我们能做的就是，将MCU的SPI通讯速率提升上去。所以程序作了如下改动。
1、不使用HAL的SPI库进行通讯，将SPI通讯函数改为：
//SPI与NRF2401读写通信
uint8_t NRF24L01_RW(uint8_t d_send)
{
uint8_t d_read;
for(d_read = 0; d_read<8; d_read++);
SPI1->DR = d_send;
for(d_read = 0; d_read<8; d_read++);
return SPI1->DR;
}2、FreeRTOS中发送任务，改为使用PIPE0连续发送10,000个32byte的数据包，数据总量为：312.5Kb
需要注意的是，HAL库是在SPI通讯函数中使能SPI1外设，所以平时SPI1外设时没有使能的，需要我们手动使能
/* NRF2401_TXRX function */
void Task_NRF2401(void const * argument)
{
uint32_t i;
SPI1->CR1 |= 0x0040; //使能SPI1
SPI1->DR = 0xff; //dummy write
for(;;)
{
if(KeySingle(KEY_0)) //KEY0被单次触发，发送数据
{
printf("\r\n发送模式\r\n");
TX_Mode();
for(i=0;i<10000;i++)
{
TX_Package();
while(NRF_Dev->IRQ_S->TxFinish == 0 && NRF_Dev->IRQ_S->TxMAXRT == 0);
NRF_Dev->IRQ_S->TxMAXRT = 0;
NRF_Dev->IRQ_S->TxFinish = 0;
}
}
if(KeySingle(KEY_1)) //KEY1被单次触发，切换为接收模式
{
printf("接收模式");
RX_Mode();
}
osDelay(1);
}
}3、接收中断处理函数中，加一个缓存标志“i”记录接收数据包的个数
void RX_Handle(uint8_t reg)
{
volatile static uint32_t i=0;
i++;
if( reg < 6 ) //获取接收数据pipe编号,溢出则不进行接收处理
{
NRF24L01_Read_Buff(NRF24_RREG + RD_RX_PLOAD, \
(uint8_t *)NRF_Dev->RX_S->Buff + reg*32, \
NRF_Dev->RX_S->Size[reg]); //接收数据
SPI_WReg(FLUSH_RX); //清除RX FIFO
}
}测试结果：
完整地接收到10000个数据包，按下输出按键同时，手机进行计时。。。别问我为什么不开个定时器，我懒。。。。
测量了几次，时间约为6.5S，据此计算，通信速率为：10000*32/1024/6.5 = 48Kb/s
听说网上有人不开启自动应答可以达到65Kb/s的，反正我是开了自动应答。。。不开启的就懒得测了。
六、距离测试
跟距离有关的因素很多，我们能通过程序调整的有：1、发射功率
2、发射速率
3、频道
所以将初始化参数更改如下：
void NRFStructInit(void)
{
NRF_Dev->RX_S = &NRF_RXS;
NRF_Dev->TX_S = &NRF_TXS;
NRF_Dev->IRQ_S = &NRF_IRQS;
NRF_Dev->Mode = NRF_RXMode;
NRF_Dev->RX_S->PIPEx = 5;
NRF_Dev->RX_S->Size = NRF_RXPxSize;
NRF_Dev->RX_S->ADDR = (uint8_t *)&NRF_RXAddr;
NRF_Dev->RX_S->Buff = (uint8_t *)&NRF_RXBuff;
NRF_Dev->TX_S->TXPIPE = 0;
NRF_Dev->TX_S->ReCount = 15;
NRF_Dev->TX_S->ReTime = 15;
NRF_Dev->TX_S->Size = NRF_TXPxSize;
NRF_Dev->TX_S->RF_Ch = 80;
NRF_Dev->TX_S->RF_DR = DR_1Mbps;
NRF_Dev->TX_S->RF_PWR = PWR_0dBm;
NRF_Dev->TX_S->ADDR = (uint8_t *)&NRF_TXAddr;
NRF_Dev->TX_S->Buff = NRF_TXBuff;
NRF_Dev->IRQ_S->TxFinish = 0;
NRF_Dev->IRQ_S->TxMAXRT = 0;
RX_Mode(); //初始化为接收模式
}未更改参数前，超过2米通讯会出现中断。
参数更改后，无障碍下7米距离通讯正常。更远则由于环境限制未测试