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

主板用自制的STM32F103RBT6的一个小板:
) ^4 M1 Z9 q+ @8 K3 T' @8 ]$ l& b& M
: y% ~6 o% n* ]% N/ J5 l/ \/ ]- d下载器用CMSIS DAP 带串口的：

7 e6 N* a+ m) G2 [3 u: q6 {: M- T好，下面开始接线：
' @  M6 y8 A4 R) u
接好线的图：
3 ^5 f8 x' U( G1 a
; t- e- v1 ]* V# ^STM32F103RBT6 和RC522 及S50复旦卡就不多说了，网上大把资料。
上程序：
- E2 E* L& w) Wspi.h
' k! P9 K0 O6 m1 ?6 p4 N6 V, l

1. #ifndef __SPI_H
   
2. #define __SPI_H
   : H' T& Z5 P" ~1 f
3. #include "sys.h"
   
4. 
   
5. 
   . F+ R4 m+ D' N
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)
   ; Y+ `5 x$ g& W9 j0 Z* N
10. // SPI总线速度设置
    4 [  W4 U8 P, q/ ~+ }, S
11. #define SPI_SPEED_2                   0
    
12. #define SPI_SPEED_4                   1
    " `- F9 y% R7 Z' o- X+ m
13. #define SPI_SPEED_8                   2
    4 z9 D+ {* E* j: k( I% B
14. #define SPI_SPEED_16                  3
    , r' `, j" r$ @/ s! `
15. #define SPI_SPEED_32                   4
    6 j# @! j/ q- \" D
16. #define SPI_SPEED_64                   5
    
17. #define SPI_SPEED_128                 6
    7 I' |# h# o: C% j. Y
18. #define SPI_SPEED_256                 7
    
19.                                                                                                                                                                         
    
20. void SPI2_Init(void);                         //初始化SPI口
    % E- I8 x) h6 u& P
21. void SPI2_SetSpeed(u8 SpeedSet); //设置SPI速度   
    
22. u8 SPIWriteByte(u8 TxData);//SPI总线读写一个字节
    3 z! {, }. t+ x: _1 k; y
23.                  
    0 n1 j2 v& ^- K" y
24. #endif
    
25. 
    9 m7 S3 b# I% U4 D4 i7 k1 P

复制代码

spi.c
  ?. P7 X1 t# J0 w  B

1. #include "spi.h"
     g. [: Q! T9 n' W- `
2. 
   , |+ @! P0 O0 F. }, c5 L! o" F, ?
3. //这里针是对SPI2的初始化
   
4. void SPI2_Init(void)
   " N( |( F0 i* f8 `5 Z
5. {         
   
6.         RCC->APB2ENR|=1<<3;            //PORTB时钟使能
   
7.         RCC->APB2ENR|=1<<4;            //PORTC时钟使能
   
8.         RCC->APB1ENR|=1<<14;           //SPI2时钟使能
   
9.         GPIOB->CRH&=0XFFFFFF0F;         
   0 H) T( [# c0 E
10.         GPIOB->CRH|=0X00000030;//PB.9 推挽输出
    
11.         GPIOC->CRL&=0X0FFFFFFF;         
    
12.         GPIOC->CRL|=0X30000000;//PC. 7 推挽输出
    
13.         //        GPIOB->CRH&=0XFFFFFFF0;         
    : D1 V' q6 f+ Q$ P# S
14.         //        GPIOB->CRH|=0X00000003;//PB. 8 推挽输出   此脚做测试用，测试完恢复PC7复位RFID功能
    . N# D4 a% f. ]* s8 F
15.         RC522_RST=1;             //RC522 复位脚置1
    7 Q. s/ o5 V  m* @2 Z* v# N  ]
16.         RC522_CS=1;
    
17. 
    
18. 
    
19.         //这里只针对SPI口初始化
    1 U+ m9 {, Q( a# D
20.         GPIOB->CRH&=0X000FFFFF;
    
21.         GPIOB->CRH|=0XBBB00000;        //PB13/14/15复用            
    
22.         GPIOB->ODR|=0X7<<13;           //PB13/14/15上拉
    2 P% z& F2 ~) t1 P$ Q! ]
23.         SPI2->CR1|=0<<10;                //全双工模式        
    
24.         SPI2->CR1|=1<<9;                 //软件nss管理
    9 F% H: ^: J4 l+ d' C: P, _
25.         SPI2->CR1|=1<<8;  
    * v4 v# S2 H& `, v: p1 K8 \! H
26. 
    " }4 d) R" L, t( Y; O* Q# V
27.         SPI2->CR1|=1<<2;                 //SPI主机
    - }( _" w# z# V1 Z
28.         SPI2->CR1|=0<<11;                //8bit数据格式        
    
29.         SPI2->CR1|=1<<1;                 //空闲模式下SCK为1 CPOL=1
    : x5 \" I4 |) {3 ]
30.         SPI2->CR1|=1<<0;                 //数据采样从第二个时间边沿开始,CPHA=1  
    9 F, ~7 A/ P. i' E# d0 y
31.         //对SPI2属于APB1的外设.时钟频率最大为36M.
    , K' ]! ~6 U# w8 A/ R! o2 O
32.         SPI2->CR1|=3<<3;                 //Fsck=Fpclk1/256
    
33.         SPI2->CR1|=0<<7;                 //MSBfirst   
    + r4 i* y' e) A
34.         SPI2->CR1|=1<<6;                 //SPI设备使能
    
35.         SPI2_SetSpeed(5);        
    % [6 Z& x* m# c" e+ m7 x
36.         SPIWriteByte(0xff);//启动传输                 
    ' W8 |. t+ e/ w% n
37. }   
    8 ~4 O' \# S* U% T
38. //SPI2速度设置函数
    
39. //SpeedSet:0~7
    
40. //SPI速度=fAPB2/2^(SpeedSet+1)
    4 H& X7 j' F! ?; |: @
41. //fAPB2时钟一般为90Mhz
    " e) e" M9 Y+ _5 `
42. void SPI2_SetSpeed(u8 SpeedSet)
    
43. {
    
44.         SpeedSet&=0X07;                        //限制范围
    
45.         SPI2->CR1&=0XFFC7;
      d: y4 R; q6 J/ l. \
46.         SPI2->CR1|=SpeedSet<<3;        //设置SPI5速度  
    8 W( U- X% x& L2 p5 q3 y, q& Q
47.         SPI2->CR1|=1<<6;                 //SPI设备使能         
    . F! i+ ^. `+ \
48. }
    
49. //SPI2 读写一个字节
      M1 K( `  _7 L
50. //TxData:要写入的字节
    / F0 |+ z# A4 s+ k+ W7 C
51. //返回值:读取到的字节
    # L+ C4 Y* W/ B. H$ v
52. u8 SPIWriteByte(u8 TxData)
    
53. {                                          
    
54.         u16 retry=0;                                 
    
55.         while((SPI2->SR&1<<1)==0)                //等待发送区空        
    ' d& [% ]6 ~; k8 P" V- Y  M' S* v+ s
56.         {
    
57.                 retry++;
    
58.                 if(retry>=0XFFFE)return 0;         //超时退出
    
59.         }                          
    # w/ [  U5 A% V- z
60.         SPI2->DR=TxData;                                   //发送一个byte
    
61.         retry=0;
    
62.         while((SPI2->SR&1<<0)==0)                 //等待接收完一个byte  
    7 v3 {' s, ~* S# F
63.         {
    
64.                 retry++;
    ) }  s+ J; y5 z2 t7 J
65.                 if(retry>=0XFFFE)return 0;        //超时退出
    
66.         }                                                              
    
67.         return SPI2->DR;                          //返回收到的数据                           
    8 ^* M  L7 @. v. N& I& Q$ v
68. }
    5 Z; d& O6 E! }6 _' B& H5 c2 L) L
69. 
    6 @, H( C( q, J6 L7 Q$ i
70. 
    
71. 
    ) d* j/ ~# G- @! n6 t+ T

复制代码

rc522.h
! r3 u- H+ b' l0 s- F" u- N. u

1. #ifndef _RC522_H_
   4 r/ Z1 g- C. ^& X
2. #define _RC522_H_
   
3. 
   6 O' e% g# e0 E" K' \
4. #include <stm32f10x.h>
   
5. #include "sys.h"
   / s; c+ b* [* Y1 l9 x
6. #include "spi.h"
   
7. 
   
8. 
   6 o+ r3 Y2 t9 k  V
9. extern u8 CupType;
   
10. 
    . n0 E' p( U7 A9 `- g8 V. k
11. 
    - _" b/ y9 ^6 ^- Q8 Z# w' h' e& O7 }5 i
12. /////////////////////////////////////////////////////////////////////
    
13. //MF522命令字
    . {" E  u5 t- s7 l' W8 e0 L4 |- y  f
14. /////////////////////////////////////////////////////////////////////
    
15. #define PCD_IDLE              0x00               //取消当前命令
    ! E  v+ Z$ s* j" w" M
16. #define PCD_AUTHENT           0x0E               //验证密钥
    # c, l' l4 j1 b; B, ?! f' H
17. #define PCD_RECEIVE           0x08               //接收数据
    : B: X9 L  ]- I  f& U: H
18. #define PCD_TRANSMIT          0x04               //发送数据
    
19. #define PCD_TRANSCEIVE        0x0C               //发送并接收数据
    + R1 U2 D* h9 k: O( p
20. #define PCD_RESETPHASE        0x0F               //复位
    
21. #define PCD_CALCCRC           0x03               //CRC计算
    " ^, Q" b7 g" i
22. 
    ( V+ K' ]& z1 g5 {: ?4 k
23. /////////////////////////////////////////////////////////////////////
    ) o% Z8 h" D, p5 Y
24. //Mifare_One卡片命令字
    
25. /////////////////////////////////////////////////////////////////////
    $ ^5 `' ~: _; h, K- |
26. #define PICC_REQIDL           0x26               //寻天线区内未进入休眠状态
    ; g; c( |9 q! P( S
27. #define PICC_REQALL           0x52               //寻天线区内全部卡
    7 d' V% a  l% C% j0 q  }0 w* I
28. #define PICC_ANTICOLL1        0x93               //防冲撞
    & y" Y  m3 ^( ~* q) T+ |& X
29. #define PICC_ANTICOLL2        0x95               //防冲撞
    , |+ I4 S* H3 N7 X# r
30. #define PICC_AUTHENT1A        0x60               //验证A密钥
    4 D. e- g  q. `5 R# N
31. #define PICC_AUTHENT1B        0x61               //验证B密钥
    
32. #define PICC_READ             0x30               //读块
    
33. #define PICC_WRITE            0xA0               //写块
    
34. #define PICC_DECREMENT        0xC0               //扣款
    4 c6 }0 B  G- N! c9 e* e! F
35. #define PICC_INCREMENT        0xC1               //充值
    6 Y4 o4 ]! d2 a# v$ x5 z
36. #define PICC_RESTORE          0xC2               //调块数据到缓冲区
    ) C  ], U' B5 _+ W
37. #define PICC_TRANSFER         0xB0               //保存缓冲区中数据
    , [5 N' C( N% _/ x1 z/ |4 o
38. #define PICC_HALT             0x50               //休眠
    - q# Q% `1 v& \' j, j* q
39. 
    
40. /////////////////////////////////////////////////////////////////////
    
41. //MF522 FIFO长度定义
    
42. /////////////////////////////////////////////////////////////////////
    ) g# [, Y& R. e6 Z2 z* v) y
43. #define DEF_FIFO_LENGTH       64                 //FIFO size=64byte
    ( e7 }! {% b+ v4 {+ f/ k* F. d
44. #define MAXRLEN  18
    
45. 
    ) W& l; B0 q7 i: I2 @! `
46. /////////////////////////////////////////////////////////////////////
    
47. //MF522寄存器定义
      Q+ X0 g2 w! P: U
48. /////////////////////////////////////////////////////////////////////
    + V# M' ~  L: q' z2 Q: p
49. // PAGE 0
    
50. #define     RFU00                 0x00   
    
51. #define     CommandReg            0x01   
    
52. #define     ComIEnReg             0x02   
    
53. #define     DivlEnReg             0x03   
    1 x# f2 |: Y1 Y1 C7 W3 j9 W6 d' l
54. #define     ComIrqReg             0x04   
    9 _/ H2 r( P- v  E$ W# w) _8 M  Z
55. #define     DivIrqReg             0x05
    4 C6 J5 l* ~5 r2 S$ ?
56. #define     ErrorReg              0x06   
    
57. #define     Status1Reg            0x07   
    " @1 |0 u" l" O# v) o# X6 I# R
58. #define     Status2Reg            0x08   
    7 r' @' w3 W% }2 |' w, _
59. #define     FIFODataReg           0x09
    
60. #define     FIFOLevelReg          0x0A
    6 e! e( l* \8 D) i. v/ _) [$ \! m
61. #define     WaterLevelReg         0x0B
    . B! V1 _0 E7 t& j5 R
62. #define     ControlReg            0x0C
    6 m4 W2 d- }( G) I5 O  ?1 X" E
63. #define     BitFramingReg         0x0D
    5 u/ B6 Q9 C& {3 b% r, t/ m
64. #define     CollReg               0x0E
    " {7 z$ m) K2 h5 l, h: @/ f; Q1 j$ e
65. #define     RFU0F                 0x0F
    , F4 v4 X5 n) `0 w5 w6 h" F
66. // PAGE 1     
    + m& ~: p8 l) g1 @
67. #define     RFU10                 0x10
    7 x" G$ x. H/ e1 `6 E9 @
68. #define     ModeReg               0x11
    # g9 Z6 A) d8 R
69. #define     TxModeReg             0x12
    : e0 ^$ s* @( R+ ^1 m
70. #define     RxModeReg             0x13
    
71. #define     TxControlReg          0x14
    
72. #define     TxAutoReg             0x15
    9 i1 y- s! q. [2 |
73. #define     TxSelReg              0x16
    
74. #define     RxSelReg              0x17
    ; W/ @9 ]: d  @( ~; r7 |+ W
75. #define     RxThresholdReg        0x18
    
76. #define     DemodReg              0x19
    
77. #define     RFU1A                 0x1A
    
78. #define     RFU1B                 0x1B
    
79. #define     MifareReg             0x1C
    4 b, k. Y2 h  G3 O4 ~' E
80. #define     RFU1D                 0x1D
    3 k" |5 a8 v8 y" B8 h  C6 ~
81. #define     RFU1E                 0x1E
    
82. #define     SerialSpeedReg        0x1F
    9 \% \/ T* B; D2 A: @8 j
83. // PAGE 2   
    + A5 o& n0 \( [" d; ]5 U6 ?
84. #define     RFU20                 0x20  
    : s7 L: S) L" q7 s; s( l! t
85. #define     CRCResultRegM         0x21
    . E+ w/ d: R- l5 s: J/ U' l& q
86. #define     CRCResultRegL         0x22
    
87. #define     RFU23                 0x23
    ( f9 E& b9 b/ t) s& b- z/ p
88. #define     ModWidthReg           0x24
    
89. #define     RFU25                 0x25
    
90. #define     RFCfgReg              0x26
    9 D' ]5 U( M, Z' v; J9 \3 @
91. #define     GsNReg                0x27
    , r1 w. ^( g( I; y+ Q. ]" R2 @" {
92. #define     CWGsCfgReg            0x28
    
93. #define     ModGsCfgReg           0x29
    % M, p3 E9 J' b, w0 `5 E
94. #define     TModeReg              0x2A
    
95. #define     TPrescalerReg         0x2B
    
96. #define     TReloadRegH           0x2C
    / ^6 r3 V; A9 M4 u
97. #define     TReloadRegL           0x2D
    
98. #define     TCounterValueRegH     0x2E
    4 ]2 A# q0 v; r+ j' }# {: L
99. #define     TCounterValueRegL     0x2F
    . W* V* c8 r6 h  r+ i
100. // PAGE 3      
     / j$ @5 s% o1 _# G+ J
101. #define     RFU30                 0x30
     " T, x9 h8 j% f
102. #define     TestSel1Reg           0x31
     
103. #define     TestSel2Reg           0x32
     
104. #define     TestPinEnReg          0x33
     
105. #define     TestPinValueReg       0x34
     5 F; p; t1 y. c; S% |
106. #define     TestBusReg            0x35
     
107. #define     AutoTestReg           0x36
     
108. #define     VersionReg            0x37
     
109. #define     AnalogTestReg         0x38
     & d" I& E0 v. Q0 y9 t1 V! v. x0 a1 f  R
110. #define     TestDAC1Reg           0x39  
     $ s9 w* Z- v, e0 H
111. #define     TestDAC2Reg           0x3A   
     
112. #define     TestADCReg            0x3B   
     
113. #define     RFU3C                 0x3C   
     
114. #define     RFU3D                 0x3D   
     
115. #define     RFU3E                 0x3E   
     
116. #define     RFU3F                                          0x3F
     
117. 
     + G- t8 p1 X9 B* C: B$ F3 w
118. /////////////////////////////////////////////////////////////////////
     : E) B" X- q( R) y* Q
119. //和MF522通讯时返回的错误代码
     
120. /////////////////////////////////////////////////////////////////////
     
121. #define         MI_OK                 0
     ! @  `! c8 T8 z: ?( o4 Y
122. #define         MI_NOTAGERR           1
     
123. #define         MI_ERR                2
     
124. 
     
125. #define        SHAQU1        0X01
     
126. #define        KUAI4        0X04
     * L) c2 F9 a, C
127. #define        KUAI7        0X07
     ; p" l. ~( p" {' M( j
128. #define        REGCARD        0xa1
     * f6 r# T2 R+ c
129. #define        CONSUME        0xa2
     
130. #define READCARD        0xa3
     0 [% [4 X8 f: B0 q" F
131. #define ADDMONEY        0xa4
     
132. 
     
133. //
     - t$ Y& I& o9 p& @2 a) n
134. //#define  spi_cs 1;
     
135. //sbit  spi_ck=P0^6;
     2 M) O  a$ t+ G% Z( b/ m
136. //sbit  spi_mosi=P0^7;
     * E/ r1 q9 C* Y9 D/ ]( _$ l: W
137. //sbit  spi_miso=P4^1;
     & w! k" ^$ D7 D' _, x4 N* n
138. //sbit  spi_rst=P2^7;
     
139. #define SPIReadByte()        SPIWriteByte(0)
     - x# Z  X" N* o1 x: j
140. //u8 SPIWriteByte(u8 byte);
     
141. //void SPI2_Init(void);
     
142. 
     3 h  C; y! y8 X8 w* e0 A' U3 n' z
143. 
     
144. //#define MYRC522_CS   PAout(4)
     
145. //#define MYRC522_RST  PAout(6)
     $ ^0 P; _4 l/ L/ `0 I7 w! d) V
146. 
     . |, ~9 _2 M" L+ _! c
147. 
     ! E; W- q1 l( u) T; s
148. 
     
149. void InitRc522(void);
     & V' F" s8 b- F6 i5 b" G
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,
     8 w& r0 K! [  q0 g  h* o
154.                  u8 *pIn ,
     
155.                  u8   InLenByte,
     
156.                  u8 *pOut ,
     7 |. C5 c. X5 J
157.                  u8  *pOutLenBit);
     
158. void CalulateCRC(u8 *pIn ,u8   len,u8 *pOut );
     
159. u8 ReadRawRC(u8   Address);
     
160. void PcdAntennaOn(void);
     
161. 
     
162. char PcdReset(void);
     
163. char PcdRequest(unsigned char req_code,unsigned char *pTagType);
     " F* x# U) X( k; u$ @1 }
164. void PcdAntennaOn(void);
       k) r6 S' z% Q1 F8 H; T" l1 `
165. void PcdAntennaOff(void);
     ; r* P0 z4 c- y; w3 `7 M5 G
166. char M500PcdConfigISOType(unsigned char type);
     & _7 ~, Q* W/ e* k
167. char PcdAnticoll(unsigned char *pSnr);
     : y/ q) e/ A* S' i/ M3 I
168. char PcdSelect(unsigned char *pSnr);
     ( E2 Y& b: u  |* Z2 b, H7 {
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);
     3 H4 x* Y! q4 c& a# u. }
172. char PcdHalt(void);
     7 q* s/ Z6 O4 M6 l9 G) z
173. void Reset_RC522(void);
     * Z1 I; E9 g: B; a6 n. o
174. u8 RfidTest(void);
     3 C& ?5 g) P/ g' A, q2 }, d0 ~
175. u8 ReadCupType(void);
     4 i" ~( c$ x9 c# Q+ [3 h
176. u8 WriteCupType1(void);
     7 x& E: ?3 Z9 p2 L7 m* `7 a* V
177. u8 WriteCupType2(void);
     . f3 B# ^* ?: e5 W3 ?# R
178. 
     
179. #endif
     

复制代码

rc522.c
) q: @7 i* j4 m  }

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

复制代码

通过串口来读写RF卡(仅块地址17)：
指令：SS11PP  //查询杯子RFID型号
指令：SS22PP  //强制写杯子RFID卡为型号1
指令：SS22PP  //强制写杯子RFID卡为型号2
& p; s# O1 p! t
编译下载，通过串口操作(S50卡放读写模块上)：

5 O7 [, a$ C% B3 O好了，简单的分析就到这了~大神勿喷~感谢观看~
代码：
, R5 S2 t  i8 C4 M STM32F103RBT6_RC522_NFC_DEMO.rar (511.74 KB, 下载次数: 4)

2021-9-14 13:44 上传

点击文件名下载附件




4 i) Z  N, q  n% u$ Z" v% h

4 d4 M2 d( S& Y! x" ]% r4 [2 O