nrf24l01写程序

㈠ nRF24l01无线模块 程序里有个头文件：#include<api.h> 谁知道，麻烦给下。

// BYTE type definition
#ifndef _BYTE_DEF_
#define _BYTE_DEF_
typedef unsigned char BYTE;
#endif /* _BYTE_DEF_ */
// Define interface to nRF24L01
/*#ifndef _SPI_PIN_DEF_
#define _SPI_PIN_DEF_
// Define SPI pins
/*sbit SCK = P0^0; // Master Out, Slave In pin (output)
sbit MISO = P0^1; // Master In, Slave Out pin (input)
sbit MOSI = P0^2; // Serial Clock pin, (output)
sbit CSN = P0^3; // Slave Select pin, (output to CSN, nRF24L01)
// Define CE & IRQ pins
sbit CE = P0^4; // Chip Enable pin signal (output)
sbit IRQ = P0^5; // Interrupt signal, from nRF24L01 (input)
#endif*/
// Macro to read SPI Interrupt flag
//#define WAIT_SPIF (!(SPI0CN & 0x80)) // SPI interrupt flag(礐 platform dependent)
// Declare SW/HW SPI modes
//#define SW_MODE 0x00
//#define HW_MODE 0x01
// Define nRF24L01 interrupt flag's
//#define MAX_RT 0x10 // Max #of TX retrans interrupt
//#define TX_DS 0x20 // TX data sent interrupt
//#define RX_DR 0x40 // RX data received
//#define SPI_CFG 0x40 // SPI Configuration register value
//#define SPI_CTR 0x01 // SPI Control register values
//#define SPI_CLK 0x00 // SYSCLK/2*(SPI_CLK+1) == > 12MHz / 2 = 6MHz
//#define SPI0E 0x02 // SPI Enable in XBR0 register
//****************************************************************//
// SPI(nRF24L01) commands
#define READ_REG 0x00 // Define read command to register
#define WRITE_REG 0x20 // Define write command to register
#define RD_RX_PLOAD 0x61 // Define RX payload register address
#define WR_TX_PLOAD 0xA0 // Define TX payload register address
#define FLUSH_TX 0xE1 // Define flush TX register command
#define FLUSH_RX 0xE2 // Define flush RX register command
#define REUSE_TX_PL 0xE3 // Define reuse TX payload register command
#define NOP 0xFF // Define No Operation, might be used to read status register
//***************************************************//
// SPI(nRF24L01) registers(addresses)
#define CONFIG 0x00 // 'Config' register address
#define EN_AA 0x01 // 'Enable Auto Acknowledgment' register address
#define EN_RXADDR 0x02 // 'Enabled RX addresses' register address
#define SETUP_AW 0x03 // 'Setup address width' register address
#define SETUP_RETR 0x04 // 'Setup Auto. Retrans' register address
#define RF_CH 0x05 // 'RF channel' register address
#define RF_SETUP 0x06 // 'RF setup' register address
#define STATUS 0x07 // 'Status' register address
#define OBSERVE_TX 0x08 // 'Observe TX' register address
#define CD 0x09 // 'Carrier Detect' register address
#define RX_ADDR_P0 0x0A // 'RX address pipe0' register address
#define RX_ADDR_P1 0x0B // 'RX address pipe1' register address
#define RX_ADDR_P2 0x0C // 'RX address pipe2' register address
#define RX_ADDR_P3 0x0D // 'RX address pipe3' register address
#define RX_ADDR_P4 0x0E // 'RX address pipe4' register address
#define RX_ADDR_P5 0x0F // 'RX address pipe5' register address
#define TX_ADDR 0x10 // 'TX address' register address
#define RX_PW_P0 0x11 // 'RX payload width, pipe0' register address
#define RX_PW_P1 0x12 // 'RX payload width, pipe1' register address
#define RX_PW_P2 0x13 // 'RX payload width, pipe2' register address
#define RX_PW_P3 0x14 // 'RX payload width, pipe3' register address
#define RX_PW_P4 0x15 // 'RX payload width, pipe4' register address
#define RX_PW_P5 0x16 // 'RX payload width, pipe5' register address
#define FIFO_STATUS 0x17 // 'FIFO Status Register' register address
//***************************************************************//
// FUNCTION's PROTOTYPES //
/****************************************************************
void SPI_Init(BYTE Mode); // Init HW or SW SPI
BYTE SPI_RW(BYTE byte); // Single SPI read/write
BYTE SPI_Read(BYTE reg); // Read one byte from nRF24L01
BYTE SPI_RW_Reg(BYTE reg, BYTE byte); // Write one byte to register 'reg'
BYTE SPI_Write_Buf(BYTE reg, BYTE *pBuf, BYTE bytes); // Writes multiply bytes to one register
BYTE SPI_Read_Buf(BYTE reg, BYTE *pBuf, BYTE bytes); // Read multiply bytes from one register
//*****************************************************************/

㈡ NRF24L01发射与接收程序——51单片机

#include <reg52.h>
#include <intrins.h>
typedef unsigned char uchar;
typedef unsigned char uint;
//****************************************NRF24L01端口定义***************************************
sbit MISO =P1^5;
sbit MOSI =P1^4;
sbit SCK =P1^3;
sbit CE =P1^1;
sbit CSN =P1^2;
sbit IRQ =P1^6;
//************************************按键***************************************************
sbit KEY1=P2^6;
sbit KEY2=P2^5;
//************************************数码管位选*********************************************
sbit led1=P2^4;
sbit led2=P3^5;
//*********************************************NRF24L01*************************************
#define TX_ADR_WIDTH 5 // 5 uints TX address width
#define RX_ADR_WIDTH 5 // 5 uints RX address width
#define TX_PLOAD_WIDTH 20 // 20 uints TX payload
#define RX_PLOAD_WIDTH 20 // 20 uints TX payload
uint const TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01}; //本地地址
uint const RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01}; //接收地址
//***************************************NRF24L01寄存器指令*******************************************************
#define READ_REG 0x00 // 读寄存器指令
#define WRITE_REG 0x20 // 写寄存器指令
#define RD_RX_PLOAD 0x61 // 读取接收数据指令
#define WR_TX_PLOAD 0xA0 // 写待发数据指令
#define FLUSH_TX 0xE1 // 冲洗发送 FIFO指令
#define FLUSH_RX 0xE2 // 冲洗接收 FIFO指令
#define REUSE_TX_PL 0xE3 // 定义重复装载数据指令
#define NOP 0xFF // 保留
//*************************************SPI(nRF24L01)寄存器地址****************************************************
#define CONFIG 0x00 // 配置收发状态，CRC校验模式以及收发状态响应方式
#define EN_AA 0x01 // 自动应答功能设置
#define EN_RXADDR 0x02 // 可用信道设置
#define SETUP_AW 0x03 // 收发地址宽度设置
#define SETUP_RETR 0x04 // 自动重发功能设置
#define RF_CH 0x05 // 工作频率设置
#define RF_SETUP 0x06 // 发射速率、功耗功能设置
#define STATUS 0x07 // 状态寄存器
#define OBSERVE_TX 0x08 // 发送监测功能
#define CD 0x09 // 地址检测
#define RX_ADDR_P0 0x0A // 频道0接收数据地址
#define RX_ADDR_P1 0x0B // 频道1接收数据地址
#define RX_ADDR_P2 0x0C // 频道2接收数据地址
#define RX_ADDR_P3 0x0D // 频道3接收数据地址
#define RX_ADDR_P4 0x0E // 频道4接收数据地址
#define RX_ADDR_P5 0x0F // 频道5接收数据地址
#define TX_ADDR 0x10 // 发送地址寄存器
#define RX_PW_P0 0x11 // 接收频道0接收数据长度
#define RX_PW_P1 0x12 // 接收频道0接收数据长度
#define RX_PW_P2 0x13 // 接收频道0接收数据长度
#define RX_PW_P3 0x14 // 接收频道0接收数据长度
#define RX_PW_P4 0x15 // 接收频道0接收数据长度
#define RX_PW_P5 0x16 // 接收频道0接收数据长度
#define FIFO_STATUS 0x17 // FIFO栈入栈出状态寄存器设置
//**************************************************************************************
void Delay(unsigned int s);
void inerDelay_us(unsigned char n);
void init_NRF24L01(void);
uint SPI_RW(uint uchar);
uchar SPI_Read(uchar reg);
void SetRX_Mode(void);
uint SPI_RW_Reg(uchar reg, uchar value);
uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars);
uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars);
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf);
void nRF24L01_TxPacket(unsigned char * tx_buf);
//*****************************************长延时*****************************************
void Delay(unsigned int s)
{
unsigned int i;
for(i=0; i<s; i++);
for(i=0; i<s; i++);
}
//******************************************************************************************
uint bdata sta; //状态标志
sbit RX_DR =sta^6;
sbit TX_DS =sta^5;
sbit MAX_RT =sta^4;
/******************************************************************************************
/*延时函数
/******************************************************************************************/
void inerDelay_us(unsigned char n)
{
for(;n>0;n--)
_nop_();
}
//****************************************************************************************
/*NRF24L01初始化
//***************************************************************************************/
void init_NRF24L01(void)
{
inerDelay_us(100);
CE=0; // chip enable
CSN=1; // Spi disable
SCK=0; //
SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH); // 写本地地址
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // 写接收端地址
SPI_RW_Reg(WRITE_REG + EN_AA, 0x01); // 频道0自动 ACK应答允许
SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // 允许接收地址只有频道0，如果需要多频道可以参考Page21
SPI_RW_Reg(WRITE_REG + RF_CH, 0); // 设置信道工作为2.4GHZ，收发必须一致
SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为32字节
SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07); //设置发射速率为1MHZ，发射功率为最大值0dB
}
/****************************************************************************************************
/*函数：uint SPI_RW(uint uchar)
/*功能：NRF24L01的SPI写时序
/****************************************************************************************************/
uint SPI_RW(uint uchar)
{
uint bit_ctr;
for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit
{
MOSI = (uchar & 0x80); // output 'uchar', MSB to MOSI
uchar = (uchar << 1); // shift next bit into MSB..
SCK = 1; // Set SCK high..
uchar |= MISO; // capture current MISO bit
SCK = 0; // ..then set SCK low again
}
return(uchar); // return read uchar
}
/****************************************************************************************************
/*函数：uchar SPI_Read(uchar reg)
/*功能：NRF24L01的SPI时序
/****************************************************************************************************/
uchar SPI_Read(uchar reg)
{
uchar reg_val;

CSN = 0; // CSN low, initialize SPI communication...
SPI_RW(reg); // Select register to read from..
reg_val = SPI_RW(0); // ..then read registervalue
CSN = 1; // CSN high, terminate SPI communication

return(reg_val); // return register value
}
/****************************************************************************************************/
/*功能：NRF24L01读写寄存器函数
/****************************************************************************************************/
uint SPI_RW_Reg(uchar reg, uchar value)
{
uint status;

CSN = 0; // CSN low, init SPI transaction
status = SPI_RW(reg); // select register
SPI_RW(value); // ..and write value to it..
CSN = 1; // CSN high again

return(status); // return nRF24L01 status uchar
}
/****************************************************************************************************/
/*函数：uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
/*功能: 用于读数据，reg：为寄存器地址，pBuf：为待读出数据地址，uchars：读出数据的个数
/****************************************************************************************************/
uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
{
uint status,uchar_ctr;

CSN = 0; // Set CSN low, init SPI tranaction
status = SPI_RW(reg); // Select register to write to and read status uchar

for(uchar_ctr=0;uchar_ctr<uchars;uchar_ctr++)
pBuf[uchar_ctr] = SPI_RW(0); //

CSN = 1;

return(status); // return nRF24L01 status uchar
}
/*********************************************************************************************************
/*函数：uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
/*功能: 用于写数据：为寄存器地址，pBuf：为待写入数据地址，uchars：写入数据的个数
/*********************************************************************************************************/
uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
{
uint status,uchar_ctr;

CSN = 0; //SPI使能
status = SPI_RW(reg);
for(uchar_ctr=0; uchar_ctr<uchars; uchar_ctr++) //
SPI_RW(*pBuf++);
CSN = 1; //关闭SPI
return(status); //
}
/****************************************************************************************************/
/*函数：void SetRX_Mode(void)
/*功能：数据接收配置
/****************************************************************************************************/
void SetRX_Mode(void)
{
CE=0;
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f); // IRQ收发完成中断响应，16位CRC ，主接收
CE = 1;
inerDelay_us(130);
}
/******************************************************************************************************/
/*函数：unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
/*功能：数据读取后放如rx_buf接收缓冲区中
/******************************************************************************************************/
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
{
unsigned char revale=0;
sta=SPI_Read(STATUS); // 读取状态寄存其来判断数据接收状况
if(RX_DR) // 判断是否接收到数据
{
CE = 0; //SPI使能
SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
revale =1; //读取数据完成标志
}
SPI_RW_Reg(WRITE_REG+STATUS,sta); //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志
return revale;
}
/***********************************************************************************************************
/*函数：void nRF24L01_TxPacket(unsigned char * tx_buf)
/*功能：发送 tx_buf中数据
/**********************************************************************************************************/
void nRF24L01_TxPacket(unsigned char * tx_buf)
{
CE=0; //StandBy I模式
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // 装载接收端地址
SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH); // 装载数据
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e); // IRQ收发完成中断响应，16位CRC，主发送
CE=1; //置高CE，激发数据发送
inerDelay_us(10);
}
//************************************主函数************************************************************
void main(void)
{
unsigned char tf =0;
unsigned char TxBuf[20]={0}; //
unsigned char RxBuf[20]={0};
init_NRF24L01() ;
led1=1;led2=1;
P0=0x00;
TxBuf[1] = 1 ;
TxBuf[2] = 1 ;
nRF24L01_TxPacket(TxBuf); // Transmit Tx buffer data
Delay(6000);
P0=0xBF;
while(1)
{
//测试程序
}

㈢ 单片机nrf24l01无线模块程序

你好：

stc52、pic16f877a、arm9、linux驱动程序的nrf例程我都有。

根据你说的四个按键做遥控车的程序相当简单，配置好nrf后，在main函数里一直扫描键盘是否按下就行，类似如下：

然后在接收端判断为何数据，做出相应的动作即可。

希望我的回答能帮助到你。

㈣ 求NRF24L01多对一通信的程序！！！

/ *********************************发送程序************** *************************************** /
＃包括

＃包括

的typedef unsigned int类型UINT;

typedef的无符号字符型UCHAR;

＃定义TX_ADDR_WITDH / /发送地址宽度设置为5个字部分

＃定义RX_ADDR_WITDH 5 / /接收地址宽度设置为5个字节

＃定义TX_DATA_WITDH 8 / /

＃定义RX_DATA_WITDH 8

/ ******* ************************************************** *********

/ / nRF24L01的指令格式：

************************** ***************************************** /

＃定义R_REGISTER销售0X00 / /读取寄存器

＃定义W_REGISTER 0X20 / /写寄存器

＃定义R_RX_PLOAD 0x61 / /读取字节的RX FIFO数据1-32，完成读取数据时，数据将被清除，应用接收到的模式

＃DEFINE W_TX_PLOAD 0XA0 / /写TX FIFO中的数据,1-32字节写操作开始字节0传输模式

＃定义FLUSH_TX 0XE1 / /清除TX FIFO寄存器，应用于使用传输模式

＃定义FLUSH_RX 0XE2 / /清除RX FIFO寄存器，用于在接收模式

＃定义REUSE_TX_PL 0XE3 / /重新使用一包有效数据当CE为高，数据包的 BR />＃定义不断重新启动0xFF的/ / NOP无操作可以用来读取状态寄存器

/ ********************* *********************************************

/ / nRF24L01的寄存器地址

**************** ******** /

＃定义配置为0x00，/ /配置寄存器

＃定义EN_AA 0X01 / /自动响应函数存储

＃定义EN_RX_ADDR 0X02 / /接收通道启用注册

＃定义SETUP_AW 0X03 / /地址宽度设置寄存器

＃定义SETUP_RETR 0x04的/ /自动重发设置寄存器

＃定义RF_CH 0X05 / / RF信道频率设置寄存器

＃定义RF_SETUP 0X06 / / RF设置寄存器

＃定义状态为0x07 / /状态寄存器的

＃定义OBSERVE_TX 0X08 / /发送检测寄存器＃定义0X09 / / CD载波检测寄存器

＃定义RX_ADDR_P0 0X0A / /数据的通道0接收地址寄存器

＃定义RX_ADDR_P1 0X0B / /数据通道接收地址寄存器

＃定义RX_ADDR_P2 0X0C / /数据通道2接收地址寄存器

＃定义RX_ADDR_P3 0X0D / /数据的通道3接收地址寄存器

＃定义RX_ADDR_P4 0X0E通道接收地址寄存器

＃定义RX_ADDR_P5 0X0F / / /数据数据路径5 /接收地址寄存器

＃定义TX_ADDR为0x10，/ /发送地址寄存器

＃定义和RX_PW_P0 0x11 / /数据通道0的数据宽度设置寄存器

＃定义RX_PW_P1 0X12 / /数据通道1有效数据宽度设置寄存器

＃定义RX_PW_P2 0X13 / /数据通道的有效数据宽度设置寄存器

＃定义RX_PW_P3 0X14 / /数据通道3有效数据宽度设置寄存器

＃定义RX_PW_P4 0X15 / /数据通道4有效数据宽度设置寄存器＃定义RX_PW_P5 0X16 / /数据通道的有效数据宽度设置寄存器

＃定义FIFO_STATUS 0X17 / / FIFO状态寄存器

/ / *** ************************************************** ****************************

UCHAR站; / /状态变量

＃定义RX_DR（STA 0X40 ）/ /接收成功

＃定义TX_DS（站地址0x20）/ /成功发射中断标志

＃定义MAX_RT（STA 0X10）/ /转播溢出中断标志 SBIT CE = P2 ^ 0;

SBIT IRQ = P1 ^ 0;

SBIT CSN = P2 ^ 1

SBIT MOSI = P2 ^ 3;

SBIT MISO = P2 ^ 4;

SBIT SCK = P2 ^ 2;

/ / SBIT LED的= P0 ^ 0;

SBIT键= P3 ^ 2;

UCHAR代码TX_ADDR [] = {0X34，0x43，为0x10，0X10，0X01};

代码TX_BUFFER UCHAR [] = {0XFE，会将0xfd，0xFB的，0XF7，0xef，0xDF的，为0xBF，0X00};

UCHAR RX_BUFFER [RX_DATA_WITDH];

无效_delay_us（UINT）

{

UINT I，J;

（J = 0; J <X; J + +）

就（i = 0; <12 + +）;

}

无效_delay_ms（UINT）

{

UINT I，J;

（J = 0; <X; + +）<（= 0; <120; + +）;

}

/ * nRF24L01的初始化* /

无效nRF24L01_Init的（无效） /> {

CE = 0 ;/ /待机模式我

CSN = 1;

SCK = 0;

IRQ = 1;

}
> / * SPI时序函数* /

：UCHAR SPI_RW（UCHAR字节）

{

UCHAR I;

就（i = 0; <8; + +）/ / 8个字节的8位循环写

{

（字节0X80）/ /如果数据位是1

MOSI = 1 ;/ /写入nRF24L01的1

其他/ /否则，写0

MOSI = 0;

字节<< = 1 ;/ /低一个移动的最高位

SCK = 1 ;/ / SCK拉，写数据，而读一个数据

（MISO）

字节| = 0X01;

SCK = 0 ;/ / SCK低

}

;/ /返回返回字节读取一个字节 BR />}

/ * SPI写寄存器一个字节函数* /

/ * REG：寄存器地址* /

/ *值：一个字节（值）* /

UCHAR章第：UCHAR SPI_W_Reg（UCHAR值）

{

UCHAR状态;/ /返回状态

CSN = 0 ;/ / SPI片选

状态= SPI_RW（REG）; / /写寄存器地址，和读取状态

SPI_RW（值）;/ /写一个字节

CSN = 1 ;/ /

返回状态;/ /返回状态
>}

/ * SPI读字节* /

，UCHAR章第：UCHAR SPI_R_byte（）

{

UCHAR reg_value

CSN = 0 ;/ / SPI片选

SPI_RW（REG）;/ /写解决，

reg_value = SPI_RW（0）;/ /读取寄存器值

CSN = 1;

返回reg_value ;/ /返回值

读取}

/ * SPI读取RXFIFO寄存器数据* /

/ * REG：寄存器地址* /

/ * Dat_Buffer：用来保持读取数据* / / *，DLEN：数据长度* /

：UCHAR SPI_R_DBuffer（UCHAR REG，UCHAR * Dat_Buffer中，UCHAR DLEN），

UCHAR状态，我

CSN = 0 ;/ / SPI片选

= SPI_RW（REG）;/ /写状态寄存器地址，状态

就（i = 0; <DLEN，我+ +） { Dat_Buffer [I] = SPI_RW（0）;/ /存储数据

}

CSN = 1;

返回状态;

}

/ * SPI写入TXFIFO寄存器数据* /

/ * REG：写寄存器地址* /

/ * TX_Dat_Buffer：存储要发送的数据* /

/ *，DLEN：数据长度* /

UCHAR SPI_W_DBuffer（UCHAR注册UCHAR * TX_Dat_Buffer，UCHAR DLEN）

{

UCHAR状态，我

CSN = 0 ;/ / SPI片选，开始计时

状态= SPI_RW（REG）;

（I = 0; <DLEN，I + +）

{

SPI_RW的（TX_Dat_Buffer [I]） ;/ /发送数据

}

CSN = 1;

返回状态;

}

/ *设置发送模式* /

无效nRF24L01_Set_TX_Mode的（UCHAR * TX_DATA），

{

CE = 0 ;/ /待机（写寄存器之前一定要进入待机模式或掉电模式）

SPI_W_DBuffer（W_REGISTER + TX_ADDR TX_ADDR TX_ADDR_WITDH）;/ *写寄存器指令+接收节点地址+地址宽度* / SPI_W_DBuffer（W_REGISTER中+ RX_ADDR_P0 TX_ADDR，TX_ADDR_WITDH）;/ *为了接收信号的设备的答案，一样的接收通道0地址和发送地址* /

SPI_W_DBuffer（W_TX_PLOAD TX_Data的TX_DATA_WITDH）;/ *写有效数据地址+有效数据+有效的数据宽度* /

SPI_W_Reg（W_REGISTER + EN_AA 0X01的） ;/ *接收通道0的自动应答* /

SPI_W_Reg（W_REGISTER + EN_RX_ADDR，0X01）;/ *使能接收通道0 * /

SPI_W_Reg（0X0A W_REGISTER + SETUP_RETR）的;/ *自动重发，延缓美国250US +86转播10 * /

SPI_W_Reg（W_REGISTER + RF_CH，0）;/ *（2400 +40）MHZ选择RF通道0X40 * /

SPI_W_Reg（W_REGISTER + RF_SETUP 0X07） ;/ * 1Mbps的速率，发射功率：0 dBm时，低噪声放大器增益* /

SPI_W_Reg（W_REGISTER + CONFIG 0x0E的）;/ *发送模式，上电，16位CRC，CRC可以* /

CE = 1 ;/ /开始发射

_delay_ms（5）;/ * CE高水平持续时间起码10US * /

}

UCHAR的Check_Rec的（无效）

UCHAR状态;

STA = SPI_R_byte（R_REGISTER，STATUS）;

如果（RX_DR）

CE = 0; BR /> SPI_R_DBuffer（R_RX_PLOAD RX_BUFFER，RX_DATA_WITDH）的;

状态= 1;

}

SPI_W_Reg（W_REGISTER +状态，255）;返回状态

}

/ *检测应答信号* /

：UCHAR Check_Ack（无效）

{

STA = SPI_R_byte（R_REGISTER +状态）;/ *读取存储* / （TX_DS | | MAX_RT）/ *如果TX_DS或MAX_RT 1，清除中断和清晰的TX_FIFO寄存器的值* /

{ SPI_W_Reg（W_REGISTER +状态，0XFF）;

CSN = 0;

SPI_RW（FLUSH_TX）;/ *如果没有人只能一次数据，我们应该注意* /

CSN = 1;

返回0;

}

其他

返回1;

}

无效的主要（无效）

UCHAR I;

P0 = P1 = 0xff的0xff的; / /初始化IO端口

P2 = 0XFF;

P3的= 0XFF;

_delay_us（100）;

nRF24L01_Init（）;/ /每个人的初始化，而（1）

{

（主要== 0）

{/> _delay_ms（10）; />如果（按键== 0）

{

（I = 0; <TX_DATA_WITDH; + +）/ /发送数据

{

nRF24L01_Set_TX_Mode（TX_BUFFER [I]）;/ /发送数据

（Check_Ack，（））;/ /等待发送完成

/ / LED =LED;

}

}

} }

}

/ ------------------------------------- ---------接收程序--------------------------------------- ----- /

＃包括

＃包括有

＃定义UINT无符号整型

＃定义UCHAR无符号字符型 ＃定义TX_ADDR_WITDH 5 / /宽度设置发送地址字节

＃定义RX_ADDR_WITDH 5

＃定义TX_DATA_WITDH 5 8

＃定义RX_DATA_WITDH 8 <BR / / ***** ****************************************** ******* ************

/ / nRF24L01的指令格式如下：

************************ ******************************************* /

＃定义R_REGISTER 0X00 / /读取寄存器

＃定义W_REGISTER 0X20 / /写寄存器

＃定义R_RX_PLOAD 0x61 / / RX FIFO读取数据1-32字节，完整读取数据时，数据将被清除，适用于接收

＃模式定义W_TX_PLOAD 0XA0 / /写TX FIFO有效数据1-32字节，用于在发送模式

＃定义FLUSH_TX 0XE1 / /清除TX FIFO寄存器0字节开始写操作，发送模式

＃定义FLUSH_RX 0XE2 / /清除RX FIFO寄存器，用于在接收模式

＃定义REUSE_TX_PL 0XE3 / /重新使用上一包有效数据当CE为高，包被不断重新启动

＃定义NOP 0xFF的/ /空操作，可以用来读取状态寄存器

/ ****************** ************************************************ / / nRF24L01的寄存器地址

********* ******** /

＃定义的CONFIG 0X00 / /配置寄存器

ID：定义EN_AA $ 0X01 / /“自动接听”功能注册

＃定义EN_RX_ADDR 0X02 / /接收通道使能寄存器

＃定义SETUP_AW 0X03 / /地址宽度设置注册

＃定义SETUP_RETR 0x04的/ /自动重发设置寄存器

＃定义0X05 RF_CH的/ / RF信道频率设置寄存器

＃定义RF_SETUP 0X06 / / RF设置寄存器

＃定义状态的0X07 / /状态寄存器<BR /＃定义OBSERVE_TX 0X08 / /发送测试寄存器

＃定义CD 0X09 / /载波检测寄存器

＃定义RX_ADDR_P0 0X0A / /数据的通道0接收地址寄存器

＃定义RX_ADDR_P1 0X0B / /数据信道接收地址注册

＃定义RX_ADDR_P2 0X0C / /数据通道2接收地址寄存器

＃定义RX_ADDR_P3 0X0D / /数据通道3接收地址寄存器

＃定义RX_ADDR_P4 0X0E / /数据通道4接收地址寄存器

＃定义RX_ADDR_P5 0X0F / /数据信道接收地址寄存器

＃定义TX_ADDR为0x10，/ /发送地址寄存器

＃定义和RX_PW_P0 0x11 / /数据通道0有效数据宽度设置寄存器

＃定义RX_PW_P1 0X12 / /数据通道1有效数据宽度设置寄存器

＃定义RX_PW_P2 0X13 / /数据通道的有效数据宽度设置寄存器

＃定义RX_PW_P3 0X14 / /数据通道3有效数据宽度设置寄存器

＃定义RX_PW_P4 0X15 / /数据通道4有效数据宽度设置寄存器

＃定义RX_PW_P5 0X16 / /数据通道5数据宽度设置寄存器

＃定义0X17 FIFO_STATUS / / FIFO状态寄存器/> / / ********************************************** ***********************************

UCHAR STA / /状态变量
> - ＃定义RX_DR的（STA 0X40）/ /成功接收中断标志

＃定义引起TX_DS（STA地址0x20）/ /成功发射中断标志

＃定义MAX_RT的（STA 0X10 ）/ /重传溢出中断标志

SBIT CE = P2 ^ 0;

SBIT IRQ = P2 ^ 5;

SBIT CSN = P2 ^ 1; SBIT MOSI = P2 ^ 3;

SBIT MISO = P2 ^ 4;

SBIT SCK = P2 ^ 2;

SBIT LED = P3 ^ 2;

UCHAR代码TX_ADDR [ ] = {0X34，0x43，0X10，0X10，0X01};

代码TX_BUFFER UCHAR [] = {0XFE，会将0xfd，0xFB的，0XF7，0xef，0xDF的，为0xBF，0x7f的};

UCHAR RX_BUFFER [RX_DATA_WITDH

无效_delay_us（UINT）

{

UINT I，J;

（J = 0; <X; J + +）

（ I = 0; <12; + +）;

}

无效_delay_ms（UINT）

{

UINT I，J;

（J = 0 J <X; J + +）

（i = 0; <120; i + +）;

}

无效nRF24L01_Init请（无效）

{ _delay_us（2000）;

CE = 0;

CSN = 1;

SCK = 0;

IRQ = 1;

}

UCHAR SPI_RW （UCHAR字节）

{

UCHAR I;

就（i = 0; <8; + +）

（字节0x80的） BR /> MOSI = 1;

其他有

MOSI = 0;

字节<< = 1;

SCK = 1;

（MISO）如果

字节| = 0X01;

SCK = 0;

}

返回字节;

}

：UCHAR SPI_W_Reg（UCHAR章第UCHAR值）

{ UCHAR状态;

CSN = 0;

状态= SPI_RW（REG）;

SPI_RW（值）;

CSN = 1;

返回状态; />}

：UCHAR SPI_R_byte（UCHAR REG）

{

UCHAR状态;

CSN = 0;

：SPI_RW（REG）;

状态= SPI_RW（ 0）;

CSN = 1;

返回状态;

}

：UCHAR SPI_R_DBuffer（UCHAR REG，UCHAR * Dat_Buffer中，UCHAR DLEN），

{

UCHAR reg_value，I;

CSN = 0;

reg_value SPI_RW（REG）;

就（i = 0; <DLEN; + +）

{

Dat_Buffer [] = SPI_RW（0）;

}

CSN = 1;

返回reg_value，;

}

：UCHAR SPI_W_DBuffer（UCHAR章第UCHAR * TX_Dat_Buffer UCHAR DLEN）

{

的UCHAR reg_value我的 CSN = 0; reg_value = SPI_RW

就（i = 0; DLEN;我+ +）{

SPI_RW（TX_Dat_Buffer [I]）;

}

CSN = 1;

返回reg_value，;

}

无效nRF24L01_Set_RX_Mode（无效）

{

CE = 0 ;/ /待机

SPI_W_DBuffer（W_REGISTER + TX_ADDR，TX_ADDR，TX_ADDR_WITDH）;

SPI_W_DBuffer（W_REGISTER + RX_ADDR_P0，TX_ADDR TX_ADDR_WITDH）;的的ack

，

SPI_W_Reg（W_REGISTER + EN_AA，0X01）;/ / auot SPI_W_Reg（W_REGISTER + EN_RX_ADDR，0X01）;，

SPI_W_Reg（W_REGISTER + SETUP_RETR 0X0A）;

SPI_W_Reg（W_REGISTER + RX_PW_P0 RX_DATA_WITDH）;

SPI_W_Reg（W_REGISTER + RF_CH，0）;

SPI_W_Reg（W_REGISTER + RF_SETUP，为0x07）;/ /0分贝的LNA

SPI_W_Reg（W_REGISTER + CONFIG，0X0F）;

CE = 1;

_delay_ms（5）;

}

：UCHAR nRF24L01_RX_Data（无效）

{

/ / UCHAR，状态;
> STA = SPI_R_byte（R_REGISTER +状态）;

如果（RX_DR） {

CE = 0;

SPI_R_DBuffer（R_RX_PLOAD，RX_BUFFER，RX_DATA_WITDH）;

/ / P3 = RX_BUFFER [0];

SPI_W_Reg（W_REGISTER +状态，255）;

CSN = 0;

SPI_RW（FLUSH_RX）;

CSN = 1;

返回1

}

其他

返回0;

}

{ UCHAR I;

P0 = 0xff的;

P1 = 0xff的;

P2 = 0xff的;

P3 = 0xff的; /> _delay_us（1000）; /> nRF24L01_Init（）;

（而1）

{

nRF24L01_Set_RX_Mode（）;

_delay_ms（100）;

（nRF24L01_RX_Data（））

{

LED = 0;
> / / Delay_ms用来（300）;

}

其他 LED = 1;

}

}

我希望对你有所帮助，谢谢！

㈤ 求一个nrf24l01模块简易收发程序，越简单越好，只传输一个数就可以了，单向传输 恳求

#include <reg51.h>
#include <intrins.h>
#include "api.h"
/*
*This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTYT;
*
*uart:9600BPS
*
*/
/***************************************************/
#define uchar unsigned char
#define TX_ADR_WIDTH 5 // 5 bytes TX(RX) address width
#define TX_PLOAD_WIDTH 20 // 20 bytes TX payload
uchar const TX_ADDRESS[TX_ADR_WIDTH] = {0x34,0x43,0x10,0x10,0x01}; // Define a static TX address
uchar rx_buf[TX_PLOAD_WIDTH];
uchar tx_buf[TX_PLOAD_WIDTH];
uchar flag;
uchar rx_com_buffer[10];
uchar tx_com_buffer[10];
uchar i;
uchar accept_flag;
/**************************************************/
sbit CE = P1^6;
sbit CSN= P1^7;
sbit SCK= P1^4;
sbit MOSI= P1^5;
sbit MISO= P1^3;
sbit IRQ = P1^2;
sbit LED1= P3^7;
/**************************************************/
uchar bdata sta;
sbit RX_DR =sta^6;
sbit TX_DS =sta^5;
sbit MAX_RT =sta^4;
/**************************************************/

/**************************************************
Function: init_io();
Description:
flash led one time,chip enable(ready to TX or RX Mode),
Spi disable,Spi clock line init high
/**************************************************/
#define KEY 0xaa
void init_io(void)
{
CE=0; // chip enable
CSN=1; // Spi disable
SCK=0; // Spi clock line init high
}
/**************************************************/

/**************************************************
Function: Inituart();

Description:
set uart working mode
/**************************************************/
void Inituart(void)
{

SM0=0; //设置串行口工作方式为方式1。SM0=0,SM1=0为工作方式0.依次类推
SM1=1;
REN=1; //串行口接收允许。REN=0时，禁止接收。
TMOD=0x20; //定时器1工作方式2.
TH1=0xfd; //相应波特率设初值计算方法。 初值X=(256－11059200/(12*32*9600))
TL1=0xfd; //9600为你要设置的波特率。11059200为晶振频率。X的值最后要换算成16进制
TR1=1; //定时器T1开始工作,TR1=0,T1停止工作
}
/**************************************************/

/**************************************************
Function: init_int0();

Description:
enable int0 interrupt;
/**************************************************/
void init_int0(void)
{
EA=1;
EX0=1; // Enable int0 interrupt.
}
void delay_ms(unsigned int x)
{
unsigned int i,j;
i=0;
for(i=0;i<x;i++)
{
j=108;
while(j--);
}
}
/**************************************************/

/**************************************************
Function: SPI_RW();

Description:
Writes one byte to nRF24L01, and return the byte read
from nRF24L01 ring write, according to SPI protocol
/**************************************************/
uchar SPI_RW(uchar byte)
{
uchar bit_ctr;
for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit
{
MOSI = (byte & 0x80); // output 'byte', MSB to MOSI
byte = (byte << 1); // shift next bit into MSB..
SCK = 1; // Set SCK high..
byte |= MISO; // capture current MISO bit
SCK = 0; // ..then set SCK low again
}
return(byte); // return read byte
}
/**************************************************/

/**************************************************
Function: SPI_RW_Reg();

Description:
Writes value 'value' to register 'reg'
/**************************************************/
uchar SPI_RW_Reg(BYTE reg, BYTE value)
{
uchar status;
CSN = 0; // CSN low, init SPI transaction
status = SPI_RW(reg); // select register
SPI_RW(value); // ..and write value to it..
CSN = 1; // CSN high again
return(status); // return nRF24L01 status byte
}
/**************************************************/

/**************************************************
Function: SPI_Read();

Description:
Read one byte from nRF24L01 register, 'reg'
/**************************************************/
BYTE SPI_Read(BYTE reg)
{
BYTE reg_val;

CSN = 0; // CSN low, initialize SPI communication...
SPI_RW(reg); // Select register to read from..
reg_val = SPI_RW(0); // ..then read registervalue
CSN = 1; // CSN high, terminate SPI communication

return(reg_val); // return register value
}
/**************************************************/

/**************************************************
Function: SPI_Read_Buf();

Description:
Reads 'bytes' #of bytes from register 'reg'
Typically used to read RX payload, Rx/Tx address
/**************************************************/
uchar SPI_Read_Buf(BYTE reg, BYTE *pBuf, BYTE bytes)
{
uchar status,byte_ctr;

CSN = 0; // Set CSN low, init SPI tranaction
status = SPI_RW(reg); // Select register to write to and read status byte

for(byte_ctr=0;byte_ctr<bytes;byte_ctr++)
pBuf[byte_ctr] = SPI_RW(0); // Perform SPI_RW to read byte from nRF24L01

CSN = 1; // Set CSN high again

return(status); // return nRF24L01 status byte
}
/**************************************************/

/**************************************************
Function: SPI_Write_Buf();

Description:
Writes contents of buffer '*pBuf' to nRF24L01
Typically used to write TX payload, Rx/Tx address
/**************************************************/
uchar SPI_Write_Buf(BYTE reg, BYTE *pBuf, BYTE bytes)
{
uchar status,byte_ctr;

CSN = 0; // Set CSN low, init SPI tranaction
status = SPI_RW(reg); // Select register to write to and read status byte
for(byte_ctr=0; byte_ctr<bytes; byte_ctr++) // then write all byte in buffer(*pBuf)
SPI_RW(*pBuf++);
CSN = 1; // Set CSN high again
return(status); // return nRF24L01 status byte
}
/**************************************************/

/**************************************************
Function: RX_Mode();

Description:
This function initializes one nRF24L01 device to
RX Mode, set RX address, writes RX payload width,
select RF channel, datarate & LNA HCURR.
After init, CE is toggled high, which means that
this device is now ready to receive a datapacket.
/**************************************************/
void RX_Mode(void)
{
CE=0;
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // Use the same address on the RX device as the TX device

SPI_RW_Reg(WRITE_REG + EN_AA, 0x01); // Enable Auto.Ack:Pipe0
SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // Enable Pipe0
SPI_RW_Reg(WRITE_REG + RF_CH, 40); // Select RF channel 40
SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH); // Select same RX payload width as TX Payload width
SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07); // TX_PWR:0dBm, Datarate:2Mbps, LNA:HCURR
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f); // Set PWR_UP bit, enable CRC(2 bytes) & Prim:RX. RX_DR enabled..

CE = 1; // Set CE pin high to enable RX device

// This device is now ready to receive one packet of 16 bytes payload from a TX device sending to address
// '3443101001', with auto acknowledgment, retransmit count of 10, RF channel 40 and datarate = 2Mbps.

}
/**************************************************/

/**************************************************
Function: TX_Mode();

Description:
This function initializes one nRF24L01 device to
TX mode, set TX address, set RX address for auto.ack,
fill TX payload, select RF channel, datarate & TX pwr.
PWR_UP is set, CRC(2 bytes) is enabled, & PRIM:TX.

ToDo: One high pulse(>10us) on CE will now send this
packet and expext an acknowledgment from the RX device.
/**************************************************/
void TX_Mode(void)
{
CE=0;

SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH); // Writes TX_Address to nRF24L01
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // RX_Addr0 same as TX_Adr for Auto.Ack
SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH); // Writes data to TX payload

SPI_RW_Reg(WRITE_REG + EN_AA, 0x01); // Enable Auto.Ack:Pipe0
SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // Enable Pipe0
SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x1a); // 500us + 86us, 10 retrans...
SPI_RW_Reg(WRITE_REG + RF_CH, 40); // Select RF channel 40
SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07); // TX_PWR:0dBm, Datarate:2Mbps, LNA:HCURR
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e); // Set PWR_UP bit, enable CRC(2 bytes) & Prim:TX. MAX_RT & TX_DS enabled..
CE=1;

}
/**************************************************/

/**************************************************
Function: check_ACK();

Description:
check if have "Data sent TX FIFO interrupt",if TX_DS=1,
all led light and after delay 100ms all led close
/**************************************************
void check_ACK()
{
uchar test;
test=SPI_Read(READ_REG+STATUS); // read register STATUS's
test=test&0x20; // check if have Data sent TX FIFO interrupt (TX_DS=1)
if(test==0x20) // TX_DS =1
{
P0=0x00; // turn on all led
delay100(); // delay 100ms
P0=0xff;
}
}
/**************************************************/

/**************************************************
Function: TxData();

Description:
write data x to SBUF
/**************************************************/
void TxData_com(void)
{
for(i=0;i<10;i++)
{
SBUF=tx_com_buffer[i]; // write data x to SBUF
while(TI==0);
TI=0;
}
accept_flag=0;
}

void TxData (uchar x)
{
SBUF=x; // write data x to SBUF
while(TI==0);
TI=0;
}

void RxData(void)
{
if(RI) // 是否有数据到来
{
RI = 0;
rx_com_buffer[i] = SBUF; // 暂存接收到的数据
i++;
if(i>10)
{
accept_flag=1;
i=0;
}
}
}
/**************************************************/

/**************************************************
Function: CheckButtons();

Description:
check buttons ,if have press,read the key values,
turn on led and transmit it; after transmition,
if received ACK, clear TX_DS interrupt and enter RX Mode;
turn off the led
/**************************************************/
/*void CheckButtons()
{
uchar Temp,xx,Tempi;
P0=0xff;
Temp=P0&KEY; //read key value from port P0
if (Temp!=KEY)
{
delay_ms(10);
Temp=P0&KEY; // read key value from port P0
if (Temp!=KEY)
{
xx=Temp;
Tempi=Temp>>1; // Left shift 4 bits
P0=Tempi; // Turn On the led
tx_buf[0]=Tempi; // Save to tx_buf[0]
TX_Mode(); // set TX Mode and transmitting
TxData(xx); // send data to uart
//check_ACK(); // if have acknowledgment from RX device,turn on all led
SPI_RW_Reg(WRITE_REG+STATUS,SPI_Read(READ_REG+STATUS)); // clear interrupt flag(TX_DS)
delay_ms(500);
P0=0xff; // Turn off the led
RX_Mode(); // set receive mode

while((P0&KEY)!=KEY);
}
}
} */
/**************************************************/

/**************************************************
Function: main();

Description:
control all subprogrammes;
/**************************************************/
void main(void)
{
uchar ia;
init_io(); // Initialize IO port
LED1=1;
Inituart(); // initialize 232 uart
RX_Mode(); // set RX mode
while(1)
{
RxData();
if(accept_flag==1)
{
LED1=0 ;
accept_flag=0;
for(ia=0;ia<5;ia++)
{
tx_buf[ia]=tx_com_buffer[ia];
}
TX_Mode();
SPI_RW_Reg(WRITE_REG+STATUS,SPI_Read(READ_REG+STATUS)); // clear interrupt flag(TX_DS)
delay_ms(100);
LED1=1;
RX_Mode();
}
if(!IRQ)
{
sta=SPI_Read(STATUS); // read register STATUS's value
if(RX_DR) // if receive data ready (RX_DR) interrupt
{
SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer;
for(ia=0;ia<5;ia++)
{
tx_com_buffer[ia]=rx_buf[ia];
}
LED1=0;
flag=0; // set flag=0
TxData_com();
LED1=1;
}
if(MAX_RT)
{
SPI_RW_Reg(FLUSH_TX,0);
}
SPI_RW_Reg(WRITE_REG+STATUS,0xff);// clear RX_DR or TX_DS or MAX_RT interrupt flag
IRQ=1;
RX_Mode();
}
}
}

㈥ NRF24L01模块发射---接收51单片机程序

#include <reg52.h>
#include <intrins.h>

typedef unsigned char uchar;
typedef unsigned char uint;
//****************************************IO端口定义***************************************
sbit MISO =P1^4;
sbit MOSI =P1^3;// P3.2
sbit SCK =P1^2;
sbit CE =P1^0;
sbit CSN =P1^1;
sbit IRQ =P1^5;
//***********************************数码管0-9编码*******************************************
uchar seg[10]={0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f}; //0~~9段码
uchar TxBuf[32]=
{
0x01,0x02,0x03,0x4,0x05,0x06,0x07,0x08,
0x09,0x10,0x11,0x12,0x13,0x14,0x15,0x16,
0x17,0x18,0x19,0x20,0x21,0x22,0x23,0x24,
0x25,0x26,0x27,0x28,0x29,0x30,0x31,0x32,
}; //
//************************************按键**********************************************
sbit KEY1=P3^6;
sbit KEY2=P3^7;
//***********************************数码管位选**************************************************
sbit led1=P2^1;
sbit led0=P2^0;
sbit led2=P2^2;
sbit led3=P2^3;
//*********************************************NRF24L01*************************************
#define TX_ADR_WIDTH 5 // 5 uints TX address width
#define RX_ADR_WIDTH 5 // 5 uints RX address width
#define TX_PLOAD_WIDTH 32 // 20 uints TX payload
#define RX_PLOAD_WIDTH 32 // 20 uints TX payload
uint const TX_ADDRESS[TX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01}; //本地地址
uint const RX_ADDRESS[RX_ADR_WIDTH]= {0x34,0x43,0x10,0x10,0x01}; //接收地址
//***************************************NRF24L01寄存器指令*******************************************************
#define READ_REG 0x00 // 读寄存器指令
#define WRITE_REG 0x20 // 写寄存器指令
#define RD_RX_PLOAD 0x61 // 读取接收数据指令
#define WR_TX_PLOAD 0xA0 // 写待发数据指令
#define FLUSH_TX 0xE1 // 冲洗发送 FIFO指令
#define FLUSH_RX 0xE2 // 冲洗接收 FIFO指令
#define REUSE_TX_PL 0xE3 // 定义重复装载数据指令
#define NOP 0xFF // 保留
//*************************************SPI(nRF24L01)寄存器地址****************************************************
#define CONFIG 0x00 // 配置收发状态，CRC校验模式以及收发状态响应方式
#define EN_AA 0x01 // 自动应答功能设置
#define EN_RXADDR 0x02 // 可用信道设置
#define SETUP_AW 0x03 // 收发地址宽度设置
#define SETUP_RETR 0x04 // 自动重发功能设置
#define RF_CH 0x05 // 工作频率设置
#define RF_SETUP 0x06 // 发射速率、功耗功能设置
#define STATUS 0x07 // 状态寄存器
#define OBSERVE_TX 0x08 // 发送监测功能
#define CD 0x09 // 地址检测
#define RX_ADDR_P0 0x0A // 频道0接收数据地址
#define RX_ADDR_P1 0x0B // 频道1接收数据地址
#define RX_ADDR_P2 0x0C // 频道2接收数据地址
#define RX_ADDR_P3 0x0D // 频道3接收数据地址
#define RX_ADDR_P4 0x0E // 频道4接收数据地址
#define RX_ADDR_P5 0x0F // 频道5接收数据地址
#define TX_ADDR 0x10 // 发送地址寄存器
#define RX_PW_P0 0x11 // 接收频道0接收数据长度
#define RX_PW_P1 0x12 // 接收频道1接收数据长度
#define RX_PW_P2 0x13 // 接收频道2接收数据长度
#define RX_PW_P3 0x14 // 接收频道3接收数据长度
#define RX_PW_P4 0x15 // 接收频道4接收数据长度
#define RX_PW_P5 0x16 // 接收频道5接收数据长度
#define FIFO_STATUS 0x17 // FIFO栈入栈出状态寄存器设置
//**************************************************************************************
void Delay(unsigned int s);
void inerDelay_us(unsigned char n);
void init_NRF24L01(void);
uint SPI_RW(uint uchar);
uchar SPI_Read(uchar reg);
void SetRX_Mode(void);
uint SPI_RW_Reg(uchar reg, uchar value);
uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars);
uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars);
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf);
void nRF24L01_TxPacket(unsigned char * tx_buf);
//*****************************************长延时*****************************************
void Delay(unsigned int s)
{
unsigned int i;
for(i=0; i<s; i++);
for(i=0; i<s; i++);
}
//******************************************************************************************
uint bdata sta; //状态标志
sbit RX_DR =sta^6;
sbit TX_DS =sta^5;
sbit MAX_RT =sta^4;
/******************************************************************************************
/*延时函数
/******************************************************************************************/
void inerDelay_us(unsigned char n)
{
for(;n>0;n--)
_nop_();
}
//****************************************************************************************
/*NRF24L01初始化
//***************************************************************************************/
void init_NRF24L01(void)
{
inerDelay_us(100);
CE=0; // chip enable 芯片启动
CSN=1; // Spi disable 禁用spi
SCK=0; // Spi clock line init high
SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH); // 写本地地址
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH); // 写接收端地址
SPI_RW_Reg(WRITE_REG + EN_AA, 0x01); // 频道0自动 ACK应答允许
SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01); // 允许接收地址只有频道0，如果需要多频道可以参考Page21
SPI_RW_Reg(WRITE_REG + RF_CH, 0); // 设置信道工作为2.4GHZ，收发必须一致
SPI_RW_Reg(WRITE_REG + RX_PW_P0, RX_PLOAD_WIDTH); //设置接收数据长度，本次设置为32字节
SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07); //设置发射速率为1MHZ，发射功率为最大值0dB
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e); // IRQ收发完成中断响应，16位CRC，主发送

}
/*************************************************+3***************************************************
/*函数：uint SPI_RW(uint uchar)
/*功能：NRF24L01的SPI写时序
/****************************************************************************************************/
uint SPI_RW(uint uchar)
{
uint bit_ctr;
for(bit_ctr=0;bit_ctr<8;bit_ctr++) // output 8-bit
{
MOSI = (uchar & 0x80); // output 'uchar', MSB to MOSI
uchar = (uchar << 1); // shift next bit into MSB..
SCK = 1; // Set SCK high..
uchar |= MISO; // capture current MISO bit
SCK = 0; // ..then set SCK low again
}
return(uchar); // return read uchar
}
/****************************************************************************************************
/*函数：uchar SPI_Read(uchar reg)
/*功能：NRF24L01的SPI时序
/****************************************************************************************************/
uchar SPI_Read(uchar reg)
{
uchar reg_val;

CSN = 0; // CSN low, initialize SPI communication...
SPI_RW(reg); // Select register to read from..
reg_val = SPI_RW(0); // ..then read registervalue
CSN = 1; // CSN high, terminate SPI communication

return(reg_val); // return register value
}
/****************************************************************************************************/
/*功能：NRF24L01读写寄存器函数
/****************************************************************************************************/
uint SPI_RW_Reg(uchar reg, uchar value)
{
uint status;

CSN = 0; // CSN low, init SPI transaction
status = SPI_RW(reg); // select register
SPI_RW(value); // ..and write value to it..
CSN = 1; // CSN high again

return(status); // return nRF24L01 status uchar
}
/****************************************************************************************************/
/*函数：uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
/*功能: 用于读数据，reg：为寄存器地址，pBuf：为待读出数据地址，uchars：读出数据的个数
/****************************************************************************************************/
uint SPI_Read_Buf(uchar reg, uchar *pBuf, uchar uchars)
{
uint status,uchar_ctr;

CSN = 0; // Set CSN low, init SPI tranaction
status = SPI_RW(reg); // Select register to write to and read status uchar

for(uchar_ctr=0;uchar_ctr<uchars;uchar_ctr++)
pBuf[uchar_ctr] = SPI_RW(0); //

CSN = 1;

return(status); // return nRF24L01 status uchar
}
/*********************************************************************************************************
/*函数：uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
/*功能: 用于写数据：为寄存器地址，pBuf：为待写入数据地址，uchars：写入数据的个数
/*********************************************************************************************************/
uint SPI_Write_Buf(uchar reg, uchar *pBuf, uchar uchars)
{
uint status,uchar_ctr;

CSN = 0; //SPI使能
status = SPI_RW(reg);
for(uchar_ctr=0; uchar_ctr<uchars; uchar_ctr++) //
SPI_RW(*pBuf++);
CSN = 1; //关闭SPI
return(status); //
}
/****************************************************************************************************/
/*函数：void SetRX_Mode(void)
/*功能：数据接收配置
/****************************************************************************************************/
void SetRX_Mode(void)
{
CE=0;
SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f); // IRQ收发完成中断响应，16位CRC ，主接收
CE = 1;
inerDelay_us(130);
}
/******************************************************************************************************/
/*函数：unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
/*功能：数据读取后放如rx_buf接收缓冲区中
/******************************************************************************************************/
unsigned char nRF24L01_RxPacket(unsigned char* rx_buf)
{
unsigned char revale=0;
sta=SPI_Read(STATUS); // 读取状态寄存其来判断数据接收状况
if(RX_DR) // 判断是否接收到数据
{
CE = 0; //SPI使能
SPI_Read_Buf(RD_RX_PLOAD,rx_buf,TX_PLOAD_WIDTH);// read receive payload from RX_FIFO buffer
revale =1; //读取数据完成标志
}
SPI_RW_Reg(WRITE_REG+STATUS,sta); //接收到数据后RX_DR,TX_DS,MAX_PT都置高为1，通过写1来清楚中断标志
return revale;
}
/***********************************************************************************************************
/*函数：void nRF24L01_TxPacket(unsigned char * tx_buf)
/*功能：发送 tx_buf中数据
/**********************************************************************************************************/
void nRF24L01_TxPacket(unsigned char * tx_buf)
{
CE=0; //StandBy I模式
SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH); // 装载接收端地址
SPI_Write_Buf(WR_TX_PLOAD, tx_buf, TX_PLOAD_WIDTH); // 装载数据
// SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e); // IRQ收发完成中断响应，16位CRC，主发送
CE=1; //置高CE，激发数据发送
inerDelay_us(10);
}
//************************************主函数************************************************************
void main(void)
{
uchar temp =0;
init_NRF24L01() ;
led0=0;
led1=0;
led2=0;
led3=0;
P0=0x00;
nRF24L01_TxPacket(TxBuf); // Transmit Tx buffer data
Delay(6000);
P0=0xBF;
while(1)
{
if(temp<4)
{
switch(temp)
{
case 1:
P0= 0xBF;
break;
case 2:
P0= 0xf7;

break;
case 3:
P0= 0xFE;

break;
default: break;
}
}
if(temp==3)
{
temp=0;
}
nRF24L01_TxPacket(TxBuf); // Transmit Tx buffer data
Delay(20000);
SPI_RW_Reg(WRITE_REG+STATUS,0XFF);
temp++;
}

}

㈦ 求大神讲解一下写NRF24L01无线模块程序的具体步骤，

一般驱动这抄个模块的话，程序一般包括模块的初始化，主控io口初始化，因为他是spi通信协议的，所以还要有spi协议的函数，这个可以通过io口模拟时序，这个部分怎么写得看你用什么做中控了，然后就是发送函数，接收函数。这个程序我调了好久，有问题再问吧。