NRF24L01无线2.4G控制模块

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

模块来源

采购链接：
https://item.taobao.com/item.htm?spm=a1z09.2.0.0.2f042e8dSu55YD&id=609297351472&_u=j2t4uge5fa1d
资料下载链接：
https://pan.baidu.com/s/1CUQ3SOdnmD8xSXMdR4YopA
资料提取码：1234

规格参数

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

查看资料

接收方式

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

轮询方式接收

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

中断方式接收

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

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

移植过程

引脚选择

移植至工程

我们的目标是将例程移植至ESP32-S3开发板上。已经为大家提供了完整的驱动代码，按照以下步骤，即可完成移植。

具体新建文件夹和新建c和h文件在 【DHT11温湿度传感器】章节中的1.4.2小节中有详细的教学，这里就不再多说了。

只不过这里我们将文件名 bsp_dht11.c 和 bsp_dht11.h 换成 NRF24L01.c 和 NRF24L01.h，文件夹名字改为NRF24L01。
我们多两个步骤，再创建一个文件夹：SPI文件夹中新建两个文件：drv_spi.h 和 drv_spi.c

main 文件夹中 新建一个文件：main.h

在main文件中的 CMakeLists.txt 文件中写入：

代码写入

在文件main.h中，编写如下代码。

将 RECEIVING_MODE 设定 1 或者 0，来切换接收端和发送端。

#ifndef __MAIN_H__
#define __MAIN_H__

// 如使用硬件SPI则将宏 __USE_SOFT_SPI_INTERFACE__  注释；如果使用软件SPI则需要定义改宏。
#define __USE_SOFT_SPI_INTERFACE__

#define RECEIVING_MODE 1  //是否使用接收模式  1使用接收模式       0使用发送模式

#endif

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

#include "drv_spi.h"
#include "stdlib.h"
#include "string.h"

void delay_ms(unsigned int ms)
{
    vTaskDelay(ms / portTICK_PERIOD_MS);
}
void delay_us(unsigned int us)
{
    ets_delay_us(us);
}
void delay_1ms(unsigned int ms)
{
    vTaskDelay(ms / portTICK_PERIOD_MS);
}
void delay_1us(unsigned int us)
{
    ets_delay_us(us);
}

#ifndef __USE_SOFT_SPI_INTERFACE__

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

spi_device_handle_t spi2_handle;

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

    spi_bus_config_t buscfg={
        .miso_io_num=SPI_MISO_GPIO_PIN,
        .mosi_io_num=SPI_MOSI_GPIO_PIN,
        .sclk_io_num=SPI_CLK_GPIO_PIN,
        .quadwp_io_num=-1,
        .quadhd_io_num=-1,
        .max_transfer_sz= 512 //最大传输大小
    };
    spi_device_interface_config_t devcfg={

        .clock_speed_hz=80*1000*1000,           //Clock out at 80 MHz
        .mode=3,                                //SPI mode 3
        .spics_io_num=-1,                       //CS pin
        .queue_size=7,                          //事务队列尺寸 7个
        .pre_cb=NULL,                   // 数据传输前回调，用作D/C（数据命令）线分别处理
    };
  // 初始化SPI总线
    ret=spi_bus_initialize(SPI2_HOST, &buscfg, SPI_DMA_CH_AUTO);
    ESP_ERROR_CHECK(ret);

  // 添加SPI总线驱动
    ret=spi_bus_add_device(SPI2_HOST, &devcfg, &spi2_handle);
    ESP_ERROR_CHECK(ret);
}

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

        uint8_t data = 0;
        esp_err_t ret;
        spi_transaction_t t={0};
        t.length=1*8;                   // 数据长度 Len 是字节数，len, transaction length is in bits.
        t.tx_buffer=&TxByte;            // 写入数据指针
        t.rx_buffer=&data;              // 读取数据存放
        t.user=(void*)1;                // 设置D/C 线，在SPI传输前回调中根据此值处理DC信号线
        ret=spi_device_polling_transmit(spi2_handle, &t);    // 开始传输
        assert(ret==ESP_OK);            // 一般不会有问题

        // spi_set_nss_high();

        return 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( );//拉高片选
}

/** 硬件SPI */
#endif

#ifdef __USE_SOFT_SPI_INTERFACE__

/** 软件SPI */

/**
  * @brief :SPI初始化(软件)
  * @param :无
  * @note  :无
  * @retval:无
  */
void drv_spi_init( void )
{
    gpio_config_t out_config = {
        .pin_bit_mask = (1ULL<<SPI_CLK_GPIO_PIN)|(1ULL<<SPI_MOSI_GPIO_PIN)|(1ULL<<SPI_NSS_GPIO_PIN),    //配置引脚
        .mode =GPIO_MODE_OUTPUT,                  //输出模式
        .pull_up_en = GPIO_PULLUP_DISABLE,        //不使能上拉
        .pull_down_en = GPIO_PULLDOWN_DISABLE,    //不使能下拉
        .intr_type = GPIO_INTR_DISABLE            //不使能引脚中断
        };
    gpio_config(&out_config);

    gpio_config_t in_config = {
        .pin_bit_mask = (1ULL<<SPI_MISO_GPIO_PIN),          //配置引脚
        .mode =GPIO_MODE_INPUT,                   //输出模式
        .pull_up_en = GPIO_PULLUP_ENABLE,         //使能上拉
        .pull_down_en = GPIO_PULLDOWN_DISABLE,    //不使能下拉
        .intr_type = GPIO_INTR_DISABLE            //不使能引脚中断
        };
    gpio_config(&in_config);

}

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

        spi_set_clk_low( );

        for( i = 0; i < 8; i++ )                        //一个字节8byte需要循环8次
        {
                /** 发送 */
                if( 0x80 == ( TxByte & 0x80 ))
                {
                        spi_set_mosi_hight( );                //如果即将要发送的位为 1 则置高IO引脚
                }
                else
                {
                        spi_set_mosi_low( );                //如果即将要发送的位为 0 则置低IO引脚
                }
                TxByte <<= 1;                                        //数据左移一位，先发送的是最高位

                spi_set_clk_high( );                        //时钟线置高
                delay_us(2);

                /** 接收 */
                Data <<= 1;                                                //接收数据左移一位，先接收到的是最高位
                if( 1 == spi_get_miso( ))
                {
                        Data |= 0x01;                                //如果接收时IO引脚为高则认为接收到 1
                }

                spi_set_clk_low( );                                //时钟线置低
                delay_us(2);
        }

        return 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( );                //片选拉高
}

/** 软件SPI */
#endif

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

#ifndef __DRV_SPI_H__
#define __DRV_SPI_H__

#include "driver/i2c.h"
#include "sdkconfig.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "freertos/queue.h"
#include <inttypes.h>
#include "sdkconfig.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "rom/ets_sys.h"
#include "esp_system.h"
#include "driver/gpio.h"
#include "driver/spi_master.h"
#include "driver/spi_common.h"
#include "hal/gpio_types.h"
#include "../main.h"

//SPI引脚定义
#define SPI_CLK_GPIO_PIN          4
#define SPI_MISO_GPIO_PIN         2
#define SPI_MOSI_GPIO_PIN         3
#define SPI_NSS_GPIO_PIN          5

#define spi_set_nss_high( )          gpio_set_level(SPI_NSS_GPIO_PIN, 1)    //片选置高
#define spi_set_nss_low( )           gpio_set_level(SPI_NSS_GPIO_PIN, 0)    //片选置低

#ifdef __USE_SOFT_SPI_INTERFACE__ /** 只有使用软件SPI才需要的封装 */

#define spi_set_clk_high( )              gpio_set_level(SPI_CLK_GPIO_PIN, 1)      //时钟置高
#define spi_set_clk_low( )               gpio_set_level(SPI_CLK_GPIO_PIN, 0)      //时钟置低

#define spi_set_mosi_hight( )            gpio_set_level(SPI_MOSI_GPIO_PIN, 1)                                                                //发送脚置高
#define spi_set_mosi_low( )              gpio_set_level(SPI_MOSI_GPIO_PIN, 0)    //发送脚置低

#define spi_get_miso( )                  (gpio_get_level(SPI_MISO_GPIO_PIN) != 1) ? 0 : 1 // 若相应输入位为低则得到0，相应输入位为高则得到1

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 );
void delay_us(unsigned int us);
void delay_ms(unsigned int ms);
void delay_1us(unsigned int us);
void delay_1ms(unsigned int ms);

#else   /** 只有使用硬件SPI时会使用 */

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 );
void delay_us(unsigned int us);
void delay_ms(unsigned int ms);
void delay_1us(unsigned int us);
void delay_1ms(unsigned int ms);

#endif

#endif

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

#include "NRF24L01.h"
#include "stdio.h"

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


void drv_delay_500Ms( unsigned int ms)
{
    while(ms--)
    {
        delay_1ms(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[5]={ 0XA5, 0XA5, 0XA5, 0XA5, 0XA5 };
        uint8_t read_buf[ 5 ] = { 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[ i ] != read_buf[ i ] )
                        {
                                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还没有发送成功，重新初始化设备
                {
                        NRF24L01_Gpio_Init( );
                        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;        //其他原因发送失败
}

#if  RECEIVING_MODE   //接收模式时

/**********************************************************
 * 函 数 名 称：IRQ_gpio_config
 * 函 数 功 能：对NRF24L01模块的IRQ引脚配置为外部中断，上升与下降沿触发。
 * 传 入 参 数：无
 * 函 数 返 回：无
 * 作       者：LC
 * 备       注：无
**********************************************************/

static QueueHandle_t gpio_evt_queue = NULL;

void IRQ_gpio_config(void)
{
    gpio_config_t io_conf = {};
    //下降沿中断
    io_conf.intr_type = GPIO_INTR_NEGEDGE;
    //设置GPIO0的输入寄存器
    io_conf.pin_bit_mask = RF24L01_IRQ_GPIO_PIN;
    //输入模式
    io_conf.mode = GPIO_MODE_INPUT;
    //使能上拉模式
    io_conf.pull_up_en = 1;
    io_conf.pull_down_en = 0;
    gpio_config(&io_conf);

    //创建一个队列来处理来自isr的gpio事件
     gpio_evt_queue = xQueueCreate(10, sizeof(uint32_t));

    //注册中断服务
    gpio_install_isr_service(ESP_INTR_FLAG_EDGE);

    //设置GPIO的中断服务函数
    gpio_isr_handler_add(RF24L01_IRQ_GPIO_PIN, BSP_IRQ_EXTI_IRQHANDLER, (void*) RF24L01_IRQ_GPIO_PIN);

    //使能GPIO模块中断信号
    gpio_intr_enable(RF24L01_IRQ_GPIO_PIN);

    //创建一个按键检测任务
    xTaskCreate(gpio_get_irq_task,        //任务函数
                "gpio_get_irq_task",      //任务名字
                2048,                           //任务堆栈
                NULL,                           //传递给任务函数的参数
                10,                             //任务优先级
                NULL                            //任务句柄
     );
}

 /**
  * @brief :RF24L01引脚初始化
  * @param :无
  * @note  :无
  * @retval:无
  */
void NRF24L01_Gpio_Init( void )
{
    gpio_config_t out_config = {
        .pin_bit_mask = (1ULL<<RF24L01_CE_GPIO_PIN),    //配置引脚
        .mode =GPIO_MODE_OUTPUT,                        //输出模式
        .pull_up_en = GPIO_PULLUP_DISABLE,              //不使能上拉
        .pull_down_en = GPIO_PULLDOWN_DISABLE,          //不使能下拉
        .intr_type = GPIO_INTR_DISABLE                  //不使能引脚中断
        };
    gpio_config(&out_config);

    gpio_config_t in_config = {
        .pin_bit_mask = (1ULL<<RF24L01_IRQ_GPIO_PIN),          //配置引脚
        .mode =GPIO_MODE_INPUT,                   //输出模式
        .pull_up_en = GPIO_PULLUP_ENABLE,         //使能上拉
        .pull_down_en = GPIO_PULLDOWN_DISABLE,    //不使能下拉
        .intr_type = GPIO_INTR_DISABLE            //不使能引脚中断
        };
    gpio_config(&in_config);

    //IRQ外部中断方式
        IRQ_gpio_config();

        RF24L01_SET_CE_LOW( );
        RF24L01_SET_CS_HIGH( );
}

//接收数据缓存，最大接收250个字符（根据自己的情况进行调整
uint8_t g_RF24L01RxBuffer[250];
/**********************************************************
 * 函 数 名 称：BSP_IRQ_EXTI_IRQHANDLER
 * 函 数 功 能：中断处理函数
 * 传 入 参 数：无
 * 函 数 返 回：无
 * 作       者：LC
 * 备       注：无
**********************************************************/
void IRAM_ATTR BSP_IRQ_EXTI_IRQHANDLER(void* arg)
{

    uint32_t gpio_num = (uint32_t) arg;
    xQueueSendFromISR(gpio_evt_queue, &gpio_num, NULL);

}

//检测任务
void gpio_get_irq_task(void)
{
    uint32_t io_num;
    while(1)
    {
        //读取最新的gpio_evt_queue消息
        if(RF24L01_GET_IRQ_STATUS())
        {
            NRF24L01_RxPacket(g_RF24L01RxBuffer);  //接收数据
            //测试是否接收的数据是否与发送的数据一致
            // printf("data = %s",g_RF24L01RxBuffer );//输出数据
        }
        delay_ms(50);
    }
}

/**
  * @brief :NRF24L01接收数据
  * @param :
  *                        @rxbuf:接收数据存放地址
  * @note  :无
  * @retval:接收的数据个数
  */
uint8_t NRF24L01_RxPacket( uint8_t *rxbuf )
{
        uint8_t l_Status = 0, l_RxLength = 0, l_100MsTimes = 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;                                //没有收到数据
}
#else   //发送模式

 /**
  * @brief :RF24L01引脚初始化
  * @param :无
  * @note  :无
  * @retval:无
  */
void NRF24L01_Gpio_Init( void )
{
    gpio_config_t out_config = {
        .pin_bit_mask = (1ULL<<RF24L01_CE_GPIO_PIN),    //配置引脚
        .mode =GPIO_MODE_OUTPUT,                  //输出模式
        .pull_up_en = GPIO_PULLUP_DISABLE,        //不使能上拉
        .pull_down_en = GPIO_PULLDOWN_DISABLE,    //不使能下拉
        .intr_type = GPIO_INTR_DISABLE            //不使能引脚中断
        };
    gpio_config(&out_config);

    gpio_config_t in_config = {
        .pin_bit_mask = (1ULL<<RF24L01_IRQ_GPIO_PIN),          //配置引脚
        .mode =GPIO_MODE_INPUT,                   //输出模式
        .pull_up_en = GPIO_PULLUP_ENABLE,         //使能上拉
        .pull_down_en = GPIO_PULLDOWN_DISABLE,    //不使能下拉
        .intr_type = GPIO_INTR_DISABLE            //不使能引脚中断
        };
    gpio_config(&in_config);

        RF24L01_SET_CE_LOW( );
        RF24L01_SET_CS_HIGH( );
}
#endif

 /**
  * @brief :RF24L01模块初始化
  * @param :无
  * @note  :无
  * @retval:无
  */
void RF24L01_Init( void )
{
    uint8_t addr[5] = {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[0], 5 );                      //设置TX地址
    NRF24L01_Set_RxAddr( 0, &addr[0], 5 );                   //设置RX地址
}

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

#ifndef __NRF24L01_H__
#define __NRF24L01_H__

#include "drv_spi.h"
#include "../main.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_PIN          6
#define RF24L01_IRQ_GPIO_PIN         1
#define RF24L01_CS_GPIO_PIN          5

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

#define RF24L01_SET_CE_HIGH( )         gpio_set_level(RF24L01_CE_GPIO_PIN, 1)
#define RF24L01_SET_CE_LOW( )          gpio_set_level(RF24L01_CE_GPIO_PIN, 0)

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

#define RF24L01_GET_IRQ_STATUS( )      (gpio_get_level(RF24L01_IRQ_GPIO_PIN) != 1) ? 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( void );
void RF24L01_Init( void );

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

void IRAM_ATTR BSP_IRQ_EXTI_IRQHANDLER(void* arg);
void gpio_get_irq_task(void);

#endif

移植验证

在main.c 文件中写入：

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

void app_main(void)
{
    uint8_t g_RF24L01RxBuffer[30];
    uint8_t NRF_FLAG = 0;

    float t=0;

    printf("Start......\r\n");

    //SPI初始化
    drv_spi_init( );

    //RF24L01引脚初始化
    NRF24L01_Gpio_Init( );

    //检测nRF24L01
    NRF24L01_check( );

    //NRF接收模式初始化
    RF24L01_Init( );

    #if RECEIVING_MODE

    RF24L01_Set_Mode( MODE_RX );//NRF接收模式   .
    printf("MODE_RX\r\n");

    #else

    RF24L01_Set_Mode( MODE_TX );//NRF发送模式
    printf("MODE_TX\r\n");

    #endif

    while(1)
    {

        #if RECEIVING_MODE//NRF接收模式 .

        NRF_FLAG = NRF24L01_RxPacket( g_RF24L01RxBuffer );      //接收nrf发送过来的字节
        if( NRF_FLAG > 5 )//有数据
        {
            printf("data = %s\r\n",g_RF24L01RxBuffer );//输出数据
            NRF_FLAG = 0;
        }

        #else   //NRF发送模式

        NRF24L01_TxPacket((uint8_t*)"hello LCEDA\r\n",13);//NRF发送数据
        printf("send\r\n");
        delay_1ms(1000);

        #endif

        delay_ms(50);
    }
}

将发送端代码烧入开发板，接收端代码烧入另一个开发板。

驱动代码：

文件下载

📌 资料下载中心（点击跳转）

📌 在 资料下载中心->模块移植资料下载 里面的该章节压缩包中。