NRF24L01编写

NRF24L01

模式控制图

NRF24L01.c

软件模拟SPI，通过手动翻转特定GPIO的高低电平，然后写SPI的代码，然后调用SPI代码来写NRF24L01的代码。

include "NRF24L01.h"
#include "stm32f10x.h"
#include "NRF24L01_Define.h"

//发送部分
uint8_t NRF24L01_TxAddress[5]={0x11,0x22,0x33,0x44,0x55};
#define NRF24L01_TX_PACKET_WIDTH 4
uint8_t NRF24L01_TxPacket[NRF24L01_TX_PACKET_WIDTH];

//接收部分
uint8_t NRF24L01_RxAddress[5]={0x11,0x22,0x33,0x44,0x55};
#define NRF24L01_RX_PACKET_WIDTH 4
uint8_t NRF24L01_RxPacket[NRF24L01_RX_PACKET_WIDTH];


//CE: 开启/关闭收发模式
void NRF24L01_W_CE(uint8_t BitValue) {
    GPIO_WriteBit(GPIOA, GPIO_Pin_0, (BitAction)BitValue);
}

//CSN: 片选CS/SS
void NRF24L01_W_CSN(uint8_t BitValue) {
    GPIO_WriteBit(GPIOA, GPIO_Pin_1, (BitAction)BitValue);
}

void NRF24L01_W_SCK(uint8_t BitValue) {
    GPIO_WriteBit(GPIOA, GPIO_Pin_2, (BitAction)BitValue);
}

void NRF24L01_W_M0SI(uint8_t BitValue) {
    GPIO_WriteBit(GPIOA, GPIO_Pin_3, (BitAction)BitValue);
}

uint8_t NRF24L01_R_MISO(uint8_t BitValue) {
    return GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_4);
}

void NRF24L01_GPIO_Init(void) {
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA, ENABLE);

    GPIO_InitTypeDef GPIO_InitStructure;
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1|GPIO_Pin_2|GPIO_Pin_3;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);

    NRF24L01_W_CE(0); //CE默认为0，退出收发模式
    NRF24L01_W_CSN(1); //CSN默认为1，高电平不选中从机
    NRF24L01_W_SCK(0); //SCk默认为0，对应SPI模式0
    NRF24L01_W_M0SI(0); //MOSI默认电平随意，1和0均可
}

uint8_t NRF24L01_SPI_SwapByte(uint8_t Byte) {
    for (uint8_t i = 0; i < 8; i++) {
        if (Byte & 0x80) {
            NRF24L01_W_M0SI(1);
        }
        else {
            NRF24L01_W_M0SI(0);
        }
        Byte <<= 1;
        NRF24L01_W_SCK(1); //SCK产生上升沿
        if (NRF24L01_R_MISO(1)) {
            Byte |= 0x01;
        }
        NRF24L01_W_SCK(0); //SCK产生下降沿
    }
    return Byte;
}

uint8_t NRF24L01_ReadReg(uint8_t RegAddress) {
    uint8_t Data;
    NRF24L01_W_CSN(0); //通信开始
    NRF24L01_SPI_SwapByte(NRF24L01_R_REGISTER | RegAddress);
    Data = NRF24L01_SPI_SwapByte(NRF24L01_NOP);
    NRF24L01_W_CSN(1); //通信结束
    return Data;
}

void NRF24L01_WriteReg(uint8_t RegAddress, uint8_t Data) {
    NRF24L01_W_CSN(0);
    NRF24L01_SPI_SwapByte(NRF24L01_W_REGISTER | RegAddress);
    NRF24L01_SPI_SwapByte(Data);
    NRF24L01_W_CSN(1);
}

void NRF24L01_WriteRegs(uint8_t RegAddress, uint8_t *DataArray, uint8_t Count) {
    NRF24L01_W_CSN(0);
    NRF24L01_SPI_SwapByte(NRF24L01_W_REGISTER | RegAddress);
    for (uint8_t i = 0; i < Count; i++) {
        NRF24L01_SPI_SwapByte(DataArray[i]);
    }
    NRF24L01_W_CSN(1);
}

void NRF24L01_WriteTXPayload(uint8_t *DataArray, uint8_t Count) {
    NRF24L01_W_CSN(0);
    NRF24L01_SPI_SwapByte(NRF24L01_W_TX_PAYLOAD);
    for (uint8_t i = 0; i < Count; i++) {
        NRF24L01_SPI_SwapByte(DataArray[i]);
    }
    NRF24L01_W_CSN(1);
}

void NRF24L01_ReadRegs(uint8_t RegAddress, uint8_t *DataArray, uint8_t Count) {
    NRF24L01_W_CSN(0);
    NRF24L01_SPI_SwapByte(NRF24L01_R_REGISTER | RegAddress);
    for (uint8_t i = 0; i < Count; i++) {
        DataArray[i] = NRF24L01_SPI_SwapByte(NRF24L01_NOP);
    }
    NRF24L01_W_CSN(1);
    //这里不需要返回，因为这里是用指针地址传参的。
}

void NRF24L01_ReadRXPayload(uint8_t *DataArray, uint8_t Count) {
    NRF24L01_W_CSN(0);
    NRF24L01_SPI_SwapByte(NRF24L01_R_RX_PAYLOAD);
    for (uint8_t i = 0; i < Count; i++) {
        DataArray[i] = NRF24L01_SPI_SwapByte(NRF24L01_NOP);
    }
    NRF24L01_W_CSN(1);
    //这里不需要返回，因为这里是用指针地址传参的。
}

void NRF24L01_Flush_TX(void) {
    NRF24L01_W_CSN(0);
    NRF24L01_SPI_SwapByte(NRF24L01_FLUSH_TX);
    NRF24L01_W_CSN(1);
}

void NRF24L01_Flush_RX(void) {
    NRF24L01_W_CSN(0);
    NRF24L01_SPI_SwapByte(NRF24L01_FLUSH_RX);
    NRF24L01_W_CSN(1);
}

uint8_t NRF24L01_ReadStatus(void) {
    NRF24L01_W_CSN(0);
    uint8_t Status=NRF24L01_SPI_SwapByte(NRF24L01_NOP);
    NRF24L01_W_CSN(1);
    return Status;
}

//掉电模式，只修改寄存器的其中一位，典型操作就是读改写
//读：先把整个寄存器的所有位都读出来
//改：通过位与/或来改某一位
//写：把改好的整体寄存器的值再写进去
void NRF24L01_PowerDown(void) {
    uint8_t Config;
    NRF24L01_W_CE(0);
    Config=NRF24L01_ReadReg(NRF24L01_CONFIG);
    Config &= ~0x02;
    NRF24L01_WriteReg(NRF24L01_CONFIG, Config);
}

void NRF24L01_StandbyI(void) {
    uint8_t Config;
    NRF24L01_W_CE(0);
    Config=NRF24L01_ReadReg(NRF24L01_CONFIG);
    Config |= 0x02;
    NRF24L01_WriteReg(NRF24L01_CONFIG, Config);
}

void NRF24L01_RxMode(void) {
    uint8_t Config;
    NRF24L01_W_CE(0);
    Config=NRF24L01_ReadReg(NRF24L01_CONFIG);
    Config |= 0x03;
    NRF24L01_WriteReg(NRF24L01_CONFIG, Config);
    NRF24L01_W_CE(1);
}

void NRF24L01_TxMode(void) {
    uint8_t Config;
    NRF24L01_W_CE(0);
    Config=NRF24L01_ReadReg(NRF24L01_CONFIG);
    Config |= 0x02;
    Config &= ~0x01;
    NRF24L01_WriteReg(NRF24L01_CONFIG, Config);
    NRF24L01_W_CE(1);
}

void NRF24L01_Init(void) {
    NRF24L01_GPIO_Init();
    /*初始化配置一系列寄存器*/
    NRF24L01_WriteReg(NRF24L01_CONFIG,0x08);//配置寄存器，不屏蔽中断，使能CRC，CRC为1字节，PWR_UP=0,PRIM_Rx=0
    NRF24L01_WriteReg(NRF24L01_EN_AA,0x3F);
    NRF24L01_WriteReg(NRF24L01_EN_RXADDR,0x01);
    NRF24L01_WriteReg(NRF24L01_SETUP_AW,0x03);
    NRF24L01_WriteReg(NRF24L01_RF_CH,0x02);
    NRF24L01_WriteReg(NRF24L01_RF_SETUP,0x0E);

    NRF24L01_WriteReg(NRF24L01_RX_PW_P0,NRF24L01_RX_PACKET_WIDTH);
    NRF24L01_WriteRegs(NRF24L01_RX_ADDR_P0, NRF24L01_RxAddress, 5);

    NRF24L01_Flush_TX();
    NRF24L01_Flush_RX();

    /*给状态寄存器的位4（MAX_RT）、位5（TX_DS）和位6（RX_DR）写1，清标志位*/
    NRF24L01_WriteReg(NRF24L01_STATUS, 0x70);

    //初始化完成，芯片默认进入接收模式
    NRF24L01_RxMode();
}

uint8_t NRF24L01_Send(void) {
    uint8_t Status;
    uint8_t SendFlag;
    uint32_t TimeOut;
    NRF24L01_WriteRegs(NRF24L01_TX_ADDR, NRF24L01_TxAddress, 5);
    NRF24L01_WriteRegs(NRF24L01_RX_ADDR_P0, NRF24L01_TxAddress, 5);
    NRF24L01_WriteTXPayload(NRF24L01_TxPacket,NRF24L01_TX_PACKET_WIDTH);
    NRF24L01_TxMode();

    //循环读取状态寄存器
    TimeOut=10000;
    while (1) {
        Status=NRF24L01_ReadStatus();
        TimeOut--;
        if (TimeOut == 0)			//如果计次减至0
        {
            SendFlag = 4;			//发送超时，置标志位为4
            NRF24L01_Init();		//发送出错，重新初始化一次设备，这样有助于设备从错误中恢复正常
            break;					//跳出循环
        }

        if ((Status & 0x30) == 0x30)		//状态寄存器位4（MAX_RT）和位5（TX_DS）同时为1
        {
            SendFlag = 3;			//状态寄存器的值不合法，置标志位为3
            NRF24L01_Init();		//发送出错，重新初始化一次设备，这样有助于设备从错误中恢复正常
            break;					//跳出循环
        }
        else if ((Status & 0x10) == 0x10)	//状态寄存器位4（MAX_RT）为1
        {
            SendFlag = 2;			//达到了最大重发次数仍未收到应答，置标志位为2
            NRF24L01_Init();		//发送出错，重新初始化一次设备，这样有助于设备从错误中恢复正常
            break;					//跳出循环
        }

        else if ((Status & 0x20) == 0x20)	//状态寄存器位5（TX_DS）为1
        {
            SendFlag = 1;			//发送成功，无错误，置标志位为1
            break;					//跳出循环
        }
    }

    NRF24L01_WriteReg(NRF24L01_STATUS,0x30);
    NRF24L01_Flush_TX();

    //发送完成后，恢复接收通道0原来的地址
    NRF24L01_WriteRegs(NRF24L01_RX_ADDR_P0,NRF24L01_RxAddress,5);

    //发送完成后，芯片恢复接收模式
    NRF24L01_RxMode();
    return SendFlag;
}

uint8_t NRF24L01_Receive(void) {
    uint8_t Status, Config;
    uint8_t ReceiveFlag;

    /*读取状态寄存器，保存至Status变量*/
    Status = NRF24L01_ReadStatus();

    /*读取配置寄存器，保存至Config变量*/
    Config = NRF24L01_ReadReg(NRF24L01_CONFIG);

    /*根据配置寄存器和状态寄存器的值，判断接收状态*/
    if ((Config & 0x02) == 0x00)		//配置寄存器位1（PWR_UP）为0
    {
        ReceiveFlag = 3;				//设备仍处于掉电模式，置标志位为3
        NRF24L01_Init();				//接收出错，重新初始化一次设备，这样有助于设备从错误中恢复正常
    }
    else if ((Status & 0x30) == 0x30)	//状态寄存器位4（MAX_RT）和位5（TX_DS）同时为1
    {
        ReceiveFlag = 2;				//状态寄存器的值不合法，置标志位为2
        NRF24L01_Init();				//接收出错，重新初始化一次设备，这样有助于设备从错误中恢复正常
    }
    else if ((Status & 0x40) == 0x40)	//状态寄存器位6（RX_DR）为1,这是想要的状态
    {
        ReceiveFlag=1;
        NRF24L01_ReadRXPayload(NRF24L01_RxPacket,NRF24L01_RX_PACKET_WIDTH);
        NRF24L01_WriteReg(NRF24L01_STATUS,0x40);
        NRF24L01_Flush_RX();
    }
    else
    {
        ReceiveFlag = 0;				//未接收到数据，置标志位为0
    }
    return ReceiveFlag;
}

NRF24L01.h

#ifndef BIAOZHUNCESHI_NRF24L01_H
#define BIAOZHUNCESHI_NRF24L01_H
#include "stm32f10x.h"

#define NRF24L01_TX_PACKET_WIDTH 4
extern uint8_t NRF24L01_TxPacket[NRF24L01_TX_PACKET_WIDTH];
//接收部分

#define NRF24L01_RX_PACKET_WIDTH 4
extern uint8_t NRF24L01_RxPacket[NRF24L01_RX_PACKET_WIDTH];

void NRF24L01_W_CE(uint8_t BitValue);
void NRF24L01_W_CSN(uint8_t BitValue);
void NRF24L01_W_SCK(uint8_t BitValue);
void NRF24L01_W_M0SI(uint8_t BitValue);
uint8_t NRF24L01_R_MISO(uint8_t BitValue);
void NRF24L01_GPIO_Init(void);
uint8_t NRF24L01_SPI_SwapByte(uint8_t Byte);
uint8_t NRF24L01_ReadReg(uint8_t RegAddress);
void NRF24L01_WriteReg(uint8_t RegAddress, uint8_t Data);
void NRF24L01_WriteRegs(uint8_t RegAddress, uint8_t *DataArray, uint8_t Count);
void NRF24L01_ReadRegs(uint8_t RegAddress, uint8_t *DataArray, uint8_t Count);
uint8_t NRF24L01_ReadReg(uint8_t RegAddress);
void NRF24L01_WriteTXPayload(uint8_t *DataArray, uint8_t Count);
void NRF24L01_ReadRXPayload(uint8_t *DataArray, uint8_t Count);
void NRF24L01_Flush_TX(void);
void NRF24L01_Flush_RX(void);
uint8_t NRF24L01_ReadStatus(void);
void NRF24L01_PowerDown(void);
void NRF24L01_StandbyI(void);
void NRF24L01_RxMode(void);
void NRF24L01_TxMode(void);
void NRF24L01_Init(void);
uint8_t NRF24L01_Send(void);
uint8_t NRF24L01_Receive(void);

#endif //BIAOZHUNCESHI_NRF24L01_H

NRF24L01_Define.h

#ifndef BIAOZHUNCESHI_NRF24L01_DEFINE_H
#define BIAOZHUNCESHI_NRF24L01_DEFINE_H

#ifndef __NRF24L01_DEFINE_H
#define __NRF24L01_DEFINE_H

/*NRF24L01指令宏定义*/
#define NRF24L01_R_REGISTER			0x00	//读寄存器，高3位为指令码，低5位为寄存器地址，后续跟1~5字节读数据
#define NRF24L01_W_REGISTER			0x20	//写寄存器，高3位为指令码，低5位为寄存器地址，后续跟1~5字节写数据
#define NRF24L01_R_RX_PAYLOAD		0x61	//读Rx有效载荷，后续跟1~32字节读数据
#define NRF24L01_W_TX_PAYLOAD		0xA0	//写Tx有效载荷，后续跟1~32字节写数据
#define NRF24L01_FLUSH_TX			0xE1	//清空Tx FIFO所有数据，单独指令
#define NRF24L01_FLUSH_RX			0xE2	//清空Rx FIFO所有数据，单独指令
#define NRF24L01_REUSE_TX_PL		0xE3	//重新使用最后一次发送的有效载荷，单独指令
#define NRF24L01_R_RX_PL_WID		0x60	//读取Rx FIFO最前面一个数据包的宽度，后续跟1字节读数据，仅适用于动态包长模式
#define NRF24L01_W_ACK_PAYLOAD		0xA8	//写应答附带的有效载荷，高5位为指令码，低3位为通道号，后续跟1~32字节写数据，仅适用于应答附带载荷模式
#define NRF24L01_W_TX_PAYLOAD_NOACK	0xB0	//写Tx有效载荷，不要求应答，后续跟1~32字节写数据，仅适用于不要求应答模式
#define NRF24L01_NOP				0xFF	//空操作，单独指令，可以用读取状态寄存器

/*NRF24L01寄存器地址宏定义*/
#define NRF24L01_CONFIG				0x00	//配置寄存器，1字节
#define NRF24L01_EN_AA				0x01	//使能自动应答，1字节
#define NRF24L01_EN_RXADDR			0x02	//使能接收通道，1字节
#define NRF24L01_SETUP_AW			0x03	//设置地址宽度，1字节
#define NRF24L01_SETUP_RETR			0x04	//设置自动重传，1字节
#define NRF24L01_RF_CH				0x05	//射频通道，1字节
#define NRF24L01_RF_SETUP			0x06	//射频相关参数设置，1字节
#define NRF24L01_STATUS				0x07	//状态寄存器，1字节
#define NRF24L01_OBSERVE_TX			0x08	//发送观察寄存器，1字节
#define NRF24L01_RPD				0x09	//接收功率检测，1字节
#define NRF24L01_RX_ADDR_P0			0x0A	//接收通道0地址，5字节
#define NRF24L01_RX_ADDR_P1			0x0B	//接收通道1地址，5字节
#define NRF24L01_RX_ADDR_P2			0x0C	//接收通道2地址，1字节，高位地址与接收通道1相同
#define NRF24L01_RX_ADDR_P3			0x0D	//接收通道3地址，1字节，高位地址与接收通道1相同
#define NRF24L01_RX_ADDR_P4			0x0E	//接收通道4地址，1字节，高位地址与接收通道1相同
#define NRF24L01_RX_ADDR_P5			0x0F	//接收通道5地址，1字节，高位地址与接收通道1相同
#define NRF24L01_TX_ADDR			0x10	//发送地址，5字节
#define NRF24L01_RX_PW_P0			0x11	//接收通道0有效载荷数据宽度，1字节
#define NRF24L01_RX_PW_P1			0x12	//接收通道1有效载荷的数据宽度，1字节
#define NRF24L01_RX_PW_P2			0x13	//接收通道2有效载荷的数据宽度，1字节
#define NRF24L01_RX_PW_P3			0x14	//接收通道3有效载荷的数据宽度，1字节
#define NRF24L01_RX_PW_P4			0x15	//接收通道4有效载荷的数据宽度，1字节
#define NRF24L01_RX_PW_P5			0x16	//接收通道5有效载荷的数据宽度，1字节
#define NRF24L01_FIFO_STATUS		0x17	//发送和接收FIFO状态，1字节
#define NRF24L01_DYNPD				0x1C	//使能接收通道的动态包长模式，1字节
#define NRF24L01_FEATURE			0x1D	//使能高级功能，1字节

#endif

#endif //BIAOZHUNCESHI_NRF24L01_DEFINE_H

main.c

#include "stm32f10x.h"                  // Device header
#include "Delay.h"
#include "OLED.h"
#include "Key.h"
#include "NRF24L01.h"
#include "NRF24L01_Define.h"

uint8_t KeyNum;
uint8_t SendFlag; //发送标志位
uint8_t SendSuccessCount,SendFailedCount; //发送成功计次，发送失败计次

uint8_t ReceiveFlag; //接收标志位
uint8_t ReceiveSuccessCount,ReceiveFailedCount; //接收成功计次，接收失败计次

int main(void)
{
    Key_Init();
    OLED_Init();
    NRF24L01_Init();

    OLED_ShowString(1,1,"TX:000-000-0");
    OLED_ShowString(3,1,"RX:000-000-0");

    /*初始化测试数据，此处值为任意设定，便于观察实验现象*/
    NRF24L01_TxPacket[0] = 0x00;
    NRF24L01_TxPacket[1] = 0x01;
    NRF24L01_TxPacket[2] = 0x02;
    NRF24L01_TxPacket[3] = 0x03;

    while (1)
    {
        if (Key_GetNum() == 1) {
            NRF24L01_TxPacket[0] ++;
            NRF24L01_TxPacket[1] ++;
            NRF24L01_TxPacket[2] ++;
            NRF24L01_TxPacket[3] ++;

            SendFlag=NRF24L01_Send();
            if (SendFlag==1) {
                SendSuccessCount++;
            }
            else {
                SendFailedCount++;
            }
            OLED_ShowNum(1, 3, SendSuccessCount, 3);	//显示发送成功次数
            OLED_ShowNum(1, 7, SendFailedCount, 3);		//显示发送失败次数
            OLED_ShowNum(1, 11, SendFlag, 1);			//显示最近一次的发送标志位

            /*显示发送数据*/
            OLED_ShowHexNum(2, 1, NRF24L01_TxPacket[0], 2);
            OLED_ShowHexNum(2, 4, NRF24L01_TxPacket[1], 2);
            OLED_ShowHexNum(2, 7, NRF24L01_TxPacket[2], 2);
            OLED_ShowHexNum(2, 10, NRF24L01_TxPacket[3], 2);

            /*TX字符串闪烁一次，表明发送了一次数据*/
            OLED_ShowString(1, 15, "TX");
            Delay_ms(100);
            OLED_ShowString(1, 15, "  ");
        }
        ReceiveFlag = NRF24L01_Receive();
        if (ReceiveFlag) {
            if (ReceiveFlag==1) {
                ReceiveSuccessCount++;
            }
            else {
                ReceiveFailedCount++;
            }
            OLED_ShowNum(3, 3, ReceiveSuccessCount, 3);	//显示接收成功次数
            OLED_ShowNum(3, 7, ReceiveFailedCount, 3);	//显示接收失败次数
            OLED_ShowNum(3, 11, ReceiveFlag, 1);		//显示最近一次的接收标志位

            /*显示接收数据*/
            OLED_ShowHexNum(4, 1, NRF24L01_RxPacket[0], 2);
            OLED_ShowHexNum(4, 4, NRF24L01_RxPacket[1], 2);
            OLED_ShowHexNum(4, 7, NRF24L01_RxPacket[2], 2);
            OLED_ShowHexNum(4, 10, NRF24L01_RxPacket[3], 2);

            /*RX字符串闪烁一次，表明接收到了一次数据*/
            OLED_ShowString(3, 15, "RX");
            Delay_ms(100);
            OLED_ShowString(3, 15, "  ");
        }
    }
}