標(biāo)題: STM32單片機(jī)NFC門禁系統(tǒng)程序 [打印本頁(yè)]
作者: 小鋇愛(ài)學(xué)    時(shí)間: 2023-10-20 12:20
標(biāo)題: STM32單片機(jī)NFC門禁系統(tǒng)程序

  2. /*   RFID_RC522門禁系統(tǒng)  */

  4. /*   接線： RC522模塊：RST接PB11；MISO接PB10； MOSI接PB1；SCK接PB0；SDA接PA7；
  5.                               0.96寸OLED:scl接PB8，sda接PB9
  6.                         有源蜂鳴器：I/O接PA3
  7.                         180度舵機(jī)：信號(hào)線接PA1(5V電源驅(qū)動(dòng))
  8.                         按鍵1：PB12； 按鍵2：PB14；按鍵3：PA9；按鍵4：PA12；   
  9. */

  11. /*         
  12. 具體功能描述：
  13.          讀模式：        上電后默認(rèn)為讀模式，按下2鍵后進(jìn)入寫模式，按下3鍵進(jìn)入刪模式
  14.          寫模式： 在寫模式下將靠近感應(yīng)區(qū)即可寫成功，已錄入的不能重復(fù)錄入，在寫模式下按下1鍵進(jìn)入尋模式，按下3鍵進(jìn)入刪模式
  15.          刪模式： 在刪`模式下按下1鍵或2鍵選擇要?jiǎng)h除的，按下3鍵確認(rèn)刪除，按下4鍵返回到讀模式。
  16. */
  17. #include "stm32f10x.h"                  // Device header
  18. #include "RC522.H"                       

  20. uint8_t UID[4],Temp[4];

  22. uint8_t UI0[4]={0xFF,0xFF,0xFF,0xFF};                         //0ID號(hào)
  23. uint8_t UI1[4]={0xFF,0xFF,0xFF,0xFF};                         //1ID號(hào)
  24. uint8_t UI2[4]={0xFF,0xFF,0xFF,0xFF};                        //2ID號(hào)
  25. uint8_t UI3[4]={0xFF,0xFF,0xFF,0xFF};                        //3ID號(hào)

  27. //RC522端口定義
  28. void PcdInit()
  29. {
  30.           GPIO_InitTypeDef  GPIO_InitStructure;

  32.           /* Enable the GPIO Clock */
  33.           RCC_APB2PeriphClockCmd(MF522_RST_CLK, ENABLE);

  35.           /* Configure the GPIO pin */
  36.           GPIO_InitStructure.GPIO_Pin = MF522_RST_PIN;
  37.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  38.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;

  40.           GPIO_Init(MF522_RST_PORT, &GPIO_InitStructure);

  42.           /* Enable the GPIO Clock */
  43.           RCC_APB2PeriphClockCmd(MF522_MISO_CLK, ENABLE);

  45.           /* Configure the GPIO pin */
  46.           GPIO_InitStructure.GPIO_Pin = MF522_MISO_PIN;
  47.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  48.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;

  50.           GPIO_Init(MF522_MISO_PORT, &GPIO_InitStructure);

  52.           /* Enable the GPIO Clock */
  53.           RCC_APB2PeriphClockCmd(MF522_MOSI_CLK, ENABLE);

  55.           /* Configure the GPIO pin */
  56.           GPIO_InitStructure.GPIO_Pin = MF522_MOSI_PIN;
  57.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  58.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;

  60.           GPIO_Init(MF522_MOSI_PORT, &GPIO_InitStructure);

  62.           /* Enable the GPIO Clock */
  63.           RCC_APB2PeriphClockCmd(MF522_SCK_CLK, ENABLE);

  65.           /* Configure the GPIO pin */
  66.           GPIO_InitStructure.GPIO_Pin = MF522_SCK_PIN;
  67.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  68.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;

  70.           GPIO_Init(MF522_SCK_PORT, &GPIO_InitStructure);

  72.           /* Enable the GPIO Clock */
  73.           RCC_APB2PeriphClockCmd(MF522_NSS_CLK, ENABLE);

  75.           /* Configure the GPIO pin */
  76.           GPIO_InitStructure.GPIO_Pin = MF522_NSS_PIN;
  77.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
  78.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;

  80.           GPIO_Init(MF522_NSS_PORT, &GPIO_InitStructure);
  81. }


  84. ///////////////////////以下為RC522驅(qū)動(dòng)函數(shù)/////////////////////////
  85. ///////////////////////以下為RC522驅(qū)動(dòng)函數(shù)/////////////////////////
  86. ///////////////////////以下為RC522驅(qū)動(dòng)函數(shù)/////////////////////////

  88. //功    能：尋
  89. //參數(shù)說(shuō)明: req_code[IN]:尋方式
  90. //                0x52 = 尋感應(yīng)區(qū)內(nèi)所有符合14443A標(biāo)準(zhǔn)的
  91. //                0x26 = 尋未進(jìn)入休眠狀態(tài)的
  92. //                    pTagType[OUT]：片類型代碼
  93. //                0x4400 = Mifare_UltraLight
  94. //                0x0400 = Mifare_One(S50)
  95. //                0x0200 = Mifare_One(S70)
  96. //                0x0800 = Mifare_Pro(X)
  97. //                0x4403 = Mifare_DESFire
  98. //返    回: 成功返回MI_OK
  99. char PcdRequest(unsigned char req_code,unsigned char *pTagType)
  100. {
  101.    char status;  
  102.    unsigned int  unLen;
  103.    unsigned char ucComMF522Buf[MAXRLEN];
  104. //  unsigned char xTest ;
  105.    ClearBitMask(Status2Reg,0x08);
  106.    WriteRawRC(BitFramingReg,0x07);

  108. //  xTest = ReadRawRC(BitFramingReg);
  109. //  if(xTest == 0x07 )
  110. //   { LED_GREEN  =0 ;}
  111. // else {LED_GREEN =1 ;while(1){}}
  112.    SetBitMask(TxControlReg,0x03);

  114.    ucComMF522Buf[0] = req_code;

  116.    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,1,ucComMF522Buf,&unLen);
  117. //     if(status  == MI_OK )
  118. //   { LED_GREEN  =0 ;}
  119. //   else {LED_GREEN =1 ;}
  120.    if ((status == MI_OK) && (unLen == 0x10))
  121.    {   
  122.        *pTagType     = ucComMF522Buf[0];
  123.        *(pTagType+1) = ucComMF522Buf[1];
  124.    }
  125.    else
  126.    {   status = MI_ERR;   }

  128.    return status;
  129. }

  131. //功    能：防沖撞
  132. //參數(shù)說(shuō)明: pSnr[OUT]:片序列號(hào)，4字節(jié)
  133. //返    回: 成功返回MI_OK
  134. char PcdAnticoll(unsigned char *pSnr)
  135. {
  136.     char status;
  137.     unsigned char i,snr_check=0;
  138.     unsigned int  unLen;
  139.     unsigned char ucComMF522Buf[MAXRLEN];


  142.     ClearBitMask(Status2Reg,0x08);
  143.     WriteRawRC(BitFramingReg,0x00);
  144.     ClearBitMask(CollReg,0x80);

  146.     ucComMF522Buf[0] = PICC_ANTICOLL1;
  147.     ucComMF522Buf[1] = 0x20;

  149.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,2,ucComMF522Buf,&unLen);

  151.     if (status == MI_OK)
  152.     {
  153.              for (i=0; i<4; i++)
  154.          {   
  155.              *(pSnr+i)  = ucComMF522Buf[ i];
  156.              snr_check ^= ucComMF522Buf[ i];
  157.          }
  158.          if (snr_check != ucComMF522Buf[ i])
  159.          {   status = MI_ERR;    }
  160.     }

  162.     SetBitMask(CollReg,0x80);
  163.     return status;
  164. }

  166. //功    能：選定片
  167. //參數(shù)說(shuō)明: pSnr[IN]:片序列號(hào)，4字節(jié)
  168. //返    回: 成功返回MI_OK
  169. char PcdSelect(unsigned char *pSnr)
  170. {
  171.     char status;
  172.     unsigned char i;
  173.     unsigned int  unLen;
  174.     unsigned char ucComMF522Buf[MAXRLEN];

  176.     ucComMF522Buf[0] = PICC_ANTICOLL1;
  177.     ucComMF522Buf[1] = 0x70;
  178.     ucComMF522Buf[6] = 0;
  179.     for (i=0; i<4; i++)
  180.     {
  181.             ucComMF522Buf[i+2] = *(pSnr+i);
  182.             ucComMF522Buf[6]  ^= *(pSnr+i);
  183.     }
  184.     CalulateCRC(ucComMF522Buf,7,&ucComMF522Buf[7]);

  186.     ClearBitMask(Status2Reg,0x08);

  188.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);

  190.     if ((status == MI_OK) && (unLen == 0x18))
  191.     {   status = MI_OK;  }
  192.     else
  193.     {   status = MI_ERR;    }

  195.     return status;
  196. }

  198. //功    能：驗(yàn)證片密碼
  199. //參數(shù)說(shuō)明: auth_mode[IN]: 密碼驗(yàn)證模式
  200. //                 0x60 = 驗(yàn)證A密鑰
  201. //                 0x61 = 驗(yàn)證B密鑰
  202. //          addr[IN]：塊地址
  203. //          pKey[IN]：密碼
  204. //          pSnr[IN]：片序列號(hào)，4字節(jié)
  205. //返    回: 成功返回MI_OK      
  206. char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr)
  207. {
  208.     char status;
  209.     unsigned int  unLen;
  210.     unsigned char i,ucComMF522Buf[MAXRLEN];

  212.     ucComMF522Buf[0] = auth_mode;
  213.     ucComMF522Buf[1] = addr;
  214.     for (i=0; i<6; i++)
  215.     {    ucComMF522Buf[i+2] = *(pKey+i);   }
  216.     for (i=0; i<6; i++)
  217.     {    ucComMF522Buf[i+8] = *(pSnr+i);   }
  218. //   memcpy(&ucComMF522Buf[2], pKey, 6);
  219. //   memcpy(&ucComMF522Buf[8], pSnr, 4);

  221.     status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
  222.     if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
  223.     {   status = MI_ERR;   }

  225.     return status;
  226. }

  228. //功    能：讀取M1一塊數(shù)據(jù)
  229. //參數(shù)說(shuō)明: addr[IN]：塊地址
  230. //          pData[OUT]：讀出的數(shù)據(jù)，16字節(jié)
  231. //返    回: 成功返回MI_OK
  232. char PcdRead(unsigned char addr,unsigned char *pData)
  233. {
  234.     char status;
  235.     unsigned int  unLen;
  236.     unsigned char i,ucComMF522Buf[MAXRLEN];

  238.     ucComMF522Buf[0] = PICC_READ;
  239.     ucComMF522Buf[1] = addr;
  240.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

  242.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
  243.     if ((status == MI_OK) && (unLen == 0x90))
  244. //   {   memcpy(pData, ucComMF522Buf, 16);   }
  245.     {
  246.         for (i=0; i<16; i++)
  247.         {    *(pData+i) = ucComMF522Buf[ i];   }
  248.     }
  249.     else
  250.     {   status = MI_ERR;   }

  252.     return status;
  253. }

  255. //功    能：寫數(shù)據(jù)到M1一塊
  256. //參數(shù)說(shuō)明: addr[IN]：塊地址
  257. //          pData[IN]：寫入的數(shù)據(jù)，16字節(jié)
  258. //返    回: 成功返回MI_OK         
  259. char PcdWrite(unsigned char addr,unsigned char *pData)
  260. {
  261.     char status;
  262.     unsigned int  unLen;
  263.     unsigned char i,ucComMF522Buf[MAXRLEN];

  265.     ucComMF522Buf[0] = PICC_WRITE;
  266.     ucComMF522Buf[1] = addr;
  267.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

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

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

  274.     if (status == MI_OK)
  275.     {
  276.         //memcpy(ucComMF522Buf, pData, 16);

  278.         for (i=0; i<16; i++)
  279.         {    ucComMF522Buf[ i] = *(pData+i);   }
  280.         CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16]);

  282.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,18,ucComMF522Buf,&unLen);
  283.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
  284.         {   status = MI_ERR;   }
  285.     }

  287.     return status;
  288. }

  290. //功    能：命令片進(jìn)入休眠狀態(tài)
  291. //返    回: 成功返回MI_OK
  292. char PcdHalt(void)
  293. {
  294.     unsigned int  unLen;
  295.     unsigned char ucComMF522Buf[MAXRLEN];

  297.     ucComMF522Buf[0] = PICC_HALT;
  298.     ucComMF522Buf[1] = 0;
  299.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);

  301.     PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);

  303.     return MI_OK;
  304. }

  306. //用MF522計(jì)算CRC16函數(shù)
  307. void CalulateCRC(unsigned char *pIndata,unsigned char len,unsigned char *pOutData)
  308. {
  309.     unsigned char i,n;
  310.     ClearBitMask(DivIrqReg,0x04);
  311.     WriteRawRC(CommandReg,PCD_IDLE);
  312.     SetBitMask(FIFOLevelReg,0x80);
  313.     for (i=0; i<len; i++)
  314.     {   WriteRawRC(FIFODataReg, *(pIndata+i));   }
  315.     WriteRawRC(CommandReg, PCD_CALCCRC);
  316.     i = 0xFF;
  317.     do
  318.     {
  319.         n = ReadRawRC(DivIrqReg);
  320.         i--;
  321.     }
  322.     while ((i!=0) && !(n&0x04));
  323.     pOutData[0] = ReadRawRC(CRCResultRegL);
  324.     pOutData[1] = ReadRawRC(CRCResultRegM);
  325. }

  327. //功    能：復(fù)位RC522
  328. //返    回: 成功返回MI_OK
  329. char PcdReset(void)
  330. {
  331.     RST_H;
  332.     delay_10ms(1);
  333.     RST_L;
  334.     delay_10ms(1);
  335.     RST_H;
  336.           delay_10ms(10);
  337.         
  338.                 if(ReadRawRC(0x02) == 0x80)
  339.                 {
  340.                 }

  342.     WriteRawRC(CommandReg,PCD_RESETPHASE);

  344.     WriteRawRC(ModeReg,0x3D);            //和Mifare通訊，CRC初始值0x6363
  345.     WriteRawRC(TReloadRegL,30);           
  346.     WriteRawRC(TReloadRegH,0);
  347.     WriteRawRC(TModeReg,0x8D);
  348.     WriteRawRC(TPrescalerReg,0x3E);
  349.     WriteRawRC(TxAutoReg,0x40);     
  350.     return MI_OK;
  351. }

  353. //設(shè)置RC632的工作方式
  354. char M500PcdConfigISOType(unsigned char type)
  355. {
  356.    if (type == 'A')                     //ISO14443_A
  357.    {
  358.        ClearBitMask(Status2Reg,0x08);

  360. /*     WriteRawRC(CommandReg,0x20);    //as default   
  361.        WriteRawRC(ComIEnReg,0x80);     //as default
  362.        WriteRawRC(DivlEnReg,0x0);      //as default
  363.            WriteRawRC(ComIrqReg,0x04);     //as default
  364.            WriteRawRC(DivIrqReg,0x0);      //as default
  365.            WriteRawRC(Status2Reg,0x0);//80    //trun off temperature sensor
  366.            WriteRawRC(WaterLevelReg,0x08); //as default
  367.        WriteRawRC(ControlReg,0x20);    //as default
  368.            WriteRawRC(CollReg,0x80);    //as default
  369. */
  370.        WriteRawRC(ModeReg,0x3D);//3F
  371. /*           WriteRawRC(TxModeReg,0x0);      //as default???
  372.            WriteRawRC(RxModeReg,0x0);      //as default???
  373.            WriteRawRC(TxControlReg,0x80);  //as default???
  374.            WriteRawRC(TxSelReg,0x10);      //as default???
  375.    */
  376.        WriteRawRC(RxSelReg,0x86);//84
  377. //      WriteRawRC(RxThresholdReg,0x84);//as default
  378. //      WriteRawRC(DemodReg,0x4D);      //as default

  380. //      WriteRawRC(ModWidthReg,0x13);//26
  381.        WriteRawRC(RFCfgReg,0x7F);   //4F
  382.         /*   WriteRawRC(GsNReg,0x88);        //as default???
  383.            WriteRawRC(CWGsCfgReg,0x20);    //as default???
  384.        WriteRawRC(ModGsCfgReg,0x20);   //as default???
  385. */
  386.               WriteRawRC(TReloadRegL,30);//tmoLength);// TReloadVal = 'h6a =tmoLength(dec)
  387.            WriteRawRC(TReloadRegH,0);
  388.        WriteRawRC(TModeReg,0x8D);
  389.            WriteRawRC(TPrescalerReg,0x3E);
  390.            

  392.   //     PcdSetTmo(106);
  393.            delay_10ms(1);
  394.        PcdAntennaOn();
  395.    }
  396.    else{ return (char)-1; }

  398.    return MI_OK;
  399. }

  401. //功    能：讀RC632寄存器
  402. //參數(shù)說(shuō)明：Address[IN]:寄存器地址
  403. //返    回：讀出的值
  404. unsigned char ReadRawRC(unsigned char Address)
  405. {
  406.      unsigned char i, ucAddr;
  407.      unsigned char ucResult=0;

  409.      NSS_L;
  410.      ucAddr = ((Address<<1)&0x7E)|0x80;

  412.      for(i=8;i>0;i--)
  413.      {
  414.          SCK_L;
  415.                   if(ucAddr&0x80)
  416.                  MOSI_H;
  417.                  else
  418.                                  MOSI_L;
  419.          SCK_H;
  420.          ucAddr <<= 1;
  421.      }

  423.      for(i=8;i>0;i--)
  424.      {
  425.          SCK_L;
  426.          ucResult <<= 1;
  427.          SCK_H;
  428.                  if(READ_MISO == 1)
  429.                  ucResult |= 1;
  430.      }

  432.      NSS_H;
  433.      SCK_H;
  434.      return ucResult;
  435. }

  437. //功    能：寫RC632寄存器
  438. //參數(shù)說(shuō)明：Address[IN]:寄存器地址
  439. //          value[IN]:寫入的值
  440. void WriteRawRC(unsigned char Address, unsigned char value)
  441. {  
  442.     unsigned char i, ucAddr;

  444.     SCK_L;
  445.     NSS_L;
  446.     ucAddr = ((Address<<1)&0x7E);

  448.     for(i=8;i>0;i--)
  449.     {
  450.                 if(ucAddr&0x80)
  451.                 MOSI_H;
  452.                 else
  453.                         MOSI_L;
  454.         SCK_H;
  455.         ucAddr <<= 1;
  456.         SCK_L;
  457.     }

  459.     for(i=8;i>0;i--)
  460.     {
  461.                 if(value&0x80)
  462.                 MOSI_H;
  463.                 else
  464.                         MOSI_L;
  465.         SCK_H;
  466.         value <<= 1;
  467.         SCK_L;
  468.     }
  469.     NSS_H;
  470.     SCK_H;
  471. }

  473. //功    能：置RC522寄存器位
  474. //參數(shù)說(shuō)明：reg[IN]:寄存器地址
  475. //          mask[IN]:置位值
  476. void SetBitMask(unsigned char reg,unsigned char mask)  
  477. {
  478.     char tmp = 0x0;
  479.     tmp = ReadRawRC(reg);
  480.     WriteRawRC(reg,tmp | mask);  // set bit mask
  481. }

  483. //功    能：清RC522寄存器位
  484. //參數(shù)說(shuō)明：reg[IN]:寄存器地址
  485. //          mask[IN]:清位值
  486. void ClearBitMask(unsigned char reg,unsigned char mask)  
  487. {
  488.     char tmp = 0x0;
  489.     tmp = ReadRawRC(reg);
  490.     WriteRawRC(reg, tmp & ~mask);  // clear bit mask
  491. }

  493. //功    能：通過(guò)RC522和ISO14443通訊
  494. //參數(shù)說(shuō)明：Command[IN]:RC522命令字
  495. //          pInData[IN]:通過(guò)RC522發(fā)送到片的數(shù)據(jù)
  496. //          InLenByte[IN]:發(fā)送數(shù)據(jù)的字節(jié)長(zhǎng)度
  497. //          pOutData[OUT]:接收到的片返回?cái)?shù)據(jù)
  498. //          *pOutLenBit[OUT]:返回?cái)?shù)據(jù)的位長(zhǎng)度
  499. char PcdComMF522(unsigned char Command,
  500.                  unsigned char *pInData,
  501.                  unsigned char InLenByte,
  502.                  unsigned char *pOutData,
  503.                  unsigned int  *pOutLenBit)
  504. {
  505.     char status = MI_ERR;
  506.     unsigned char irqEn   = 0x00;
  507.     unsigned char waitFor = 0x00;
  508.     unsigned char lastBits;
  509.     unsigned char n;
  510.     unsigned int i;
  511.     switch (Command)
  512.     {
  513.        case PCD_AUTHENT:
  514.           irqEn   = 0x12;
  515.           waitFor = 0x10;
  516.           break;
  517.        case PCD_TRANSCEIVE:
  518.           irqEn   = 0x77;
  519.           waitFor = 0x30;
  520.           break;
  521.        default:
  522.          break;
  523.     }

  525.     WriteRawRC(ComIEnReg,irqEn|0x80);
  526.     ClearBitMask(ComIrqReg,0x80);
  527.     WriteRawRC(CommandReg,PCD_IDLE);
  528.     SetBitMask(FIFOLevelReg,0x80);

  530.     for (i=0; i<InLenByte; i++)
  531.     {   WriteRawRC(FIFODataReg, pInData[ i]);    }
  532.     WriteRawRC(CommandReg, Command);


  535.     if (Command == PCD_TRANSCEIVE)
  536.     {    SetBitMask(BitFramingReg,0x80);  }

  538. //    i = 600;//根據(jù)時(shí)鐘頻率調(diào)整，操作M1最大等待時(shí)間25ms
  539. i = 2000;
  540.     do
  541.     {
  542.          n = ReadRawRC(ComIrqReg);
  543.          i--;
  544.     }
  545.     while ((i!=0) && !(n&0x01) && !(n&waitFor));
  546.     ClearBitMask(BitFramingReg,0x80);
  547.               
  548.     if (i!=0)
  549.     {   
  550.          if(!(ReadRawRC(ErrorReg)&0x1B))
  551.          {
  552.              status = MI_OK;
  553.              if (n & irqEn & 0x01)
  554.              {   status = MI_NOTAGERR;   }
  555.              if (Command == PCD_TRANSCEIVE)
  556.              {
  557.                        n = ReadRawRC(FIFOLevelReg);
  558.                       lastBits = ReadRawRC(ControlReg) & 0x07;
  559.                 if (lastBits)
  560.                 {   *pOutLenBit = (n-1)*8 + lastBits;   }
  561.                 else
  562.                 {   *pOutLenBit = n*8;   }
  563.                 if (n == 0)
  564.                 {   n = 1;    }
  565.                 if (n > MAXRLEN)
  566.                 {   n = MAXRLEN;   }
  567.                 for (i=0; i<n; i++)
  568.                 {   pOutData[ i] = ReadRawRC(FIFODataReg);    }
  569.             }
  570.          }
  571.          else
  572.          {   status = MI_ERR;   }

  574.    }


  577.    SetBitMask(ControlReg,0x80);           // stop timer now
  578.    WriteRawRC(CommandReg,PCD_IDLE);
  579.    return status;
  580. }

  582. //開(kāi)啟天線  
  583. //每次啟動(dòng)或關(guān)閉天險(xiǎn)發(fā)射之間應(yīng)至少有1ms的間隔
  584. void PcdAntennaOn()
  585. {
  586.     unsigned char i;
  587.     i = ReadRawRC(TxControlReg);
  588.     if (!(i & 0x03))
  589.     {
  590.         SetBitMask(TxControlReg, 0x03);
  591.     }
  592. }

  594. //關(guān)閉天線
  595. void PcdAntennaOff()
  596. {
  597.     ClearBitMask(TxControlReg, 0x03);
  598. }

  600. //等待離開(kāi)
  601. void WaitCardOff(void)
  602. {
  603.         char          status;
  604.   unsigned char        TagType[2];

  606.         while(1)
  607.         {
  608.                 status = PcdRequest(REQ_ALL, TagType);
  609.                 if(status)
  610.                 {
  611.                         status = PcdRequest(REQ_ALL, TagType);
  612.                         if(status)
  613.                         {
  614.                                 status = PcdRequest(REQ_ALL, TagType);
  615.                                 if(status)
  616.                                 {
  617.                                         return;
  618.                                 }
  619.                         }
  620.                 }
  621.                 delay_10ms(10);
  622.         }
  623. }

  625. // Delay 10ms
  626. void delay_10ms(unsigned int _10ms)
  627. {
  628.         unsigned int i, j;

  630.         for(i=0; i<_10ms; i++)
  631.         {
  632.                 for(j=0; j<60000; j++);
  633.         }
  634. }

  636. ///////////////////////以上為RC522驅(qū)動(dòng)函數(shù)/////////////////////////
  637. ///////////////////////以上為RC522驅(qū)動(dòng)函數(shù)/////////////////////////
  638. ///////////////////////以上為RC522驅(qū)動(dòng)函數(shù)/////////////////////////


  641. //RFID模塊初始化
  642. void RFID_Init(void)                                                                        
  643. {
  644.         PcdInit();                                                                                                //RC522端口定義
  645.     PcdReset();                                                                                                //復(fù)位RC522
  646.     PcdAntennaOff();                                                                                  //關(guān)天線                 
  647.     PcdAntennaOn();                                                                                  //開(kāi)天線
  648.         M500PcdConfigISOType('A');
  649. }

  651. //獲取編號(hào)函數(shù)，返回編號(hào)1-3，非系統(tǒng)錄入返回0，沒(méi)有識(shí)別到返回5或6
  652. uint8_t Rc522Test(void)                                                                                
  653. {
  654.         uint8_t cardno;
  655.         if (PcdRequest(REQ_ALL, Temp) == MI_OK)//尋
  656.         {
  657.                 if (PcdAnticoll(UID) == MI_OK)//防沖撞
  658.                 {
  659.                         cardno=0;        
  660.                         if(UID[0]==UI0[0]&&UID[1]==UI0[1]&&UID[2]==UI0[2]&&UID[3]==UI0[3])
  661.                         {
  662.                                 cardno=1;
  663.                         }
  664.                         else if(UID[0]==UI1[0]&&UID[1]==UI1[1]&&UID[2]==UI1[2]&&UID[3]==UI1[3])
  665.                         {
  666.                                 cardno=2;
  667.                         }
  668.                         else if(UID[0]==UI2[0]&&UID[1]==UI2[1]&&UID[2]==UI2[2]&&UID[3]==UI2[3])
  669.                         {
  670.                                 cardno=3;
  671.                         }
  672.                         else if(UID[0]==UI3[0]&&UID[1]==UI3[1]&&UID[2]==UI3[2]&&UID[3]==UI3[3])
  673.                         {
  674.                                 cardno=4;
  675.                         }
  676.                         else cardno = 0;
  677.                 }
  678.                 else cardno = 5;
  679.         }
  680.         else cardno = 6;
  681.         return cardno;
  682. }
復(fù)制代碼


原理圖: 無(wú)
仿真: 無(wú)
代碼: NFC門禁系統(tǒng).zip (332.47 KB, 下載次數(shù): 19)



歡迎光臨 (http://www.torrancerestoration.com/bbs/) Powered by Discuz! X3.1