今天，我们抽空来弄下STM32F103RBT6通过SPI方式驱动RC522  NFC模块读写S50复旦卡~
一个简单的下例子，NFC的应用在生活中随处可见了。我们这里的假设应用场景是在不同杯子
底部粘上复旦卡，来辨别不同的杯子TYPE型号~这里仅对块地址17的第一个字节进行判断！
: E( Z4 N( D4 N( X4 {复旦卡就是常见的那种门禁卡钥匙扣形状的：

% ~8 ^8 r4 F5 }  A  X; [* v主板用自制的STM32F103RBT6的一个小板:

4 c  ]7 `. O$ G0 r6 B1 \下载器用CMSIS DAP 带串口的：

4 }2 a; _% ~3 I好，下面开始接线：

1 l9 ^' j. ?4 `7 w接好线的图：

STM32F103RBT6 和RC522 及S50复旦卡就不多说了，网上大把资料。
. u6 C- I* {& ?/ b上程序：
+ a0 z5 _* _! l! s8 d- D1 j* ~spi.h

1. #ifndef __SPI_H
   
2. #define __SPI_H
   . b; H; i; n1 s8 s# F7 ~% Q2 i
3. #include "sys.h"
   - Z6 X) q4 B( d4 S2 U
4. 
   
5. 
   2 n: Y* w% u' E- h6 G$ D8 z! m
6. //#define RC522_RST                   PCout(7)
   
7. #define RC522_RST                   PCout(7)       //测试后恢复PCout(7)
   
8. #define RC522_CS        PBout(9)
   & t- {7 k7 Z1 N, N( D4 R) X- z
9. #define SPIReadByte()          SPIWriteByte(0)
   
10. // SPI总线速度设置
    : J3 q7 [) V' Q7 B
11. #define SPI_SPEED_2                   0
    ) J: U2 C# ?. X  A
12. #define SPI_SPEED_4                   1
    
13. #define SPI_SPEED_8                   2
    
14. #define SPI_SPEED_16                  3
    
15. #define SPI_SPEED_32                   4
    
16. #define SPI_SPEED_64                   5
    % d, i, @( t# T" T
17. #define SPI_SPEED_128                 6
    & f6 P# o2 [! }% @' ~: v- w; w4 V
18. #define SPI_SPEED_256                 7
    ! K( t7 h3 _/ L& Z& D
19.                                                                                                                                                                         
    " ?0 X5 f4 f1 J
20. void SPI2_Init(void);                         //初始化SPI口
    
21. void SPI2_SetSpeed(u8 SpeedSet); //设置SPI速度   
    8 \5 U3 M( Y/ R: A4 W; M
22. u8 SPIWriteByte(u8 TxData);//SPI总线读写一个字节
    
23.                  
    ! |' i( U. Z: |8 b6 F3 Q2 |1 b4 n
24. #endif
    9 l/ M5 O/ \! q; o  l& ]# F# o
25. 
    & w9 P: l& X) J0 L8 ~4 ?/ L" h

复制代码

spi.c
- y2 ]# z$ x  c: q  I" D4 A6 D

1. #include "spi.h"
   
2. 
   
3. //这里针是对SPI2的初始化
   ! I6 d; Q4 m1 d! z8 e: e# I) w% ^
4. void SPI2_Init(void)
   : V; u# b, h- r5 r. }3 G( x3 Q
5. {         
   # l) O; S3 }3 L9 L2 O! S$ Y' ^
6.         RCC->APB2ENR|=1<<3;            //PORTB时钟使能
   
7.         RCC->APB2ENR|=1<<4;            //PORTC时钟使能
   
8.         RCC->APB1ENR|=1<<14;           //SPI2时钟使能
   + z# b" k4 z1 c+ j# t  |
9.         GPIOB->CRH&=0XFFFFFF0F;         
     e* G% }8 ]: g
10.         GPIOB->CRH|=0X00000030;//PB.9 推挽输出
    
11.         GPIOC->CRL&=0X0FFFFFFF;         
    
12.         GPIOC->CRL|=0X30000000;//PC. 7 推挽输出
    
13.         //        GPIOB->CRH&=0XFFFFFFF0;         
    
14.         //        GPIOB->CRH|=0X00000003;//PB. 8 推挽输出   此脚做测试用，测试完恢复PC7复位RFID功能
    
15.         RC522_RST=1;             //RC522 复位脚置1
    5 q% j+ v  c$ t9 I6 o+ J# W3 p4 \- C
16.         RC522_CS=1;
    * F, p1 v5 {9 J/ `7 y/ p5 f6 M
17. 
    
18. 
    0 G6 K* C( M1 ~1 }9 L' ~$ t8 D
19.         //这里只针对SPI口初始化
    " @+ y3 r) m1 ~* b2 K! E
20.         GPIOB->CRH&=0X000FFFFF;
    1 i) S' v; ~2 K8 d& D' c
21.         GPIOB->CRH|=0XBBB00000;        //PB13/14/15复用            
    
22.         GPIOB->ODR|=0X7<<13;           //PB13/14/15上拉
    % M7 T: Q( _; b4 u' L( V% I9 m
23.         SPI2->CR1|=0<<10;                //全双工模式        
    $ T  [5 V4 f3 V4 ^; k9 b' U" H. K
24.         SPI2->CR1|=1<<9;                 //软件nss管理
    % F. f& b' ~' D, q1 j( X
25.         SPI2->CR1|=1<<8;  
    . e1 U6 v" f! V* I
26. 
    2 D, y+ f" v5 q0 f, W9 k5 Q
27.         SPI2->CR1|=1<<2;                 //SPI主机
    . x+ n* {* X0 A& T' b4 Y. e  `
28.         SPI2->CR1|=0<<11;                //8bit数据格式        
    * [7 T3 I6 ^5 r& K! K8 `1 ^
29.         SPI2->CR1|=1<<1;                 //空闲模式下SCK为1 CPOL=1
    0 b/ s3 _9 @  r0 d
30.         SPI2->CR1|=1<<0;                 //数据采样从第二个时间边沿开始,CPHA=1  
    & |8 t8 J0 v9 e9 }$ U
31.         //对SPI2属于APB1的外设.时钟频率最大为36M.
    3 p  O. ?* y! C2 t2 V- |' c
32.         SPI2->CR1|=3<<3;                 //Fsck=Fpclk1/256
    
33.         SPI2->CR1|=0<<7;                 //MSBfirst   
    + ?8 g2 i) C! Q8 b2 t5 O$ q
34.         SPI2->CR1|=1<<6;                 //SPI设备使能
    
35.         SPI2_SetSpeed(5);        
    
36.         SPIWriteByte(0xff);//启动传输                 
    
37. }   
    3 m8 l* y2 i2 v; B
38. //SPI2速度设置函数
    0 P" e+ e" l5 p
39. //SpeedSet:0~7
    / x& m+ h  }$ R' t) g& Q7 N7 }
40. //SPI速度=fAPB2/2^(SpeedSet+1)
    
41. //fAPB2时钟一般为90Mhz
    
42. void SPI2_SetSpeed(u8 SpeedSet)
      c) i' n2 U- e3 u! k& A
43. {
    , }' E4 }: E( j
44.         SpeedSet&=0X07;                        //限制范围
    
45.         SPI2->CR1&=0XFFC7;
    
46.         SPI2->CR1|=SpeedSet<<3;        //设置SPI5速度  
    
47.         SPI2->CR1|=1<<6;                 //SPI设备使能         
    . A0 q/ \) \" g
48. }
    
49. //SPI2 读写一个字节
    . o- K' n! l/ Q0 m( b
50. //TxData:要写入的字节
    6 D! w/ e: u, H
51. //返回值:读取到的字节
    - |4 x( X9 a% d) O: {- K
52. u8 SPIWriteByte(u8 TxData)
    
53. {                                          
    
54.         u16 retry=0;                                 
    
55.         while((SPI2->SR&1<<1)==0)                //等待发送区空        
    
56.         {
    ; \) w  B' c; B& n" u
57.                 retry++;
    
58.                 if(retry>=0XFFFE)return 0;         //超时退出
    
59.         }                          
    
60.         SPI2->DR=TxData;                                   //发送一个byte
    
61.         retry=0;
    
62.         while((SPI2->SR&1<<0)==0)                 //等待接收完一个byte  
    
63.         {
    + }5 }8 Q- Q+ _
64.                 retry++;
    - K0 X8 y2 `- b' `" f/ s
65.                 if(retry>=0XFFFE)return 0;        //超时退出
    
66.         }                                                              
    9 R# O. u, H# g: b, F: v" e* h( C
67.         return SPI2->DR;                          //返回收到的数据                           
    8 B; i7 g: r# @# O) b5 }
68. }
    ; @# ^" ^* D5 ]; U" N$ F0 C
69. 
    
70. 
    
71. 
    

复制代码

rc522.h
9 y; t+ z7 b2 C, C6 e0 f

1. #ifndef _RC522_H_
   ' T0 r6 _6 h. s) I, [: ^. ^& t' ]
2. #define _RC522_H_
   / c, q0 j1 N+ \: y! w. v
3. 
   
4. #include <stm32f10x.h>
   
5. #include "sys.h"
   
6. #include "spi.h"
   6 B0 ^! q$ o1 I) ?/ u( G9 U
7. 
   
8. 
   
9. extern u8 CupType;
   9 G5 B; E: a/ i6 S% g1 V
10. 
    8 n  }3 q6 m; I4 `. W5 o8 _
11. 
    4 ^+ t/ b, V. _7 n3 T# f% N
12. /////////////////////////////////////////////////////////////////////
    * s% O0 v2 P5 X5 }
13. //MF522命令字
    ' L1 V$ L+ Z0 c' q, h$ ?
14. /////////////////////////////////////////////////////////////////////
    5 f+ |0 ]0 X( L$ {2 H+ I1 [. B
15. #define PCD_IDLE              0x00               //取消当前命令
    
16. #define PCD_AUTHENT           0x0E               //验证密钥
    : ]2 h  G. V- n
17. #define PCD_RECEIVE           0x08               //接收数据
    2 }% H- S% s% C
18. #define PCD_TRANSMIT          0x04               //发送数据
    , T& y6 @7 T+ f! l
19. #define PCD_TRANSCEIVE        0x0C               //发送并接收数据
    9 Z& `8 p3 Z" t1 L
20. #define PCD_RESETPHASE        0x0F               //复位
    6 b- E! c# ]3 i8 m
21. #define PCD_CALCCRC           0x03               //CRC计算
    
22. 
    1 ?$ \* l" p8 A2 V1 U
23. /////////////////////////////////////////////////////////////////////
    3 Q3 g+ u4 L" r
24. //Mifare_One卡片命令字
    ( C1 g' `$ X- x2 P4 j& U
25. /////////////////////////////////////////////////////////////////////
    
26. #define PICC_REQIDL           0x26               //寻天线区内未进入休眠状态
    
27. #define PICC_REQALL           0x52               //寻天线区内全部卡
    
28. #define PICC_ANTICOLL1        0x93               //防冲撞
    
29. #define PICC_ANTICOLL2        0x95               //防冲撞
    
30. #define PICC_AUTHENT1A        0x60               //验证A密钥
    $ Q/ u3 i- e7 l7 N$ p0 @
31. #define PICC_AUTHENT1B        0x61               //验证B密钥
    / q7 I/ _4 P, g( r* E
32. #define PICC_READ             0x30               //读块
    
33. #define PICC_WRITE            0xA0               //写块
    
34. #define PICC_DECREMENT        0xC0               //扣款
    
35. #define PICC_INCREMENT        0xC1               //充值
    % R% ?& }, x1 v; P
36. #define PICC_RESTORE          0xC2               //调块数据到缓冲区
    
37. #define PICC_TRANSFER         0xB0               //保存缓冲区中数据
    
38. #define PICC_HALT             0x50               //休眠
    ) G7 O5 e+ M0 C4 c0 }* a
39. 
    
40. /////////////////////////////////////////////////////////////////////
    
41. //MF522 FIFO长度定义
    
42. /////////////////////////////////////////////////////////////////////
    ) B3 w+ ^/ r8 j7 X
43. #define DEF_FIFO_LENGTH       64                 //FIFO size=64byte
    5 g8 S& A7 u" L9 {9 M
44. #define MAXRLEN  18
    
45. 
    
46. /////////////////////////////////////////////////////////////////////
    
47. //MF522寄存器定义
    ' @6 K) O9 Z8 t! l
48. /////////////////////////////////////////////////////////////////////
    0 n& L' s! {5 T8 G# O
49. // PAGE 0
    
50. #define     RFU00                 0x00   
    0 @, c. u) ~  o2 U: n
51. #define     CommandReg            0x01   
    
52. #define     ComIEnReg             0x02   
    
53. #define     DivlEnReg             0x03   
    ) V2 e/ N5 P/ B" G
54. #define     ComIrqReg             0x04   
    ( T6 R/ A9 Y  w7 ?9 P3 H% E* |
55. #define     DivIrqReg             0x05
    4 r$ D) G6 y. Q2 L
56. #define     ErrorReg              0x06   
    
57. #define     Status1Reg            0x07   
    7 ]$ n; ]; L/ k8 b2 @
58. #define     Status2Reg            0x08   
    7 N& \7 B* l) H' h9 X* C# {
59. #define     FIFODataReg           0x09
    % ~$ v" e! l% i7 T( e6 j" V
60. #define     FIFOLevelReg          0x0A
    
61. #define     WaterLevelReg         0x0B
    9 X/ s: G4 E( f% Y2 h9 Z* ]- D% X
62. #define     ControlReg            0x0C
    4 a7 U/ [, f7 {+ j7 D2 @5 f* X% X
63. #define     BitFramingReg         0x0D
    ' b$ [4 x: [1 s7 y' N8 Z
64. #define     CollReg               0x0E
    1 X1 \& `( g' |+ T- Y* t0 x
65. #define     RFU0F                 0x0F
    * w+ @" o& Z0 z$ o
66. // PAGE 1     
    , b1 f7 y: X: o0 E
67. #define     RFU10                 0x10
    % e1 l" g) g3 ]6 q$ J8 }; v) ]
68. #define     ModeReg               0x11
    5 i5 N* L7 Y4 J$ z
69. #define     TxModeReg             0x12
    
70. #define     RxModeReg             0x13
    
71. #define     TxControlReg          0x14
    , B" Q: q$ S7 S! p& ~  C
72. #define     TxAutoReg             0x15
    
73. #define     TxSelReg              0x16
    
74. #define     RxSelReg              0x17
    , T6 R; _) }7 u* n
75. #define     RxThresholdReg        0x18
    8 k# k& [, _* y
76. #define     DemodReg              0x19
    
77. #define     RFU1A                 0x1A
    / U- t, I. r& m+ E3 c, K1 I
78. #define     RFU1B                 0x1B
      P  F0 U( {8 W4 [! }% t3 W) f
79. #define     MifareReg             0x1C
    $ s+ e. q6 i' V5 I* d/ S
80. #define     RFU1D                 0x1D
    
81. #define     RFU1E                 0x1E
    ' j2 r9 t, l  r3 q1 b  k% p2 p( l
82. #define     SerialSpeedReg        0x1F
    ! C, a7 w  y2 l, e, H6 A5 n
83. // PAGE 2   
    
84. #define     RFU20                 0x20  
    + R" M* w7 I' T) e' {; @* Z
85. #define     CRCResultRegM         0x21
    
86. #define     CRCResultRegL         0x22
    
87. #define     RFU23                 0x23
    
88. #define     ModWidthReg           0x24
    ; y' N0 q4 D( r2 l: k
89. #define     RFU25                 0x25
    
90. #define     RFCfgReg              0x26
    , S* y* g6 G( ~3 I0 m
91. #define     GsNReg                0x27
    
92. #define     CWGsCfgReg            0x28
    
93. #define     ModGsCfgReg           0x29
    
94. #define     TModeReg              0x2A
    
95. #define     TPrescalerReg         0x2B
    2 o4 ~( M+ m( [2 O1 g+ g
96. #define     TReloadRegH           0x2C
    & A/ N1 X: C, x2 s4 _6 D2 a0 e1 X
97. #define     TReloadRegL           0x2D
    + b) e# L, I, f* p' ^' x
98. #define     TCounterValueRegH     0x2E
    1 L! w$ e3 o/ [1 S2 n
99. #define     TCounterValueRegL     0x2F
    
100. // PAGE 3      
     
101. #define     RFU30                 0x30
     : i4 @4 ?) o& ?8 ?: I% J7 D
102. #define     TestSel1Reg           0x31
     . W8 z0 K- j, R# e, b+ f: t8 Z
103. #define     TestSel2Reg           0x32
     
104. #define     TestPinEnReg          0x33
     5 P0 |# Y0 L+ |+ y% Q6 A  l3 S
105. #define     TestPinValueReg       0x34
     ; G6 [+ M5 F8 [" t6 M% a/ g, H
106. #define     TestBusReg            0x35
     
107. #define     AutoTestReg           0x36
     
108. #define     VersionReg            0x37
     
109. #define     AnalogTestReg         0x38
     
110. #define     TestDAC1Reg           0x39  
     ! r# w- ~6 I  ]; a  W  f
111. #define     TestDAC2Reg           0x3A   
     
112. #define     TestADCReg            0x3B   
     - X" x  E9 Z' F8 q- m
113. #define     RFU3C                 0x3C   
     
114. #define     RFU3D                 0x3D   
     1 Y% o9 Q$ a5 ^, B( B8 M4 P: Y
115. #define     RFU3E                 0x3E   
     
116. #define     RFU3F                                          0x3F
     
117. 
     " h" K* ^: Y; |7 w) S% V3 k& m
118. /////////////////////////////////////////////////////////////////////
     9 y6 v1 k& [$ A6 L# h
119. //和MF522通讯时返回的错误代码
     
120. /////////////////////////////////////////////////////////////////////
     2 Y% [6 Y6 h4 f  }$ T% J
121. #define         MI_OK                 0
     2 [* H! P4 g0 u% V4 ?& O" E, M
122. #define         MI_NOTAGERR           1
     1 |3 S8 T5 |6 J$ _
123. #define         MI_ERR                2
     
124. 
     
125. #define        SHAQU1        0X01
     
126. #define        KUAI4        0X04
     6 p0 b9 v: y& v  i  |+ @
127. #define        KUAI7        0X07
     
128. #define        REGCARD        0xa1
     # ], q2 r' @- i: N6 D( S5 R
129. #define        CONSUME        0xa2
     " F: f- k3 ~; U' X6 ^; |
130. #define READCARD        0xa3
     
131. #define ADDMONEY        0xa4
     / N& d0 G- w9 H6 n5 j
132. 
     # b& Q* K) B2 A( G0 ^
133. //
     
134. //#define  spi_cs 1;
     4 k/ E4 l$ h$ U7 z! D$ E0 k; T
135. //sbit  spi_ck=P0^6;
     
136. //sbit  spi_mosi=P0^7;
     
137. //sbit  spi_miso=P4^1;
     
138. //sbit  spi_rst=P2^7;
     
139. #define SPIReadByte()        SPIWriteByte(0)
     + \+ _: J5 `7 N1 L0 o- D  J$ q+ W
140. //u8 SPIWriteByte(u8 byte);
     
141. //void SPI2_Init(void);
     & r+ E: w' x- u0 e
142. 
     
143. 
     ; n& w+ \. x0 f, X/ F0 b, w1 F
144. //#define MYRC522_CS   PAout(4)
     
145. //#define MYRC522_RST  PAout(6)
     % Z7 C. ?7 G& C6 i- n
146. 
     0 x; ~* _: a+ ]2 ]6 N" \
147. 
     7 {+ O, t% j3 d8 B
148. 
     2 S/ T/ T  {  E, G
149. void InitRc522(void);
     
150. void ClearBitMask(u8   reg,u8   mask);
     
151. void WriteRawRC(u8   Address, u8   value);
     $ `6 ]5 @7 X$ B
152. void SetBitMask(u8   reg,u8   mask);
     1 I- j8 k) V+ j( R6 Q
153. char PcdComMF522(u8   Command,
     9 q3 X5 c2 b$ y7 _$ y+ [( m
154.                  u8 *pIn ,
     
155.                  u8   InLenByte,
     
156.                  u8 *pOut ,
     
157.                  u8  *pOutLenBit);
     6 o& j& G1 n1 G3 b, M
158. void CalulateCRC(u8 *pIn ,u8   len,u8 *pOut );
     
159. u8 ReadRawRC(u8   Address);
     
160. void PcdAntennaOn(void);
     3 ^8 O( W3 o, u& G# M4 G6 t
161. 
     
162. char PcdReset(void);
     + g! e; o) L0 Z" `; Q
163. char PcdRequest(unsigned char req_code,unsigned char *pTagType);
     
164. void PcdAntennaOn(void);
     
165. void PcdAntennaOff(void);
     
166. char M500PcdConfigISOType(unsigned char type);
     
167. char PcdAnticoll(unsigned char *pSnr);
     
168. char PcdSelect(unsigned char *pSnr);
     1 {8 W- h3 B9 M" v. m
169. char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr);
     / V7 ^+ h, Q( I+ l
170. char PcdWrite(unsigned char addr,unsigned char *pData);
     " D. ]* Z3 j* y4 g
171. char PcdRead(unsigned char addr,unsigned char *pData);
     
172. char PcdHalt(void);
     1 B% j( {( w3 i0 S, w
173. void Reset_RC522(void);
     * R) F$ T$ ~  U3 D5 P! f
174. u8 RfidTest(void);
     ' T9 ~% k( _, a) E/ m' x
175. u8 ReadCupType(void);
     
176. u8 WriteCupType1(void);
     
177. u8 WriteCupType2(void);
     
178. 
     : M! z5 I" r9 S8 A/ R$ ^& r1 Y
179. #endif
     % X  _/ U+ j. [+ g) i

复制代码

rc522.c

1. #include "sys.h"
   
2. #include "delay.h"
   
3. #include "rc522.h"
   9 C1 w$ m8 Q) P; D4 e
4. #include  <stdio.h>
   ) ]* \1 F2 L& m
5. #include  <string.h>
   1 Y1 b( n. U4 Z( s2 O, A, N
6. #include  <ctype.h>
   ) j- X" f- b" k- Y& F' B  M. ^
7. #include  <stdlib.h>
   
8. #include  <stdarg.h>
   
9. #include  <math.h>
   # h. h- t, g7 n! K1 o
10. 
    2 Y7 |6 D; e, ]/ c
11. u8 CupType;
      M& z9 r; W" r& x
12. 
    
13. /*0扇区的第0块是不能写的，只能读，前4字节是卡片ID*/
    % N4 f6 ?" G; N: W9 e
14. /*块3前6字节是A密钥，中间4字节是控制块，后6字节是B密钥*/
    / [/ [, C& P- d
15. /*扇区0：0-3块  扇区1:4-7块  扇区2:8-11块  扇区3:12-15块*/
    
16. /*3、7、11、15块存储密钥*/
    
17. void delay_ns(u32 ns)
    
18. {
    
19.   u32 i;
    ' V- ?0 B; G3 E
20.   for(i=0;i<ns;i++)
    : q  w. X2 h! H5 M0 K, q6 q6 U& @
21.   {
    
22.     __nop();
    
23.     __nop();
    ; Z$ z1 g$ @: q  g+ _- ]
24.     __nop();
    
25.     __nop();
    
26.     __nop();               
    # d8 w/ \  R! o$ K- k% d  q
27.   }
    ' A  Q5 @9 }8 p# X# d
28. }
    
29. 
    * S% U) |% V2 [/ `) _8 p0 u
30. 
    
31. void InitRc522(void)
    
32. {
    
33.   SPI2_Init();
    
34.   PcdReset();
    
35.   PcdAntennaOff();  
    $ R# m5 M0 C/ a0 k  d2 [. h
36.   PcdAntennaOn();
    
37.   M500PcdConfigISOType( 'A' );
    8 n# m5 u7 J' t% Q4 W6 m
38. }
    0 p8 `5 j; C) T, C4 M* y
39. 
    ( g" u7 T% y. m2 z. s8 ~' O% S
40. void Reset_RC522(void)
    7 q: F4 b% O0 e+ D
41. {
    ! |& f* D  Q6 B
42.         PcdReset();
    & L' ~% I4 z( ^
43.   PcdAntennaOff();  
    9 j% C7 j5 d# E* j- D6 Q. M
44.   PcdAntennaOn();
    
45. }                        
    " @/ L3 F1 h1 }9 M7 {
46. /////////////////////////////////////////////////////////////////////
    . g8 t6 P6 ~4 d  l1 z! I) z* M
47. //功    能：寻卡
    
48. //参数说明: req_code[IN]:寻卡方式
    ! L' C+ e$ r" [; a+ C. o: B
49. //                0x52 = 寻感应区内所有符合14443A标准的卡
    0 ^. c1 b( Q; [0 x- T% L- J
50. //                0x26 = 寻未进入休眠状态的卡
    
51. //          pTagType[OUT]：卡片类型代码
    1 D$ H  Q/ H; ~
52. //                0x4400 = Mifare_UltraLight
    . P* G/ ?' N: k8 o% J) n
53. //                0x0400 = Mifare_One(S50)
    
54. //                0x0200 = Mifare_One(S70)
    . w$ W6 Y6 D+ v; P) p
55. //                0x0800 = Mifare_Pro(X)
    
56. //                0x4403 = Mifare_DESFire
    
57. //返    回: 成功返回MI_OK
    6 K8 S# O) K( `; G" k
58. /////////////////////////////////////////////////////////////////////
    
59. char PcdRequest(u8   req_code,u8 *pTagType)
    
60. {
    : v  Q$ X( ]4 u+ ]) A2 B; M* }( i8 c
61.         char   status;  
    5 _$ a7 S" ]/ T8 {" d4 [- P7 K
62.         u8   unLen;
    , T5 V; V9 M9 {
63.         u8   ucComMF522Buf[MAXRLEN];
    . r( {0 u4 W9 J" C4 J# n" Q8 m* Q
64. 
    
65.         ClearBitMask(Status2Reg,0x08);
    
66.         WriteRawRC(BitFramingReg,0x07);
      l' g% z, X7 b* {; ~9 z) l
67.         SetBitMask(TxControlReg,0x03);
    2 _# I, `7 q" p7 I- Z( b
68. 
    
69.         ucComMF522Buf[0] = req_code;
    
70. 
    
71.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,1,ucComMF522Buf,&unLen);
    
72. 
    
73.         if ((status == MI_OK) && (unLen == 0x10))
    
74.         {   
    5 W- p, \7 E" ?3 t, R. v7 j6 W3 V
75.                 *pTagType     = ucComMF522Buf[0];
    : d+ u( @. A5 V' ?2 o& B
76.                 *(pTagType+1) = ucComMF522Buf[1];
    
77.         }
    
78.         else
    4 A8 `: [& F& p. d: y
79.         {   status = MI_ERR;   }
    
80.    
    $ ^0 B( \# y) e. q  a( g
81.         return status;
    
82. }
    " j' S7 L1 U( G/ r
83. 
    
84. /////////////////////////////////////////////////////////////////////
    
85. //功    能：防冲撞
    0 E% C/ ~# c1 c$ l
86. //参数说明: pSnr[OUT]:卡片序列号，4字节
    , l5 I8 \1 y) n5 r2 E+ i
87. //返    回: 成功返回MI_OK
    
88. /////////////////////////////////////////////////////////////////////  
    
89. char PcdAnticoll(u8 *pSnr)
    
90. {
    8 ?. n& n) f% F9 V* z
91.     char   status;
    
92.     u8   i,snr_check=0;
    
93.     u8   unLen;
    " s; @. e7 L/ V+ z" Y( K
94.     u8   ucComMF522Buf[MAXRLEN];
    
95.    
    2 W$ C# z6 g. Y% e9 M# a
96. 
    
97.     ClearBitMask(Status2Reg,0x08);
    9 [. i( ^' t2 |
98.     WriteRawRC(BitFramingReg,0x00);
    . y* O! ^) J# b2 `- Q
99.     ClearBitMask(CollReg,0x80);
    - D' Q: x# m3 Z
100. 
     : J; V# E; Y  A2 h2 `
101.     ucComMF522Buf[0] = PICC_ANTICOLL1;
     1 y& _9 R& \1 l/ `; P
102.     ucComMF522Buf[1] = 0x20;
     7 ]+ ~: ?8 @3 ~3 Z; u+ X
103. 
     
104.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,2,ucComMF522Buf,&unLen);
     ! O) _6 Z, Z9 h# G
105. 
     ) f) {2 j, h6 p2 h& p
106.     if (status == MI_OK)
     
107.     {
     
108.              for (i=0; i<4; i++){   
       X5 i+ L  p% b4 m
109.              *(pSnr+i)  = ucComMF522Buf[i];
     : c* v. `! ?5 Z% {! |
110.              snr_check ^= ucComMF522Buf[i];
     
111.         }
     0 e9 o8 F3 Q1 R) @! \+ W0 \# f
112.          if (snr_check != ucComMF522Buf[i]){   
     
113.                                       status = MI_ERR;   
     . m* d' P. i/ C$ N9 `1 m: [% [
114.                                  }
     
115.     }
     
116.    
     % R8 k% n1 I+ i' g1 O
117.     SetBitMask(CollReg,0x80);
     
118.     return status;
     / U) h$ F0 W+ q6 S$ q: z
119. }
     
120. 
     ' }# ]4 E7 v! f% q6 b
121. /////////////////////////////////////////////////////////////////////
     - O) @3 v; i' s+ n
122. //功    能：选定卡片
     
123. //参数说明: pSnr[IN]:卡片序列号，4字节
     
124. //返    回: 成功返回MI_OK
     
125. /////////////////////////////////////////////////////////////////////
     
126. char PcdSelect(u8 *pSnr)
     
127. {
     
128.     char   status;
     
129.     u8   i;
     
130.     u8   unLen;
     
131.     u8   ucComMF522Buf[MAXRLEN];
     
132.    
     2 a: s+ k# ~, m4 j
133.     ucComMF522Buf[0] = PICC_ANTICOLL1;
     
134.     ucComMF522Buf[1] = 0x70;
     
135.     ucComMF522Buf[6] = 0;
     ' ]( I" B6 Q0 h+ [& q( |# R: ~+ @
136.     for (i=0; i<4; i++)
     
137.     {
     . H; e* s) D" F  u  X: i/ N
138.             ucComMF522Buf[i+2] = *(pSnr+i);
     6 X7 h- {1 D. [' r6 e+ b
139.             ucComMF522Buf[6]  ^= *(pSnr+i);
     
140.     }
     3 K8 O- ~- w3 h+ a) M" Y
141.     CalulateCRC(ucComMF522Buf,7,&ucComMF522Buf[7]);
     
142.   
     % Y- E6 Z; b+ R8 v4 i0 v1 s
143.     ClearBitMask(Status2Reg,0x08);
     1 o: }; ~9 I6 z8 a  A- N! F/ ?% |
144. 
     4 |, }$ ^6 @2 q+ w$ Q+ }: e
145.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);
     
146.    
     
147.     if ((status == MI_OK) && (unLen == 0x18))
     . H! P2 D. g1 M5 B, [6 {3 [
148.     {   status = MI_OK;  }
     
149.     else
     
150.     {   status = MI_ERR;    }
     
151. 
     ' k. R8 \4 E3 b3 b- Y8 o
152.     return status;
     
153. }
     5 K+ T5 \0 s' D
154. 
     # W: u9 [( q4 Q# @) y$ c
155. /////////////////////////////////////////////////////////////////////
     $ a7 i8 f. a* Q9 g" Z2 O0 Z7 D: J; ~
156. //功    能：验证卡片密码
     ( X  u) C  m) a- h$ K" _4 V& Q6 H
157. //参数说明: auth_mode[IN]: 密码验证模式
     
158. //                 0x60 = 验证A密钥
     ( A! V- T0 N' R& _4 w; i; z4 _$ w1 c
159. //                 0x61 = 验证B密钥
     
160. //          addr[IN]：块地址
     
161. //          pKey[IN]：密码
     
162. //          pSnr[IN]：卡片序列号，4字节
     3 B# d& H( {) V3 v
163. //返    回: 成功返回MI_OK
     
164. /////////////////////////////////////////////////////////////////////               
     & R$ }/ J( \2 \8 V
165. char PcdAuthState(u8   auth_mode,u8   addr,u8 *pKey,u8 *pSnr)
     $ B$ w3 {7 g& P& |/ f" \
166. {
     6 b6 r3 x+ q7 L1 d) j/ J# r
167.     char   status;
     
168.     u8   unLen;
     $ _7 n7 @8 p& l$ p: k9 d
169.     u8   ucComMF522Buf[MAXRLEN];
     
170. 
     
171.     ucComMF522Buf[0] = auth_mode;
     
172.     ucComMF522Buf[1] = addr;
     
173.     memcpy(&ucComMF522Buf[2], pKey, 6);
     
174.     memcpy(&ucComMF522Buf[8], pSnr, 4);
     
175.    
     . o: R) b0 R7 W
176.     status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
     3 c) I7 l$ J: D' g# t1 x8 g
177.     if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
     
178.     {   status = MI_ERR;   }
     ; P8 _5 p; D2 j% T8 \: f/ J/ e, Z9 n
179.    
     
180.     return status;
     ) D; n1 @3 f& t
181. }
     ; N! z5 Y6 P" L. S
182. 
     
183. /////////////////////////////////////////////////////////////////////
     1 a# Z3 L' ?* K, p1 N9 O
184. //功    能：读取M1卡一块数据
     7 d, G  t# Z$ R0 ]: w
185. //参数说明: addr[IN]：块地址
     
186. //          p [OUT]：读出的数据，16字节
     4 [8 m' Y$ Q4 m1 l/ D+ Z, Z
187. //返    回: 成功返回MI_OK
     
188. /////////////////////////////////////////////////////////////////////
     
189. char PcdRead(u8   addr,u8 *p )
     
190. {
     
191.     char   status;
     0 L* k1 Y5 }9 i4 b1 D
192.     u8   unLen;
     
193.     u8   i,ucComMF522Buf[MAXRLEN];
     . L8 l* Z' D5 a: i# \0 r3 x3 l) I
194. 
     4 h% O, s5 X$ m8 {- Q) ?1 c* q9 e: l* T
195.     ucComMF522Buf[0] = PICC_READ;
     
196.     ucComMF522Buf[1] = addr;
     1 G- J) q# x7 a# Y
197.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
198.    
     
199.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     * O% L1 N1 M6 E$ f
200.           if ((status == MI_OK) && (unLen == 0x90))
     
201.     {
     - j6 f5 D+ Q4 o- }1 ^/ W7 G2 O
202.         for (i=0; i<16; i++)
     
203.         {    *(p +i) = ucComMF522Buf[i];   }
     # ^2 w9 [) W* T" ~# {. d# `8 f
204.     }
     ; ]0 J8 K5 f* P% W
205.     else
     7 ]4 d5 {7 o& J3 H* r, n+ }. H
206.     {   status = MI_ERR;   }
     2 S  B( i0 x$ C& m2 R2 A6 W$ }
207.    
     5 T( k" V* m# K6 |9 }$ f6 Q
208.     return status;
     
209. }
     . [4 c/ `. S( [* ?0 j* g
210. 
     
211. /////////////////////////////////////////////////////////////////////
     
212. //功    能：写数据到M1卡一块
     " @0 B3 A; Z) Z9 L) Q: K  h* \/ B/ |
213. //参数说明: addr[IN]：块地址
     
214. //          p [IN]：写入的数据，16字节
     
215. //返    回: 成功返回MI_OK       /*读01扇区数据，改密码只能写3、7、11、15扇区*/
     
216. /////////////////////////////////////////////////////////////////////                  
     4 i+ n! y# f' E+ w1 m
217. char PcdWrite(u8   addr,u8 *p )
     8 f- ]6 ?& |  |" A
218. {
     1 f9 g9 I$ {) M+ [4 @, S9 ]) U/ C
219.     char   status;
     
220.     u8   unLen;
     & l# j2 k) Q6 @
221.     u8   i,ucComMF522Buf[MAXRLEN];
     5 v, T& c) G2 w0 R! q
222.    
     
223.     ucComMF522Buf[0] = PICC_WRITE;
     " D/ p9 @0 z+ M" ^1 D+ \
224.     ucComMF522Buf[1] = addr;
     
225.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
226. 
     + F. C5 s2 ~1 k( B# ~
227.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
228. 
     
229.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     . o9 z! r3 [) p  A
230.     {   status = MI_ERR;   }
     
231.         
     ) ~. y7 w2 P, H: b2 q3 h
232.     if (status == MI_OK)
     
233.     {
     ( n0 o5 b/ q5 z. {
234.         //memcpy(ucComMF522Buf, p , 16);
     
235.         for (i=0; i<16; i++)
     
236.         {   
     
237.                 ucComMF522Buf[i] = *(p +i);   
     # t; e) j6 [. A9 G3 e0 }7 [. V+ \, a
238.         }
     
239.         CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16]);
     
240. 
     ) _- z! J" \! S% m. j3 _) p2 B$ |
241.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,18,ucComMF522Buf,&unLen);
     4 z8 [  ?0 t2 j( L8 b$ G& l6 e
242.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     7 g4 S$ a+ L% {- R( _' O& V, A
243.         {   status = MI_ERR;   }
     0 T$ y3 p, c; O. q; M
244.     }
     $ N. ^1 H, S& b& W- t3 g- K* L
245.    
     2 W5 d+ W; |1 \) o
246.     return status;
     
247. }
     $ {3 _+ H# p3 q1 {6 R) w
248. 
     
249. /////////////////////////////////////////////////////////////////////
     
250. //功    能：命令卡片进入休眠状态
     
251. //返    回: 成功返回MI_OK
     
252. /////////////////////////////////////////////////////////////////////
     : c3 g& V* Z) `4 A
253. char PcdHalt(void)
     , B1 ^* D! u' g  o. E. Q2 y
254. {
     
255.     uint8_t   status;
       s! g2 ^) f& N% K4 q' N! S
256.     uint8_t   unLen;
     
257.     uint8_t   ucComMF522Buf[MAXRLEN];
     5 E, x7 J" W% G" s' h6 d* m
258. 
     ! D) k& ]' C1 b6 L/ U& V, x; p
259.     ucComMF522Buf[0] = PICC_HALT;
     2 C' ~! ^3 |$ Y2 T4 A# M" `! Z3 J
260.     ucComMF522Buf[1] = 0;
     
261.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     * M7 @6 G$ a9 Y% F2 V$ Q  t
262. 
     
263.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     1 k) z, H# H" j/ B/ G
264. 
     
265.     return status;
     
266. }
     0 F3 o/ J6 \" e4 L( x( D5 n$ M
267. 
     & V6 J1 E1 H; {" ?% }
268. /////////////////////////////////////////////////////////////////////
     
269. //用MF522计算CRC16函数
     0 U0 g* F2 a  y1 F5 c1 A4 F
270. /////////////////////////////////////////////////////////////////////
     
271. void CalulateCRC(u8 *pIn ,u8   len,u8 *pOut )
     
272. {
     
273.     u8   i,n;
     
274.     ClearBitMask(DivIrqReg,0x04);
     , Z9 @. ]+ A" A4 }  j
275.     WriteRawRC(CommandReg,PCD_IDLE);
     ( p; A3 f- p! j& {; o* w( Y: o
276.     SetBitMask(FIFOLevelReg,0x80);
     
277.     for (i=0; i<len; i++)
     
278.     {   WriteRawRC(FIFODataReg, *(pIn +i));   }
     
279.     WriteRawRC(CommandReg, PCD_CALCCRC);
     % r" J. T! b7 Z, ]0 W: C
280.     i = 0xFF;
     4 t. K3 x9 S7 r
281.     do
     
282.     {
     
283.         n = ReadRawRC(DivIrqReg);
     % e+ [( D6 C: T/ H+ O) r
284.         i--;
     
285.     }
     
286.     while ((i!=0) && !(n&0x04));
     3 R$ X/ v' T2 E! {' w
287.     pOut [0] = ReadRawRC(CRCResultRegL);
     8 Q" g, i$ c" {
288.     pOut [1] = ReadRawRC(CRCResultRegM);
     + j- ]: i1 A- j  n) B5 D
289. }
     
290. 
     5 ?* k# x# A. M- h0 Y! X1 W: H
291. /////////////////////////////////////////////////////////////////////
     
292. //功    能：复位RC522
     ) `4 \8 [. i0 x5 N( C
293. //返    回: 成功返回MI_OK
     $ F" ]9 k/ Y* T) Q6 }8 N
294. /////////////////////////////////////////////////////////////////////
     & s* P- {% C% Y0 T% @6 K1 q
295. char PcdReset(void)
     
296. {
     
297.          
     # H  m/ j7 I" d# o5 `  @: T
298.           RC522_RST=1;
     
299.     delay_ns(1000);
     
300.           RC522_RST=0;
     
301.     delay_ns(1000);
     3 m4 j$ r, L4 M: j
302.           RC522_RST=1;
     $ d# E5 ]' }: ?
303.     delay_ns(1000);
     
304.     WriteRawRC(CommandReg,PCD_RESETPHASE);
     , u* W# Y5 c! R3 O+ @1 i; d
305.     delay_ns(1000);
     
306.    
     
307.     WriteRawRC(ModeReg,0x3D);            //和Mifare卡通讯，CRC初始值0x6363
     
308.     WriteRawRC(TReloadRegL,30);           
     
309.     WriteRawRC(TReloadRegH,0);
     
310.     WriteRawRC(TModeReg,0x8D);
     
311.     WriteRawRC(TPrescalerReg,0x3E);
     
312.         
     ! l# d2 @" o. ], I; O3 M9 B
313.           WriteRawRC(TxAutoReg,0x40);       //
     
314. //WriteRawRC(ComIEnReg,0x20);        
     $ g" b8 Y; g0 T- l2 Q
315. //WriteRawRC(DivlEnReg,0x90);        
     4 w' e2 ^2 K" F
316.    
     5 F9 `. a: H! ?1 {3 P
317.     return MI_OK;
     
318. }
     3 I( m1 y/ E# H( L+ i) m, }6 G
319. //////////////////////////////////////////////////////////////////////
     
320. //设置RC632的工作方式
     # c! `7 |( @4 W) A% u/ R
321. //////////////////////////////////////////////////////////////////////
     6 {) T+ i* Q) f" m6 V8 r' }" e
322. char M500PcdConfigISOType(u8   type)
     . L9 }$ a2 b% F1 K! }7 t
323. {
     % D+ |! B6 ?4 s# b8 X$ C5 W
324.    if (type == 'A')                     //ISO14443_A
     
325.    {
     
326.        ClearBitMask(Status2Reg,0x08);
     % `7 c4 M0 g7 a, @5 O
327.        WriteRawRC(ModeReg,0x3D);//3F
     9 S2 w8 ?0 L% k- s$ L$ i
328.        WriteRawRC(RxSelReg,0x86);//84
     : Q( g7 _1 C$ v# Z
329.        WriteRawRC(RFCfgReg,0x7F);   //4F
     
330.               WriteRawRC(TReloadRegL,30);//tmoLength);// TReloadVal = 'h6a =tmoLength(dec)
     
331.              WriteRawRC(TReloadRegH,0);
     
332.        WriteRawRC(TModeReg,0x8D);
     
333.              WriteRawRC(TPrescalerReg,0x3E);
     & N; O4 S/ I  Z' G6 U
334.              delay_ns(1000);
     
335.        PcdAntennaOn();
     9 `* |% T( T3 H& |, n9 j6 a  o
336.    }
     
337.    else{ return 1; }
     
338.    
     2 @# Y: P; M  r0 h5 x
339.    return MI_OK;
     
340. }
     + \0 h6 y9 K- D7 |
341. /////////////////////////////////////////////////////////////////////
     ( ~0 _4 Z- L2 M9 Y7 U$ N
342. //功    能：读RC632寄存器
     ! U) V& t. ~  N0 f! X" _
343. //参数说明：Address[IN]:寄存器地址
     
344. //返    回：读出的值
     
345. /////////////////////////////////////////////////////////////////////
     2 {# \* D" c4 V' ~& C3 T
346. u8 ReadRawRC(u8   Address)
     
347. {
     $ ?9 [5 E& a  i+ K' u
348.     u8   ucAddr;
     
349.     u8   ucResult=0;
     6 P( E0 z: a0 w; n- F
350.           RC522_CS=0;
     9 ?) {; |' w% S5 S
351.     ucAddr = ((Address<<1)&0x7E)|0x80;
     , R1 c$ t6 a2 e
352.         
     
353.          SPIWriteByte(ucAddr);
     
354.          ucResult=SPIReadByte();
     3 e- _9 B5 J) z; N0 Y
355.          RC522_CS=1;
     
356.    return ucResult;
     4 B1 p) s& D3 U; H
357. }
     $ T4 j& \2 i3 A1 |9 c' ?
358. 
     2 [4 w' {% |; @5 n* C# {# i
359. /////////////////////////////////////////////////////////////////////
     7 f+ B2 t# q- I$ s
360. //功    能：写RC632寄存器
     
361. //参数说明：Address[IN]:寄存器地址
     8 g+ C% o3 [( h* g, N$ \& ?
362. //          value[IN]:写入的值
     / K+ B1 e. D) J& i* k  j- z
363. /////////////////////////////////////////////////////////////////////
     ) k% W' S0 _+ x- S2 d
364. void WriteRawRC(u8   Address, u8   value)
     ' ]; }( E' H& [) j4 {: R* k
365. {  
     # a( g0 y" [* e0 B% l. L
366.     u8   ucAddr;
     - Y1 Y: ^* ^2 Z5 V( |* ]; {
367. 
     
368.           RC522_CS=0;
     ( N1 Z. y1 Z( f! E) p- t7 ]6 X
369.     ucAddr = ((Address<<1)&0x7E);
     
370. 
     
371.          SPIWriteByte(ucAddr);
     
372.          SPIWriteByte(value);
     
373.          RC522_CS=1;
     
374. }
     8 W' m3 \: X7 @$ f
375. /////////////////////////////////////////////////////////////////////
     
376. //功    能：置RC522寄存器位
     
377. //参数说明：reg[IN]:寄存器地址
     1 a2 ^1 R  Z( k  F- B
378. //          mask[IN]:置位值
     8 n+ R: {5 |" m1 a, x; U% }% {6 D  N
379. /////////////////////////////////////////////////////////////////////
     
380. void SetBitMask(u8   reg,u8   mask)  
     
381. {
     
382.     char   tmp = 0x0;
     
383.     tmp = ReadRawRC(reg);
     
384.     WriteRawRC(reg,tmp | mask);  // set bit mask
     - ~" `# ]0 S0 B- ?
385. }
     
386. 
     - ]0 F2 g$ `1 u6 I
387. /////////////////////////////////////////////////////////////////////
     
388. //功    能：清RC522寄存器位
     7 M' M/ v( x5 g' F: a
389. //参数说明：reg[IN]:寄存器地址
     ) O$ l% q+ z6 ~* V. W/ \( Y( S! p) }! f* w; r
390. //          mask[IN]:清位值
     * P$ v- k+ A" x  u' X" @( A
391. /////////////////////////////////////////////////////////////////////
     
392. void ClearBitMask(u8   reg,u8   mask)  
     ! K) r9 F: {. L
393. {
     % y: b& q6 w; L& k( C+ Y
394.     char   tmp = 0x0;
     ( {- `6 E7 c4 l* I! g% `
395.     tmp = ReadRawRC(reg);
     / c8 q8 L" C0 U* d9 G
396.     WriteRawRC(reg, tmp & ~mask);  // clear bit mask
     - D. A( ^  O: h! h
397. }
     4 \7 H+ D4 a5 d  q( x9 V
398. 
     
399. /////////////////////////////////////////////////////////////////////
     
400. //功    能：通过RC522和ISO14443卡通讯
     * l( U$ Y! V  ^( G* D! d! E
401. //参数说明：Command[IN]:RC522命令字
     ( S# d7 C7 s: e: M% w/ p
402. //          pIn [IN]:通过RC522发送到卡片的数据
     9 N" u1 E. a5 m, K0 |
403. //          InLenByte[IN]:发送数据的字节长度
     
404. //          pOut [OUT]:接收到的卡片返回数据
     6 v, l+ x; J/ y2 b( Q- Z
405. //          *pOutLenBit[OUT]:返回数据的位长度
     
406. /////////////////////////////////////////////////////////////////////
     " k4 b8 a, g' V# j! A
407. char PcdComMF522(u8   Command,
     
408.                  u8 *pIn ,
     6 ]% b' c' [" p
409.                  u8   InLenByte,
     
410.                  u8 *pOut ,
     - h) F# w" v8 r; ^
411.                  u8 *pOutLenBit)
     
412. {
     
413.     char   status = MI_ERR;
     
414.     u8   irqEn   = 0x00;
     # K; B: d( `5 h( I3 {9 @1 X: Z. @
415.     u8   waitFor = 0x00;
       Q9 Y6 K, r9 Q8 }4 o5 q  w
416.     u8   lastBits;
     
417.     u8   n;
     
418.     long   i;
     
419.     switch (Command){
     9 Z( ~8 Z! o& E, Y) Y( T! r
420.     case PCD_AUTHENT:
     0 M. y( C! t9 S$ L
421.                            irqEn   = 0x12;
     9 C. t' g" N( E) s
422.                            waitFor = 0x10;
     / A) Y0 k5 A9 o3 L! _- f
423.                            break;
     3 X1 c3 F+ {: Y0 x% c4 _, q
424.                 case PCD_TRANSCEIVE:
     0 `5 j1 p) P& P& Z
425.                           irqEn   = 0x77;
     
426.                           waitFor = 0x30;
     
427.                           break;
     ! p/ j1 \  m2 E  y0 C
428.                 default:
     : V+ b: O% \% A2 x2 x- j
429.                         break;
       A' m8 w1 s7 [
430.     }
     ' w  j- l" }& N( Y
431.    
     
432.     WriteRawRC(ComIEnReg,irqEn|0x80);
     5 {* f, z  E0 q+ y8 D% |
433.     ClearBitMask(ComIrqReg,0x80);        //清所有中断位
     
434.     WriteRawRC(CommandReg,PCD_IDLE);
     
435.     SetBitMask(FIFOLevelReg,0x80);                 //清FIFO缓存
     
436.    
     
437.     for (i=0; i<InLenByte; i++){   
     & @# Y. c" M8 a  T3 J' h0 {
438.                 WriteRawRC(FIFODataReg, pIn [i]);   
     ) a% D- o: K8 J! N/ I
439.                 }
     0 \+ k9 T3 K& ?+ b: U# o2 ?* J
440.     WriteRawRC(CommandReg, Command);         
     & K. ]5 D* b5 \( g! V8 J
441.    
     ! k5 h: h4 q2 e8 V" G' L5 Y; v
442.     if (Command == PCD_TRANSCEIVE){   
     
443.                     SetBitMask(BitFramingReg,0x80);
     * T% w8 G/ @: Q$ ~
444.                  }         //开始传送
     
445.                                                                                     
     $ f! R/ Z+ `: T1 G" a
446.     //i = 600;//根据时钟频率调整，操作M1卡最大等待时间25ms
     
447.           i = 100000;
     9 p9 t, x# n" ]& q
448.     do
     
449.     {
     ! y* c; g3 L9 }; n: |+ Z. `
450.         n = ReadRawRC(ComIrqReg);
     * s- Z7 j! P; a! a9 s* T! ^# ?, K) W
451.         i--;
     
452.     }while ((i!=0) && !(n&0x01) && !(n&waitFor));
     
453.     ClearBitMask(BitFramingReg,0x80);
     + V- [0 u, g; Q# \& @
454. 
     7 h9 Q3 t# @  L0 L4 W3 b
455.     if (i!=0){   
     6 N& C# g- p: g; e. p, v
456.         if(!(ReadRawRC(ErrorReg)&0x1B)){
     
457.             status = MI_OK;
     ) `, G% I( q4 V" R! K- \
458.             if (n & irqEn & 0x01){   
     
459.                                                     status = MI_NOTAGERR;
     
460.                                                 }
     * _$ |. U; p0 f2 q3 {6 v' c
461.             if (Command == PCD_TRANSCEIVE){
     : @! c$ Q' @: n$ `! x7 J
462.                        n = ReadRawRC(FIFOLevelReg);
     
463.                       lastBits = ReadRawRC(ControlReg) & 0x07;
     6 W' `" ~. G! K
464.                 if (lastBits){  
     
465.                                                                    *pOutLenBit = (n-1)*8 + lastBits;  
     9 b8 Y) b6 L! F2 `* k4 r/ Y  S6 D4 q
466.                                                                 }else{  
     
467.                                                                    *pOutLenBit = n*8;   
     
468.                                                                 }
     
469.                 if (n == 0){   
     1 \! x  N3 b' ]2 n
470.                                                                     n = 1;   
     
471.                                                                 }
       o- B- \2 b: @$ F; o
472.                 if (n > MAXRLEN){  
     ' ?# Y4 X' O$ w9 P$ R
473.                                                          n = MAXRLEN;   
     * z6 h  k0 ~/ e' w# M
474.                                                                  }
     
475.                 for (i=0; i<n; i++){   
     
476.                                                                     pOut [i] = ReadRawRC(FIFODataReg);  
     
477.                                                                 }
     
478.             }
       q& k" f/ j7 n, V
479.         }else{   
     2 L4 G* u% \2 [: z
480.                                      status = MI_ERR;  
     
481.                                  }
     4 w5 t! @" Y* Q( O! K
482.         
     
483.     }
     
484.     SetBitMask(ControlReg,0x80);           // stop timer now
     
485.     WriteRawRC(CommandReg,PCD_IDLE);
     
486.     return status;
     
487. }
     
488. 
     
489. /////////////////////////////////////////////////////////////////////
     
490. //开启天线  
     
491. //每次启动或关闭天险发射之间应至少有1ms的间隔
     
492. /////////////////////////////////////////////////////////////////////
     
493. void PcdAntennaOn(void)
     
494. {
     8 S  z! f8 y, v0 x
495.     u8   i;
     
496.     i = ReadRawRC(TxControlReg);
     5 `& p/ Q" n* E( y
497.     if (!(i & 0x03)){
     
498.         SetBitMask(TxControlReg, 0x03);
     
499.     }
     9 i$ w# ~, t/ }
500. }
     
501. 
     5 \) f& P- p3 b: m
502. 
     * I/ d+ ?- Z5 u: ]0 y1 r( ^' M
503. /////////////////////////////////////////////////////////////////////
     
504. //关闭天线
     1 N! r' I9 z2 w' V. h
505. /////////////////////////////////////////////////////////////////////
     
506. void PcdAntennaOff(void)
     
507. {
       b3 b7 e- S9 m9 i! h) Z
508.         ClearBitMask(TxControlReg, 0x03);
     
509. }
     / A1 e- V* O5 y, Z+ ^
510. extern unsigned char CT[2];//卡类型
     
511. extern unsigned char SN[4]; //卡号
     
512. extern unsigned char pptr[64];
     / w& a( d: B9 J- U6 V! V% X+ y
513. extern unsigned char KEY[6];
     
514. 
     
515. 
     ; P6 Y+ ~; g" ?/ H+ [
516. u8 RfidTest(void)
     ; J4 B8 i5 v# ^! z" [9 F
517. {
     
518.         static u8 oncnt;
     , x1 w1 q* p( T& E8 j
519.         static u16 allcnt;
     7 `: z# ?/ ~: [. p
520.         static u8 res=1;
     ( U. R( S: s9 {2 s! r2 k! J
521.         u8 status;
     
522.         allcnt++;                                                 /*未明确什么含义 RF卡扫描次数？*/
     
523.         if(PcdRequest(PICC_REQALL,CT)==0)                         /*扫描卡*/
     
524.         {
     1 Q% U$ ~! @1 J- S. G
525.                 status = PcdAnticoll(SN);                             /*防冲撞--获取卡号*/
     
526.                 status = PcdSelect(SN);                               /*根据卡号选择卡*/
     
527.                 //1个扇区4个块 每个块16个字节 密码长度6个字节
     
528.                 //块地址=扇区编号×4+扇区内的块编号 17 代表4扇区 块1
     
529.                 //将保存在块地址17内的6个字节的密码与秘钥B进行比较
     
530.                 //调用该函数需要选择密码验证是KEYA还是KEYB，
     
531.                 //然后输入你要操作的块地址(想要读写的)()
     3 E. M2 I( _+ v) X8 j" r9 j
532.                 //存放密码数组和存放卡片序列号的数组。(感觉仅用来计算扇区)
     
533.                 //验证成功后就可以对该块所在的扇区内所有的块进行操作了
     6 a: [/ u& R) }7 ~, J" }! h# C
534.                 //读、写、加值、减值、转移、恢复）
     $ b) ]8 u( f2 ~5 e
535.                 //KEYA KEYB 默认密码都是0XFF
     ! K. U8 R7 t. e7 L: t
536.                 status = PcdAuthState(PICC_AUTHENT1B,17,KEY,SN);      /*解密:验证B密钥,密码所在地址 3-7-11-15-19*/
     
537.                 status = PcdRead(17,pptr);                            /*读4扇区01块数据 返回16个字节数据*/
     2 c& x1 _9 `( |$ N; a% K! @
538.                 if(status == MI_OK)  //5次以上成功
     + ]1 W) L* W. j0 M6 I' I$ l7 x
539.                 {
     
540.                         oncnt++;
     
541.                         CupType = pptr[0];//茶杯类型在0位置
     4 j6 e; ]5 I( u
542.                 }
     5 f. q: d+ o" x/ Z8 ~
543.         }
     - ^6 q1 w+ y# {6 d1 }# p- q
544.         if(allcnt>13)//检测13次
     ' w% [# @0 _' O' P  E
545.         {
     & W" X' |, n. ]- v/ f0 @% m7 |
546.                 if(oncnt>5)//5次以上成功
     
547.                 {
     
548.                         res= 0;
     
549.                 }
     ' _& r8 a! v2 B. v2 f* E7 ^: J
550.                 else
     + P( Q/ X( Q+ a9 U: Q  `8 B
551.                 {
       T* t: Y  T  }" p1 H3 k' I' P
552.                         res = 1;
       a, h6 X" u& k( P' h
553.                         CupType=0xff;
     " Q$ q* O# u  ~. n3 ^% G
554.                 }
     ; d6 ?$ m) V/ p+ f, N
555.                 allcnt=0;oncnt=0;
     7 y) i0 q& F6 J' _6 ~. d
556.         }
     6 M! }% ~8 @! w. a8 u% p
557.         return res;
     
558. }
     
559. /////////////////////////////////////////////////////////////////////
     
560. //功    能：读取杯子类型
     
561. //
     
562. //返    回: 失败  返回0xff   型号一返回01    型号二返回02   空白卡返回00
     
563. /////////////////////////////////////////////////////////////////////
     ; B5 E' G6 R6 y: k
564. 
     + b) V2 g/ i/ {/ D* V' {: n
565. extern u8 CheckRFTime;
     " p6 h0 P1 l) o9 P4 W5 c
566. u8 AllCnt=0;
     ; z! V4 M. _2 w5 Z+ n
567. 
     2 E/ Q& ?+ j! |  h6 a9 s# F
568. u8 ReadCupType(void)
     # h: \* d" [) r; z& Y+ U
569. {
       C# x9 x3 g6 P( @0 F
570.         u8 status;  
     . j- o& I" E( _6 w
571. 
     
572.     AllCnt++;
     
573.         /*无卡次数，也就是非MI_OK的次数*/
     
574.         status = PcdRequest(PICC_REQALL,CT);                    /*扫描卡  0 OK  2失败*/
     3 }' R1 R! R* Q$ t" H3 n6 P
575.         if(status==MI_OK)
     - I3 t! x& A% t8 g8 Z& \8 h5 Z
576.                 printf("寻卡状态:成功\r\n");
     
577.         else
     
578.         {
     # H- {5 b, k/ F1 r8 i
579.                 printf("寻卡状态:失败\r\n");
     4 q: Y6 m& {: u; P2 c, B- ~
580.                 return 0XDF;
     * _! N  ?1 i0 K1 n
581.         }
     
582.                
     
583.         status = PcdAnticoll(SN);                               /*防冲撞*/
     
584.         if(status==MI_OK)
     
585.                 printf("防冲撞:成功\r\n");
     
586.         else
     
587.         {
     
588.                 printf("防冲撞:失败\r\n");
     
589.                 return 0XDF;
     7 |- P1 o. j! p) t
590.         }
     
591.                
     
592.         status = PcdSelect(SN);                                 /*选卡*/
     ( y# W3 Y/ v. I+ V- @# M) J( `
593.         if(status==MI_OK)
     
594.                 printf("选卡:成功\r\n");
     1 @: [: S6 E! S5 Y1 [9 S
595.         else
     
596.         {
     
597.                 printf("选卡:失败\r\n");
     
598.                 return 0XDF;
     
599.         }
     . U! K+ W# W% u0 ~' }
600.                
     7 H8 G% D% m9 c
601.         //PS:块地址17之前被强制性写入了杯子的型号(用另一个程序)
     
602.         status = PcdAuthState(PICC_AUTHENT1A,17,KEY,SN);        
     0 }( ?4 q) |8 c$ N1 @
603.         if(status==MI_OK)
     5 N/ Z( F7 I8 n) Q; y( h0 w3 u/ l
604.                 printf("密码校验:成功\r\n");
     $ Y' ]: @! T/ P  F
605.         else
     
606.         {
     5 }; }, p" u4 J1 F/ f2 g
607.                 printf("密码校验:失败\r\n");
     
608.                 return 0XDF;               
     0 J* D+ Q( y4 \; o$ }
609.         
     0 j/ {5 d. q4 e8 g' k
610.         }
     4 I% `6 p( |  `7 G4 }
611.                
     " ~, E/ R) Q  o. u  X
612.         status = PcdRead(17,pptr);
     
613.         
     
614.         if(status == MI_OK)
     
615.         {
     
616.                 return pptr[0];
     
617.                         
     
618.         }
     7 d7 x+ _  L3 Y) C$ v
619.         else
     
620.         {
     
621.           return 0XEF;
     7 u' v; x+ Y$ W+ u4 R
622.         }
     
623. 
       q/ a( C$ C3 W3 ~! q
624. 
     
625. }
     
626. 
     " S9 F) g- L7 H6 G+ Y' Z% n
627. /*写杯子类型1*/
     7 y& M3 X! p# O* R5 ^
628. u8 WriteCupType1(void)
     ; J2 r/ O, q% N( R
629. {
     
630. 
     2 C5 B3 u; P" A  O7 Q$ A
631.         u8 status;  
     
632.         u8 CUP1KEY[16]={0X01,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF};
     6 V2 [9 Y  l5 d& m$ G" b' M
633. 
     % @& ?# r% h  Q0 O- P; {
634.     AllCnt++;
     
635.         /*无卡次数，也就是非MI_OK的次数*/
     ! E' r) B( \( n
636.         status = PcdRequest(PICC_REQALL,CT);                    /*扫描卡  0 OK  2失败*/
     
637.         printf("%d%s",PICC_REQALL,CT);
     7 V# @5 k& w) w' w/ f
638.         if(status==MI_OK)
     
639.                 printf("寻卡状态:成功\r\n");
     
640.         else
     ) \. a6 K3 ^6 ^6 l0 O2 m1 X4 V0 R6 q
641.         {
     
642.                 printf("寻卡状态:失败\r\n");
     # K" m) d7 T8 |1 O4 U1 V1 }( n, n
643.                 return 0XDF;
     " k  ]/ i1 W; P1 j
644.         }
     " h0 D4 E4 i, j& {8 R
645.                
     3 b. b0 y: [- j+ y
646.         status = PcdAnticoll(SN);                               /*防冲撞*/
     $ R. _! ]* ?* K: d
647.         if(status==MI_OK)
     : [3 B! @% R( l8 T
648.                 printf("防冲撞:成功\r\n");
     * z$ H9 |1 s. `: Q) E$ q
649.         else
     1 Q; K+ J8 ?8 t5 r- k- u
650.         {
     * O( X; E7 |, f' @2 g- {
651.                 printf("防冲撞:失败\r\n");
     8 m4 Q8 i; }" U; R
652.                 return 0XDF;
     
653.         }
     + K3 K4 h* P, e! I) ~6 p
654.                
     " Y! b* N& M) k) V$ r
655.         status = PcdSelect(SN);                                 /*选卡*/
     ( e. H6 a4 L: h/ w5 D; P
656.         if(status==MI_OK)
     
657.                 printf("选卡:成功\r\n");
     
658.         else
     3 t3 @* p; I! O7 O# }$ ^* M
659.         {
     1 V. E! L+ A, e/ t& S
660.                 printf("选卡:失败\r\n");
       Z, l9 H+ p0 E: B. p
661.                 return 0XDF;
     $ O, V8 \6 S) t5 y1 y
662.         }
     
663.                
     
664.         //PS:块地址17之前被强制性写入了杯子的型号(用另一个程序)
     # r3 R; @& M4 I& K- n9 p/ _
665.         status = PcdAuthState(PICC_AUTHENT1A,17,KEY,SN);        
     7 r0 m: w7 a# |7 L. Y- K+ b0 P
666.         if(status==MI_OK)
     6 |) I6 K- }+ D! Y
667.                 printf("密码校验:成功\r\n");
     
668.         else
     * o% j. l# ?  m1 d0 U4 U
669.         {
     ( ~4 W) o- b: k3 A- O' F1 k
670.                 printf("密码校验:失败\r\n");
     
671.                 return 0XDF;               
     
672.         
     
673.         }
     % p: [* w: c) R4 N, u* E
674.                
     
675.         status = PcdWrite(17,CUP1KEY);
     
676.         printf("%S",CUP1KEY);
     
677.         if(status == MI_OK)
     3 ~3 p. b, y. q8 a: Z0 a: X& Y2 E
678.         {
     9 n% e( z3 J4 e
679.                 return MI_OK;
     
680.                         
     # _# S5 ~5 |0 U: N2 A4 w
681.         }
     
682.         else
     
683.         {
     
684.           return 0XEF;
     
685.         }
     / O" Y+ J' A5 i
686. }
     
687. /*写杯子类型2*/
     & g3 l- ^/ u5 g  O" F& A
688. u8 WriteCupType2(void)
     
689. {
     
690. 
     
691.         u8 status;  
       A; ]# }. w  f
692.         u8 CUP2KEY[16]={0X02,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF,0XFF};
     
693. 
     
694.     AllCnt++;
     1 R" D- w6 j0 |. l' [- _" e5 x
695.         /*无卡次数，也就是非MI_OK的次数*/
     
696.         status = PcdRequest(PICC_REQALL,CT);                    /*扫描卡  0 OK  2失败*/
     
697.         if(status==MI_OK)
     
698.                 printf("寻卡状态:成功\r\n");
     $ k2 D/ Q! }9 w6 |( P# c
699.         else
     2 f$ K" C+ R! M- P7 ?
700.         {
     
701.                 printf("寻卡状态:失败\r\n");
     3 H" T6 m' B2 v7 Z8 u7 l
702.                 return 0XDF;
     
703.         }
     
704.                
     
705.         status = PcdAnticoll(SN);                               /*防冲撞*/
     ' s- X* G2 r0 G* i  t: H5 W/ V+ R
706.         if(status==MI_OK)
     
707.                 printf("防冲撞:成功\r\n");
     ! x& I# k$ P9 x. I; D
708.         else
     6 W, q: j% J4 O6 u: P; R
709.         {
     
710.                 printf("防冲撞:失败\r\n");
     + x  h% T  a( @: g0 C
711.                 return 0XDF;
     6 U+ M5 w/ `4 t* {" g
712.         }
     
713.                
     & _8 [2 x0 q, u2 f2 l
714.         status = PcdSelect(SN);                                 /*选卡*/
     
715.         if(status==MI_OK)
     5 ?  J/ W3 r; `1 |" d" F5 \3 `
716.                 printf("选卡:成功\r\n");
     
717.         else
     
718.         {
     
719.                 printf("选卡:失败\r\n");
     & W1 |5 m8 p) I# V( Q
720.                 return 0XDF;
     
721.         }
     1 l% m9 V, t0 b
722.                
     ' a' X) O/ D+ C: G, U7 J" i7 S7 c
723.         //PS:块地址17之前被强制性写入了杯子的型号(用另一个程序)
     
724.         status = PcdAuthState(PICC_AUTHENT1A,17,KEY,SN);        
     - T! x& k2 ]. k3 J
725.         if(status==MI_OK)
     : ^) y0 v' m$ q$ ^1 n& E3 W
726.                 printf("密码校验:成功\r\n");
     , L# X4 F6 |( p) c8 B6 {" r  {
727.         else
     % ?1 |3 k8 _3 B# F/ `
728.         {
     # Y5 M% ~/ e1 k  F+ \- R$ e7 Q
729.                 printf("密码校验:失败\r\n");
     - G2 k2 I3 A$ M
730.                 return 0XDF;               
     
731.         
     + p: _$ ?+ D  e$ c( Z8 ?
732.         }
       G( j6 H: z0 F0 c  V% _
733.                
     ; X. ?4 N7 c( X3 ^
734.         status = PcdWrite(17,CUP2KEY);
     3 U, V7 v' G  R  D5 ~% ]8 s1 @
735.         
     
736.         if(status == MI_OK)
     
737.         {
     
738.                 return MI_OK;
     8 k# F% Y0 Y$ H  j
739.                         
     0 t7 C! h6 Q- a3 d. l
740.         }
     . m9 E; d6 ]8 }! M- W3 \
741.         else
     
742.         {
     / X: n5 N9 h+ e' a2 e" u
743.           return 0XEF;
     ; P5 Y' |. g2 [3 Q+ s/ L  \  J
744.         }
     
745. }
     0 f/ P8 m# l( Z2 x; ]
746. 
     : `1 u& k7 X+ m1 q( D2 [( M+ X! e. z
747. /////////////////////////////////////////////////////////////////////
     
748. //功    能：扣款和充值
     
749. //参数说明: dd_mode[IN]：命令字
     
750. //               0xC0 = 扣款
     4 e0 Q6 i5 l+ L! s" G+ L
751. //               0xC1 = 充值
     
752. //          addr[IN]：钱包地址
     . w4 z( {$ y4 t1 d2 a% p; i' ?
753. //          pValue[IN]：4字节增(减)值，低位在前
     ) j% l: y5 O: h3 Y  `) F
754. //返    回: 成功返回MI_OK
     
755. /////////////////////////////////////////////////////////////////////                 
     + x8 [. l. ^0 s
756. /*char PcdValue(u8 dd_mode,u8 addr,u8 *pValue)
     8 V4 k3 A) V0 D# W+ x$ l
757. {
     
758.     char status;
     
759.     u8  unLen;
     
760.     u8 ucComMF522Buf[MAXRLEN];
     
761.     //u8 i;
     8 g3 o5 ?( Q# s! s* h+ V( L: Z
762.         
       I& h6 v3 f4 T) J: O2 X$ J
763.     ucComMF522Buf[0] = dd_mode;
     5 T1 w5 p3 L- s. L) l* l0 l8 B2 c% o
764.     ucComMF522Buf[1] = addr;
     
765.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     0 \/ O5 U: u- J" }3 ?* w$ G
766. 
     3 Y* Q5 ~9 y; Z5 E
767.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     7 ?" J1 D- [& l  C/ [
768. 
     
769.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     
770.     {   status = MI_ERR;   }
     ' [) P+ ~9 F- O* Y2 f
771.         
     ( z$ I  G! i8 a# A5 p
772.     if (status == MI_OK)
     
773.     {
     
774.         memcpy(ucComMF522Buf, pValue, 4);
     $ A+ Y. U6 L& H' }5 J$ @
775.         //for (i=0; i<16; i++)
     & I) I" W% G6 ]* O3 A6 r
776.         //{    ucComMF522Buf[i] = *(pValue+i);   }
     ! q+ |. ^7 V% V9 h+ J- N* ]
777.         CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);
     
778.         unLen = 0;
     % ~1 x7 `" m+ |/ [: j
779.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
     : ?2 Y+ l! k. Q
780.                 if (status != MI_ERR)
     
781.         {    status = MI_OK;    }
     
782.     }
     
783.    
     - D% \* n& u  }% Z: P" D$ j/ p) Y5 ~
784.     if (status == MI_OK)
     
785.     {
     ( h2 |2 l  q7 v' A
786.         ucComMF522Buf[0] = PICC_TRANSFER;
     8 s( V$ Y9 {4 D% c$ u3 P: N
787.         ucComMF522Buf[1] = addr;
     9 @/ x+ Z( {' r/ O; F; `2 K
788.         CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
789.    
     , T8 W+ }# m, e. G$ l: k% m
790.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
791. 
     9 q% }  t9 ]3 j2 h: M( o
792.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     # J/ K8 e9 o% t6 {8 O6 d- V) s
793.         {   status = MI_ERR;   }
     
794.     }
     
795.     return status;
     $ _$ `) L  z7 a, P) D
796. }*/
     
797. 
     
798. /////////////////////////////////////////////////////////////////////
     
799. //功    能：备份钱包
     
800. //参数说明: sourceaddr[IN]：源地址
     ( r  @, @- ?- ~7 g+ `
801. //          goaladdr[IN]：目标地址
     8 }0 k! n; M; b" S0 r
802. //返    回: 成功返回MI_OK
     + Q) }: N+ y! q8 h' R
803. /////////////////////////////////////////////////////////////////////
     
804. /*char PcdBakValue(u8 sourceaddr, u8 goaladdr)
     
805. {
     
806.     char status;
     ' w9 J1 ~5 X' e% U
807.     u8  unLen;
     
808.     u8 ucComMF522Buf[MAXRLEN];
     
809. 
     5 K. b$ }4 C. a% P* y6 U8 ~5 h
810.     ucComMF522Buf[0] = PICC_RESTORE;
     
811.     ucComMF522Buf[1] = sourceaddr;
     # B9 W6 ?$ U( t6 p
812.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     & i6 ^; U4 z2 V; k
813. 
     
814.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     9 R5 H: V# H' \$ K) S1 F
815. 
     ' ~/ l0 U! `$ n2 w7 K: O3 ~8 [
816.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     ) ~7 u0 o, l  S/ D. N9 x4 l; B
817.     {   status = MI_ERR;   }
     3 X2 }; [, W* H* [) Z$ Z
818.    
     " j: k6 V: j+ [5 P
819.     if (status == MI_OK)
       p8 X0 G0 m0 B7 Q- m
820.     {
     
821.         ucComMF522Buf[0] = 0;
     
822.         ucComMF522Buf[1] = 0;
     
823.         ucComMF522Buf[2] = 0;
     
824.         ucComMF522Buf[3] = 0;
     
825.         CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);
     
826. 
     
827.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
     
828.                 if (status != MI_ERR)
     2 \4 F# _9 }, n' i
829.         {    status = MI_OK;    }
     5 m0 Y, I  u4 k* h& _8 c; y: a
830.     }
     
831.    
     
832.     if (status != MI_OK)
     # Q* t0 S: K% X; f
833.     {    return MI_ERR;   }
     
834.    
     
835.     ucComMF522Buf[0] = PICC_TRANSFER;
     
836.     ucComMF522Buf[1] = goaladdr;
     
837. 
     ! M8 Z5 r& ^1 a" `% `" U, O
838.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
839. 
     
840.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     , J6 i& m! T6 W0 v& Q8 N
841. 
     # b6 z1 J* V' Y& M/ O, K
842.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     0 N: K8 \1 U# h4 D& W. `
843.     {   status = MI_ERR;   }
     
844. 
     
845.     return status;
     1 F# ]/ [8 n2 [& w) Z$ Q: d
846. }*/
     

复制代码

通过串口来读写RF卡(仅块地址17)：
指令：SS11PP  //查询杯子RFID型号
5 ~9 R5 S( L1 e& g0 T  L指令：SS22PP  //强制写杯子RFID卡为型号1
指令：SS22PP  //强制写杯子RFID卡为型号2

& b6 M/ S- t: ?% C- q+ M; ~编译下载，通过串口操作(S50卡放读写模块上)：

! v5 ~# v# f6 Y  W好了，简单的分析就到这了~大神勿喷~感谢观看~
  Q: j. b% r6 Q7 U+ [代码：
STM32F103RBT6_RC522_NFC_DEMO.rar (511.74 KB, 下载次数: 6)

2021-9-14 13:44 上传

点击文件名下载附件



, d  z$ C/ }; {5 t8 e* e. G