NRF24L01无线2.4G控制模块

NRF24L01是一款工作在2.4-2.5GHz世界通用ISM频段的单片收发芯片， 使用4线SPI通讯端口，通讯速率最高可达8Mbps，适合与各种MCU连接，编程简单；输出功率、频道选择和协议的设置可以通过SPI接口设置极低的电流消耗，当工作在发射模式下发射功率为6dBm时电流消耗为9.0mA接受模式为12.3mA掉电模式和待机模式下电流消耗模式更低。

模块来源

采购链接：

资料下载链接：

https://pan.baidu.com/s/1CUQ3SOdnmD8xSXMdR4YopA

资料提取码：1234

规格参数

工作电压：1.9~3.6V
供电电流：900~12.3mA
最大数据传输率：2000 Kbps
控制方式：SPI
管脚数量：8 Pin（2.54mm间距排针）

移植过程

我们的目标是在天空星GD32F407上能够实现无线的数据传输的功能。首先要获取资料，查看数据手册应如何实现，再移植至我们的工程。

使用事项

代码中实现了接收端与发送端的实现步骤。如使用接收数据功能，将 TRANSMIT_or_RECEIVE.h 文件中的宏 RECEIVING_MODE 置1；如使用发送数据功能，将宏置0.

接收方式

NRF24L01的接收端是靠IRQ引脚进行判断，当IRQ为高电平时，说明接收到了数据，IRQ为1则是正在等待数据。因此可以根据IRQ引脚来决定接收的方式。这里提供轮询方式和中断方式。

轮询方式接收

采用轮询方式会阻碍其他任务的运行，因接收数据要时时刻刻判断IRQ引脚是否为高电平，会一直占用MCU的时间。为了解决因为没有接收到数据就卡死问题以及防止错过数据没有接收问题，在等待数据的过程中，加入了超时判断，当一定的时间内没有接收到数据，则结束等待接收，去运行其他任务。

中断方式接收
采用中断方式接收数据，是通过将IRQ引脚设置为外部中断功能。

当检测到IRQ引脚有变化时，则接收数据。根据24L01的要求，当接收完数据后，必须清除接收的FIFO。

引脚选择

各引脚说明。

硬件SPI与软件SPI相比，硬件SPI是靠硬件上面的SPI控制器，所有的时钟边缘采样，时钟发生，还有时序控制，都是由硬件完成的。它降低了CPU的使用率，提高了运行速度。软件SPI就是用代码控制IO输出高低电平，模拟SPI的时序，这种方法通信速度较慢，且不可靠。
主控为GD32F407VET6，其带有3个SPI外设，可以通过简单的库函数调用，实现硬件SPI的通信。想要使用硬件SPI驱动，需要确定使用的引脚是否有SPI外设功能。可以通过数据手册【GD32F407xx_Datasheet_Rev2.7.pdf】进行查看。

在数据手册的第40页结尾，是关于GD32F407Vx系列芯片引脚的功能定义示意图。

当前使用的是硬件SPI接口，而NRF24L01我们需要与它发送数据也需要接收数据，故使用的是4线的SPI，使用到了时钟线SCK、主机输出从机输入线MOSI、主机输入从机输出线MISO和软件控制的片选线NSS。所以除了这些引脚需要使用硬件SPI功能的引脚外，其他引脚都可以使用开发板上其他的GPIO。这里选择使用PB13/PB14/PB15的SPI复用功能。其他对应接入的引脚请按照你的需要。这里选择的引脚见右表。

移植至工程

将bsp_uart.h文件，替换成下方的代码：

/*
* 天空星软硬件资料与相关扩展板软硬件资料官网全部开源
* 开发板官网：www.lckfb.com
* 技术支持常驻论坛，任何技术问题欢迎随时交流学习
* 立创论坛：club.szlcsc.com
* 关注bilibili账号：【立创开发板】，掌握我们的最新动态！
* 不靠卖板赚钱，以培养中国工程师为己任
* Change Logs:
* Date           Author       Notes
* 2023-11-02     LCKFB-yzh    first version
*/

#ifndef __BSP_UART_H__
#define __BSP_UART_H__

#include "board.h"

#define BSP_USART_TX_RCU  RCU_GPIOA   // 串口TX的端口时钟
#define BSP_USART_RX_RCU  RCU_GPIOA   // 串口RX的端口时钟
#define BSP_USART_RCU     RCU_USART0  // 串口0的时钟

#define BSP_USART_TX_PORT GPIOA                                // 串口TX的端口
#define BSP_USART_RX_PORT GPIOA                                // 串口RX的端口
#define BSP_USART_AF                         GPIO_AF_7   // 串口0的复用功能
#define BSP_USART_TX_PIN  GPIO_PIN_9  // 串口TX的引脚
#define BSP_USART_RX_PIN  GPIO_PIN_10 // 串口RX的引脚

#define BSP_USART                                                 USART0                                                                      // 串口0
#define BSP_USART_IRQ                     USART0_IRQn                                                                 // 串口0中断
#define BSP_USART_IRQHandler  USART0_IRQHandler                                                // 串口0中断服务函数

/* 串口缓冲区的数据长度 */
#define USART_RECEIVE_LENGTH  1024

extern uint8_t  g_recv_buff[]; // 接收缓冲区
extern uint16_t g_recv_length;                                                                                 // 接收数据长度
extern uint8_t  g_recv_complete_flag;                                                  // 接收完成标志位

void usart_gpio_config(uint32_t band_rate);                           // 配置串口
void usart_send_data(uint8_t ucch);                                   // 发送一个字符
void usart_send_string(uint8_t *ucstr);                               // 发送一个字符串
void  usart_receive_clear(void);

#endif /* __BSP_UART_H__ */

将bsp_uart.c文件，替换成下方的代码：

/*
* 天空星软硬件资料与相关扩展板软硬件资料官网全部开源
* 开发板官网：www.lckfb.com
* 技术支持常驻论坛，任何技术问题欢迎随时交流学习
* 立创论坛：club.szlcsc.com
* 关注bilibili账号：【立创开发板】，掌握我们的最新动态！
* 不靠卖板赚钱，以培养中国工程师为己任
* Change Logs:
* Date           Author       Notes
* 2023-11-02     LCKFB-yzh    first version
*/

#include "bsp_uart.h"
#include <stdio.h>

uint8_t         g_recv_buff[];   // 接收缓冲区
uint16_t         g_recv_length = 0;                                                                         // 接收数据长度
uint8_t                g_recv_complete_flag = 0;                                          // 接收数据完成标志位

/************************************************
函数名称 ： usart_gpio_config
功    能 ： 串口配置GPIO
参    数 ： band_rate:波特率
返 回 值 ： 无
作    者 ： LC
*************************************************/
void usart_gpio_config(uint32_t band_rate)
{
        /* 开启时钟 */
        rcu_periph_clock_enable(BSP_USART_TX_RCU);   // 开启串口时钟
        rcu_periph_clock_enable(BSP_USART_RX_RCU);   // 开启端口时钟
        rcu_periph_clock_enable(BSP_USART_RCU);      // 开启端口时钟

        /* 配置GPIO复用功能 */
  gpio_af_set(BSP_USART_TX_PORT,BSP_USART_AF,BSP_USART_TX_PIN);
        gpio_af_set(BSP_USART_RX_PORT,BSP_USART_AF,BSP_USART_RX_PIN);

        /* 配置GPIO的模式 */
        /* 配置TX为复用模式 上拉模式 */
        gpio_mode_set(BSP_USART_TX_PORT,GPIO_MODE_AF,GPIO_PUPD_PULLUP,BSP_USART_TX_PIN);
        /* 配置RX为复用模式 上拉模式 */
        gpio_mode_set(BSP_USART_RX_PORT, GPIO_MODE_AF,GPIO_PUPD_PULLUP,BSP_USART_RX_PIN);

        /* 配置TX为推挽输出 50MHZ */
        gpio_output_options_set(BSP_USART_TX_PORT,GPIO_OTYPE_PP,GPIO_OSPEED_50MHZ,BSP_USART_TX_PIN);
        /* 配置RX为推挽输出 50MHZ */
        gpio_output_options_set(BSP_USART_RX_PORT,GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, BSP_USART_RX_PIN);

        /* 配置串口的参数 */
        usart_deinit(BSP_USART);                                 // 复位串口
        usart_baudrate_set(BSP_USART,band_rate);                 // 设置波特率
        usart_parity_config(BSP_USART,USART_PM_NONE);            // 没有校验位
        usart_word_length_set(BSP_USART,USART_WL_8BIT);          // 8位数据位
        usart_stop_bit_set(BSP_USART,USART_STB_1BIT);                              // 1位停止位

  /* 使能串口 */
        usart_enable(BSP_USART);                                 // 使能串口
        usart_transmit_config(BSP_USART,USART_TRANSMIT_ENABLE);  // 使能串口发送
        usart_receive_config(BSP_USART,USART_RECEIVE_ENABLE);    // 使能串口接收

        /* 中断配置 */
        nvic_irq_enable(BSP_USART_IRQ, 2, 2);                                                                          // 配置中断优先级
        usart_interrupt_enable(BSP_USART,USART_INT_RBNE);                                 // 读数据缓冲区非空中断和溢出错误中断
        usart_interrupt_enable(BSP_USART,USART_INT_IDLE);                                 // 空闲检测中断
}

/************************************************
函数名称 ： usart_send_data
功    能 ： 串口重发送一个字节
参    数 ： ucch：要发送的字节
返 回 值 ：
作    者 ： LC
*************************************************/
void usart_send_data(uint8_t ucch)
{
        usart_data_transmit(BSP_USART,(uint8_t)ucch);                                                         // 发送数据
        while(RESET == usart_flag_get(BSP_USART,USART_FLAG_TBE));  // 等待发送数据缓冲区标志置位
}


/************************************************
函数名称 ： usart_send_String
功    能 ： 串口发送字符串
参    数 ： ucstr:要发送的字符串
返 回 值 ：
作    者 ： LC
*************************************************/
void usart_send_string(uint8_t *ucstr)
{
        while(ucstr && *ucstr)        // 地址为空或者值为空跳出
        {
          usart_send_data(*ucstr++);  // 发送单个字符
        }
}
void  usart_receive_clear(void)
{
    unsigned int i = 0;
    for( i = 0; i < USART_RECEIVE_LENGTH; i++ )
    {
        g_recv_buff[] = 0;
    }
    g_recv_length = 0;
}

#if !defined(__MICROLIB)
//不使用微库的话就需要添加下面的函数
#if (__ARMCLIB_VERSION <= 6000000)
//如果编译器是AC5  就定义下面这个结构体
struct __FILE
{
        int handle;
};
#endif

FILE __stdout;

//定义_sys_exit()以避免使用半主机模式
void _sys_exit(int x)
{
        x = x;
}
#endif

/* retarget the C library printf function to the USART */
int fputc(int ch, FILE *f)
{
    usart_data_transmit(BSP_USART, (uint8_t)ch);
    while(RESET == usart_flag_get(BSP_USART, USART_FLAG_TBE));
    return ch;
}

/************************************************
函数名称 ： BSP_USART_IRQHandler
功    能 ： 串口接收中断服务函数
参    数 ： 无
返 回 值 ： 无
作    者 ： LC
*************************************************/
void BSP_USART_IRQHandler(void)
{
        if(usart_interrupt_flag_get(BSP_USART,USART_INT_FLAG_RBNE) == SET)   // 接收缓冲区不为空
        {
                g_recv_buff[] = usart_data_receive(BSP_USART);      // 把接收到的数据放到缓冲区中
        }

        if(usart_interrupt_flag_get(BSP_USART,USART_INT_FLAG_IDLE) == SET)   // 检测到帧中断
        {
                usart_data_receive(BSP_USART);                                     // 必须要读，读出来的值不能要
                g_recv_buff[] = '\0';                                                                                                                                 // 数据接收完毕，数组结束标志
                g_recv_complete_flag = 1;                                          // 接收完成
                usart_interrupt_flag_clear(BSP_USART, USART_INT_FLAG_IDLE);
        }

}

在文件rev_spi.c中，编写如下代码。

#include "drv_spi.h"



/** 硬件SPI */
#define SPI_WAIT_TIMEOUT                        ((uint16_t)0xFFFF)

/**
  * @brief :SPI初始化(硬件)
  * @param :无
  * @note  :无
  * @retval:无
  */
void drv_spi_init( void )
{
    spi_parameter_struct spi_init_struct;

    rcu_periph_clock_enable(SPI_CLK_GPIO_CLK);
    rcu_periph_clock_enable(SPI_MISO_GPIO_CLK);
    rcu_periph_clock_enable(SPI_MOSI_GPIO_CLK);
     rcu_periph_clock_enable(SPI_NSS_GPIO_CLK);

    rcu_periph_clock_enable(RCU_SPI_HARDWARE);  // 使能SPI

     /* 配置 SPI的CLK GPIO */
    gpio_af_set(SPI_CLK_GPIO_PORT, LINE_AF_SPI, SPI_CLK_GPIO_PIN);
    gpio_mode_set(SPI_CLK_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, SPI_CLK_GPIO_PIN);
    gpio_output_options_set(SPI_CLK_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, SPI_CLK_GPIO_PIN);
    gpio_bit_set(SPI_CLK_GPIO_PORT,SPI_CLK_GPIO_PIN);
      /* 配置 SPI的MOSI  GPIO */
    gpio_af_set(SPI_MOSI_GPIO_PORT, LINE_AF_SPI, SPI_MOSI_GPIO_PIN);
    gpio_mode_set(SPI_MOSI_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, SPI_MOSI_GPIO_PIN);
    gpio_output_options_set(SPI_MOSI_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, SPI_MOSI_GPIO_PIN);
    gpio_bit_set(SPI_MOSI_GPIO_PORT, SPI_MOSI_GPIO_PIN);

      /* 配置 SPI的MIS0  GPIO */
    gpio_af_set(SPI_MISO_GPIO_PORT, LINE_AF_SPI, SPI_MISO_GPIO_PIN);
    gpio_mode_set(SPI_MISO_GPIO_PORT, GPIO_MODE_AF, GPIO_PUPD_NONE, SPI_MISO_GPIO_PIN);
    gpio_output_options_set(SPI_MISO_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ, SPI_MISO_GPIO_PIN);
    gpio_bit_set(SPI_MISO_GPIO_PORT, SPI_MISO_GPIO_PIN);

        //NSS配置为推挽输出
    /* 配置CS */
    gpio_mode_set(SPI_NSS_GPIO_PORT,GPIO_MODE_OUTPUT,GPIO_PUPD_PULLUP,SPI_NSS_GPIO_PIN);
    gpio_output_options_set(SPI_NSS_GPIO_PORT,GPIO_OTYPE_PP,GPIO_OSPEED_50MHZ,SPI_NSS_GPIO_PIN);
    gpio_bit_write(SPI_NSS_GPIO_PORT, SPI_NSS_GPIO_PIN, SET);

        /** SPI配置 */
    /* 配置 SPI 参数 */
    spi_init_struct.trans_mode           = SPI_TRANSMODE_FULLDUPLEX;  // 传输模式全双工
    spi_init_struct.device_mode          = SPI_MASTER;   // 配置为主机
    spi_init_struct.frame_size           = SPI_FRAMESIZE_8BIT; // 8位数据
    spi_init_struct.clock_polarity_phase = SPI_CK_PL_LOW_PH_1EDGE;//第一个时钟沿
    spi_init_struct.nss                  = SPI_NSS_SOFT;  // 软件cs
    spi_init_struct.prescale             = SPI_PSC_16;//32分频
    spi_init_struct.endian               = SPI_ENDIAN_MSB;
    spi_init(PORT_SPI, &spi_init_struct);

    /* 使能 SPI */
    spi_enable(PORT_SPI);
}

/**
  * @brief :SPI收发一个字节
  * @param :
  *                        @TxByte: 发送的数据字节
  * @note  :非堵塞式，一旦等待超时，函数会自动退出
  * @retval:接收到的字节
  */
uint8_t drv_spi_read_write_byte( uint8_t TxByte )
{
        uint8_t l_Data = 0;
        uint16_t l_WaitTime = 0;

    while(RESET == spi_i2s_flag_get(PORT_SPI, SPI_FLAG_TBE))//等待发送缓冲区为空
        {
                if( SPI_WAIT_TIMEOUT == ++l_WaitTime )
                {
                        break;                        //如果等待超时则退出
                }
        }
        l_WaitTime = SPI_WAIT_TIMEOUT / 2;                //重新设置接收等待时间(因为SPI的速度很快，正常情况下在发送完成之后会立即收到数据，等待时间不需要过长)
        spi_i2s_data_transmit(PORT_SPI, TxByte);//发送数据

    while(RESET == spi_i2s_flag_get(PORT_SPI, SPI_FLAG_RBNE))//等待接收缓冲区非空
        {
                if( SPI_WAIT_TIMEOUT == ++l_WaitTime )
                {
                        break;                        //如果等待超时则退出
                }
        }
    l_Data = spi_i2s_data_receive(PORT_SPI);//读取接收数据

        return l_Data;                //返回
}

/**
  * @brief :SPI收发字符串
  * @param :
  *                        @ReadBuffer: 接收数据缓冲区地址
  *                        @WriteBuffer:发送字节缓冲区地址
  *                        @Length:字节长度
  * @note  :非堵塞式，一旦等待超时，函数会自动退出
  * @retval:无
  */
void drv_spi_read_write_string( uint8_t* ReadBuffer, uint8_t* WriteBuffer, uint16_t Length )
{
    spi_set_nss_low( );//拉低片选
        while( Length-- )
        {
                *ReadBuffer = drv_spi_read_write_byte( *WriteBuffer );                //收发数据
                ReadBuffer++;
                WriteBuffer++;                                //读写地址加1
        }
    spi_set_nss_high( );//拉高片选
}

在drv_spi.h中，修改为如下代码。

#ifndef __DRV_SPI_H__
#define __DRV_SPI_H__

#include "gd32f4xx.h"


//SPI引脚定义
#define SPI_CLK_GPIO_PORT                GPIOB
#define SPI_CLK_GPIO_CLK                 RCU_GPIOB
#define SPI_CLK_GPIO_PIN                  GPIO_PIN_13

#define SPI_MISO_GPIO_PORT                GPIOB
#define SPI_MISO_GPIO_CLK                 RCU_GPIOB
#define SPI_MISO_GPIO_PIN                GPIO_PIN_14

#define SPI_MOSI_GPIO_PORT               GPIOB
#define SPI_MOSI_GPIO_CLK               RCU_GPIOB
#define SPI_MOSI_GPIO_PIN                GPIO_PIN_15

#define SPI_NSS_GPIO_PORT                  GPIOB
#define SPI_NSS_GPIO_CLK                   RCU_GPIOB
#define SPI_NSS_GPIO_PIN                  GPIO_PIN_9


#define spi_set_nss_high( )                        gpio_bit_write(SPI_NSS_GPIO_PORT,        SPI_NSS_GPIO_PIN, SET)                //片选置高
#define spi_set_nss_low( )                        gpio_bit_write(SPI_NSS_GPIO_PORT,        SPI_NSS_GPIO_PIN, RESET)        //片选置低



/******** 硬件SPI修改此次 ********/
#define RCU_SPI_HARDWARE RCU_SPI1
#define PORT_SPI         SPI1
#define LINE_AF_SPI      GPIO_AF_5


void drv_spi_init( void );
uint8_t drv_spi_read_write_byte( uint8_t TxByte );
void drv_spi_read_write_string( uint8_t* ReadBuffer, uint8_t* WriteBuffer, uint16_t Length );

#endif

在NRF24L01.c中，修改如下代码。

#include "NRF24L01.h"
#include "board.h"
#include "stdio.h"
#include "TRANSMIT_or_RECEIVE.h"


const char *g_ErrorString = "RF24L01 is not find !...";


void drv_delay_500Ms( unsigned int ms)
{
        while(ms--)
        {
                delay_ms(500);
        }
}

/**
  * @brief :NRF24L01读寄存器
  * @param :
           @Addr:寄存器地址
  * @note  :地址在设备中有效
  * @retval:读取的数据
  */
uint8_t NRF24L01_Read_Reg( uint8_t RegAddr )
{
    uint8_t btmp;

    RF24L01_SET_CS_LOW( );                        //片选

    drv_spi_read_write_byte( NRF_READ_REG | RegAddr );        //读命令 地址
    btmp = drv_spi_read_write_byte( 0xFF );                                //读数据

    RF24L01_SET_CS_HIGH( );                        //取消片选

    return btmp;
}

/**
  * @brief :NRF24L01读指定长度的数据
  * @param :
  *                        @reg:地址
  *                        @pBuf:数据存放地址
  *                        @len:数据长度
  * @note  :数据长度不超过255，地址在设备中有效
  * @retval:读取状态
  */
void NRF24L01_Read_Buf( uint8_t RegAddr, uint8_t *pBuf, uint8_t len )
{
    uint8_t btmp;

    RF24L01_SET_CS_LOW( );                        //片选

    drv_spi_read_write_byte( NRF_READ_REG | RegAddr );        //读命令 地址
    for( btmp = 0; btmp < len; btmp ++ )
    {
        *( pBuf + btmp ) = drv_spi_read_write_byte( 0xFF );        //读数据
    }
    RF24L01_SET_CS_HIGH( );                //取消片选
}

/**
  * @brief :NRF24L01写寄存器
  * @param :无
  * @note  :地址在设备中有效
  * @retval:读写状态
  */
void NRF24L01_Write_Reg( uint8_t RegAddr, uint8_t Value )
{
    RF24L01_SET_CS_LOW( );                //片选

    drv_spi_read_write_byte( NRF_WRITE_REG | RegAddr );        //写命令 地址
    drv_spi_read_write_byte( Value );                        //写数据

    RF24L01_SET_CS_HIGH( );                //取消片选
}

/**
  * @brief :NRF24L01写指定长度的数据
  * @param :
  *                        @reg:地址
  *                        @pBuf:写入的数据地址
  *                        @len:数据长度
  * @note  :数据长度不超过255，地址在设备中有效
  * @retval:写状态
  */
void NRF24L01_Write_Buf( uint8_t RegAddr, uint8_t *pBuf, uint8_t len )
{
    uint8_t i;

    RF24L01_SET_CS_LOW( );                //片选

    drv_spi_read_write_byte( NRF_WRITE_REG | RegAddr );        //写命令 地址
    for( i = 0; i < len; i ++ )
    {
        drv_spi_read_write_byte( *( pBuf + i ) );                //写数据
    }

    RF24L01_SET_CS_HIGH( );                //取消片选
}

/**
  * @brief :清空TX缓冲区
  * @param :无
  * @note  :无
  * @retval:无
  */
void NRF24L01_Flush_Tx_Fifo ( void )
{
    RF24L01_SET_CS_LOW( );                //片选

    drv_spi_read_write_byte( FLUSH_TX );        //清TX FIFO命令

    RF24L01_SET_CS_HIGH( );                //取消片选
}

/**
  * @brief :清空RX缓冲区
  * @param :无
  * @note  :无
  * @retval:无
  */
void NRF24L01_Flush_Rx_Fifo( void )
{
    RF24L01_SET_CS_LOW( );                //片选

    drv_spi_read_write_byte( FLUSH_RX );        //清RX FIFO命令

    RF24L01_SET_CS_HIGH( );                //取消片选
}

/**
  * @brief :重新使用上一包数据
  * @param :无
  * @note  :无
  * @retval:无
  */
void NRF24L01_Reuse_Tx_Payload( void )
{
    RF24L01_SET_CS_LOW( );                //片选

    drv_spi_read_write_byte( REUSE_TX_PL );                //重新使用上一包命令

    RF24L01_SET_CS_HIGH( );                //取消片选
}

/**
  * @brief :NRF24L01空操作
  * @param :无
  * @note  :无
  * @retval:无
  */
void NRF24L01_Nop( void )
{
    RF24L01_SET_CS_LOW( );                //片选

    drv_spi_read_write_byte( NOP );                //空操作命令

    RF24L01_SET_CS_HIGH( );                //取消片选
}

/**
  * @brief :NRF24L01读状态寄存器
  * @param :无
  * @note  :无
  * @retval:RF24L01状态
  */
uint8_t NRF24L01_Read_Status_Register( void )
{
    uint8_t Status;

    RF24L01_SET_CS_LOW( );                //片选

    Status = drv_spi_read_write_byte( NRF_READ_REG + STATUS );        //读状态寄存器

    RF24L01_SET_CS_HIGH( );                //取消片选

    return Status;
}

/**
  * @brief :NRF24L01清中断
  * @param :
           @IRQ_Source:中断源
  * @note  :无
  * @retval:清除后状态寄存器的值
  */
uint8_t NRF24L01_Clear_IRQ_Flag( uint8_t IRQ_Source )
{
    uint8_t btmp = 0;

    IRQ_Source &= ( 1 << RX_DR ) | ( 1 << TX_DS ) | ( 1 << MAX_RT );        //中断标志处理
    btmp = NRF24L01_Read_Status_Register( );                        //读状态寄存器

    RF24L01_SET_CS_LOW( );                        //片选
    drv_spi_read_write_byte( NRF_WRITE_REG + STATUS );        //写状态寄存器命令
    drv_spi_read_write_byte( IRQ_Source | btmp );                //清相应中断标志
    RF24L01_SET_CS_HIGH( );                        //取消片选

    return ( NRF24L01_Read_Status_Register( ));                        //返回状态寄存器状态
}

/**
  * @brief :读RF24L01中断状态
  * @param :无
  * @note  :无
  * @retval:中断状态
  */
uint8_t RF24L01_Read_IRQ_Status( void )
{
    return ( NRF24L01_Read_Status_Register( ) & (( 1 << RX_DR ) | ( 1 << TX_DS ) | ( 1 << MAX_RT )));        //返回中断状态
}

 /**
  * @brief :读FIFO中数据宽度
  * @param :无
  * @note  :无
  * @retval:数据宽度
  */
uint8_t NRF24L01_Read_Top_Fifo_Width( void )
{
    uint8_t btmp;

    RF24L01_SET_CS_LOW( );                //片选

    drv_spi_read_write_byte( R_RX_PL_WID );        //读FIFO中数据宽度命令
    btmp = drv_spi_read_write_byte( 0xFF );        //读数据

    RF24L01_SET_CS_HIGH( );                //取消片选

    return btmp;
}

 /**
  * @brief :读接收到的数据
  * @param :无
  * @note  :无
  * @retval:
           @pRxBuf:数据存放地址首地址
  */
uint8_t NRF24L01_Read_Rx_Payload( uint8_t *pRxBuf )
{
    uint8_t Width, PipeNum;

    PipeNum = ( NRF24L01_Read_Reg( STATUS ) >> 1 ) & 0x07;        //读接收状态
    Width = NRF24L01_Read_Top_Fifo_Width( );                //读接收数据个数

    RF24L01_SET_CS_LOW( );                //片选
    drv_spi_read_write_byte( RD_RX_PLOAD );                        //读有效数据命令

    for( PipeNum = 0; PipeNum < Width; PipeNum ++ )
    {
        *( pRxBuf + PipeNum ) = drv_spi_read_write_byte( 0xFF );                //读数据
    }
    RF24L01_SET_CS_HIGH( );                //取消片选
    NRF24L01_Flush_Rx_Fifo( );        //清空RX FIFO

    return Width;
}

 /**
  * @brief :发送数据（带应答）
  * @param :
  *                        @pTxBuf:发送数据地址
  *                        @len:长度
  * @note  :一次不超过32个字节
  * @retval:无
  */
void NRF24L01_Write_Tx_Payload_Ack( uint8_t *pTxBuf, uint8_t len )
{
    uint8_t btmp;
    uint8_t length = ( len > 32 ) ? 32 : len;                //数据长达大约32 则只发送32个

    NRF24L01_Flush_Tx_Fifo( );                //清TX FIFO

    RF24L01_SET_CS_LOW( );                        //片选
    drv_spi_read_write_byte( WR_TX_PLOAD );        //发送命令

    for( btmp = 0; btmp < length; btmp ++ )
    {
        drv_spi_read_write_byte( *( pTxBuf + btmp ) );        //发送数据
    }
    RF24L01_SET_CS_HIGH( );                        //取消片选
}

 /**
  * @brief :发送数据（不带应答）
  * @param :
  *                        @pTxBuf:发送数据地址
  *                        @len:长度
  * @note  :一次不超过32个字节
  * @retval:无
  */
void NRF24L01_Write_Tx_Payload_NoAck( uint8_t *pTxBuf, uint8_t len )
{
    if( len > 32 || len == 0 )
    {
        return ;                //数据长度大于32 或者等于0 不执行
    }

    RF24L01_SET_CS_LOW( );        //片选
    drv_spi_read_write_byte( WR_TX_PLOAD_NACK );        //发送命令
    while( len-- )
    {
        drv_spi_read_write_byte( *pTxBuf );                        //发送数据
                pTxBuf++;
    }
    RF24L01_SET_CS_HIGH( );                //取消片选
}

 /**
  * @brief :在接收模式下向TX FIFO写数据(带ACK)
  * @param :
  *                        @pData:数据地址
  *                        @len:长度
  * @note  :一次不超过32个字节
  * @retval:无
  */
void NRF24L01_Write_Tx_Payload_InAck( uint8_t *pData, uint8_t len )
{
    uint8_t btmp;

        len = ( len > 32 ) ? 32 : len;                //数据长度大于32个则只写32个字节

    RF24L01_SET_CS_LOW( );                        //片选
    drv_spi_read_write_byte( W_ACK_PLOAD );                //命令
    for( btmp = 0; btmp < len; btmp ++ )
    {
        drv_spi_read_write_byte( *( pData + btmp ) );        //写数据
    }
    RF24L01_SET_CS_HIGH( );                        //取消片选
}

 /**
  * @brief :设置发送地址
  * @param :
  *                        @pAddr:地址存放地址
  *                        @len:长度
  * @note  :无
  * @retval:无
  */
void NRF24L01_Set_TxAddr( uint8_t *pAddr, uint8_t len )
{
        len = ( len > 5 ) ? 5 : len;                                        //地址不能大于5个字节
    NRF24L01_Write_Buf( TX_ADDR, pAddr, len );        //写地址
}

 /**
  * @brief :设置接收通道地址
  * @param :
  *                        @PipeNum:通道
  *                        @pAddr:地址存肥着地址
  *                        @Len:长度
  * @note  :通道不大于5 地址长度不大于5个字节
  * @retval:无
  */
void NRF24L01_Set_RxAddr( uint8_t PipeNum, uint8_t *pAddr, uint8_t Len )
{
    Len = ( Len > 5 ) ? 5 : Len;
    PipeNum = ( PipeNum > 5 ) ? 5 : PipeNum;                //通道不大于5 地址长度不大于5个字节

    NRF24L01_Write_Buf( RX_ADDR_P0 + PipeNum, pAddr, Len );        //写入地址
}

 /**
  * @brief :设置通信速度
  * @param :
  *                        @Speed:速度
  * @note  :无
  * @retval:无
  */
void NRF24L01_Set_Speed( nRf24l01SpeedType Speed )
{
        uint8_t btmp = 0;

        btmp = NRF24L01_Read_Reg( RF_SETUP );
        btmp &= ~( ( 1<<5 ) | ( 1<<3 ) );

        if( Speed == SPEED_250K )                //250K
        {
                btmp |= ( 1<<5 );
        }
        else if( Speed == SPEED_1M )   //1M
        {
                   btmp &= ~( ( 1<<5 ) | ( 1<<3 ) );
        }
        else if( Speed == SPEED_2M )   //2M
        {
                btmp |= ( 1<<3 );
        }

        NRF24L01_Write_Reg( RF_SETUP, btmp );
}

 /**
  * @brief :设置功率
  * @param :
  *                        @Speed:速度
  * @note  :无
  * @retval:无
  */
void NRF24L01_Set_Power( nRf24l01PowerType Power )
{
    uint8_t btmp;

        btmp = NRF24L01_Read_Reg( RF_SETUP ) & ~0x07;
    switch( Power )
    {
        case POWER_F18DBM:
            btmp |= PWR_18DB;
            break;
        case POWER_F12DBM:
            btmp |= PWR_12DB;
            break;
        case POWER_F6DBM:
            btmp |= PWR_6DB;
            break;
        case POWER_0DBM:
            btmp |= PWR_0DB;
            break;
        default:
            break;
    }
    NRF24L01_Write_Reg( RF_SETUP, btmp );
}

 /**
  * @brief :设置频率
  * @param :
  *                        @FreqPoint:频率设置参数
  * @note  :值不大于127
  * @retval:无
  */
void RF24LL01_Write_Hopping_Point( uint8_t FreqPoint )
{
    NRF24L01_Write_Reg(  RF_CH, FreqPoint & 0x7F );
}

/**
  * @brief :NRF24L01检测
  * @param :无
  * @note  :无
  * @retval:无
  */
void NRF24L01_check( void )
{
        uint8_t i;
        uint8_t error = 0;
        uint8_t buf[]={ 0XA5, 0XA5, 0XA5, 0XA5, 0XA5 };
        uint8_t read_buf[] = { 0 };

        while( 1 )
        {
                NRF24L01_Write_Buf( TX_ADDR, buf, 5 );                        //写入5个字节的地址
                NRF24L01_Read_Buf( TX_ADDR, read_buf, 5 );                //读出写入的地址
                for( i = 0; i < 5; i++ )
                {
                        if( buf[] != read_buf[] )
                        {
                                break;
                        }
                }

                if( 5 == i )
                {
                        break;
                }
                else
                {
                        error++;
                        if( error >= 3 )
                        {
                                break;
                        }
                        //测试错误
                        printf("NRF24L01 ERROR  FILE:NRF24L01.C  LINE = %d\r\n",__LINE__);
                }
                drv_delay_500Ms( 4 );
        }
    printf("Successful configuration\r\n");
}

 /**
  * @brief :设置模式
  * @param :
  *                        @Mode:模式发送模式或接收模式
  * @note  :无
  * @retval:无
  */
void RF24L01_Set_Mode( nRf24l01ModeType Mode )
{
    uint8_t controlreg = 0;
        controlreg = NRF24L01_Read_Reg( CONFIG );

    if( Mode == MODE_TX )
        {
                controlreg &= ~( 1<< PRIM_RX );
        }
    else
        {
                if( Mode == MODE_RX )
                {
                        controlreg |= ( 1<< PRIM_RX );
                }
        }

    NRF24L01_Write_Reg( CONFIG, controlreg );
}

/**
  * @brief :NRF24L01发送一次数据
  * @param :
  *                        @txbuf:待发送数据首地址
  *                        @Length:发送数据长度
  * @note  :无
  * @retval:
  *                        MAX_TX：达到最大重发次数
  *                        TX_OK：发送完成
  *                        0xFF:其他原因
  */
uint8_t NRF24L01_TxPacket( uint8_t *txbuf, uint8_t Length )
{
        uint8_t l_Status = 0;
        uint16_t l_MsTimes = 0;

        RF24L01_SET_CS_LOW( );                //片选
        drv_spi_read_write_byte( FLUSH_TX );
        RF24L01_SET_CS_HIGH( );

        RF24L01_SET_CE_LOW( );
        NRF24L01_Write_Buf( WR_TX_PLOAD, txbuf, Length );        //写数据到TX BUF 32字节  TX_PLOAD_WIDTH
        RF24L01_SET_CE_HIGH( );                        //启动发送
        while( 0 != RF24L01_GET_IRQ_STATUS( ))
        {
                delay_ms( 5 );
//        printf("error-1\r\n");
                if( 500 == l_MsTimes++ )                                                //500ms还没有发送成功，重新初始化设备
                {
                        if(RECEIVING_MODE == 1) //如果为接收模式
                        {
                                NRF24L01_Gpio_Init_receive( );
                        }
                        else                                         //否则
                        {
                                NRF24L01_Gpio_Init_transmit( );
                        }
                        RF24L01_Init( );
                        RF24L01_Set_Mode( MODE_TX );
                        break;
                }
        }
        l_Status = NRF24L01_Read_Reg(STATUS);                                                //读状态寄存器
        NRF24L01_Write_Reg( STATUS, l_Status );                                                //清除TX_DS或MAX_RT中断标志

        if( l_Status & MAX_TX )        //达到最大重发次数
        {
                NRF24L01_Write_Reg( FLUSH_TX,0xff );        //清除TX FIFO寄存器
                return MAX_TX;
        }
        if( l_Status & TX_OK )        //发送完成
        {
                return TX_OK;
        }

        return 0xFF;        //其他原因发送失败
}


void key_gpio_config(void)
{
        /* 开启时钟 */
        rcu_periph_clock_enable(RF24L01_IRQ_GPIO_CLK);
        rcu_periph_clock_enable(RCU_SYSCFG);    // 系统配置时钟

        /* 配置为输入模式 下拉模式 */
        gpio_mode_set(RF24L01_IRQ_GPIO_PORT,GPIO_MODE_INPUT,GPIO_PUPD_NONE,RF24L01_IRQ_GPIO_PIN);  // 按键默认状态是低电平，配置为下拉

        /* 使能NVIC中断 中断分组为2位抢占优先级，2位子优先级 */
        nvic_irq_enable(BSP_KEY_EXTI_IRQN,2U,2U);  // 抢占优先级3，子优先级3
        /* 连接中断线到GPIO */
        syscfg_exti_line_config(BSP_KEY_EXTI_PORT_SOURCE,BSP_KEY_EXTI_PIN_SOURCE);
        /* 初始化中断线 */
        exti_init(BSP_KEY_EXTI_LINE,EXTI_INTERRUPT,EXTI_TRIG_BOTH);//x沿触发

        /* 使能中断 */
        exti_interrupt_enable(BSP_KEY_EXTI_LINE);
        /* 清除中断标志位 */
        exti_interrupt_flag_clear(BSP_KEY_EXTI_LINE);
}

 /**
  * @brief :RF24L01引脚初始化
  * @param :无
  * @note  :无
  * @retval:无
  */
void NRF24L01_Gpio_Init_receive( void )
{
        rcu_periph_clock_enable(RF24L01_CE_GPIO_CLK);
        rcu_periph_clock_enable(RF24L01_IRQ_GPIO_CLK);

        //CE推挽输出
        gpio_mode_set(RF24L01_CE_GPIO_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE,RF24L01_CE_GPIO_PIN);
    gpio_output_options_set(RF24L01_CE_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ,RF24L01_CE_GPIO_PIN);
        gpio_bit_set(RF24L01_CE_GPIO_PORT,RF24L01_CE_GPIO_PIN);

////        IRQ上拉输入
//        gpio_mode_set(RF24L01_IRQ_GPIO_PORT, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP,RF24L01_IRQ_GPIO_PIN);
//    gpio_output_options_set(RF24L01_IRQ_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ,RF24L01_IRQ_GPIO_PIN);
//    gpio_bit_set(RF24L01_IRQ_GPIO_PORT,RF24L01_IRQ_GPIO_PIN);
    //IRQ外部中断方式
        key_gpio_config();

        RF24L01_SET_CE_LOW( );
        RF24L01_SET_CS_HIGH( );
}

/************************************************
函数名称 ： BSP_KEY_EXTI_IRQHandler
功    能 ： 中断处理函数
参    数 ： 无
返 回 值 ： 无
作    者 ： LCEDA
*************************************************/
extern uint8_t g_RF24L01RxBuffer[];

void BSP_KEY_EXTI_IRQHANDLER(void)
{
  if(exti_interrupt_flag_get(BSP_KEY_EXTI_LINE) == SET)   // 中断标志位为1，按键按下
  {
                if(gpio_input_bit_get(RF24L01_IRQ_GPIO_PORT,RF24L01_IRQ_GPIO_PIN) == RESET)  // IRQ为低电平
                {
            NRF24L01_RxPacket(g_RF24L01RxBuffer);  //接收数据
            printf("data = %s",g_RF24L01RxBuffer );//输出数据

            RF24L01_SET_CS_LOW( );                //片选
            drv_spi_read_write_byte( FLUSH_RX );//清除RX FIFO寄存器
            RF24L01_SET_CS_HIGH( );
                }
        else// IRQ为高电平
        {

                }
          exti_interrupt_flag_clear(BSP_KEY_EXTI_LINE);            // 清中断标志位
        }
}

/**
  * @brief :NRF24L01接收数据
  * @param :
  *                        @rxbuf:接收数据存放地址
  * @note  :无
  * @retval:接收的数据个数
  */
uint8_t NRF24L01_RxPacket( uint8_t *rxbuf )
{
        uint8_t l_Status = 0, l_RxLength = 0;

        l_Status = NRF24L01_Read_Reg( STATUS );                //读状态寄存器
        NRF24L01_Write_Reg( STATUS,l_Status );                //清中断标志
        if( l_Status & RX_OK)        //接收到数据
        {
                l_RxLength = NRF24L01_Read_Reg( R_RX_PL_WID );                //读取接收到的数据个数
                NRF24L01_Read_Buf( RD_RX_PLOAD,rxbuf,l_RxLength );        //接收到数据
                NRF24L01_Write_Reg( FLUSH_RX,0xff );                                //清除RX FIFO
                return l_RxLength;
        }
        return 0;                                //没有收到数据
}

 /**
  * @brief :RF24L01引脚初始化
  * @param :无
  * @note  :无
  * @retval:无
  */
void NRF24L01_Gpio_Init_transmit( void )
{
        rcu_periph_clock_enable(RF24L01_CE_GPIO_CLK);
        rcu_periph_clock_enable(RF24L01_IRQ_GPIO_CLK);

        //CE推挽输出
        gpio_mode_set(RF24L01_CE_GPIO_PORT, GPIO_MODE_OUTPUT, GPIO_PUPD_NONE,RF24L01_CE_GPIO_PIN);
    gpio_output_options_set(RF24L01_CE_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ,RF24L01_CE_GPIO_PIN);
        gpio_bit_set(RF24L01_CE_GPIO_PORT,RF24L01_CE_GPIO_PIN);

        //IRQ上拉输入
        gpio_mode_set(RF24L01_IRQ_GPIO_PORT, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP,RF24L01_IRQ_GPIO_PIN);
    gpio_output_options_set(RF24L01_IRQ_GPIO_PORT, GPIO_OTYPE_PP, GPIO_OSPEED_50MHZ,RF24L01_IRQ_GPIO_PIN);
    gpio_bit_set(RF24L01_IRQ_GPIO_PORT,RF24L01_IRQ_GPIO_PIN);


        RF24L01_SET_CE_LOW( );
        RF24L01_SET_CS_HIGH( );
}


 /**
  * @brief :RF24L01模块初始化
  * @param :无
  * @note  :无
  * @retval:无
  */
void RF24L01_Init( void )
{
    uint8_t addr[] = {INIT_ADDR};

    RF24L01_SET_CE_HIGH( );
    NRF24L01_Clear_IRQ_Flag( IRQ_ALL );
#if DYNAMIC_PACKET == 1

    NRF24L01_Write_Reg( DYNPD, ( 1 << 0 ) );         //使能通道1动态数据长度
    NRF24L01_Write_Reg( FEATRUE, 0x07 );
    NRF24L01_Read_Reg( DYNPD );
    NRF24L01_Read_Reg( FEATRUE );

#elif DYNAMIC_PACKET == 0

    L01_WriteSingleReg( L01REG_RX_PW_P0, FIXED_PACKET_LEN );        //固定数据长度

#endif        //DYNAMIC_PACKET

    NRF24L01_Write_Reg( CONFIG,     /*( 1<<MASK_RX_DR ) |*/                //接收中断*/
                                      ( 1 << EN_CRC ) |     //使能CRC 1个字节
                                      ( 1 << PWR_UP ) );    //开启设备
    NRF24L01_Write_Reg( EN_AA, ( 1 << ENAA_P0 ) );                   //通道0自动应答
    NRF24L01_Write_Reg( EN_RXADDR, ( 1 << ERX_P0 ) );                //通道0接收
    NRF24L01_Write_Reg( SETUP_AW, AW_5BYTES );                             //地址宽度 5个字节
    NRF24L01_Write_Reg( SETUP_RETR, ARD_4000US |
                        ( REPEAT_CNT & 0x0F ) );                 //重复等待时间 250us
    NRF24L01_Write_Reg( RF_CH, 00 );                                     //初始化通道
    NRF24L01_Write_Reg( RF_SETUP, 0x26 );

    NRF24L01_Set_TxAddr( &addr[], 5 );                      //设置TX地址
    NRF24L01_Set_RxAddr( 0, &addr[], 5 );                   //设置RX地址
}

在NRF24L01.h中，修改为如下代码。

#ifndef __NRF24L01_H__
#define __NRF24L01_H__


#include "drv_spi.h"


/** 配置和选项定义 */
#define DYNAMIC_PACKET      1                 //1:动态数据包, 0:固定
#define FIXED_PACKET_LEN    32                //包长度
#define REPEAT_CNT          15                //重复次数
#define INIT_ADDR           0x34,0x43,0x10,0x10,0x01


/** RF24L01硬件接口定义 */
#define RF24L01_CE_GPIO_PORT                      GPIOB
#define RF24L01_CE_GPIO_CLK                       RCU_GPIOB
#define RF24L01_CE_GPIO_PIN                       GPIO_PIN_8

#define RF24L01_IRQ_GPIO_PORT                       GPIOA
#define RF24L01_IRQ_GPIO_CLK                        RCU_GPIOA
#define RF24L01_IRQ_GPIO_PIN                        GPIO_PIN_2

#define RF24L01_CS_GPIO_PORT                        SPI_NSS_GPIO_PORT
#define RF24L01_CS_GPIO_CLK                         SPI_NSS_GPIO_CLK
#define RF24L01_CS_GPIO_PIN                         SPI_NSS_GPIO_PIN


#define BSP_KEY_EXTI_IRQN                        EXTI2_IRQn          // 外部中断4
#define BSP_KEY_EXTI_PORT_SOURCE                 EXTI_SOURCE_GPIOA   // 外部中断端口资源
#define BSP_KEY_EXTI_PIN_SOURCE                  EXTI_SOURCE_PIN2    // 外部中断引脚资源
#define BSP_KEY_EXTI_LINE                        EXTI_2              // 外部中断
#define BSP_KEY_EXTI_IRQHANDLER                  EXTI2_IRQHandler    // 外部中断函数名



/** 口线操作函数定义 */

#define RF24L01_SET_CE_HIGH( )                        gpio_bit_write(RF24L01_CE_GPIO_PORT,        RF24L01_CE_GPIO_PIN, SET)
#define RF24L01_SET_CE_LOW( )                        gpio_bit_write(RF24L01_CE_GPIO_PORT,        RF24L01_CE_GPIO_PIN, RESET)

#define RF24L01_SET_CS_HIGH( )                        spi_set_nss_high( )
#define RF24L01_SET_CS_LOW( )                        spi_set_nss_low( )

#define RF24L01_GET_IRQ_STATUS( )                (gpio_input_bit_get(RF24L01_IRQ_GPIO_PORT, RF24L01_IRQ_GPIO_PIN) != SET) ? 0 : 1        //IRQ状态


typedef enum ModeType
{
        MODE_TX = 0,
        MODE_RX
}nRf24l01ModeType;

typedef enum SpeedType
{
        SPEED_250K = 0,
        SPEED_1M,
        SPEED_2M
}nRf24l01SpeedType;

typedef enum PowerType
{
        POWER_F18DBM = 0,
        POWER_F12DBM,
        POWER_F6DBM,
        POWER_0DBM
}nRf24l01PowerType;


/** NRF24L01定义 */
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//寄存器操作命令
#define NRF_READ_REG    0x00        //读配置寄存器，低5位为寄存器地址
#define NRF_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 R_RX_PL_WID     0x60
#define NOP             0xFF        //空操作，可以用来读状态寄存器
#define W_ACK_PLOAD                0xA8
#define WR_TX_PLOAD_NACK 0xB0
//SPI(NRF24L01)寄存器地址
#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        //设置地址宽度(所有数据通道) bit0~1: 00,3字节 01,4字节, 02,5字节
#define SETUP_RETR      0x04        //建立自动重发;bit0~3:自动重发计数器;bit4~7:自动重发延时 250*x+86us
#define RF_CH           0x05        //RF通道,bit0~6工作通道频率
#define RF_SETUP        0x06        //RF寄存器，bit3:传输速率( 0:1M 1:2M);bit1~2:发射功率;bit0:噪声放大器增益
#define STATUS          0x07        //状态寄存器;bit0:TX FIFO满标志;bit1~3:接收数据通道号(最大: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[]相等
#define RX_ADDR_P3      0x0D        //数据通道3接收地址，最低字节可设置，高字节，必须同RX_ADDR_P1[]相等
#define RX_ADDR_P4      0x0E        //数据通道4接收地址，最低字节可设置，高字节，必须同RX_ADDR_P1[]相等
#define RX_ADDR_P5      0x0F        //数据通道5接收地址，最低字节可设置，高字节，必须同RX_ADDR_P1[]相等
#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 NRF_FIFO_STATUS 0x17        //FIFO状态寄存器;bit0:RX FIFO寄存器空标志;bit1:RX FIFO满标志;bit2~3保留
                                                                //bit4:TX FIFO 空标志;bit5:TX FIFO满标志;bit6:1,循环发送上一数据包.0,不循环
#define DYNPD                        0x1C
#define FEATRUE                        0x1D
//////////////////////////////////////////////////////////////////////////////////////////////////////////

//位定义
#define MASK_RX_DR           6
#define MASK_TX_DS           5
#define MASK_MAX_RT          4
#define EN_CRC               3
#define CRCO                 2
#define PWR_UP               1
#define PRIM_RX              0

#define ENAA_P5              5
#define ENAA_P4              4
#define ENAA_P3              3
#define ENAA_P2              2
#define ENAA_P1              1
#define ENAA_P0              0

#define ERX_P5               5
#define ERX_P4               4
#define ERX_P3               3
#define ERX_P2              2
#define ERX_P1               1
#define ERX_P0               0

#define AW_RERSERVED         0x0
#define AW_3BYTES            0x1
#define AW_4BYTES            0x2
#define AW_5BYTES            0x3

#define ARD_250US            (0x00<<4)
#define ARD_500US            (0x01<<4)
#define ARD_750US            (0x02<<4)
#define ARD_1000US           (0x03<<4)
#define ARD_2000US           (0x07<<4)
#define ARD_4000US           (0x0F<<4)
#define ARC_DISABLE           0x00
#define ARC_15                0x0F

#define CONT_WAVE             7
#define RF_DR_LOW             5
#define PLL_LOCK              4
#define RF_DR_HIGH            3
//bit2-bit1:
#define PWR_18DB                  (0x00<<1)
#define PWR_12DB                  (0x01<<1)
#define PWR_6DB                   (0x02<<1)
#define PWR_0DB                   (0x03<<1)

#define RX_DR                 6
#define TX_DS                 5
#define MAX_RT                4
//for bit3-bit1,
#define TX_FULL_0             0

#define RPD                   0

#define TX_REUSE              6
#define TX_FULL_1             5
#define TX_EMPTY              4
//bit3-bit2, reserved, only '00'
#define RX_FULL               1
#define RX_EMPTY              0

#define DPL_P5                5
#define DPL_P4                4
#define DPL_P3                3
#define DPL_P2                2
#define DPL_P1                1
#define DPL_P0                0

#define EN_DPL                2
#define EN_ACK_PAY            1
#define EN_DYN_ACK            0
#define IRQ_ALL  ( (1<<RX_DR) | (1<<TX_DS) | (1<<MAX_RT) )



uint8_t NRF24L01_Read_Reg( uint8_t RegAddr );
void NRF24L01_Read_Buf( uint8_t RegAddr, uint8_t *pBuf, uint8_t len );
void NRF24L01_Write_Reg( uint8_t RegAddr, uint8_t Value );
void NRF24L01_Write_Buf( uint8_t RegAddr, uint8_t *pBuf, uint8_t len );
void NRF24L01_Flush_Tx_Fifo ( void );
void NRF24L01_Flush_Rx_Fifo( void );
void NRF24L01_Reuse_Tx_Payload( void );
void NRF24L01_Nop( void );
uint8_t NRF24L01_Read_Status_Register( void );
uint8_t NRF24L01_Clear_IRQ_Flag( uint8_t IRQ_Source );
uint8_t RF24L01_Read_IRQ_Status( void );
uint8_t NRF24L01_Read_Top_Fifo_Width( void );
uint8_t NRF24L01_Read_Rx_Payload( uint8_t *pRxBuf );
void NRF24L01_Write_Tx_Payload_Ack( uint8_t *pTxBuf, uint8_t len );
void NRF24L01_Write_Tx_Payload_NoAck( uint8_t *pTxBuf, uint8_t len );
void NRF24L01_Write_Tx_Payload_InAck( uint8_t *pData, uint8_t len );
void NRF24L01_Set_TxAddr( uint8_t *pAddr, uint8_t len );
void NRF24L01_Set_RxAddr( uint8_t PipeNum, uint8_t *pAddr, uint8_t Len );
void NRF24L01_Set_Speed( nRf24l01SpeedType Speed );
void NRF24L01_Set_Power( nRf24l01PowerType Power );
void RF24LL01_Write_Hopping_Point( uint8_t FreqPoint );
void RF24L01_Set_Mode( nRf24l01ModeType Mode );
void  NRF24L01_check( void );
uint8_t NRF24L01_TxPacket( uint8_t *txbuf, uint8_t Length );
uint8_t NRF24L01_RxPacket( uint8_t *rxbuf );
void NRF24L01_Gpio_Init_transmit( void );
void NRF24L01_Gpio_Init_receive( void );
void RF24L01_Init( void );

void Rocker_Mode(void);
char Get_NRF24L01_ConnectFlag(void);

#endif

移植验证

将发送端代码烧入开发板，接收端代码烧入另一个开发板。 main.c代码如下：

/*
 * 立创开发板软硬件资料与相关扩展板软硬件资料官网全部开源
 * 开发板官网：www.lckfb.com
 * 技术支持常驻论坛，任何技术问题欢迎随时交流学习
 * 立创论坛：club.szlcsc.com
 * 关注bilibili账号：【立创开发板】，掌握我们的最新动态！
 * 不靠卖板赚钱，以培养中国工程师为己任
 * Change Logs:
 * Date           Author       Notes
 * 2023-11-02     LCKFB-yzh    first version
 */
#include "board.h"
#include "NRF24L01.h"
#include "drv_spi.h"
#include "stdio.h"
extern unsigned int RECEIVING_MODE;

uint8_t g_RF24L01RxBuffer[];

int main(void)
{
    board_init();
        usart_gpio_config(115200U);
        printf("start\r\n");

        //SPI初始化
        drv_spi_init( );

        //RF24L01引脚初始化
        if(RECEIVING_MODE == 1) //如果为接收模式
        {
                NRF24L01_Gpio_Init_receive( );
        }
        else                                         //否则
        {
                NRF24L01_Gpio_Init_transmit( );
        }

        //检测nRF24L01
        NRF24L01_check( );

        //NRF初始化
        RF24L01_Init( );


        if(RECEIVING_MODE == 1) //如果为接收模式
        {
                RF24L01_Set_Mode( MODE_RX );//NRF接收模式        .
                printf("MODE_RX\r\n");
        }
        else                                         //否则
        {
                RF24L01_Set_Mode( MODE_TX );//NRF发送模式        .
                printf("MODE_TX\r\n");
        }

    while (1)
    {
                if(RECEIVING_MODE == 1) //如果为接收模式
                {

                }
                else                                         //否则
                {
                        NRF24L01_TxPacket((uint8_t*)"hello LCEDA\r\n",13);//NRF发送数据
                        printf("send\r\n");
                        delay_ms(100);
                }
    }
}

移植成功案例：

代码下载

链接在资料下载章节的模块移植手册资料那里！！