N76E003_24L01/Home_Light_V0.1/Code/.svn/pristine/41/41add2e7eecf5918f2e74005ac31a2cf64a1888b.svn-base

C51 COMPILER V9.53.0.0   NRF24L01_INTE                                                     09/28/2018 15:19:33 PAGE 1   


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

line level    source

   1          #include "NRF24L01_inte.H"
   2          #include <string.h>
   3          
   4          #define RF_CH_DEF   40
   5          #define RF_C_NUM_DEF  0   //0通道无法发送
   6          unsigned char RF_CH = RF_CH_DEF;      //RF频道
   7          unsigned char RF_C_NUM = RF_C_NUM_DEF;    //RF通道
   8          unsigned char NRF24L01_FLAG = 0;      //NRF24L01当前状态标志
   9          //DB7; 1接收模式      0发射模式
  10          //DB6; 1有任务        0空闲
  11          //DB5; 1发送成功      0发送失败(配合DB6检测是否发送成功)
  12          //DB4; 1NRF正常连接   0 检测不到连接
  13          //DB3; 1接收到数据包  0 缓冲区无数据
  14          //DB2; 1 ACK模式      0 NOACK模式
  15          //DB1; 1发送完自动进入接收模式 0关闭自动切换模式
  16          unsigned char DYNPD_LEN = 0;      //用于存放动态数据包长度
  17          //接收地址-- 接收有6个通道
  18          const unsigned char RX_ADD[NRF24L01_CH_NUM_MAX + 1][NRF24L01_ADR_LEN] =
  19          {
  20              {0x00, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4},   //通道0
  21              {0x01, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4},   //通道1
  22              {0x02, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4},   //通道2
  23              {0x03, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4},   //通道3
  24              {0x04, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4},   //通道4
  25              {0x05, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4}    //通道5
  26          };
  27          //本地地址-- 发送只有1个通道
  28          const unsigned char TX_ADD[NRF24L01_CH_NUM_MAX + 1][NRF24L01_ADR_LEN] =
  29          {
  30              {0x00, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4},   //对应通道0
  31              {0x01, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4},   //对应通道1
  32              {0x02, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4},   //对应通道2
  33              {0x03, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4},   //对应通道3
  34              {0x04, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4},   //对应通道4
  35              {0x05, TR_ADDR_B1, TR_ADDR_B2, TR_ADDR_B3, TR_ADDR_B4}    //对应通道5
  36          };
  37          
  38          
  39          struct init_reg_data
  40          {
  41              unsigned char reg;
  42              unsigned char data1;
  43              unsigned char *data2;
  44              unsigned char len2;
  45          };
  46          
  47          const struct init_reg_data init_first[] =
  48          {
  49          #if 1
  50              //RX全部通道配置
  51              {NRF24L01_RX_ADDR_P0, 0, RX_ADD[0], NRF24L01_ADR_LEN},    //P0接收地址
  52              {NRF24L01_RX_ADDR_P1, 0, RX_ADD[1], NRF24L01_ADR_LEN},  //P1接收地址
  53              {NRF24L01_RX_ADDR_P2, 0, RX_ADD[2], 1},           //P2接收地址
C51 COMPILER V9.53.0.0   NRF24L01_INTE                                                     09/28/2018 15:19:33 PAGE 2   

  54              {NRF24L01_RX_ADDR_P3, 0, RX_ADD[3], 1},           //P3接收地址
  55              {NRF24L01_RX_ADDR_P4, 0, RX_ADD[4], 1},           //P4接收地址
  56              {NRF24L01_RX_ADDR_P5, 0, RX_ADD[5], 1},           //P5接收地址
  57              {NRF24L01_RX_PW_P0, NRF24L01_ADR_LEN, NULL, 0},       //P0接受通道有效宽度
  58              {NRF24L01_RX_PW_P1, NRF24L01_ADR_LEN, NULL, 0},       //P1接受通道有效宽度
  59              {NRF24L01_RX_PW_P2, NRF24L01_ADR_LEN, NULL, 0},       //P2接受通道有效宽度
  60              {NRF24L01_RX_PW_P3, NRF24L01_ADR_LEN, NULL, 0},       //P3接受通道有效宽度
  61              {NRF24L01_RX_PW_P4, NRF24L01_ADR_LEN, NULL, 0},       //P4接受通道有效宽度
  62              {NRF24L01_RX_PW_P5, NRF24L01_ADR_LEN, NULL, 0},       //P5接受通道有效宽度
  63              //其他配置
  64              {NRF24L01_SETUP_AW, NRF24L01_ADR_LEN - 2, NULL, 0},     //设置地址长度为 NRF24L01_ADR_LEN
  65              {NRF24L01_RF_SETUP, 0x0f, NULL, 0},                   //设置TX发射参数,7db增益,2Mbps,低噪声增益开启
  66              //RX模式配置
  67              {NRF24L01_FEATURE, 0x06, NULL, 0},              //使能动态数据包长度,AUTO_ACK模式
  68              //TX模式配置
  69              {NRF24L01_SETUP_RETR, 0x1a, NULL, 0},               //设置自动重发间隔时间:500us + 86us;重发次数:10次
  70          
  71              //通道/频段/TX地址配置
  72              {NRF24L01_RF_CH, RF_CH_DEF, NULL, 0},                 //设置RF频道为RFCH [6:0]
  73              {NRF24L01_EN_AA, 1 << RF_C_NUM_DEF, NULL, 0},             //通道自动应答  : 0~5通道
  74              {NRF24L01_EN_RXADDR, 1 << RF_C_NUM_DEF, NULL, 0},         //接收通道使能  : 0~5通道
  75              {NRF24L01_TX_ADDR, 0, TX_ADD[RF_C_NUM_DEF], NRF24L01_ADR_LEN},    //写TX节点地址
  76              {NRF24L01_DYNPD, 1 << RF_C_NUM_DEF, NULL, 0},               //选择通道0动态数据包长度
  77          #else
                  {NRF24L01_RX_PW_P0, NRF24L01_ADR_LEN, NULL, 0},       //设置接收数据长度，本次设置为32字节
                  //{NRF24L01_FLUSE_RX, 0xff, NULL, 0},             //清除RX FIFO寄存器
                  {NRF24L01_TX_ADDR, 0, TX_ADD[0], NRF24L01_ADR_LEN},     //写TX节点地址
                  {NRF24L01_RX_ADDR_P0, 0, RX_ADD[0], NRF24L01_ADR_LEN},    //设置RX节点地址,主要为了使能ACK
              
                  {NRF24L01_EN_AA, 0x01, NULL, 0},              //使能通道0的自动应答
                  {NRF24L01_EN_RXADDR, 0x01, NULL, 0},            //使能通道0的接收地址
              
                  {NRF24L01_SETUP_RETR, 0x1a, NULL, 0},             //设置自动重发间隔时间:500us + 86us;最大自动重发次数:10(a)
             -次
                  {NRF24L01_RF_CH, 40, NULL, 0},                //设置RF通道为40 收发必须一致，0为2.4GHz + 40
                  {NRF24L01_RF_SETUP, 0x0f, NULL, 0},             //设置TX发射参数,0db增益,2Mbps,低噪声增益开启
                  {NRF24L01_CONFIG, 0x0f, NULL, 0},               //配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模式,开�
             -羲�兄卸�
              
              #endif
  92          };
  93          
  94          const struct init_reg_data init_recv_mod[] =
  95          {
  96              {NRF24L01_CONFIG, 0x0f, NULL, 0},             //bit0接收模式
  97              {NRF24L01_STATUS, 0x70, NULL, 0},             //清中断
  98              {NRF24L01_FLUSE_RX, NRF24L01_NOP, NULL, 0},         //清理接收FIFO
  99          };
 100          
 101          const struct init_reg_data init_send_mod[] =
 102          {
 103              {NRF24L01_CONFIG, 0x0e, NULL, 0},             //bit0发送模式
 104              {NRF24L01_STATUS, 0x70, NULL, 0},             //清中断
 105              {NRF24L01_FLUSE_TX, NRF24L01_NOP, NULL, 0},         //清理发送FIFO
 106          };
 107          
 108          void NRF24L01_Init_reg ( struct init_reg_data *addr, unsigned char len )
 109          {
 110   1          unsigned char i;
 111   1      
 112   1          for ( i = 0; i < len; i++ )
 113   1          {
C51 COMPILER V9.53.0.0   NRF24L01_INTE                                                     09/28/2018 15:19:33 PAGE 3   

 114   2              if ( addr[i].data2 == NULL )
 115   2              {
 116   3                  NRF24L01_Write_Reg ( addr[i].reg, addr[i].data1 );
 117   3              }
 118   2              else
 119   2              {
 120   3                  NRF24L01_Write_Buf ( addr[i].reg, addr[i].data2, addr[i].len2 );
 121   3              }
 122   2          }
 123   1      }
 124          
 125          unsigned char  NRF24L01_check_reg ( struct init_reg_data *addr, unsigned char len )
 126          {
 127   1          unsigned char buff[5];
 128   1          unsigned char i, j;
 129   1      
 130   1          for ( i = 0; i < len; i++ )
 131   1          {
 132   2              if ( addr[i].data2 == NULL )
 133   2              {
 134   3                  buff[0] = NRF24L01_Read_Reg ( addr[i].reg );
 135   3      
 136   3                  if ( buff[0] != addr[i].data1 )
 137   3                  {
 138   4                      return 0;
 139   4                  }
 140   3              }
 141   2              else
 142   2              {
 143   3                  NRF24L01_Read_Buf ( addr[i].reg, buff, addr[i].len2 );
 144   3      
 145   3                  for ( j = 0; j < 5; j++ )
 146   3                  {
 147   4                      if ( buff[j] != addr[i].data2[j] )
 148   4                      {
 149   5                          return 0;
 150   5                      }
 151   4                  }
 152   3              }
 153   2          }
 154   1      
 155   1          return 1;
 156   1      }
 157          
 158          //向从机发送一个字节数据并返回接收数据
 159          /**************************************************/
 160          #if 0
              unsigned char SPI_WriteRead ( unsigned char byte )
              {
                  unsigned char 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;
              }
C51 COMPILER V9.53.0.0   NRF24L01_INTE                                                     09/28/2018 15:19:33 PAGE 4   

              #else
 177          unsigned char SPI_WriteRead ( unsigned char byte )
 178          {
 179   1          unsigned char i;
 180   1          SPDR = byte;            //写寄存器
 181   1      
 182   1          for ( i = 0; i < 255; i++ )
 183   1          {
 184   2              if ( SPSR & SET_BIT7 )
 185   2              {
 186   3                  break;   //等待传输
 187   3              }
 188   2          }
 189   1      
 190   1          SPSR &= ~SET_BIT7;
 191   1          byte = SPDR;            //读寄存器
 192   1          return byte;
 193   1      }
 194          
 195          #endif
 196          
 197          //写NRF24L01寄存器，返回状态值
 198          unsigned char NRF24L01_Write_Reg ( unsigned char reg, unsigned char value )
 199          {
 200   1          unsigned char BackDate;
 201   1          NRF_CE = 0;   //在写寄存器之前一定要进入待机模式或掉电模式。
 202   1          NRF_CSN = 0;
 203   1        if( reg <= 0x1F ){    //0~0x1f
 204   2            reg = NRF24L01_WRITE_REG | reg;
 205   2        }
 206   1          SPI_WriteRead ( reg );
 207   1          BackDate = SPI_WriteRead ( value );
 208   1          NRF_CSN = 1;
 209   1          NRF_CE = 1;   //恢复正常模式
 210   1          return ( BackDate );
 211   1      }
 212          //读NRF24L01寄存器，返回寄存器值
 213          unsigned char NRF24L01_Read_Reg ( unsigned char reg )
 214          {
 215   1          unsigned char BackDate;
 216   1          NRF_CSN = 0;
 217   1        if( reg <= 0x1F ){    //0~0x1f
 218   2            reg = NRF24L01_READ_REG | reg;
 219   2        }
 220   1          SPI_WriteRead ( reg );
 221   1          BackDate = SPI_WriteRead ( NRF24L01_NOP );  //NOP，无效值，用于读取
 222   1          NRF_CSN = 1;
 223   1          return ( BackDate );
 224   1      }
 225          
 226          //向缓冲区写入数据
 227          unsigned char NRF24L01_Write_Buf ( unsigned char reg, unsigned char *pBuf, unsigned char bytes )
 228          {
 229   1          unsigned char status, byte_ctr;
 230   1      
 231   1          NRF_CE = 0;   //在写寄存器之前一定要进入待机模式或掉电模式。
 232   1          NRF_CSN = 0;
 233   1        
 234   1        if( reg <= 0x1F ){    //0~0x1f
 235   2            reg = NRF24L01_WRITE_REG | reg;
 236   2        }
 237   1          status = SPI_WriteRead ( reg );
C51 COMPILER V9.53.0.0   NRF24L01_INTE                                                     09/28/2018 15:19:33 PAGE 5   

 238   1      
 239   1          for ( byte_ctr = 0; byte_ctr < bytes; byte_ctr++ )
 240   1          {
 241   2              SPI_WriteRead ( *pBuf++ );
 242   2          }
 243   1      
 244   1          NRF_CSN = 1;
 245   1          NRF_CE = 1;   //恢复正常模式
 246   1          return ( status );
 247   1      }
 248          
 249          //读取缓冲区数据
 250          void NRF24L01_Read_Buf ( unsigned char reg, unsigned char *pBuf, unsigned char bytes )
 251          {
 252   1          unsigned char byte_ctr;
 253   1          NRF_CSN = 0;
 254   1        if( reg <= 0x1F ){    //0~0x1f
 255   2            reg = NRF24L01_READ_REG | reg;
 256   2        }
 257   1          SPI_WriteRead ( reg );
 258   1      
 259   1          for ( byte_ctr = 0; byte_ctr < bytes; byte_ctr++ )
 260   1          {
 261   2              pBuf[byte_ctr] = SPI_WriteRead ( NRF24L01_NOP );  //NOP，无效值，用于读取
 262   2          }
 263   1      
 264   1          NRF_CSN = 1;
 265   1      }
 266          
 267          
 268          /*
 269          PIPEN 中断使能
 270          PINEN 正反向特性
 271          PICON 触发方式（电平或边沿检测）
 272          PIF 中断标志
 273          */
 274          void NRF24L01_Interrupt_P03 ( void )
 275          {
 276   1          //P0M1|=SET_BIT3;P0M2&=~SET_BIT3;       //input
 277   1          PICON &= ~ ( SET_BIT0 | SET_BIT1 );
 278   1          PICON |= ( 0x00 );              //[1:0]=0.端口0
 279   1          PICON |= SET_BIT5;              //通道3=1.边沿触发
 280   1          PINEN |= SET_BIT3;              // 1 = 低电平/ 下降沿触发中断
 281   1          PIPEN &= ~SET_BIT3;             //0 = 关闭中断(高电平/ 上升沿触发中断)
 282   1          EIE |= SET_BIT1;              //管脚中断，最多8个,中断号7
 283   1          EA = 1;                   // 总中断
 284   1      }
 285          
 286          
 287          
 288          
 289          uint8 NRF24L01_Wait_Param ( void );
 290          //NRF24L01初始化函数
 291          void NRF24L01_Init ( void )
 292          {
 293   1          //uint8 i;
 294   1      #if BK2423
                  //NRF_CE = 0;   //在写寄存器之前一定要进入待机模式或掉电模式。
                  NRF24L01_Write_Reg ( ACTIVATE_CMD, 0x73 );
                  //NRF_CE = 1;
              #endif
 299   1      
C51 COMPILER V9.53.0.0   NRF24L01_INTE                                                     09/28/2018 15:19:33 PAGE 6   

 300   1          NRF_CSN = 1;      // Spi disable
 301   1          NRF_SCK = 0;      // Spi clock line init high
 302   1      
 303   1          //NRF_CE = 0;   //在写寄存器之前一定要进入待机模式或掉电模式。
 304   1          //配置寄存器
 305   1          NRF24L01_FLAG |= NRF24L01_AUTO_ACK;   //是否开启应答模式
 306   1          NRF24L01_FLAG |= NRF24L01_AUTO_RX;    //发送完是否自动进入接收模式
 307   1      
 308   1      #if 0
              
                  //0-5通道接收地址,长度配置
                  for ( i = 0; i <= NRF24L01_CH_NUM_MAX; i++ )
                  {
                      NRF24L01_Write_Buf ( NRF24L01_RX_ADDR_P0 + i, RX_ADD[i], NRF24L01_ADR_LEN );  //设置接收地址
                      NRF24L01_Write_Reg ( NRF24L01_RX_PW_P0 + i, NRF24L01_ADR_LEN );       //接受通道有效宽度
                  }
              
                  NRF24L01_Write_Reg ( NRF24L01_SETUP_AW, NRF24L01_ADR_LEN - 2 ); //设置地址长度为 NRF24L01_ADR_LEN
                  NRF24L01_Write_Reg ( NRF24L01_RF_CH, RF_CH );              //设置RF通道为RFCH [6:0]
                  NRF24L01_Write_Reg ( NRF24L01_RF_SETUP, 0x07 );            //设置TX发射参数,7db增益,1Mbps,低噪声增益开
             -启
                  NRF24L01_Write_Reg ( NRF24L01_EN_AA, 0x01 );                  //使能通道0的自动应答
                  NRF24L01_Write_Reg ( NRF24L01_EN_RXADDR, 0x01 );           //使能通道0的接收地址
                  //RX模式配置
                  //NRF24L01_Write_Buf ( NRF24L01_RX_ADDR_P0, RX_ADD[0], NRF24L01_ADR_LEN ); //写RX节点地址
                  NRF24L01_Write_Reg ( NRF24L01_FEATURE, 0x05 );                  //使能动态数据包长度,AUTO_ACK模式
                  NRF24L01_Write_Reg ( NRF24L01_DYNPD, 0X01 );                    //选择通道0动态数据包长度
                  NRF24L01_Write_Reg ( NRF24L01_FLUSE_RX, NRF24L01_NOP );            //清除RX FIFO寄存器,写1清除
                  //TX模式配置
                  NRF24L01_Write_Buf ( NRF24L01_TX_ADDR , TX_ADD[RF_C_NUM], NRF24L01_ADR_LEN ); //写TX节点地址
                  NRF24L01_Write_Reg ( NRF24L01_SETUP_RETR, 0x1f );        //设置自动重发间隔时间:500us + 86us;最大自动�
             -胤⒋问�:15次
                  NRF24L01_Write_Reg ( NRF24L01_FLUSE_TX, NRF24L01_NOP );           //清除TX FIFO寄存器,写1清除
                  NRF24L01_RxMode();                                                            //默认进入接收模式
                  //NRF_CE = 1;
                  NRF24L01_Change_Working_Frequency ( 0x64 );
                  NRF24L01_Change_Data_Channel ( 2 );
              #else
 336   1          NRF24L01_Init_reg ( init_first, sizeof ( init_first ) / sizeof ( init_first[0] ) );
 337   1      #endif
 338   1      
 339   1          NRF24L01_RxMode();
 340   1          NRF24L01_Interrupt_P03();
 341   1      
 342   1          NRF24L01_Wait_Param();
 343   1      }
 344          
 345          //NRF24L01进入发送模式
 346          void NRF24L01_TxMode ( void )
 347          {
 348   1          //NRF_CE = 0;   //在写寄存器之前一定要进入待机模式或掉电模式。
 349   1      #if 0
                  NRF24L01_Write_Reg ( NRF24L01_CONFIG, 0x0e );
                  NRF24L01_Write_Reg ( NRF24L01_STATUS, 0x70 );   //清除中断标志
                  NRF24L01_Write_Reg ( NRF24L01_FLUSE_TX, NRF24L01_NOP ); //清除TX FIFO寄存器,写1清除
              #else
 354   1          NRF24L01_Init_reg ( init_send_mod, sizeof ( init_send_mod ) / sizeof ( init_send_mod[0] ) );
 355   1      #endif
 356   1          //NRF_CE = 1;
 357   1          NRF24L01_FLAG &= ~NRF24L01_MODE_RX;   //修改状态标识为发射模式
 358   1          NRF24L01_FLAG &= ~NRF24L01_BUSY;  //BUSY标志置0
 359   1          NRF24L01_FLAG &= ~NRF24L01_RECIVE;//清除有数据标志
C51 COMPILER V9.53.0.0   NRF24L01_INTE                                                     09/28/2018 15:19:33 PAGE 7   

 360   1          Timer3_Delay10us ( 1 );
 361   1      }
 362          //NRF24L01进入接收模式
 363          void NRF24L01_RxMode ( void )
 364          {
 365   1          //NRF_CE = 0;   //在写寄存器之前一定要进入待机模式或掉电模式。
 366   1      #if 0
                  NRF24L01_Write_Reg ( NRF24L01_CONFIG, 0x0f );   //配置基本工作模式的参数;PWR_UP,EN_CRC,16BIT_CRC,接收模
             -式
                  NRF24L01_Write_Reg ( NRF24L01_STATUS, 0x70 );   //清除中断标志
                  NRF24L01_Write_Reg ( NRF24L01_FLUSE_RX, NRF24L01_NOP ); //清除RX FIFO寄存器,写1清除
              #else
 371   1          NRF24L01_Init_reg ( init_recv_mod, sizeof ( init_recv_mod ) / sizeof ( init_recv_mod[0] ) );
 372   1      #endif
 373   1          //NRF_CE = 1;
 374   1          NRF24L01_FLAG |= NRF24L01_MODE_RX;    //修改状态标识为接收模式
 375   1          NRF24L01_FLAG &= ~NRF24L01_BUSY;  //BUSY标志置0
 376   1          DYNPD_LEN = 0;  //清0动态数据包长度
 377   1          NRF24L01_FLAG &= ~NRF24L01_RECIVE;//清除有数据标志
 378   1          Timer3_Delay10us ( 13 );
 379   1      }
 380          
 381          
 382          uint8 NRF24L01_Wait_Param ( void )
 383          {
 384   1          uint8 res = 1;
 385   1      #if 1
 386   1          uint8 i;
 387   1          uint8 TX_Buff[5]={0}, RX_Buff[5]={0}, FRE, CH;
 388   1          NRF24L01_Read_Buf ( NRF24L01_TX_ADDR, TX_Buff, NRF24L01_ADR_LEN );
 389   1          NRF24L01_Read_Buf ( NRF24L01_RX_ADDR_P0 + RF_C_NUM, RX_Buff, NRF24L01_ADR_LEN );
 390   1          CH = NRF24L01_Read_Reg ( NRF24L01_EN_RXADDR );
 391   1          FRE = NRF24L01_Read_Reg ( NRF24L01_RF_CH );
 392   1      
 393   1          //接收/发送地址检查
 394   1          for ( i = 0; i < ( RF_C_NUM < 2 ? 5 : 1 ); i++ )
 395   1          {
 396   2              if ( TX_Buff[i] != TX_ADD[RF_C_NUM][i] || RX_Buff[i] != RX_ADD[RF_C_NUM][i] )
 397   2              {
 398   3                  res = 0;
 399   3                  break;
 400   3              }
 401   2          }
 402   1      
 403   1          //通道使能检查
 404   1          if ( ! ( CH & ( 1 << RF_C_NUM ) ) )
 405   1          {
 406   2              res = 0;
 407   2          }
 408   1      
 409   1          //频道检查
 410   1          if ( FRE != RF_CH )
 411   1          {
 412   2              res = 0;
 413   2          }
 414   1        
 415   1          DBG (   "TX=%x %x %x %x %x\n"
 416   1            "RX=%x %x %x %x %x\n"
 417   1            "CH=%d\n"
 418   1            "FRE=%d\n", 
 419   1          TX_Buff[0], TX_Buff[1], TX_Buff[2], TX_Buff[3], TX_Buff[4],
 420   1          RX_Buff[0], RX_Buff[1], RX_Buff[2], RX_Buff[3], RX_Buff[4],
C51 COMPILER V9.53.0.0   NRF24L01_INTE                                                     09/28/2018 15:19:33 PAGE 8   

 421   1          CH,
 422   1          FRE);
 423   1      #else
                  res = NRF24L01_check_reg ( init_first, sizeof ( init_first ) / sizeof ( init_first[0] ) );
              #endif
 426   1      
 427   1          res ? ( NRF24L01_FLAG |= NRF24L01_CHECK ) : ( NRF24L01_FLAG &= ~NRF24L01_CHECK );
 428   1          return res;
 429   1      }
 430          
 431          
 432          //NRF24L01发送数据
 433          void NRF24L01_SendFrame ( unsigned char *temp, unsigned char len )
 434          {
 435   1          if ( NRF24L01_FLAG & NRF24L01_MODE_RX )
 436   1          {
 437   2              NRF24L01_TxMode();
 438   2          }
 439   1      
 440   1          NRF24L01_FLAG |= NRF24L01_BUSY; //BUSY标志置1
 441   1          NRF24L01_FLAG &= ~NRF24L01_TX_ACCESS;//清除发送成功标志
 442   1          //NRF_CE = 0;
 443   1      
 444   1          if ( NRF24L01_FLAG & NRF24L01_AUTO_ACK )
 445   1          {
 446   2              NRF24L01_Write_Buf ( NRF24L01_WR_TX_PLOAD, temp, len ); //写待发数据包,需要回应
 447   2          }
 448   1          else
 449   1          {
 450   2              NRF24L01_Write_Buf ( W_TX_PAYLOAD_NOACK_CMD, temp, len ); //写待发数据包,无须回应
 451   2          }
 452   1      
 453   1          //NRF_CE = 1;
 454   1      }
 455          
 456          //NRF24L01接收数据
 457          void NRF24L01_RecvFrame ( unsigned char *temp )
 458          {
 459   1          DYNPD_LEN = NRF24L01_Read_Reg ( R_RX_PL_WID_CMD );
 460   1      
 461   1          if ( DYNPD_LEN > 32 )
 462   1          {
 463   2              NRF24L01_RxMode();  //重新初始化接收模式
 464   2          }
 465   1          else
 466   1          {
 467   2              NRF24L01_Read_Buf ( NRF24L01_RD_RX_PLOAD, temp, DYNPD_LEN );  //读取缓冲区数据
 468   2          }
 469   1      
 470   1          NRF24L01_FLAG &= ~NRF24L01_RECIVE;//清除有数据标志
 471   1      }
 472          //更改工作频率0~7f
 473          void NRF24L01_Change_Working_Frequency ( unsigned char ch ) //0~7f
 474          {
 475   1          if ( ch > 0x7f )
 476   1          {
 477   2              return;
 478   2          }
 479   1      
 480   1          //NRF_CE = 0;
 481   1          NRF24L01_Write_Reg ( NRF24L01_RF_CH, ch & 0x7F );  //设置RF频道
 482   1          //NRF_CE = 1;
C51 COMPILER V9.53.0.0   NRF24L01_INTE                                                     09/28/2018 15:19:33 PAGE 9   

 483   1          RF_CH = ch & 0x7F;          //同步设置到系统参数
 484   1      }
 485          
 486          //更改通道0~3f
 487          void NRF24L01_Change_Data_Channel ( unsigned char ch ) //0~5
 488          {
 489   1          if ( ch > NRF24L01_CH_NUM_MAX )
 490   1          {
 491   2              return;
 492   2          }
 493   1      
 494   1          RF_C_NUM = ch;
 495   1      
 496   1          NRF24L01_Write_Reg ( NRF24L01_EN_AA, 1 << RF_C_NUM ); //通道自动应答
 497   1          NRF24L01_Write_Reg ( NRF24L01_EN_RXADDR, 1 << RF_C_NUM ); //接收通道使能
 498   1      
 499   1          NRF24L01_Write_Buf ( NRF24L01_TX_ADDR , TX_ADD[RF_C_NUM], NRF24L01_ADR_LEN ); //写TX节点地址
 500   1        NRF24L01_Write_Reg ( NRF24L01_DYNPD, 1 << RF_C_NUM ); //通道TX自动长度
 501   1      }
 502          
 503          //NRF24L01中断处理:当状态寄存器中 TX_DS、 RX_DR 或 MAX_RT 为高时触发中断。
 504          #ifdef N76E003_IAR
              #pragma vector=0x3B
              __interrupt void NRF24L01_Handler ( void )
              #else
 508          void NRF24L01_Handler ( void ) interrupt 7            //interrupt address is 0x001B
 509          #endif
 510          {
 511   1          unsigned char state, fifo_state, flag;
 512   1          clr_EPI;        //关闭管脚中断7
 513   1          flag = PIF;
 514   1          PIF = 0x00;       //清除全部标志
 515   1          state = NRF24L01_Read_Reg ( NRF24L01_STATUS );    //读NRF24L01状态寄存器
 516   1          fifo_state = NRF24L01_Read_Reg ( NRF24L01_FIFO_STATUS );    //读NRF24L01FIFO状态寄存器
 517   1          NRF24L01_Write_Reg ( NRF24L01_STATUS, state );  //清除中断,写1清除
 518   1      
 519   1          //发送成功中断
 520   1          if ( state & NRF24L01_STATUS_TX_DS )
 521   1          {
 522   2              NRF24L01_FLAG &= ~NRF24L01_BUSY;  //BUSY标志置0
 523   2              NRF24L01_FLAG |= NRF24L01_TX_ACCESS;//发送成功标志置1
 524   2      
 525   2              if ( NRF24L01_FLAG & NRF24L01_AUTO_RX )
 526   2              {
 527   3                  NRF24L01_RxMode();  //重新初始化接收模式
 528   3              }
 529   2          }
 530   1      
 531   1          //达到最大重发次数中断
 532   1          if ( state & NRF24L01_STATUS_MAX_RT )
 533   1          {
 534   2              NRF24L01_Write_Reg ( NRF24L01_FLUSE_TX, NRF24L01_NOP );  //清除TX FIFO寄存器,写1清除
 535   2              NRF24L01_FLAG &= ~NRF24L01_BUSY;  //BUSY标志置0
 536   2              NRF24L01_FLAG &= ~NRF24L01_TX_ACCESS;//发送成功标志置0
 537   2          }
 538   1      
 539   1          //接收到数据中断
 540   1          if ( state & NRF24L01_STATUS_RX_DR )
 541   1          {
 542   2              NRF24L01_FLAG |= NRF24L01_RECIVE; //接收到数据标志位置1
 543   2          }
 544   1      
C51 COMPILER V9.53.0.0   NRF24L01_INTE                                                     09/28/2018 15:19:33 PAGE 10  

 545   1          //TX_FIFO满中断
 546   1          if ( state & NRF24L01_STATUS_TX_FULL )
 547   1          {
 548   2              NRF24L01_TxMode();  //重新初始化发射模式
 549   2          }
 550   1      
 551   1          //RX_FIFO满
 552   1          if ( fifo_state & NRF24L01_STATUS_RX_FULL )
 553   1          {
 554   2              NRF24L01_RxMode();  //重新初始化接收模式
 555   2          }
 556   1      
 557   1          state = NRF24L01_Read_Reg ( NRF24L01_CONFIG );    //读NRF24L01状态寄存器
 558   1          set_EPI;        //开启管脚中断7
 559   1      }


MODULE INFORMATION:   STATIC OVERLAYABLE
   CODE SIZE        =   2533    ----
   CONSTANT SIZE    =     60    ----
   XDATA SIZE       =    288    ----
   PDATA SIZE       =   ----    ----
   DATA SIZE        =   ----    ----
   IDATA SIZE       =   ----    ----
   BIT SIZE         =   ----    ----
END OF MODULE INFORMATION.


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