N76E003_24L01/Home_Light_V0.1/Code/.svn/pristine/e1/e1dcd2e4abaefc84a6a0543c4d1d16eb5f76ee16.svn-base

C51 COMPILER V9.53.0.0   NRF24L01_API                                                      09/30/2018 11:45:28 PAGE 1   


C51 COMPILER V9.53.0.0, COMPILATION OF MODULE NRF24L01_API
OBJECT MODULE PLACED IN .\Output\nRF24L01_API.obj
COMPILER INVOKED BY: D:\Keil_v5\C51\BIN\C51.EXE ..\..\Code\User\Driver\nRF24L01_API.c LARGE OPTIMIZE(0,SPEED) BROWSE INC
                    -DIR(../../Code/Include;../../Code/User;../../Code/User/Common;../../Code/User/Driver) DEFINE(FOSC_160000=1) DEBUG OBJECT
                    -EXTEND PRINT(.\Output\LST\nRF24L01_API.lst) TABS(2) OBJECT(.\Output\nRF24L01_API.obj)

line level    source

   1          #include "nRF24L01_API.h"
   2          
   3          static uchar TX_ADDRESS[TX_ADR_WIDTH] = {0x00, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4}; //发送地址
   4          static uchar RX_ADDRESS[RX_ADR_WIDTH] = {0x00, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4}; //接收地址
   5          
   6          /*
   7          00    配置寄存器
   8              [7]
   9              [6]可屏蔽中断 RX_RD
  10              [5]可屏蔽中断 TX_DS
  11              [4]可屏蔽中断 MAX_RT
  12              [3]CRC 使能
  13              [2]CRC 模式
  14              [1]1:上电0:掉电
  15              [0]1:接收模式0:发射模式
  16          01    使能“自动应答”功能
  17              [7:6]
  18              [5:0]数据通道 5 ~0自动应答允许
  19          02    接收地址允许
  20              [7:6]
  21              [5:0]接收数据通道 5 ~0允许
  22          03    设置地址宽度（所有数据通道）
  23              [7:2]
  24              [1:0]0.无效 1.3byte  2.4byte  3.5byte 宽度
  25          04    建立自动重发
  26              [7:4]自动重发延时:'0000'-等待 250+86us  '1111'-等待 4000+86us
  27              [3:0]自动重发计数:'0000'-禁止自动重发 '1111'-自动重发 15 次
  28          05    射频通道
  29              [7]
  30              [6:0]设置 nRF24L01 工作通道频率
  31          06    射频寄存器
  32          
  33          .....
  34          .....
  35          
  36          
  37          */
  38          
  39          
  40          #if 1
  41          void delay_us ( uchar num )
  42          {
  43   1          uchar i;
  44   1      
  45   1          for ( i = 0; i < num; i++ )
  46   1          {
  47   2      #ifdef N76E003_IAR
                      asm ( "nop" );
              #else
  50   2              nop;
  51   2      #endif
  52   2          }
  53   1      }
C51 COMPILER V9.53.0.0   NRF24L01_API                                                      09/30/2018 11:45:28 PAGE 2   

  54          #else
              #define delay_us(us) Timer3_Delay10us(us/10+1)
              #endif
  57          /***************************************************************/
  58          
  59          /*******************************************************************/
  60          //spi速度为9Mhz（24L01的最大SPI时钟为10Mhz）
  61          #if 0
              uchar SPI_RW ( uchar byte )
              {
                  uchar bit_ctr;
              
                  for ( bit_ctr = 0; bit_ctr < 8; bit_ctr++ ) // 输出8位
                  {
                      NRF_MOSI = ( byte & 0x80 );       // MSB TO MOSI
                      byte = ( byte << 1 );         // shift next bit to MSB
                      NRF_SCK = 1;
                      byte |= NRF_MISO;             // capture current MISO bit
                      NRF_SCK = 0;
                  }
              
                  return byte;
              }
              #else
  78          uchar SPI_RW ( uchar byte )
  79          {
  80   1          uchar i;
  81   1          SPDR = byte;            //写寄存器
  82   1      
  83   1          for ( i = 0; i < 255; i++ )
  84   1          {
  85   2              if ( SPSR & SET_BIT7 )
  86   2              {
  87   3                  break;   //等待传输
  88   3              }
  89   2          }
  90   1      
  91   1          SPSR &= ~SET_BIT7;
  92   1          byte = SPDR;            //读寄存器
  93   1          return byte;
  94   1      }
  95          
  96          #endif
  97          /*********************************************/
  98          /* 函数功能：给24L01的寄存器写值（一个字节） */
  99          /* 入口参数：reg   要写的寄存器地址          */
 100          /*           value 给寄存器写的值            */
 101          /* 出口参数：status 状态值                   */
 102          /*********************************************/
 103          uchar NRF24L01_Write_Reg ( uchar reg, uchar value )
 104          {
 105   1          uchar status;
 106   1          NRF_CSN = 0;                //CSN=0;
 107   1          status = SPI_RW ( reg );    //发送寄存器地址,并读取状态值
 108   1          SPI_RW ( value );
 109   1          NRF_CSN = 1;                //CSN=1;
 110   1      
 111   1          return status;
 112   1      }
 113          /*************************************************/
 114          /* 函数功能：读24L01的寄存器值 （一个字节）      */
 115          /* 入口参数：reg  要读的寄存器地址               */
C51 COMPILER V9.53.0.0   NRF24L01_API                                                      09/30/2018 11:45:28 PAGE 3   

 116          /* 出口参数：value 读出寄存器的值                */
 117          /*************************************************/
 118          uchar NRF24L01_Read_Reg ( uchar reg )
 119          {
 120   1          uchar value;
 121   1      
 122   1          NRF_CSN = 0;              //CSN=0;
 123   1          SPI_RW ( reg );       //发送寄存器值(位置),并读取状态值
 124   1          value = SPI_RW ( NOP );
 125   1          NRF_CSN = 1;              //CSN=1;
 126   1      
 127   1          return value;
 128   1      }
 129          /*********************************************/
 130          /* 函数功能：读24L01的寄存器值（多个字节）   */
 131          /* 入口参数：reg   寄存器地址                */
 132          /*           *pBuf 读出寄存器值的存放数组    */
 133          /*           len   数组字节长度              */
 134          /* 出口参数：status 状态值                   */
 135          /*********************************************/
 136          uchar NRF24L01_Read_Buf ( uchar reg, uchar *pBuf, uchar len )
 137          {
 138   1          uchar status, u8_ctr;
 139   1          NRF_CSN = 0;                    //CSN=0
 140   1          status = SPI_RW ( reg );        //发送寄存器地址,并读取状态值
 141   1      
 142   1          for ( u8_ctr = 0; u8_ctr < len; u8_ctr++ )
 143   1          {
 144   2              pBuf[u8_ctr] = SPI_RW ( 0XFF );   //读出数据
 145   2          }
 146   1      
 147   1          NRF_CSN = 1;                    //CSN=1
 148   1          return status;              //返回读到的状态值
 149   1      }
 150          /**********************************************/
 151          /* 函数功能：给24L01的寄存器写值（多个字节）  */
 152          /* 入口参数：reg  要写的寄存器地址            */
 153          /*           *pBuf 值的存放数组               */
 154          /*           len   数组字节长度               */
 155          /**********************************************/
 156          uchar NRF24L01_Write_Buf ( uchar reg, uchar *pBuf, uchar len )
 157          {
 158   1          uchar status, u8_ctr;
 159   1          NRF_CSN = 0;
 160   1          status = SPI_RW ( reg );      //发送寄存器值(位置),并读取状态值
 161   1      
 162   1          for ( u8_ctr = 0; u8_ctr < len; u8_ctr++ )
 163   1          {
 164   2              SPI_RW ( *pBuf++ );         //写入数据
 165   2          }
 166   1      
 167   1          NRF_CSN = 1;
 168   1          return status;              //返回读到的状态值
 169   1      }
 170          
 171          /*********************************************/
 172          /* 函数功能：24L01接收数据               */
 173          /* 入口参数：rxbuf 接收数据数组     */
 174          /* 返回值： 0   成功收到数据            */
 175          /*          1   没有收到数据                    */
 176          /*********************************************/
 177          uchar NRF24L01_RxPacket ( uchar *rxbuf, uchar rxlen )
C51 COMPILER V9.53.0.0   NRF24L01_API                                                      09/30/2018 11:45:28 PAGE 4   

 178          {
 179   1          uchar state;
 180   1          uchar res = 0;
 181   1      
 182   1          state = NRF24L01_Read_Reg ( STATUS );       //读取状态寄存器的值
 183   1      
 184   1          if ( state & RX_DR )                //接收到数据
 185   1          {
 186   2              state &= ~RX_DR;
 187   2              NRF_CE = 0;   //配置前
 188   2              rxlen = ( rxlen < RX_PLOAD_WIDTH ) ? ( rxlen ) : ( RX_PLOAD_WIDTH );
 189   2              NRF24L01_Read_Buf ( RD_RX_PLOAD, rxbuf, RX_PLOAD_WIDTH ); //读取数据
 190   2              NRF24L01_Write_Reg ( FLUSH_RX, 0xff );          //清除RX FIFO寄存器
 191   2              NRF_CE = 1;   //配置完,使能收发
 192   2              delay_us ( 150 );
 193   2              res = 1;
 194   2          }
 195   1      
 196   1          NRF24L01_Write_Reg ( WRITE_REG + STATUS, state ); //清除TX_DS或MAX_RT中断标志
 197   1          return res;//没收到任何数据
 198   1      }
 199          /**********************************************/
 200          /* 函数功能：设置24L01为发送模式              */
 201          /* 入口参数：txbuf  发送数据数组              */
 202          /* 返回值； 0x10    达到最大重发次数，发送失败*/
 203          /*          0x20    成功发送完成              */
 204          /*          0xff    发送失败                  */
 205          /**********************************************/
 206          uchar NRF24L01_TxPacket ( uchar *txbuf, uchar txlen )
 207          {
 208   1          uchar res = 1;
 209   1          uchar state;
 210   1          uint16 i;
 211   1      
 212   1          NRF_CE = 0;         //CE拉低，使能24L01配置
 213   1          txlen = ( txlen < TX_PLOAD_WIDTH ) ? ( txlen ) : ( TX_PLOAD_WIDTH );
 214   1          NRF24L01_Write_Buf ( WR_TX_PLOAD, txbuf, TX_PLOAD_WIDTH );  //写数据到TX BUF  32个字节
 215   1          NRF_CE = 1;         //CE置高，使能发送
 216   1      
 217   1          for ( i = 0; i < 65535; i++ )
 218   1          {
 219   2              if ( NRF_IRQ == 1 )
 220   2              {
 221   3                  break;   //等待发送完成
 222   3              }
 223   2          }
 224   1      
 225   1          state = NRF24L01_Read_Reg ( STATUS );             //读取状态寄存器的值
 226   1      
 227   1          if ( state & MAX_RT )                             //达到最大重发次数
 228   1          {
 229   2              NRF24L01_Write_Reg ( FLUSH_TX, 0xff );          //清除TX FIFO寄存器
 230   2              state &= ~MAX_RT;
 231   2              res = 0;
 232   2          }
 233   1      
 234   1          if ( state & TX_DS )                    //发送完成
 235   1          {
 236   2              state &= ~TX_DS;
 237   2              res = 0;
 238   2          }
 239   1      
C51 COMPILER V9.53.0.0   NRF24L01_API                                                      09/30/2018 11:45:28 PAGE 5   

 240   1          NRF24L01_Write_Reg ( WRITE_REG + STATUS, state );     //清除TX_DS或MAX_RT中断标志
 241   1          return res;                       //发送失败
 242   1      }
 243          
 244          /********************************************/
 245          /* 函数功能：检测24L01是否存在              */
 246          /* 返回值；  1  存在                        */
 247          /*           0  不存在                      */
 248          /********************************************/
 249          uchar NRF24L01_Check ( void )
 250          {
 251   1          uchar res = 0;
 252   1          uchar check_in_buf[5] = {0x11, 0x22, 0x33, 0x44, 0x55};
 253   1          uchar check_out_buf[5] = {0x00};
 254   1      
 255   1          NRF_SCK = 0;
 256   1          NRF_CSN = 1;
 257   1          NRF_CE = 0;
 258   1      
 259   1          NRF24L01_Write_Buf ( WRITE_REG + TX_ADDR, check_in_buf, 5 );
 260   1      
 261   1          NRF24L01_Read_Buf ( READ_REG + TX_ADDR, check_out_buf, 5 );
 262   1      
 263   1          if ( ( check_out_buf[0] == 0x11 ) && \
 264   1                  ( check_out_buf[1] == 0x22 ) && \
 265   1                  ( check_out_buf[2] == 0x33 ) && \
 266   1                  ( check_out_buf[3] == 0x44 ) && \
 267   1                  ( check_out_buf[4] == 0x55 ) )
 268   1          {
 269   2              res = 1;
 270   2          }
 271   1      
 272   1          return res;
 273   1      }
 274          
 275          uint16 NRF24L01_Wait_Check ( void )
 276          {
 277   1          uint16 i;
 278   1      
 279   1          for ( i = 0; i < 50; i++ )
 280   1          {
 281   2              if ( NRF24L01_Check() )
 282   2              {
 283   3                  break;   //等待发送完成
 284   3              }
 285   2      
 286   2              Timer3_Delay10us ( 10 );
 287   2          }
 288   1      
 289   1          return i;
 290   1      }
 291          /**********************************************/
 292          /* 函数功能：24L01初始化                      */
 293          /* 入口参数：PLOAD_WIDTH  有效数据宽度        */
 294          /*       TX_ADR  发送地址             */
 295          /*         TX_ADDR_WIDTH  发送地址宽度      */
 296          /*       RX_ADR  接收发送地址           */
 297          /*       RX_ADDR_WIDTH  接收地址宽度      */
 298          /*       RATE  有效数据宽度             */
 299          /* 返回值  ；无                             */
 300          /**********************************************/
 301          void NRF24L01_RT_Init ( void )
C51 COMPILER V9.53.0.0   NRF24L01_API                                                      09/30/2018 11:45:28 PAGE 6   

 302          {
 303   1          NRF_CE = 0;
 304   1          NRF24L01_Write_Reg ( WRITE_REG + RX_PW_P0, TX_PLOAD_WIDTH ); //设置接收数据长度，本次设置为32字节
 305   1          NRF24L01_Write_Reg ( FLUSH_RX, 0xff );          //清除RX FIFO寄存器
 306   1          NRF24L01_Write_Buf ( WRITE_REG + TX_ADDR, TX_ADDRESS, TX_ADR_WIDTH ); //写TX节点地址
 307   1          NRF24L01_Write_Buf ( WRITE_REG + RX_ADDR_P0, RX_ADDRESS, RX_ADR_WIDTH ); //设置RX节点地址,主要为了使能
             -ACK
 308   1      
 309   1          NRF24L01_Write_Reg ( WRITE_REG + EN_AA, 0x05 );     //使能通道0的自动应答
 310   1          NRF24L01_Write_Reg ( WRITE_REG + EN_RXADDR, 0x01 );   //使能通道0的接收地址
 311   1      
 312   1          NRF24L01_Write_Reg ( WRITE_REG + FEATURE, 0x00 );   //使能动态数据包长度,AUTO_ACK模式
 313   1          NRF24L01_Write_Reg ( WRITE_REG + DYNPD, 0x01 );       //选择通道0动态数据包长度
 314   1      
 315   1          NRF24L01_Write_Reg ( WRITE_REG + SETUP_RETR, 0x1a );  //设置自动重发间隔时间:500us + 86us;最大自动重发
             -次数:10(a)次
 316   1          NRF24L01_Write_Reg ( WRITE_REG + RF_CH, 40 );       //设置RF通道为40 收发必须一致，0为2.4GHz + 40
 317   1          NRF24L01_Write_Reg ( WRITE_REG + RF_SETUP, 0x0f );    //设置TX发射参数,0db增益,2Mbps,低噪声增益开启
 318   1          NRF24L01_Write_Reg ( WRITE_REG + CONFIG, 0x0f );     //配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接
             -收模式,开启所有中断
 319   1          NRF_CE = 1;         //CE置高，使能发送
 320   1      }
 321          /**********************************************/
 322          /* 函数功能：发射函数                         */
 323          /* 入口参数：buf  发送寄存器                */
 324          /* 返回值  ；无                             */
 325          /**********************************************/
 326          /*
 327          nRF24L01 可以设置为以下几种主要的模式，
 328          模式      PWR_UP    PRIM_RX     CE    FIFO 寄存器状态
 329          接收模式  1       1       1     -
 330          发送模式  1       0       1     数据在 TX FIFO 寄存器中
 331          发送模式  1       0       1→0  停留在发送模式，直至数据发送完
 332          待机模式II  1       0       1     TX FIFO 为空
 333          待机模式I   1       -       0     无数据传输
 334          掉电模式  0       -       -     -
 335          CONFIG[0] PRIM_RX:  1:接收模式 0:发射模式
 336          CONFIG[1] PWR_UP:   1:上电 0:掉电
 337          */
 338          uchar SEND_BUF ( uchar *buf, uchar len )
 339          {
 340   1          uchar state;
 341   1          NRF_CE = 0;
 342   1          NRF24L01_Write_Reg ( WRITE_REG + CONFIG, 0x0e );  //CONFIG[0] PRIM_RX=0.发射
 343   1          NRF_CE = 1;
 344   1          delay_us ( 15 );
 345   1          state = NRF24L01_TxPacket ( buf, len );
 346   1          NRF_CE = 0;
 347   1          NRF24L01_Write_Reg ( WRITE_REG + CONFIG, 0x0f );  //CONFIG[0] PRIM_RX=0.发射
 348   1          NRF_CE = 1;
 349   1          return state;
 350   1      }
 351          


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =   1130    ----
   CONSTANT SIZE    =     10    ----
   XDATA SIZE       =     65    ----
   PDATA SIZE       =   ----    ----
   DATA SIZE        =   ----    ----
   IDATA SIZE       =   ----    ----
C51 COMPILER V9.53.0.0   NRF24L01_API                                                      09/30/2018 11:45:28 PAGE 7   

   BIT SIZE         =   ----    ----
END OF MODULE INFORMATION.


C51 COMPILATION COMPLETE.  0 WARNING(S),  0 ERROR(S)