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

📄 m500auc.lst

📁 51+rc500阅读器源码程序
💻 LST
📖 第 1 页 / 共 5 页
字号:
C51 COMPILER V7.06   M500AUC                                                               03/16/2008 20:55:11 PAGE 1   


C51 COMPILER V7.06, COMPILATION OF MODULE M500AUC
OBJECT MODULE PLACED IN M500AuC.OBJ
COMPILER INVOKED BY: C:\Program Files\C51\BIN\C51.EXE M500AuC.c BROWSE DEBUG OBJECTEXTEND

stmt level    source

   1          #define M500_GLOBALS
   2          
   3          #include <string.h>
   4          #include <stdio.h>
   5          #include <absacc.h>
   6          #include <intrins.h>
   7          
   8          #include "Mfreg500.h"
   9          #include "MfErrNo.h"
  10          #include "reg52.h"
  11          #include "M500AuC.h"
  12          
  13          #define GetRegPage(addr)    (0x80 | (addr>>3))
  14          #define nocard                      0
  15          #define mifare1                     1
  16          #define mifarepro                   2
  17          #define mifarelight                 3
  18          #define unknowncard                 4
  19          #define NO_TIMER2           1
  20          
  21          ///////////////////////////////////////////////////////////////////////
  22          // 往一个地址写一个数据
  23          ///////////////////////////////////////////////////////////////////////
  24          void WriteRawIO(unsigned char Address,unsigned char value)
  25          {
  26   1              unsigned int Add;
  27   1          
  28   1          Add = Address & 0x7fff;
  29   1          XBYTE[Add] = value;
  30   1              //XBYTE[Address] = value;
  31   1      }
  32          
  33          ///////////////////////////////////////////////////////////////////////
  34          // 从一个地址读出一个数据
  35          ///////////////////////////////////////////////////////////////////////
  36          unsigned char ReadRawIO(unsigned char Address)
  37          {
  38   1              unsigned int Add;
  39   1              
  40   1              Add = Address & 0x7fff;
  41   1              return XBYTE[Add];
  42   1              //return XBYTE[Address];
  43   1      }
  44          
  45          ///////////////////////////////////////////////////////////////////////
  46          // 往一个地址写一个数据(EEPROM)
  47          ///////////////////////////////////////////////////////////////////////
  48          void WriteIO(unsigned char Address, unsigned char value)
  49          {
  50   1          WriteRawIO(0x00,GetRegPage(Address));  
  51   1          WriteRawIO(Address,value);              
  52   1      }
  53          
  54          ///////////////////////////////////////////////////////////////////////
  55          // 从一个地址读出一个数据(EEPROM)
C51 COMPILER V7.06   M500AUC                                                               03/16/2008 20:55:11 PAGE 2   

  56          ///////////////////////////////////////////////////////////////////////
  57          unsigned char ReadIO(unsigned char Address)
  58          {
  59   1         WriteRawIO(0x00,GetRegPage(Address));
  60   1         return ReadRawIO(Address);                    
  61   1      }  
  62          
  63          ///////////////////////////////////////////////////////////////////////
  64          // 设置定时时间
  65          ///////////////////////////////////////////////////////////////////////
  66          void M500PcdSetTmo(unsigned char tmoLength)
  67          {
  68   1          switch(tmoLength)
  69   1          {  
  70   2              case 1:                       
  71   2                  WriteIO(RegTimerClock,0x07); 
  72   2                  WriteIO(RegTimerReload,0x6a);
  73   2                  break;
  74   2              case 2:                       
  75   2                  WriteIO(RegTimerClock,0x07); 
  76   2                  WriteIO(RegTimerReload,0xa0);
  77   2                  break;
  78   2              case 3:  
  79   2                  WriteIO(RegTimerClock,0x09); 
  80   2                  WriteIO(RegTimerReload,0xa0);
  81   2                  break;
  82   2              case 4: 
  83   2                  WriteIO(RegTimerClock,0x09);
  84   2                  WriteIO(RegTimerReload,0xff);
  85   2                  break;
  86   2              case 5:  
  87   2                  WriteIO(RegTimerClock,0x0b); 
  88   2                  WriteIO(RegTimerReload,0xff);
  89   2                  break;
  90   2              case 6:                       
  91   2                  WriteIO(RegTimerClock,0x0d); 
  92   2                  WriteIO(RegTimerReload,0xff);
  93   2                  break;
  94   2              case 7:                      
  95   2                  WriteIO(RegTimerClock,0x0f); 
  96   2                  WriteIO(RegTimerReload,0xff);
  97   2                  break;
  98   2              default:                       
  99   2                  WriteIO(RegTimerClock,0x07); 
 100   2                  WriteIO(RegTimerReload,tmoLength);
 101   2                  break;
 102   2          }     
 103   1      }
 104          
 105          ///////////////////////////////////////////////////////////////////////
 106          // Request Command defined in ISO14443(Mifare)
 107          //Mifare定义在ISO14443请求命令
 108          ///////////////////////////////////////////////////////////////////////
 109          char  M500PcdCmd(unsigned char cmd,
 110                         volatile unsigned char data *rcv,
 111                          MfCmdInfo idata *info)
 112          {
 113   1          char          idata status    = MI_OK;
 114   1          char          idata tmpStatus ;
 115   1          unsigned char idata lastBits;
 116   1          unsigned int  idata timecnt = 0;
 117   1          unsigned char idata irqEn = 0x00;
C51 COMPILER V7.06   M500AUC                                                               03/16/2008 20:55:11 PAGE 3   

 118   1          unsigned char idata waitFor = 0x00;
 119   1          unsigned char idata timerCtl  = 0x00;
 120   1      
 121   1          WriteIO(RegInterruptEn,0x7F);
 122   1          WriteIO(RegInterruptRq,0x7F);
 123   1          WriteIO(RegCommand,PCD_IDLE); 
 124   1      
 125   1          FlushFIFO();     
 126   1          MpIsrInfo = info;  
 127   1          MpIsrOut = rcv;
 128   1          info->irqSource = 0x00;
 129   1          switch(cmd)
 130   1          {
 131   2              case PCD_IDLE:                
 132   2                  irqEn = 0x00;
 133   2                  waitFor = 0x00;
 134   2                  break;
 135   2              case PCD_WRITEE2:            
 136   2                  irqEn = 0x11;
 137   2                  waitFor = 0x10;
 138   2                  break;
 139   2              case PCD_READE2:     
 140   2                  irqEn = 0x07;
 141   2                  waitFor = 0x04;
 142   2                  break;
 143   2              case PCD_LOADCONFIG:  
 144   2              case PCD_LOADKEYE2:   
 145   2              case PCD_AUTHENT1:    
 146   2                  irqEn = 0x05;
 147   2                  waitFor = 0x04;
 148   2                  break;
 149   2              case PCD_CALCCRC:
 150   2                  irqEn = 0x11;
 151   2                  waitFor = 0x10;
 152   2                  break;
 153   2              case PCD_AUTHENT2: 
 154   2                  irqEn = 0x04;
 155   2                  waitFor = 0x04;
 156   2                  break;
 157   2              case PCD_RECEIVE:     
 158   2                  info->nBitsReceived = -(ReadIO(RegBitFraming) >> 4);
 159   2                  irqEn = 0x06;
 160   2                  waitFor = 0x04;
 161   2                  break;
 162   2              case PCD_LOADKEY: 
 163   2                  irqEn = 0x05;
 164   2                  waitFor = 0x04;
 165   2                  break;
 166   2              case PCD_TRANSMIT: 
 167   2                  irqEn = 0x05;
 168   2                  waitFor = 0x04;
 169   2                  break;
 170   2              case PCD_TRANSCEIVE: 
 171   2                      info->nBitsReceived = -(ReadIO(RegBitFraming) >> 4);
 172   2                  irqEn = 0x3D;
 173   2                  waitFor = 0x04;
 174   2                  break;
 175   2              default:
 176   2                  status = MI_UNKNOWN_COMMAND;
 177   2          }        
 178   1          if (status == MI_OK)
 179   1          {
C51 COMPILER V7.06   M500AUC                                                               03/16/2008 20:55:11 PAGE 4   

 180   2              irqEn |= 0x20;                     
 181   2              waitFor |= 0x20;      
 182   2              timecnt=1000;
 183   2              WriteIO(RegInterruptEn,irqEn | 0x80); 
 184   2              WriteIO(RegCommand,cmd);     
 185   2              while (!(MpIsrInfo->irqSource & waitFor||!(timecnt--)));
 186   2              WriteIO(RegInterruptEn,0x7F);         
 187   2              WriteIO(RegInterruptRq,0x7F);          
 188   2              SetBitMask(RegControl,0x04);          
 189   2              WriteIO(RegCommand,PCD_IDLE);         
 190   2              if (!(MpIsrInfo->irqSource & waitFor))   
 191   2              {                               
 192   3                  status = MI_ACCESSTIMEOUT;
 193   3              }
 194   2              else
 195   2              {
 196   3                  status = MpIsrInfo->status;           
 197   3              }
 198   2              if (status == MI_OK)                    
 199   2              {
 200   3                  if (tmpStatus = (ReadIO(RegErrorFlag) & 0x17))
 201   3                  {
 202   4                      if (tmpStatus & 0x01)
 203   4                      {
 204   5                          info->collPos = ReadIO(RegCollPos);
 205   5                          status = MI_COLLERR;
 206   5                      }
 207   4                      else
 208   4                      {
 209   5                          info->collPos = 0;
 210   5                          if (tmpStatus & 0x02)  
 211   5                          {
 212   6                              status = MI_PARITYERR;
 213   6                          }
 214   5                      }
 215   4                      if (tmpStatus & 0x04)   
 216   4                      {
 217   5                          status = MI_FRAMINGERR;
 218   5                      }
 219   4                      if (tmpStatus & 0x10)   
 220   4                      {
 221   5                          FlushFIFO();
 222   5                          status = MI_OVFLERR;
 223   5                      }
 224   4                          if (tmpStatus & 0x08) 
 225   4                          {
 226   5                          status = MI_CRCERR;
 227   5                          }   
 228   4                      if (status == MI_OK)
 229   4                          status = MI_NY_IMPLEMENTED;
 230   4                  }
 231   3                  if (cmd == PCD_TRANSCEIVE)
 232   3                  {
 233   4                      lastBits = ReadIO(RegSecondaryStatus) & 0x07;
 234   4                      if (lastBits)
 235   4                          info->nBitsReceived += (info->nBytesReceived-1) * 8 + lastBits;
 236   4                      else
 237   4                          info->nBitsReceived += info->nBytesReceived * 8;
 238   4                  }
 239   3              }
 240   2              else
 241   2              {
C51 COMPILER V7.06   M500AUC                                                               03/16/2008 20:55:11 PAGE 5   

 242   3                  info->collPos = 0x00;
 243   3              }
 244   2          }
 245   1          MpIsrInfo = 0;         
 246   1          MpIsrOut  = 0;
 247   1          return status;
 248   1      }   
 249          
 250          ///////////////////////////////////////////////////////////////////////
 251          // 置一个bit
 252          ///////////////////////////////////////////////////////////////////////
 253          char SetBitMask(unsigned char reg,unsigned char mask)  
 254          {
 255   1          char idata tmp = 0x00;
 256   1      
 257   1          tmp = ReadIO(reg);
 258   1          WriteIO(reg,tmp | mask);  // set bit mask
 259   1          return 0x00;
 260   1      }
 261          
 262          ///////////////////////////////////////////////////////////////////////
 263          // 清一个bit
 264          ///////////////////////////////////////////////////////////////////////
 265          char ClearBitMask(unsigned char reg,unsigned char mask)  
 266          {
 267   1          char idata tmp = 0x00;
 268   1      
 269   1          tmp = ReadIO(reg);
 270   1          WriteIO(reg,tmp & ~mask);  // clear bit mask
 271   1          return 0x00;

⌨️ 快捷键说明

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