调试备忘录-nRF24L01P的使用（教程 + 源码）
目录--点击可快速直达
MCU:KEAZ64A
MDK:CodeWarrior 11.0
写在前面
因为最近在重写之前项目的代码，以提升系统的稳定性和代码的可读性，所以重新选择了一块nRF24L01P,进行调试。
以下算是一些调试的备忘录吧,如有问题可以通过私信或者邮箱联系我。
什么是nRF24L01P？
nRF24L01P是一颗工作在 2.4GHz ISM 频段，专为低功耗无线场合设计，集成嵌入式 ARQ基带协议引擎的无线收发器芯片。
工作频率范围为 2400MHz-2525MHz，共有 126 个 1MHz带宽的信道。
简单来说，就是一块基于民用频段的无线通信芯片，可以用于无线鼠标、无线键盘、遥控器、工业传感器等应用。
后面我要使用的模块是在某宝上买的泽耀的nRF24L01P无线通信模块，以下的一些图片也是截取自它家的产品资料。
nRF24L01P模块的简单介绍
nRF24L01P模块一共有八个引脚，其中4个SPI引脚，一共工作模式切换引脚和一个终端引脚。
推荐与MCU的连接图
nRF24L01P的工作模式
nRF24L01P使用SPI进行通讯，可以通过SPI设置nRF24L01P的寄存器来改变nRF24L01P的工作模式。
如图所示，nRF24L01P的工作模式有如上几种，我们主要使用的就是接收模式、发射模式以及在两者之间过渡的待机模式II。
通过改变CONFIG寄存器中的PRIM_RX的值和模块引脚CE的高低电平，就可以切换工作模式了。
工作模式之间切换是有延时的，如果不加延时，可能导致未知的问题。一定要按照芯片手册中的资料来增加延时。
nRF24L01P模块的初始化简易配置
（一对一模式，使用接收通道0，禁止自动重发）
| 寄存器 | 位名 | 推荐值 | 备注 |
|---|---|---|---|
| TX_ADDR | None | 0x34 0x43 0x10 0x10 0x01 | 发射地址 |
| RX_ADDR_P0 | None | 0x34 0x43 0x10 0x10 0x01 | 接收通道0地址 |
| EN_AA | None | 0 | 禁止自动应答 |
| SETUP_RETR | None | 0 | 禁止自动重发 |
| EN_RXADDR | ERX_P0 | 0x01 | 使能通道0 |
| RF_CH | None | 40 | 设置通道频率 |
| RX_PW_P0 | None | 0x05 | 设置P0通道的数据宽度 |
| RF_SETUP | None | 0x07 | 设置发射功率以及数据传输数率 |
| CONFIG | None | 0x3e | 禁止发射中断，使能发射模式 |
注：
1.配置寄存器时，一定要按照SPI的指令格式进行配置。如下图。
nRF24L01P模块调试的一些小技巧
1.刚开始调试的时候一定要选择一个模块为发射模式，一个模块为接收模式。发射的开启发射中断，接收的开启接收中断。这样就可以用过在中断中加入显示（例如LED）开观察是否发射成功或者接收成功。
2.刚开启中断的时候一定要记得清除中断标志位，中断标志位有两个，一个是模块的中断标志位，一个是MCU的中断标志位。
3.对于发射模式，切换发射模式的时候，最好把发射地址（TX_ADDR）也重新写一遍，因为我在调试的时候发现，如果不重写一遍地址，就会出问题。当然，这个可能是模块的BUG，因人而异把。
4.如果有问题，记得使用示波器查看SPI引脚、CE和IRQ的运行情况。
5.写入寄存器的时候记得拉低CE引脚。
6.如果还是有未知的问题，可以试试延长一下操作IO的时间。
附上源码
软件模拟的SPI通信，方便移植。
/**
******************************************************************************
* @file drv_spi.c
* @author xxx
* @version V1.0
* @date 2020-1-04
* @brief SPI配置C文件
******************************************************************************
*/
#include "common.h"
/*
* PTB2->SCK PTF0->CE
* PTB3->MOSI PTE2->MISO
* PTD2->CSN IRQ->PTA6
*
* PTE0->SCK PTG3->CE
* PTE1->MOSI PTE2->MISO
* PTE3->CSN IRQ->PTC7
*/
void spi_set_clk_low( )
{
//GPIO_Set_IO_Value(PORT_B,GPIO_PIN_2,OUTPUT_LOW);
GPIO_Set_IO_Value(PORT_E,GPIO_PIN_0,OUTPUT_LOW);
}
void spi_set_clk_high( )
{
//GPIO_Set_IO_Value(PORT_B,GPIO_PIN_2,OUTPUT_HIGH);
GPIO_Set_IO_Value(PORT_E,GPIO_PIN_0,OUTPUT_HIGH);
}
void spi_set_mosi_low( )
{
GPIO_Set_IO_Value(PORT_E,GPIO_PIN_1,OUTPUT_LOW);
}
void spi_set_mosi_hight( )
{
GPIO_Set_IO_Value(PORT_E,GPIO_PIN_1,OUTPUT_HIGH);
}
unsigned char spi_get_miso( )
{
return GPIO_Get_IO_Value(PORT_E,GPIO_PIN_2);
}
void spi_set_nss_low( )
{
GPIO_Set_IO_Value(PORT_E,GPIO_PIN_3,OUTPUT_LOW);
}
void spi_set_nss_high( )
{
GPIO_Set_IO_Value(PORT_E,GPIO_PIN_3,OUTPUT_HIGH);
}
/** 软件SPI */
/**
* @brief :SPI初始化(软件)
* @param :无
* @note :无
* @retval:无
*/
void drv_spi_init( void )
{
/*GPIO_Init_IO(PORT_B,GPIO_PIN_2,OUTPUT);
GPIO_Init_IO(PORT_B,GPIO_PIN_3,OUTPUT);
GPIO_Init_IO(PORT_E,GPIO_PIN_2,INPUT);
GPIO_Init_IO(PORT_D,GPIO_PIN_2,OUTPUT);*/
GPIO_Init_IO(PORT_E,GPIO_PIN_0,OUTPUT);
GPIO_Init_IO(PORT_E,GPIO_PIN_3,OUTPUT);
GPIO_Init_IO(PORT_E,GPIO_PIN_2,INPUT);
GPIO_Init_IO(PORT_E,GPIO_PIN_1,OUTPUT);
}
/**
* @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( ); //时钟线置高
asm ("nop; nop");
asm ("nop; nop");
/** 接收 */
Data <<= 1; //接收数据左移一位，先接收到的是最高位
if( 1 == spi_get_miso( ))
{
Data |= 0x01; //如果接收时IO引脚为高则认为接收到 1
}
spi_set_clk_low( ); //时钟线置低
asm ("nop; nop");
asm ("nop; nop");
}
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 */
RF24L01的驱动函数，主要调用NRF24L01_Gpio_Init() RF24L01_Init() NRF24L01_check() RF24L01_Set_Mode() NRF24L01_TxPacket() 这几个函数就够用了。
/**
******************************************************************************
* @file dev_RF24L01.c
* @author xxx
* @version V1.0.0
* @date 2020-1-03
* @brief NRF24L01配置C文件
******************************************************************************
*/
#include "common.h"
const char *g_ErrorString = "RF24L01 is not find !...";
/*
* PTB2->SCK PTF0->CE
* PTB3->MOSI PTE2->MISO
* PTD2->CSN IRQ->PTA6
*
* PTE0->SCK PTG3->CE
* PTE1->MOSI PTE2->MISO
* PTE3->CSN IRQ->PTC7
*/
void RF24L01_SET_CS_LOW()
{
GPIO_Set_IO_Value(PORT_E,GPIO_PIN_3,OUTPUT_LOW);
}
void RF24L01_SET_CS_HIGH()
{
GPIO_Set_IO_Value(PORT_E,GPIO_PIN_3,OUTPUT_HIGH);
}
void RF24L01_SET_CE_LOW()
{
GPIO_Set_IO_Value(PORT_G,GPIO_PIN_3,OUTPUT_LOW);
}
void RF24L01_SET_CE_HIGH()
{
GPIO_Set_IO_Value(PORT_G,GPIO_PIN_3,OUTPUT_HIGH);
}
unsigned char RF24L01_GET_IRQ_STATUS()
{
return GPIO_Get_IO_Value(PORT_C,GPIO_PIN_7);
}
/**
* @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 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
{
//drv_uart_tx_bytes( (uint8_t *)g_ErrorString, 26 );
}
//Delay_1ms( 4 * 500 );
Delay_1ms( 4 * 5 );
}
}
/**
* @brief :设置模式
* @param :
* @Mode:模式发送模式或接收模式
* @note :无
* @retval:无
*/
void RF24L01_Set_Mode( nRf24l01ModeType Mode )
{
uint8_t controlreg = 0;
RF24L01_SET_CE_LOW( );
controlreg = NRF24L01_Read_Reg( CONFIG );
if( Mode == MODE_TX )
{
controlreg &= ~( 1<< PRIM_RX );
}
else
{
if( Mode == MODE_RX )
{
uint8_t addr[5] = {INIT_ADDR};
NRF24L01_Set_RxAddr( 0, &addr[0], 5 );
controlreg |= ( 1<< PRIM_RX );
controlreg &= ~( 1<< MASK_RX_DR );
}
}
NRF24L01_Write_Reg( CONFIG, controlreg );
RF24L01_SET_CE_HIGH( );
Delay_1us(130);
}
/**
* @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;
uint8_t addr[5] = {INIT_ADDR};
RF24L01_SET_CE_LOW( );
NRF24L01_Set_TxAddr( &addr[0], 5 ); //设置TX地址
NRF24L01_Write_Buf( WR_TX_PLOAD, txbuf, Length ); //写数据到TX BUF 32字节 TX_PLOAD_WIDTH.
RF24L01_SET_CE_HIGH( );
Delay_1us(130);
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寄存器
drv_spi_read_write_byte( FLUSH_TX );
return MAX_TX;
}
if( l_Status & TX_OK ) //发送完成
{
return TX_OK;
}
return 0xFF; //其他原因发送失败
}
/**
* @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 ); //清中断标志
/*RF24L01_SET_CS_LOW( ); //片选
drv_spi_read_write_byte( FLUSH_RX );
RF24L01_SET_CS_HIGH( );*/
//while( 0 != RF24L01_GET_IRQ_STATUS( ))
/*{
Delay_1ms( 100 );
if( 30 == l_100MsTimes++ ) //3s没接收过数据，重新初始化模块
{
NRF24L01_Gpio_Init( );
RF24L01_Init( );
RF24L01_Set_Mode( MODE_RX );
//break;
}
}
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引脚初始化
* PTB2->SCK PTF0->CE
* PTB3->MOSI PTE2->MISO
* PTD2->CSN IRQ->PTA6
*
* PTE0->SCK PTG3->CE
* PTE1->MOSI PTE2->MISO
* PTE3->CSN IRQ->PTC7
* @param :无
* @note :无
* @retval:无
*/
void NRF24L01_Gpio_Init( void )
{
GPIO_Init_IO(PORT_C,GPIO_PIN_7,INPUT);
GPIO_Init_IO(PORT_G,GPIO_PIN_3,OUTPUT);
KBI_Init(PORT_C,GPIO_PIN_7,FALLING);
}
/**
* @brief :RF24L01模块初始化
* @param :无
* @note :无
* @retval:无
*/
void RF24L01_Init( void )
{
uint8_t addr[5] = {INIT_ADDR};
RF24L01_SET_CE_LOW( );
NRF24L01_Write_Reg( RX_PW_P0, 8 );
NRF24L01_Write_Reg( CONFIG, 0x7e ); //接收中断
NRF24L01_Write_Reg( EN_AA, ( 0 ) ); //禁止通道0自动应答
NRF24L01_Write_Reg( EN_RXADDR, ( 1 ) ); //通道0接收
NRF24L01_Write_Reg( SETUP_AW, AW_5BYTES ); //地址宽度 5个字节
NRF24L01_Write_Reg( SETUP_RETR, 0x0a ); //重复等待时间 250us
NRF24L01_Write_Reg( RF_CH, 40 ); //初始化通道
NRF24L01_Write_Reg( RF_SETUP, 0x07 );
NRF24L01_Set_TxAddr( &addr[0], 5 ); //设置TX地址
NRF24L01_Set_RxAddr( 0, &addr[0], 5 ); //设置RX地址
RF24L01_SET_CE_HIGH( );
Delay_1ms(1);
}
IRQ接收中断处理函数
void KBI0_IRQHandler()
{
uint8_t l_Status = 0, l_RxLength = 0, l_100MsTimes = 0;
unsigned char rxbuf[8];
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
GPIO_Toggle_IO_Value(PORT_C,GPIO_PIN_0);
return l_RxLength;
}
KBI0_SC |= KBI_SC_KBACK_MASK; // clear interrupt flag
}
