基于NRF24L01的无线通讯

一、 NRF24L01的 简介

　　NRF24L01无线模块，采用的芯片是 NRF24L01 ，该芯片的主要特点如下

1. 2.4G 全球开放的 ISM 频段，免许可证使用。
2. 最高工作速率 2Mbps ，高校的 GFSK 调制，抗干扰能力强。
3. 125 个可选的频道，满足多点通信和调频通信的需要。
4. 内置 CRC 检错和点对多点的通信地址控 制。
5. 低工作电压 1.9~3.6V ）。
6. 可设置自动应答，确保数 据可靠传输。

　　该芯片通过SPI 与外部 MCU 通信，最大的 SPI 速度可以达到 10Mhz 。本章我们用到的模
块是深圳云佳科技生产的 NRF24L01 ，该模块已经被很多公司大量使用，成熟度和稳定性都是
相当不错的。该模块的外形和引脚图如图 36. 1.1 所示：
　　　　

　　　　　　　　　　　　　　　　36. 1.1 NRF24L01 无线模块外观引脚图模块
VCC 脚的电压范围为 1.9~3.6V ，建议不要超过 3.6V ，否则可能烧坏模块，一般用 3.3V
电压比较合适。除了 VCC 和 GND 脚，其他引脚都 可以和 5V 单片机的 IO 口直连，正是因为其
兼容 5V 单片机的 IO ，故使用上 具有很大优势。
关于
NRF24L01 的详细介绍，请参考 NRF24L01 的技术手册。

 

二、硬件连接

硬件资源:
1,DS0(连接在PB5)
2,串口1(波特率:115200,PA9/PA10连接在板载USB转串口芯片CH340上面)
3,ALIENTEK 2.8/3.5/4.3/7寸TFTLCD模块(通过FSMC驱动,FSMC_NE4接LCD片选/A10接RS)
4,KEY0按键(连接在PE4)/KEY1按键(连接在PE3)
5,NRF24L01模块(SPI2(PB13/PB14/PB15)/IRQ(PG6)/CS(PG7)/CE(PG8)).

 

 

三、软件设计

要实现的功能：对NRF24L01模块进行初步测试，即一块带有NRF24L01无线模块的开发板按下KEY0进入接收模式，另一块带有NRF24L01无线模块的开发板按下KEY1进入发送模式，并同时在发送开发板和接收开发板上的TFTLCD上显示发送或者接收的数据。

在开发无线功能之前，我们先理清思路：

要实现NRF24L01模块==〉

要先通过MCU（即主控芯片STM32f103ZET6）和NRF24L01模块建立连接==>

SPI，通过SPI交流数据，对NRF24L01的参数进行配置==〉

配置好之后，发送的开发板才可发送数据到NRF24L01的调频器===〉

接收的开发板需要NRF24L01的解调器，转换成可被开发板识别的模拟信号

要实现以上功能，主要需要LCD、KEY、LED，USART，关键是SPI和NRF24L01

由于LCD、KEY、LED、USART的运用过于简单，这里就不啰嗦了，大家来看一下SPI函数吧！

#ifndef __SPI_H
#define __SPI_H
#include "sys.h"                                                                              
void SPI2_Init(void);             //初始化SPI口
void SPI2_SetSpeed(u8 SpeedSet); //设置SPI速度   
u8 SPI2_ReadWriteByte(u8 TxData);//SPI总线读写一个字节
#endif

#include "spi.h"

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

    RCC_APB2PeriphClockCmd(    RCC_APB2Periph_GPIOB, ENABLE );//PORTB时钟使能 (SPI2(PB13/PB14/PB15)
    RCC_APB1PeriphClockCmd(    RCC_APB1Periph_SPI2,  ENABLE );//SPI2时钟使能    ＳＰＩ２（ＳＣＫ／ＭＩＳＯ／ＭＯＳＩ） 
 
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PB13/14/15复用推挽输出 
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB

     GPIO_SetBits(GPIOB,GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);  //PB13/14/15上拉

    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_256;        //定义波特率预分频的值:波特率预分频值为256
    SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;    //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    SPI_InitStructure.SPI_CRCPolynomial = 7;    //CRC值计算的多项式
    SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
 
    SPI_Cmd(SPI2, ENABLE); //使能SPI外设
    
    SPI2_ReadWriteByte(0xff);//启动传输         
 

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

} 

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

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

spi.c里面主要是spi初始化函数void SPI2_Init(void)、spi速度设置函数void SPI2_SetSpeed(u8 SPI_BaudRatePrescaler)和spi读写函数

u8 SPI2_ReadWriteByte(u8 TxData)。其中值得注意的是，但无线通讯NRF24L01进行通讯时，要通过SPI2_SetSpeed函数把速度

降低到10MHZ以下，不然NRF24L01将无法通讯。

 

接下来是NRF24L01的函数相关介绍

#ifndef __24L01_H
#define __24L01_H               
#include "sys.h"   
   
//NRF24L01寄存器操作命令
#define NRF_READ_REG    0x00  //读配置寄存器,低5位为寄存器地址
#define NRF_WRITE_REG   0x20  //写配置寄存器,低5位为寄存器地址
#define RD_RX_PLOAD     0x61  //读RX有效数据,1~32字节
#define WR_TX_PLOAD     0xA0  //写TX有效数据,1~32字节
#define FLUSH_TX        0xE1  //清除TX FIFO寄存器.发射模式下用
#define FLUSH_RX        0xE2  //清除RX FIFO寄存器.接收模式下用
#define REUSE_TX_PL     0xE3  //重新使用上一包数据,CE为高,数据包被不断发送.
#define NOP             0xFF  //空操作,可以用来读状态寄存器     
//SPI(NRF24L01)寄存器地址
#define CONFIG          0x00  //配置寄存器地址;bit0:1接收模式,0发射模式;bit1:电选择;bit2:CRC模式;bit3:CRC使能;
                              //bit4:中断MAX_RT(达到最大重发次数中断)使能;bit5:中断TX_DS使能;bit6:中断RX_DR使能
#define EN_AA           0x01  //使能自动应答功能  bit0~5,对应通道0~5
#define EN_RXADDR       0x02  //接收地址允许,bit0~5,对应通道0~5
#define SETUP_AW        0x03  //设置地址宽度(所有数据通道):bit1,0:00,3字节;01,4字节;02,5字节;
#define SETUP_RETR      0x04  //建立自动重发;bit3:0,自动重发计数器;bit7:4,自动重发延时 250*x+86us
#define RF_CH           0x05  //RF通道,bit6:0,工作通道频率;
#define RF_SETUP        0x06  //RF寄存器;bit3:传输速率(0:1Mbps,1:2Mbps);bit2:1,发射功率;bit0:低噪声放大器增益
#define STATUS          0x07  //状态寄存器;bit0:TX FIFO满标志;bit3:1,接收数据通道号(最大:6);bit4,达到最多次重发
                              //bit5:数据发送完成中断;bit6:接收数据中断;
#define MAX_TX          0x10  //达到最大发送次数中断
#define TX_OK           0x20  //TX发送完成中断
#define RX_OK           0x40  //接收到数据中断

#define OBSERVE_TX      0x08  //发送检测寄存器,bit7:4,数据包丢失计数器;bit3:0,重发计数器
#define CD              0x09  //载波检测寄存器,bit0,载波检测;
#define RX_ADDR_P0      0x0A  //数据通道0接收地址,最大长度5个字节,低字节在前
#define RX_ADDR_P1      0x0B  //数据通道1接收地址,最大长度5个字节,低字节在前
#define RX_ADDR_P2      0x0C  //数据通道2接收地址,最低字节可设置,高字节,必须同RX_ADDR_P1[39:8]相等;
#define RX_ADDR_P3      0x0D  //数据通道3接收地址,最低字节可设置,高字节,必须同RX_ADDR_P1[39:8]相等;
#define RX_ADDR_P4      0x0E  //数据通道4接收地址,最低字节可设置,高字节,必须同RX_ADDR_P1[39:8]相等;
#define RX_ADDR_P5      0x0F  //数据通道5接收地址,最低字节可设置,高字节,必须同RX_ADDR_P1[39:8]相等;
#define TX_ADDR         0x10  //发送地址(低字节在前),ShockBurstTM模式下,RX_ADDR_P0与此地址相等
#define RX_PW_P0        0x11  //接收数据通道0有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P1        0x12  //接收数据通道1有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P2        0x13  //接收数据通道2有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P3        0x14  //接收数据通道3有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P4        0x15  //接收数据通道4有效数据宽度(1~32字节),设置为0则非法
#define RX_PW_P5        0x16  //接收数据通道5有效数据宽度(1~32字节),设置为0则非法
#define NRF_FIFO_STATUS 0x17  //FIFO状态寄存器;bit0,RX FIFO寄存器空标志;bit1,RX FIFO满标志;bit2,3,保留
                              //bit4,TX FIFO空标志;bit5,TX FIFO满标志;bit6,1,循环发送上一数据包.0,不循环;
//////////////////////////////////////////////////////////////////////////////////////////////////////////
//24L01操作线
#define NRF24L01_CE   PGout(8) //24L01片选信号
#define NRF24L01_CSN  PGout(7) //SPI片选信号       
#define NRF24L01_IRQ  PGin(6)  //IRQ主机数据输入
//24L01发送接收数据宽度定义
#define TX_ADR_WIDTH 5
#define RX_ADR_WIDTH 5
#define RD_RX_PLOAD_WIDTH 32
#define WR_TX_PLOAD_WIDTH 32
void NRF24L01_Init(void);
u8 NRF24L01_Write_Reg(u8 Reg,u8 Value);
u8 NRF24L01_Read_Reg(u8 Reg);
u8 NRF24L01_Check(void);
u8 NRF24L01_WriteBuf(u8 WriteAddr,u8* pBuf,u8 len);
u8 NRF24L01_ReadBuf(u8 ReadAddr,u8* pBuf,u8 len);

void NRF24L01_RX_Mode(void);
u8 NRF24L01_RxPacket(u8* tem_buf);
void NRF24L01_TX_Mode(void);
u8 NRF24L01_TxPacket(u8* tem_buf);
#endif

#include "spi.h"
#include "24l01.h"
const u8 TX_ADDRESS[TX_ADR_WIDTH]={0x44,0x41,0x20,0x10,0x02}; // 发送地址
const u8 RX_ADDRESS[RX_ADR_WIDTH]={0x44,0x41,0x20,0x10,0x02}; // 发送地址

void NRF24L01_Init(void)
{
    GPIO_InitTypeDef GPIO_InitType;
    SPI_InitTypeDef SPI_InitType;
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOG,ENABLE);
    
    GPIO_InitType.GPIO_Pin = GPIO_Pin_12;                                 //PB12上拉 防止W25X的干扰
     GPIO_InitType.GPIO_Mode = GPIO_Mode_Out_PP;                      //推挽输出
     GPIO_InitType.GPIO_Speed = GPIO_Speed_50MHz;
     GPIO_Init(GPIOB, &GPIO_InitType);    //初始化指定IO
     GPIO_SetBits(GPIOB,GPIO_Pin_12);//上拉
    
    GPIO_InitType.GPIO_Pin=GPIO_Pin_7|GPIO_Pin_8;　　　　　　　　//IRQ(PG6)/CS(PG7)/CE(PG8) 
    GPIO_InitType.GPIO_Mode=GPIO_Mode_Out_PP;
    GPIO_InitType.GPIO_Speed=GPIO_Speed_50MHz;
    GPIO_Init(GPIOG,&GPIO_InitType);
    
    GPIO_InitType.GPIO_Pin=GPIO_Pin_6;
    GPIO_InitType.GPIO_Mode=GPIO_Mode_IPD;
    GPIO_Init(GPIOG,&GPIO_InitType);
    GPIO_ResetBits(GPIOG,GPIO_Pin_6|GPIO_Pin_7|GPIO_Pin_8);
    
    SPI2_Init();　　　　　　　　　　　　//SPI 初始化
    SPI_Cmd(SPI2,DISABLE);
    SPI_InitType.SPI_BaudRatePrescaler=SPI_BaudRatePrescaler_16;
    SPI_InitType.SPI_CPHA=SPI_CPHA_1Edge;
    SPI_InitType.SPI_CPOL=SPI_CPOL_Low;
    SPI_InitType.SPI_CRCPolynomial=0x7;
    SPI_InitType.SPI_DataSize=SPI_DataSize_8b;
    SPI_InitType.SPI_Direction=SPI_Direction_2Lines_FullDuplex;
    SPI_InitType.SPI_FirstBit=SPI_FirstBit_MSB;
    SPI_InitType.SPI_Mode=SPI_Mode_Master;
    SPI_InitType.SPI_NSS=SPI_NSS_Soft;
    SPI_Init(SPI2,&SPI_InitType);
    SPI_Cmd(SPI2,ENABLE);
    NRF24L01_CSN=1;
    NRF24L01_CE=0;
}


//检查是否有RF24L01这个器件
//给TX_ADDR寄存器写入5个字节的地址，然后在读取TX_ADDR 寄存器的值
//比较是否各个都是0xA5,假如不是返回非0值，否则返回0（正确时）
u8 NRF24L01_Check(void)
{

    u8 i=0;
    u8 Buf[5]={0xA5,0xA5,0xA5,0xA5,0xA5};
    SPI2_SetSpeed(SPI_BaudRatePrescaler_4);
    NRF24L01_WriteBuf(NRF_WRITE_REG+TX_ADDR,Buf,5);
    NRF24L01_ReadBuf(NRF_READ_REG+TX_ADDR,Buf,5);
    for(i=0;i<5;i++)
    {
        if(Buf[i]!=0xA5) break;
    }
    if(i!=5) return 1;
    return 0;    
}




    
//给那个寄存器写入一个值
u8 NRF24L01_Write_Reg(u8 Reg,u8 Value)
{
    u8 status;
    NRF24L01_CSN=0;
    status=SPI2_ReadWriteByte(Reg);
    SPI2_ReadWriteByte(Value);
    NRF24L01_CSN=1;
    return status;
}


//从那个寄存器读取一个值
u8 NRF24L01_Read_Reg(u8 Reg)
{
    u8 reg_val;
    NRF24L01_CSN=0;
    SPI2_ReadWriteByte(Reg);
    reg_val=SPI2_ReadWriteByte(0xFF);
    NRF24L01_CSN=1;
    return reg_val;
}

//给那个寄存器写入一些数据
u8 NRF24L01_WriteBuf(u8 WriteAddr,u8* pBuf,u8 len)
{
    u8 status,i=0;
    NRF24L01_CSN=0;
    status=SPI2_ReadWriteByte(WriteAddr);
    for(i=0;i)
    {
        SPI2_ReadWriteByte(*pBuf++);
    }
    NRF24L01_CSN=1;
    return status;
}

//读取那个寄存器的一些数据
u8 NRF24L01_ReadBuf(u8 ReadAddr,u8* pBuf,u8 len)
{
    u8 status,i=0;
    NRF24L01_CSN=0;
    status=SPI2_ReadWriteByte(ReadAddr);
    for(i=0;i)
    {
        pBuf[i]=SPI2_ReadWriteByte(0xFF);
    }
    NRF24L01_CSN=1;
    return status;
}

void NRF24L01_RX_Mode(void)
{
    NRF24L01_CE=0;
    NRF24L01_WriteBuf(NRF_WRITE_REG+RX_ADDR_P0,(u8*)RX_ADDRESS,RX_ADR_WIDTH);//给接收地址写入数据
    NRF24L01_Write_Reg(NRF_WRITE_REG+EN_AA,0x01);                    //使能通道0自动应答功能
    NRF24L01_Write_Reg(NRF_WRITE_REG+EN_RXADDR,0x01);            //使能通道0地址接受允许
    NRF24L01_Write_Reg(NRF_WRITE_REG+RF_CH,0x40);                    //设置通道接受的频段（共有125个可选的频段）
    NRF24L01_Write_Reg(NRF_WRITE_REG+RX_PW_P0,RD_RX_PLOAD_WIDTH);//选择通道0的有效数据宽度
    NRF24L01_Write_Reg(NRF_WRITE_REG+RF_SETUP,0x0f);            //设置通道的发射功率及速度
    NRF24L01_Write_Reg(NRF_WRITE_REG+CONFIG,0x0f);                //屏蔽中断及模式
    NRF24L01_CE=1;

}
    

u8 NRF24L01_RxPacket(u8* tem_buf)
{
    u8 sta;
    SPI2_SetSpeed (SPI_BaudRatePrescaler_8);// 36/8=4.5Mhz
    sta=NRF24L01_Read_Reg(STATUS);                    //读取接收状态
    NRF24L01_Write_Reg(NRF_WRITE_REG+STATUS,sta);    //写入‘1’取消中断
    if(sta&RX_OK)                                                        //假如是发送完成中断，则开始接收
    {
        NRF24L01_ReadBuf(RD_RX_PLOAD,tem_buf,RD_RX_PLOAD_WIDTH);
//        while(NRF24L01_IRQ!=0);                                     //等待接收完成
        NRF24L01_Write_Reg(FLUSH_RX,0xFF);                //接收之后开始清除接收BUFF
        return 0;
    }
    return 1;
}


void NRF24L01_TX_Mode(void)
{

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

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

u8 NRF24L01_TxPacket(u8* tem_buf)
{
    u8 sta;
    SPI2_SetSpeed (SPI_BaudRatePrescaler_8);    // 4.5Mhz
    NRF24L01_CE=0;
    NRF24L01_WriteBuf(WR_TX_PLOAD,tem_buf,WR_TX_PLOAD_WIDTH);
    NRF24L01_CE=1;                                                         //启动发送
    while(NRF24L01_IRQ!=0);                                     //等待发送完成
    sta=NRF24L01_Read_Reg(STATUS);    
    NRF24L01_Write_Reg(NRF_WRITE_REG+STATUS,sta);    //读取状态值后清除发送中断或者重发超限中断
    if(sta&MAX_TX)
    {
        NRF24L01_Write_Reg(FLUSH_TX,0xFF);                    //重发次数超限，则清理发送BUFF,重新开始发送并计数
        return MAX_TX;
    }
    if(sta&TX_OK)
    {
        return TX_OK;                                                            //发送中断则返回中断标志
    }
    return 0xff;                                                                //其他情况返回错误标志0xFF
}

 

四、在ｍａｉｎ函数中的运用

#include "led.h"
#include "delay.h"
#include "key.h"
#include "sys.h"
#include "lcd.h"
#include "usart.h"     
#include "24l01.h"      
#include "math.h"
#include "string.h"
/************************************************
 ALIENTEK精英STM32开发板实验31
 MPU6050六轴传感器 实验     
 技术支持：www.openedv.com
 淘宝店铺：http://eboard.taobao.com 
 关注微信公众平台微信号："正点原子"，免费获取STM32资料。
 广州市星翼电子科技有限公司  
 作者：正点原子 @ALIENTEK
************************************************/
u8 rx_buf[32]={49,50,51,52,53,54,55,56,57,58,49,50,51,52,53,54,55,56,57,58,49,50,51,52,53,54,55,56,57,58,61,0};


 int main(void)
 {    
    u8 i=0;
    u8 key,mode;
    u16 t=0;             
    u8 tmp_buf[33];            
    delay_init();             //延时函数初始化      
    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//设置中断优先级分组为组2：2位抢占优先级，2位响应优先级
    uart_init(115200);         //串口初始化为115200
     LED_Init();                      //初始化与LED连接的硬件接口
    KEY_Init();                    //初始化按键
    LCD_Init();                       //初始化LCD  
     NRF24L01_Init();            //初始化NRF24L01 
     POINT_COLOR=RED;            //设置字体为红色 
    LCD_ShowString(30,50,200,16,16,"ELITE STM32");    
    LCD_ShowString(30,70,200,16,16,"NRF24L01 TEST");    
    LCD_ShowString(30,90,200,16,16,"ATOM@ALIENTEK");
    LCD_ShowString(30,110,200,16,16,"2015/1/17"); 
    while(NRF24L01_Check())
    {
        LCD_ShowString(30,130,200,16,16,"NRF24L01 Error");
        delay_ms(200);
        LCD_Fill(30,130,239,130+16,WHITE);
         delay_ms(200);
    }
    LCD_ShowString(30,130,200,16,16,"NRF24L01 OK");      
     while(1)
    {    
        key=KEY_Scan(0);
        if(key==KEY0_PRES)
        {
            mode=0;   
            break;
        }else if(key==KEY1_PRES)
        {
            mode=1;
            break;
        }
        t++;
        if(t==100)LCD_ShowString(10,150,230,16,16,"KEY0:RX_Mode  KEY1:TX_Mode"); //闪烁显示提示信息
         if(t==200)
        {    
            LCD_Fill(10,150,230,150+16,WHITE);
            t=0; 
        }
        delay_ms(5);      
    }   
     LCD_Fill(10,150,240,166,WHITE);//清空上面的显示          
     POINT_COLOR=BLUE;//设置字体为蓝色       
    if(mode==0)//RX模式
    {
        LCD_ShowString(30,150,200,16,16,"NRF24L01 RX_Mode");    
        LCD_ShowString(30,170,200,16,16,"Received DATA:");    
        NRF24L01_RX_Mode();          
        while(1)
        {                                               
            if(NRF24L01_RxPacket(rx_buf)==0)//一旦接收到信息,则显示出来.
            {
                LCD_ShowString(0,190,lcddev.width-1,32,16,rx_buf); //接收到数据就在LCD上显示出来
                delay_ms(500);                                                                            //半秒之后清除接收到的数据
                memset(rx_buf,0,32);
                break;                                                                                        //跳出循环体
            }else delay_us(100);                                               //接收失败，延时100us
            t++;
            if(t==10000)//大约1s钟改变一次状态
            {
                t=0;
                LED0=!LED0;
            }                     
        };    

    }else//TX模式
    {                                
        LCD_ShowString(30,150,200,16,16,"NRF24L01 TX_Mode");    
        NRF24L01_TX_Mode();
        mode=' ';//从空格键开始  
        while(1)
        {                                  
            if(NRF24L01_TxPacket(rx_buf)==TX_OK)                    //发送成功
            {
                
                LCD_ShowString(30,170,239,32,16,"Sended DATA:");        //显示发送的数据
                LCD_ShowString(0,190,lcddev.width-1,32,16,rx_buf);
                delay_ms(500);                                                                            //延时500ms
                i++;
                printf("TXText%d",i);                                                                //串口1调试用，可看出本次是第几次发送
                break;
                
            }else
            {                                               
                 LCD_Fill(0,170,lcddev.width,170+16*3,WHITE);//清空显示               
                LCD_ShowString(30,170,lcddev.width-1,32,16,"Send Failed "); 
            };
            LED0=!LED0;
            delay_ms(1500);                    
        };
    } 
}

调试过程中，出现问题：

按下ＫＥＹ０按键可进入接收模式，按下ＫＥＹ１按键可进入发送模式，可是前两次进入发送模式之后，ｂｒｅａｋ可打破ｗｈｉｌｅ（１）发送循环体，使发送完数据就退出发送循环函数，怎么第３次就退不出来了？

留待以后思考：

现在，我觉得主要是不是ｂｒｅａｋ不能打破并离开循环体呢？可是前面２次都可以通过ｂｒｅａｋ离开循环体，这就奇怪了。