最近在一个项目中用到了nRF24L01这个无线2.4G收发芯片，项目中有主机和分机，默认都是使用数据通道0，主机通过nRF24L01发送数据后，对应地址的分机在收到数据后会返回一个确认数据包给主机（注意：这个确认数据包并不是nRF24L01自动应答时的数据包，而是自定义的一个数据包，说明了就是双方都能进行收发），在经过长时间的摸索之后，终于将接收和发送都调通了，基本的SPI驱动我使用的是正点原子的教程，我是使用的中断法来处理相应的收发工作。
我的软件硬件环境大致如下：
服务端：STM32F103VET6+u/COS-III
从机端：STM32F103RBT6+u/COS-III
库函数是使用的3.5版本的。
在这里我只是列出主机部分的代码，从机上的都是差不多的。
下面是nRF24L01的驱动部分
头文件部分（24l01.h）：
#ifndef __24L01_H
#define __24L01_H
#include "config.h"
#if nRF24L01_EN > 0u
#include "sys_temp.h"
/*---------------------------------------------------------------------------------------------
NRF24L01寄存器操作命令及寄存器地址
-----------------------------------------------------------------------------------------------*/
#define SPI_READ_REG 0x00 //读配置寄存器,低5位为寄存器地址
#define SPI_WRITE_REG 0x20 //写配置寄存器,低5位为寄存器地址
#define RD_RX_PLOAD 0x61 //读RX有效数据,1~32字节
#define WR_TX_PLOAD 0xA0 //写TX有效数据,1~32字节
#define FLUSH_TX 0xE1 //清除TX FIFO寄存器.发射模式下用
#define FLUSH_RX 0xE2 //清除RX FIFO寄存器.接收模式下用
#define REUSE_TX_PL 0xE3 //重新使用上一包数据,CE为高,数据包被不断发送.
#define NOP 0xFF //空操作,可以用来读状态寄存器
#define CONFIG 0x00 //配置寄存器地址;bit0:1接收模式,0发射模式;bit1:电选择;bit2:CRC模式;bit3:CRC使能;
//bit4:中断MAX_RT(达到最大重发次数中断)使能;bit5:中断TX_DS使能;bit6:中断RX_DR使能
#define EN_AA 0x01 //使能自动应答功能 bit0~5,对应通道0~5
#define EN_RXADDR 0x02 //接收地址允许,bit0~5,对应通道0~5
#define SETUP_AW 0x03 //设置地址宽度(所有数据通道):bit1,0:00,3字节;01,4字节;02,5字节;
#define SETUP_RETR 0x04 //建立自动重发;bit3:0,自动重发计数器;bit7:4,自动重发延时 250*x+86us
#define RF_CH 0x05 //RF通道,bit6:0,工作通道频率;
#define RF_SETUP 0x06 //RF寄存器;bit3:传输速率(0:1Mbps,1:2Mbps);bit2:1,发射功率;bit0:低噪声放大器增益
#define STATUS 0x07 //状态寄存器;bit0:TX FIFO满标志;bit3:1,接收数据通道号(最大:6);bit4,自动重发完成中断
//bit5:数据发送完成中断;bit6:接收数据完成中断;
#define MAX_TX 0x10 //达到最大发送次数中断，即自动重发完成中断
#define TX_OK 0x20 //TX发送完成中断，即数据发送完成中断
#define RX_OK 0x40 //接收到数据中断，即数据接收完成中断
#define OBSERVE_TX 0x08 //发送检测寄存器,bit7:4,数据包丢失计数器;bit3:0,重发计数器
#define CD 0x09 //载波检测寄存器,bit0,载波检测;
#define RX_ADDR_P0 0x0A //数据通道0接收地址,最大长度5个字节,低字节在前
#define RX_ADDR_P1 0x0B //数据通道1接收地址,最大长度5个字节,低字节在前
#define RX_ADDR_P2 0x0C //数据通道2接收地址,最低字节可设置,高字节,必须同RX_ADDR_P1[39:8]相等;
#define RX_ADDR_P3 0x0D //数据通道3接收地址,最低字节可设置,高字节,必须同RX_ADDR_P1[39:8]相等;
#define RX_ADDR_P4 0x0E //数据通道4接收地址,最低字节可设置,高字节,必须同RX_ADDR_P1[39:8]相等;
#define RX_ADDR_P5 0x0F //数据通道5接收地址,最低字节可设置,高字节,必须同RX_ADDR_P1[39:8]相等;
#define TX_ADDR 0x10 //发送地址(低字节在前),ShockBurstTM模式下,RX_ADDR_P0与此地址相等
#define RX_PW_P0 0x11 //接收数据通道0有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P1 0x12 //接收数据通道1有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P2 0x13 //接收数据通道2有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P3 0x14 //接收数据通道3有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P4 0x15 //接收数据通道4有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P5 0x16 //接收数据通道5有效数据宽度(1~32字节),设置为0则非法
#define FIFO_STATUS 0x17 //FIFO状态寄存器;bit0,RX FIFO寄存器空标志;bit1,RX FIFO满标志;bit2,3,保留
//bit4,TX FIFO空标志;bit5,TX FIFO满标志;bit6,1,循环发送上一数据包.0,不循环;
/*---------------------------------------------------------------------------------------------
24L01的用到的单片机引脚
-----------------------------------------------------------------------------------------------*/
#define NRF24L01_SPI_Periph_CLK RCC_APB2Periph_GPIOB //无线2.4G模块用到的引脚的外设时钟源
#define NRF24L01_SPI_GPIO_SRC GPIOB
#define NRF24L01_SPI_SCK_PIN GPIO_Pin_13 //SCK时钟
#define NRF24L01_SPI_MISO_PIN GPIO_Pin_14 //主机输入，从机输出
#define NRF24L01_SPI_MOSI_PIN GPIO_Pin_15 //主机输出，从机输入
#define NRF24L01_CE_PIN GPIO_Pin_10 //24L01芯片使能信号
#define NRF24L01_IRQ_PIN GPIO_Pin_11 //IRQ主机数据输入
#define NRF24L01_CSN_PIN GPIO_Pin_12 //SPI片选
/*---------------------------------------------------------------------------------------------
24L01芯片使能信号和片选信号操作
-----------------------------------------------------------------------------------------------*/
#define NRF24L01_CE PBout(10) //24L01芯片使能信号
#define NRF24L01_CSN PBout(12) //SPI片选信号
#define NRF24L01_IRQ PBin(11) //IRQ主机数据输入
/*---------------------------------------------------------------------------------------------
24L01中断线配置，当接收到数据，发送数据，达到最大重发次数时都会触发中断
相应的状态寄存器会置位1，注意需要手动清除中断，写1清零
-----------------------------------------------------------------------------------------------*/
#define NRF24L01_INT_SOURCE_PORT GPIO_PortSourceGPIOB //中断引脚组
#define NRF24L01_INT_IRQ EXTI15_10_IRQn //中断号
#define NRF24L01_STATUS_INT_SOURCE GPIO_PinSource11 //中断源
#define NRF24L01_STATUS_LINE EXTI_Line11 //中断线
#define NRF24L01_STATUS_INT_MODE EXTI_Trigger_Falling //中断触发方式
/*---------------------------------------------------------------------------------------------
24L01发送接收数据宽度定义
-----------------------------------------------------------------------------------------------*/
#define TX_ADR_WIDTH 5 //5字节的地址宽度
#define RX_ADR_WIDTH 5 //5字节的地址宽度
#define TX_PLOAD_WIDTH 32 //32字节的用户数据宽度
#define RX_PLOAD_WIDTH 32 //32字节的用户数据宽度
/*---------------------------------------------------------------------------------------------
24L01相关操作函数定义
-----------------------------------------------------------------------------------------------*/
void NRF24L01_Init(void);//初始化
void RX_Mode(void);//配置为接收模式
//void TX_Mode(void);//配置为发送模式（原始定义）
void TX_Mode(u8 * addr);//配置为发送模式
static u8 SPIx_ReadWriteByte(u8 TxData);
u8 NRF24L01_Write_Buf(u8 reg, u8 *pBuf, u8 u8s);//写数据区
u8 NRF24L01_Read_Buf(u8 reg, u8 *pBuf, u8 u8s);//读数据区
u8 NRF24L01_Read_Reg(u8 reg); //读寄存器
u8 NRF24L01_Write_Reg(u8 reg, u8 value);//写寄存器
u8 NRF24L01_Check(void);//检查24L01是否存在
u8 NRF24L01_TxPacket(u8 *txbuf);//发送一个包的数据
//u8 NRF24L01_RxPacket(u8 *rxbuf);//接收一个包的数据（原始定义）
u8 NRF24L01_RxPacket(u8 *rxbuf, u8 *chl);//接收一个包的数据
#endif /* nRF24L01_EN */
#endif /* __24L01_H */
源文件部分（24l01.c）：
/******************** (C) COPYRIGHT 2015 ASTO ***************************
@* 文件名 ：24l01.c
@* 描述 ：nRF24L01驱动程序
@* 开发平台：STM32F103VET6主控制MCU
@* 硬件连接：SPI2
@* 库版本 ：ST3.5.0
@* 作者 ：
@* 公司网址：<a target=_blank href="http://www.test.com">www.test.com</a>
@* 总部网址：<a target=_blank href="http://www.test.com">www.test.com</a>
**********************************************************************************/
#include "config.h"
#if nRF24L01_EN > 0u
#include "sys_temp.h"
#include "24l01.h"
#include "delay.h"
const u8 RX0_Address[RX_ADR_WIDTH]={0x01,0x01,0x01,0x01,0x01}; //接收方通道0地址
/*
const u8 RX1_Address[RX_ADR_WIDTH]={0x02,0x20,0x20,0x20,0x20}; //接收方通道1地址
const u8 RX2_Address[1] = {0x03}; //接收方通道2地址
const u8 RX3_Address[1] = {0x04}; //接收方通道3地址
const u8 RX4_Address[1] = {0x05}; //接收方通道4地址
const u8 RX5_Address[1] = {0x06}; //接收方通道5地址
*/
/**
@函数名称：EXTI_Configuration()
@函数功能：nRF24L01的IRQ中断配置（只响应接收数据的中断）
@输入：无
@输出：无
@调用：内部调用
**/
static void EXTI_Configuration(void)
{
EXTI_InitTypeDef EXTI_InitStructure;
NVIC_InitTypeDef NVIC_InitStructure;
//中断优先级设置
NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);
NVIC_InitStructure.NVIC_IRQChannel = NRF24L01_INT_IRQ; //10-15的中断线共享一个中断处理程序
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;//抢占优先级
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;//响应优行级
NVIC_Init(&NVIC_InitStructure);
//中断线配置EXTI_Line11-->PB11
GPIO_EXTILineConfig(NRF24L01_INT_SOURCE_PORT, NRF24L01_STATUS_INT_SOURCE); //设置中断源引脚
EXTI_InitStructure.EXTI_Line = NRF24L01_STATUS_LINE; //中断线设置
EXTI_InitStructure.EXTI_LineCmd = ENABLE; //中断线使能
EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt; //中断方式
EXTI_InitStructure.EXTI_Trigger = NRF24L01_STATUS_INT_MODE;//模式，这里设置为下降沿触发
EXTI_Init(&EXTI_InitStructure);
}
/**
@* 函数名：NRF24L01_SPI_Init()
@* 描述 ：初始化SPI2端口及基模式，用于操作nRF24L01无线2.4G模块
@* 输入 ：无
@* 输出 : 无
@* 调用 ：内部调用
*/
static void NRF24L01_SPI_Init(void) {
GPIO_InitTypeDef GPIO_InitStructure;
SPI_InitTypeDef SPI_InitStructure;
//注意将普通IO作为中断线时必须开启AFIO时钟
RCC_APB2PeriphClockCmd(NRF24L01_SPI_Periph_CLK|RCC_APB2Periph_AFIO, ENABLE);//开启GPIOB的时钟
RCC_APB1PeriphClockCmd(RCC_APB1Periph_SPI2, ENABLE);//开启SPI2的时钟
/*配置 SPI的SCK, MISO, MOSI引脚，GPIOB^13,GPIOB^14,GPIOB^15 */
GPIO_InitStructure.GPIO_Pin = NRF24L01_SPI_SCK_PIN| NRF24L01_SPI_MISO_PIN | NRF24L01_SPI_MOSI_PIN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;//复用输出功能
GPIO_Init(NRF24L01_SPI_GPIO_SRC, &GPIO_InitStructure);
/*GPIOB^10为nRF24L01的CE引脚，CSN引脚GPIOB^12 */
GPIO_InitStructure.GPIO_Pin = NRF24L01_CE_PIN|NRF24L01_CSN_PIN;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;//通用推挽输出
GPIO_Init(NRF24L01_SPI_GPIO_SRC, &GPIO_InitStructure);
/* GIOB^11为nRF24L01的IRQ中断输入引脚 */
GPIO_InitStructure.GPIO_Pin = NRF24L01_IRQ_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮动输入
GPIO_Init(NRF24L01_SPI_GPIO_SRC, &GPIO_InitStructure);
SPI_Cmd(SPI2,DISABLE);/*先失能，然后再使能*/
SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex ; /* 全双工 */
SPI_InitStructure.SPI_Mode = SPI_Mode_Master ; /*当前的设备为主机模式*/
SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low ; /* 时钟极性为低，即SPI空闲时，SCK为低电平 */
SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge ; /* 时钟相位，第一个时钟沿（也就是奇数边沿）捕捉数据 */
SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b; /* 数据宽度 */
SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB ; /* 低地址存放最高有效字节 */
SPI_InitStructure.SPI_NSS = SPI_NSS_Soft; /*配置片选为软件控制方式*/
SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8; /* 时钟分频为8分频，即72MHz/8=9MHz */
SPI_InitStructure.SPI_CRCPolynomial = 7; /* 校验多项式，这个不起作用 */
SPI_Init(SPI2, &SPI_InitStructure);
//使能SPI2
SPI_Cmd(SPI2,ENABLE);
EXTI_Configuration();//配置中断线
}
/**
@* 函数名：SPIx_ReadWriteByte()
@* 描述 ：SPI2 读写一个字节
@* 输入 ：TxData:要写入的字节
@* 输出 : 读取到的字节
@* 调用 ：内部调用
*/
static u8 SPIx_ReadWriteByte(u8 TxData) {
/** 原来的实现方式
u8 retry=0;
while((SPI2->SR&1<<1)==0) {//等待发送区空
retry++;
if(retry>200)return 0;
}
SPI2->DR=TxData; //发送一个byte
retry=0;
while((SPI2->SR&1<<0)==0) { //等待接收完一个byte
retry++;
if(retry>200)return 0;
}
return SPI2->DR; //返回收到的数据 */
/* Loop while DR register in not empty */
while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET);
/* Send byte through the SPI2 peripheral */
SPI_I2S_SendData(SPI2, TxData);
/* Wait to receive a byte */
while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET);
/* Return the byte read from the SPI bus */
return SPI_I2S_ReceiveData(SPI2);
}
/**
@* 函数名：NRF24L01_Init()
@* 描述 ：初始化24L01的相关IO口
@* 输入 ：无
@* 输出 : 无
@* 调用 ：外部板级支持包调用
*/
void NRF24L01_Init(void) {
NRF24L01_SPI_Init(); //初始化SPI2
NRF24L01_CE=0; //使能24L01
NRF24L01_CSN=1; //SPI片选取消
}
/**
@* 函数名：NRF24L01_Check()
@* 描述 ：检测24L01是否存在
@* 输入 ：无
@* 输出 : 0:成功，1:失败
@* 调用 ：外部板级支持包调用
*/
u8 NRF24L01_Check(void) {
u8 buf[5]={0x21,0x21,0x21,0x21,0x21};
u8 buf1[5];
u8 i;
//SPIx_SetSpeed(SPI_SPEED_8); //spi速度为9Mhz（24L01的最大SPI时钟为10Mhz）
NRF24L01_Write_Buf(SPI_WRITE_REG+TX_ADDR,buf,5);//写入5个字节的地址.
NRF24L01_Read_Buf(TX_ADDR,buf1, 5); //读出写入的地址
for(i=0;i<5;i++)if(buf1[i]!=0x21)break; //判断读出的数据和写入的数据是否完全一致
if(i!=5)return 1;//检测24L01错误
return 0; //执行到这里，表示成功检测到24L01
}
/**
@* 函数名：NRF24L01_Write_Reg()
@* 描述 ：SPI写寄存器
@* 输入 ：reg: 指定的寄存器地址
@* value: 要写入的值
@* 输出 : 返回寄存器的状态值
@* 调用 ：内部调用
*/
u8 NRF24L01_Write_Reg(u8 reg,u8 value) {
u8 status;
NRF24L01_CSN=0; //使能SPI传输
status =SPIx_ReadWriteByte(reg); //发送寄存器号
SPIx_ReadWriteByte(value); //写入寄存器的值
NRF24L01_CSN=1; //禁止SPI传输
return(status); //返回状态值
}
/**
@* 函数名：NRF24L01_Read_Reg()
@* 描述 ：读取SPI寄存器值
@* 输入 ：reg: 指定的寄存器地址
@* 输出 : 返回寄存器的状态值
@* 调用 ：内部调用
*/
u8 NRF24L01_Read_Reg(u8 reg) {
u8 reg_val;
NRF24L01_CSN = 0; //使能SPI传输
SPIx_ReadWriteByte(reg); //发送寄存器号
reg_val=SPIx_ReadWriteByte(0XFF); //读取寄存器内容
NRF24L01_CSN = 1; //禁止SPI传输
return(reg_val); //返回状态值
}
/**
@* 函数名：NRF24L01_Read_Buf()
@* 描述 ：在指定位置读出指定长度的数据
@* 输入 ：reg:指定的寄存器位置
@* pBuf:数据指针用来存储读到的数据，一般是数组
@* len:数据长度
@* 输出 : 此次读到的状态寄存器值
@* 调用 ：内部调用
*/
u8 NRF24L01_Read_Buf(u8 reg,u8 *pBuf,u8 len) {
u8 status,u8_ctr;
NRF24L01_CSN = 0; //使能SPI传输
status=SPIx_ReadWriteByte(reg);//发送寄存器值(位置),并读取状态值
for(u8_ctr=0;u8_ctr<len;u8_ctr++)pBuf[u8_ctr]=SPIx_ReadWriteByte(0xFF);//读出数据
NRF24L01_CSN=1; //关闭SPI传输
return status; //返回读到的状态值
}
/**
@* 函数名：NRF24L01_Write_Buf()
@* 描述 ：在指定位置写指定长度的数据
@* 输入 ：reg:寄存器(位置)
@* pBuf:数据指针
@* len:数据长度
@* 输出 : 此次读到的状态寄存器值
@* 调用 ：内部调用
*/
u8 NRF24L01_Write_Buf(u8 reg, u8 *pBuf, u8 len) {
u8 status,u8_ctr;
NRF24L01_CSN = 0; //使能SPI传输
status = SPIx_ReadWriteByte(reg);//发送寄存器值(位置),并读取状态值
for(u8_ctr=0; u8_ctr<len; u8_ctr++)SPIx_ReadWriteByte(*pBuf++); //写入数据
NRF24L01_CSN = 1; //关闭SPI传输
return status; //返回读到的状态值
}
/**
@* 函数名：NRF24L01_TxPacket()
@* 描述 ：启动NRF24L01发送一次数据
@* 输入 ：txbuf:待发送数据首地址
@* 输出 : 发送完成状况
@* 调用 ：外部板级支持包调用
*/
u8 NRF24L01_TxPacket(u8 *txbuf) {
//u8 sta;
//SPIx_SetSpeed(SPI_SPEED_8);//spi速度为9Mhz（24L01的最大SPI时钟为10Mhz）
NRF24L01_CE=0;
NRF24L01_Write_Buf(WR_TX_PLOAD,txbuf,TX_PLOAD_WIDTH);//写数据到TX BUF 最长32个字节
NRF24L01_CE=1;//启动发送，10微秒后启动发送
return 0xff;//其他原因发送失败
}
/**
@* 函数名：NRF24L01_RxPacket()
@* 描述 ：启动NRF24L01接收数据
@* 输入 ：rxbuf:用来接收数据的buffer
@* chl:接收到数据的通道号
@* 输出 : 0，接收完成；其他，错误代码
@* 调用 ：外部板级支持包调用
*/
u8 NRF24L01_RxPacket(u8 *rxbuf, u8 *chl) {
u8 sta;
//SPIx_SetSpeed(SPI_SPEED_8); //spi速度为9Mhz（24L01的最大SPI时钟为10Mhz）
sta=NRF24L01_Read_Reg(STATUS); //读取状态寄存器的值
//状态寄存器的bit1-bit3是表示接收到数据的通道号，最大值为6
*chl=(0x0e&sta)>>1;
//清除TX_DS或MAX_RT中断标志，注意这里是写1清零，只有清零后设备才能正常通讯
NRF24L01_Write_Reg(SPI_WRITE_REG+STATUS,sta);
if(sta&RX_OK) { //接收到数据
NRF24L01_Read_Buf(RD_RX_PLOAD,rxbuf,RX_PLOAD_WIDTH);//读取数据
NRF24L01_Write_Reg(FLUSH_RX, 0xff);//清除RX FIFO寄存器
return 0;
}
return 1;//没收到任何数据
}
/**
@* 函数名：RX_Mode()
@* 描述 ：该函数初始化NRF24L01到RX模式
@* 设置RX地址,写RX数据宽度,选择RF频道,波特率和LNA HCURR
@* 当CE变高后,即进入RX模式,并可以接收数据了
@* 输入 ：无
@* 输出 : 无
@* 调用 ：外部板级支持包调用
*/
void RX_Mode(void) {
NRF24L01_CE=0; //CE为0进入待机模式
//配置通道的接收
NRF24L01_Write_Buf(SPI_WRITE_REG+RX_ADDR_P0,(u8*)RX0_Address,RX_ADR_WIDTH);//写RX节点地址（通道0），也就是表示用哪个通道接收数据
//======================注意以下被注释掉的内容可作参考和=========================================
//NRF24L01_Write_Buf(SPI_WRITE_REG+RX_ADDR_P1,(u8*)RX1_Address,RX_ADR_WIDTH);//写RX节点地址（通道1），也就是表示用哪个通道接收数据
//NRF24L01_Write_Buf(SPI_WRITE_REG+RX_ADDR_P2,(u8*)RX2_Address,1);//写RX节点地址（通道2），也就是表示用哪个通道接收数据
//NRF24L01_Write_Buf(SPI_WRITE_REG+RX_ADDR_P3,(u8*)RX3_Address,1);//写RX节点地址（通道3），也就是表示用哪个通道接收数据
//NRF24L01_Write_Buf(SPI_WRITE_REG+RX_ADDR_P4,(u8*)RX4_Address,1);//写RX节点地址（通道4），也就是表示用哪个通道接收数据
//NRF24L01_Write_Buf(SPI_WRITE_REG+RX_ADDR_P5,(u8*)RX5_Address,1);//写RX节点地址（通道5），也就是表示用哪个通道接收数据
NRF24L01_Write_Reg(SPI_WRITE_REG+EN_AA, 0x01); //使能通道0的自动应答
NRF24L01_Write_Reg(SPI_WRITE_REG+EN_RXADDR,0x01); //使能通道0的接收地址，共有6个通道，高两位保留固定为00
NRF24L01_Write_Reg(SPI_WRITE_REG+RF_CH,0); //设置RF通信频率
NRF24L01_Write_Reg(SPI_WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);//选择通道0的有效数据宽度
NRF24L01_Write_Reg(SPI_WRITE_REG+RF_SETUP,0x07);//设置TX发射参数,0db增益,2Mbps,低噪声增益开启
NRF24L01_Write_Reg(SPI_WRITE_REG+CONFIG, 0x0f);//配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式
NRF24L01_CE = 1; //CE为高,进入接收模式
}
/**
@* 函数名：TX_Mode()
@* 描述 ：该函数初始化NRF24L01到TX模式
@* 设置TX地址,写TX数据宽度,设置RX自动应答的地址,
@* 填充TX发送数据,选择RF频道,波特率和LNA HCURR,PWR_UP,CRC使能
@* 当CE变高后,即进入RX模式,并可以接收数据了
@* CE为高大于10us,则启动发送
@* 输入 ：addr，要发送数据的目标地址
@* 输出 : 无
@* 调用 ：外部板级支持包调用
*/
void TX_Mode(u8 * addr) {
NRF24L01_CE=0; //CE为0进入待机模式
NRF24L01_Write_Buf(SPI_WRITE_REG+TX_ADDR, addr, TX_ADR_WIDTH);//写TX节点地址，也就是接收方的地址（目标地址）
//在发送端，数据通道0被用作接收应答信号，因此数据通道0的接收地址必须要与发送端的地址相同以确保收到正确的应答信号
NRF24L01_Write_Buf(SPI_WRITE_REG+RX_ADDR_P0,(u8*)addr, RX_ADR_WIDTH);
//先单独测试发送方，看发送是否正常
NRF24L01_Write_Reg(SPI_WRITE_REG+EN_AA,0x01); //使能通道0的自动应答
NRF24L01_Write_Reg(SPI_WRITE_REG+EN_RXADDR,0x01); //使能通道0的接收地址
NRF24L01_Write_Reg(SPI_WRITE_REG+SETUP_RETR, 0x1a); //使能自动重发，设置自动重发间隔时间:500us + 86us;最大自动重发次数:10次
NRF24L01_Write_Reg(SPI_WRITE_REG+RF_CH,0); //设置RF通道为40
NRF24L01_Write_Reg(SPI_WRITE_REG+RF_SETUP,0x07); //设置TX发射参数,0db增益,2Mbps,低噪声增益开启
NRF24L01_Write_Reg(SPI_WRITE_REG+CONFIG,0x0e); //配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式,开启所有中断
NRF24L01_CE=1;//CE为高,10us后启动发送
}
#endif
/******************************************END OF FILE*************************************************/中断处理函数（stm32f10x_it.c）
#if nRF24L01_EN > 0u
#include "24l01.h"
/**
@*功能简介：I/O线中断处理函数，处理nRF24L01的数据接收中断，IO口是PB11
@*参数：None
@*返回值：None
*/
void EXTI15_10_IRQHandler(void)
{
OSIntEnter(); //用于统计中断的嵌套层数，对嵌套层数+1，请注意：这适用于有内核参与的中断
if (EXTI_GetITStatus(NRF24L01_STATUS_LINE)!=RESET) {
EXTI_ClearITPendingBit(NRF24L01_STATUS_LINE);//清除中断标志位
if (!GPIO_ReadInputDataBit(NRF24L01_SPI_GPIO_SRC, NRF24L01_IRQ_PIN)) {//如果为低电平表示产生中断
u8 sta; u8 sta2;
sta=NRF24L01_Read_Reg(STATUS); //读取nRF24L01状态寄存器的值
sta2=NRF24L01_Read_Reg(FIFO_STATUS);//读取FIFO状态寄存器
//状态寄存器的bit1-bit3是表示接收到数据的通道号，最大值为6
//*chl=(0x0e&sta)>>1;
NRF24L01_Write_Reg(SPI_WRITE_REG+STATUS,sta); //清除TX_DS或MAX_RT中断标志，注意这里是写1清零，只有清零后设备才能正常通讯
if(sta & RX_OK) { //此次中断表示是接收到了数据
OS_ERR err;
USART1_SendData((u8*)"Feedback received!", 19);
//直接发信号量给任务，这种方式比使用中介信号量更快，更节省资源
//第二个参数：1. OS_OPT_POST_NONE表明在发布任务信号量之后调用任务调度程序
// 2. OS_OPT_POST_NO_SCHED则OSTaskSemPost后不会调用调度程序
OSTaskSemPost(&nRF24L01_TCB,
OS_OPT_POST_NONE,
&err);
}else if (sta & MAX_TX) { //此次中断表示达到最大重发次数后必须手动清除TX FIFO寄存器
USART1_SendData((u8 *)"Max retransmission reached!", 28);
NRF24L01_Write_Reg(FLUSH_TX,0xff);
}
//如果数据发送成功，则相应的寄存器值为下列值，可以调试用：
//FIFO_STATUS: 0x11
//STATUS: 0x2E
else if (sta & TX_OK) { //此次中断表示发送数据成功，无需手动清除TX FIFO寄存器
USART1_SendData((u8 *)"Send data OK!", 14);
RX_Mode(); //数据成功发送后直接转为接收模式
}
}
}
OSIntExit();//对嵌套层数减1，在退出中断前启动任务调度（适用于有u/COS-III内核参与的中断）
}
#endi
在中断处理函数中，当收到数据的中断产生时，也就是RX_DR位置高时，我会将接收数据的工作交给某个任务去做，这里我使用的是发布信号量的方法，这样可以尽量减少中断处理的时间。这里我把RX_Mode();这句放在中断处理函数中，也就是数据发送完成后将nRF24L01转换为接收模式，也是出于无奈，因为我在函数NRF24L01_TxPacket中如果使用以下语句，就会出现问题：
while(NRF24L01_IRQ!=0);//等待发送完成，IRQ变为0后表示发送完成或者达到最大重发次数后来我就不用这一句，然后让主程序执行其他的语句，当产生中断后（无论怎样都会产生一种中断，要么发送成功，要么达到最大重传次数）再将nRF24L01的模式变为接收模式，不知这样做是否合理，还望看过的朋友指点一下。
nRF24L01_TCB任务控制块的任务代码主函数（接收数据）：
#if nRF24L01_EN > 0u
/**
@* 函数名：Task_nRF24L01_Sendback_Process()
@* 描述 : 无线2.4G模块nRF24L01接收反馈数据包处理任务，优先级为4
@* 当Main_Task或USART1_Task或Wi-Fi模块确定是要以无线2.4G方式发送数据给客户端后，会等待客户端设备的回应
@* 以确定此次操作是否成功并同时会启动一个定时器，此任务采用等待信号量方式确认是否有客户端的回复
@* 如果收到回复，则会根据上位机发送数据给主控制MCU的方式将回应数据包回发给上位机。
@*
@* 发送数据给上位机的方式有以下几种：
@* *****************************
@* * 1. 网络方式 *
@* * 2. 串口方式 *
@* * 3. Wi-Fi方式 *
@* *****************************
@* 输入 ：p_arg: 创建任务时赋给任务的参数，该参数可以是任意类型的
@* 输出 : 无
*/
void Task_nRF24L01_Sendback_Process(void *p_arg) {
OS_ERR err; //用于记录错误代号
//u8 chl=0; //接收到数据的通道号
CPU_TS ts;
u8 n24l01_buf[32]; //接收2.4G数据缓冲区
(void)p_arg; //保存创建任务控制块时传递的任务参数
while(NRF24L01_Check()) { //如果检测不到24L01模块则打印出错信息
printf("No nRF24L01 device is found!\r\n");
}
RX_Mode(); //默认为接收模式
OSTimeDlyHMSM(0, 0, 0, 2, OS_OPT_TIME_HMSM_STRICT,&err); //至少延时130微秒后，nRF24L01模块进入接收状态
while(DEF_ON) {
IWDG_Feed(); //每个任务都会调用看门狗程序
//*************************使用中断方式*************************************
OSTaskSemPend(0,
OS_OPT_PEND_BLOCKING,
&ts, //信号量等待的时间
&err);
switch(err) { //处理Pend的结果
case OS_ERR_NONE:
OSTmrDel(&ClientDeviceTimeout_Tmr,&err); //正确接收到反馈数据包则删除定时器
<strong><span style="color:#990000;">NRF24L01_Read_Buf(RD_RX_PLOAD, n24l01_buf, RX_PLOAD_WIDTH); //从nRF24L01中读取接收到的数据
NRF24L01_Write_Reg(FLUSH_RX, 0xff); //清除RX FIFO接收数据寄存器</span></strong>
switch(snd_type){ //根据上位机发送指令的方式分别处理
#if ETHNET_EN > 0u
case Ethernet: //以太网方式
if (custom_udp_send.cus_pbuf!=NULL) {
custom_udp_send.cus_pbuf->payload=n24l01_buf; //得到反馈数据包
custom_udp_send.cus_pbuf->tot_len=custom_udp_send.cus_pbuf->len=sizeof(n24l01_buf);
udp_sendto(custom_udp_send.cus_udp_pcb, //使用当前pbuf发送反馈数据包到客户端
custom_udp_send.cus_pbuf,
custom_udp_send.cus_ip_addr,
custom_udp_send.cus_udp_port);
pbuf_free(custom_udp_send.cus_pbuf); //释放缓冲池中的当前pbuf对象
custom_udp_send.cus_pbuf=NULL;
}
break;
#endif
#if RS232_EN > 0u
case RS232: //RS232串口方式
USART1_SendData(n24l01_buf, sizeof(n24l01_buf));
break;
#endif
#if HF_LPB100_EN > 0u
case WiFi: //Wi-Fi方式（需要Wi-Fi模块作为服务端）
USART3_SendData(n24l01_buf, sizeof(n24l01_buf));
break;
#endif
default:
break;
}
break;
case OS_ERR_PEND_ABORT: //等待（挂起）状态被其他任务打断
break;
case OS_ERR_OBJ_DEL: //内核对象已被删除
break;
default:
break;
}
// //*************************原来的方式，使用查询法****************************
//
// if(NRF24L01_RxPacket(n24l01_buf, &chl)==0) { //如果正确接收到数据
// //nRF24L01_BUF[31]=chl; //最后一个字节表示模块接收到数据的通道号（暂时不用）
// USART1_SendData(n24l01_buf,sizeof(n24l01_buf)); //测试接收到的数据
// OSTmrDel(&ClientDeviceTimeout_Tmr,&err); //正确接收到反馈数据包则删除定时器
//
// switch(snd_type){ //根据上位机发送指令的方式分别处理
// #if ETHNET_EN > 0u
// case Ethernet: //以太网方式
// if (custom_udp_send.cus_pbuf!=NULL) {
// custom_udp_send.cus_pbuf->payload=n24l01_buf; //得到反馈数据包
// custom_udp_send.cus_pbuf->tot_len=custom_udp_send.cus_pbuf->len=sizeof(n24l01_buf);
// udp_sendto(custom_udp_send.cus_udp_pcb, //使用当前pbuf发送反馈数据包到客户端
// custom_udp_send.cus_pbuf,
// custom_udp_send.cus_ip_addr,
// custom_udp_send.cus_udp_port);
// pbuf_free(custom_udp_send.cus_pbuf); //释放缓冲池中的当前pbuf对象
// custom_udp_send.cus_pbuf=NULL;
// }
// break;
// #endif
//
// #if RS232_EN > 0u
// case RS232: //RS232串口方式
// USART1_SendData(n24l01_buf, sizeof(n24l01_buf));
// break;
// #endif
//
// #if HF_LPB100_EN > 0u
// case WiFi: //Wi-Fi方式（需要Wi-Fi模块作为服务端）
// USART3_SendData(n24l01_buf, sizeof(n24l01_buf));
// break;
// #endif
//
// default:
// break;
// }
// }
//
// OSTimeDlyHMSM(0, 0, 0, 1, OS_OPT_TIME_HMSM_NON_STRICT,&err); //阻塞1毫秒，即延时1个时钟节拍
}
}
#endif
发送数据的代码就比较简单了，这里只列出部分代码：
#if nRF24L01_EN > 0u
TX_Mode(addr_t); //设置nRF24L01模块为发送模式
NRF24L01_TxPacket(arg);
OSTimeDlyHMSM(0, 0, 0, 1, OS_OPT_TIME_HMSM_STRICT,&err); //根据手册说明，至少延时10微秒后开始发送，这里延时长了一些
//******其他的方式发送数据******
//NRF24L01_CE=0;
//NRF24L01_Write_Buf(WR_TX_PLOAD, arg, TX_PLOAD_WIDTH); //写数据到TX BUF 最长32个字节
//NRF24L01_CE=1; //启动发送，10微秒后会发送数据
//OSTimeDlyHMSM(0, 0, 0, 20, OS_OPT_TIME_HMSM_STRICT,&err); //延时以等待数据发送完成并产生中断，至少拉高CE10微秒才开始发送
//RX_Mode(); //设置nRF24L01为接收模式，至少延时130微秒
//OSTimeDlyHMSM(0, 0, 0, 2, OS_OPT_TIME_HMSM_STRICT,&err);
#endif
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
