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

主板用自制的STM32F103RBT6的一个小板:
4 m5 `4 d3 Q3 b% m
下载器用CMSIS DAP 带串口的：

+ M" Q. x+ q9 ^- H8 Q4 r! S好，下面开始接线：

" S) N) M* B# g( X. u* T接好线的图：

STM32F103RBT6 和RC522 及S50复旦卡就不多说了，网上大把资料。
上程序：
% K, x/ d6 S( M& Wspi.h

1. #ifndef __SPI_H
   ) U0 V0 c' v' `( k' u9 }% ]
2. #define __SPI_H
   0 f& `. P. b3 ^# V2 ?6 o
3. #include "sys.h"
   # i1 z) K2 C2 I- D. s' z, v, m
4. 
   
5. 
   2 |' ?1 k+ @( e. @, k9 ?
6. //#define RC522_RST                   PCout(7)
   
7. #define RC522_RST                   PCout(7)       //测试后恢复PCout(7)
   
8. #define RC522_CS        PBout(9)
   
9. #define SPIReadByte()          SPIWriteByte(0)
   : U* U, u! F. i& A  n/ z
10. // SPI总线速度设置
    
11. #define SPI_SPEED_2                   0
    
12. #define SPI_SPEED_4                   1
    . `5 g' A# S) r5 P* E0 d% m
13. #define SPI_SPEED_8                   2
    
14. #define SPI_SPEED_16                  3
    
15. #define SPI_SPEED_32                   4
    
16. #define SPI_SPEED_64                   5
    2 W' ^+ D5 p3 H' M& z% \! [
17. #define SPI_SPEED_128                 6
    
18. #define SPI_SPEED_256                 7
    3 V3 J- r9 H. O) J/ z7 ^. ]/ x
19.                                                                                                                                                                         
    + g3 h- J) m8 z0 i! w" K
20. void SPI2_Init(void);                         //初始化SPI口
    ' u  m1 e- s! ~: V: M4 o
21. void SPI2_SetSpeed(u8 SpeedSet); //设置SPI速度   
    ! o" ~8 u3 B) l2 p
22. u8 SPIWriteByte(u8 TxData);//SPI总线读写一个字节
    
23.                  
    8 Q/ c' t# c: `, M1 {  S$ t
24. #endif
    ! N0 b! o( W% Y) R6 S+ W# Z
25. 
    

复制代码

spi.c

1. #include "spi.h"
   
2. 
   + L: a; o/ M7 J: k3 _7 U
3. //这里针是对SPI2的初始化
   
4. void SPI2_Init(void)
   
5. {         
   
6.         RCC->APB2ENR|=1<<3;            //PORTB时钟使能
   5 H) N  t! J) q3 r* H0 M  y' Q
7.         RCC->APB2ENR|=1<<4;            //PORTC时钟使能
   % V2 {8 |9 j0 P
8.         RCC->APB1ENR|=1<<14;           //SPI2时钟使能
   & e, I0 d+ H) m* @/ [; I0 Q) z8 k
9.         GPIOB->CRH&=0XFFFFFF0F;         
   $ \% T& M& R) C9 G7 L2 i
10.         GPIOB->CRH|=0X00000030;//PB.9 推挽输出
    6 n3 d  T8 {1 K; F. D; j1 i
11.         GPIOC->CRL&=0X0FFFFFFF;         
    
12.         GPIOC->CRL|=0X30000000;//PC. 7 推挽输出
    0 G. X* Y* w% K) U" I) J
13.         //        GPIOB->CRH&=0XFFFFFFF0;         
    # {9 U# t- p, C8 ]) W3 N
14.         //        GPIOB->CRH|=0X00000003;//PB. 8 推挽输出   此脚做测试用，测试完恢复PC7复位RFID功能
    , _, y) O1 ^, ^+ S" [* e4 w
15.         RC522_RST=1;             //RC522 复位脚置1
    8 `$ M% V9 U- p& f( H; T$ F
16.         RC522_CS=1;
    
17. 
    . r8 d1 C0 q3 [
18. 
    
19.         //这里只针对SPI口初始化
    
20.         GPIOB->CRH&=0X000FFFFF;
    
21.         GPIOB->CRH|=0XBBB00000;        //PB13/14/15复用            
    ( ]7 F, D8 ]* U9 l
22.         GPIOB->ODR|=0X7<<13;           //PB13/14/15上拉
    . u$ W1 y$ @7 m
23.         SPI2->CR1|=0<<10;                //全双工模式        
    
24.         SPI2->CR1|=1<<9;                 //软件nss管理
    
25.         SPI2->CR1|=1<<8;  
    
26. 
    * Q" \- m8 q0 {# i
27.         SPI2->CR1|=1<<2;                 //SPI主机
    , d8 L, M4 z! N! q+ R6 d5 o7 b
28.         SPI2->CR1|=0<<11;                //8bit数据格式        
    # d# W% I) T8 H
29.         SPI2->CR1|=1<<1;                 //空闲模式下SCK为1 CPOL=1
    / t7 C, {( r+ ~6 T6 F+ t# ?
30.         SPI2->CR1|=1<<0;                 //数据采样从第二个时间边沿开始,CPHA=1  
    
31.         //对SPI2属于APB1的外设.时钟频率最大为36M.
    
32.         SPI2->CR1|=3<<3;                 //Fsck=Fpclk1/256
    2 x; O9 z6 H1 I- b, v' l
33.         SPI2->CR1|=0<<7;                 //MSBfirst   
    0 C; E* |5 i7 l: }" n
34.         SPI2->CR1|=1<<6;                 //SPI设备使能
    4 j3 Z; q! b* ?) h2 g7 z
35.         SPI2_SetSpeed(5);        
    
36.         SPIWriteByte(0xff);//启动传输                 
    
37. }   
    ( W2 u* w/ W; a- w$ u
38. //SPI2速度设置函数
    
39. //SpeedSet:0~7
    3 {, E: g: h  X0 ]2 w& Z
40. //SPI速度=fAPB2/2^(SpeedSet+1)
    
41. //fAPB2时钟一般为90Mhz
    
42. void SPI2_SetSpeed(u8 SpeedSet)
    . _. P* T& P  Q# V! `/ A4 z
43. {
    
44.         SpeedSet&=0X07;                        //限制范围
    
45.         SPI2->CR1&=0XFFC7;
    0 S* p8 S- ]/ V7 S1 x- |
46.         SPI2->CR1|=SpeedSet<<3;        //设置SPI5速度  
    
47.         SPI2->CR1|=1<<6;                 //SPI设备使能         
    
48. }
    7 a% i/ D: `  v* p& ^8 N5 e+ o
49. //SPI2 读写一个字节
    
50. //TxData:要写入的字节
    
51. //返回值:读取到的字节
    
52. u8 SPIWriteByte(u8 TxData)
    
53. {                                          
    ) C' |5 k) U$ X1 u! v
54.         u16 retry=0;                                 
    , y$ g. w3 t4 ~8 J  D  j
55.         while((SPI2->SR&1<<1)==0)                //等待发送区空        
    % h7 S$ v) d* I( x) k+ O
56.         {
    3 v# S% x6 X% I9 q4 b( H
57.                 retry++;
    6 X  \" Z( u, a; p7 _' v
58.                 if(retry>=0XFFFE)return 0;         //超时退出
    
59.         }                          
    
60.         SPI2->DR=TxData;                                   //发送一个byte
    7 w+ h! y: U6 R. N4 e+ q6 f- ^5 c
61.         retry=0;
    2 e' C6 H4 T% B8 R  }
62.         while((SPI2->SR&1<<0)==0)                 //等待接收完一个byte  
    0 |5 D3 L: I" N) A2 n
63.         {
    
64.                 retry++;
    ( I: L( P, m. E  J) S
65.                 if(retry>=0XFFFE)return 0;        //超时退出
    
66.         }                                                              
    
67.         return SPI2->DR;                          //返回收到的数据                           
    7 }5 p, G' v: t9 t/ f# j0 X6 ~
68. }
    + ^) {6 U6 H: Z7 p; e
69. 
    $ t8 c( y4 v% P: a
70. 
    % i/ b" r/ j, O% h+ ~; r% U+ A2 Q' h
71. 
    , }0 Z, {. V  |: Q* e

复制代码

rc522.h
& X4 ~* P" a" C/ B" _

1. #ifndef _RC522_H_
   6 w9 H7 x" a( j. v% G! I# I% O
2. #define _RC522_H_
   
3. 
   ' ~3 b/ D1 W8 j% [
4. #include <stm32f10x.h>
   ; ~3 m( [, R7 t( r( |; X# a7 M
5. #include "sys.h"
   
6. #include "spi.h"
   0 U4 T0 |2 G5 m: |. ^& G
7. 
   ' E/ m' @" Y+ H1 W4 ~0 o$ W
8. 
   
9. extern u8 CupType;
   
10. 
    ) T# j0 ?* N* s1 A
11. 
    $ }2 v- @" B4 Y9 T4 d# c
12. /////////////////////////////////////////////////////////////////////
    
13. //MF522命令字
    
14. /////////////////////////////////////////////////////////////////////
    6 d+ L* S: O9 m! b% _
15. #define PCD_IDLE              0x00               //取消当前命令
    ! b5 }4 e) y& M; F1 ~# N& F7 ]8 S
16. #define PCD_AUTHENT           0x0E               //验证密钥
    
17. #define PCD_RECEIVE           0x08               //接收数据
    + I& V7 A; B) o) G) n0 m) q$ j
18. #define PCD_TRANSMIT          0x04               //发送数据
    # A) j/ }, F4 ]  B& O) W7 e
19. #define PCD_TRANSCEIVE        0x0C               //发送并接收数据
    
20. #define PCD_RESETPHASE        0x0F               //复位
    
21. #define PCD_CALCCRC           0x03               //CRC计算
    7 u0 @9 a- U1 ?& t( j' ^
22. 
    . j+ K  c8 ]0 u- h4 ]% T8 D3 h
23. /////////////////////////////////////////////////////////////////////
    ) |1 L! w9 U: ~2 q1 c0 R
24. //Mifare_One卡片命令字
    1 i) L# b8 j: k! C* i1 ~. W* t+ M
25. /////////////////////////////////////////////////////////////////////
    9 h3 Q) e+ I; B* C, ~, Y% c5 ?% e& S
26. #define PICC_REQIDL           0x26               //寻天线区内未进入休眠状态
    
27. #define PICC_REQALL           0x52               //寻天线区内全部卡
    % M4 g7 r! }9 l
28. #define PICC_ANTICOLL1        0x93               //防冲撞
    
29. #define PICC_ANTICOLL2        0x95               //防冲撞
    * K4 a/ w6 {1 Z5 @* R+ @' ~
30. #define PICC_AUTHENT1A        0x60               //验证A密钥
    
31. #define PICC_AUTHENT1B        0x61               //验证B密钥
    
32. #define PICC_READ             0x30               //读块
    * R9 ], I# |8 V7 ~# h/ w0 `3 {
33. #define PICC_WRITE            0xA0               //写块
    6 j2 Z2 [; m- K* F# r3 `
34. #define PICC_DECREMENT        0xC0               //扣款
    
35. #define PICC_INCREMENT        0xC1               //充值
    
36. #define PICC_RESTORE          0xC2               //调块数据到缓冲区
    ! H9 `* y3 s0 ~+ {- c( x: n4 P
37. #define PICC_TRANSFER         0xB0               //保存缓冲区中数据
    
38. #define PICC_HALT             0x50               //休眠
    
39. 
    9 q. m+ D7 I, h: _4 b' `) B8 X
40. /////////////////////////////////////////////////////////////////////
    # s) M8 {6 C+ X9 |* `$ S
41. //MF522 FIFO长度定义
    
42. /////////////////////////////////////////////////////////////////////
    * n: J. C8 l+ [! a
43. #define DEF_FIFO_LENGTH       64                 //FIFO size=64byte
    
44. #define MAXRLEN  18
    3 {9 y  W: H  b
45. 
    
46. /////////////////////////////////////////////////////////////////////
    
47. //MF522寄存器定义
    4 B6 o. z' r. C8 B; ~
48. /////////////////////////////////////////////////////////////////////
    
49. // PAGE 0
      l8 @: d$ ]9 j& f6 c: E+ f3 U$ Y
50. #define     RFU00                 0x00   
    
51. #define     CommandReg            0x01   
    
52. #define     ComIEnReg             0x02   
    
53. #define     DivlEnReg             0x03   
    
54. #define     ComIrqReg             0x04   
    
55. #define     DivIrqReg             0x05
    
56. #define     ErrorReg              0x06   
    
57. #define     Status1Reg            0x07   
    6 d) d" v$ {1 o* v& q
58. #define     Status2Reg            0x08   
    
59. #define     FIFODataReg           0x09
    1 o' B7 g& j2 U1 R
60. #define     FIFOLevelReg          0x0A
    
61. #define     WaterLevelReg         0x0B
    + B: N6 T0 i) v. w" w) R. G% N
62. #define     ControlReg            0x0C
    1 r% |: N1 D) a$ c$ _2 A6 N# d
63. #define     BitFramingReg         0x0D
    
64. #define     CollReg               0x0E
    
65. #define     RFU0F                 0x0F
    
66. // PAGE 1     
    7 t! Y9 @6 d2 C, I! x% l3 z
67. #define     RFU10                 0x10
    / u2 i6 m* X+ N0 Z, d* l3 y, n/ d5 Q
68. #define     ModeReg               0x11
    
69. #define     TxModeReg             0x12
    6 e2 k5 I/ [1 B4 c% i
70. #define     RxModeReg             0x13
    / k  D  U8 T0 Y2 q
71. #define     TxControlReg          0x14
    
72. #define     TxAutoReg             0x15
    " L" T; C% g- H2 z' X
73. #define     TxSelReg              0x16
    
74. #define     RxSelReg              0x17
    
75. #define     RxThresholdReg        0x18
    
76. #define     DemodReg              0x19
    $ e& t6 @( z6 M6 P  e  i+ h$ o. Z3 l- a
77. #define     RFU1A                 0x1A
    & z( ^* J0 @1 z* `- v. f  r1 ]6 l
78. #define     RFU1B                 0x1B
    
79. #define     MifareReg             0x1C
    8 ?2 r3 I, P+ c# T- i
80. #define     RFU1D                 0x1D
    . q9 H* P' s' ~) V+ W" m
81. #define     RFU1E                 0x1E
    $ P4 L! }$ n- @, n- R0 c' Z% `
82. #define     SerialSpeedReg        0x1F
    5 w, {- W4 {4 K7 C  ]6 _
83. // PAGE 2   
    
84. #define     RFU20                 0x20  
    8 M. k9 Z( I$ m
85. #define     CRCResultRegM         0x21
    0 ~" p$ }: }" G" x9 h
86. #define     CRCResultRegL         0x22
    & B0 L1 x3 w- |+ `- E# G( u  i9 E6 o6 C2 R
87. #define     RFU23                 0x23
    + H) d0 |; D+ g: {2 k. u$ Z
88. #define     ModWidthReg           0x24
    
89. #define     RFU25                 0x25
    & e8 l2 J! s, r
90. #define     RFCfgReg              0x26
    
91. #define     GsNReg                0x27
    
92. #define     CWGsCfgReg            0x28
    
93. #define     ModGsCfgReg           0x29
    
94. #define     TModeReg              0x2A
    
95. #define     TPrescalerReg         0x2B
    3 ~( B& `+ H- Z1 ?
96. #define     TReloadRegH           0x2C
    " z# @/ w, J* B8 I& M# T/ R1 c
97. #define     TReloadRegL           0x2D
    
98. #define     TCounterValueRegH     0x2E
    
99. #define     TCounterValueRegL     0x2F
    
100. // PAGE 3      
     
101. #define     RFU30                 0x30
     
102. #define     TestSel1Reg           0x31
     
103. #define     TestSel2Reg           0x32
     ! Z# G' C+ e1 n/ k
104. #define     TestPinEnReg          0x33
     
105. #define     TestPinValueReg       0x34
     6 C. ]9 F8 g! m( Y2 r
106. #define     TestBusReg            0x35
     
107. #define     AutoTestReg           0x36
       V  N/ P8 O9 m( g
108. #define     VersionReg            0x37
     
109. #define     AnalogTestReg         0x38
     
110. #define     TestDAC1Reg           0x39  
     
111. #define     TestDAC2Reg           0x3A   
     
112. #define     TestADCReg            0x3B   
     ; u+ c( R0 a* k( A& r) _
113. #define     RFU3C                 0x3C   
     # ]9 c" O, ~/ y8 d3 T' U- j
114. #define     RFU3D                 0x3D   
     
115. #define     RFU3E                 0x3E   
     + u% S& o) z4 M& d' a0 l1 t4 Z
116. #define     RFU3F                                          0x3F
     
117. 
     % d; F1 E$ l' x1 u1 j8 _" j. L, J
118. /////////////////////////////////////////////////////////////////////
     ; x6 |" j' W' N& e6 E
119. //和MF522通讯时返回的错误代码
     2 |2 S! p7 d/ W4 W
120. /////////////////////////////////////////////////////////////////////
       c' Q  `2 x1 j; g
121. #define         MI_OK                 0
     
122. #define         MI_NOTAGERR           1
     
123. #define         MI_ERR                2
     5 k8 v8 }2 |& w, U1 w+ ^5 N
124. 
     2 P* j; i% ?0 b% [3 f
125. #define        SHAQU1        0X01
     
126. #define        KUAI4        0X04
     
127. #define        KUAI7        0X07
     
128. #define        REGCARD        0xa1
     
129. #define        CONSUME        0xa2
     % H* p& I! }) k( X+ F
130. #define READCARD        0xa3
     
131. #define ADDMONEY        0xa4
     / C9 s7 N) A) m4 f. n' U- E' G
132. 
     
133. //
     6 ]9 h- L' f$ p( w
134. //#define  spi_cs 1;
     
135. //sbit  spi_ck=P0^6;
     0 f# r' P  F# K' ?# g
136. //sbit  spi_mosi=P0^7;
     
137. //sbit  spi_miso=P4^1;
     , C4 ^& \8 u1 v) q
138. //sbit  spi_rst=P2^7;
     
139. #define SPIReadByte()        SPIWriteByte(0)
     
140. //u8 SPIWriteByte(u8 byte);
     
141. //void SPI2_Init(void);
     ) M% D( ]7 C3 _; L' T
142. 
     
143. 
     
144. //#define MYRC522_CS   PAout(4)
       `& S1 M. m& ]- S& e
145. //#define MYRC522_RST  PAout(6)
     ' D' B' Y% \( D9 M( I( v" F
146. 
     
147. 
     " {! x6 ^0 X) W/ O' W$ W- C
148. 
     
149. void InitRc522(void);
     9 B/ s: r$ C3 y
150. void ClearBitMask(u8   reg,u8   mask);
     
151. void WriteRawRC(u8   Address, u8   value);
     
152. void SetBitMask(u8   reg,u8   mask);
     $ r" V1 c8 [3 ]+ E3 G4 U% ^
153. char PcdComMF522(u8   Command,
     
154.                  u8 *pIn ,
       @1 P+ f5 r% ^
155.                  u8   InLenByte,
     
156.                  u8 *pOut ,
     
157.                  u8  *pOutLenBit);
     
158. void CalulateCRC(u8 *pIn ,u8   len,u8 *pOut );
     ' j! b7 @9 M% Q1 f2 ~/ u- e
159. u8 ReadRawRC(u8   Address);
     
160. void PcdAntennaOn(void);
     
161. 
     ' v- y9 v  q% l4 K  O
162. char PcdReset(void);
     * c' f( _% I+ m" R2 Y
163. char PcdRequest(unsigned char req_code,unsigned char *pTagType);
     1 S* R# m3 l! }/ g. f
164. void PcdAntennaOn(void);
     3 x; T3 L3 U4 t
165. void PcdAntennaOff(void);
     
166. char M500PcdConfigISOType(unsigned char type);
     # e4 Q" R0 X" D
167. char PcdAnticoll(unsigned char *pSnr);
     , C1 }7 C. Z% Z
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);
     
171. char PcdRead(unsigned char addr,unsigned char *pData);
     : S9 x8 F5 f" |( O- s, i2 b7 ]& O
172. char PcdHalt(void);
     
173. void Reset_RC522(void);
     ' q, A& M% r) d# h% {9 }& ]# r
174. u8 RfidTest(void);
     
175. u8 ReadCupType(void);
     
176. u8 WriteCupType1(void);
     
177. u8 WriteCupType2(void);
     
178. 
     6 j# o  X. x0 R( y/ c3 I( I
179. #endif
     

复制代码

rc522.c

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

复制代码

通过串口来读写RF卡(仅块地址17)：
指令：SS11PP  //查询杯子RFID型号
: o2 G& D! b' C' }8 b1 U指令：SS22PP  //强制写杯子RFID卡为型号1
% R0 p; w' n; L指令：SS22PP  //强制写杯子RFID卡为型号2

编译下载，通过串口操作(S50卡放读写模块上)：
2 Y; V4 y) Z# _
9 G# Y2 a2 L' F/ y好了，简单的分析就到这了~大神勿喷~感谢观看~
3 J. ]' u( z6 @+ u" T  i代码：
& ]4 d/ M2 s; Z% p STM32F103RBT6_RC522_NFC_DEMO.rar (511.74 KB, 下载次数: 4)

2021-9-14 13:44 上传

点击文件名下载附件

! v  h+ V% i2 s4 f: N