STM32--使用SPI1和SPI3配置nrf24l01

正点原子自带的nrf24l01的例程是SPI2的，现在我使用了SPI1和SPI3来配置nrf24l01，芯片型号是STM32F103ZET6。

使用SPI1配置nrf24l01

spi.c

//这里针是对SPI1的初始化
void SPI1_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    SPI_InitTypeDef  SPI_InitStructure;
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOA, ENABLE );//PORTA时钟使能 
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_SPI1,  ENABLE );//SPI1时钟使能   

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;   //PA 5/6/7复用推挽输出 
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_SetBits(GPIOA,GPIO_Pin_5|GPIO_Pin_6|GPIO_Pin_7);  //PA567 上拉

    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;        //设置SPI工作模式:设置为主SPI
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;    //设置SPI的数据大小:SPI发送接收8位帧结构
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;           //串行同步时钟的空闲状态为低电平
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;         //串行同步时钟的第1个跳变沿（上升或下降）数据被采样
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;            //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;     //定义波特率预分频的值:波特率预分频值为16
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;   //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    SPI_InitStructure.SPI_CRCPolynomial = 7;             //CRC值计算的多项式
    SPI_Init(SPI1, &SPI_InitStructure);                  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器

    SPI_Cmd(SPI1, ENABLE); //使能SPI外设

    SPI1_ReadWriteByte(0xff);//启动传输      
}   
//SPI 速度设置函数
//SpeedSet:
//SPI_BaudRatePrescaler_2   2分频   
//SPI_BaudRatePrescaler_8   8分频   
//SPI_BaudRatePrescaler_16  16分频  
//SPI_BaudRatePrescaler_256 256分频   
void SPI1_SetSpeed(u8 SPI_BaudRatePrescaler)
{
    assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));
    SPI1->CR1&=0XFFC7;
    SPI1->CR1|=SPI_BaudRatePrescaler;   //设置SPI1速度 
    SPI_Cmd(SPI1,ENABLE); 
} 

//SPIx 读写一个字节
//TxData:要写入的字节
//返回值:读取到的字节
//先判断发送缓冲器空，然后发送数据，再等待接收数据完成
u8 SPI1_ReadWriteByte(u8 TxData) //TxData 可以是8位或16位的，在启用SPI之前就确定好数据帧格式
{       
    u8 retry = 0;                         
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_TXE) == RESET) //0：发送缓冲非空  等待发送缓冲器变空
    {
        retry++;
        if(retry>200)return 0;
    }             
    SPI_I2S_SendData(SPI1, TxData);
    retry=0;
    while (SPI_I2S_GetFlagStatus(SPI1, SPI_I2S_FLAG_RXNE) == RESET)//等待接收数据完成
    {
        retry++;
        if(retry>200)return 0;
    }                               
    return SPI_I2S_ReceiveData(SPI1); //返回最近接收的数据，SPI_DR寄存器里面的                      
}

spi.h

void SPI1_Init(void);            //初始化SPI口
void SPI1_SetSpeed(u8 SpeedSet); //设置SPI速度   
u8 SPI1_ReadWriteByte(u8 TxData);//SPI总线读写一个字节

24l01.c

/**
MISO -----A6
MOSI -----A7
SCK  -----A5
IRQ  -----C5
CE   -----A4
CS   -----C4


**/
//初始化24L01的IO口
void NRF24L01_SPI1_Init(void)
{   
    GPIO_InitTypeDef GPIO_InitStructure;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOC|RCC_APB2Periph_GPIOA, ENABLE);   //使能PG端口时钟     

    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;         
    GPIO_Init(GPIOA, &GPIO_InitStructure);        //CE  PA4  推挽输出

    GPIO_Init(GPIOC, &GPIO_InitStructure);        //CSN PC4  推挽输出
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //IRQ PC5 下拉输入 
    GPIO_Init(GPIOC, &GPIO_InitStructure);

    GPIO_ResetBits(GPIOC,GPIO_Pin_5 | GPIO_Pin_4 ); //拉低             
    GPIO_ResetBits(GPIOA,GPIO_Pin_4 ); //拉低      
    SPI1_Init();                //初始化SPI     

    NRF24L01_CE_SPI1 = 0;           //使能24L01
    NRF24L01_CSN_SPI1 = 1;          //SPI片选取消                
}

//检测24L01是否存在
//返回值:0，成功;1，失败 
u8 NRF24L01_SPI1_Check(void)
{
    u8 buf[5]={0XA5,0XA5,0XA5,0XA5,0XA5};
    u8 i;
    SPI1_SetSpeed(SPI_BaudRatePrescaler_8);             //spi速度为9Mhz（24L01的最大SPI时钟为10Mhz）        
    NRF24L01_SPI1_Write_Buf(NRF_WRITE_REG + TX_ADDR, buf, 5);//buf是地址，写入5个字节的地址.    
    NRF24L01_SPI1_Read_Buf(NRF_READ_REG + TX_ADDR, buf, 5);  //读取的数据放在 buf 里面 
    for(i = 0; i < 5; i++)
        if(buf[i] != 0XA5)
            break;                                 
    if(i != 5) 
        return 1;    //检测24L01错误    
    return 0;        //检测到24L01
}        
//SPI写寄存器
//reg:指定寄存器地址
//value:写入的值
u8 NRF24L01_SPI1_Write_Reg(u8 reg,u8 value) //返回状态值
{
    u8 status;  
    NRF24L01_CSN_SPI1 = 0;                 //使能SPI传输
    status =SPI1_ReadWriteByte(reg);  //发送寄存器号 
    SPI1_ReadWriteByte(value);        //写入寄存器的值
    NRF24L01_CSN_SPI1 = 1;                 //禁止SPI传输       
    return(status);                   //返回状态值
}
//读取SPI寄存器值
//reg:要读的寄存器
u8 NRF24L01_SPI1_Read_Reg(u8 reg) //返回寄存器的值
{
    u8 reg_val;     
    NRF24L01_CSN_SPI1 = 0;          //使能SPI传输       
    SPI1_ReadWriteByte(reg);   //发送寄存器号
    reg_val = SPI1_ReadWriteByte(0XFF);//读取寄存器内容
    NRF24L01_CSN_SPI1 = 1;          //禁止SPI传输           
    return(reg_val);           //返回寄存器的值
}   
//在指定位置读出指定长度的数据
u8 NRF24L01_SPI1_Read_Buf(u8 reg,u8 *pBuf,u8 len)
{
    u8 status,u8_ctr;          
    NRF24L01_CSN_SPI1 = 0;           //使能SPI传输
    status=SPI1_ReadWriteByte(reg);//发送寄存器值,并读取状态值         
    for(u8_ctr = 0; u8_ctr < len; u8_ctr++)
        pBuf[u8_ctr] = SPI1_ReadWriteByte(0XFF);//读出数据
    NRF24L01_CSN_SPI1=1;       //关闭SPI传输
    return status;        //返回读到的状态值
}

u8 NRF24L01_SPI1_Write_Buf(u8 reg, u8 *pBuf, u8 len)
{
    u8 status,u8_ctr;       
    NRF24L01_CSN_SPI1 = 0;          //使能SPI传输
    status = SPI1_ReadWriteByte(reg);//发送 寄存器值和命令！并读取状态值
    for(u8_ctr = 0; u8_ctr < len; u8_ctr++) SPI1_ReadWriteByte(*pBuf++); //写入数据，一次发送一个字节 
    NRF24L01_CSN_SPI1 = 1;       //关闭SPI传输
    return status;          //返回读到的状态值
}                  

u8 NRF24L01_SPI1_TxPacket(u8 *txbuf)
{
    u8 sta;
    SPI1_SetSpeed(SPI_BaudRatePrescaler_8);//spi速度为9Mhz（24L01的最大SPI时钟为10Mhz）   
    NRF24L01_CE_SPI1 = 0;
    NRF24L01_SPI1_Write_Buf(WR_TX_PLOAD, txbuf, TX_PLOAD_WIDTH);//写数据到txbuf  32个字节  
    NRF24L01_CE_SPI1 = 1;         //拉高10us后则启动发送

    while(NRF24L01_IRQ_SPI1 != 0);//等待发送完成
    sta = NRF24L01_SPI1_Read_Reg(STATUS);    
    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG + STATUS, sta); //清除TX_DS或MAX_RT中断标志
    if(sta&MAX_TX)//达到最大重发次数
    {
        NRF24L01_SPI1_Write_Reg(FLUSH_TX,0xff);//清除TX FIFO寄存器 
        return MAX_TX; 
    }
    if(sta&TX_OK)//发送完成
    {
        return TX_OK;
    }
    return 0xff;//其他原因发送失败
}

u8 NRF24L01_SPI1_RxPacket(u8 *rxbuf)
{
    u8 sta;     
    u8 RX_P_NO;     //接收通道号
    SPI1_SetSpeed(SPI_BaudRatePrescaler_8);    
    sta = NRF24L01_SPI1_Read_Reg(STATUS);  
    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG + STATUS, sta); 
    if(sta & RX_OK)//接收到数据
    {
        NRF24L01_SPI1_Read_Buf(RD_RX_PLOAD,rxbuf,RX_PLOAD_WIDTH);//读取数据
        NRF24L01_SPI1_Write_Reg(FLUSH_RX, 0xff);//清除RX FIFO寄存器 
        return 0; 
    }      
    return 1;//没收到任何数据
}   


void NRF24L01_SPI1_RX_Mode(void)
{
    NRF24L01_CE_SPI1 = 0;    //写配置寄存器 + 数据通道0接收地址   接收地址常量
    NRF24L01_SPI1_Write_Reg(FLUSH_RX,0xff);                //清除RX FIFO寄存器  

//  NRF24L01_SPI1_Write_Buf(NRF_WRITE_REG+TX_ADDR,(u8*)TX_ADDRESS,TX_ADR_WIDTH);    

    NRF24L01_SPI1_Write_Buf(NRF_WRITE_REG+RX_ADDR_P0,(u8*)RX_ADDRESS,RX_ADR_WIDTH);//写RX0节点地址


    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);//选择通道0的有效数据宽度   


    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG+EN_AA,0x01);    //使能通道0-5的ACK自动应答    
    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG+EN_RXADDR,0x01); //使能通道0-5的接收地址    
    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG+RF_CH,40);          //设置RF通信频率          

    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG+RF_SETUP,0x0f);  //设置TX发射参数,0db增益,2Mbps,低噪声增益开启   
    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG+CONFIG, 0x0f);   //配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式 
    NRF24L01_CE_SPI1 = 1; //CE为高,进入接收模式 

}                        

void NRF24L01_SPI1_TX_Mode(void)
{                                                        
    NRF24L01_CE_SPI1 = 0; 
    NRF24L01_SPI1_Write_Buf(NRF_WRITE_REG+TX_ADDR,(u8*)TX_ADDRESS,TX_ADR_WIDTH);//写TX节点地址 
    NRF24L01_SPI1_Write_Buf(NRF_WRITE_REG+RX_ADDR_P0,(u8*)RX_ADDRESS,RX_ADR_WIDTH); //设置TX节点地址,主要为了使能ACK

    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG+EN_AA,0x01);     //使能通道0的自动应答 开启自动ACK则默认选择Enhanced模式   
    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG+EN_RXADDR,0x01); //使能通道0的接收 
    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG+SETUP_RETR,0x1a);//设置自动重发间隔时间:500us + 86us;最大自动重发次数:10次   
    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG+RF_CH,40);        //设置RF通道为40，工作通道频率

    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG+RF_SETUP,0x0f);  //设置TX发射参数,0db增益,2Mbps,低噪声增益开启   
    NRF24L01_SPI1_Write_Reg(NRF_WRITE_REG+CONFIG,0x0e);    //配置基本工作模式的参数;EN_CRC,16BIT_CRC,PWR_UP,发送模式,开启所有中断
    NRF24L01_CE_SPI1 = 1;                                  //CE为高,10us后启动发送
}

24l01.h

#define NRF24L01_CE_SPI1   PAout(4) //24L01片选信号
#define NRF24L01_CSN_SPI1  PCout(4) //SPI片选信号    
#define NRF24L01_IRQ_SPI1  PCin(5)  //IRQ主机数据输入

void NRF24L01_SPI1_Init(void);                      //初始化
void NRF24L01_SPI1_RX_Mode(void);                   //配置为接收模式
void NRF24L01_SPI1_TX_Mode(void);                   //配置为发送模式
u8 NRF24L01_SPI1_Write_Buf(u8 reg, u8 *pBuf, u8 u8s);//写数据区
u8 NRF24L01_SPI1_Read_Buf(u8 reg, u8 *pBuf, u8 u8s);    //读数据区  
u8 NRF24L01_SPI1_Read_Reg(u8 reg);                  //读寄存器
u8 NRF24L01_SPI1_Write_Reg(u8 reg, u8 value);       //写寄存器
u8 NRF24L01_SPI1_Check(void);                       //检查24L01是否存在
u8 NRF24L01_SPI1_TxPacket(u8 *txbuf);               //发送一个包的数据
u8 NRF24L01_SPI1_RxPacket(u8 *rxbuf);               //接收一个包的数据

使用SPI3配置nrf24l01

spi.c

void SPI3_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    SPI_InitTypeDef  SPI_InitStructure;

    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能 
    RCC_APB1PeriphClockCmd( RCC_APB1Periph_SPI3,  ENABLE );//SPI3时钟使能   

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);  
    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE); 

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3 | GPIO_Pin_4 | GPIO_Pin_5;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PB3/4/5复用推挽输出 
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB

    GPIO_SetBits(GPIOB,GPIO_Pin_3|GPIO_Pin_4|GPIO_Pin_5);  //PB3/4/5上拉

    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;       //设置SPI工作模式:设置为主SPI
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;       //设置SPI的数据大小:SPI发送接收8位帧结构
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_High;     //串行同步时钟的空闲状态为高电平
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_2Edge;    //串行同步时钟的第二个跳变沿（上升或下降）数据被采样
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;       //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;     //定义波特率预分频的值:波特率预分频值为256
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;  //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    SPI_InitStructure.SPI_CRCPolynomial = 7;    //CRC值计算的多项式
    SPI_Init(SPI3, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器

    SPI_Cmd(SPI3, ENABLE); //使能SPI外设

    SPI3_ReadWriteByte(0xff);//启动传输      
}   

//SPI 速度设置函数
//SpeedSet:
//SPI_BaudRatePrescaler_2   2分频   
//SPI_BaudRatePrescaler_8   8分频   
//SPI_BaudRatePrescaler_16  16分频  
//SPI_BaudRatePrescaler_256 256分频 

void SPI3_SetSpeed(u8 SPI_BaudRatePrescaler)
{
    assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));
    SPI3->CR1&=0XFFC7;
    SPI3->CR1|=SPI_BaudRatePrescaler;   //设置SPI2速度 
    SPI_Cmd(SPI3,ENABLE); 

} 

//SPIx 读写一个字节
//TxData:要写入的字节
//返回值:读取到的字节
u8 SPI3_ReadWriteByte(u8 TxData)
{       
    u8 retry=0;                 
    while (SPI_I2S_GetFlagStatus(SPI3, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
        {
        retry++;
        if(retry>200)return 0;
        }             
    SPI_I2S_SendData(SPI3, TxData); //通过外设SPIx发送一个数据
    retry=0;

    while (SPI_I2S_GetFlagStatus(SPI3, SPI_I2S_FLAG_RXNE) == RESET)//检查指定的SPI标志位设置与否:接受缓存非空标志位
        {
        retry++;
        if(retry>200)return 0;
        }                               
    return SPI_I2S_ReceiveData(SPI3); //返回通过SPIx最近接收的数据                     
}

spi.h

void SPI3_Init(void);            //初始化SPI口
void SPI3_SetSpeed(u8 SpeedSet); //设置SPI速度   
u8 SPI3_ReadWriteByte(u8 TxData);//SPI总线读写一个字节

24l01.c

/**
MISO -----B4
MOSI -----B5
SCK  -----B3
IRQ  -----B8
CE   -----B6
CS   -----B7

**/

//初始化24L01的IO口
void NRF24L01_SPI3_Init(void)
{   
    GPIO_InitTypeDef GPIO_InitStructure;
    SPI_InitTypeDef  SPI_InitStructure;

    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOA, ENABLE);   //使能PB,A端口时钟


    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;               //PA15上拉 防止W25X的干扰
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;         //推挽输出
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);  //初始化指定IO
    GPIO_SetBits(GPIOA,GPIO_Pin_15);//上拉                


    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_7|GPIO_Pin_6;    //PB6 7 推挽

    GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化指定IO

    GPIO_InitStructure.GPIO_Pin  = GPIO_Pin_8;   
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //PB8 输入  
    GPIO_Init(GPIOB, &GPIO_InitStructure);

    GPIO_ResetBits(GPIOB,GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8);//PB6,7,8上拉                   

    SPI3_Init();            //初始化SPI     

    SPI_Cmd(SPI3, DISABLE); // SPI外设不使能

    SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //SPI设置为双线双向全双工
    SPI_InitStructure.SPI_Mode = SPI_Mode_Master;       //SPI主机
    SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;       //发送接收8位帧结构
    SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;      //时钟悬空低
    SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;    //数据捕获于第1个时钟沿
    SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;       //NSS信号由软件控制
    SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_16;     //定义波特率预分频的值:波特率预分频值为16
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;  //数据传输从MSB位开始
    SPI_InitStructure.SPI_CRCPolynomial = 7;    //CRC值计算的多项式
    SPI_Init(SPI3, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器

    SPI_Cmd(SPI3, ENABLE); //使能SPI外设

    NRF24L01_SPI3_CE=0;             //使能24L01
    NRF24L01_SPI3_CSN=1;            //SPI片选取消  

}
//检测24L01是否存在
//返回值:0，成功;1，失败 
u8 NRF24L01_SPI3_Check(void)
{
    u8 buf[5]={0XA5,0XA5,0XA5,0XA5,0XA5};
    u8 i;
    SPI3_SetSpeed(SPI_BaudRatePrescaler_8); //spi速度为9Mhz（24L01的最大SPI时钟为10Mhz）        
    NRF24L01_SPI3_Write_Buf(NRF_WRITE_REG+TX_ADDR,buf,5);//写入5个字节的地址.   
    NRF24L01_SPI3_Read_Buf(TX_ADDR,buf,5); //读出写入的地址  
    for(i=0;i<5;i++)if(buf[i]!=0XA5)break;                                 
    if(i!=5)return 1;//检测24L01错误    
    return 0;        //检测到24L01
}        
//SPI写寄存器
//reg:指定寄存器地址
//value:写入的值
u8 NRF24L01_SPI3_Write_Reg(u8 reg,u8 value)
{
    u8 status;  
    NRF24L01_SPI3_CSN=0;                 //使能SPI传输
    status =SPI3_ReadWriteByte(reg);//发送寄存器号 
    SPI3_ReadWriteByte(value);      //写入寄存器的值
    NRF24L01_SPI3_CSN=1;                 //禁止SPI传输     
    return(status);                 //返回状态值
}
//读取SPI寄存器值
//reg:要读的寄存器
u8 NRF24L01_SPI3_Read_Reg(u8 reg)
{
    u8 reg_val;     
    NRF24L01_SPI3_CSN = 0;          //使能SPI传输       
    SPI3_ReadWriteByte(reg);   //发送寄存器号
    reg_val=SPI3_ReadWriteByte(0XFF);//读取寄存器内容
    NRF24L01_SPI3_CSN = 1;          //禁止SPI传输           
    return(reg_val);           //返回状态值
}   
//在指定位置读出指定长度的数据
//reg:寄存器(位置)
//*pBuf:数据指针
//len:数据长度
//返回值,此次读到的状态寄存器值 
u8 NRF24L01_SPI3_Read_Buf(u8 reg,u8 *pBuf,u8 len)
{
    u8 status,u8_ctr;          
    NRF24L01_SPI3_CSN = 0;           //使能SPI传输
    status=SPI3_ReadWriteByte(reg);//发送寄存器值(位置),并读取状态值         
    for(u8_ctr=0;u8_ctr<len;u8_ctr++)pBuf[u8_ctr]=SPI3_ReadWriteByte(0XFF);//读出数据
    NRF24L01_SPI3_CSN=1;       //关闭SPI传输
    return status;        //返回读到的状态值
}
//在指定位置写指定长度的数据
//reg:寄存器(位置)
//*pBuf:数据指针
//len:数据长度
//返回值,此次读到的状态寄存器值
u8 NRF24L01_SPI3_Write_Buf(u8 reg, u8 *pBuf, u8 len)
{
    u8 status,u8_ctr;       
    NRF24L01_SPI3_CSN = 0;          //使能SPI传输
    status = SPI3_ReadWriteByte(reg);//发送寄存器值(位置),并读取状态值
    for(u8_ctr=0; u8_ctr<len; u8_ctr++)SPI3_ReadWriteByte(*pBuf++); //写入数据   
    NRF24L01_SPI3_CSN = 1;       //关闭SPI传输
    return status;          //返回读到的状态值
}                  
//启动NRF24L01发送一次数据
//txbuf:待发送数据首地址
//返回值:发送完成状况
u8 NRF24L01_SPI3_TxPacket(u8 *txbuf)
{
    u8 sta;
    SPI3_SetSpeed(SPI_BaudRatePrescaler_8);//spi速度为9Mhz（24L01的最大SPI时钟为10Mhz）   
    NRF24L01_SPI3_CE=0;
    NRF24L01_SPI3_Write_Buf(WR_TX_PLOAD,txbuf,TX_PLOAD_WIDTH);//写数据到TX BUF  32个字节
    NRF24L01_SPI3_CE=1;//启动发送    
    while(NRF24L01_SPI3_IRQ!=0);//等待发送完成
    sta=NRF24L01_SPI3_Read_Reg(STATUS);  //读取状态寄存器的值       
    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+STATUS,sta); //清除TX_DS或MAX_RT中断标志
    if(sta&MAX_TX)//达到最大重发次数
    {
        NRF24L01_SPI3_Write_Reg(FLUSH_TX,0xff);//清除TX FIFO寄存器 
        return MAX_TX; 
    }
    if(sta&TX_OK)//发送完成
    {
        return TX_OK;
    }
    return 0xff;//其他原因发送失败
}
//启动NRF24L01发送一次数据
//txbuf:待发送数据首地址
//返回值:0，接收完成；其他，错误代码
u8 NRF24L01_SPI3_RxPacket(u8 *rxbuf)
{
    u8 sta;       
    u8 RX_P_NO;     //接收通道号
    SPI3_SetSpeed(SPI_BaudRatePrescaler_8); //spi速度为9Mhz（24L01的最大SPI时钟为10Mhz）   
    sta=NRF24L01_SPI3_Read_Reg(STATUS);  //读取状态寄存器的值         
    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+STATUS,sta); //清除TX_DS或MAX_RT中断标志
    if(sta&RX_OK)//接收到数据
    {
            //读取通道0数据
        NRF24L01_SPI3_Read_Buf(RD_RX_PLOAD,rxbuf,RX_PLOAD_WIDTH);       //读取通道1数据

        NRF24L01_SPI3_Write_Reg(FLUSH_RX,0xff);//清除RX FIFO寄存器 
        return 0; 
    }      
    return 1;//没收到任何数据
}                       
//该函数初始化NRF24L01到RX模式
//设置RX地址,写RX数据宽度,选择RF频道,波特率和LNA HCURR
//当CE变高后,即进入RX模式,并可以接收数据了          
void NRF24L01_SPI3_RX_Mode(void)
{
    NRF24L01_SPI3_CE=0;   
    NRF24L01_SPI3_Write_Buf(NRF_WRITE_REG+RX_ADDR_P0,(u8*)RX_ADDRESS,RX_ADR_WIDTH);//写RX0节点地址


    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);//选择通道0的有效数据宽度   


    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+EN_AA,0x01);    //使能通道0-5的ACK自动应答    
    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+EN_RXADDR,0x01); //使能通道0-5的接收地址    
    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+RF_CH,40);          //设置RF通信频率          

    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+RF_SETUP,0x0f);  //设置TX发射参数,0db增益,2Mbps,低噪声增益开启   
    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+CONFIG, 0x0f);   //配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式 
    NRF24L01_SPI3_CE = 1; //CE为高,进入接收模式 
}                    
//该函数初始化NRF24L01到TX模式
//设置TX地址,写TX数据宽度,设置RX自动应答的地址,填充TX发送数据,选择RF频道,波特率和LNA HCURR
//PWR_UP,CRC使能
//当CE变高后,即进入RX模式,并可以接收数据了          
//CE为高大于10us,则启动发送.  
void NRF24L01_SPI3_TX_Mode(void)
{                                                        
    NRF24L01_SPI3_CE=0;     
    NRF24L01_SPI3_Write_Buf(NRF_WRITE_REG+TX_ADDR,(u8*)TX_ADDRESS,TX_ADR_WIDTH);//写TX节点地址 
    NRF24L01_SPI3_Write_Buf(NRF_WRITE_REG+RX_ADDR_P0,(u8*)RX_ADDRESS,RX_ADR_WIDTH); //设置TX节点地址,主要为了使能ACK      

    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+EN_AA,0x01);     //使能通道0的自动应答    
    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+EN_RXADDR,0x01); //使能通道0的接收地址  
    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+SETUP_RETR,0x1a);//设置自动重发间隔时间:500us + 86us;最大自动重发次数:10次
    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+RF_CH,40);       //设置RF通道为40
    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+RF_SETUP,0x0f);  //设置TX发射参数,0db增益,2Mbps,低噪声增益开启   
    NRF24L01_SPI3_Write_Reg(NRF_WRITE_REG+CONFIG,0x0e);    //配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式,开启所有中断
    NRF24L01_SPI3_CE=1;//CE为高,10us后启动发送
}

24l01.h

#define NRF24L01_SPI3_CE   PBout(6) //24L01片选信号
#define NRF24L01_SPI3_CSN  PBout(7) //SPI片选信号      
#define NRF24L01_SPI3_IRQ  PBin(8)  //IRQ主机数据输入

void NRF24L01_SPI3_Init(void);                      //初始化
void NRF24L01_SPI3_RX_Mode(void);                   //配置为接收模式
void NRF24L01_SPI3_TX_Mode(void);                   //配置为发送模式
u8 NRF24L01_SPI3_Write_Buf(u8 reg, u8 *pBuf, u8 u8s);//写数据区
u8 NRF24L01_SPI3_Read_Buf(u8 reg, u8 *pBuf, u8 u8s);    //读数据区        
u8 NRF24L01_SPI3_Read_Reg(u8 reg);                  //读寄存器
u8 NRF24L01_SPI3_Write_Reg(u8 reg, u8 value);       //写寄存器
u8 NRF24L01_SPI3_Check(void);                       //检查24L01是否存在
u8 NRF24L01_SPI3_TxPacket(u8 *txbuf);               //发送一个包的数据
u8 NRF24L01_SPI3_RxPacket(u8 *rxbuf);               //接收一个包的数据