SPI1和SPI3配置nrf24l01的程序代码该如何去实现

怎样去编写使用SPI1配置nrf24l01的程序代码呢？
怎样去编写使用SPI3配置nrf24l01的程序代码呢？

回帖（2）

徐丹

2021-12-16 09:29:17

正点原子自带的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 != 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); //接收一个包的数据
正点原子自带的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 != 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); //接收一个包的数据

举报

张览秀

2021-12-16 09:29:21

使用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!=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     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     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); //接收一个包的数据
使用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!=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     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     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); //接收一个包的数据

举报

更多回帖

rotate(-90deg);
回复

2 0 0

2 0 0

相关问答
SPI nRF24L01 STM32F103ZET6

如何利用STM32软件SPI去实现NRF24L01通信呢

2021-12-16 1478

如何去实现基于STM32F1开发板和NRF24L01模块的SPI单通信呢

2021-12-16 486

NRF24L01驱动函数包括哪些

2021-12-16 935

无线数字传输芯片nRF24L01的WIFI模块该怎样去设计呢

2021-12-17 1407

如何去实现NRF24L01状态机的软硬件设计呢

2021-12-16 962

SPI3多次写入NRF24L01失效的原因是什么？

2020-04-23 1721

NRF24L01是如何去定义的？NRF24L01有哪些特性呢

2021-12-16 896

SPI1配置24L01问题的解决办法？

2020-06-17 1646

SPI2与FLASH及NRF24L01通讯问题

2020-04-10 1249

求大佬分享stm8硬件spi初始化nrf24l01的spi代码

2021-12-17 573

发帖

登录/注册

20万+工程师都在用，免费PCB检查工具

无需安装、支持浏览器和手机在线查看、实时共享

电子发烧友APP

登录注册
|投诉反馈|电子发烧友网

© 2021 bbs.elecfans.com

湘ICP备2023018690号

点击登录

登录更多精彩功能！

首页

论坛版块

小组

免费开发板试用

ebook

直播

搜索

登录

李伟

SPI1和SPI3配置nrf24l01的程序代码该如何去实现

回帖（2）

徐丹

张览秀

相关问答

如何利用STM32软件SPI去实现NRF24L01通信呢

如何去实现基于STM32F1开发板和NRF24L01模块的SPI单通信呢

NRF24L01驱动函数包括哪些

无线数字传输芯片nRF24L01的WIFI模块该怎样去设计呢

如何去实现NRF24L01状态机的软硬件设计呢

SPI3多次写入NRF24L01失效的原因是什么？

NRF24L01是如何去定义的 ？NRF24L01有哪些特性呢

SPI1配置24L01问题的解决办法？

SPI2与FLASH及NRF24L01通讯问题

求大佬分享stm8硬件spi初始化nrf24l01的spi代码

20万+工程师都在用，免费PCB检查工具

NRF24L01是如何去定义的？NRF24L01有哪些特性呢