RFID-RC522是一个淘宝上比较常见的一个识别RFID的一个模块。他可以做到对RFID的读写。MF RC522 是应用于13.56MHz 非接触式通信中高集成度读写卡系列芯片中的一员。是NXP公司针对“三表”应用推出的一款低电压、低成本、体积小的非接触式读写卡芯片，是智能仪表和便携 式手持设备研发的较好选择

##RFID读写卡的过程     读写卡主要有五个步骤：寻卡，防冲突，选卡，认证，读/写卡。 ###寻卡

1. <font face="微软雅黑" size="3">// REQ_ALL代表寻天线区内所有卡，TagType为返回的卡的类型
   
2. status= PcdRequest( REQ_ALL , TagType );</font>

复制代码

TagType返回的卡类型有： 0x4400 = Mifare_UltraLight 0x0400 = Mifare_One(S50) 0x0200 = Mifare_One(S70) 0x0800 = Mifare_Pro(X) 0x4403 = Mifare_DESFire ###防冲突

1. <font face="微软雅黑" size="3">
   
2. if(!status)
   
3. {
   
4.         status = PcdAnticoll(SelectedSnr);
   
5.         // ......
   
6. }</font>

复制代码

###认证

1. <font face="微软雅黑" size="3">if(!status)
   
2. {
   
3.         // 认证
   
4.         snr = 1;    // 扇区号1
   
5.         status = PcdAuthState(KEYA, (snr*4+3), DefaultKey, SelectedSnr);    // 校验1扇区密码，密码位于每一扇区第3块
   
6.         // ......
   
7. }</font>

复制代码

四个参数分别是：验证A密钥，块地址，扇区密码，卡序列号 ###读写卡

1. <font face="微软雅黑" size="3">
   
2. if(!status)
   
3. {
   
4.         //读写卡
   
5.         status = PcdRead((snr*4+0), buf);   // 读卡，读取1扇区0块数据到buf[0]-buf[16]
   
6.         status = PcdWrite((snr*4+0), "way2");   // 写卡，将buf[0]-buf[16]写入1扇区0块
   
7.         if(!status)
   
8.         {
   
9.                 //读写成功
   
10.                 printf("read finish!\n");
    
11.                 printf("读到的值是： %s\n",buf);
    
12.                 WaitCardOff();
    
13.         }
    
14. </font>

复制代码

##代码 以下为核心代码： main.c

1. <font face="微软雅黑" size="3">
   
2. #include "stm32f10x.h"
   
3. #include "delay.h"
   
4. #include "bsp_usart.h"
   
5. #include "RC522.h"
   
6. 
   
7. int main()
   
8. {
   
9.     char status;
   
10.         unsigned char snr, buf[16], TagType[2], SelectedSnr[4], DefaultKey[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
    
11.    
    
12.     delay_init();
    
13.     usart_init();
    
14.    
    
15.     PcdInit();
    
16.         PcdReset();
    
17.         PcdAntennaOff();
    
18.         PcdAntennaOn();
    
19.         M500PcdConfigISOType( 'A' );
    
20. 
    
21.     printf( "init over!\n" );
    
22.         while(1){
    
23.         // 寻卡
    
24.                 status= PcdRequest( REQ_ALL , TagType );    // REQ_ALL代表寻天线区内所有卡。TagType为返回的卡类型
    
25.                 if(!status)
    
26.                 {
    
27.             // 防冲突
    
28.                         status = PcdAnticoll(SelectedSnr);
    
29.                         if(!status)
    
30.                         {
    
31.                 // 选卡
    
32.                                 status=PcdSelect(SelectedSnr);
    
33.                                 if(!status)
    
34.                                 {
    
35.                     // 认证
    
36.                                         snr = 1;    // 扇区号1
    
37.                                         status = PcdAuthState(KEYA, (snr*4+3), DefaultKey, SelectedSnr);    // 校验1扇区密码，密码位于每一扇区第3块
    
38.                                           // 验证A密钥，块地址，扇区密码，卡序列号
    
39.                                         {
    
40.                                                 if(!status)
    
41.                                                 {
    
42.                             //读写卡
    
43.                                                         status = PcdRead((snr*4+0), buf);   // 读卡，读取1扇区0块数据到buf[0]-buf[16]
    
44. //                                                        status = PcdWrite((snr*4+0), "way2");   // 写卡，将buf[0]-buf[16]写入1扇区0块
    
45.                                                         if(!status)
    
46.                                                         {
    
47.                                 //读写成功
    
48.                                 printf("read finish!\n");
    
49.                                 printf("读到的值是： %s\n",buf);
    
50.                                                                 WaitCardOff();
    
51.                                                         }
    
52.                                                 }
    
53.                                         }
    
54.                                 }
    
55.                         }
    
56.                 }
    
57.         }
    
58. }
    
59. </font>

复制代码

RC522.h

1. <font face="微软雅黑" size="3">
   
2. #ifndef __RC522_H
   
3. #define __RC522_H
   
4. 
   
5. #define MF522_RST_PIN                    GPIO_Pin_11
   
6. #define MF522_RST_PORT                   GPIOB
   
7. #define MF522_RST_CLK                    RCC_APB2Periph_GPIOB
   
8. 
   
9. #define MF522_MISO_PIN                   GPIO_Pin_10
   
10. #define MF522_MISO_PORT                  GPIOB
    
11. #define MF522_MISO_CLK                   RCC_APB2Periph_GPIOB
    
12. 
    
13. #define MF522_MOSI_PIN                   GPIO_Pin_1
    
14. #define MF522_MOSI_PORT                  GPIOB
    
15. #define MF522_MOSI_CLK                   RCC_APB2Periph_GPIOB
    
16. 
    
17. #define MF522_SCK_PIN                    GPIO_Pin_0
    
18. #define MF522_SCK_PORT                   GPIOB
    
19. #define MF522_SCK_CLK                    RCC_APB2Periph_GPIOB
    
20. 
    
21. #define MF522_NSS_PIN                    GPIO_Pin_7
    
22. #define MF522_NSS_PORT                   GPIOA
    
23. #define MF522_NSS_CLK                    RCC_APB2Periph_GPIOA
    
24. 
    
25. #define RST_H                            GPIO_SetBits(MF522_RST_PORT, MF522_RST_PIN)
    
26. #define RST_L                            GPIO_ResetBits(MF522_RST_PORT, MF522_RST_PIN)
    
27. #define MOSI_H                           GPIO_SetBits(MF522_MOSI_PORT, MF522_MOSI_PIN)
    
28. #define MOSI_L                           GPIO_ResetBits(MF522_MOSI_PORT, MF522_MOSI_PIN)
    
29. #define SCK_H                            GPIO_SetBits(MF522_SCK_PORT, MF522_SCK_PIN)
    
30. #define SCK_L                            GPIO_ResetBits(MF522_SCK_PORT, MF522_SCK_PIN)
    
31. #define NSS_H                            GPIO_SetBits(MF522_NSS_PORT, MF522_NSS_PIN)
    
32. #define NSS_L                            GPIO_ResetBits(MF522_NSS_PORT, MF522_NSS_PIN)
    
33. #define READ_MISO                        GPIO_ReadInputDataBit(MF522_MISO_PORT, MF522_MISO_PIN)
    
34. 
    
35. // 函数原型
    
36. void PcdInit(void);
    
37. char PcdReset(void);
    
38. void PcdAntennaOn(void);
    
39. void PcdAntennaOff(void);
    
40. char PcdRequest(unsigned char req_code,unsigned char *pTagType);
    
41. char PcdAnticoll(unsigned char *pSnr);
    
42. char PcdSelect(unsigned char *pSnr);
    
43. char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr);
    
44. char PcdRead(unsigned char addr,unsigned char *pData);
    
45. char PcdWrite(unsigned char addr,unsigned char *pData);
    
46. char PcdValue(unsigned char dd_mode,unsigned char addr,unsigned char *pValue);
    
47. char PcdBakValue(unsigned char sourceaddr, unsigned char goaladdr);
    
48. char PcdHalt(void);
    
49. char PcdComMF522(unsigned char Command,
    
50.                  unsigned char *pInData,
    
51.                  unsigned char InLenByte,
    
52.                  unsigned char *pOutData,
    
53.                  unsigned int  *pOutLenBit);
    
54. void CalulateCRC(unsigned char *pIndata,unsigned char len,unsigned char *pOutData);
    
55. void WriteRawRC(unsigned char Address,unsigned char value);
    
56. unsigned char ReadRawRC(unsigned char Address);
    
57. void SetBitMask(unsigned char reg,unsigned char mask);
    
58. void ClearBitMask(unsigned char reg,unsigned char mask);
    
59. char M500PcdConfigISOType(unsigned char type);
    
60. void delay_10ms(unsigned int _10ms);
    
61. void WaitCardOff(void);
    
62. 
    
63. // MF522命令字
    
64. #define PCD_IDLE              0x00               //取消当前命令
    
65. #define PCD_AUTHENT           0x0E               //验证密钥
    
66. #define PCD_RECEIVE           0x08               //接收数据
    
67. #define PCD_TRANSMIT          0x04               //发送数据
    
68. #define PCD_TRANSCEIVE        0x0C               //发送并接收数据
    
69. #define PCD_RESETPHASE        0x0F               //复位
    
70. #define PCD_CALCCRC           0x03               //CRC计算
    
71. 
    
72. 
    
73. // Mifare_One卡片命令字
    
74. #define PICC_REQIDL           0x26               //寻天线区内未进入休眠状态
    
75. #define PICC_REQALL           0x52               //寻天线区内全部卡
    
76. #define PICC_ANTICOLL1        0x93               //防冲撞
    
77. #define PICC_ANTICOLL2        0x95               //防冲撞
    
78. #define PICC_AUTHENT1A        0x60               //验证A密钥
    
79. #define PICC_AUTHENT1B        0x61               //验证B密钥
    
80. #define PICC_READ             0x30               //读块
    
81. #define PICC_WRITE            0xA0               //写块
    
82. #define PICC_DECREMENT        0xC0               //扣款
    
83. #define PICC_INCREMENT        0xC1               //充值
    
84. #define PICC_RESTORE          0xC2               //调块数据到缓冲区
    
85. #define PICC_TRANSFER         0xB0               //保存缓冲区中数据
    
86. #define PICC_HALT             0x50               //休眠
    
87. 
    
88. // MF522 FIFO长度定义
    
89. #define DEF_FIFO_LENGTH       64                 //FIFO size=64byte
    
90. 
    
91. // MF522寄存器定义
    
92. // PAGE 0
    
93. #define     RFU00                 0x00   
    
94. #define     CommandReg            0x01   
    
95. #define     ComIEnReg             0x02   
    
96. #define     DivlEnReg             0x03   
    
97. #define     ComIrqReg             0x04   
    
98. #define     DivIrqReg             0x05
    
99. #define     ErrorReg              0x06   
    
100. #define     Status1Reg            0x07   
     
101. #define     Status2Reg            0x08   
     
102. #define     FIFODataReg           0x09
     
103. #define     FIFOLevelReg          0x0A
     
104. #define     WaterLevelReg         0x0B
     
105. #define     ControlReg            0x0C
     
106. #define     BitFramingReg         0x0D
     
107. #define     CollReg               0x0E
     
108. #define     RFU0F                 0x0F
     
109. // PAGE 1     
     
110. #define     RFU10                 0x10
     
111. #define     ModeReg               0x11
     
112. #define     TxModeReg             0x12
     
113. #define     RxModeReg             0x13
     
114. #define     TxControlReg          0x14
     
115. #define     TxAutoReg             0x15
     
116. #define     TxSelReg              0x16
     
117. #define     RxSelReg              0x17
     
118. #define     RxThresholdReg        0x18
     
119. #define     DemodReg              0x19
     
120. #define     RFU1A                 0x1A
     
121. #define     RFU1B                 0x1B
     
122. #define     MifareReg             0x1C
     
123. #define     RFU1D                 0x1D
     
124. #define     RFU1E                 0x1E
     
125. #define     SerialSpeedReg        0x1F
     
126. // PAGE 2   
     
127. #define     RFU20                 0x20  
     
128. #define     CRCResultRegM         0x21
     
129. #define     CRCResultRegL         0x22
     
130. #define     RFU23                 0x23
     
131. #define     ModWidthReg           0x24
     
132. #define     RFU25                 0x25
     
133. #define     RFCfgReg              0x26
     
134. #define     GsNReg                0x27
     
135. #define     CWGsCfgReg            0x28
     
136. #define     ModGsCfgReg           0x29
     
137. #define     TModeReg              0x2A
     
138. #define     TPrescalerReg         0x2B
     
139. #define     TReloadRegH           0x2C
     
140. #define     TReloadRegL           0x2D
     
141. #define     TCounterValueRegH     0x2E
     
142. #define     TCounterValueRegL     0x2F
     
143. // PAGE 3      
     
144. #define     RFU30                 0x30
     
145. #define     TestSel1Reg           0x31
     
146. #define     TestSel2Reg           0x32
     
147. #define     TestPinEnReg          0x33
     
148. #define     TestPinValueReg       0x34
     
149. #define     TestBusReg            0x35
     
150. #define     AutoTestReg           0x36
     
151. #define     VersionReg            0x37
     
152. #define     AnalogTestReg         0x38
     
153. #define     TestDAC1Reg           0x39  
     
154. #define     TestDAC2Reg           0x3A   
     
155. #define     TestADCReg            0x3B   
     
156. #define     RFU3C                 0x3C   
     
157. #define     RFU3D                 0x3D   
     
158. #define     RFU3E                 0x3E   
     
159. #define     RFU3F                          0x3F
     
160. 
     
161. 
     
162. #define     REQ_ALL               0x52
     
163. #define     KEYA                  0x60
     
164. 
     
165. // 和MF522通讯时返回的错误代码
     
166. #define MI_OK                          (char)0
     
167. #define MI_NOTAGERR                    (char)(-1)
     
168. #define MI_ERR                         (char)(-2)
     
169. 
     
170. #endif
     
171. </font>

复制代码

RC522.c

1. <font face="微软雅黑" size="3">#include "RC522.H"
   
2. #include "stm32f10x_gpio.h"
   
3. 
   
4. #define MAXRLEN 18                        
   
5. 
   
6. void PcdInit()
   
7. {
   
8.           GPIO_InitTypeDef  GPIO_InitStructure;
   
9. 
   
10.           /* Enable the GPIO Clock */
    
11.           RCC_APB2PeriphClockCmd(MF522_RST_CLK, ENABLE);
    
12. 
    
13.           /* Configure the GPIO pin */
    
14.           GPIO_InitStructure.GPIO_Pin = MF522_RST_PIN;
    
15.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
16.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    
17. 
    
18.           GPIO_Init(MF522_RST_PORT, &GPIO_InitStructure);
    
19. 
    
20.           /* Enable the GPIO Clock */
    
21.           RCC_APB2PeriphClockCmd(MF522_MISO_CLK, ENABLE);
    
22. 
    
23.           /* Configure the GPIO pin */
    
24.           GPIO_InitStructure.GPIO_Pin = MF522_MISO_PIN;
    
25.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    
26.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    
27. 
    
28.           GPIO_Init(MF522_MISO_PORT, &GPIO_InitStructure);
    
29. 
    
30.           /* Enable the GPIO Clock */
    
31.           RCC_APB2PeriphClockCmd(MF522_MOSI_CLK, ENABLE);
    
32. 
    
33.           /* Configure the GPIO pin */
    
34.           GPIO_InitStructure.GPIO_Pin = MF522_MOSI_PIN;
    
35.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
36.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    
37. 
    
38.           GPIO_Init(MF522_MOSI_PORT, &GPIO_InitStructure);
    
39. 
    
40.           /* Enable the GPIO Clock */
    
41.           RCC_APB2PeriphClockCmd(MF522_SCK_CLK, ENABLE);
    
42. 
    
43.           /* Configure the GPIO pin */
    
44.           GPIO_InitStructure.GPIO_Pin = MF522_SCK_PIN;
    
45.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
46.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    
47. 
    
48.           GPIO_Init(MF522_SCK_PORT, &GPIO_InitStructure);
    
49. 
    
50.           /* Enable the GPIO Clock */
    
51.           RCC_APB2PeriphClockCmd(MF522_NSS_CLK, ENABLE);
    
52. 
    
53.           /* Configure the GPIO pin */
    
54.           GPIO_InitStructure.GPIO_Pin = MF522_NSS_PIN;
    
55.           GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    
56.           GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
    
57. 
    
58.           GPIO_Init(MF522_NSS_PORT, &GPIO_InitStructure);
    
59. }
    
60. 
    
61. //功    能：寻卡
    
62. //参数说明: req_code[IN]:寻卡方式
    
63. //                0x52 = 寻感应区内所有符合14443A标准的卡
    
64. //                0x26 = 寻未进入休眠状态的卡
    
65. //                    pTagType[OUT]：卡片类型代码
    
66. //                0x4400 = Mifare_UltraLight
    
67. //                0x0400 = Mifare_One(S50)
    
68. //                0x0200 = Mifare_One(S70)
    
69. //                0x0800 = Mifare_Pro(X)
    
70. //                0x4403 = Mifare_DESFire
    
71. //返    回: 成功返回MI_OK
    
72. char PcdRequest(unsigned char req_code,unsigned char *pTagType)
    
73. {
    
74.    char status;  
    
75.    unsigned int  unLen;
    
76.    unsigned char ucComMF522Buf[MAXRLEN];
    
77. //  unsigned char xTest ;
    
78.    ClearBitMask(Status2Reg,0x08);
    
79.    WriteRawRC(BitFramingReg,0x07);
    
80. 
    
81. //  xTest = ReadRawRC(BitFramingReg);
    
82. //  if(xTest == 0x07 )
    
83. //   { LED_GREEN  =0 ;}
    
84. // else {LED_GREEN =1 ;while(1){}}
    
85.    SetBitMask(TxControlReg,0x03);
    
86. 
    
87.    ucComMF522Buf[0] = req_code;
    
88. 
    
89.    status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,1,ucComMF522Buf,&unLen);
    
90. //     if(status  == MI_OK )
    
91. //   { LED_GREEN  =0 ;}
    
92. //   else {LED_GREEN =1 ;}
    
93.    if ((status == MI_OK) && (unLen == 0x10))
    
94.    {   
    
95.        *pTagType     = ucComMF522Buf[0];
    
96.        *(pTagType+1) = ucComMF522Buf[1];
    
97.    }
    
98.    else
    
99.    {   status = MI_ERR;   }
    
100.    
     
101.    return status;
     
102. }
     
103. 
     
104. //功    能：防冲撞
     
105. //参数说明: pSnr[OUT]:卡片序列号，4字节
     
106. //返    回: 成功返回MI_OK
     
107. char PcdAnticoll(unsigned char *pSnr)
     
108. {
     
109.     char status;
     
110.     unsigned char i,snr_check=0;
     
111.     unsigned int  unLen;
     
112.     unsigned char ucComMF522Buf[MAXRLEN];
     
113.    
     
114. 
     
115.     ClearBitMask(Status2Reg,0x08);
     
116.     WriteRawRC(BitFramingReg,0x00);
     
117.     ClearBitMask(CollReg,0x80);
     
118. 
     
119.     ucComMF522Buf[0] = PICC_ANTICOLL1;
     
120.     ucComMF522Buf[1] = 0x20;
     
121. 
     
122.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,2,ucComMF522Buf,&unLen);
     
123. 
     
124.     if (status == MI_OK)
     
125.     {
     
126.              for (i=0; i<4; i++)
     
127.          {   
     
128.              *(pSnr+i)  = ucComMF522Buf[i];
     
129.              snr_check ^= ucComMF522Buf[i];
     
130.          }
     
131.          if (snr_check != ucComMF522Buf[i])
     
132.          {   status = MI_ERR;    }
     
133.     }
     
134.    
     
135.     SetBitMask(CollReg,0x80);
     
136.     return status;
     
137. }
     
138. 
     
139. //功    能：选定卡片
     
140. //参数说明: pSnr[IN]:卡片序列号，4字节
     
141. //返    回: 成功返回MI_OK
     
142. char PcdSelect(unsigned char *pSnr)
     
143. {
     
144.     char status;
     
145.     unsigned char i;
     
146.     unsigned int  unLen;
     
147.     unsigned char ucComMF522Buf[MAXRLEN];
     
148.    
     
149.     ucComMF522Buf[0] = PICC_ANTICOLL1;
     
150.     ucComMF522Buf[1] = 0x70;
     
151.     ucComMF522Buf[6] = 0;
     
152.     for (i=0; i<4; i++)
     
153.     {
     
154.             ucComMF522Buf[i+2] = *(pSnr+i);
     
155.             ucComMF522Buf[6]  ^= *(pSnr+i);
     
156.     }
     
157.     CalulateCRC(ucComMF522Buf,7,&ucComMF522Buf[7]);
     
158.   
     
159.     ClearBitMask(Status2Reg,0x08);
     
160. 
     
161.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);
     
162.    
     
163.     if ((status == MI_OK) && (unLen == 0x18))
     
164.     {   status = MI_OK;  }
     
165.     else
     
166.     {   status = MI_ERR;    }
     
167. 
     
168.     return status;
     
169. }
     
170. 
     
171. //功    能：验证卡片密码
     
172. //参数说明: auth_mode[IN]: 密码验证模式
     
173. //                 0x60 = 验证A密钥
     
174. //                 0x61 = 验证B密钥
     
175. //          addr[IN]：块地址
     
176. //          pKey[IN]：密码
     
177. //          pSnr[IN]：卡片序列号，4字节
     
178. //返    回: 成功返回MI_OK      
     
179. char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr)
     
180. {
     
181.     char status;
     
182.     unsigned int  unLen;
     
183.     unsigned char i,ucComMF522Buf[MAXRLEN];
     
184. 
     
185.     ucComMF522Buf[0] = auth_mode;
     
186.     ucComMF522Buf[1] = addr;
     
187.     for (i=0; i<6; i++)
     
188.     {    ucComMF522Buf[i+2] = *(pKey+i);   }
     
189.     for (i=0; i<6; i++)
     
190.     {    ucComMF522Buf[i+8] = *(pSnr+i);   }
     
191. //   memcpy(&ucComMF522Buf[2], pKey, 6);
     
192. //   memcpy(&ucComMF522Buf[8], pSnr, 4);
     
193.    
     
194.     status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
     
195.     if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
     
196.     {   status = MI_ERR;   }
     
197.    
     
198.     return status;
     
199. }
     
200. 
     
201. //功    能：读取M1卡一块数据
     
202. //参数说明: addr[IN]：块地址
     
203. //          pData[OUT]：读出的数据，16字节
     
204. //返    回: 成功返回MI_OK
     
205. char PcdRead(unsigned char addr,unsigned char *pData)
     
206. {
     
207.     char status;
     
208.     unsigned int  unLen;
     
209.     unsigned char i,ucComMF522Buf[MAXRLEN];
     
210. 
     
211.     ucComMF522Buf[0] = PICC_READ;
     
212.     ucComMF522Buf[1] = addr;
     
213.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
214.    
     
215.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
216.     if ((status == MI_OK) && (unLen == 0x90))
     
217. //   {   memcpy(pData, ucComMF522Buf, 16);   }
     
218.     {
     
219.         for (i=0; i<16; i++)
     
220.         {    *(pData+i) = ucComMF522Buf[i];   }
     
221.     }
     
222.     else
     
223.     {   status = MI_ERR;   }
     
224.    
     
225.     return status;
     
226. }
     
227. 
     
228. //功    能：写数据到M1卡一块
     
229. //参数说明: addr[IN]：块地址
     
230. //          pData[IN]：写入的数据，16字节
     
231. //返    回: 成功返回MI_OK         
     
232. char PcdWrite(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_WRITE;
     
239.     ucComMF522Buf[1] = addr;
     
240.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
241. 
     
242.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
243. 
     
244.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     
245.     {   status = MI_ERR;   }
     
246.         
     
247.     if (status == MI_OK)
     
248.     {
     
249.         //memcpy(ucComMF522Buf, pData, 16);
     
250. 
     
251.         for (i=0; i<16; i++)
     
252.         {    ucComMF522Buf[i] = *(pData+i);   }
     
253.         CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16]);
     
254. 
     
255.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,18,ucComMF522Buf,&unLen);
     
256.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     
257.         {   status = MI_ERR;   }
     
258.     }
     
259.    
     
260.     return status;
     
261. }
     
262. 
     
263. //功    能：命令卡片进入休眠状态
     
264. //返    回: 成功返回MI_OK
     
265. char PcdHalt(void)
     
266. {
     
267.     unsigned int  unLen;
     
268.     unsigned char ucComMF522Buf[MAXRLEN];
     
269. 
     
270.     ucComMF522Buf[0] = PICC_HALT;
     
271.     ucComMF522Buf[1] = 0;
     
272.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
273. 
     
274.     PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
275. 
     
276.     return MI_OK;
     
277. }
     
278. 
     
279. //用MF522计算CRC16函数
     
280. void CalulateCRC(unsigned char *pIndata,unsigned char len,unsigned char *pOutData)
     
281. {
     
282.     unsigned char i,n;
     
283.     ClearBitMask(DivIrqReg,0x04);
     
284.     WriteRawRC(CommandReg,PCD_IDLE);
     
285.     SetBitMask(FIFOLevelReg,0x80);
     
286.     for (i=0; i<len; i++)
     
287.     {   WriteRawRC(FIFODataReg, *(pIndata+i));   }
     
288.     WriteRawRC(CommandReg, PCD_CALCCRC);
     
289.     i = 0xFF;
     
290.     do
     
291.     {
     
292.         n = ReadRawRC(DivIrqReg);
     
293.         i--;
     
294.     }
     
295.     while ((i!=0) && !(n&0x04));
     
296.     pOutData[0] = ReadRawRC(CRCResultRegL);
     
297.     pOutData[1] = ReadRawRC(CRCResultRegM);
     
298. }
     
299. 
     
300. //功    能：复位RC522
     
301. //返    回: 成功返回MI_OK
     
302. char PcdReset(void)
     
303. {
     
304.     RST_H;
     
305.     delay_10ms(1);
     
306.     RST_L;
     
307.     delay_10ms(1);
     
308.     RST_H;
     
309.           delay_10ms(10);
     
310.        
     
311.                 if(ReadRawRC(0x02) == 0x80)
     
312.                 {
     
313.                 }
     
314. 
     
315.     WriteRawRC(CommandReg,PCD_RESETPHASE);
     
316.    
     
317.     WriteRawRC(ModeReg,0x3D);            //和Mifare卡通讯，CRC初始值0x6363
     
318.     WriteRawRC(TReloadRegL,30);           
     
319.     WriteRawRC(TReloadRegH,0);
     
320.     WriteRawRC(TModeReg,0x8D);
     
321.     WriteRawRC(TPrescalerReg,0x3E);
     
322.     WriteRawRC(TxAutoReg,0x40);     
     
323.     return MI_OK;
     
324. }
     
325. 
     
326. //设置RC632的工作方式
     
327. char M500PcdConfigISOType(unsigned char type)
     
328. {
     
329.    if (type == 'A')                     //ISO14443_A
     
330.    {
     
331.        ClearBitMask(Status2Reg,0x08);
     
332. 
     
333. /*     WriteRawRC(CommandReg,0x20);    //as default   
     
334.        WriteRawRC(ComIEnReg,0x80);     //as default
     
335.        WriteRawRC(DivlEnReg,0x0);      //as default
     
336.            WriteRawRC(ComIrqReg,0x04);     //as default
     
337.            WriteRawRC(DivIrqReg,0x0);      //as default
     
338.            WriteRawRC(Status2Reg,0x0);//80    //trun off temperature sensor
     
339.            WriteRawRC(WaterLevelReg,0x08); //as default
     
340.        WriteRawRC(ControlReg,0x20);    //as default
     
341.            WriteRawRC(CollReg,0x80);    //as default
     
342. */
     
343.        WriteRawRC(ModeReg,0x3D);//3F
     
344. /*           WriteRawRC(TxModeReg,0x0);      //as default???
     
345.            WriteRawRC(RxModeReg,0x0);      //as default???
     
346.            WriteRawRC(TxControlReg,0x80);  //as default???
     
347.            WriteRawRC(TxSelReg,0x10);      //as default???
     
348.    */
     
349.        WriteRawRC(RxSelReg,0x86);//84
     
350. //      WriteRawRC(RxThresholdReg,0x84);//as default
     
351. //      WriteRawRC(DemodReg,0x4D);      //as default
     
352. 
     
353. //      WriteRawRC(ModWidthReg,0x13);//26
     
354.        WriteRawRC(RFCfgReg,0x7F);   //4F
     
355.         /*   WriteRawRC(GsNReg,0x88);        //as default???
     
356.            WriteRawRC(CWGsCfgReg,0x20);    //as default???
     
357.        WriteRawRC(ModGsCfgReg,0x20);   //as default???
     
358. */
     
359.               WriteRawRC(TReloadRegL,30);//tmoLength);// TReloadVal = 'h6a =tmoLength(dec)
     
360.            WriteRawRC(TReloadRegH,0);
     
361.        WriteRawRC(TModeReg,0x8D);
     
362.            WriteRawRC(TPrescalerReg,0x3E);
     
363.           
     
364. 
     
365.   //     PcdSetTmo(106);
     
366.            delay_10ms(1);
     
367.        PcdAntennaOn();
     
368.    }
     
369.    else{ return (char)-1; }
     
370.    
     
371.    return MI_OK;
     
372. }
     
373. 
     
374. //功    能：读RC632寄存器
     
375. //参数说明：Address[IN]:寄存器地址
     
376. //返    回：读出的值
     
377. unsigned char ReadRawRC(unsigned char Address)
     
378. {
     
379.      unsigned char i, ucAddr;
     
380.      unsigned char ucResult=0;
     
381. 
     
382.      NSS_L;
     
383.      ucAddr = ((Address<<1)&0x7E)|0x80;
     
384. 
     
385.      for(i=8;i>0;i--)
     
386.      {
     
387.          SCK_L;
     
388.                   if(ucAddr&0x80)
     
389.                  MOSI_H;
     
390.                  else
     
391.                                  MOSI_L;
     
392.          SCK_H;
     
393.          ucAddr <<= 1;
     
394.      }
     
395. 
     
396.      for(i=8;i>0;i--)
     
397.      {
     
398.          SCK_L;
     
399.          ucResult <<= 1;
     
400.          SCK_H;
     
401.                  if(READ_MISO == 1)
     
402.                  ucResult |= 1;
     
403.      }
     
404. 
     
405.      NSS_H;
     
406.      SCK_H;
     
407.      return ucResult;
     
408. }
     
409. 
     
410. //功    能：写RC632寄存器
     
411. //参数说明：Address[IN]:寄存器地址
     
412. //          value[IN]:写入的值
     
413. void WriteRawRC(unsigned char Address, unsigned char value)
     
414. {  
     
415.     unsigned char i, ucAddr;
     
416. 
     
417.     SCK_L;
     
418.     NSS_L;
     
419.     ucAddr = ((Address<<1)&0x7E);
     
420. 
     
421.     for(i=8;i>0;i--)
     
422.     {
     
423.                 if(ucAddr&0x80)
     
424.                 MOSI_H;
     
425.                 else
     
426.                         MOSI_L;
     
427.         SCK_H;
     
428.         ucAddr <<= 1;
     
429.         SCK_L;
     
430.     }
     
431. 
     
432.     for(i=8;i>0;i--)
     
433.     {
     
434.                 if(value&0x80)
     
435.                 MOSI_H;
     
436.                 else
     
437.                         MOSI_L;
     
438.         SCK_H;
     
439.         value <<= 1;
     
440.         SCK_L;
     
441.     }
     
442.     NSS_H;
     
443.     SCK_H;
     
444. }
     
445. 
     
446. //功    能：置RC522寄存器位
     
447. //参数说明：reg[IN]:寄存器地址
     
448. //          mask[IN]:置位值
     
449. void SetBitMask(unsigned char reg,unsigned char mask)  
     
450. {
     
451.     char tmp = 0x0;
     
452.     tmp = ReadRawRC(reg);
     
453.     WriteRawRC(reg,tmp | mask);  // set bit mask
     
454. }
     
455. 
     
456. //功    能：清RC522寄存器位
     
457. //参数说明：reg[IN]:寄存器地址
     
458. //          mask[IN]:清位值
     
459. void ClearBitMask(unsigned char reg,unsigned char mask)  
     
460. {
     
461.     char tmp = 0x0;
     
462.     tmp = ReadRawRC(reg);
     
463.     WriteRawRC(reg, tmp & ~mask);  // clear bit mask
     
464. }
     
465. 
     
466. //功    能：通过RC522和ISO14443卡通讯
     
467. //参数说明：Command[IN]:RC522命令字
     
468. //          pInData[IN]:通过RC522发送到卡片的数据
     
469. //          InLenByte[IN]:发送数据的字节长度
     
470. //          pOutData[OUT]:接收到的卡片返回数据
     
471. //          *pOutLenBit[OUT]:返回数据的位长度
     
472. char PcdComMF522(unsigned char Command,
     
473.                  unsigned char *pInData,
     
474.                  unsigned char InLenByte,
     
475.                  unsigned char *pOutData,
     
476.                  unsigned int  *pOutLenBit)
     
477. {
     
478.     char status = MI_ERR;
     
479.     unsigned char irqEn   = 0x00;
     
480.     unsigned char waitFor = 0x00;
     
481.     unsigned char lastBits;
     
482.     unsigned char n;
     
483.     unsigned int i;
     
484.     switch (Command)
     
485.     {
     
486.        case PCD_AUTHENT:
     
487.           irqEn   = 0x12;
     
488.           waitFor = 0x10;
     
489.           break;
     
490.        case PCD_TRANSCEIVE:
     
491.           irqEn   = 0x77;
     
492.           waitFor = 0x30;
     
493.           break;
     
494.        default:
     
495.          break;
     
496.     }
     
497.    
     
498.     WriteRawRC(ComIEnReg,irqEn|0x80);
     
499.     ClearBitMask(ComIrqReg,0x80);
     
500.     WriteRawRC(CommandReg,PCD_IDLE);
     
501.     SetBitMask(FIFOLevelReg,0x80);
     
502.    
     
503.     for (i=0; i<InLenByte; i++)
     
504.     {   WriteRawRC(FIFODataReg, pInData[i]);    }
     
505.     WriteRawRC(CommandReg, Command);
     
506.    
     
507.    
     
508.     if (Command == PCD_TRANSCEIVE)
     
509.     {    SetBitMask(BitFramingReg,0x80);  }
     
510.    
     
511. //    i = 600;//根据时钟频率调整，操作M1卡最大等待时间25ms
     
512. i = 2000;
     
513.     do
     
514.     {
     
515.          n = ReadRawRC(ComIrqReg);
     
516.          i--;
     
517.     }
     
518.     while ((i!=0) && !(n&0x01) && !(n&waitFor));
     
519.     ClearBitMask(BitFramingReg,0x80);
     
520.              
     
521.     if (i!=0)
     
522.     {   
     
523.          if(!(ReadRawRC(ErrorReg)&0x1B))
     
524.          {
     
525.              status = MI_OK;
     
526.              if (n & irqEn & 0x01)
     
527.              {   status = MI_NOTAGERR;   }
     
528.              if (Command == PCD_TRANSCEIVE)
     
529.              {
     
530.                        n = ReadRawRC(FIFOLevelReg);
     
531.                       lastBits = ReadRawRC(ControlReg) & 0x07;
     
532.                 if (lastBits)
     
533.                 {   *pOutLenBit = (n-1)*8 + lastBits;   }
     
534.                 else
     
535.                 {   *pOutLenBit = n*8;   }
     
536.                 if (n == 0)
     
537.                 {   n = 1;    }
     
538.                 if (n > MAXRLEN)
     
539.                 {   n = MAXRLEN;   }
     
540.                 for (i=0; i<n; i++)
     
541.                 {   pOutData[i] = ReadRawRC(FIFODataReg);    }
     
542.             }
     
543.          }
     
544.          else
     
545.          {   status = MI_ERR;   }
     
546.         
     
547.    }
     
548.    
     
549. 
     
550.    SetBitMask(ControlReg,0x80);           // stop timer now
     
551.    WriteRawRC(CommandReg,PCD_IDLE);
     
552.    return status;
     
553. }
     
554. 
     
555. //开启天线  
     
556. //每次启动或关闭天险发射之间应至少有1ms的间隔
     
557. void PcdAntennaOn()
     
558. {
     
559.     unsigned char i;
     
560.     i = ReadRawRC(TxControlReg);
     
561.     if (!(i & 0x03))
     
562.     {
     
563.         SetBitMask(TxControlReg, 0x03);
     
564.     }
     
565. }
     
566. 
     
567. //关闭天线
     
568. void PcdAntennaOff()
     
569. {
     
570.     ClearBitMask(TxControlReg, 0x03);
     
571. }
     
572. 
     
573. //等待卡离开
     
574. void WaitCardOff(void)
     
575. {
     
576.         char          status;
     
577.   unsigned char        TagType[2];
     
578. 
     
579.         while(1)
     
580.         {
     
581.                 status = PcdRequest(REQ_ALL, TagType);
     
582.                 if(status)
     
583.                 {
     
584.                         status = PcdRequest(REQ_ALL, TagType);
     
585.                         if(status)
     
586.                         {
     
587.                                 status = PcdRequest(REQ_ALL, TagType);
     
588.                                 if(status)
     
589.                                 {
     
590.                                         return;
     
591.                                 }
     
592.                         }
     
593.                 }
     
594.                 delay_10ms(10);
     
595.         }
     
596. }
     
597. 
     
598. // Delay 10ms
     
599. void delay_10ms(unsigned int _10ms)
     
600. {
     
601.         unsigned int i, j;
     
602. 
     
603.         for(i=0; i<_10ms; i++)
     
604.         {
     
605.                 for(j=0; j<60000; j++);
     
606.         }
     
607. }</font>
     

复制代码

RC522手册里说支持14443智能卡协议，有研究没？