【送70块板卡】“中秋芯礼”开发板大放送

eefocus_3840188

做音频播放的时候，出现杂音，排查DMA需要使用无缓存内存以及时刷新。

wakojosin

rt_pin_mode(LED1, PIN_MODE_OUTPUT);
while(1)
{
rt_pin_write(LED1, PIN_HIGH);
rt_thread_mdelay(500);
rt_pin_write(LED1, PIN_LOW);
rt_thread_mdelay(500);
}

eefocus_3891719

亲测，MCUXpresso IDE 编译出来的 hex 文件，经 Teensy loader 下载到开发板也可以运行。
即 Teensy4.1 的开发方式除了 Arduino IDE, 也可以用 MUCXpresso IDE 进行开发，只是不能在线调试。

yinwuqing

国庆节即将到来，出行堵车是常态，如果新能源汽车途中再遇上电量不足，那就糟心了。想开发一个支持DRP的PD快充设备，既能支持太阳能充电，又能支持车标接口充电、并且当车电量不足时，可以给车快速充电，应急储能。

suncat0504

控制NRF24L01发送的代码：

#include "NRF24l01.h"
#include "delay.h"
#include "spi.h"

// 物理地址5字节，只有物理地址一致的两个无限卡才能实现通讯
const u8 TX_ADDRESS[TX_ADR_WIDTH]={'w', 'h', 'j', '0', '0'}; //发送地址
const u8 RX_ADDRESS[RX_ADR_WIDTH]={'w', 'h', 'j', '0', '0'}; //接收地址

//NRF24L01 驱动函数

unsigned char idel_mode_flag = 0;
unsigned char mode_time_counter = 0;



//初始化24L01的IO口
void NRF24L01_Init(void)
{
        GPIO_InitTypeDef GPIO_InitStructure;
        RCC_APB2PeriphClockCmd(RCC_NRF24L01_CE, ENABLE);    //使能GPIO的时钟
    GPIO_InitStructure.GPIO_Pin = NRF24L01_CE;          //NRF24L01 模块片选信号
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    //推挽输出
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIO_NRF24L01_CE, &GPIO_InitStructure);

        RCC_APB2PeriphClockCmd(RCC_NRF24L01_CSN, ENABLE);   //使能GPIO的时钟
    GPIO_InitStructure.GPIO_Pin = NRF24L01_CSN;      
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;    //推挽输出
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIO_NRF24L01_CSN, &GPIO_InitStructure);
       
        Set_NRF24L01_CE;                                    //初始化时先拉高
    Set_NRF24L01_CSN;                                   //初始化时先拉高

    //配置NRF2401的IRQ
        GPIO_InitStructure.GPIO_Pin = NRF24L01_IRQ;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU  ;     //上拉输入
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
        GPIO_Init(GPIO_NRF24L01_IRQ, &GPIO_InitStructure);
        GPIO_SetBits(GPIO_NRF24L01_IRQ,NRF24L01_IRQ);

        WIRELESS_SPI_Init();                                //初始化SPI
        Clr_NRF24L01_CE;                                         //使能24L01
        Set_NRF24L01_CSN;                                   //SPI片选取消
}
//上电检测NRF24L01是否在位
//写5个数据然后再读回来进行比较，
//相同时返回值:0，表示在位;否则返回1，表示不在位       
u8 NRF24L01_Check(void)
{
        u8 buf[5]={0XA5,0XA5,0XA5,0XA5,0XA5};
        u8 buf1[5];
        u8 i;            
    for (i=0; i<5; i++) {
        buf[i]=TX_ADDRESS[i];
    }
        NRF24L01_Write_Buf(SPI_WRITE_REG+TX_ADDR, buf, 5);//写入5个字节的地址.       
        NRF24L01_Read_Buf(TX_ADDR, buf1, 5);              //读出写入的地址         
        for(i=0;i<5;i++) {
        if(buf1[i]!=buf[i]) {
            break;               
        }
    }        
        if(i!=5)return 1;                               //NRF24L01不在位       
        return 0;                                                //NRF24L01在位
}                  
//通过SPI写寄存器
u8 NRF24L01_Write_Reg(u8 regaddr,u8 data)
{
        u8 status;       
    Clr_NRF24L01_CSN;                    //使能SPI传输
          status =SPI_ReadWriteByte(regaddr); //发送寄存器号
          SPI_ReadWriteByte(data);            //写入寄存器的值
          Set_NRF24L01_CSN;                    //禁止SPI传输          
          return(status);                                //返回状态值
}
//读取SPI寄存器值 ，regaddr:要读的寄存器
u8 NRF24L01_Read_Reg(u8 regaddr)
{
        u8 reg_val;            
        Clr_NRF24L01_CSN;                //使能SPI传输               
          SPI_ReadWriteByte(regaddr);     //发送寄存器号
          reg_val=SPI_ReadWriteByte(0XFF);//读取寄存器内容
          Set_NRF24L01_CSN;                //禁止SPI传输                    
          return(reg_val);                 //返回状态值
}       
//在指定位置读出指定长度的数据
//*pBuf:数据指针
//返回值,此次读到的状态寄存器值
u8 NRF24L01_Read_Buf(u8 regaddr,u8 *pBuf,u8 datalen)
{
        u8 status,u8_ctr;               
          Clr_NRF24L01_CSN;                     //使能SPI传输
          status=SPI_ReadWriteByte(regaddr);   //发送寄存器值(位置),并读取状态值             
        for(u8_ctr=0;u8_ctr<datalen;u8_ctr++)pBuf[u8_ctr]=SPI_ReadWriteByte(0XFF);//读出数据
          Set_NRF24L01_CSN;                     //关闭SPI传输
          return status;                        //返回读到的状态值
}
//在指定位置写指定长度的数据
//*pBuf:数据指针
//返回值,此次读到的状态寄存器值
u8 NRF24L01_Write_Buf(u8 regaddr, u8 *pBuf, u8 datalen)
{
        u8 status,u8_ctr;            
        Clr_NRF24L01_CSN;                                    //使能SPI传输
          status = SPI_ReadWriteByte(regaddr);                //发送寄存器值(位置),并读取状态值
          for(u8_ctr=0; u8_ctr<datalen; u8_ctr++) SPI_ReadWriteByte(*pBuf++); //写入数据         
          Set_NRF24L01_CSN;                                    //关闭SPI传输
          return status;                                       //返回读到的状态值
}                                  
//启动NRF24L01发送一次数据
//txbuf:待发送数据首地址
//返回值:发送完成状况
u8 NRF24L01_TxPacket(u8 *txbuf) {
        u8 state, i;   

    // 输出到串口
    printf("Sent data:");
    for (i=0;i<TX_PLOAD_WIDTH;i++) {
        printf("%2x ", txbuf[i]);
    }
    printf("\n\r");
   
        Clr_NRF24L01_CE;
          NRF24L01_Write_Buf(WR_TX_PLOAD,txbuf,TX_PLOAD_WIDTH);//写数据到TX BUF  32个字节
        Set_NRF24L01_CE;                                     //启动发送          
        while(READ_NRF24L01_IRQ!=0);                         //等待发送完成
        state=NRF24L01_Read_Reg(STATUS);                     //读取状态寄存器的值          
        NRF24L01_Write_Reg(SPI_WRITE_REG+STATUS,state);      //清除TX_DS或MAX_RT中断标志
        if(state&MAX_TX)                                     //达到最大重发次数
        {
                NRF24L01_Write_Reg(FLUSH_TX,0xff);               //清除TX FIFO寄存器
                return MAX_TX;
        }
        if(state&TX_OK)                                      //发送完成
        {
        NRF24L01_Write_Reg(FLUSH_TX,0xff);               //清除TX FIFO寄存器
                return TX_OK;
        }
        return 0xff;                                         //其他原因发送失败
}

//启动NRF24L01接收一次数据
//rxbuf:待接收数据首地址
//返回值:0，接收完成；其他，错误代码
u8 NRF24L01_RxPacket(u8 *rxbuf) {
        u8 state, i;                  
   
        state=NRF24L01_Read_Reg(STATUS);                //读取状态寄存器的值             
        NRF24L01_Write_Reg(SPI_WRITE_REG+STATUS,state); //清除TX_DS或MAX_RT中断标志
        if(state&RX_OK)                                 //接收到数据
        {
                NRF24L01_Read_Buf(RD_RX_PLOAD,rxbuf,RX_PLOAD_WIDTH);//读取数据
                NRF24L01_Write_Reg(FLUSH_RX,0xff);          //清除RX FIFO寄存器
        
        // 输出到串口
        printf("Received data::");
        for (i=0;i<TX_PLOAD_WIDTH;i++) {
            printf("%2x ", rxbuf[i]);
        }
        printf("\n\r");
        
        
                return 0;
        }          
        return 1;                                      //没收到任何数据
}

//该函数初始化NRF24L01到RX模式
//设置RX地址,写RX数据宽度,选择RF频道,波特率和LNA HCURR
//当CE变高后,即进入RX模式,并可以接收数据了                  
void RX_Mode(u8 offset) {
    u8  addr[RX_ADR_WIDTH],i;
    for (i=0;i<RX_ADR_WIDTH;i++) {
        addr[i]=RX_ADDRESS[i];
    }
    // 根据预设子机地址，重新设定主机无线模块地址
    addr[RX_ADR_WIDTH-2]=offset/10 + addr[RX_ADR_WIDTH-2];
    addr[RX_ADR_WIDTH-1]=offset%10 + addr[RX_ADR_WIDTH-1];
   
        Clr_NRF24L01_CE;          
    //写RX节点地址
          NRF24L01_Write_Buf(SPI_WRITE_REG+RX_ADDR_P0,(u8*)addr, RX_ADR_WIDTH);

    // 自动应答
          NRF24L01_Write_Reg(SPI_WRITE_REG+EN_AA,0x01);

     //使能通道0的接收地址           
          NRF24L01_Write_Reg(SPI_WRITE_REG+EN_RXADDR,0x01);
   
    //设置RF通信频率                  
          NRF24L01_Write_Reg(SPI_WRITE_REG+RF_CH,40);
   
    //选择通道0的有效数据宽度             
          NRF24L01_Write_Reg(SPI_WRITE_REG+RX_PW_P0,RX_PLOAD_WIDTH);
   
    //设置TX发射参数,0db增益,2Mbps,低噪声增益开启   
          NRF24L01_Write_Reg(SPI_WRITE_REG+RF_SETUP,0x0f);
   
    //配置基本工作模式的参数WR_UP,EN_CRC,16BIT_CRC,PRIM_RX接收模式
          NRF24L01_Write_Reg(SPI_WRITE_REG+CONFIG, 0x0f);
   
    //CE为高,进入接收模式
          Set_NRF24L01_CE;                                
}                       

//该函数初始化NRF24L01到TX模式
//设置TX地址,写TX数据宽度,设置RX自动应答的地址,填充TX发送数据,
//选择RF频道,波特率和LNA HCURR PWR_UP,CRC使能
//当CE变高后,即进入RX模式,并可以接收数据了                  
//CE为高大于10us,则启动发送.         
void TX_Mode(u8 offset) {       
    u8  addr[TX_ADR_WIDTH],i;
    // 根据预设子机地址，重新设定主机无线模块地址
    for (i=0;i<TX_ADR_WIDTH;i++) {
        addr[i]=TX_ADDRESS[i];
    }
    addr[TX_ADR_WIDTH-2]=offset/10 + addr[TX_ADR_WIDTH-2];
    addr[TX_ADR_WIDTH-1]=offset%10 + addr[TX_ADR_WIDTH-1];
   
    // 输出到串口
    printf("Target sub-device address:");
    for (i=0;i<TX_ADR_WIDTH;i++) {
        printf("%2x ", addr[i]);
    }
    printf("\n\r");

        Clr_NRF24L01_CE;            
    //写TX节点地址
          NRF24L01_Write_Buf(SPI_WRITE_REG+TX_ADDR,(u8*)addr,TX_ADR_WIDTH);
   
    //设置TX节点地址,主要为了使能ACK          
          NRF24L01_Write_Buf(SPI_WRITE_REG+RX_ADDR_P0,(u8*)addr, RX_ADR_WIDTH);

    //使能通道0的自动应答   
          NRF24L01_Write_Reg(SPI_WRITE_REG+EN_AA,0x01);  
    //NRF24L01_Write_Reg(SPI_WRITE_REG+EN_AA,0x00);   
   
    //使能通道0的接收地址  
          NRF24L01_Write_Reg(SPI_WRITE_REG+EN_RXADDR,0x01);
   
    //设置自动重发间隔时间:‘1111’-等待 4000+86us;最大自动重发次数:3次
     NRF24L01_Write_Reg(SPI_WRITE_REG+SETUP_RETR,0xf3);
   
    //设置RF通道为40
          NRF24L01_Write_Reg(SPI_WRITE_REG+RF_CH,40);      
   
    //设置TX发射参数,0db增益,2Mbps,低噪声增益开启   
          NRF24L01_Write_Reg(SPI_WRITE_REG+RF_SETUP,0x0f);  
   
    //配置基本工作模式的参数WR_UP,EN_CRC,16BIT_CRC,PRIM_RX发送模式,开启所有中断
          NRF24L01_Write_Reg(SPI_WRITE_REG+CONFIG,0x0e);   
   
    // CE为高,10us后启动发送
        Set_NRF24L01_CE;                                 
}                  

eefocus_3934543

开发过程遇到最大的bug就是把非阻塞的函数当阻塞用了，出现了奇奇怪怪的问题，内存也报错

wudianjun2001

台风导致公司断电，继续在家休息

def Sensor_Read():                                                #读取传感器数据
    global Humi1_AD                                       #土壤湿度
    global Humi1_Val                                      #土壤湿度百分比
    global rtemp                                                #温度
    global rhumi                                                #湿度
    global Light_Val                                        #采集到的光照值

    Humi1_AD = adc1.read()                                #读AD值,读到的是12位数据
    Humi1_Val = 100 - int(Humi1_AD * 100 / 4096)#湿度值
    print("Humi1_AD: %d, Humi1_Val: %d"%(Humi1_AD, Humi1_Val))

    d.measure()
    rtemp = float(d.temperature())                #读取温度
    rhumi = d.humidity()                                #读取湿度
#     print('Temp:', rtemp,'℃',' Humi:', rhumi,'%RH')
    print("Temp: %.1f, Humi: %d"%(rtemp, rhumi))

    Light_Val = int(Get_Light())
    print("Light_Val: %d Lux"%Light_Val)

eefocus_3840188

pockit模块化电脑这个设计很不错。

suncat0504

NRF24L01发送：
//51单片机驱动nrf24l01无线模块发送程序：当按键P3.2按下，发送一组8字节的LED流水灯数组TX_Buffer[]；如果发送成功P0.0口LED灯则会闪烁！
#include <reg52.h>
#include <intrins.h>
typedef unsigned int uint;
typedef unsigned char uchar;

#define TX_ADDR_WITDH 5//发送地址宽度设置为5个字节
#define RX_ADDR_WITDH 5//接收地址宽度设置为5个字节
#define TX_DATA_WITDH 8//
#define RX_DATA_WITDH 8
/******************************************************************
// nRF24L01指令格式：
*******************************************************************/
#define R_REGISTER    0x00  // 读寄存器
#define W_REGISTER    0x20  // 写寄存器
#define R_RX_PLOAD    0x61  // 读RX FIFO有效数据，1-32字节，当读数据完成后，数据被清除，应用于接收模式
#define W_TX_PLOAD    0xA0  // 写TX FIFO有效数据，1-32字节，写操作从字节0开始，应用于发射模式
#define FLUSH_TX    0xE1  // 清除TX FIFO寄存器，应用于发射模式
#define FLUSH_RX    0xE2  // 清除RX FIFO寄存器，应用于接收模式
#define REUSE_TX_PL 0xE3  // 重新使用上一包有效数据，当CE为高过程中，数据包被不断的重新发射
#define NOP         0xFF  // 空操作，可以用来读状态寄存器
/******************************************************************
// nRF24L01寄存器地址
*******************************************************************/
#define CONFIG      0x00  // 配置寄存器
#define EN_AA       0x01  // “自动应答”功能寄存
#define EN_RX_ADDR  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状态寄存器
//*********************************************************************************
uchar sta;    // 状态变量
#define RX_DR  (sta & 0x40)  // 接收成功中断标志
#define TX_DS  (sta & 0x20)  // 发射成功中断标志
#define MAX_RT (sta & 0x10)  // 重发溢出中断标志

sbit Key=P3^0;
sbit CE=P1^2;
sbit IRQ=P3^2;
sbit CSN=P1^3;
sbit MOSI=P1^5;
sbit MISO=P1^6;
sbit SCK=P1^4;
sbit LED=P1^0;

uchar code TX_Addr[]={0x34,0x43,0x10,0x10,0x01};
uchar code TX_Buffer[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x00};
uchar RX_Buffer[RX_DATA_WITDH];

void _delay_us(uint x)
{
    uint i,j;
    for (j=0;j<x;j++)
        for (i=0;i<12;i++);
}
void _delay_ms(uint x)
{
    uint i,j;
    for (j=0;j<x;j++)
        for (i=0;i<120;i++);
}
/*nRF24L01初始化*/
void nRF24L01_Init(void)
{
    CE=0;//待机模式Ⅰ
    CSN=1;
    SCK=0;
    IRQ=1;
}
/*SPI时序函数*/
uchar SPI_RW(uchar byte)
{
    uchar i;
    for(i=0;i<8;i++)//一字节8位循环8次写入
    {
        if(byte&0x80)//如果数据最高位是1
            MOSI=1;//向NRF24L01写1
        else //否则写0
            MOSI=0;
        byte<<=1;//低一位移到最高位
        SCK=1;//SCK拉高，写入一位数据，同时读取一位数据
        if(MISO)
            byte|=0x01;
        SCK=0;//SCK拉低
    }
    return byte;//返回读取一字节
}
/*SPI写寄存器一字节函数*/
/*reg:寄存器地址*/
/*value:一字节（值）*/
uchar SPI_W_Reg(uchar reg,uchar value)
{
    uchar status;//返回状态
    CSN=0;//SPI片选
    status=SPI_RW(reg);//写入寄存器地址，同时读取状态
    SPI_RW(value);//写入一字节
    CSN=1;//
    return status;//返回状态
}
/*SPI读一字节*/
uchar SPI_R_byte(uchar reg)
{
    uchar reg_value;
    CSN=0;//SPI片选
    SPI_RW(reg);//写入地址
    reg_value=SPI_RW(0);//读取寄存器的值
    CSN=1;
    return reg_value;//返回读取的值
}
/*SPI读取RXFIFO寄存器数据*/
/*reg:寄存器地址*/
/*Dat_Buffer:用来存读取的数据*/
/*DLen:数据长度*/
uchar SPI_R_DBuffer(uchar reg,uchar *Dat_Buffer,uchar Dlen)
{
    uchar status,i;
    CSN=0;//SPI片选
    status=SPI_RW(reg);//写入寄存器地址，同时状态
    for(i=0;i<Dlen;i++)
    {
        Dat_Buffer[i]=SPI_RW(0);//存储数据
    }
    CSN=1;
    return status;
}
/*SPI向TXFIFO寄存器写入数据*/
/*reg:写入寄存器地址*/
/*TX_Dat_Buffer:存放需要发送的数据*/
/*Dlen:数据长度*/  
uchar SPI_W_DBuffer(uchar reg,uchar *TX_Dat_Buffer,uchar Dlen)
{
    uchar status,i;
    CSN=0;//SPI片选，启动时序
    status=SPI_RW(reg);
    for(i=0;i<Dlen;i++)
    {
        SPI_RW(TX_Dat_Buffer[i]);//发送数据
    }
    CSN=1;
    return status;  
}
/*设置发送模式*/
void 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(W_REGISTER+SETUP_RETR,0x0a);/*自动重发延时250US+86US，重发10次*/
    SPI_W_Reg(W_REGISTER+RF_CH,0);/*(2400+40)MHZ选择射频通道0X40*/
    SPI_W_Reg(W_REGISTER+RF_SETUP,0x07);/*1Mbps速率,发射功率:0DBM,低噪声放大器增益*/
    SPI_W_Reg(W_REGISTER+CONFIG,0x0e);/*发送模式,上电,16位CRC校验,CRC使能*/
    CE=1;//启动发射
    _delay_ms(5);/*CE高电平持续时间最少10US以上*/
}

uchar Check_Rec(void)
{
    uchar status;
    sta=SPI_R_byte(R_REGISTER+STATUS);
    if(RX_DR)
    {
        CE=0;
        SPI_R_DBuffer(R_RX_PLOAD,RX_Buffer,RX_DATA_WITDH);
        status=1;
    }
    SPI_W_Reg(W_REGISTER+STATUS,0xff);
    return status;  
}
/*检测应答信号*/
uchar Check_Ack(void)
{
    sta=SPI_R_byte(R_REGISTER+STATUS);/*读取寄存状态*/
    if(TX_DS||MAX_RT)/*如果TX_DS或MAX_RT为1,则清除中断和清除TX_FIFO寄存器的值*/
    {
        SPI_W_Reg(W_REGISTER+STATUS,0xff);
        CSN=0;
        SPI_RW(FLUSH_TX);/*如果没有这一句只能发一次数据，大家要注意*/
        CSN=1;
        return 0;
    }
    else
        return 1;
}

void main(void)
{
    uchar i;
    P0=0xff;//初始化IO口
    P1=0xff;
    P2=0xff;
    P3=0xff;
    _delay_us(100);
    nRF24L01_Init();//NRF24L01初始化
    while(1)
    {
        if(Key==0)
        {
            _delay_ms(10);
            if(Key==0)
            {
                for(i=0;i<TX_DATA_WITDH;i++)//发送7次数据
                {
                    nRF24L01_Set_TX_Mode(&TX_Buffer[i]);//发送数据
                    while(Check_Ack());//等待发送完成
     LED=~LED;
                }
            }
        }
    }
}

suncat0504

NRF24L01接收：
//51单片机驱动NRF24L01无线模块接收C语言程序：如果接收成功P3.2口的LED灯就会亮，否则熄灭！

#include <reg52.h>
#include <intrins.h>
#define uint unsigned int
#define uchar unsigned char

#define TX_ADDR_WITDH 5//发送地址宽度设置为5个字节
#define RX_ADDR_WITDH 5
#define TX_DATA_WITDH 8
#define RX_DATA_WITDH 8
/******************************************************************
// nRF24L01指令格式：
*******************************************************************/
#define R_REGISTER    0x00  // 读寄存器
#define W_REGISTER    0x20  // 写寄存器
#define R_RX_PLOAD    0x61  // 读RX FIFO有效数据，1-32字节，当读数据完成后，数据被清除，应用于接收模式
#define W_TX_PLOAD    0xA0  // 写TX FIFO有效数据，1-32字节，写操作从字节0开始，应用于发射模式
#define FLUSH_TX    0xE1  // 清除TX FIFO寄存器，应用于发射模式
#define FLUSH_RX    0xE2  // 清除RX FIFO寄存器，应用于接收模式
#define REUSE_TX_PL 0xE3  // 重新使用上一包有效数据，当CE为高过程中，数据包被不断的重新发射
#define NOP         0xFF  // 空操作，可以用来读状态寄存器
/******************************************************************
// nRF24L01寄存器地址
*******************************************************************/
#define CONFIG      0x00  // 配置寄存器
#define EN_AA       0x01  // “自动应答”功能寄存器
#define EN_RX_ADDR  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状态寄存器
//*********************************************************************************
uchar  sta;    // 状态变量
#define RX_DR  (sta & 0x40)  // 接收成功中断标志
#define TX_DS  (sta & 0x20)  // 发射成功中断标志
#define MAX_RT (sta & 0x10)  // 重发溢出中断标志
  
sbit CE=P1^2;
sbit IRQ=P3^2;
sbit CSN=P1^3;
sbit MOSI=P1^5;
sbit MISO=P1^6;
sbit SCK=P1^4;
sbit LED=P1^0;

uchar code TX_Addr[]={0x34,0x43,0x10,0x10,0x01};
uchar code TX_Buffer[]={0xfe,0xfd,0xfb,0xf7,0xef,0xdf,0xbf,0x7f};
uchar RX_Buffer[RX_DATA_WITDH];

void _delay_us(uint x)
{
    uint i,j;
    for (j=0;j<x;j++)
        for (i=0;i<12;i++);
}

void _delay_ms(uint x)
{
    uint i,j;
    for (j=0;j<x;j++)
        for (i=0;i<120;i++);
}
void nRF24L01_Init(void)
{
    _delay_us(2000);
    CE=0;
    CSN=1;
    SCK=0;
    IRQ=1;
}

uchar SPI_RW(uchar byte) {
    uchar i;
    for(i=0;i<8;i++)
    {
        if(byte&0x80)
            MOSI=1;
        else
            MOSI=0;
        byte<<=1;
        SCK=1;
        if(MISO)
            byte|=0x01;
        SCK=0;
    }
    return byte;
}

uchar SPI_W_Reg(uchar reg,uchar value) {
    uchar status;
    CSN=0;
    status=SPI_RW(reg);
    SPI_RW(value);
    CSN=1;
    return status;
}

uchar SPI_R_byte(uchar reg)
{
    uchar status;
    CSN=0;
    SPI_RW(reg);
    status=SPI_RW(0);
    CSN=1;
    return status;
}

uchar SPI_R_DBuffer(uchar reg,uchar *Dat_Buffer,uchar Dlen) {
    uchar reg_value,i;
    CSN=0;
    reg_value=SPI_RW(reg);
    for(i=0;i<Dlen;i++)
    {
        Dat_Buffer[i]=SPI_RW(0);
    }
    CSN=1;
    return reg_value;
}

uchar SPI_W_DBuffer(uchar reg,uchar *TX_Dat_Buffer,uchar Dlen) {
    uchar reg_value,i;
    CSN=0;
    reg_value=SPI_RW(reg);
    for(i=0;i<Dlen;i++)
    {
        SPI_RW(TX_Dat_Buffer[i]);
    }
    CSN=1;
    return reg_value;   
}

void nRF24L01_Set_RX_Mode(void) {
    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);
    SPI_W_Reg(W_REGISTER+EN_AA,0x01);//auot ack
    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);//0db,lna
    SPI_W_Reg(W_REGISTER+CONFIG,0x0f);
     
    CE=1;
    _delay_ms(5);
}

uchar nRF24L01_RX_Data(void)
{
//  uchar i,status;
    sta=SPI_R_byte(R_REGISTER+STATUS);
    if(RX_DR)
    {
        CE=0;
        SPI_R_DBuffer(R_RX_PLOAD,RX_Buffer,RX_DATA_WITDH);
    //  P3=RX_Buffer[0];
        SPI_W_Reg(W_REGISTER+STATUS,0xff);
        CSN=0;
        SPI_RW(FLUSH_RX);
        CSN=1;
        return 1;
    }
    else
        return 0;
}
  
void main(void) {
    P0=0xff;
    P1=0xff;
    P2=0xff;
    P3=0xff;
    _delay_us(1000);
    nRF24L01_Init();
    while(1)
    {
        nRF24L01_Set_RX_Mode();
        _delay_ms(100);
        if(nRF24L01_RX_Data())
        {
            LED=0;
        }
        else
            LED=1;
    }
}