rc522作为使用非常多的读写卡芯片，使用SPI芯片读写应用已经非常广了。但有些时候我们只有串口可以使用，或者我们觉得串口使用更加方便，那么就必须要编写串口的驱动程序。不过很难找到可以直接使用的串口程序。所以在此将我这边写好的串口驱动写好如下：


直接上代码
下面是RC522.C的驱动文件。支持读写卡号8位数据。rc522用的是stm32 的串口3，调试显示是串口1；
8 G6 T+ z5 U6 [9 a: O6 T6 J

1. <font face="微软雅黑" size="3">#include "rc522.h"
     [* b. x, V9 h+ ^- B; q( m' n
2. #include "delay.h"
   
3. /
     ]* l) E# v9 ^) m5 {, B3 Y
4. //MF522命令字
   / q  j. }; `2 l4 c. T+ ?, Z+ z; \8 y
5. /
   & g& g$ b9 V/ T4 u2 x2 i. |
6. #define PCD_IDLE              0x00               //取消当前命令
   9 A( T0 B4 U. p, {  _0 N
7. #define PCD_CALCCRC           0x03               //CRC计算
   
8. #define PCD_TRANSMIT          0x04               //发送数据
   8 t- S8 W5 H  T8 S" ]$ l- ^) W
9. #define PCD_RECEIVE           0x08               //接收数据
   
10. #define PCD_TRANSCEIVE        0x0C               //发送并接收数据
    9 P8 i4 k  `( o9 Q+ b
11. #define PCD_AUTHENT           0x0E               //验证密钥
    
12. #define PCD_RESETPHASE        0x0F               //复位
    8 u4 ~& z  g5 S9 H5 q
13. 
    
14. /
    
15. //Mifare_One卡片命令字
    ) D; c" o. L% q/ D
16. /
    
17. #define PICC_REQIDL           0x26               //寻天线区内未进入休眠状态
    
18. #define PICC_REQALL           0x52               //寻天线区内全部卡
    8 _7 e+ D6 x& X3 O
19. #define PICC_ANTICOLL1        0x93               //防冲撞
    
20. #define PICC_ANTICOLL2        0x95               //防冲撞
    4 [9 p( x( ^8 \
21. #define PICC_AUTHENT1A        0x60               //验证A密钥
    
22. #define PICC_AUTHENT1B        0x61               //验证B密钥
    
23. #define PICC_READ             0x30               //读块
    " C2 M9 s/ D2 G# }" J1 ^
24. #define PICC_WRITE            0xA0               //写块
    
25. #define PICC_DECREMENT        0xC0               //扣款
    
26. #define PICC_INCREMENT        0xC1               //充值
    
27. #define PICC_RESTORE          0xC2               //调块数据到缓冲区
    + x" i9 ^: `* t2 @- }' j  Q! o
28. #define PICC_TRANSFER         0xB0               //保存缓冲区中数据
    
29. #define PICC_HALT             0x50               //休眠
    
30. 
    / s' s5 _: N9 m' x
31. /
    ; B0 _; c' e/ I' t! T/ O
32. //MF522 FIFO长度定义
    
33. /
    , N# q$ @8 w7 L) H" m
34. #define DEF_FIFO_LENGTH       64                 //FIFO size=64byte
    
35. #define MAXRLEN  18
    
36. 
    / f+ G8 n0 [. f1 B+ w7 j
37. /
    ( ~1 l: V7 N5 |) P: ^" w# O
38. //MF522寄存器定义
    / O7 g  p# ^( y/ g/ F. I
39. /
    
40. // PAGE 0
    
41. #define     RFU00                 0x00   
    ) a$ \4 n- i8 t' a+ c& v6 i
42. #define     CommandReg            0x01   
    4 v: [0 r! X. \8 S- K/ v# {4 G; O2 n
43. #define     ComIEnReg             0x02   
    
44. #define     DivlEnReg             0x03   
    7 s1 L3 U8 k$ _1 a5 c$ g7 i4 k& x
45. #define     ComIrqReg             0x04   
    
46. #define     DivIrqReg             0x05
    % f& J5 l; Z" g  Z
47. #define     ErrorReg              0x06   
    
48. #define     Status1Reg            0x07   
    
49. #define     Status2Reg            0x08   
    
50. #define     FIFODataReg           0x09
    ; u/ {, ?! A- e1 a( K' Z) v
51. #define     FIFOLevelReg          0x0A
    - w# _( Y: O- G  H4 E& z0 l
52. #define     WaterLevelReg         0x0B
    
53. #define     ControlReg            0x0C
    
54. #define     BitFramingReg         0x0D
    
55. #define     CollReg               0x0E
    ; t: ~2 b; U0 d. O; n0 h: Y5 Y* J
56. #define     RFU0F                 0x0F
    , Z* X; E" |" `, x( K( [, d% M1 }
57. // PAGE 1     
    
58. #define     RFU10                 0x10
    
59. #define     ModeReg               0x11
    & ^) `0 [% \6 u6 h6 `7 f, H8 H
60. #define     TxModeReg             0x12
    9 e  N3 c/ B/ `
61. #define     RxModeReg             0x13
    0 O9 ?& `# w1 @
62. #define     TxControlReg          0x14
    
63. #define     TxAutoReg             0x15
    
64. #define     TxSelReg              0x16
    
65. #define     RxSelReg              0x17
    0 R: \- l7 h/ _# b5 z/ z& J3 G
66. #define     RxThresholdReg        0x18
    ' j2 x- V1 l5 z
67. #define     DemodReg              0x19
    
68. #define     RFU1A                 0x1A
      H  K7 d5 L$ Z+ R7 q/ U
69. #define     RFU1B                 0x1B
    
70. #define     MifareReg             0x1C
    - z* i7 m1 [2 ]" S+ v$ {9 E) s7 x2 T
71. #define     RFU1D                 0x1D
    
72. #define     RFU1E                 0x1E
      c3 D7 ]" [+ |6 A: f
73. #define     SerialSpeedReg        0x1F
    ' V% j8 _9 |" n
74. // PAGE 2   
    
75. #define     RFU20                 0x20  
    
76. #define     CRCResultRegM         0x21
    , ^. ^% A2 @* G! s9 ~, ?# \+ S
77. #define     CRCResultRegL         0x22
    
78. #define     RFU23                 0x23
    5 V. \, o, G: \. p
79. #define     ModWidthReg           0x24
    
80. #define     RFU25                 0x25
    
81. #define     RFCfgReg              0x26
    
82. #define     GsNReg                0x27
    
83. #define     CWGsCfgReg            0x28
    ( N8 A. n6 u( y+ j9 Q
84. #define     ModGsCfgReg           0x29
    6 o7 q. {2 }, S7 n2 ]) X
85. #define     TModeReg              0x2A
    5 e4 E" @; u' m4 ^
86. #define     TPrescalerReg         0x2B
    
87. #define     TReloadRegH           0x2C
    * O8 ~/ [3 h. h$ r, X) L6 o
88. #define     TReloadRegL           0x2D
    
89. #define     TCounterValueRegH     0x2E
    7 z9 N" H! b+ p& J2 @
90. #define     TCounterValueRegL     0x2F
      |9 R# i1 \% W# }* \. h
91. // PAGE 3      
    0 z; [! f9 y- S! N; R7 |9 m
92. #define     RFU30                 0x30
    
93. #define     TestSel1Reg           0x31
    - x; O% Q1 @% k) U0 d+ a) t
94. #define     TestSel2Reg           0x32
    - C  p: w+ T3 R7 b3 j4 y
95. #define     TestPinEnReg          0x33
    
96. #define     TestPinValueReg       0x34
    ' r4 |4 u( K% U, ?& u
97. #define     TestBusReg            0x35
    
98. #define     AutoTestReg           0x36
    4 @2 I; I/ x8 V$ s
99. #define     VersionReg            0x37
    # |# b1 ]# x" S" d
100. #define     AnalogTestReg         0x38
     % S1 {+ O7 d: B* V
101. #define     TestDAC1Reg           0x39  
     
102. #define     TestDAC2Reg           0x3A   
     9 o' r% a2 ^- D* v8 ], Q2 m
103. #define     TestADCReg            0x3B   
     " B9 V$ I+ p1 l' \1 J
104. #define     RFU3C                 0x3C   
     
105. #define     RFU3D                 0x3D   
     " a3 x0 ^8 j1 x& p1 H0 P5 x
106. #define     RFU3E                 0x3E   
     , k% B6 q1 q0 X8 o: p6 ]2 t
107. #define     RFU3F                                    0x3F
     
108. 
     
109. /
     - x* x1 ~+ j0 I! G
110. //和MF522通讯时返回的错误代码
     
111. /
     / S0 e, w0 x1 B, u5 b! @
112. #define         MI_OK                 0
     
113. #define         MI_NOTAGERR           (1)
     % ?  K/ y" F, Q
114. #define         MI_ERR                (2)
     
115. 
     
116. #define        SHAQU1                0X01
     % n& ~- L! J9 c! \1 ]
117. #define        KUAI4                0X04
     ! m5 n' m; z  ]8 I' L$ f
118. #define        KUAI7                0X07
     
119. #define        REGCARD                0xa1
     , }8 w) J9 ~- V* I' R/ H
120. #define        CONSUME                0xa2
     
121. #define READCARD        0xa3
     
122. #define ADDMONEY        0xa4
     ! N: n6 M$ c+ _& p# W. }0 ~4 P. y
123. 
     6 @" ]: P4 v& U! V/ {
124. //==============================================================================================
     0 M- w& ^( q, e$ J8 a* F
125. void UART3_init(void)/*串口3MC20通信*/
     
126. {
       l) W8 h' l8 P( Y( ^5 U
127.         GPIO_InitTypeDef GPIO_InitStructure;
     
128.     USART_InitTypeDef USART_InitStructure;
     
129.    
     3 w* P" ~% _) Y5 i8 z2 y, U
130.     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB|RCC_APB2Periph_AFIO, ENABLE);
     ! M. \/ m2 x4 A4 _8 K
131.     RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3 , ENABLE);        
     
132.         USART_DeInit(USART3);  //复位串口3
     
133.    
     % U, b2 I8 k5 E5 X
134.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 ;
     & j1 I3 @; a" V0 m
135.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;        //复用推挽输出
     ) ~- y( d) B8 T1 e) j8 J, r* E
136.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
     2 ^' m7 e0 W6 G8 |* g; |
137.     GPIO_Init(GPIOB, &GPIO_InitStructure);
     
138. 
     * d' x# W4 ]) p
139.     GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11 ;
     
140.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
     
141.     GPIO_Init(GPIOB, &GPIO_InitStructure);
     
142. 
     : S1 Q( ?6 N: A% o( B
143.     USART_InitStructure.USART_BaudRate = 9600;
     
144.     USART_InitStructure.USART_WordLength = USART_WordLength_8b;
     
145.     USART_InitStructure.USART_StopBits = USART_StopBits_1;
     
146.     USART_InitStructure.USART_Parity = USART_Parity_No;
     9 @" c6 U3 `$ N1 Z
147.     USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
     
148.     USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
     
149.        
     & D7 T! {2 o5 B6 D; E: r# i2 o9 J
150.     USART_Init(USART3, &USART_InitStructure);
     4 T: h- i5 c# d/ q! Y7 ]
151.     USART_Cmd(USART3, ENABLE);
     
152. }
     
153. /***********************RC522 函数宏定义**********************/
     
154. u8 UART3_ReadWriteByte(u8 TxData)
     
155. {               
     
156.         while (USART_GetFlagStatus(USART3, USART_FLAG_TXE) == RESET||USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET) {}                          
     
157.         USART_SendData(USART3,TxData);
     
158.         delay_ms(5);
     
159.         return         USART_ReceiveData(USART3);                    
     * X% V8 T7 D  u  o5 b* M% B0 O( a
160. }
     
161. 
     ( d" n& i; J) a/ }1 b% T
162. //==============================================================================================
     7 n7 N) Y- u; e# F
163. 
     8 l% l3 {( T1 J$ C2 O8 w" o" I; x' L" x+ ?
164. void  M500PcdConfigISOType( u8 type );          //工作方式
     + e: l, ?2 x& P& c
165. void  PcdReset( void );                               //复位
     
166. char  PcdRequest( u8 req_code, u8 * pTagType ); //寻卡
     
167. char  PcdAnticoll( u8 * pSnr);                  //读卡号
     
168. 
     
169. char  PcdSelect( u8 * pSnr );
     $ p; a% J1 Y: }
170. char  PcdAuthState( u8 ucAuth_mode, u8 ucAddr, u8 * pKey, u8 * pSnr );
     
171. 
     
172. char  PcdWrite( u8 ucAddr, u8 * pData );
     7 n( ]5 {( n2 |
173. char  PcdRead( u8 ucAddr, u8 * pData );
     5 t% L9 N( `4 ^* n5 |6 c
174. 
     / Q7 Q3 j( `0 s3 @, t, w
175. void PcdAntennaOn ( void );
     : V3 [" p7 J6 n, n! G8 ]
176. void PcdAntennaOff ( void );
     0 M+ b8 F& n6 e6 p& U, P2 k
177. 
     % B4 z9 A) @: F& ~; I* Y
178. void RC522_Init(void)
     1 f2 {. P8 E! E: A& i
179. {
     
180.         UART3_init();//初始化spi3
     
181.         delay_ms(1000);
     
182.     PcdReset();
     
183.     M500PcdConfigISOType ( 'A' );//设置工作方式
       g! _; P( C" |
184. }
     ( ~5 o' L: u0 k5 H0 r5 l
185. 
     9 A. [7 S! Q) F5 m1 f
186. //
     ; v% _6 w3 S2 a; `! M2 o* X( M) q
187. // M1卡分为16个扇区，每个扇区由四个块（块0、块1、块2、块3）组成
     2 j7 V1 b9 [2 U$ Z
188. // 将16个扇区的64个块按绝对地址编号为：0~63
     ( b4 Z$ r3 l% ~; f, F
189. // 第0个扇区的块0（即绝对地址0块），用于存放厂商代码，已经固化不可更改
     # L" {3 C+ }! h, ~8 p" s
190. // 每个扇区的块0、块1、块2为数据块，可用于存放数据
     8 w, }* y0 N; T5 m
191. // 每个扇区的块3为控制块（绝对地址为:块3、块7、块11.....）包括密码A，存取控制、密码B等
     
192. 
     
193. /*全局变量*/
     
194. unsigned char CT[2];//卡类型
     
195. unsigned char SN[4]; //卡号
     & R+ t9 ]( A% e
196. unsigned char RFID[16];                        //存放RFID
     
197. unsigned char total=0;
     
198. u8 KEY[6]={0xff,0xff,0xff,0xff,0xff,0xff};
     6 _2 g& d. p0 \. L0 ]1 q# b
199. u8 AUDIO_OPEN[6] = {0xAA, 0x07, 0x02, 0x00, 0x09, 0xBC};
     8 c+ S! \  X( l7 C
200. unsigned char RFID1[16]={0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x07,0x80,0x29,0xff,0xff,0xff,0xff,0xff,0xff};
     
201. /*函数声明*/
     6 W0 Z( `8 @2 t  N# I+ D3 i
202. unsigned char status;
     # f# i! o6 |( r, S2 N- t' W, e
203. unsigned char s=0x08;
     5 E! m/ |  f5 q( E( l
204. 
     & E) Y6 f" T, n. T
205. /**************************************************************************************
     2 S! m4 q2 V6 r
206. * 函数名：WriteRawRC 描述  ：写RC522寄存器输入 ：ucAddress，寄存器地址 ucValue，写入寄存器的值
     
207. */
     " D6 G7 r7 Q% Z) o! T' t- L1 y( Q
208. void WriteRawRC ( u8 ucAddress, u8 ucValue )
     
209. {  
     1 O' s6 L( [( S8 {
210.         u8 ch = UART3_ReadWriteByte (ucAddress& 0x3F);  // 写入寄存器地址(最低6位为实际地址，次高为保留为0，最高位为1)
     
211.         if(ch != ucAddress) printf("not equal!!\r\n");
     
212.         UART3_ReadWriteByte (ucValue);
     
213. }
     
214. /**************************************************************************************
     2 A. w/ X1 y7 |1 D  i9 y: ]
215. * 函数名：ReadRawRC 读取寄存器的当前值
     
216. */
     & n# t; @9 N1 r3 E
217. u8 ReadRawRC ( u8 ucAddress )
     
218. {
     
219.         return UART3_ReadWriteByte((ucAddress&0x3F) | 0x80);
     
220. }
     
221. /**************************************************************************************
     8 p, h- L4 Y. B! x2 k4 o
222. * 函数名：ClearBitMask 对RC522寄存器清位
     
223. */
     / e0 U& [; N' g/ A9 Q
224. void ClearBitMask ( u8 ucReg, u8 ucMask )  
     $ s. S7 r  a5 Y4 }* Z
225. {
     2 ^9 @9 j' z2 s8 o6 W, J
226.     u8 ucTemp;
     
227.     ucTemp = ReadRawRC ( ucReg );
     
228.     WriteRawRC ( ucReg, ucTemp & ( ~ ucMask) );  // clear bit mask
     
229. }
     8 u, D+ m+ m) J/ c5 ^* s
230. /**************************************************************************************
     
231. * 函数名：SetBitMask 对RC522寄存器置位
     5 v" c9 d9 q- @, W  c1 `$ l& M6 m4 G
232. */
     2 d+ {1 `. V: g  q" G( _
233. void SetBitMask ( u8 ucReg, u8 ucMask )  
     
234. {
     
235.     u8 ucTemp;
     9 O; }0 d' G. K" y
236.     ucTemp = ReadRawRC ( ucReg );
     
237.     WriteRawRC ( ucReg, ucTemp | ucMask );         // set bit mask
     7 c$ `6 E, Y. W1 o! B; W# d; X
238. }
     
239. /**************************************************************************************
     
240. * 函数名：PcdAntennaOn 开启天线
     
241. */
     5 w  P  c2 D% R( |5 H* z
242. void PcdAntennaOn ( void )
     , {8 K1 I7 s& u& p7 V
243. {
     4 D, y7 U0 S6 b0 K
244.     u8 uc;
     5 i5 Y* x1 f+ L! `" g! X' F
245.     uc = ReadRawRC ( TxControlReg );
     , D! x- i$ h$ A9 B5 ~" M6 E
246.     if ( ! ( uc & 0x03 ) )
     
247.                         SetBitMask(TxControlReg, 0x03);
     
248. }
     
249. /**************************************************************************************
     
250. * 函数名：PcdAntennaOff 关闭天线
     
251. */
       x" Z" k/ r4 W" s7 K0 `+ m
252. void PcdAntennaOff ( void )
     
253. {
     , i' O7 a2 [7 G5 J0 _3 p
254.     ClearBitMask ( TxControlReg, 0x03 );
     , i$ v% Y$ d* T# u
255. }
     # w. N, {3 V3 b0 X# r$ A
256. /**************************************************************************************
     8 }# L6 i- [2 d& K: C. U( e, ]
257. * 描述  ：设置RC522的工作方式 ucType，工作方式
     3 y, M( o* f% K2 Q( }; F( m+ k
258. */
     # _1 {; J" g* [9 ]# M) Y. v5 r
259. void M500PcdConfigISOType ( u8 ucType )
     
260. {
     
261.         if ( ucType == 'A')                     //ISO14443_A
     6 d4 s& f( `' ?
262.   {
     - v0 e6 L2 g# V, K" }0 G
263.                 ClearBitMask ( Status2Reg, 0x08 );
     
264.         WriteRawRC ( ModeReg, 0x3D );//3F
     
265.                 WriteRawRC ( RxSelReg, 0x86 );//84
     
266.                 WriteRawRC( RFCfgReg, 0x7F );   //4F
     * m' v8 g; l4 H3 o
267.                 WriteRawRC( TReloadRegL, 30 );//tmoLength);// TReloadVal = 'h6a =tmoLength(dec)
     
268.                 WriteRawRC ( TReloadRegH, 0 );
     4 k5 z8 d9 g0 P& m1 d
269.                 WriteRawRC ( TModeReg, 0x8D );
     
270.                 WriteRawRC ( TPrescalerReg, 0x3E );
     
271.                 delay_us ( 2 );
     
272.                 PcdAntennaOn ();//开天线
     # a% x' `* ~/ [4 z/ \, r- K  u
273.    }
     
274. }
     
275. /**************************************************************************************
     
276. * 函数名：PcdComMF522
     
277. * 描述  ：通过RC522和ISO14443卡通讯
     
278. * 输入  ：ucCommand，RC522命令字
     ' {0 v! o9 w$ E; U
279. *         pInData，通过RC522发送到卡片的数据
     
280. *         ucInLenByte，发送数据的字节长度
     
281. *         pOutData，接收到的卡片返回数据
     * Z$ `1 V) C& x/ B7 n8 Y. c5 Z( Z
282. *         pOutLenBit，返回数据的位长度
     $ c! m0 ^$ T4 u' W$ h% R
283. * 返回  : 状态值 MI_OK，成功
     
284. */
     % M% ]9 e- v  r- G- c/ ]- t4 {. H9 |
285. char PcdComMF522 ( u8 ucCommand, u8 * pInData, u8 ucInLenByte, u8 * pOutData, u32 * pOutLenBit )               
     4 _  v: |0 s3 |2 s
286. {
     
287.     char cStatus = MI_ERR;
     & V" X! P, ]) s. r
288.     u8 ucIrqEn   = 0x00;
     5 K7 D% E2 I9 @' A- {
289.     u8 ucWaitFor = 0x00;
     # V6 l6 }6 l: _5 {) N
290.     u8 ucLastBits;
     
291.     u8 ucN;
     
292.     u32 ul;
     
293.     switch ( ucCommand )
     
294.     {
     
295.        case PCD_AUTHENT:                //Mifare认证
     
296.           ucIrqEn   = 0x12;                //允许错误中断请求ErrIEn  允许空闲中断IdleIEn
     
297.           ucWaitFor = 0x10;                //认证寻卡等待时候 查询空闲中断标志位
     
298.           break;
     , E0 F. A1 @. ^# }0 S
299.                          
     5 ]" R9 m9 _1 A5 B+ Q
300.        case PCD_TRANSCEIVE:                //接收发送 发送接收
     
301.           ucIrqEn   = 0x77;                //允许TxIEn RxIEn IdleIEn LoAlertIEn ErrIEn TimerIEn
     # U1 J' v! m) p& W, x& y
302.           ucWaitFor = 0x30;                //寻卡等待时候 查询接收中断标志位与 空闲中断标志位
     
303.           break;
     7 v2 b7 p% a2 n. B8 R+ h$ {
304.                          
     
305.        default:
     
306.          break;
     
307.     }
     + y3 l* B0 N  N- f
308.     WriteRawRC ( ComIEnReg, ucIrqEn | 0x80 );                //IRqInv置位管脚IRQ与Status1Reg的IRq位的值相反
     3 }$ X0 y& o3 @4 F3 h, M. G' u6 j" C
309.     ClearBitMask ( ComIrqReg, 0x80 );                                //Set1该位清零时，CommIRqReg的屏蔽位清零
     $ V3 j0 C  R8 [) L
310.     WriteRawRC ( CommandReg, PCD_IDLE );                        //写空闲命令
     , `! D* i% L! m  a( q5 D
311.     SetBitMask ( FIFOLevelReg, 0x80 );                                //置位FlushBuffer清除内部FIFO的读和写指针以及ErrReg的BufferOvfl标志位被清除
     
312.    
     
313.     for ( ul = 0; ul < ucInLenByte; ul ++ )
     * P+ F& A& a$ Z9 N/ A* H! L3 P1 u: J2 U
314.                   WriteRawRC ( FIFODataReg, pInData [ ul ] );            //写数据进FIFOdata
     + }6 V0 Y9 T9 A2 p
315.                        
     
316.     WriteRawRC ( CommandReg, ucCommand );                                        //写命令
     - Z- a6 L1 i3 H1 O0 C
317.    
     
318.     if ( ucCommand == PCD_TRANSCEIVE )
     
319.                         SetBitMask(BitFramingReg,0x80);                                  //StartSend置位启动数据发送 该位与收发命令使用时才有效
     , g" O- f% I. U" @
320.    
     
321.     ul = 1000;//根据时钟频率调整，操作M1卡最大等待时间25ms
     , b; L5 D$ l/ b9 ]
322.                
     
323.     do                                                                                                                 //认证 与寻卡等待时间       
     
324.     {
       A8 p2 g/ Z& r
325.          ucN = ReadRawRC ( ComIrqReg );                                                //查询事件中断
       ]' K& E1 \: ^
326.          ul --;
     
327.     }
     
328.         while ( ( ul != 0 ) && ( ! ( ucN & 0x01 ) ) && ( ! ( ucN & ucWaitFor ) ) );                //退出条件i=0,定时器中断，与写空闲命令
     # o, ^/ _7 T4 [8 `" C4 y# n
329.                
     . \. j3 |$ ~6 O& p: \; B! G: k  N/ \
330.     ClearBitMask ( BitFramingReg, 0x80 );                                        //清理允许StartSend位
     
331.                
     * a! `( c! f8 S
332.     if ( ul != 0 )
     
333.     {
     
334.                 if ( ! (( ReadRawRC ( ErrorReg ) & 0x1B )) )                        //读错误标志寄存器BufferOfI CollErr ParityErr ProtocolErr
     
335.                 {
     0 u+ }( O8 T% ]" E
336.                         cStatus = MI_OK;
     ) o5 i2 C! Z' x% x
337.                         if ( ucN & ucIrqEn & 0x01 )                                        //是否发生定时器中断
     # N. R9 p8 G" k
338.                           cStatus = MI_NOTAGERR;   
     
339.                         if ( ucCommand == PCD_TRANSCEIVE )
     0 Y8 z) x5 o$ J
340.                         {
     
341.                                 ucN = ReadRawRC ( FIFOLevelReg );                        //读FIFO中保存的字节数
     4 Y9 l! G: V; x% M
342.                                 ucLastBits = ReadRawRC ( ControlReg ) & 0x07;        //最后接收到得字节的有效位数
     
343.                                 if ( ucLastBits )
     
344.                                         * pOutLenBit = ( ucN - 1 ) * 8 + ucLastBits;           //N个字节数减去1（最后一个字节）+最后一位的位数 读取到的数据总位数
     
345.                                 else
     1 X7 f8 H* R7 p- [6 ^' s$ o. ~
346.                                         * pOutLenBit = ucN * 8;                                           //最后接收到的字节整个字节有效
     
347.                                 if ( ucN == 0 )       
     # u4 ^+ H% D7 m2 t# v; {6 H4 w* Q
348.                     ucN = 1;   
     
349.                                 if ( ucN > MAXRLEN )
     % n4 f( H1 U9 a  y# o
350.                                         ucN = MAXRLEN;   
     
351.                                 for ( ul = 0; ul < ucN; ul ++ )
       [$ d) A/ E$ i6 |- a' |* e& x
352.                                   pOutData [ ul ] = ReadRawRC ( FIFODataReg );   
     ' A5 ^9 u! z* A5 I2 y, D; R/ W
353.                         }               
     
354.         }
     
355.                         else
     9 K' }4 s" U( e+ J
356.                                 cStatus = MI_ERR;   
     ( r3 V. h2 o; q: Y! d; T9 d
357.                         //printf("ErrorReg=%d\r\n",ErrorReg);
     
358.     }
     2 ^4 J5 z7 |* M7 {
359.    SetBitMask ( ControlReg, 0x80 );           // stop timer now
     
360.    WriteRawRC ( CommandReg, PCD_IDLE );
     
361.    return cStatus;
     - \4 E; M, j0 ?' g# D
362. }
     5 a' `3 k$ l9 g7 u
363. //=========================================RC522_Handel================================================//
     ( q. k( a0 ?0 V& C
364. bool RC522_READ(u8 * str)
     
365. {
     
366.     status = PcdRequest(PICC_REQALL,CT);//寻卡
     2 l9 V: m: Y7 g7 ?, o
367.     if(status==MI_OK)//寻卡成功
     
368.     {
     
369.          status=MI_ERR;
     
370.          status = PcdAnticoll(SN);//防冲撞               
     
371.     }
     
372.     if (status==MI_OK)//防衝撞成功
     
373.     {
     7 K1 t; Z7 b  G( c0 N
374.         status=MI_ERR;               
     
375.         status =PcdSelect(SN);
     
376.     }
     : G2 S  ]$ a8 M8 j
377.     if(status==MI_OK)//選卡成功
     
378.     {
     
379.         status=MI_ERR;
     . J. m* a( P" a% J/ W
380.         status =PcdAuthState(0x60,0x09,KEY,SN);
     
381.      }
     
382.         if(status==MI_OK)//驗證成功
     9 _8 Z5 E7 h0 v& n6 t6 H
383.     {
     
384.         status=MI_ERR;
     
385.         status=PcdRead(s,RFID);
     
386.     }
     
387.     if(status==MI_OK)//讀卡成功
     
388.     {
     
389.         status=MI_ERR;
     ) l" z9 X1 l9 h5 A0 o
390.                 memset(str,0,10);
     
391.                 memcpy(str,RFID,9); //显示卡的ID号
     + d/ _/ H+ N, @
392.                 return 1;
     
393.    }
     
394.    
     . b: A' i5 G1 U; y- M( T
395.   return 0;
     - s# t5 ~# j9 m% p$ y( W
396. }
     $ B% d, ^9 ^, d2 O
397. //=========================================RC522_Handel================================================//
     
398. bool RC522_WRITE(u8 * msg)
     
399. {
     
400.         if(msg == NULL)return false;
     4 R4 j8 @( o; w0 G! ?
401.     status = PcdRequest(PICC_REQALL,CT);//寻卡
       p. {  b+ M: B  I) q$ _' p9 I
402.     if(status==MI_OK)//寻卡成功
     
403.     {
     " x$ P, i4 k3 P
404.          status=MI_ERR;
     7 @5 d4 G. I& e) j8 g2 r. z2 ?
405.          status = PcdAnticoll(SN);//防冲撞               
     
406.     }
       F' L) H: M& y( A
407.     if (status==MI_OK)//防衝撞成功
     , F/ l1 }: R7 y( j3 R* \: l, b  X
408.     {
     3 @2 q+ s% K; e  s' T& z
409.         status=MI_ERR;               
     
410.         status =PcdSelect(SN);
     
411.     }
     
412.     if(status==MI_OK)//選卡成功
     2 d5 C, u( O% q9 W: V0 K7 y; s1 f& A
413.     {
     
414.         status=MI_ERR;
     ; y) H# D1 @9 T) R; m6 v* ?
415.         status =PcdAuthState(0x60,0x09,KEY,SN);
     
416.      }
     
417.    if(status==MI_OK)//驗證成功
     
418.     {
     
419.         status=MI_ERR;
     
420.                 status=PcdWrite(s,msg);
     , h! G. S. B: U8 f2 B2 R( }
421.     }
     # d! d. l& F0 _# ^. K# O0 A2 ~
422.     if(status==MI_OK)//写卡成功
     
423.                 return true;
     
424.         return false;
     
425. }
     
426. /*********************************************************************************************************************
     
427. * 函数名：PcdRequest 寻卡
     ' k) p$ h: ]1 A
428. * 输入  ：ucReq_code，寻卡方式
     
429. *                   = 0x52，寻感应区内所有符合14443A标准的卡
     
430. *                   = 0x26，寻未进入休眠状态的卡
     " M. ^5 O8 ?. ]
431. *         pTagType，卡片类型代码
     
432. *                   = 0x4400，Mifare_UltraLight
     
433. *                   = 0x0400，Mifare_One(S50)
     
434. *                   = 0x0200，Mifare_One(S70)
     
435. *                   = 0x0800，Mifare_Pro(X))
     ! m9 f3 F$ ^" N# ]+ w
436. *                   = 0x4403，Mifare_DESFire
     
437. * 返回  : 状态值  MI_OK，成功
     2 x# [4 Z1 @* I$ w& r* }; f
438. */
     
439. char PcdRequest ( u8 ucReq_code, u8 * pTagType )
     
440. {
     
441.     char cStatus;  
     2 T" @+ n$ a. [& E
442.     u8 ucComMF522Buf [ MAXRLEN ];
     
443.     u32 ulLen;
     
444. 
     
445.     ClearBitMask ( Status2Reg, 0x08 );        //清理指示MIFARECyptol单元接通以及所有卡的数据通信被加密的情况
     : d2 ~. Y, w: j# T
446.     WriteRawRC ( BitFramingReg, 0x07 );        //        发送的最后一个字节的 七位
     
447.     SetBitMask ( TxControlReg, 0x03 );        //TX1,TX2管脚的输出信号传递经发送调制的13.56的能量载波信号
     
448.     ucComMF522Buf [ 0 ] = ucReq_code;                //存入 卡片命令字
     
449.     cStatus = PcdComMF522( PCD_TRANSCEIVE,ucComMF522Buf, 1, ucComMF522Buf, & ulLen );        //寻卡  
     " ?2 }9 O0 S: t" |4 M
450.     if ( ( cStatus == MI_OK ) && ( ulLen == 0x10 ) )        //寻卡成功返回卡类型
     6 C# V' h/ |2 V0 M. u( J
451.     {   
     
452.        * pTagType = ucComMF522Buf [ 0 ];
     & v$ {* v9 V% n8 Z5 h* H8 u( D7 `, J
453.        * ( pTagType + 1 ) = ucComMF522Buf [ 1 ];
     
454.     }
     & E) _" ]3 q# l9 R' O2 T  E
455.     else
     
456.      cStatus = MI_ERR;
     + G+ v* {5 r" \2 X$ f* }
457.     return cStatus;
     . Y: @' R! r  U0 R) b0 D) b
458. }
     
459. 
     8 [1 V1 Q; c( n
460. /************************************************************************************************************
     - u0 M2 t; Y/ h4 Q4 i- T
461. * 函数名：PcdAnticoll 防冲撞：pSnr，卡片序列号，4字节
     
462. * 返回  : 状态值 MI_OK，成功
     4 g6 w$ q  A, S) U$ @
463. */
     
464. char PcdAnticoll ( u8 * pSnr )
     
465. {
     
466.     char cStatus;
     * ~5 J1 @9 E1 T
467.     u8 uc, ucSnr_check = 0;
     6 A- S) x5 u, {6 E
468.     u8 ucComMF522Buf [ MAXRLEN ];
     9 Y; r0 a( ]6 S+ ^9 X) H
469.         u32 ulLen;
     / o8 h6 e! _; @) l
470.     ClearBitMask ( Status2Reg, 0x08 );                //清MFCryptol On位 只有成功执行MFAuthent命令后，该位才能置位
     
471.     WriteRawRC ( BitFramingReg, 0x00);                //清理寄存器 停止收发
     4 L9 N" o( l  Y& u
472.     ClearBitMask ( CollReg, 0x80 );                        //清ValuesAfterColl所有接收的位在冲突后被清除
     
473.     ucComMF522Buf [ 0 ] = 0x93;        //卡片防冲突命令
     ( e+ Z+ ?) t/ Q4 ]* ^; T: U' S- K: P. B5 ]
474.     ucComMF522Buf [ 1 ] = 0x20;
     
475.     cStatus = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 2, ucComMF522Buf, & ulLen);//与卡片通信
     
476.     if ( cStatus == MI_OK)                //通信成功
     
477.     {
     
478.                 for ( uc = 0; uc < 4; uc ++ )
     3 a6 X& v' ]0 J0 h$ J0 c% x
479.         {
     ) |0 T# q/ T3 t1 F1 B; |% j
480.             * ( pSnr + uc )  = ucComMF522Buf [ uc ];                        //读出UID
     
481.             ucSnr_check ^= ucComMF522Buf [ uc ];
     
482.         }       
     & f( F- F5 q7 ^% O! u" D1 x6 b" G6 ]
483.         if ( ucSnr_check != ucComMF522Buf [ uc ] )
     2 K4 m" y/ o/ V* c: O( v& h
484.                         cStatus = MI_ERR;                     
     
485.     }
     ' T. U9 |9 Z% V% H% P, M- r0 |
486.     SetBitMask ( CollReg, 0x80 );
     5 _: J" t/ \; v4 H& _3 Q' G% `1 F/ n
487.     return cStatus;
     
488. }
     
489. /************************************************************************************************************
     
490. * 函数名：CalulateCRC
     
491. * 描述  ：用RC522计算CRC16
     6 t; g; u! l6 v+ \6 W
492. * 输入  ：pIndata，计算CRC16的数组
     ' B; Y% X' j. Q8 C0 }
493. *         ucLen，计算CRC16的数组字节长度
     
494. *         pOutData，存放计算结果存放的首地址
     
495. */
     
496. void CalulateCRC ( u8 * pIndata, u8 ucLen, u8 * pOutData )
     ! M) d# }  q5 {& x
497. {
     , ~! b" h+ b5 K, a! J6 m7 b
498.     u8 uc, ucN;
     * j5 u) o$ A- b3 ]
499.     ClearBitMask(DivIrqReg,0x04);
     ! S' J/ L  |3 H
500.     WriteRawRC(CommandReg,PCD_IDLE);
     5 L3 O$ ?3 c/ ~* r' y
501.     SetBitMask(FIFOLevelReg,0x80);
     , G% F2 a! D- ^# N1 W+ J  Z! S# Q
502.     for ( uc = 0; uc < ucLen; uc ++)
     
503.             WriteRawRC ( FIFODataReg, * ( pIndata + uc ) );   
     
504.     WriteRawRC ( CommandReg, PCD_CALCCRC );
     $ a" t* m. Q+ G1 s( `9 C
505.     uc = 0xFF;
     
506.     do
     
507.     {
     / k' V! G: s! Z3 f7 b
508.         ucN = ReadRawRC ( DivIrqReg );
     & I/ ~. }( o& x) j' a; ^# F
509.         uc --;
     
510.     } while ( ( uc != 0 ) && ! ( ucN & 0x04 ) );
     
511.                
     + O' i* M2 w  t6 |7 t
512.     pOutData [ 0 ] = ReadRawRC ( CRCResultRegL );
     9 B6 @% z' W& K
513.     pOutData [ 1 ] = ReadRawRC ( CRCResultRegM );
     
514. }
     
515. 
     
516. /************************************************************************************************************
     # m  o4 `; J& \7 U8 P) k
517. * 函数名：PcdSelect
     ! `$ d+ h2 [* z1 t) \
518. * 描述  ：选定卡片
     4 R( ?8 V8 s: i4 X
519. * 输入  ：pSnr，卡片序列号，4字节
     
520. * 返回  : 状态值
     
521. *         = MI_OK，成功
     / {7 N, c% s) m# g- ^; u
522. * 调用  ：外部调用
     ( a1 m+ X) @' L) I/ }
523. */
     
524. char PcdSelect ( u8 * pSnr )
     3 [* q5 M9 K4 ~
525. {
     + v3 C- q% D, N- H7 N
526.     char         ucN;
     
527.     u8                 uc;
     
528.         u8                 ucComMF522Buf [ MAXRLEN ];
     
529.     u32          ulLen;
     
530.     ucComMF522Buf [ 0 ] = PICC_ANTICOLL1;
     # c5 ?: u- R; l+ b2 p4 k
531.     ucComMF522Buf [ 1 ] = 0x70;
     
532.     ucComMF522Buf [ 6 ] = 0;
     & ~- k0 n' [% L) A5 P
533.     for ( uc = 0; uc < 4; uc ++ )
     
534.     {
     
535.             ucComMF522Buf [ uc + 2 ] = * ( pSnr + uc );
     : H1 I9 I- D" Y! z
536.             ucComMF522Buf [ 6 ] ^= * ( pSnr + uc );
     
537.     }       
     7 w$ g5 G% y( O
538.     CalulateCRC ( ucComMF522Buf, 7, & ucComMF522Buf [ 7 ] );
     
539.     ClearBitMask ( Status2Reg, 0x08 );
     8 d+ K, v- |' u4 j/ b- e
540.     ucN = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 9, ucComMF522Buf, & ulLen );
     
541.     if ( ( ucN == MI_OK ) && ( ulLen == 0x18 ) )
     
542.       ucN = MI_OK;  
     : G. F+ i$ F2 U! l5 K% n
543.     else
     
544.       ucN = MI_ERR;   
     5 P+ I- u2 ~" n8 {/ W$ h( U# F4 P" N
545.     return ucN;
     
546. }
     
547. /************************************************************************************************************
     3 Y9 }& n( x% j# ~+ ]  \
548. * 函数名：PcdAuthState 验证卡片密码
     
549. * 输入  ：ucAuth_mode，密码验证模式
     3 P% o9 F- n+ T, D+ u$ b; H: p
550. *                     = 0x60，验证A密钥
     5 H* h1 q1 `& V, v$ s, P
551. *                     = 0x61，验证B密钥
     
552. *         u8 ucAddr，块地址
     
553. *         pKey，密码
     
554. *         pSnr，卡片序列号，4字节
     - o* T0 l" c1 K7 ?$ E
555. * 返回  : 状态值MI_OK，成功
     
556. */
     
557. char PcdAuthState ( u8 ucAuth_mode, u8 ucAddr, u8 * pKey, u8 * pSnr )
     
558. {
     
559.     char cStatus;
     
560.         u8 uc, ucComMF522Buf [ MAXRLEN ];
     2 D# \/ F2 }( q! o8 L
561.     u32 ulLen;
     
562.     ucComMF522Buf [ 0 ] = ucAuth_mode;
     
563.     ucComMF522Buf [ 1 ] = ucAddr;
     
564.     for ( uc = 0; uc < 6; uc ++ )
     
565.             ucComMF522Buf [ uc + 2 ] = * ( pKey + uc );   
     
566.     for ( uc = 0; uc < 6; uc ++ )
     
567.             ucComMF522Buf [ uc + 8 ] = * ( pSnr + uc );   
     1 P, i+ y. r, e, ?( A5 O8 W
568.     cStatus = PcdComMF522 ( PCD_AUTHENT, ucComMF522Buf, 12, ucComMF522Buf, & ulLen );
     
569.     if ( ( cStatus != MI_OK ) || ( ! ( ReadRawRC ( Status2Reg ) & 0x08 ) ) )
     " I9 s4 s! N  R! I
570.                 {
     ) }' b# ]7 i! e* y, ]( l- H5 d
571.                         if(cStatus != MI_OK)
     6 R, @0 B4 I5 q7 d, d6 I- p
572.                                 printf("666");               
     1 m: ^) a5 N* Q
573.                         else
     
574.                                 printf("888");
     
575.                         cStatus = MI_ERR;
     
576.                 }
     7 Z3 t' H: y; Z1 d  f9 r& r
577.     return cStatus;
     9 v3 J( R- n1 H6 I. P6 l( b9 E
578. }
     
579. 
     
580. /**********************************************************************************************
     
581. * 函数名：PcdWrite B写数据到M1卡一块 NpData，写入的数据，16字节
     % @; L% T# I; P# Y' e! H1 I4 D2 N
582. * 返回  : 状态值MI_OK，成功
     # n1 B& k2 R) ]; t
583. */
     7 Y3 L; G6 a6 l
584. char PcdWrite ( u8 ucAddr, u8 * pData )
     
585. {
     
586.     char cStatus;
     
587.         u8 uc, ucComMF522Buf [ MAXRLEN ];
     ' y5 b+ t3 \5 }! ~2 l
588.     u32 ulLen;
     " Y% M5 }3 _# E
589.        
     ( t- w4 X4 U; g/ B0 y- }' ?
590.     ucComMF522Buf [ 0 ] = PICC_WRITE;
     
591.     ucComMF522Buf [ 1 ] = ucAddr;
     2 i& W' M  `! x9 a; y
592.     CalulateCRC ( ucComMF522Buf, 2, & ucComMF522Buf [ 2 ] );
     
593.     cStatus = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, & ulLen );
     
594.     if ( ( cStatus != MI_OK ) || ( ulLen != 4 ) || ( ( ucComMF522Buf [ 0 ] & 0x0F ) != 0x0A ) )
     
595.       cStatus = MI_ERR;   
     
596.     if ( cStatus == MI_OK )
       Y/ y- f& M( \# O
597.     {
     , `+ f$ O+ R! r. u4 T# d' \
598.                 memcpy(ucComMF522Buf, pData, 16);
     
599.                 for ( uc = 0; uc < 16; uc ++ )
     
600.                           ucComMF522Buf [ uc ] = * ( pData + uc );  
     ( D. e0 U' }+ ~) y
601.                 CalulateCRC ( ucComMF522Buf, 16, & ucComMF522Buf [ 16 ] );
     ( b/ K# i" q- u  f3 m: \, Y3 f! F! Q! ]
602.                 cStatus = PcdComMF522 ( PCD_TRANSCEIVE, ucComMF522Buf, 18, ucComMF522Buf, & ulLen );
     
603.                 if ( ( cStatus != MI_OK ) || ( ulLen != 4 ) || ( ( ucComMF522Buf [ 0 ] & 0x0F ) != 0x0A ) )
     
604.                         cStatus = MI_ERR;   
     . v: x( x5 t) a6 M
605.     }
     6 g9 f4 O# H4 e
606.     return cStatus;
     
607. }
     " g7 F, F% `+ i# f+ O) K9 H0 G
608. /**********************************************************************************************
     
609. * 函数名：PcdRead读取M1卡一块数据  pData，读出的数据，16字节
     8 @  i5 I+ g6 ]& p
610. * 返回  : 状态值 MI_OK，成功
     8 w% G( {0 [: s' W1 q
611. */
     ' Q6 `0 t8 Z# t/ W2 {" q$ w$ i' x  i
612. char PcdRead ( u8 ucAddr, u8 * pData )
     8 |0 ]2 F' ]$ t/ I2 l
613. {
     
614.     char cStatus;
     $ \) I! X5 I4 K6 V9 |( i
615.         u8 uc, ucComMF522Buf [ MAXRLEN ];
     7 o5 n$ X5 d0 o# S
616.     u32 ulLen;
     
617. 
     
618.     ucComMF522Buf [ 0 ] = PICC_READ;
     
619.     ucComMF522Buf [ 1 ] = ucAddr;
     
620.     CalulateCRC ( ucComMF522Buf, 2, & ucComMF522Buf [ 2 ] );
     $ k. X' E- K' t/ c
621.     cStatus = PcdComMF522 (PCD_TRANSCEIVE, ucComMF522Buf, 4, ucComMF522Buf, & ulLen);
     
622.     if ( ( cStatus == MI_OK ) && ( ulLen == 0x90 ) )
     + n2 y) K6 a; X' t6 s, N& h
623.     {
     
624.                 for ( uc = 0; uc < 16; uc ++ )
     + t; \* A5 c9 a/ u) \: O9 o# e) W
625.         * ( pData + uc ) = ucComMF522Buf [ uc ];   
     3 L$ k% E5 c$ g2 d6 Y9 |$ t. _
626.     }
     ( h: e1 T, e6 }+ X
627.     else
     6 [0 Z' D4 t& \) a4 ]
628.       cStatus = MI_ERR;   
     1 ?/ F$ l9 D# \! n. n
629.     return cStatus;
     
630. }
     
631. /**********************************************************************************************
     
632. */
     
633. 
     ; p9 N; J# a- A1 S+ n5 o: C1 N
634. /*
     
635. * 函数名：PcdRese
     # y& i( M# S  K- x3 K: I
636. * 描述  ：复位RC522
     
637. */
     ) B% \% D: Q/ [8 e
638. void PcdReset ( void )
     
639. {
     3 M! P3 M0 c; o
640.     delay_us ( 4 );
     
641.     WriteRawRC ( CommandReg, 0x0f );
     
642.     while( ReadRawRC ( CommandReg ) & 0x10 );
     6 O7 P1 K2 |& Q6 R
643.         ReadRawRC ( CommandReg );
     
644.     delay_us ( 5 );
     & e. ^( _! f- w7 _4 s/ d
645.     WriteRawRC ( ModeReg, 0x3D );                    //定义发送和接收常用模式 和Mifare卡通讯，CRC初始值0x6363
     ' @3 n, J' f1 U- t" C
646.     WriteRawRC ( TReloadRegL, 30 );                  //16位定时器低位   
     
647.     WriteRawRC ( TReloadRegH, 0 );                            //16位定时器高位
     
648.     WriteRawRC ( TModeReg, 0x8D );                                //定义内部定时器的设置
     : j" f4 \6 L4 F2 |. [# M
649.     WriteRawRC ( TPrescalerReg, 0x3E );                        //设置定时器分频系数
     
650.     WriteRawRC ( TxAutoReg, 0x40 );                                //调制发送信号为100%ASK       
     
651. }
       o. `# Q, h3 A1 F4 |: T/ ]* Z
652. /* 该测试用例测试中 */
     
653. void test(void){
     
654.         while(1){
     
655.                 printf("================================\r\n");
     % v# g$ b% `. L
656.                 delay_ms(1000);
     
657.                 u32 i = 0;
     
658.                 while(i<0x40){
     8 k& z& c3 ^; Q: y& P! u
659.                         u8 ch =  ReadRawRC(i);
     - P4 c; H, Y% R6 c% [# ?3 s
660.                         printf("%02x ",ch);
     
661.                         i++;
     0 W5 R/ f# G) ^6 v5 M9 x% k
662.                         delay_ms(10);
     ; W. a7 y- u" w; r( C
663.                         if(i%16 == 0)
     ) x( C6 x0 w$ U$ W. ~, q. U
664.                                 printf("\r\n");
     
665.                 }
     
666.                
     5 ^. Y0 p) `/ F6 G. e( q' W
667.                 static u32 t = 0;
       c, r- ], j" f  D" O1 K( X; @
668.                 if(t++ == 5){
     . R! ]9 ?  ^: J, }( N: F' K
669.                         WriteRawRC(WaterLevelReg,0x01);
     
670.                         u8 ch = ReadRawRC(WaterLevelReg);
     
671.                         printf("%02x\r\n",ch);
     + u( M1 p+ \: X1 G) E! u
672.                 }else if(t == 8){
     & Q% Q4 g! m9 J6 g1 s
673.                         WriteRawRC(WaterLevelReg,0x02);
     - B4 [( y7 @, o3 g
674.                         u8 ch = ReadRawRC(WaterLevelReg);
     
675.                         printf("%02x\r\n",ch);
     / v/ ]  y/ z; N5 A! u7 ]
676.                 }else if(t == 12){
     0 }6 k2 J7 y& O% |2 w9 I
677.                         WriteRawRC(WaterLevelReg,0x03);
     
678.                         u8 ch = ReadRawRC(WaterLevelReg);
     . x, S% i7 ]' \5 W; e5 T& x5 U8 i
679.                         printf("%02x\r\n",ch);
     
680.                 }
     ! j  j* L* m, q) |: S
681.         }
     ) x( [' R8 n0 ~4 c! l+ M% T6 m
682. }</font>

复制代码

下发是头文件rc522.h

1. <font face="微软雅黑" size="3">#ifndef _RC522_H_
   1 n, o8 A( K' I( e9 c9 B
2. #define _RC522_H_
   / p1 D) D% f' j5 I; h
3. #include "sys.h"
   ) u& ^" S) M# C# k
4. bool  RC522_READ(u8 * str);                                    //读卡
   / b7 U; `# r% |' F4 i1 c! w
5. bool  RC522_WRITE(u8 * msg);                                //写卡
   ! |' [/ j! L" L5 C! _) I3 `
6. void  RC522_Init(void);                     //初始化
   
7. void test(void);
   ; a3 u7 h# m5 ?( l) m, \: N/ X" r
8. #endif
   ! n3 \# v+ d# k, G4 c8 G$ C
9. </font>

复制代码

最后是我用来测试的main文件
  w' C# R2 j5 k7 {0 f% u包含写卡，和读卡测试。亲测可以使用。
2 \- r' W/ G/ ?3 u) f' ^9 v
( T% O/ Z1 r8 ]1 Q, A  s

1. <font face="微软雅黑" size="3">#include "stm32f10x.h"
   2 u: B3 V% y% I" t0 J
2. #include "uart.h"
   
3. #include "sys.h"
   ; f5 v, K& Z8 @4 T$ |
4. #include "rc522.h"
   4 H% i/ e$ z3 t7 j3 h
5. 
   
6. int main(void)
   
7. {
   
8.         u8 IC[50] = {0};
   
9.         delay_init();
   
10.         UART1_init();
    
11.         delay_ms(2000);
    8 P0 n0 |4 q  D1 h7 ?# }2 B/ h
12.         RC522_Init();
    
13.         printf("RC522_UART_TEST...\r\n");
    + u  m4 ~8 u  c, B3 r
14.        
    
15.         printf(" 写卡开始...\r\n");
    
16.         while(!RC522_WRITE((u8 *)"12121212")){};
    ) ^, S9 f: {7 A, ]( I8 {8 C0 [
17.         printf(" 写卡成功...\r\n");
    
18.        
    
19.         while(1){
    
20.                 if(RC522_READ(IC)){
    / O1 N& _* G6 v
21.                         printf("%s\r\n",IC);
    $ d3 k; f$ P& p8 X" p4 Q. G1 s/ _
22.                         delay_ms(500);
    
23.                 }
    . ^2 [  D" t8 b. {: c
24.                 delay_ms(100);
    
25.                 printf("waitting...\r\n");
    
26.         }
    " h' i; n& k* s1 u- b8 c( Z6 h2 T
27. }</font>
    

复制代码

5 z2 R; ^; Y& C' \* B* r: `