nrf24l01调试求助……

驱动程序给你看一下
/**************************************************/
/*  函数: init_io()                                                                  */
/*  描述:初始化IO                                                                  */
/**************************************************/
void init_io(void)
{
        CE  = 0;        // 待机
        CSN = 1;        // SPI禁止
        SCK = 0;        // SPI时钟置低
        IRQ = 1;        // 中断复位
}
/**************************************************/
/*函数: init_ser()                                                                  */
/*描述:初始化串口                                                                  */
/**************************************************/
void init_ser()
{
        TMOD = 0x20;          //定时器T1使用工作方式2
        TH1 = 253;        // 设置初值
        TL1 = 253;
        TR1 = 1;          // 开始计时
        SCON = 0x50;          //工作方式1，波特率9600bps，允许接收   
        ES = 1;
        EA = 1;           // 打开所以中断   
        TI = 0;
        RI = 0;
}
/**************************************************/
/*函数：delay_ms()                                */
/*描述：延迟x毫秒                                                                  */
/**************************************************/
void delay_ms(uchar x)
{
    uchar i, j;
    i = 0;
    for(i=0; i<x; i++)
    {
       j = 250;
       while(--j);
           j = 250;
       while(--j);
    }
}
/**************************************************/
/*函数：SPI_RW()                                                                  */
/*描述：根据SPI协议，写一字节数据到nRF24L01，          */
/*        同时从nRF24L01读出一字节                                  */
/**************************************************/
uchar SPI_RW(uchar byte)
{
        uchar i;
           for(i=0; i<8; i++)          // 循环8次
           {
                   MOSI = (byte & 0x80);   // byte最高位输出到MOSI
                   byte <<= 1;             // 低一位移位到最高位
                   SCK = 1;                // 拉高SCK，nRF24L01从MOSI读入1位数据，同时从MISO输出1位数据
                   byte |= MISO;               // 读MISO到byte最低位
                   SCK = 0;                    // SCK置低
           }
    return(byte);                   // 返回读出的一字节
}
/**************************************************/
/*函数：SPI_RW_Reg()                                                          */
/*描述：写数据value到reg寄存器                                          */
/**************************************************/
uchar SPI_RW_Reg(uchar reg, uchar value)
{
        uchar status;
          CSN = 0;                   // CSN置低，开始传输数据
          status = SPI_RW(reg);      // 选择寄存器，同时返回状态字
          SPI_RW(value);             // 然后写数据到该寄存器
          CSN = 1;                   // CSN拉高，结束数据传输
          return(status);            // 返回状态寄存器
}
/**************************************************/
/*函数：SPI_Read()                                                                  */
/*描述：从reg寄存器读一字节                                                  */
/**************************************************/
uchar SPI_Read(uchar reg)
{
        uchar reg_val;
          CSN = 0;                    // CSN置低，开始传输数据
          SPI_RW(reg);                // 选择寄存器
          reg_val = SPI_RW(0);        // 然后从该寄存器读数据
          CSN = 1;                    // CSN拉高，结束数据传输
          return(reg_val);            // 返回寄存器数据
}
/**************************************************/
/*函数：SPI_Read_Buf()                                                          */
/*描述：从reg寄存器读出bytes个字节，                          */
/*通常用来读取接收通道数据或接收/发送地址                  */
/**************************************************/
uchar SPI_Read_Buf(uchar reg, uchar * pBuf, uchar bytes)
{
        uchar status, i;
          CSN = 0;                    // CSN置低，开始传输数据
          status = SPI_RW(reg);       // 选择寄存器，同时返回状态字
          for(i=0; i<bytes; i++)
            pBuf[i] = SPI_RW(0);    // 逐个字节从nRF24L01读出
          CSN = 1;                    // CSN拉高，结束数据传输
          return(status);             // 返回状态寄存器
}
/**************************************************/
/*函数：SPI_Write_Buf()                                                          */
/*描述：把pBuf缓存中的数据写入到nRF24L01，                  */
/*通常用来写入发射通道数据或接收/发送地址                  */
/**************************************************/
uchar SPI_Write_Buf(uchar reg, uchar * pBuf, uchar bytes)
{
        uchar status, i;
          CSN = 0;                    // CSN置低，开始传输数据
          status = SPI_RW(reg);       // 选择寄存器，同时返回状态字
          for(i=0; i<bytes; i++)
            SPI_RW(pBuf[i]);        // 逐个字节写入nRF24L01
          CSN = 1;                    // CSN拉高，结束数据传输
          return(status);             // 返回状态寄存器
}
/**************************************************/
/*函数：RX_Mode()                                                                  */
/*描述：这个函数设置nRF24L01为接收模式，                  */
/*      等待接收发送设备的数据包                                  */
/**************************************************/
void RX_Mode(void)
{
        CE = 0;
          SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);  // 接收设备接收通道0使用和发送设备相同的发送地址
          SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);               // 使能接收通道0自动应答
          SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);           // 使能接收通道0
          SPI_RW_Reg(WRITE_REG + RF_CH, 40);                 // 选择射频通道0x40
          SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH);  // 接收通道0选择和发送通道相同有效数据宽度
          SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);            // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
          SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);              // CRC使能，16位CRC校验，上电，接收模式
          CE = 1;                                            // 拉高CE启动接收设备
}
/**************************************************/
/*函数：TX_Mode()                                                                  */
/*描述：这个函数设置nRF24L01为发送模式，                  */
/*     （CE=1持续至少10us），                                          */
/*            130us后启动发射，数据发送结束后，                  */
/*            发送模块自动转入接收模式等待应答信号。          */
/**************************************************/
void TX_Mode(uchar * BUF)
{
        CE = 0;
          SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);     // 写入发送地址
          SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);  // 为了应答接收设备，接收通道0地址和发送地址相同
          SPI_Write_Buf(WR_TX_PLOAD, BUF, TX_PLOAD_WIDTH);                  // 写数据包到TX FIFO
          SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);       // 使能接收通道0自动应答
          SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);   // 使能接收通道0
          SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x0a);  // 自动重发延时等待250us+86us，自动重发10次
          SPI_RW_Reg(WRITE_REG + RF_CH, 40);         // 选择射频通道0x40
          SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);    // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
          SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);      // CRC使能，16位CRC校验，上电
        CE = 1;
}
/**************************************************/
/*函数：SendData(uchar *a)                                                  */
/*描述：串口发送数据                                                          */
/**************************************************/
SendData(uchar a[TX_PLOAD_WIDTH])
{        int i;
        for(i=0;i<TX_PLOAD_WIDTH;i++)
        {
           outdata[i] = a[i];
        }
        count = 1;
        SBUF=outdata[0];
}
/**************************************************/
/*函数：Check_ACK()                                                                  */
/*描述：检查接收设备有无接收到数据包，                          */
/*设定没有收到应答信号是否重发                                          */
/**************************************************/
uchar Check_ACK(bit clear)
{
        while(IRQ);
        sta = SPI_RW(NOP);                    // 返回状态寄存器
        if(MAX_RT)
                if(clear)                         // 是否清除TX FIFO，没有清除在复位MAX_RT中断标志后重发
                        SPI_RW(FLUSH_TX);
        SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志
        IRQ = 1;
        if(TX_DS)
                return(0x00);
        else
                return(0xff);
}

请问一下你硬件电路是怎么连得?直接对应端口相连么?还是加了什么电阻?

我看了下除了你比我多了个senddata函数，其他的一样，我就纳闷了……关键是我的SCK MOSI MISO CSN都有脉冲，应该是进行数据传输了，不知道为什么就是不对……唉

这就是无线部分电路

咦，我这就无语了……看来我已经崩溃了……这接线接的差不多……也没看你有什么分压电阻，就是那个3.3V的电容咱俩接的大一样，我接了一个22uf并联一个47uf的……我要疯了……

地址对应的对吗?程序使用前有初始化吗?

大神能详细说下么?

网上的例子我看了好多……也试了就是不行。

我做的是DHT11的无线温湿度传送，这是发送端程序，你可以参考下
#include <reg51.h>
#include <intrins.h>
#include <api.h>
#include <stdio.h>
void Xianshi1602(void);
typedef unsigned char  U8;       /* defined for unsigned 8-bits integer variable           无符号8位整型变量  */
typedef signed   char  S8;       /* defined for signed 8-bits integer variable                  有符号8位整型变量  */
typedef unsigned int   U16;      /* defined for unsigned 16-bits integer variable           无符号16位整型变量 */
typedef signed   int   S16;      /* defined for signed 16-bits integer variable           有符号16位整型变量 */
typedef unsigned long  U32;      /* defined for unsigned 32-bits integer variable           无符号32位整型变量 */
typedef signed   long  S32;      /* defined for signed 32-bits integer variable           有符号32位整型变量 */
typedef float          F32;      /* single precision floating point variable (32bits) 单精度浮点数（32位长度） */
typedef double         F64;      /* double precision floating point variable (64bits) 双精度浮点数（64位长度） */
#define uchar unsigned char
#define uint unsigned int
#define Data_0_time    4
#define TX_ADR_WIDTH   5  // 5字节宽度的发送/接收地址
#define TX_PLOAD_WIDTH 6  // 数据通道有效数据宽度
uchar code TX_ADDRESS[TX_ADR_WIDTH] = {0x34,0x43,0x10,0x10,0x01};  // 定义一个静态发送地址
uchar RX_BUF[TX_PLOAD_WIDTH];
uchar TX_BUF[TX_PLOAD_WIDTH];
uchar flag;
uchar str_1[TX_PLOAD_WIDTH]="AZainm",outdata[TX_PLOAD_WIDTH];                //第一位为地址位
uchar bdata sta;

int        count,h;
U8  U8FLAG,k;
U8  U8count,U8temp;
U8  U8T_data_H,U8T_data_L,U8RH_data_H,U8RH_data_L,U8checkdata;
U8  U8T_data_H_temp,U8T_data_L_temp,U8RH_data_H_temp,U8RH_data_L_temp,U8checkdata_temp;
U8  U8comdata;
U16 U16temp1,U16temp2;
uchar T[3]={0x30,0x30,0x30};
uchar RHA[3]={0x30,0x30,0x30};
sbit P1_6=P1^6 ;//DHT11数据输入口
sbit EN_LCD1602=P2^2;//液晶屏使能
sbit RW_LCD1602=P2^1;//液晶屏读写选择
sbit RS_LCD1602=P2^0;//液晶屏复位
sbit RX_DR=sta^6;
sbit TX_DS=sta^5;
sbit MAX_RT=sta^4;
/**************************************************/
/*  函数: init_io()                                                                  */
/*  描述:初始化IO                                                                  */
/**************************************************/
void init_io(void)
{
        CE  = 0;        // 待机
        CSN = 1;        // SPI禁止
        SCK = 0;        // SPI时钟置低
        IRQ = 1;        // 中断复位
}
/**************************************************/
/*函数: init_ser()                                                                  */
/*描述:初始化串口                                                                  */
/**************************************************/
void init_ser()
{
        TMOD = 0x20;          //定时器T1使用工作方式2
        TH1 = 253;        // 设置初值
        TL1 = 253;
        TR1 = 1;          // 开始计时
        SCON = 0x50;          //工作方式1，波特率9600bps，允许接收   
        ES = 1;
        EA = 1;           // 打开所以中断   
        TI = 0;
        RI = 0;
}
/**************************************************/
/*函数：delay_ms()                                */
/*描述：延迟x毫秒                                                                  */
/**************************************************/
void delay_ms(uchar x)
{
    uchar i, j;
    i = 0;
    for(i=0; i<x; i++)
    {
       j = 250;
       while(--j);
           j = 250;
       while(--j);
    }
}
/**************************************************/
/*函数：SPI_RW()                                                                  */
/*描述：根据SPI协议，写一字节数据到nRF24L01，          */
/*        同时从nRF24L01读出一字节                                  */
/**************************************************/
uchar SPI_RW(uchar byte)
{
        uchar i;
           for(i=0; i<8; i++)          // 循环8次
           {
                   MOSI = (byte & 0x80);   // byte最高位输出到MOSI
                   byte <<= 1;             // 低一位移位到最高位
                   SCK = 1;                // 拉高SCK，nRF24L01从MOSI读入1位数据，同时从MISO输出1位数据
                   byte |= MISO;               // 读MISO到byte最低位
                   SCK = 0;                    // SCK置低
           }
    return(byte);                   // 返回读出的一字节
}
/**************************************************/
/*函数：SPI_RW_Reg()                                                          */
/*描述：写数据value到reg寄存器                                          */
/**************************************************/
uchar SPI_RW_Reg(uchar reg, uchar value)
{
        uchar status;
          CSN = 0;                   // CSN置低，开始传输数据
          status = SPI_RW(reg);      // 选择寄存器，同时返回状态字
          SPI_RW(value);             // 然后写数据到该寄存器
          CSN = 1;                   // CSN拉高，结束数据传输
          return(status);            // 返回状态寄存器
}
/**************************************************/
/*函数：SPI_Read()                                                                  */
/*描述：从reg寄存器读一字节                                                  */
/**************************************************/
uchar SPI_Read(uchar reg)
{
        uchar reg_val;
          CSN = 0;                    // CSN置低，开始传输数据
          SPI_RW(reg);                // 选择寄存器
          reg_val = SPI_RW(0);        // 然后从该寄存器读数据
          CSN = 1;                    // CSN拉高，结束数据传输
          return(reg_val);            // 返回寄存器数据
}
/**************************************************/
/*函数：SPI_Read_Buf()                                                          */
/*描述：从reg寄存器读出bytes个字节，                          */
/*通常用来读取接收通道数据或接收/发送地址                  */
/**************************************************/
uchar SPI_Read_Buf(uchar reg, uchar * pBuf, uchar bytes)
{
        uchar status, i;
          CSN = 0;                    // CSN置低，开始传输数据
          status = SPI_RW(reg);       // 选择寄存器，同时返回状态字
          for(i=0; i<bytes; i++)
            pBuf[i] = SPI_RW(0);    // 逐个字节从nRF24L01读出
          CSN = 1;                    // CSN拉高，结束数据传输
          return(status);             // 返回状态寄存器
}
/**************************************************/
/*函数：SPI_Write_Buf()                                                          */
/*描述：把pBuf缓存中的数据写入到nRF24L01，                  */
/*通常用来写入发射通道数据或接收/发送地址                  */
/**************************************************/
uchar SPI_Write_Buf(uchar reg, uchar * pBuf, uchar bytes)
{
        uchar status, i;
          CSN = 0;                    // CSN置低，开始传输数据
          status = SPI_RW(reg);       // 选择寄存器，同时返回状态字
          for(i=0; i<bytes; i++)
            SPI_RW(pBuf[i]);        // 逐个字节写入nRF24L01
          CSN = 1;                    // CSN拉高，结束数据传输
          return(status);             // 返回状态寄存器
}
/**************************************************/
/*函数：RX_Mode()                                                                  */
/*描述：这个函数设置nRF24L01为接收模式，                  */
/*      等待接收发送设备的数据包                                  */
/**************************************************/
void RX_Mode(void)
{
        CE = 0;
          SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);  // 接收设备接收通道0使用和发送设备相同的发送地址
          SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);               // 使能接收通道0自动应答
          SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);           // 使能接收通道0
          SPI_RW_Reg(WRITE_REG + RF_CH, 40);                 // 选择射频通道0x40
          SPI_RW_Reg(WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH);  // 接收通道0选择和发送通道相同有效数据宽度
          SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);            // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
          SPI_RW_Reg(WRITE_REG + CONFIG, 0x0f);              // CRC使能，16位CRC校验，上电，接收模式
          CE = 1;                                            // 拉高CE启动接收设备
}
/**************************************************/
/*函数：TX_Mode()                                                                  */
/*描述：这个函数设置nRF24L01为发送模式，                  */
/*     （CE=1持续至少10us），                                          */
/*            130us后启动发射，数据发送结束后，                  */
/*            发送模块自动转入接收模式等待应答信号。          */
/**************************************************/
void TX_Mode(uchar * BUF)
{
        CE = 0;
          SPI_Write_Buf(WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH);     // 写入发送地址
          SPI_Write_Buf(WRITE_REG + RX_ADDR_P0, TX_ADDRESS, TX_ADR_WIDTH);  // 为了应答接收设备，接收通道0地址和发送地址相同
          SPI_Write_Buf(WR_TX_PLOAD, BUF, TX_PLOAD_WIDTH);                  // 写数据包到TX FIFO
          SPI_RW_Reg(WRITE_REG + EN_AA, 0x01);       // 使能接收通道0自动应答
          SPI_RW_Reg(WRITE_REG + EN_RXADDR, 0x01);   // 使能接收通道0
          SPI_RW_Reg(WRITE_REG + SETUP_RETR, 0x0a);  // 自动重发延时等待250us+86us，自动重发10次
          SPI_RW_Reg(WRITE_REG + RF_CH, 40);         // 选择射频通道0x40
          SPI_RW_Reg(WRITE_REG + RF_SETUP, 0x07);    // 数据传输率1Mbps，发射功率0dBm，低噪声放大器增益
          SPI_RW_Reg(WRITE_REG + CONFIG, 0x0e);      // CRC使能，16位CRC校验，上电
        CE = 1;
}
/**************************************************/
/*函数：SendData(uchar *a)                                                  */
/*描述：串口发送数据                                                          */
/**************************************************/
SendData(uchar a[TX_PLOAD_WIDTH])
{        int i;
        for(i=0;i<TX_PLOAD_WIDTH;i++)
        {
           outdata[i] = a[i];
        }
        count = 1;
        SBUF=outdata[0];
}
/**************************************************/
/*函数：Check_ACK()                                                                  */
/*描述：检查接收设备有无接收到数据包，                          */
/*设定没有收到应答信号是否重发                                          */
/**************************************************/
uchar Check_ACK(bit clear)
{
        while(IRQ);
        sta = SPI_RW(NOP);                    // 返回状态寄存器
        if(MAX_RT)
                if(clear)                         // 是否清除TX FIFO，没有清除在复位MAX_RT中断标志后重发
                        SPI_RW(FLUSH_TX);
        SPI_RW_Reg(WRITE_REG + STATUS, sta);  // 清除TX_DS或MAX_RT中断标志
        IRQ = 1;
        if(TX_DS)
                return(0x00);
        else
                return(0xff);
}
/**************************************************/
/*   DHT11部分                                                                          */
/**************************************************/
void Delay(U16 j)
{      
   U8 i;
   for(;j>0;j--)
   {        
          for(i=0;i<27;i++);
   }
}
void  Delay_10us(void)
{
    U8 i;
    i--;
    i--;
    i--;
    i--;
    i--;
    i--;
}
void  COM(void)
{
   U8 i;
    for(i=0;i<8;i++)          
        {
            U8FLAG=2;       
                   while((！P1_6)&&U8FLAG++);
                Delay_10us();
                Delay_10us();
                Delay_10us();
                  U8temp=0;
            if(P1_6)U8temp=1;
                    U8FLAG=2;
            while((P1_6)&&U8FLAG++);
                   //超时则跳出for循环                  
                   if(U8FLAG==1)break;
                   //判断数据位是0还是1         
                   // 如果高电平高过预定0高电平值则数据位为 1
                   U8comdata<<=1;
            U8comdata|=U8temp;        //0
        }//rof
}
//--------------------------------
//-----湿度读取子程序 ------------
//--------------------------------
//----以下变量均为全局变量--------
//----温度高8位== U8T_data_H------
//----温度低8位== U8T_data_L------
//----湿度高8位== U8RH_data_H-----
//----湿度低8位== U8RH_data_L-----
//----校验 8位 == U8checkdata-----
//----调用相关子程序如下----------
//---- Delay();, Delay_10us();,COM();
//--------------------------------
void RH(void)
{
    //主机拉低18ms
    P1_6=0;
        Delay(180);
        P1_6=1;
        //总线由上拉电阻拉高 主机延时20us
        Delay_10us();
        Delay_10us();
        Delay_10us();
        Delay_10us();
        //主机设为输入 判断从机响应信号
        P1_6=1;
        //判断从机是否有低电平响应信号 如不响应则跳出，响应则向下运行          
        if(！P1_6)//T ！          
        {
           U8FLAG=2;
           //判断从机是否发出 80us 的低电平响应信号是否结束         
           while((！P1_6)&&U8FLAG++);
           U8FLAG=2;
           //判断从机是否发出 80us 的高电平，如发出则进入数据接收状态
           while((P1_6)&&U8FLAG++);
           //数据接收状态                 
           COM();
           U8RH_data_H_temp=U8comdata;
           COM();
           U8RH_data_L_temp=U8comdata;
           COM();
           U8T_data_H_temp=U8comdata;
           COM();
           U8T_data_L_temp=U8comdata;
           COM();
           U8checkdata_temp=U8comdata;
           P1_6=1;
           //数据校验
           U8temp=(U8T_data_H_temp+U8T_data_L_temp+U8RH_data_H_temp+U8RH_data_L_temp);
           if(U8temp==U8checkdata_temp)
           {
                     U8RH_data_H=U8RH_data_H_temp;
                     U8RH_data_L=U8RH_data_L_temp;
                  U8T_data_H=U8T_data_H_temp;
                     U8T_data_L=U8T_data_L_temp;
                     U8checkdata=U8checkdata_temp;
           }//fi
        }//fi
}
/*主函数*/
void main()
{
        /* 系统初始化 */
    init_io();        // 初始化IO
        init_ser();        // 初始化串口
        RX_Mode();        // 设置为接收模式
        Delay(1);
    InitLCD1602();//初始化液晶屏
    ReadLCD1602();//读液晶屏忙状态
    while (1)
    {
           RH();         //调用温湿度读取子程序
           Xianshi1602();//液晶屏显示程序
           //串口显示程序
           str_1[0]=0x01;                                //地址位
           str_1[1]=U8RH_data_H;
           str_1[2]=U8RH_data_L;
           str_1[3]=U8T_data_H;
       str_1[4]=U8T_data_L;
           str_1[5]=U8checkdata;  
           //读取模块数据周期不应小于 2S
           Delay(20000);
           for(h=0;h<TX_PLOAD_WIDTH;h++)
           {
                   TX_BUF[h] = str_1[h];          // 数据送到缓存
           }
           TX_Mode(TX_BUF);                        // 把nRF24L01设置为发送模式并发送数据
           Check_ACK(1);               // 等待发送完毕，清除TX FIFO
           delay_ms(500);
           RX_Mode();                                        // 设置为接收模式
           delay_ms(500);
           SendData(TX_BUF);
    }
}
/**************************************************/
/*函数：RISINTR()                                                                  */
/*描述：中断函数                                                                  */
/**************************************************/
void RSINTR() interrupt 4 using 2
{
        if(TI==1) //发送中断          
        {
                TI=0;
                if(count！=TX_PLOAD_WIDTH) //发送完TX_PLOAD_WIDTH位数据         
                {
                        SBUF= outdata[count];
                        count++;
                }
        }
}

好的，我在仔细看看你的程序，要是再不成我就真得看看硬件电路和通信芯片是否损坏了了，非常感谢

我看了下你的SPI函数和我的一模一样

已成功，谢谢指点