今天，我们抽空来弄下STM32F103RBT6通过SPI方式驱动RC522  NFC模块读写S50复旦卡~
5 w3 U3 @9 M9 p4 U" o" M一个简单的下例子，NFC的应用在生活中随处可见了。我们这里的假设应用场景是在不同杯子
底部粘上复旦卡，来辨别不同的杯子TYPE型号~这里仅对块地址17的第一个字节进行判断！
3 ^& n1 W: L7 ~( M6 f' w8 R复旦卡就是常见的那种门禁卡钥匙扣形状的：

) S( `& D' G  d$ k7 w主板用自制的STM32F103RBT6的一个小板:
* x; R. O2 Y: L
. _' l! W+ ?' z) W下载器用CMSIS DAP 带串口的：
3 x8 n% O2 j! U2 \0 C* P# K
好，下面开始接线：

接好线的图：

1 m4 y7 Q0 a" s  o3 D. `% A3 CSTM32F103RBT6 和RC522 及S50复旦卡就不多说了，网上大把资料。
上程序：
spi.h

1. #ifndef __SPI_H
   
2. #define __SPI_H
   ; a) R7 w  \9 h2 K( t' A
3. #include "sys.h"
   : p. \& ~  O: Q/ R  ]- E
4. 
   " W9 N. M6 Z( |* _4 B. l. V  C: y" h
5. 
   
6. //#define RC522_RST                   PCout(7)
   
7. #define RC522_RST                   PCout(7)       //测试后恢复PCout(7)
   8 Y, H2 ~9 V% o0 z' W5 i, k
8. #define RC522_CS        PBout(9)
   / S  x) ?5 |0 [/ N
9. #define SPIReadByte()          SPIWriteByte(0)
   / N7 k" T% d. _7 m( ?
10. // SPI总线速度设置
    
11. #define SPI_SPEED_2                   0
    & N2 I; f# q# I( s' N# c1 q, j2 D
12. #define SPI_SPEED_4                   1
    5 i. h# K8 ~' p! C+ h$ G
13. #define SPI_SPEED_8                   2
    : q4 |4 r* a/ y" w+ a/ J
14. #define SPI_SPEED_16                  3
    
15. #define SPI_SPEED_32                   4
    
16. #define SPI_SPEED_64                   5
    
17. #define SPI_SPEED_128                 6
    
18. #define SPI_SPEED_256                 7
    ( }8 D  W# T) l" {0 E  o
19.                                                                                                                                                                         
    : r8 P- F6 r; R( c% t% C' p
20. void SPI2_Init(void);                         //初始化SPI口
    
21. void SPI2_SetSpeed(u8 SpeedSet); //设置SPI速度   
    
22. u8 SPIWriteByte(u8 TxData);//SPI总线读写一个字节
    $ I" {' f1 l1 i( T4 [
23.                  
    ) a; g# D; w' l- X) u
24. #endif
    
25. 
    

复制代码

spi.c
) s% F4 `' N3 I) t" j* T

1. #include "spi.h"
   - @3 `& H2 h8 a4 @  R3 R
2. 
   + A: ~- s. f3 U& ^, N% L$ i
3. //这里针是对SPI2的初始化
   
4. void SPI2_Init(void)
   # M0 ^. _# y3 B, n) H
5. {         
   & k4 M# g7 {0 {% k
6.         RCC->APB2ENR|=1<<3;            //PORTB时钟使能
   # l& \5 \) G8 r: K+ l. M$ s
7.         RCC->APB2ENR|=1<<4;            //PORTC时钟使能
   + S( V6 z! M- h+ z
8.         RCC->APB1ENR|=1<<14;           //SPI2时钟使能
   
9.         GPIOB->CRH&=0XFFFFFF0F;         
   % x' v1 b+ Y$ Z
10.         GPIOB->CRH|=0X00000030;//PB.9 推挽输出
    + @  F- }; l, V' C0 u3 e! }2 k- r9 U
11.         GPIOC->CRL&=0X0FFFFFFF;         
    0 C. l% n; T0 ?0 ~4 ~& C
12.         GPIOC->CRL|=0X30000000;//PC. 7 推挽输出
    
13.         //        GPIOB->CRH&=0XFFFFFFF0;         
    
14.         //        GPIOB->CRH|=0X00000003;//PB. 8 推挽输出   此脚做测试用，测试完恢复PC7复位RFID功能
    ) n, e) p; P) \7 o1 G6 D1 v, f, U
15.         RC522_RST=1;             //RC522 复位脚置1
    # n1 z& t$ |' i8 z9 O  [6 l( Z
16.         RC522_CS=1;
    7 J* d# `% g  j! E2 q1 i
17. 
    
18. 
    
19.         //这里只针对SPI口初始化
    4 Y- i( f& o* Z- T5 y3 G& x% z
20.         GPIOB->CRH&=0X000FFFFF;
    * R4 r% V7 h9 W. f
21.         GPIOB->CRH|=0XBBB00000;        //PB13/14/15复用            
    
22.         GPIOB->ODR|=0X7<<13;           //PB13/14/15上拉
    
23.         SPI2->CR1|=0<<10;                //全双工模式        
    ) e9 H) E6 l; d( a. D* C, p8 s8 `
24.         SPI2->CR1|=1<<9;                 //软件nss管理
    # X1 s& o& ~* J6 q# t, c5 P
25.         SPI2->CR1|=1<<8;  
    , Y# E6 Q; k! A2 W5 ?9 O+ U' K
26. 
    ' a9 d9 Z7 C# o2 y# y6 t
27.         SPI2->CR1|=1<<2;                 //SPI主机
    7 |: T' Y! D/ O& \' P. T
28.         SPI2->CR1|=0<<11;                //8bit数据格式        
    
29.         SPI2->CR1|=1<<1;                 //空闲模式下SCK为1 CPOL=1
    6 B5 i6 t7 P! A8 B' Z; Y
30.         SPI2->CR1|=1<<0;                 //数据采样从第二个时间边沿开始,CPHA=1  
    
31.         //对SPI2属于APB1的外设.时钟频率最大为36M.
    
32.         SPI2->CR1|=3<<3;                 //Fsck=Fpclk1/256
    2 W0 Q6 P' X$ G
33.         SPI2->CR1|=0<<7;                 //MSBfirst   
    4 C; D2 r! i3 g0 L5 Y( R
34.         SPI2->CR1|=1<<6;                 //SPI设备使能
    
35.         SPI2_SetSpeed(5);        
    
36.         SPIWriteByte(0xff);//启动传输                 
    
37. }   
    
38. //SPI2速度设置函数
    
39. //SpeedSet:0~7
    
40. //SPI速度=fAPB2/2^(SpeedSet+1)
    $ d0 K: g, h( l% ~. v3 o& V" a
41. //fAPB2时钟一般为90Mhz
    
42. void SPI2_SetSpeed(u8 SpeedSet)
    : w8 a* j! J7 H) J/ q
43. {
    
44.         SpeedSet&=0X07;                        //限制范围
    9 m/ F( U8 W/ p$ K6 n
45.         SPI2->CR1&=0XFFC7;
    
46.         SPI2->CR1|=SpeedSet<<3;        //设置SPI5速度  
    % o2 \: L% _% n4 [
47.         SPI2->CR1|=1<<6;                 //SPI设备使能         
    
48. }
      P& D/ t! B) d4 m/ u% ]  G
49. //SPI2 读写一个字节
    
50. //TxData:要写入的字节
    
51. //返回值:读取到的字节
    
52. u8 SPIWriteByte(u8 TxData)
    9 \( \: v& k+ X# c* U
53. {                                          
    
54.         u16 retry=0;                                 
    % G% X3 z! b# E7 x6 x  e. i
55.         while((SPI2->SR&1<<1)==0)                //等待发送区空        
    
56.         {
    
57.                 retry++;
    
58.                 if(retry>=0XFFFE)return 0;         //超时退出
    / m% b7 m- v8 ^+ I# ~$ \
59.         }                          
    ) ]: b; K4 m1 k+ O2 O( T) X$ `
60.         SPI2->DR=TxData;                                   //发送一个byte
    9 G. F# J& C/ Z1 i4 m. g
61.         retry=0;
    " p- |: c* J0 e! X" r) i, I, y9 |
62.         while((SPI2->SR&1<<0)==0)                 //等待接收完一个byte  
    
63.         {
    * ?/ T! h$ p4 j" a) y; n
64.                 retry++;
    
65.                 if(retry>=0XFFFE)return 0;        //超时退出
    / \3 G" Y' k: b7 U$ {6 ^
66.         }                                                              
    
67.         return SPI2->DR;                          //返回收到的数据                           
      a5 d6 x0 U0 c2 i2 N# r8 V6 T2 a
68. }
    5 j2 C3 U' g( `9 M/ U
69. 
    9 f5 [4 X+ Y  b) o; e0 X2 g
70. 
    
71. 
    

复制代码

rc522.h
  W( I/ B- A$ W: s3 V" Q$ g

1. #ifndef _RC522_H_
   
2. #define _RC522_H_
   % s& K  ^- B$ p  w5 @0 L& g
3. 
   
4. #include <stm32f10x.h>
   6 R9 F8 Y: u( f6 p" l: [6 e
5. #include "sys.h"
   
6. #include "spi.h"
   
7. 
   # @% w8 e% H6 W- {% Z3 N2 h( }
8. 
   
9. extern u8 CupType;
   
10. 
    % ~6 R: T- o& p( Z- o  r/ X2 ^
11. 
    
12. /////////////////////////////////////////////////////////////////////
    ) T$ Q3 B/ \% t: ]% e& i- c) C* h
13. //MF522命令字
    
14. /////////////////////////////////////////////////////////////////////
    
15. #define PCD_IDLE              0x00               //取消当前命令
    
16. #define PCD_AUTHENT           0x0E               //验证密钥
    
17. #define PCD_RECEIVE           0x08               //接收数据
    ! }0 }3 \$ H5 [  n
18. #define PCD_TRANSMIT          0x04               //发送数据
    
19. #define PCD_TRANSCEIVE        0x0C               //发送并接收数据
    
20. #define PCD_RESETPHASE        0x0F               //复位
    1 q  {9 Z& X8 C( g9 H1 R+ `
21. #define PCD_CALCCRC           0x03               //CRC计算
    , Z% S& X  r) A3 z: ?
22. 
    
23. /////////////////////////////////////////////////////////////////////
    1 e$ Y4 S4 d/ s4 M8 L
24. //Mifare_One卡片命令字
    2 j9 ?1 {3 h) H3 u: l! Z! _
25. /////////////////////////////////////////////////////////////////////
    4 [' U' `  |& G) b
26. #define PICC_REQIDL           0x26               //寻天线区内未进入休眠状态
    + f  [6 B7 Q3 B8 ?
27. #define PICC_REQALL           0x52               //寻天线区内全部卡
    
28. #define PICC_ANTICOLL1        0x93               //防冲撞
    ! x) A$ {' L. w) f$ k  e6 o
29. #define PICC_ANTICOLL2        0x95               //防冲撞
    
30. #define PICC_AUTHENT1A        0x60               //验证A密钥
    ! z( I6 \# K4 T0 L' R/ }$ I
31. #define PICC_AUTHENT1B        0x61               //验证B密钥
    3 P9 t$ ~, H  ~1 m& z" @2 Y& T
32. #define PICC_READ             0x30               //读块
    * b" A/ z1 X# j" d
33. #define PICC_WRITE            0xA0               //写块
    
34. #define PICC_DECREMENT        0xC0               //扣款
    
35. #define PICC_INCREMENT        0xC1               //充值
    0 F& o4 r2 g6 |' T0 {
36. #define PICC_RESTORE          0xC2               //调块数据到缓冲区
    
37. #define PICC_TRANSFER         0xB0               //保存缓冲区中数据
    6 T0 A2 T' H5 z) ~
38. #define PICC_HALT             0x50               //休眠
    
39. 
      B9 W' V+ {2 h. I
40. /////////////////////////////////////////////////////////////////////
    
41. //MF522 FIFO长度定义
    
42. /////////////////////////////////////////////////////////////////////
    
43. #define DEF_FIFO_LENGTH       64                 //FIFO size=64byte
    
44. #define MAXRLEN  18
    0 f- X: ?1 P( N! ^# n& p7 Q' s' Q
45. 
    , D8 @+ [4 @7 K+ }& j  H7 X
46. /////////////////////////////////////////////////////////////////////
    ! c; z& B4 m2 m* T
47. //MF522寄存器定义
    
48. /////////////////////////////////////////////////////////////////////
    " b  Q3 h8 n1 q
49. // PAGE 0
      _6 Y$ u. b4 }0 g
50. #define     RFU00                 0x00   
    
51. #define     CommandReg            0x01   
    ; n3 Z0 h6 k4 x3 A( E3 r3 v
52. #define     ComIEnReg             0x02   
    ! F2 Z1 @; q) W, \3 v
53. #define     DivlEnReg             0x03   
    
54. #define     ComIrqReg             0x04   
    
55. #define     DivIrqReg             0x05
    
56. #define     ErrorReg              0x06   
    2 r+ z4 B0 A( c+ W6 q
57. #define     Status1Reg            0x07   
    
58. #define     Status2Reg            0x08   
    / `8 s& ^& ^* v, j7 v, T
59. #define     FIFODataReg           0x09
    9 `) }, X  b! n( E1 J4 @$ a
60. #define     FIFOLevelReg          0x0A
    ( l) h$ b( a5 o# i4 U8 b) ]  [9 x
61. #define     WaterLevelReg         0x0B
    
62. #define     ControlReg            0x0C
    
63. #define     BitFramingReg         0x0D
    9 |& j5 E0 T7 b6 s
64. #define     CollReg               0x0E
    2 G8 z6 B  j! g" h: D) U' K
65. #define     RFU0F                 0x0F
    
66. // PAGE 1     
    : Z- k& [' q2 `9 I* r
67. #define     RFU10                 0x10
    
68. #define     ModeReg               0x11
    
69. #define     TxModeReg             0x12
    
70. #define     RxModeReg             0x13
    
71. #define     TxControlReg          0x14
    
72. #define     TxAutoReg             0x15
    , Y$ _: w  a7 t/ O2 Z. ]! ?
73. #define     TxSelReg              0x16
    0 Q$ v$ l  Z5 Y0 Q
74. #define     RxSelReg              0x17
    
75. #define     RxThresholdReg        0x18
    
76. #define     DemodReg              0x19
    
77. #define     RFU1A                 0x1A
    
78. #define     RFU1B                 0x1B
      X5 [9 L. U% w$ ~5 [
79. #define     MifareReg             0x1C
    
80. #define     RFU1D                 0x1D
    
81. #define     RFU1E                 0x1E
    
82. #define     SerialSpeedReg        0x1F
    
83. // PAGE 2   
    " c7 y7 e/ N0 }' Z: z1 o1 T
84. #define     RFU20                 0x20  
    9 G/ v; m; o: F& {* W0 V
85. #define     CRCResultRegM         0x21
    
86. #define     CRCResultRegL         0x22
    ; ?  n) V& ]" _) r* }
87. #define     RFU23                 0x23
    : u3 E6 ?5 v- \* X4 v* a
88. #define     ModWidthReg           0x24
    . L* A& \) J1 m" \
89. #define     RFU25                 0x25
    
90. #define     RFCfgReg              0x26
    * p8 m( R3 O+ q
91. #define     GsNReg                0x27
    7 ?: P. h0 `2 V1 L7 {
92. #define     CWGsCfgReg            0x28
    
93. #define     ModGsCfgReg           0x29
    / X6 W  H5 R+ K1 l4 t) e: @' C
94. #define     TModeReg              0x2A
    4 C% b0 W2 R4 _3 f9 ~
95. #define     TPrescalerReg         0x2B
    
96. #define     TReloadRegH           0x2C
    + u' @7 p1 \+ k# d2 i  G9 e  F) }
97. #define     TReloadRegL           0x2D
    
98. #define     TCounterValueRegH     0x2E
    
99. #define     TCounterValueRegL     0x2F
    
100. // PAGE 3      
     
101. #define     RFU30                 0x30
     3 a& [: q3 r: k2 m9 f+ y
102. #define     TestSel1Reg           0x31
     1 \! x9 h% |% H- [' L
103. #define     TestSel2Reg           0x32
     % B7 |# s3 }; t# J5 u
104. #define     TestPinEnReg          0x33
     
105. #define     TestPinValueReg       0x34
     
106. #define     TestBusReg            0x35
     4 |4 k$ r$ L+ Z/ w2 z  K. q' N
107. #define     AutoTestReg           0x36
     
108. #define     VersionReg            0x37
     1 A& g& \6 S0 |8 C4 i
109. #define     AnalogTestReg         0x38
     
110. #define     TestDAC1Reg           0x39  
     
111. #define     TestDAC2Reg           0x3A   
     " B* z# u$ S# d* s) N: k
112. #define     TestADCReg            0x3B   
     
113. #define     RFU3C                 0x3C   
     - d3 z: R3 o9 g1 l. C! D
114. #define     RFU3D                 0x3D   
     5 a) u) E( @% o, ^
115. #define     RFU3E                 0x3E   
     . U2 }3 i$ v+ C+ p! ~
116. #define     RFU3F                                          0x3F
     * @  ?$ Q. |+ H" n
117. 
     * P1 _% ?  Z* j
118. /////////////////////////////////////////////////////////////////////
     : A, N2 X9 l! N: _
119. //和MF522通讯时返回的错误代码
     
120. /////////////////////////////////////////////////////////////////////
     0 I4 \8 |% H' b2 M6 p+ l" V" J
121. #define         MI_OK                 0
     2 E% q& r* c- D6 s" `
122. #define         MI_NOTAGERR           1
     9 v' l" U' }; w& k# k- [' K( f6 |0 W) ?
123. #define         MI_ERR                2
       [3 q- q4 s5 |2 j
124. 
     ) y2 g) X/ R6 x% P! ?, b
125. #define        SHAQU1        0X01
     3 q* V1 U7 ^0 `
126. #define        KUAI4        0X04
     : A; I2 ^( }; Z& ?8 x
127. #define        KUAI7        0X07
     
128. #define        REGCARD        0xa1
     
129. #define        CONSUME        0xa2
     
130. #define READCARD        0xa3
     9 H, N! {2 a, d( \5 T6 D  w
131. #define ADDMONEY        0xa4
     
132. 
     3 x4 T+ `% `5 I5 \2 w$ D
133. //
     3 t& |" p$ A; M. }6 ^  Z) ]
134. //#define  spi_cs 1;
     
135. //sbit  spi_ck=P0^6;
     
136. //sbit  spi_mosi=P0^7;
     - p/ G- F7 q; b
137. //sbit  spi_miso=P4^1;
     4 N) D/ V1 d- M2 G
138. //sbit  spi_rst=P2^7;
     8 s+ i/ ~& c6 s+ I' ~
139. #define SPIReadByte()        SPIWriteByte(0)
     & F5 s: ]! u0 w! c6 b4 h
140. //u8 SPIWriteByte(u8 byte);
     
141. //void SPI2_Init(void);
     
142. 
     4 b5 w3 N" Y9 \1 A6 ^% H) _& m
143. 
     
144. //#define MYRC522_CS   PAout(4)
     1 l7 ]! a4 N+ u! Q) A
145. //#define MYRC522_RST  PAout(6)
     . D' m* b* k4 @7 C4 l! S
146. 
     
147. 
     
148. 
     
149. void InitRc522(void);
     * l4 V2 W/ X" n5 L7 `0 j3 }
150. void ClearBitMask(u8   reg,u8   mask);
     
151. void WriteRawRC(u8   Address, u8   value);
     
152. void SetBitMask(u8   reg,u8   mask);
     
153. char PcdComMF522(u8   Command,
     
154.                  u8 *pIn ,
     
155.                  u8   InLenByte,
     % M5 W+ M9 J( k  b5 Z; L
156.                  u8 *pOut ,
     5 @/ _& S0 {; @, u. ?
157.                  u8  *pOutLenBit);
     % R5 w6 h) j7 n/ z- S1 g" ?
158. void CalulateCRC(u8 *pIn ,u8   len,u8 *pOut );
     
159. u8 ReadRawRC(u8   Address);
     
160. void PcdAntennaOn(void);
     % _/ t9 {$ }" k8 V
161. 
     ' `# Q, m+ E5 E$ w2 B' q
162. char PcdReset(void);
     6 ?' b/ ?, }  e. u
163. char PcdRequest(unsigned char req_code,unsigned char *pTagType);
     
164. void PcdAntennaOn(void);
     
165. void PcdAntennaOff(void);
     : s6 \  o: l7 O% N1 a
166. char M500PcdConfigISOType(unsigned char type);
     
167. char PcdAnticoll(unsigned char *pSnr);
     
168. char PcdSelect(unsigned char *pSnr);
     
169. char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr);
     
170. char PcdWrite(unsigned char addr,unsigned char *pData);
     # b4 |) N; s) J, ]
171. char PcdRead(unsigned char addr,unsigned char *pData);
     
172. char PcdHalt(void);
     , x4 W! R. P$ R' V5 H$ J; @
173. void Reset_RC522(void);
     ( A. k: z& y% w- r  M0 l0 {6 t- ]! N) S
174. u8 RfidTest(void);
     
175. u8 ReadCupType(void);
     ( B& G/ M% f' L0 {5 P
176. u8 WriteCupType1(void);
     
177. u8 WriteCupType2(void);
     
178. 
     / I* w9 i2 ^" t. X7 O
179. #endif
     : s1 D, ~  @/ q! ]% }

复制代码

rc522.c
# m+ p' _6 J0 Y/ u, k. K

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

复制代码

通过串口来读写RF卡(仅块地址17)：
指令：SS11PP  //查询杯子RFID型号
指令：SS22PP  //强制写杯子RFID卡为型号1
指令：SS22PP  //强制写杯子RFID卡为型号2

6 N& c, x7 X, t编译下载，通过串口操作(S50卡放读写模块上)：
; M; Y, |& i2 T
好了，简单的分析就到这了~大神勿喷~感谢观看~
代码：
STM32F103RBT6_RC522_NFC_DEMO.rar (511.74 KB, 下载次数: 4)

2021-9-14 13:44 上传

点击文件名下载附件
  e+ I" T/ F% ?. L2 C


1 C4 J; K, n9 R, a


$ o& U* @, {# R) ]+ n