设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › 基于STC89C52的MF RC522门禁卡 代码
返回列表 发新帖
查看: 3344|回复: 1
打印 上一主题 下一主题
收起左侧

基于STC89C52的MF RC522门禁卡 代码

[复制链接]
跳转到指定楼层
楼主
ID:398765 发表于 2018-12-16 23:47 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
  1. #include <intrins.h>
  2. #include "reg52.h"
  3. #include "main.h"
  4. #include "mfrc522.h"
  5. #include <string.h>
  6. #define MAXRLEN 18                        
  7. /////////////////////////////////////////////////////////////////////
  8. //功    能：寻卡
  9. //参数说明: req_code[IN]:寻卡方式
  10. //                0x52 = 寻感应区内所有符合14443A标准的卡
  11. //                0x26 = 寻未进入休眠状态的卡
  12. //          pTagType[OUT]：卡片类型代码
  13. //                0x4400 = Mifare_UltraLight
  14. //                0x0400 = Mifare_One(S50)
  15. //                0x0200 = Mifare_One(S70)
  16. //                0x0800 = Mifare_Pro(X)
  17. //                0x4403 = Mifare_DESFire
  18. //返    回: 成功返回MI_OK
  19. /////////////////////////////////////////////////////////////////////
  20. char PcdRequest(unsigned char req_code,unsigned char *pTagType)
  21. {
  22.    char status;  
  23.    unsigned int  unLen;
  24.    unsigned char ucComMF522Buf[MAXRLEN];
  25. // unsigned char xTest ;
  26.    ClearBitMask(Status2Reg,0x08);
  27.    WriteRawRC(BitFramingReg,0x07);
  28. // xTest = ReadRawRC(BitFramingReg);
  29. // if(xTest == 0x07 )
  30. // { LED_GREEN  =0 ;}
  31. // else {LED_GREEN =1 ;while(1){}}
  32.    SetBitMask(TxControlReg,0x03);
  33.    ucComMF522Buf[0] = req_code;
  34.    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,1,ucComMF522Buf,&unLen);
  35. // if(status  == MI_OK )
  36. // { LED_GREEN  =0 ;}
  37. // else {LED_GREEN =1 ;}
  38.    if ((status == MI_OK) && (unLen == 0x10))
  39.    {   
  40.        *pTagType     = ucComMF522Buf[0];
  41.        *(pTagType+1) = ucComMF522Buf[1];
  42.    }
  43.    else
  44.    {   status = MI_ERR;   }
  45.    return status;
  46. }

  48. /////////////////////////////////////////////////////////////////////
  49. //功    能：防冲撞
  50. //参数说明: pSnr[OUT]:卡片序列号，4字节
  51. //返    回: 成功返回MI_OK
  52. /////////////////////////////////////////////////////////////////////  
  53. char PcdAnticoll(unsigned char *pSnr)
  54. {
  55.     char status;
  56.     unsigned char i,snr_check=0;
  57.     unsigned int  unLen;
  58.     unsigned char ucComMF522Buf[MAXRLEN];
  59.    

  61.     ClearBitMask(Status2Reg,0x08);
  62.     WriteRawRC(BitFramingReg,0x00);
  63.     ClearBitMask(CollReg,0x80);
  64.     ucComMF522Buf[0] = PICC_ANTICOLL1;
  65.     ucComMF522Buf[1] = 0x20;
  66.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,2,ucComMF522Buf,&unLen);
  67.     if (status == MI_OK)
  68.     {
  69.              for (i=0; i<4; i++)
  70.          {   
  71.              *(pSnr+i)  = ucComMF522Buf[i];
  72.              snr_check ^= ucComMF522Buf[i];
  73.          }
  74.          if (snr_check != ucComMF522Buf[i])
  75.          {   status = MI_ERR;    }
  76.     }
  77.     SetBitMask(CollReg,0x80);
  78.     return status;
  79. }
  80. /////////////////////////////////////////////////////////////////////
  81. //功    能：选定卡片
  82. //参数说明: pSnr[IN]:卡片序列号，4字节
  83. //返    回: 成功返回MI_OK
  84. /////////////////////////////////////////////////////////////////////
  85. char PcdSelect(unsigned char *pSnr)
  86. {
  87.     char status;
  88.     unsigned char i;
  89.     unsigned int  unLen;
  90.     unsigned char ucComMF522Buf[MAXRLEN];   
  91.     ucComMF522Buf[0] = PICC_ANTICOLL1;
  92.     ucComMF522Buf[1] = 0x70;
  93.     ucComMF522Buf[6] = 0;
  94.     for (i=0; i<4; i++)
  95.     {
  96.             ucComMF522Buf[i+2] = *(pSnr+i);
  97.             ucComMF522Buf[6]  ^= *(pSnr+i);
  98.     }
  99.     CalulateCRC(ucComMF522Buf,7,&ucComMF522Buf[7]);
  100.     ClearBitMask(Status2Reg,0x08);
  101.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);  
  102.     if ((status == MI_OK) && (unLen == 0x18))
  103.     {   status = MI_OK;  }
  104.     else
  105.     {   status = MI_ERR;    }
  106.     return status;
  107. }

  109. /////////////////////////////////////////////////////////////////////
  110. //功    能：验证卡片密码
  111. //参数说明: auth_mode[IN]: 密码验证模式
  112. //                 0x60 = 验证A密钥
  113. //                 0x61 = 验证B密钥
  114. //          addr[IN]：块地址
  115. //          pKey[IN]：密码
  116. //          pSnr[IN]：卡片序列号，4字节
  117. //返    回: 成功返回MI_OK
  118. /////////////////////////////////////////////////////////////////////               
  119. char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr)
  120. {
  121.     char status;
  122.     unsigned int  unLen;
  123.     unsigned char i,ucComMF522Buf[MAXRLEN];
  124.     ucComMF522Buf[0] = auth_mode;
  125.     ucComMF522Buf[1] = addr;
  126.     for (i=0; i<6; i++)
  127.     {    ucComMF522Buf[i+2] = *(pKey+i);   }
  128.     for (i=0; i<6; i++)
  129.     {    ucComMF522Buf[i+8] = *(pSnr+i);   }
  130. //   memcpy(&ucComMF522Buf[2], pKey, 6);
  131. //   memcpy(&ucComMF522Buf[8], pSnr, 4);  
  132.     status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
  133.     if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
  134.     {   status = MI_ERR;   }  
  135.     return status;
  136. }

  138. /////////////////////////////////////////////////////////////////////
  139. //功    能：读取M1卡一块数据
  140. //参数说明: addr[IN]：块地址
  141. //          pData[OUT]：读出的数据，16字节
  142. //返    回: 成功返回MI_OK
  143. /////////////////////////////////////////////////////////////////////
  144. char PcdRead(unsigned char addr,unsigned char *pData)
  145. {
  146.     char status;
  147.     unsigned int  unLen;
  148.     unsigned char i,ucComMF522Buf[MAXRLEN];
  149.     ucComMF522Buf[0] = PICC_READ;
  150.     ucComMF522Buf[1] = addr;
  151.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);  
  152.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
  153.     if ((status == MI_OK) && (unLen == 0x90))
  154. //   {   memcpy(pData, ucComMF522Buf, 16);   }
  155.     {
  156.         for (i=0; i<16; i++)
  157.         {    *(pData+i) = ucComMF522Buf[i];   }
  158.     }
  159.     else
  160.     {   status = MI_ERR;   }   
  161.     return status;
  162. }

  164. /////////////////////////////////////////////////////////////////////
  165. //功    能：写数据到M1卡一块
  166. //参数说明: addr[IN]：块地址
  167. //          pData[IN]：写入的数据，16字节
  168. //返    回: 成功返回MI_OK
  169. /////////////////////////////////////////////////////////////////////                  
  170. char PcdWrite(unsigned char addr,unsigned char *pData)
  171. {
  172.     char status;
  173.     unsigned int  unLen;
  174.     unsigned char i,ucComMF522Buf[MAXRLEN];   
  175.     ucComMF522Buf[0] = PICC_WRITE;
  176.     ucComMF522Buf[1] = addr;
  177.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
  178.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
  179.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  180.     {   status = MI_ERR;   }     
  181.     if (status == MI_OK)
  182.     {
  183.         //memcpy(ucComMF522Buf, pData, 16);
  184.         for (i=0; i<16; i++)
  185.         {    ucComMF522Buf[i] = *(pData+i);   }
  186.         CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16]);
  187.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,18,ucComMF522Buf,&unLen);
  188.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  189.         {   status = MI_ERR;   }
  190.     }   
  191.     return status;
  192. }
  193. /////////////////////////////////////////////////////////////////////
  194. //功    能：命令卡片进入休眠状态
  195. //返    回: 成功返回MI_OK
  196. /////////////////////////////////////////////////////////////////////
  197. char PcdHalt(void)
  198. {
  199.     char status;
  200.     unsigned int  unLen;
  201.     unsigned char ucComMF522Buf[MAXRLEN];
  202.     ucComMF522Buf[0] = PICC_HALT;
  203.     ucComMF522Buf[1] = 0;
  204.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
  205.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
  206.     return MI_OK;
  207. }

  209. /////////////////////////////////////////////////////////////////////
  210. //用MF522计算CRC16函数
  211. /////////////////////////////////////////////////////////////////////
  212. void CalulateCRC(unsigned char *pIndata,unsigned char len,unsigned char *pOutData)
  213. {
  214.     unsigned char i,n;
  215.     ClearBitMask(DivIrqReg,0x04);
  216.     WriteRawRC(CommandReg,PCD_IDLE);
  217.     SetBitMask(FIFOLevelReg,0x80);
  218.     for (i=0; i<len; i++)
  219.     {   WriteRawRC(FIFODataReg, *(pIndata+i));   }
  220.     WriteRawRC(CommandReg, PCD_CALCCRC);
  221.     i = 0xFF;
  222.     do
  223.     {
  224.         n = ReadRawRC(DivIrqReg);
  225.         i--;
  226.     }
  227.     while ((i!=0) && !(n&0x04));
  228.     pOutData[0] = ReadRawRC(CRCResultRegL);
  229.     pOutData[1] = ReadRawRC(CRCResultRegM);
  230. }

  232. /////////////////////////////////////////////////////////////////////
  233. //功    能：复位RC522
  234. //返    回: 成功返回MI_OK
  235. /////////////////////////////////////////////////////////////////////
  236. char PcdReset(void)
  237. {
  238.     MF522_RST=1;
  239.     _nop_();
  240.     MF522_RST=0;
  241.     _nop_();
  242.     MF522_RST=1;
  243.      _nop_();
  244.     WriteRawRC(CommandReg,PCD_RESETPHASE);
  245.     _nop_();
  246.    
  247.     WriteRawRC(ModeReg,0x3D);            //和Mifare卡通讯，CRC初始值0x6363
  248.     WriteRawRC(TReloadRegL,30);           
  249.     WriteRawRC(TReloadRegH,0);
  250.     WriteRawRC(TModeReg,0x8D);
  251.     WriteRawRC(TPrescalerReg,0x3E);
  252.     WriteRawRC(TxAutoReg,0x40);     
  253.     return MI_OK;
  254. }
  255. //////////////////////////////////////////////////////////////////////
  256. //设置RC632的工作方式
  257. //////////////////////////////////////////////////////////////////////
  258. char M500PcdConfigISOType(unsigned char type)
  259. {
  260.    if (type == 'A')                     //ISO14443_A
  261.    {
  262.        ClearBitMask(Status2Reg,0x08);

  264. /*     WriteRawRC(CommandReg,0x20);    //as default   
  265.        WriteRawRC(ComIEnReg,0x80);     //as default
  266.        WriteRawRC(DivlEnReg,0x0);      //as default
  267.            WriteRawRC(ComIrqReg,0x04);     //as default
  268.            WriteRawRC(DivIrqReg,0x0);      //as default
  269.            WriteRawRC(Status2Reg,0x0);//80    //trun off temperature sensor
  270.            WriteRawRC(WaterLevelReg,0x08); //as default
  271.        WriteRawRC(ControlReg,0x20);    //as default
  272.            WriteRawRC(CollReg,0x80);    //as default
  273. */
  274.        WriteRawRC(ModeReg,0x3D);//3F
  275. /*           WriteRawRC(TxModeReg,0x0);      //as default???
  276.            WriteRawRC(RxModeReg,0x0);      //as default???
  277.            WriteRawRC(TxControlReg,0x80);  //as default???

  279.            WriteRawRC(TxSelReg,0x10);      //as default???
  280.    */
  281.        WriteRawRC(RxSelReg,0x86);//84
  282. //      WriteRawRC(RxThresholdReg,0x84);//as default
  283. //      WriteRawRC(DemodReg,0x4D);      //as default

  285. //      WriteRawRC(ModWidthReg,0x13);//26
  286.        WriteRawRC(RFCfgReg,0x7F);   //4F
  287.         /*   WriteRawRC(GsNReg,0x88);        //as default???
  288.            WriteRawRC(CWGsCfgReg,0x20);    //as default???
  289.        WriteRawRC(ModGsCfgReg,0x20);   //as default???
  290. */
  291.               WriteRawRC(TReloadRegL,30);//tmoLength);// TReloadVal = 'h6a =tmoLength(dec)
  292.            WriteRawRC(TReloadRegH,0);
  293.        WriteRawRC(TModeReg,0x8D);
  294.            WriteRawRC(TPrescalerReg,0x3E);
  295.            

  297.   //     PcdSetTmo(106);
  298.                             delay_10ms(1);
  299.        PcdAntennaOn();
  300.    }
  301.    else{ return -1; }
  302.    
  303.    return MI_OK;
  304. }
  305. /////////////////////////////////////////////////////////////////////
  306. //功    能：读RC632寄存器
  307. //参数说明：Address[IN]:寄存器地址
  308. //返    回：读出的值
  309. /////////////////////////////////////////////////////////////////////
  310. unsigned char ReadRawRC(unsigned char Address)
  311. {
  312.      unsigned char i, ucAddr;
  313.      unsigned char ucResult=0;

  315.      MF522_SCK = 0;
  316.      MF522_NSS = 0;
  317.      ucAddr = ((Address<<1)&0x7E)|0x80;

  319.      for(i=8;i>0;i--)
  320.      {
  321.          MF522_SI = ((ucAddr&0x80)==0x80);
  322.          MF522_SCK = 1;
  323.          ucAddr <<= 1;
  324.          MF522_SCK = 0;
  325.      }

  327.      for(i=8;i>0;i--)
  328.      {
  329.          MF522_SCK = 1;
  330.          ucResult <<= 1;
  331.          ucResult|=(bit)MF522_SO;
  332.          MF522_SCK = 0;
  333.      }

  335.      MF522_NSS = 1;
  336.      MF522_SCK = 1;
  337.      return ucResult;
  338. }

  340. /////////////////////////////////////////////////////////////////////
  341. //功    能：写RC632寄存器
  342. //参数说明：Address[IN]:寄存器地址
  343. //          value[IN]:写入的值
  344. /////////////////////////////////////////////////////////////////////
  345. void WriteRawRC(unsigned char Address, unsigned char value)
  346. {  
  347.     unsigned char i, ucAddr;

  349.     MF522_SCK = 0;
  350.     MF522_NSS = 0;
  351.     ucAddr = ((Address<<1)&0x7E);

  353.     for(i=8;i>0;i--)
  354.     {
  355.         MF522_SI = ((ucAddr&0x80)==0x80);
  356.         MF522_SCK = 1;
  357.         ucAddr <<= 1;
  358.         MF522_SCK = 0;
  359.     }

  361.     for(i=8;i>0;i--)
  362.     {
  363.         MF522_SI = ((value&0x80)==0x80);
  364.         MF522_SCK = 1;
  365.         value <<= 1;
  366.         MF522_SCK = 0;
  367.     }
  368.     MF522_NSS = 1;
  369.     MF522_SCK = 1;
  370. }

  372. /////////////////////////////////////////////////////////////////////
  373. //功    能：置RC522寄存器位
  374. //参数说明：reg[IN]:寄存器地址
  375. //          mask[IN]:置位值
  376. /////////////////////////////////////////////////////////////////////
  377. void SetBitMask(unsigned char reg,unsigned char mask)  
  378. {
  379.     char tmp = 0x0;
  380.     tmp = ReadRawRC(reg);
  381.     WriteRawRC(reg,tmp | mask);  // set bit mask
  382. }

  384. /////////////////////////////////////////////////////////////////////
  385. //功    能：清RC522寄存器位
  386. //参数说明：reg[IN]:寄存器地址
  387. //          mask[IN]:清位值
  388. /////////////////////////////////////////////////////////////////////
  389. void ClearBitMask(unsigned char reg,unsigned char mask)  
  390. {
  391.     char tmp = 0x0;
  392.     tmp = ReadRawRC(reg);
  393.     WriteRawRC(reg, tmp & ~mask);  // clear bit mask
  394. }

  396. /////////////////////////////////////////////////////////////////////
  397. //功    能：通过RC522和ISO14443卡通讯
  398. //参数说明：Command[IN]:RC522命令字
  399. //          pInData[IN]:通过RC522发送到卡片的数据
  400. //          InLenByte[IN]:发送数据的字节长度
  401. //          pOutData[OUT]:接收到的卡片返回数据
  402. //          *pOutLenBit[OUT]:返回数据的位长度
  403. /////////////////////////////////////////////////////////////////////
  404. char PcdComMF522(unsigned char Command,
  405.                  unsigned char *pInData,
  406.                  unsigned char InLenByte,
  407.                  unsigned char *pOutData,
  408.                  unsigned int  *pOutLenBit)
  409. {
  410.     char status = MI_ERR;
  411.     unsigned char irqEn   = 0x00;
  412.     unsigned char waitFor = 0x00;
  413.     unsigned char lastBits;
  414.     unsigned char n;
  415.     unsigned int i;
  416.     switch (Command)
  417.     {
  418.        case PCD_AUTHENT:
  419.           irqEn   = 0x12;
  420.           waitFor = 0x10;
  421.           break;
  422.        case PCD_TRANSCEIVE:
  423.           irqEn   = 0x77;
  424.           waitFor = 0x30;
  425.           break;
  426.        default:
  427.          break;
  428.     }
  429.    
  430.     WriteRawRC(ComIEnReg,irqEn|0x80);
  431.     ClearBitMask(ComIrqReg,0x80);
  432.     WriteRawRC(CommandReg,PCD_IDLE);
  433.     SetBitMask(FIFOLevelReg,0x80);
  434.    
  435.     for (i=0; i<InLenByte; i++)
  436.     {   WriteRawRC(FIFODataReg, pInData[i]);    }
  437.     WriteRawRC(CommandReg, Command);
  438.    
  439.    
  440.     if (Command == PCD_TRANSCEIVE)
  441.     {    SetBitMask(BitFramingReg,0x80);  }
  442.    
  443. //    i = 600;//根据时钟频率调整，操作M1卡最大等待时间25ms
  444. i = 2000;
  445.     do
  446.     {
  447.          n = ReadRawRC(ComIrqReg);
  448.          i--;
  449.     }
  450.     while ((i!=0) && !(n&0x01) && !(n&waitFor));
  451.     ClearBitMask(BitFramingReg,0x80);
  452.               
  453.     if (i!=0)
  454.     {   
  455.          if(!(ReadRawRC(ErrorReg)&0x1B))
  456.          {
  457.              status = MI_OK;
  458.              if (n & irqEn & 0x01)
  459.              {   status = MI_NOTAGERR;   }
  460.              if (Command == PCD_TRANSCEIVE)
  461.              {
  462.                        n = ReadRawRC(FIFOLevelReg);
  463.                       lastBits = ReadRawRC(ControlReg) & 0x07;
  464.                 if (lastBits)
  465.                 {   *pOutLenBit = (n-1)*8 + lastBits;   }
  466.                 else
  467.                 {   *pOutLenBit = n*8;   }
  468.                 if (n == 0)
  469.                 {   n = 1;    }
  470.                 if (n > MAXRLEN)
  471.                 {   n = MAXRLEN;   }
  472.                 for (i=0; i<n; i++)
  473.                 {   pOutData[i] = ReadRawRC(FIFODataReg);    }
  474.             }
  475.          }
  476.          else
  477.          {   status = MI_ERR;   }
  478.         
  479.    }
  480.    

  482.    SetBitMask(ControlReg,0x80);           // stop timer now
  483.    WriteRawRC(CommandReg,PCD_IDLE);
  484.    return status;
  485. }


  488. /////////////////////////////////////////////////////////////////////
  489. //开启天线  
  490. //每次启动或关闭天险发射之间应至少有1ms的间隔
  491. /////////////////////////////////////////////////////////////////////
  492. void PcdAntennaOn()
  493. {
  494.     unsigned char i;
  495.     i = ReadRawRC(TxControlReg);
  496.     if (!(i & 0x03))
  497.     {
  498.         SetBitMask(TxControlReg, 0x03);
  499.     }
  500. }


  503. /////////////////////////////////////////////////////////////////////
  504. //关闭天线
  505. /////////////////////////////////////////////////////////////////////
  506. void PcdAntennaOff()
  507. {
  508.     ClearBitMask(TxControlReg, 0x03);
  509. }


  512. /////////////////////////////////////////////////////////////////////
  513. //功    能：扣款和充值
  514. //参数说明: dd_mode[IN]：命令字
  515. //               0xC0 = 扣款
  516. //               0xC1 = 充值
  517. //          addr[IN]：钱包地址
  518. //          pValue[IN]：4字节增(减)值，低位在前
  519. //返    回: 成功返回MI_OK
  520. /////////////////////////////////////////////////////////////////////                 
  521. char PcdValue(unsigned char dd_mode,unsigned char addr,unsigned char *pValue)
  522. {
  523.     char status;
  524.     unsigned int  unLen;
  525.     unsigned char ucComMF522Buf[MAXRLEN];
  526.    
  527.     ucComMF522Buf[0] = dd_mode;
  528.     ucComMF522Buf[1] = addr;
  529.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

  531.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  533.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  534.     {   status = MI_ERR;   }
  535.         
  536.     if (status == MI_OK)
  537.     {
  538.         memcpy(ucComMF522Buf, pValue, 4);
  539. //       for (i=0; i<16; i++)
  540. //       {    ucComMF522Buf[i] = *(pValue+i);   }
  541.         CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);
  542.         unLen = 0;
  543.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
  544.         if (status != MI_ERR)
  545.         {    status = MI_OK;    }
  546.     }
  547.    
  548.     if (status == MI_OK)
  549.     {
  550.         ucComMF522Buf[0] = PICC_TRANSFER;
  551.         ucComMF522Buf[1] = addr;
  552.         CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
  553.    
  554.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  556.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  557.         {   status = MI_ERR;   }
  558.     }
  559.     return status;
  560. }

  562. /////////////////////////////////////////////////////////////////////
  563. //功    能：备份钱包
  564. //参数说明: sourceaddr[IN]：源地址
  565. //          goaladdr[IN]：目标地址
  566. //返    回: 成功返回MI_OK
  567. /////////////////////////////////////////////////////////////////////
  568. char PcdBakValue(unsigned char sourceaddr, unsigned char goaladdr)
  569. {
  570.     char status;
  571.     unsigned int  unLen;
  572.     unsigned char ucComMF522Buf[MAXRLEN];

  574.     ucComMF522Buf[0] = PICC_RESTORE;
  575.     ucComMF522Buf[1] = sourceaddr;
  576.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

  578.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  580.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  581.     {   status = MI_ERR;   }
  582.    
  583.     if (status == MI_OK)
  584.     {
  585.         ucComMF522Buf[0] = 0;
  586.         ucComMF522Buf[1] = 0;
  587.         ucComMF522Buf[2] = 0;
  588.         ucComMF522Buf[3] = 0;
  589.         CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);

  591.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
  592.         if (status != MI_ERR)
  593.         {    status = MI_OK;    }
  594.     }
  595.    
  596.     if (status != MI_OK)
  597.     {    return MI_ERR;   }
  598.    
  599.     ucComMF522Buf[0] = PICC_TRANSFER;
  600.     ucComMF522Buf[1] = goaladdr;

  602.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

  604.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  606.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  607.     {   status = MI_ERR;   }

  609.     return status;
  610. }


  613. ///////////////////////////////////////////////////////////////////////
  614. // Delay 10ms
  615. ///////////////////////////////////////////////////////////////////////
  616. void delay_10ms(unsigned int _10ms)
  617. {
  618. #ifndef NO_TIMER2
  619.     RCAP2LH = RCAP2_10ms;
  620.     T2LH    = RCAP2_10ms;
  621.    
  622.     TR2 = TRUE;
  623.     while (_10ms--)
  624.     {
  625.             while (!TF2);
  626.             TF2 = FALSE;
  627.     }
  628.     TR2 = FALSE;
  629. #else
  630.     while (_10ms--)
  631.     {
  632.             delay_50us(19);
  633.             if (CmdValid)
  634.                 return;
  635.             delay_50us(20);
  636.             if (CmdValid)
  637.                 return;
  638.             delay_50us(20);
  639.             if (CmdValid)
  640.                 return;
  641.             delay_50us(20);
  642.             if (CmdValid)
  643.                 return;
  644.             delay_50us(20);
  645.             if (CmdValid )
  646.                 return;
  647.             delay_50us(20);
  648.             if (CmdValid)
  649.                 return;
  650.             delay_50us(20);
  651.             if (CmdValid)
  652.                 return;
  653.             delay_50us(20);
  654.             if (CmdValid)
  655.                 return;
  656.             delay_50us(20);
  657.             if (CmdValid)
  658.                 return;
  659.             delay_50us(19);
  660.             if (CmdValid)
  661.                 return;
  662.     }
  663. #endif
  664. }
复制代码


RFID门禁刷卡识别源代码.zip

260.63 KB, 下载次数: 62, 下载积分: 黑币 -5

分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏 分享淘帖 顶顶 踩踩
回复

使用道具 举报

沙发
ID:125704 发表于 2019-3-14 23:27 | 只看该作者
感谢楼主分享，最近需要
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表