标题: STM32单片机NFC门禁系统程序 [打印本页]

---

作者: 小钡爱学    时间: 2023-10-20 12:20
标题: STM32单片机NFC门禁系统程序

1. 
   
2. /*   RFID_RC522门禁系统  */
   
3. 
   
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度舵机：信号线接PA1(5V电源驱动)
   
8.                         按键1：PB12； 按键2：PB14；按键3：PA9；按键4：PA12；   
   
9. */
   
10. 
    
11. /*         
    
12. 具体功能描述：
    
13.          读模式：        上电后默认为读模式，按下2键后进入写模式，按下3键进入删模式
    
14.          写模式： 在写模式下将靠近感应区即可写成功，已录入的不能重复录入，在写模式下按下1键进入寻模式，按下3键进入删模式
    
15.          删模式： 在删`模式下按下1键或2键选择要删除的，按下3键确认删除，按下4键返回到读模式。
    
16. */
    
17. #include "stm32f10x.h"                  // Device header
    
18. #include "RC522.H"                       
    
19. 
    
20. uint8_t UID[4],Temp[4];
    
21. 
    
22. uint8_t UI0[4]={0xFF,0xFF,0xFF,0xFF};                         //0ID号
    
23. uint8_t UI1[4]={0xFF,0xFF,0xFF,0xFF};                         //1ID号
    
24. uint8_t UI2[4]={0xFF,0xFF,0xFF,0xFF};                        //2ID号
    
25. uint8_t UI3[4]={0xFF,0xFF,0xFF,0xFF};                        //3ID号
    
26. 
    
27. //RC522端口定义
    
28. void PcdInit()
    
29. {
    
30.           GPIO_InitTypeDef  GPIO_InitStructure;
    
31. 
    
32.           /* Enable the GPIO Clock */
    
33.           RCC_APB2PeriphClockCmd(MF522_RST_CLK, ENABLE);
    
34. 
    
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;
    
39. 
    
40.           GPIO_Init(MF522_RST_PORT, &GPIO_InitStructure);
    
41. 
    
42.           /* Enable the GPIO Clock */
    
43.           RCC_APB2PeriphClockCmd(MF522_MISO_CLK, ENABLE);
    
44. 
    
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;
    
49. 
    
50.           GPIO_Init(MF522_MISO_PORT, &GPIO_InitStructure);
    
51. 
    
52.           /* Enable the GPIO Clock */
    
53.           RCC_APB2PeriphClockCmd(MF522_MOSI_CLK, ENABLE);
    
54. 
    
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;
    
59. 
    
60.           GPIO_Init(MF522_MOSI_PORT, &GPIO_InitStructure);
    
61. 
    
62.           /* Enable the GPIO Clock */
    
63.           RCC_APB2PeriphClockCmd(MF522_SCK_CLK, ENABLE);
    
64. 
    
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;
    
69. 
    
70.           GPIO_Init(MF522_SCK_PORT, &GPIO_InitStructure);
    
71. 
    
72.           /* Enable the GPIO Clock */
    
73.           RCC_APB2PeriphClockCmd(MF522_NSS_CLK, ENABLE);
    
74. 
    
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;
    
79. 
    
80.           GPIO_Init(MF522_NSS_PORT, &GPIO_InitStructure);
    
81. }
    
82. 
    
83. 
    
84. ///////////////////////以下为RC522驱动函数/////////////////////////
    
85. ///////////////////////以下为RC522驱动函数/////////////////////////
    
86. ///////////////////////以下为RC522驱动函数/////////////////////////
    
87. 
    
88. //功    能：寻
    
89. //参数说明: req_code[IN]:寻方式
    
90. //                0x52 = 寻感应区内所有符合14443A标准的
    
91. //                0x26 = 寻未进入休眠状态的
    
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);
     
107. 
     
108. //  xTest = ReadRawRC(BitFramingReg);
     
109. //  if(xTest == 0x07 )
     
110. //   { LED_GREEN  =0 ;}
     
111. // else {LED_GREEN =1 ;while(1){}}
     
112.    SetBitMask(TxControlReg,0x03);
     
113. 
     
114.    ucComMF522Buf[0] = req_code;
     
115. 
     
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;   }
     
127. 
     
128.    return status;
     
129. }
     
130. 
     
131. //功    能：防冲撞
     
132. //参数说明: pSnr[OUT]:片序列号，4字节
     
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];
     
140. 
     
141. 
     
142.     ClearBitMask(Status2Reg,0x08);
     
143.     WriteRawRC(BitFramingReg,0x00);
     
144.     ClearBitMask(CollReg,0x80);
     
145. 
     
146.     ucComMF522Buf[0] = PICC_ANTICOLL1;
     
147.     ucComMF522Buf[1] = 0x20;
     
148. 
     
149.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,2,ucComMF522Buf,&unLen);
     
150. 
     
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.     }
     
161. 
     
162.     SetBitMask(CollReg,0x80);
     
163.     return status;
     
164. }
     
165. 
     
166. //功    能：选定片
     
167. //参数说明: pSnr[IN]:片序列号，4字节
     
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];
     
175. 
     
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]);
     
185. 
     
186.     ClearBitMask(Status2Reg,0x08);
     
187. 
     
188.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);
     
189. 
     
190.     if ((status == MI_OK) && (unLen == 0x18))
     
191.     {   status = MI_OK;  }
     
192.     else
     
193.     {   status = MI_ERR;    }
     
194. 
     
195.     return status;
     
196. }
     
197. 
     
198. //功    能：验证片密码
     
199. //参数说明: auth_mode[IN]: 密码验证模式
     
200. //                 0x60 = 验证A密钥
     
201. //                 0x61 = 验证B密钥
     
202. //          addr[IN]：块地址
     
203. //          pKey[IN]：密码
     
204. //          pSnr[IN]：片序列号，4字节
     
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];
     
211. 
     
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);
     
220. 
     
221.     status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
     
222.     if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
     
223.     {   status = MI_ERR;   }
     
224. 
     
225.     return status;
     
226. }
     
227. 
     
228. //功    能：读取M1一块数据
     
229. //参数说明: addr[IN]：块地址
     
230. //          pData[OUT]：读出的数据，16字节
     
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];
     
237. 
     
238.     ucComMF522Buf[0] = PICC_READ;
     
239.     ucComMF522Buf[1] = addr;
     
240.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
241. 
     
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;   }
     
251. 
     
252.     return status;
     
253. }
     
254. 
     
255. //功    能：写数据到M1一块
     
256. //参数说明: addr[IN]：块地址
     
257. //          pData[IN]：写入的数据，16字节
     
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];
     
264. 
     
265.     ucComMF522Buf[0] = PICC_WRITE;
     
266.     ucComMF522Buf[1] = addr;
     
267.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
268. 
     
269.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
270. 
     
271.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     
272.     {   status = MI_ERR;   }
     
273. 
     
274.     if (status == MI_OK)
     
275.     {
     
276.         //memcpy(ucComMF522Buf, pData, 16);
     
277. 
     
278.         for (i=0; i<16; i++)
     
279.         {    ucComMF522Buf[ i] = *(pData+i);   }
     
280.         CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16]);
     
281. 
     
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.     }
     
286. 
     
287.     return status;
     
288. }
     
289. 
     
290. //功    能：命令片进入休眠状态
     
291. //返    回: 成功返回MI_OK
     
292. char PcdHalt(void)
     
293. {
     
294.     unsigned int  unLen;
     
295.     unsigned char ucComMF522Buf[MAXRLEN];
     
296. 
     
297.     ucComMF522Buf[0] = PICC_HALT;
     
298.     ucComMF522Buf[1] = 0;
     
299.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
300. 
     
301.     PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
302. 
     
303.     return MI_OK;
     
304. }
     
305. 
     
306. //用MF522计算CRC16函数
     
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. }
     
326. 
     
327. //功    能：复位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.                 }
     
341. 
     
342.     WriteRawRC(CommandReg,PCD_RESETPHASE);
     
343. 
     
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. }
     
352. 
     
353. //设置RC632的工作方式
     
354. char M500PcdConfigISOType(unsigned char type)
     
355. {
     
356.    if (type == 'A')                     //ISO14443_A
     
357.    {
     
358.        ClearBitMask(Status2Reg,0x08);
     
359. 
     
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
     
379. 
     
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.            
     
391. 
     
392.   //     PcdSetTmo(106);
     
393.            delay_10ms(1);
     
394.        PcdAntennaOn();
     
395.    }
     
396.    else{ return (char)-1; }
     
397. 
     
398.    return MI_OK;
     
399. }
     
400. 
     
401. //功    能：读RC632寄存器
     
402. //参数说明：Address[IN]:寄存器地址
     
403. //返    回：读出的值
     
404. unsigned char ReadRawRC(unsigned char Address)
     
405. {
     
406.      unsigned char i, ucAddr;
     
407.      unsigned char ucResult=0;
     
408. 
     
409.      NSS_L;
     
410.      ucAddr = ((Address<<1)&0x7E)|0x80;
     
411. 
     
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.      }
     
422. 
     
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.      }
     
431. 
     
432.      NSS_H;
     
433.      SCK_H;
     
434.      return ucResult;
     
435. }
     
436. 
     
437. //功    能：写RC632寄存器
     
438. //参数说明：Address[IN]:寄存器地址
     
439. //          value[IN]:写入的值
     
440. void WriteRawRC(unsigned char Address, unsigned char value)
     
441. {  
     
442.     unsigned char i, ucAddr;
     
443. 
     
444.     SCK_L;
     
445.     NSS_L;
     
446.     ucAddr = ((Address<<1)&0x7E);
     
447. 
     
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.     }
     
458. 
     
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. }
     
472. 
     
473. //功    能：置RC522寄存器位
     
474. //参数说明：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. }
     
482. 
     
483. //功    能：清RC522寄存器位
     
484. //参数说明：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. }
     
492. 
     
493. //功    能：通过RC522和ISO14443通讯
     
494. //参数说明：Command[IN]:RC522命令字
     
495. //          pInData[IN]:通过RC522发送到片的数据
     
496. //          InLenByte[IN]:发送数据的字节长度
     
497. //          pOutData[OUT]:接收到的片返回数据
     
498. //          *pOutLenBit[OUT]:返回数据的位长度
     
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.     }
     
524. 
     
525.     WriteRawRC(ComIEnReg,irqEn|0x80);
     
526.     ClearBitMask(ComIrqReg,0x80);
     
527.     WriteRawRC(CommandReg,PCD_IDLE);
     
528.     SetBitMask(FIFOLevelReg,0x80);
     
529. 
     
530.     for (i=0; i<InLenByte; i++)
     
531.     {   WriteRawRC(FIFODataReg, pInData[ i]);    }
     
532.     WriteRawRC(CommandReg, Command);
     
533. 
     
534. 
     
535.     if (Command == PCD_TRANSCEIVE)
     
536.     {    SetBitMask(BitFramingReg,0x80);  }
     
537. 
     
538. //    i = 600;//根据时钟频率调整，操作M1最大等待时间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;   }
     
573. 
     
574.    }
     
575. 
     
576. 
     
577.    SetBitMask(ControlReg,0x80);           // stop timer now
     
578.    WriteRawRC(CommandReg,PCD_IDLE);
     
579.    return status;
     
580. }
     
581. 
     
582. //开启天线  
     
583. //每次启动或关闭天险发射之间应至少有1ms的间隔
     
584. void PcdAntennaOn()
     
585. {
     
586.     unsigned char i;
     
587.     i = ReadRawRC(TxControlReg);
     
588.     if (!(i & 0x03))
     
589.     {
     
590.         SetBitMask(TxControlReg, 0x03);
     
591.     }
     
592. }
     
593. 
     
594. //关闭天线
     
595. void PcdAntennaOff()
     
596. {
     
597.     ClearBitMask(TxControlReg, 0x03);
     
598. }
     
599. 
     
600. //等待离开
     
601. void WaitCardOff(void)
     
602. {
     
603.         char          status;
     
604.   unsigned char        TagType[2];
     
605. 
     
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. }
     
624. 
     
625. // Delay 10ms
     
626. void delay_10ms(unsigned int _10ms)
     
627. {
     
628.         unsigned int i, j;
     
629. 
     
630.         for(i=0; i<_10ms; i++)
     
631.         {
     
632.                 for(j=0; j<60000; j++);
     
633.         }
     
634. }
     
635. 
     
636. ///////////////////////以上为RC522驱动函数/////////////////////////
     
637. ///////////////////////以上为RC522驱动函数/////////////////////////
     
638. ///////////////////////以上为RC522驱动函数/////////////////////////
     
639. 
     
640. 
     
641. //RFID模块初始化
     
642. void RFID_Init(void)                                                                        
     
643. {
     
644.         PcdInit();                                                                                                //RC522端口定义
     
645.     PcdReset();                                                                                                //复位RC522
     
646.     PcdAntennaOff();                                                                                  //关天线                 
     
647.     PcdAntennaOn();                                                                                  //开天线
     
648.         M500PcdConfigISOType('A');
     
649. }
     
650. 
     
651. //获取编号函数，返回编号1-3，非系统录入返回0，没有识别到返回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. }

复制代码

原理图: 无
仿真: 无
代码: NFC门禁系统.zip (332.47 KB, 下载次数: 19)

2023-10-20 12:19 上传

点击文件名下载附件
下载积分: 黑币 -5

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1