⭐ 欢迎来到虫虫下载站! | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站

📄 cpu_com.lst

📁 keil下ISO7816规则的APDU程序
💻 LST
📖 第 1 页 / 共 4 页
字号:
 231   2                      while(!F_TM);
 232   2      
 233   2                      TH0 = 0x43;
 234   2                      TIMER0_ENABLE;                                  //(11+0.135)etu
 235   2                      if(BT_SND == 0)                                 //如果IC卡有误
 236   2                      {
 237   3                              if(b == 4)
 238   3                                      return FALSE;
C51 COMPILER V7.50   CPU_COM                                                               05/16/2006 17:45:20 PAGE 5   

 239   3                              F_TM=0;
 240   3                              while(!F_TM);
 241   3                              F_TM=0;
 242   3                              while(!F_TM);
 243   3      //                      TH0 = 0x45;
 244   3      //                      TIMER0_ENABLE;                                  //(11+0.135)etu   11etu处检测
 245   3                              b++;
 246   3                              ch = bak;
 247   3                              goto start1;
 248   3                      }
 249   2                      TH0 = 0x55;
 250   2                      TIMER0_ENABLE;
 251   2                      F_TM=0;
 252   2                      while(!F_TM);
 253   2                  for(i=0;i<Extra_guardtime_N;i++)
 254   2                      {       
 255   3                              TH0 = 0x57;
 256   3                              TIMER0_ENABLE;
 257   3                              F_TM=0;
 258   3                              while(!F_TM);
 259   3                      }
 260   2                      TIMER0_DISABLE;                                 //停止定时器
 261   2                      return TRUE;
 262   2              }
 263   1      }
 264          //=======================================================================
 265          /*===接收一个字符(*ndata)返回如果为FALSE表示数据和校验位不符合将口线拉低后
 266          //等待两个ETU后从新接收,但不包括接收ATR
 267          FALSE1表示超时============================TRUE则成功==========*/
 268          unsigned char GetChar(unsigned char *ndata1)
 269          {   
 270   1              unsigned char i = 0,ch = 0,b = 0;//,a1;         //i:位计数,ch:接收的字符存储位置
 271   1          unsigned char idata count = 0;              //超时计数器
 272   1              unsigned int  idata count1 = 0;
 273   1              bit a = 0,a1 = 0;
 274   1              if(CPUCD_Format == 0)
 275   1              {
 276   2      statr:
 277   2              while(BT_REC)                                   //等待开始位
 278   2                      {
 279   3                              count++;
 280   3                              if(count == 0xFF)
 281   3                              {
 282   4      //                              count = 0;
 283   4                                      count1++;
 284   4                                      if(count1 == 0x0415)
 285   4                                      {
 286   5      //                                      if(tc2 == 0)
 287   5                                                      return FALSE1;                  //等待起始位超时
 288   5      //                                      else
 289   5      //                                      {
 290   5      //                                              count1 = 0;
 291   5      //                                              tc2 = tc2-1;
 292   5      //                                      }
 293   5                                      }
 294   4                              }
 295   3                              
 296   3                      }
 297   2      
 298   2      /*----接收一个字节的数据-----*/
 299   2                      //TIMER0_ENABLE;                                //启动定时器
 300   2                      for(i=0;i<=1;i++);
C51 COMPILER V7.50   CPU_COM                                                               05/16/2006 17:45:20 PAGE 6   

 301   2                      TH0 = 0x8F;
 302   2                      TL0 = 0x8F;
 303   2      //              TH0 = 0xA0;
 304   2      //              TL0 = 0xA0;
 305   2                      TR0 = 1;
 306   2                      //TH0 = 0x9;
 307   2                      //TH0=0XB0;
 308   2                      //F_TM = 0;
 309   2              while(i<10)
 310   2                      {
 311   3                      F_TM = 0; 
 312   3                              while(!F_TM);                           //等待溢出准备接收一个字节的数据
 313   3                              ch>>=1;
 314   3                      if(BT_REC)
 315   3                      {       
 316   4                                      TH0 = 0xB2;
 317   4                                      TIMER0_ENABLE;
 318   4                              ch|=0x80;
 319   4                              a = (~a);
 320   4                      }
 321   3                              else
 322   3                              {
 323   4                                      TH0 = 0xB2;
 324   4                                      TIMER0_ENABLE;
 325   4                                      ch = ch;
 326   4                                      a = a;
 327   4                              }
 328   3                      i++;
 329   3              }
 330   2                      //TH0=0XB0;
 331   2                      //TIMER0_ENABLE;
 332   2                      F_TM = 0; 
 333   2                      while(!F_TM);                                   //等待溢出准备接收一个字节的数据
 334   2                      _nop_();
 335   2                      _nop_();
 336   2                      _nop_();
 337   2                      _nop_();
 338   2                      if(BT_REC)
 339   2                              a1 = 1;
 340   2                      else
 341   2                              a1 = 0;
 342   2                      TH0 = 0xB3; 
 343   2                      TIMER0_ENABLE;
 344   2                      F_TM = 0; 
 345   2                      while(!F_TM);                                   //等待溢出准备接收一个字节的数据
 346   2                      if(a1!=a)
 347   2              {       
 348   3                              //TIMER0_DISABLE ;                      //停止定时器
 349   3                      BT_REC = 0;                                     //10.5etu
 350   3                              if(b == 4)
 351   3                                      return FALSE;
 352   3                              b++;
 353   3                              F_TM = 0; 
 354   3                              while(!F_TM);                           //等待溢出准备接收一个字节的数据
 355   3                              F_TM = 0; 
 356   3                              TH0 = 0xAE;
 357   3                              TIMER0_ENABLE
 358   3                              while(!F_TM);                           //等待溢出准备接收一个字节的数据
 359   3                              BT_REC = 1;
 360   3      //                      F_TM = 0;
 361   3      //                      TL0 = 0xF0;
 362   3      //                      while(!F_TM);                           //等待溢出准备接收一个字节的数据
C51 COMPILER V7.50   CPU_COM                                                               05/16/2006 17:45:20 PAGE 7   

 363   3                              //BT_REC =1;
 364   3                              goto statr;                                     //接收数据发生错误
 365   3                      }
 366   2                      else
 367   2                      {
 368   3                              TR0=0;
 369   3                      *ndata1 = ch;                                   //将接收的数据以ndata指针返回 
 370   3                              //BT_REC=1;
 371   3                      }
 372   2                      return TRUE;                                    //正确接送数据
 373   2              }
 374   1              else
 375   1              {
 376   2      stara1:
 377   2              while(BT_REC)                                   //等待开始位
 378   2                      {
 379   3                              count++;
 380   3                              if(count == 0xFF)
 381   3                              {
 382   4      //                              count = 0;
 383   4                                      count1++;
 384   4                                      if(count1 == 0x0430)
 385   4                                      {
 386   5                                              if(tc2 == 0)
 387   5                                                      return FALSE1;                  //等待起始位超时
 388   5                                              else
 389   5                                              {
 390   6                                                      tc2--;
 391   6                                                      count1 = 0;
 392   6                                              }
 393   5                                      }
 394   4                              }
 395   3                              
 396   3                      }
 397   2      
 398   2      /*----接收一个字节的数据-----*/
 399   2                      //TIMER0_ENABLE;                                //启动定时器
 400   2                      for(i=0;i<=1;i++);
 401   2                      TH0 = 0x00;
 402   2                      TL0 = 0x00;
 403   2                      TR0 = 1;
 404   2                      //TH0 = 0x9;
 405   2                      //TH0=0XB0;
 406   2                      //F_TM = 0;
 407   2              while(i<10)
 408   2                      {
 409   3                      F_TM = 0; 
 410   3                              while(!F_TM);                           //等待溢出准备接收一个字节的数据
 411   3                              ch<<=1;
 412   3                      if(BT_REC)
 413   3                      {       
 414   4                                      TH0 = 0x50;
 415   4                                      TIMER0_ENABLE;
 416   4                              ch|=1;
 417   4                              a = (~a);
 418   4                      }
 419   3                              else
 420   3                              {       
 421   4                                      TH0 = 0x50;
 422   4                                      TIMER0_ENABLE;
 423   4                                      ch = ch;
 424   4                                      a = a;
C51 COMPILER V7.50   CPU_COM                                                               05/16/2006 17:45:20 PAGE 8   

 425   4                              }
 426   3      //                      TH0=0XB4;
 427   3      //                      TIMER0_ENABLE;
 428   3                      i++;
 429   3              }
 430   2                      //TH0=0XB0;
 431   2                      //TIMER0_ENABLE;
 432   2                      F_TM = 0; 
 433   2                      while(!F_TM);                                   //等待溢出准备接收一个字节的数据
 434   2                      if(BT_REC)
 435   2                              a1 = 1;
 436   2                      else
 437   2                              a1 = 0;
 438   2                      TH0 = 0x50; 
 439   2                      TIMER0_ENABLE;
 440   2                      F_TM = 0; 
 441   2                      while(!F_TM);                                   //等待溢出准备接收一个字节的数据
 442   2                      if(a1!=a)
 443   2              {       
 444   3                              //TIMER0_DISABLE ;                      //停止定时器
 445   3                      BT_REC = 0;                                     //10.5etu
 446   3                              if(b == 4)
 447   3                                      return FALSE;
 448   3                              b++;
 449   3                              F_TM = 0; 
 450   3                              while(!F_TM);                           //等待溢出准备接收一个字节的数据
 451   3                              F_TM = 0; 
 452   3                              while(!F_TM);                           //等待溢出准备接收一个字节的数据
 453   3                              BT_REC = 1;
 454   3      //                      F_TM = 0;
 455   3      //                      TL0 = 0xF0;
 456   3      //                      while(!F_TM);                           //等待溢出准备接收一个字节的数据
 457   3                              //BT_REC =1;
 458   3                              goto stara1;                            //接收数据发生错误
 459   3                      }
 460   2                      else
 461   2                      {
 462   3                              TR0 = 0;;
 463   3                      *ndata1 = ~ch;                                  //将接收的数据以ndata指针返回 
 464   3                              //BT_REC=1;
 465   3                      }
 466   2                      return TRUE;
 467   2              }
 468   1      }
 469          //触点激活子程序冷复位
 470          /*///KTD1101

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -