标题: stm32 rc522射频模块程序 [打印本页]

---

作者: 优吧大神    时间: 2016-4-16 13:07
标题: stm32 rc522射频模块程序
射频模块程序：
RFID_RC522.zip (7.22 MB, 下载次数: 149)

2016-4-16 13:06 上传

点击文件名下载附件
下载积分: 黑币 -5

程序预览：

1. #include "sys.h"
   
2. #include "rc522.h"
   
3. #include "delay.h"
   
4. 
   
5. void delay_ns(u32 ns)
   
6. {
   
7.   u32 i;
   
8.   for(i=0;i<ns;i++)
   
9.   {
   
10.     __nop();
    
11.     __nop();
    
12.     __nop();
    
13.   }
    
14. }
    
15. 
    
16. u8 SPIWriteByte(u8 Byte)
    
17. {
    
18.         while((SPI2->SR&0X02)==0);                //等待发送区空          
    
19.         SPI2->DR=Byte;                             //发送一个byte   
    
20.         while((SPI2->SR&0X01)==0);      //等待接收完一个byte  
    
21.         return SPI2->DR;                      //返回收到的数据                       
    
22. }
    
23. 
    
24. //SPIx 读写一个字节
    
25. //TxData:要写入的字节
    
26. //返回值:读取到的字节
    
27. u8 SPI2_ReadWriteByte(u8 TxData)
    
28. {               
    
29.         u8 retry=0;                                        
    
30.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_TXE) == RESET) //检查指定的SPI标志位设置与否:发送缓存空标志位
    
31.                 {
    
32.                 retry++;
    
33.                 if(retry>200)return 0;
    
34.                 }                          
    
35.         SPI_I2S_SendData(SPI2, TxData); //通过外设SPIx发送一个数据
    
36.         retry=0;
    
37. 
    
38.         while (SPI_I2S_GetFlagStatus(SPI2, SPI_I2S_FLAG_RXNE) == RESET) //检查指定的SPI标志位设置与否:接受缓存非空标志位
    
39.                 {
    
40.                 retry++;
    
41.                 if(retry>200)return 0;
    
42.                 }                                                              
    
43.         return SPI_I2S_ReceiveData(SPI2); //返回通过SPIx最近接收的数据                                            
    
44. }
    
45. 
    
46. 
    
47. //SPI 速度设置函数
    
48. //SpeedSet:
    
49. //SPI_BaudRatePrescaler_2   2分频   
    
50. //SPI_BaudRatePrescaler_8   8分频   
    
51. //SPI_BaudRatePrescaler_16  16分频  
    
52. //SPI_BaudRatePrescaler_256 256分频
    
53.   
    
54. void SPI2_SetSpeed(u8 SPI_BaudRatePrescaler)
    
55. {
    
56.           assert_param(IS_SPI_BAUDRATE_PRESCALER(SPI_BaudRatePrescaler));
    
57.         SPI2->CR1&=0XFFC7;
    
58.         SPI2->CR1|=SPI_BaudRatePrescaler;        //设置SPI2速度
    
59.         SPI_Cmd(SPI2,ENABLE);
    
60. 
    
61. }
    
62. 
    
63. 
    
64. 
    
65. 
    
66. void SPI2_Init(void)       
    
67. {
    
68.         GPIO_InitTypeDef GPIO_InitStructure;
    
69.           SPI_InitTypeDef  SPI_InitStructure;
    
70.         RCC_APB2PeriphClockCmd(        RCC_APB2Periph_GPIOB|RCC_APB2Periph_GPIOF, ENABLE );//PORTB时钟使能
    
71.         RCC_APB1PeriphClockCmd(        RCC_APB1Periph_SPI2,  ENABLE );//SPI2时钟使能
    
72. 
    
73.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0|GPIO_Pin_1;         //IO-->PF0、PF1 端口配置
    
74.     GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;                  //推挽输出
    
75.     GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;                 //IO口速度为50MHz
    
76.     GPIO_Init(GPIOF, &GPIO_InitStructure);                                         //根据设定参数初始化PF0、PF1
    
77.     GPIO_ResetBits(GPIOF,GPIO_Pin_1);                                     //PF1输出低
    
78.     //GPIO_SetBits(GPIOF,GPIO_Pin_0);
    
79. 
    
80.         GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13 | GPIO_Pin_14 | GPIO_Pin_15;
    
81.         GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;  //PB13/14/15复用推挽输出
    
82.         GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    
83.         GPIO_Init(GPIOB, &GPIO_InitStructure);//初始化GPIOB
    
84. 
    
85.         GPIO_SetBits(GPIOB,GPIO_Pin_13|GPIO_Pin_14|GPIO_Pin_15);  //PB13/14/15上拉
    
86. 
    
87.         SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;  //设置SPI单向或者双向的数据模式:SPI设置为双线双向全双工
    
88.         SPI_InitStructure.SPI_Mode = SPI_Mode_Master;                //设置SPI工作模式:设置为主SPI
    
89.         SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;                //设置SPI的数据大小:SPI发送接收8位帧结构
    
90.         SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;                //串行同步时钟的空闲状态为低电平
    
91.         SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;        //串行同步时钟的第一个跳变沿（上升或下降）数据被采样
    
92.         SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;                //NSS信号由硬件（NSS管脚）还是软件（使用SSI位）管理:内部NSS信号有SSI位控制
    
93.         SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_256;                //定义波特率预分频的值:波特率预分频值为256
    
94.         SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;        //指定数据传输从MSB位还是LSB位开始:数据传输从MSB位开始
    
95.         SPI_InitStructure.SPI_CRCPolynomial = 7;        //CRC值计算的多项式
    
96.         SPI_Init(SPI2, &SPI_InitStructure);  //根据SPI_InitStruct中指定的参数初始化外设SPIx寄存器
    
97. 
    
98.         SPI_Cmd(SPI2, ENABLE); //使能SPI外设
    
99.        
    
100.         //SPI2_ReadWriteByte(0xff);//启动传输       
     
101. }
     
102. 
     
103. void InitRc522(void)
     
104. {
     
105.   SPI2_Init();
     
106.   PcdReset();
     
107.   PcdAntennaOff();
     
108.   delay_ms(2);  
     
109.   PcdAntennaOn();
     
110.   M500PcdConfigISOType( 'A' );
     
111. }
     
112. void Reset_RC522(void)
     
113. {
     
114.   PcdReset();
     
115.   PcdAntennaOff();
     
116.   delay_ms(2);  
     
117.   PcdAntennaOn();
     
118. }                        
     
119. /////////////////////////////////////////////////////////////////////
     
120. //功    能：寻卡
     
121. //参数说明: req_code[IN]:寻卡方式
     
122. //                0x52 = 寻感应区内所有符合14443A标准的卡
     
123. //                0x26 = 寻未进入休眠状态的卡
     
124. //          pTagType[OUT]：卡片类型代码
     
125. //                0x4400 = Mifare_UltraLight
     
126. //                0x0400 = Mifare_One(S50)
     
127. //                0x0200 = Mifare_One(S70)
     
128. //                0x0800 = Mifare_Pro(X)
     
129. //                0x4403 = Mifare_DESFire
     
130. //返    回: 成功返回MI_OK
     
131. /////////////////////////////////////////////////////////////////////
     
132. char PcdRequest(u8   req_code,u8 *pTagType)
     
133. {
     
134.         char   status;  
     
135.         u8   unLen;
     
136.         u8   ucComMF522Buf[MAXRLEN];
     
137. 
     
138.         ClearBitMask(Status2Reg,0x08);
     
139.         WriteRawRC(BitFramingReg,0x07);
     
140.         SetBitMask(TxControlReg,0x03);
     
141. 
     
142.         ucComMF522Buf[0] = req_code;
     
143. 
     
144.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,1,ucComMF522Buf,&unLen);
     
145. 
     
146.         if ((status == MI_OK) && (unLen == 0x10))
     
147.         {   
     
148.                 *pTagType     = ucComMF522Buf[0];
     
149.                 *(pTagType+1) = ucComMF522Buf[1];
     
150.         }
     
151.         else
     
152.         {   status = MI_ERR;   }
     
153.    
     
154.         return status;
     
155. }
     
156. 
     
157. /////////////////////////////////////////////////////////////////////
     
158. //功    能：防冲撞
     
159. //参数说明: pSnr[OUT]:卡片序列号，4字节
     
160. //返    回: 成功返回MI_OK
     
161. /////////////////////////////////////////////////////////////////////  
     
162. char PcdAnticoll(u8 *pSnr)
     
163. {
     
164.     char   status;
     
165.     u8   i,snr_check=0;
     
166.     u8   unLen;
     
167.     u8   ucComMF522Buf[MAXRLEN];
     
168.    
     
169. 
     
170.     ClearBitMask(Status2Reg,0x08);
     
171.     WriteRawRC(BitFramingReg,0x00);
     
172.     ClearBitMask(CollReg,0x80);
     
173. 
     
174.     ucComMF522Buf[0] = PICC_ANTICOLL1;
     
175.     ucComMF522Buf[1] = 0x20;
     
176. 
     
177.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,2,ucComMF522Buf,&unLen);
     
178. 
     
179.     if (status == MI_OK)
     
180.     {
     
181.              for (i=0; i<4; i++)
     
182.          {   
     
183.              *(pSnr+i)  = ucComMF522Buf[i];
     
184.              snr_check ^= ucComMF522Buf[i];
     
185.          }
     
186.          if (snr_check != ucComMF522Buf[i])
     
187.          {   status = MI_ERR;    }
     
188.     }
     
189.    
     
190.     SetBitMask(CollReg,0x80);
     
191.     return status;
     
192. }
     
193. 
     
194. /////////////////////////////////////////////////////////////////////
     
195. //功    能：选定卡片
     
196. //参数说明: pSnr[IN]:卡片序列号，4字节
     
197. //返    回: 成功返回MI_OK
     
198. /////////////////////////////////////////////////////////////////////
     
199. char PcdSelect(u8 *pSnr)
     
200. {
     
201.     char   status;
     
202.     u8   i;
     
203.     u8   unLen;
     
204.     u8   ucComMF522Buf[MAXRLEN];
     
205.    
     
206.     ucComMF522Buf[0] = PICC_ANTICOLL1;
     
207.     ucComMF522Buf[1] = 0x70;
     
208.     ucComMF522Buf[6] = 0;
     
209.     for (i=0; i<4; i++)
     
210.     {
     
211.             ucComMF522Buf[i+2] = *(pSnr+i);
     
212.             ucComMF522Buf[6]  ^= *(pSnr+i);
     
213.     }
     
214.     CalulateCRC(ucComMF522Buf,7,&ucComMF522Buf[7]);
     
215.   
     
216.     ClearBitMask(Status2Reg,0x08);
     
217. 
     
218.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);
     
219.    
     
220.     if ((status == MI_OK) && (unLen == 0x18))
     
221.     {   status = MI_OK;  }
     
222.     else
     
223.     {   status = MI_ERR;    }
     
224. 
     
225.     return status;
     
226. }
     
227. 
     
228. /////////////////////////////////////////////////////////////////////
     
229. //功    能：验证卡片密码
     
230. //参数说明: auth_mode[IN]: 密码验证模式
     
231. //                 0x60 = 验证A密钥
     
232. //                 0x61 = 验证B密钥
     
233. //          addr[IN]：块地址
     
234. //          pKey[IN]：密码
     
235. //          pSnr[IN]：卡片序列号，4字节
     
236. //返    回: 成功返回MI_OK
     
237. /////////////////////////////////////////////////////////////////////               
     
238. char PcdAuthState(u8   auth_mode,u8   addr,u8 *pKey,u8 *pSnr)
     
239. {
     
240.     char   status;
     
241.     u8   unLen;
     
242.     u8   i,ucComMF522Buf[MAXRLEN];
     
243. 
     
244.     ucComMF522Buf[0] = auth_mode;
     
245.     ucComMF522Buf[1] = addr;
     
246. //    for (i=0; i<6; i++)
     
247. //    {    ucComMF522Buf[i+2] = *(pKey+i);   }
     
248. //    for (i=0; i<6; i++)
     
249. //    {    ucComMF522Buf[i+8] = *(pSnr+i);   }
     
250.     memcpy(&ucComMF522Buf[2], pKey, 6);
     
251.     memcpy(&ucComMF522Buf[8], pSnr, 4);
     
252.    
     
253.     status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
     
254.     if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
     
255.     {   status = MI_ERR;   }
     
256.    
     
257.     return status;
     
258. }
     
259. 
     
260. /////////////////////////////////////////////////////////////////////
     
261. //功    能：读取M1卡一块数据
     
262. //参数说明: addr[IN]：块地址
     
263. //          p [OUT]：读出的数据，16字节
     
264. //返    回: 成功返回MI_OK
     
265. /////////////////////////////////////////////////////////////////////
     
266. char PcdRead(u8   addr,u8 *p )
     
267. {
     
268.     char   status;
     
269.     u8   unLen;
     
270.     u8   i,ucComMF522Buf[MAXRLEN];
     
271. 
     
272.     ucComMF522Buf[0] = PICC_READ;
     
273.     ucComMF522Buf[1] = addr;
     
274.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
275.    
     
276.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
277.     if ((status == MI_OK) && (unLen == 0x90))
     
278. //   {   memcpy(p , ucComMF522Buf, 16);   }
     
279.     {
     
280.         for (i=0; i<16; i++)
     
281.         {    *(p +i) = ucComMF522Buf[i];   }
     
282.     }
     
283.     else
     
284.     {   status = MI_ERR;   }
     
285.    
     
286.     return status;
     
287. }
     
288. 
     
289. /////////////////////////////////////////////////////////////////////
     
290. //功    能：写数据到M1卡一块
     
291. //参数说明: addr[IN]：块地址
     
292. //          p [IN]：写入的数据，16字节
     
293. //返    回: 成功返回MI_OK
     
294. /////////////////////////////////////////////////////////////////////                  
     
295. char PcdWrite(u8   addr,u8 *p )
     
296. {
     
297.     char   status;
     
298.     u8   unLen;
     
299.     u8   i,ucComMF522Buf[MAXRLEN];
     
300.    
     
301.     ucComMF522Buf[0] = PICC_WRITE;
     
302.     ucComMF522Buf[1] = addr;
     
303.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
304. 
     
305.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
306. 
     
307.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     
308.     {   status = MI_ERR;   }
     
309.         
     
310.     if (status == MI_OK)
     
311.     {
     
312.         //memcpy(ucComMF522Buf, p , 16);
     
313.         for (i=0; i<16; i++)
     
314.         {   
     
315.                 ucComMF522Buf[i] = *(p +i);   
     
316.         }
     
317.         CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16]);
     
318. 
     
319.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,18,ucComMF522Buf,&unLen);
     
320.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     
321.         {   status = MI_ERR;   }
     
322.     }
     
323.    
     
324.     return status;
     
325. }
     
326. 
     
327. /////////////////////////////////////////////////////////////////////
     
328. //功    能：命令卡片进入休眠状态
     
329. //返    回: 成功返回MI_OK
     
330. /////////////////////////////////////////////////////////////////////
     
331. char PcdHalt(void)
     
332. {
     
333.     u8   status;
     
334.     u8   unLen;
     
335.     u8   ucComMF522Buf[MAXRLEN];
     
336. 
     
337.     ucComMF522Buf[0] = PICC_HALT;
     
338.     ucComMF522Buf[1] = 0;
     
339.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
340. 
     
341.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
342. 
     
343.     return MI_OK;
     
344. }
     
345. 
     
346. /////////////////////////////////////////////////////////////////////
     
347. //用MF522计算CRC16函数
     
348. /////////////////////////////////////////////////////////////////////
     
349. void CalulateCRC(u8 *pIn ,u8   len,u8 *pOut )
     
350. {
     
351.     u8   i,n;
     
352.     ClearBitMask(DivIrqReg,0x04);
     
353.     WriteRawRC(CommandReg,PCD_IDLE);
     
354.     SetBitMask(FIFOLevelReg,0x80);
     
355.     for (i=0; i<len; i++)
     
356.     {   WriteRawRC(FIFODataReg, *(pIn +i));   }
     
357.     WriteRawRC(CommandReg, PCD_CALCCRC);
     
358.     i = 0xFF;
     
359.     do
     
360.     {
     
361.         n = ReadRawRC(DivIrqReg);
     
362.         i--;
     
363.     }
     
364.     while ((i!=0) && !(n&0x04));
     
365.     pOut [0] = ReadRawRC(CRCResultRegL);
     
366.     pOut [1] = ReadRawRC(CRCResultRegM);
     
367. }
     
368. 
     
369. /////////////////////////////////////////////////////////////////////
     
370. //功    能：复位RC522
     
371. //返    回: 成功返回MI_OK
     
372. /////////////////////////////////////////////////////////////////////
     
373. char PcdReset(void)
     
374. {
     
375.         //PORTD|=(1<<RC522RST);
     
376.         SET_RC522RST;
     
377.     delay_ns(10);
     
378.         //PORTD&=~(1<<RC522RST);
     
379.         CLR_RC522RST;
     
380.     delay_ns(10);
     
381.         //PORTD|=(1<<RC522RST);
     
382.         SET_RC522RST;
     
383.     delay_ns(10);
     
384.     WriteRawRC(CommandReg,PCD_RESETPHASE);
     
385.         WriteRawRC(CommandReg,PCD_RESETPHASE);
     
386.     delay_ns(10);
     
387.    
     
388.     WriteRawRC(ModeReg,0x3D);            //和Mifare卡通讯，CRC初始值0x6363
     
389.     WriteRawRC(TReloadRegL,30);           
     
390.     WriteRawRC(TReloadRegH,0);
     
391.     WriteRawRC(TModeReg,0x8D);
     
392.     WriteRawRC(TPrescalerReg,0x3E);
     
393.        
     
394.         WriteRawRC(TxAutoReg,0x40);//必须要
     
395.    
     
396.     return MI_OK;
     
397. }
     
398. //////////////////////////////////////////////////////////////////////
     
399. //设置RC632的工作方式
     
400. //////////////////////////////////////////////////////////////////////
     
401. char M500PcdConfigISOType(u8   type)
     
402. {
     
403.    if (type == 'A')                     //ISO14443_A
     
404.    {
     
405.        ClearBitMask(Status2Reg,0x08);
     
406.        WriteRawRC(ModeReg,0x3D);//3F
     
407.        WriteRawRC(RxSelReg,0x86);//84
     
408.        WriteRawRC(RFCfgReg,0x7F);   //4F
     
409.               WriteRawRC(TReloadRegL,30);//tmoLength);// TReloadVal = 'h6a =tmoLength(dec)
     
410.            WriteRawRC(TReloadRegH,0);
     
411.        WriteRawRC(TModeReg,0x8D);
     
412.            WriteRawRC(TPrescalerReg,0x3E);
     
413.            delay_ns(1000);
     
414.        PcdAntennaOn();
     
415.    }
     
416.    else{ return 1; }
     
417.    
     
418.    return MI_OK;
     
419. }
     
420. /////////////////////////////////////////////////////////////////////
     
421. //功    能：读RC632寄存器
     
422. //参数说明：Address[IN]:寄存器地址
     
423. //返    回：读出的值
     
424. /////////////////////////////////////////////////////////////////////
     
425. u8 ReadRawRC(u8   Address)
     
426. {
     
427.     u8   ucAddr;
     
428.     u8   ucResult=0;
     
429.         CLR_SPI_CS;
     
430.     ucAddr = ((Address<<1)&0x7E)|0x80;
     
431.        
     
432.         SPIWriteByte(ucAddr);
     
433.         ucResult=SPIReadByte();
     
434.         SET_SPI_CS;
     
435.    return ucResult;
     
436. }
     
437. 
     
438. /////////////////////////////////////////////////////////////////////
     
439. //功    能：写RC632寄存器
     
440. //参数说明：Address[IN]:寄存器地址
     
441. //          value[IN]:写入的值
     
442. /////////////////////////////////////////////////////////////////////
     
443. void WriteRawRC(u8   Address, u8   value)
     
444. {  
     
445.     u8   ucAddr;
     
446. //        u8 tmp;
     
447. 
     
448.         CLR_SPI_CS;
     
449.     ucAddr = ((Address<<1)&0x7E);
     
450. 
     
451.         SPIWriteByte(ucAddr);
     
452.         SPIWriteByte(value);
     
453.         SET_SPI_CS;
     
454. 
     
455. //        tmp=ReadRawRC(Address);
     
456. //
     
457. //        if(value!=tmp)
     
458. //                printf("wrong\n");
     
459. }
     
460. /////////////////////////////////////////////////////////////////////
     
461. //功    能：置RC522寄存器位
     
462. //参数说明：reg[IN]:寄存器地址
     
463. //          mask[IN]:置位值
     
464. /////////////////////////////////////////////////////////////////////
     
465. void SetBitMask(u8   reg,u8   mask)  
     
466. {
     
467.     char   tmp = 0x0;
     
468.     tmp = ReadRawRC(reg);
     
469.     WriteRawRC(reg,tmp | mask);  // set bit mask
     
470. }
     
471. 
     
472. /////////////////////////////////////////////////////////////////////
     
473. //功    能：清RC522寄存器位
     
474. //参数说明：reg[IN]:寄存器地址
     
475. //          mask[IN]:清位值
     
476. /////////////////////////////////////////////////////////////////////
     
477. void ClearBitMask(u8   reg,u8   mask)  
     
478. {
     
479.     char   tmp = 0x0;
     
480.     tmp = ReadRawRC(reg);
     
481.     WriteRawRC(reg, tmp & ~mask);  // clear bit mask
     
482. }
     
483. 
     
484. /////////////////////////////////////////////////////////////////////
     
485. //功    能：通过RC522和ISO14443卡通讯
     
486. //参数说明：Command[IN]:RC522命令字
     
487. //          pIn [IN]:通过RC522发送到卡片的数据
     
488. //          InLenByte[IN]:发送数据的字节长度
     
489. //          pOut [OUT]:接收到的卡片返回数据
     
490. //          *pOutLenBit[OUT]:返回数据的位长度
     
491. /////////////////////////////////////////////////////////////////////
     
492. char PcdComMF522(u8   Command,
     
493.                  u8 *pIn ,
     
494.                  u8   InLenByte,
     
495.                  u8 *pOut ,
     
496.                  u8 *pOutLenBit)
     
497. {
     
498.     char   status = MI_ERR;
     
499.     u8   irqEn   = 0x00;
     
500.     u8   waitFor = 0x00;
     
501.     u8   lastBits;
     
502.     u8   n;
     
503.     u16   i;
     
504.     switch (Command)
     
505.     {
     
506.         case PCD_AUTHENT:
     
507.                         irqEn   = 0x12;
     
508.                         waitFor = 0x10;
     
509.                         break;
     
510.                 case PCD_TRANSCEIVE:
     
511.                         irqEn   = 0x77;
     
512.                         waitFor = 0x30;
     
513.                         break;
     
514.                 default:
     
515.                         break;
     
516.     }
     
517.    
     
518.     WriteRawRC(ComIEnReg,irqEn|0x80);
     
519.     ClearBitMask(ComIrqReg,0x80);        //清所有中断位
     
520.     WriteRawRC(CommandReg,PCD_IDLE);
     
521.     SetBitMask(FIFOLevelReg,0x80);                 //清FIFO缓存
     
522.    
     
523.     for (i=0; i<InLenByte; i++)
     
524.     {   WriteRawRC(FIFODataReg, pIn [i]);    }
     
525.     WriteRawRC(CommandReg, Command);          
     
526. //            n = ReadRawRC(CommandReg);
     
527.    
     
528.     if (Command == PCD_TRANSCEIVE)
     
529.     {    SetBitMask(BitFramingReg,0x80);  }         //开始传送
     
530.                                                                                      
     
531.     //i = 600;//根据时钟频率调整，操作M1卡最大等待时间25ms
     
532.         i = 2000;
     
533.     do
     
534.     {
     
535.         n = ReadRawRC(ComIrqReg);
     
536.         i--;
     
537.     }
     
538.     while ((i!=0) && !(n&0x01) && !(n&waitFor));
     
539.     ClearBitMask(BitFramingReg,0x80);
     
540. 
     
541.     if (i!=0)
     
542.     {   
     
543.         if(!(ReadRawRC(ErrorReg)&0x1B))
     
544.         {
     
545.             status = MI_OK;
     
546.             if (n & irqEn & 0x01)
     
547.             {   status = MI_NOTAGERR;   }
     
548.             if (Command == PCD_TRANSCEIVE)
     
549.             {
     
550.                        n = ReadRawRC(FIFOLevelReg);
     
551.                       lastBits = ReadRawRC(ControlReg) & 0x07;
     
552.                 if (lastBits)
     
553.                 {   *pOutLenBit = (n-1)*8 + lastBits;   }
     
554.                 else
     
555.                 {   *pOutLenBit = n*8;   }
     
556.                 if (n == 0)
     
557.                 {   n = 1;    }
     
558.                 if (n > MAXRLEN)
     
559.                 {   n = MAXRLEN;   }
     
560.                 for (i=0; i<n; i++)
     
561.                 {   pOut [i] = ReadRawRC(FIFODataReg);    }
     
562.             }
     
563.         }
     
564.         else
     
565.         {   status = MI_ERR;   }
     
566.         
     
567.     }
     
568.    
     
569. 
     
570.     SetBitMask(ControlReg,0x80);           // stop timer now
     
571.     WriteRawRC(CommandReg,PCD_IDLE);
     
572.     return status;
     
573. }
     
574. 
     
575. /////////////////////////////////////////////////////////////////////
     
576. //开启天线  
     
577. //每次启动或关闭天险发射之间应至少有1ms的间隔
     
578. /////////////////////////////////////////////////////////////////////
     
579. void PcdAntennaOn(void)
     
580. {
     
581.     u8   i;
     
582.     i = ReadRawRC(TxControlReg);
     
583.     if (!(i & 0x03))
     
584.     {
     
585.         SetBitMask(TxControlReg, 0x03);
     
586.     }
     
587. }
     
588. 
     
589. 
     
590. /////////////////////////////////////////////////////////////////////
     
591. //关闭天线
     
592. /////////////////////////////////////////////////////////////////////
     
593. void PcdAntennaOff(void)
     
594. {
     
595.         ClearBitMask(TxControlReg, 0x03);
     
596. }
     
597. 
     
598. /////////////////////////////////////////////////////////////////////
     
599. //功    能：扣款和充值
     
600. //参数说明: dd_mode[IN]：命令字
     
601. //               0xC0 = 扣款
     
602. //               0xC1 = 充值
     
603. //          addr[IN]：钱包地址
     
604. //          pValue[IN]：4字节增(减)值，低位在前
     
605. //返    回: 成功返回MI_OK
     
606. /////////////////////////////////////////////////////////////////////                 
     
607. /*char PcdValue(u8 dd_mode,u8 addr,u8 *pValue)
     
608. {
     
609.     char status;
     
610.     u8  unLen;
     
611.     u8 ucComMF522Buf[MAXRLEN];
     
612.     //u8 i;
     
613.        
     
614.     ucComMF522Buf[0] = dd_mode;
     
615.     ucComMF522Buf[1] = addr;
     
616.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
617. 
     
618.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
619. 
     
620.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     
621.     {   status = MI_ERR;   }
     
622.         
     
623.     if (status == MI_OK)
     
624.     {
     
625.         memcpy(ucComMF522Buf, pValue, 4);
     
626.         //for (i=0; i<16; i++)
     
627.         //{    ucComMF522Buf[i] = *(pValue+i);   }
     
628.         CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);
     
629.         unLen = 0;
     
630.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
     
631.                 if (status != MI_ERR)
     
632.         {    status = MI_OK;    }
     
633.     }
     
634.    
     
635.     if (status == MI_OK)
     
636.     {
     
637.         ucComMF522Buf[0] = PICC_TRANSFER;
     
638.         ucComMF522Buf[1] = addr;
     
639.         CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
640.    
     
641.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
642. 
     
643.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     
644.         {   status = MI_ERR;   }
     
645.     }
     
646.     return status;
     
647. }*/
     
648. 
     
649. /////////////////////////////////////////////////////////////////////
     
650. //功    能：备份钱包
     
651. //参数说明: sourceaddr[IN]：源地址
     
652. //          goaladdr[IN]：目标地址
     
653. //返    回: 成功返回MI_OK
     
654. /////////////////////////////////////////////////////////////////////
     
655. /*char PcdBakValue(u8 sourceaddr, u8 goaladdr)
     
656. {
     
657.     char status;
     
658.     u8  unLen;
     
659.     u8 ucComMF522Buf[MAXRLEN];
     
660. 
     
661.     ucComMF522Buf[0] = PICC_RESTORE;
     
662.     ucComMF522Buf[1] = sourceaddr;
     
663.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
664. 
     
665.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
666. 
     
667.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     
668.     {   status = MI_ERR;   }
     
669.    
     
670.     if (status == MI_OK)
     
671.     {
     
672.         ucComMF522Buf[0] = 0;
     
673.         ucComMF522Buf[1] = 0;
     
674.         ucComMF522Buf[2] = 0;
     
675.         ucComMF522Buf[3] = 0;
     
676.         CalulateCRC(ucComMF522Buf,4,&ucComMF522Buf[4]);
     
677. 
     
678.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,6,ucComMF522Buf,&unLen);
     
679.                 if (status != MI_ERR)
     
680.         {    status = MI_OK;    }
     
681.     }
     
682.    
     
683.     if (status != MI_OK)
     
684.     {    return MI_ERR;   }
     
685.    
     
686.     ucComMF522Buf[0] = PICC_TRANSFER;
     
687.     ucComMF522Buf[1] = goaladdr;
     
688. 
     
689.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
690. 
     
691.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
692. 
     
693.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     
694.     {   status = MI_ERR;   }
     
695. 
     
696.     return status;
     
697. }*/
     

复制代码

main.c

1. #include "output.h"
   
2. #include "delay.h"
   
3. #include "sys.h"
   
4. #include "rc522.h"
   
5. #include "lcd.h"                         //显示模块
   
6. #include "key.h"             //矩阵键盘模块
   
7. #include "usart.h"
   
8. #include "string.h"
   
9. //////////////////////////////////////////////////////////
   
10. //M1卡分為16個扇區，每個扇區由4塊（塊0、塊1、塊2、塊3）組成
    
11. //我們也將16個扇區的64個塊按絕對地址編號0~63
    
12. //第0扇區的塊0（即絕對地址0塊），他用於存放廠商代碼，已經固化，不可更改
    
13. //每個扇區的塊0、塊1、塊2為數據塊，可用於存放數據
    
14. //每個扇區的塊3為控制塊（絕對地址塊3、7、11....），包括了密碼A，存取控制、密碼B。
    
15. 
    
16. /*******************************
    
17. *连线说明：
    
18. *1--SS  <----->PF0
    
19. *2--SCK <----->PB13
    
20. *3--MOSI<----->PB15
    
21. *4--MISO<----->PB14
    
22. *5--悬空
    
23. *6--GND <----->GND
    
24. *7--RST <----->PF1
    
25. *8--VCC <----->VCC
    
26. ************************************/
    
27. /*全局变量*/
    
28. unsigned char CT[2];//卡类型
    
29. unsigned char SN[4]; //卡号
    
30. unsigned char RFID[16];                        //存放RFID
    
31. unsigned char lxl_bit=0;
    
32. unsigned char card1_bit=0;
    
33. unsigned char card2_bit=0;
    
34. unsigned char card3_bit=0;
    
35. unsigned char card4_bit=0;
    
36. unsigned char total=0;
    
37. unsigned char lxl[4]={6,109,250,186};
    
38. unsigned char card_1[4]={66,193,88,0};
    
39. unsigned char card_2[4]={66,191,104,0};
    
40. unsigned char card_3[4]={62,84,28,11};
    
41. unsigned char card_4[4]={126,252,248,12};
    
42. u8 KEY[6]={0xff,0xff,0xff,0xff,0xff,0xff};
    
43. unsigned char RFID1[16]={0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x07,0x80,0x29,0xff,0xff,0xff,0xff,0xff,0xff};
    
44. /*函数声明*/
    
45. void ShowID(u16 x,u16 y, u8 *p, u16 charColor, u16 bkColor);         //显示卡的卡号，以十六进制显示
    
46. void PutNum(u16 x,u16 y, u32 n1,u8 n0, u16 charColor, u16 bkColor);        //显示余额函数
    
47. void Store(u8 *p,u8 store,u8 cash);//最重要的一个函数        
    
48. int main(void)
    
49. {               
    
50.         unsigned char status;
    
51.         unsigned char s=0x08;
    
52.         //u8 Data[16];
    
53.         //u8 i;
    
54.         u8 t,key;
    
55.         //u8 k;//读写错误重试次数
    
56.         u8 j;
    
57. 
    
58.          delay_init();                     //延时函数初始化         
    
59.         NVIC_Configuration();          //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
    
60.          OUTPUT_Init();                         //输出模块初始化
    
61.         uart_init(9600);                                
    
62.         LCD_Init();
    
63.         KEY_Init();
    
64.         InitRc522();                                //初始化射频卡模块
    
65.         //sprintf((char*)lcd_id,"LCD ID:%04X",lcddev.id);//将LCD ID打印到lcd_id数组。
    
66.         LEDA=1;         
    
67.           while(1)
    
68.         {                key=KEY_Scan(0);
    
69.                        if(key==1){s++;LCD_ShowNum(0,272,s,3,16);}
    
70.                         else if(key==3) {s--;LCD_ShowNum(0,272,s,3,16);}
    
71.                         status = PcdRequest(PICC_REQALL,CT);/*尋卡*/
    
72.                         if(status==MI_OK)//尋卡成功
    
73.                         {
    
74.                          LCD_ShowString(0,30,200,16,16,"PcdRequest_MI_OK");
    
75.                          status=MI_ERR;
    
76.                          status = PcdAnticoll(SN);/*防冲撞*/
    
77.                         
    
78.                         }
    
79. 
    
80. 
    
81. 
    
82. 
    
83.                         if (status==MI_OK)//防衝撞成功
    
84.                         {
    
85.                                 LCD_ShowString(150,30,200,16,16,"PcdAnticoll_MI_OK");
    
86.                                 status=MI_ERR;               
    
87.                                 LEDA=1;
    
88.                                 LEDB=1;
    
89.                                 ShowID(0,200,SN,BLUE,WHITE); //在液晶屏上显示卡的ID号
    
90.                                 //printf("ID:%02x %02x %02x %02x\n",SN[0],SN[1],SN[2],SN[3]);//发送卡号
    
91.                                 LCD_ShowString(0,100,200,16,16,"The Card ID is:");
    
92.                                 for(j=0;j<4;j++)
    
93.                                 {
    
94.                                          LCD_ShowNum(0,116+j*16,SN[j],3,16);
    
95.                                 }
    
96.                                 if((SN[0]==lxl[0])&&(SN[1]==lxl[1])&&(SN[2]==lxl[2])&&(SN[3]==lxl[3]))
    
97.                                 {
    
98.                                         lxl_bit=1;
    
99.                                         LCD_ShowString(0,0,200,16,16,"The User is:lxl");
    
100.                                 }
     
101.                                 if((SN[0]==card_1[0])&&(SN[1]==card_1[1])&&(SN[2]==card_1[2])&&(SN[3]==card_1[3]))
     
102.                                 {
     
103.                                         card1_bit=1;
     
104.                                         LCD_ShowString(0,0,200,16,16,"The User is:card_1");
     
105.                                 }
     
106.                                 if((SN[0]==card_2[0])&&(SN[1]==card_2[1])&&(SN[2]==card_2[2])&&(SN[3]==card_2[3]))
     
107.                                 {
     
108.                                         card2_bit=1;
     
109.                                         LCD_ShowString(0,0,200,16,16,"The User is:card_2");
     
110.                                 }
     
111.                                 
     
112.                                 if((SN[0]==card_3[0])&&(SN[1]==card_3[1])&&(SN[2]==card_3[2])&&(SN[3]==card_3[3]))
     
113.                                 {
     
114.                                         card3_bit=1;
     
115.                                         LCD_ShowString(0,0,200,16,16,"The User is:card_3");
     
116.                                 }
     
117.                                 if((SN[0]==card_4[0])&&(SN[1]==card_4[1])&&(SN[2]==card_4[2])&&(SN[3]==card_4[3]))
     
118.                                 {
     
119.                                         card4_bit=1;
     
120.                                         LCD_ShowString(0,0,200,16,16,"The User is:card_4");
     
121.                                 }
     
122.                                 total=card1_bit+card2_bit+card3_bit+card4_bit+lxl_bit;
     
123.                                 LCD_ShowString(0,16,200,16,16,"total:");
     
124.                                 LCD_ShowNum(46,16,total,2,16);
     
125. 
     
126.                                 status =PcdSelect(SN);
     
127.                                 //Reset_RC522();
     
128.                
     
129.                         }
     
130.                         else
     
131.                         {
     
132.                                 LEDA=0;//只点亮led0
     
133.                                 LEDB=1;
     
134.                         }
     
135.                         if(status==MI_OK)//選卡成功
     
136.                         {
     
137.                          //LCD_ShowString(0,50,200,16,16,"PcdAnticoll_MI_OK");
     
138.                          LCD_ShowString(0,48,200,16,16,"PcdSelect_MI_OK  ");
     
139.                          status=MI_ERR;
     
140.                          status =PcdAuthState(0x60,0x09,KEY,SN);
     
141.                          }
     
142.                          if(status==MI_OK)//驗證成功
     
143.                          {
     
144.                           LCD_ShowString(0,64,200,16,16,"PcdAuthState_MI_OK  ");
     
145.                           status=MI_ERR;
     
146.                           status=PcdRead(s,RFID);
     
147.                           //status=PcdWrite(s,RFID1);
     
148.                           }
     
149. 
     
150.                         if(status==MI_OK)//讀卡成功
     
151.                          {
     
152.                           LCD_ShowString(0,80,200,16,16,"READ_MI_OK");
     
153.                           status=MI_ERR;
     
154.                           delay_ms(100);
     
155.                          }
     
156.                         if(key==2)
     
157.                         {
     
158.                         for(t=0;t<16;t++)                                        //开启射频模块
     
159.                 {
     
160.                  USART_ClearFlag(USART1,USART_FLAG_TC);                 //读取USART_SR
     
161.                  USART_SendData(USART1,RFID[t]);                         //向串口2发送数据
     
162.                  while(USART_GetFlagStatus(USART1,USART_FLAG_TC)!=SET); //等待发送结束
     
163.                  }
     
164.                         }
     
165.                         //else LCD_ShowString(0,80,200,16,16,"READ_MI_ERR ");
     
166. //////////////////////////////////////////////////////////////////////////////////////////////////////
     
167.                           /*if(status==MI_OK)
     
168.                           {
     
169.                            LCD_ShowString(120,80,200,16,16,"WRITE_MI_OK");
     
170.                            status=MI_ERR;
     
171.                           }*/
     
172.                           //else LCD_ShowString(120,80,200,16,16,"WRITE_MI_ERR");
     
173.                           //Reset_RC522();
     
174.         }
     
175.                         
     
176.                         
     
177. //////////////////////////////               
     
178.            }
     
179.                         
     
180. 
     
181. 
     
182. 
     
183. /*************************************
     
184. *函数功能：显示卡的卡号，以十六进制显示
     
185. *参数：x，y 坐标
     
186. *                p 卡号的地址
     
187. *                charcolor 字符的颜色
     
188. *                bkcolor   背景的颜色
     
189. ***************************************/
     
190. void ShowID(u16 x,u16 y, u8 *p, u16 charColor, u16 bkColor)         //显示卡的卡号，以十六进制显示
     
191. {
     
192.         u8 num[9];
     
193.         u8 i;
     
194. 
     
195.         for(i=0;i<4;i++)
     
196.         {
     
197.                 num[i*2]=p[i]/16;
     
198.                 num[i*2]>9?(num[i*2]+='7'):(num[i*2]+='0');
     
199.                 num[i*2+1]=p[i]%16;
     
200.                 num[i*2+1]>9?(num[i*2+1]+='7'):(num[i*2+1]+='0');
     
201.         }
     
202.         num[8]=0;
     
203.         POINT_COLOR=RED;         
     
204.         LCD_ShowString(x,y,200,16,16,"The Card ID is:");        
     
205.         //DisplayString(x,y+16,num,charColor,bkColor);
     
206.          for(i=0;i<8;i++)
     
207.         {
     
208.                   LCD_ShowNum(x+16*i,y+16,num[i],2,16);
     
209.                   //LCD_ShowNum(x,y+32,num[1],2,16);
     
210.                  // LCD_ShowNum(x,y+48,num[2],2,16);
     
211.                  // LCD_ShowNum(x,y+64,num[3],2,16);
     
212.                   
     
213.                  // LCD_ShowNum(x,y+80,num[4],2,16);
     
214.                  // LCD_ShowNum(x,y+96,num[5],2,16);
     
215.                  // LCD_ShowNum(x,y+16*7,num[6],2,16);
     
216.                  // LCD_ShowNum(x,y+16*8,num[7],2,16);
     
217.                  // LCD_ShowNum(x,y+16*9,num[8],2,16);
     
218.                  // LCD_ShowNum(x,y+16*10,num[9],2,16);
     
219.         }
     
220.         
     
221. }
     
222. /********************************
     
223. *函数功能：求p的n次幂
     
224. */
     
225. int power(u8 p,u8 n)
     
226. {
     
227.         int pow=1;
     
228.         u8 i;
     
229.         for(i=0;i<n;i++)
     
230.         {
     
231.                 pow*=p;        
     
232.         }
     
233.         return pow;
     
234. }
     
235. 
     
236. u8 ReadData(u8   addr,u8 *pKey,u8 *pSnr,u8 *dataout)
     
237. {
     
238.         u8 status,k;
     
239.         status=0x02;//
     
240.         k=5;
     
241.         do
     
242.     {
     
243.                 status=PcdAuthState(PICC_AUTHENT1A,addr,pKey,pSnr);
     
244.                 k--;
     
245.                 //printf("AuthState is wrong\n");                                                      
     
246.     }while(status!=MI_OK && k>0);
     
247. 
     
248.         status=0x02;//
     
249.         k=5;
     
250.         do
     
251.     {
     
252.                 status=PcdRead(addr,dataout);
     
253.                 k--;
     
254.                 //printf("ReadData is wrong\n");                                                              
     
255.     }while(status!=MI_OK && k>0);
     
256.         return status;
     
257. }
     
258. u8 WriteData(u8   addr,u8 *pKey,u8 *pSnr,u8 *datain)
     
259. {
     
260.         u8 status,k;
     
261.         status=0x02;//
     
262.         k=5;
     
263.         do
     
264.     {
     
265.                 status=PcdAuthState(PICC_AUTHENT1A,addr,pKey,pSnr);
     
266.                 k--;
     
267.                 //printf("AuthState is wrong\n");                                                      
     
268.     }while(status!=MI_OK && k>0);
     
269. 
     
270.         status=0x02;//
     
271.         k=5;
     
272.         do
     
273.     {
     
274.                 status=PcdWrite(addr,datain);
     
275.                 k--;
     
276.                 //printf("ReadData is wrong\n");                                                              
     
277.     }while(status!=MI_OK && k>0);
     
278.         return status;
     
279. }
     
280. void PutNum(u16 x,u16 y, u32 n1,u8 n0, u16 charColor, u16 bkColor)
     
281. {
     
282. //        u8 tmp[13];
     
283. //        u8 i;
     
284. 
     
285.         //LCD_SetRegion(0,0,239,319,FALSE);
     
286. //        tmp[0]=n1/1000000000+'0';
     
287. //        for(i=1;i<10;i++)
     
288. //        {
     
289. ///                tmp[i]=n1/(1000000000/power(10,i))%10+'0';
     
290. //        }
     
291. //        tmp[10]='.';
     
292. //        tmp[11]=n0+'0';
     
293. //        tmp[12]=0;
     
294.         //DisplayString(x,y,tmp,charColor,bkColor);
     
295.         //LCD_ShowString(x,y,)
     
296. 
     
297.         
     
298. }
     
299. void Store(u8 *p,u8 store,u8 cash)
     
300. {
     
301. 
     
302. }
     
303. 
     

复制代码

---

作者: raim8888    时间: 2016-5-10 09:56
不错谢谢

---

作者: zlo007    时间: 2016-5-19 15:49
不错谢谢                              

---

作者: 51lry521    时间: 2016-5-20 17:42
不错的资料，谢谢分享

---

作者: robinxiong    时间: 2016-7-19 14:02
供应13.56M非接芯片，兼容CV520，RC522，RC523，FM17520，FM17522.具有绝对成本优势。有意者可加QQ458231727

---

作者: nagelan    时间: 2016-9-2 22:52
不错谢谢

---

作者: IF_YOU    时间: 2017-4-3 20:54
流弊！不过我想要51的！

---

作者: yanwenhao111    时间: 2017-4-25 00:20
谢谢分享！！！！

---

作者: 羿羽锋    时间: 2017-10-13 12:27
请问楼主

工作方式那里是RC632的    RC522的能用么

---

作者: huangany    时间: 2017-12-18 17:29
初学者，路过看看

---

作者: yinwuqing    时间: 2022-3-23 14:39
void Store(u8 *p,u8 store,u8 cash);//最重要的一个函数     怎么没有分享出来呢？？

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1