标题: STC11F32单片机与RC522通信的代码 [打印本页]

---

作者: wangyuqxfx    时间: 2017-4-3 17:29
标题: STC11F32单片机与RC522通信的代码
STC11F32单片机芯片与RC522通信的源代码：

完整源码下载：
STC11F32_RC522-bke.rar (1.22 MB, 下载次数: 30)

2017-4-3 17:28 上传

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

主程序：

1. #include "include.h"
   
2. 
   
3. 
   
4. void delay_ms( INT16U tms )
   
5. {
   
6.     INT16U i;
   
7. 
   
8.     while( tms-- )
   
9.     {
   
10.             for( i = 0; i < 300; i ++ )
    
11.             {
    
12.             nop();
    
13.             nop();
    
14.             nop();
    
15.             nop();
    
16.             nop();
    
17.             nop();
    
18.             }
    
19.     }
    
20. }
    
21. 
    
22. void init_led( void )
    
23. {
    
24.     P1 = 0x00;
    
25.     delay_ms(200);
    
26.     P1 = 0Xff;
    
27. }
    
28. 
    
29. void init_port( void )
    
30. {
    
31. //    P0M1 = 0x00;
    
32. //    P0M0 = 0xff;
    
33. 
    
34.     P3M1 &= ~0x10;
    
35.     P3M0 |= 0x10;
    
36.     //
    
37.     //        P1M1=0x00;
    
38.     //        P1M0=0x00;
    
39.     //
    
40.     //        P2M1=0x00;
    
41.     //        P2M0=0xff;
    
42.     //
    
43.     //        P30=1;
    
44.     //        P3M1=0x41;
    
45.     //        P3M0=0xa2;
    
46.     //
    
47.     //        P4M1=0x02;
    
48.     //        P4M0=0x00;
    
49.     BEEP_OFF;
    
50.     LED_OFF;
    
51. }
    
52. 
    
53. void init_par( void )
    
54. {
    
55.     BEEP_OFF;
    
56.     LED_OFF;
    
57. }
    
58. 
    
59. void init_wdt( void )         //2.7S
    
60. {
    
61.     //        WDT_CONTR = 0xC1;
    
62.     //        WDT_CONTR = 0x3E;
    
63. }
    
64. 
    
65. void feed_wdt( void )
    
66. {
    
67.     //        WDT_CONTR = 0x3E;
    
68. }
    
69. 
    
70. void init_all(void)
    
71. {
    
72.     EA = 0;
    
73. 
    
74.     init_timer();
    
75.     init_uart();
    
76.     init_port();
    
77.     init_rc522();
    
78.     init_par();
    
79.     init_wdt();
    
80.     init_led();
    
81. 
    
82.     EA = 1;
    
83. }
    
84. 
    
85. void main(void)
    
86. {
    
87.     if((PCON&0x10)==0) //如果POF位=0
    
88.     {
    
89.        PCON=PCON|0x10;  //将POF位置1
    
90.        IAP_CONTR=0x60;  //软复位,从ISP监控区启动
    
91.     }
    
92.     else
    
93.     {
    
94.        PCON=PCON&0xef;  //将POF位清零
    
95.     }
    
96. 
    
97.     lcdInitinal();
    
98.     lcdMsg("创思通信",2,2);
    
99.     lcdMsg("wwwcsgsmcom",4,1);
    
100.     delay_ms(2000);
     
101.     lcdInitinal();
     
102.     delay_ms(2);
     
103.     lcdMsg("余额：----",4,0);
     
104.     lcdMsg("卡号：----",2,0);
     
105.     lcdMsg("消费：----",3,0);
     
106.     lcdMsg("状态：----",1,0);
     
107. 
     
108.     init_all();
     
109. 
     
110. 
     
111.     while(1)
     
112.     {
     
113.         feed_wdt();
     
114.         ctrl_process();
     
115.     }
     
116. }
     

复制代码

1. #include "include.h"
   
2. 
   
3. void delay_ns(unsigned int ns)
   
4. {
   
5.         unsigned int i;
   
6.         for(i=0;i<ns;i++)
   
7.         {
   
8.                 nop();
   
9.                 nop();
   
10.                 nop();
    
11.         }
    
12. }
    
13. 
    
14. //------------------------------------------
    
15. // 读SPI数据
    
16. //------------------------------------------
    
17. unsigned char SPIReadByte(void)
    
18. {
    
19.         unsigned char SPICount;                                       // Counter used to clock out the data
    
20.         unsigned char SPIData;
    
21.                         
    
22.         SPIData = 0;
    
23.         for (SPICount = 0; SPICount < 8; SPICount++)                  // Prepare to clock in the data to be read
    
24.         {
    
25.                 SPIData <<=1;                                               // Rotate the data
    
26.                 CLR_SPI_CK; //nop();//nop();                                         // Raise the clock to clock the data out of the MAX7456
    
27.                 if(STU_SPI_MISO)
    
28.                 {
    
29.                          SPIData|=0x01;
    
30.                 }
    
31.                 SET_SPI_CK;   //nop();//nop();                                               // Drop the clock ready for the next bit
    
32.         }                                                             // and loop back
    
33.         return (SPIData);                              // Finally return the read data
    
34. }
    
35. //------------------------------------------
    
36. // 写SPI数据
    
37. //------------------------------------------
    
38. void SPIWriteByte(unsigned char SPIData)
    
39. {
    
40.         unsigned char SPICount;                                       // Counter used to clock out the data
    
41.         for (SPICount = 0; SPICount < 8; SPICount++)
    
42.         {
    
43.                 if (SPIData & 0x80)
    
44.                 {
    
45.                         SET_SPI_MOSI;
    
46.                 }
    
47.                 else
    
48.                 {
    
49.                         CLR_SPI_MOSI;
    
50.                 }
    
51.                 nop();nop();
    
52.                 CLR_SPI_CK;nop();nop();
    
53.                 SET_SPI_CK;nop();nop();
    
54.                 SPIData <<= 1;
    
55.         }                 
    
56. }
    
57. 
    
58. /////////////////////////////////////////////////////////////////////
    
59. //功    能：读RC632寄存器
    
60. //参数说明：Address[IN]:寄存器地址
    
61. //返    回：读出的值
    
62. /////////////////////////////////////////////////////////////////////
    
63. unsigned char ReadRawRC(unsigned char Address)
    
64. {
    
65.         unsigned char ucAddr;
    
66.     unsigned char ucResult=0;
    
67.         CLR_SPI_CS;
    
68.     ucAddr = ((Address<<1)&0x7E)|0x80;
    
69.         SPIWriteByte(ucAddr);
    
70.         ucResult=SPIReadByte();
    
71.         SET_SPI_CS;
    
72.         return ucResult;
    
73. }
    
74. 
    
75. /////////////////////////////////////////////////////////////////////
    
76. //功    能：写RC632寄存器
    
77. //参数说明：Address[IN]:寄存器地址
    
78. //          value[IN]:写入的值
    
79. /////////////////////////////////////////////////////////////////////
    
80. void WriteRawRC(unsigned char Address, unsigned char value)
    
81. {  
    
82.     unsigned char ucAddr;
    
83. 
    
84.         CLR_SPI_CS;
    
85.     ucAddr = ((Address<<1)&0x7E);
    
86.         SPIWriteByte(ucAddr);
    
87.         SPIWriteByte(value);
    
88.         SET_SPI_CS;
    
89. }   
    
90. 
    
91. /////////////////////////////////////////////////////////////////////
    
92. //功    能：清RC522寄存器位
    
93. //参数说明：reg[IN]:寄存器地址
    
94. //          mask[IN]:清位值
    
95. /////////////////////////////////////////////////////////////////////
    
96. void ClearBitMask(unsigned char reg,unsigned char mask)  
    
97. {
    
98.     char tmp = 0x00;
    
99.     tmp = ReadRawRC(reg);
    
100.     WriteRawRC(reg, tmp & ~mask);  // clear bit mask
     
101. }
     
102. 
     
103. 
     
104. /////////////////////////////////////////////////////////////////////
     
105. //功    能：置RC522寄存器位
     
106. //参数说明：reg[IN]:寄存器地址
     
107. //          mask[IN]:置位值
     
108. /////////////////////////////////////////////////////////////////////
     
109. void SetBitMask(unsigned char reg,unsigned char mask)  
     
110. {
     
111.     char tmp = 0x00;
     
112.     tmp = ReadRawRC(reg);
     
113.     WriteRawRC(reg,tmp | mask);  // set bit mask
     
114. }
     
115. 
     
116. /////////////////////////////////////////////////////////////////////
     
117. //用MF522计算CRC16函数
     
118. /////////////////////////////////////////////////////////////////////
     
119. void CalulateCRC(unsigned char *pIndata,unsigned char len,unsigned char *pOutData)
     
120. {
     
121.     unsigned char i,n;
     
122.     ClearBitMask(DivIrqReg,0x04);
     
123.     WriteRawRC(CommandReg,PCD_IDLE);
     
124.     SetBitMask(FIFOLevelReg,0x80);
     
125.     for (i=0; i<len; i++)
     
126.     {   WriteRawRC(FIFODataReg, *(pIndata+i));   }
     
127.     WriteRawRC(CommandReg, PCD_CALCCRC);
     
128.     i = 0xFF;
     
129.     do
     
130.     {
     
131.         n = ReadRawRC(DivIrqReg);
     
132.         i--;
     
133.     }
     
134.     while ((i!=0) && !(n&0x04));
     
135.     pOutData[0] = ReadRawRC(CRCResultRegL);
     
136.     pOutData[1] = ReadRawRC(CRCResultRegM);
     
137. }
     
138. 
     
139. /////////////////////////////////////////////////////////////////////
     
140. //功    能：通过RC522和ISO14443卡通讯
     
141. //参数说明：Command[IN]:RC522命令字
     
142. //          pInData[IN]:通过RC522发送到卡片的数据
     
143. //          InLenByte[IN]:发送数据的字节长度
     
144. //          pOutData[OUT]:接收到的卡片返回数据
     
145. //          *pOutLenBit[OUT]:返回数据的位长度
     
146. /////////////////////////////////////////////////////////////////////
     
147. char PcdComMF522(unsigned char Command,
     
148.                  unsigned char *pInData,
     
149.                  unsigned char InLenByte,
     
150.                  unsigned char *pOutData,
     
151.                  unsigned int *pOutLenBit)
     
152. {
     
153.     char status = MI_ERR;
     
154.     unsigned char irqEn   = 0x00;
     
155.     unsigned char waitFor = 0x00;
     
156.     unsigned char lastBits;
     
157.     unsigned char n;
     
158.     unsigned int i;
     
159.     switch (Command)
     
160.     {
     
161.         case PCD_AUTHENT:
     
162.                         irqEn   = 0x12;
     
163.                         waitFor = 0x10;
     
164.                         break;
     
165.                 case PCD_TRANSCEIVE:
     
166.                         irqEn   = 0x77;
     
167.                         waitFor = 0x30;
     
168.                         break;
     
169.                 default:
     
170.                         break;
     
171.     }
     
172.    
     
173.     WriteRawRC(ComIEnReg,irqEn|0x80);
     
174.     ClearBitMask(ComIrqReg,0x80);
     
175.     WriteRawRC(CommandReg,PCD_IDLE);
     
176.     SetBitMask(FIFOLevelReg,0x80);
     
177.    
     
178.     for (i=0; i<InLenByte; i++)
     
179.     {   
     
180.                 WriteRawRC(FIFODataReg, pInData[i]);   
     
181.         }
     
182.     WriteRawRC(CommandReg, Command);
     
183.    
     
184.     if (Command == PCD_TRANSCEIVE)
     
185.     {   
     
186.                 SetBitMask(BitFramingReg,0x80);  
     
187.         }
     
188.    
     
189.     //i = 600;//根据时钟频率调整，操作M1卡最大等待时间25ms
     
190.         i = 2000;
     
191.     do
     
192.     {
     
193.         n = ReadRawRC(ComIrqReg);
     
194.         i--;
     
195.     }
     
196.     while ((i!=0) && !(n&0x01) && !(n&waitFor));
     
197.     ClearBitMask(BitFramingReg,0x80);
     
198. 
     
199.     if (i!=0)
     
200.     {   
     
201.         if(!(ReadRawRC(ErrorReg)&0x1B))
     
202.         {
     
203.             status = MI_OK;
     
204.             if (n & irqEn & 0x01)
     
205.             {   status = MI_NOTAGERR;   }
     
206.             if (Command == PCD_TRANSCEIVE)
     
207.             {
     
208.                        n = ReadRawRC(FIFOLevelReg);
     
209.                       lastBits = ReadRawRC(ControlReg) & 0x07;
     
210.                 if (lastBits)
     
211.                 {   
     
212.                                         *pOutLenBit = (n-1)*8 + lastBits;   
     
213.                                 }
     
214.                 else
     
215.                 {   
     
216.                                         *pOutLenBit = n*8;   
     
217.                                 }
     
218.                 if (n == 0)
     
219.                 {   
     
220.                                         n = 1;   
     
221.                                 }
     
222.                 if (n > MAXRLEN)
     
223.                 {   
     
224.                                         n = MAXRLEN;   
     
225.                                 }
     
226.                 for (i=0; i<n; i++)
     
227.                 {   
     
228.                                         pOutData[i] = ReadRawRC(FIFODataReg);   
     
229.                                 }
     
230.             }
     
231.         }
     
232.         else
     
233.         {   
     
234.                         status = MI_ERR;   
     
235.                 }
     
236.         
     
237.     }
     
238.    
     
239.     SetBitMask(ControlReg,0x80);           // stop timer now
     
240.     WriteRawRC(CommandReg,PCD_IDLE);
     
241.     return status;
     
242. }
     
243.                      
     
244. /////////////////////////////////////////////////////////////////////
     
245. //功    能：寻卡
     
246. //参数说明: req_code[IN]:寻卡方式
     
247. //                0x52 = 寻感应区内所有符合14443A标准的卡
     
248. //                0x26 = 寻未进入休眠状态的卡
     
249. //          pTagType[OUT]：卡片类型代码
     
250. //                0x4400 = Mifare_UltraLight
     
251. //                0x0400 = Mifare_One(S50)
     
252. //                0x0200 = Mifare_One(S70)
     
253. //                0x0800 = Mifare_Pro(X)
     
254. //                0x4403 = Mifare_DESFire
     
255. //返    回: 成功返回MI_OK
     
256. /////////////////////////////////////////////////////////////////////
     
257. char PcdRequest(unsigned char req_code,unsigned char *pTagType)
     
258. {
     
259.         char status;  
     
260.         unsigned int unLen;
     
261.         unsigned char ucComMF522Buf[MAXRLEN];
     
262. 
     
263.         ClearBitMask(Status2Reg,0x08);
     
264.         WriteRawRC(BitFramingReg,0x07);
     
265.         SetBitMask(TxControlReg,0x03);
     
266. 
     
267.         ucComMF522Buf[0] = req_code;
     
268. 
     
269.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,1,ucComMF522Buf,&unLen);
     
270. 
     
271.         if ((status == MI_OK) && (unLen == 0x10))
     
272.         {   
     
273.                 *pTagType     = ucComMF522Buf[0];
     
274.                 *(pTagType+1) = ucComMF522Buf[1];
     
275.         }
     
276.         else
     
277.         {   
     
278.                 status = MI_ERR;   
     
279.         }
     
280.    
     
281.         return status;
     
282. }
     
283. 
     
284. 
     
285. /////////////////////////////////////////////////////////////////////
     
286. //功    能：防冲撞
     
287. //参数说明: pSnr[OUT]:卡片序列号，4字节
     
288. //返    回: 成功返回MI_OK
     
289. /////////////////////////////////////////////////////////////////////  
     
290. char PcdAnticoll(unsigned char *pSnr)
     
291. {
     
292.     char status;
     
293.     unsigned char i,snr_check=0;
     
294.     unsigned int unLen;
     
295.     unsigned char ucComMF522Buf[MAXRLEN];
     
296.    
     
297. 
     
298.     ClearBitMask(Status2Reg,0x08);
     
299.     WriteRawRC(BitFramingReg,0x00);
     
300.     ClearBitMask(CollReg,0x80);
     
301. 
     
302.     ucComMF522Buf[0] = PICC_ANTICOLL1;
     
303.     ucComMF522Buf[1] = 0x20;
     
304. 
     
305.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,2,ucComMF522Buf,&unLen);
     
306. 
     
307.     if (status == MI_OK)
     
308.         {
     
309.                 for (i=0; i<4; i++)
     
310.                 {   
     
311.                         *(pSnr+i)  = ucComMF522Buf[i];
     
312.                         snr_check ^= ucComMF522Buf[i];
     
313.                 }
     
314.                 if (snr_check != ucComMF522Buf[i])
     
315.                    {   
     
316.                         status = MI_ERR;   
     
317.                 }
     
318.     }
     
319.    
     
320.     SetBitMask(CollReg,0x80);
     
321.     return status;
     
322. }
     
323. 
     
324. /////////////////////////////////////////////////////////////////////
     
325. //功    能：选定卡片
     
326. //参数说明: pSnr[IN]:卡片序列号，4字节
     
327. //返    回: 成功返回MI_OK
     
328. /////////////////////////////////////////////////////////////////////
     
329. char PcdSelect(unsigned char *pSnr)
     
330. {
     
331.     char status;
     
332.     unsigned char i;
     
333.     unsigned int unLen;
     
334.     unsigned char ucComMF522Buf[MAXRLEN];
     
335.    
     
336.     ucComMF522Buf[0] = PICC_ANTICOLL1;
     
337.     ucComMF522Buf[1] = 0x70;
     
338.     ucComMF522Buf[6] = 0;
     
339.     for (i=0; i<4; i++)
     
340.     {
     
341.             ucComMF522Buf[i+2] = *(pSnr+i);
     
342.             ucComMF522Buf[6]  ^= *(pSnr+i);
     
343.     }
     
344.     CalulateCRC(ucComMF522Buf,7,&ucComMF522Buf[7]);
     
345.   
     
346.     ClearBitMask(Status2Reg,0x08);
     
347. 
     
348.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,9,ucComMF522Buf,&unLen);
     
349.    
     
350.     if ((status == MI_OK) && (unLen == 0x18))
     
351.     {   
     
352.                 status = MI_OK;  
     
353.         }
     
354.     else
     
355.     {   
     
356.                 status = MI_ERR;   
     
357.         }
     
358. 
     
359.     return status;
     
360. }
     
361. 
     
362. /////////////////////////////////////////////////////////////////////
     
363. //功    能：验证卡片密码
     
364. //参数说明: auth_mode[IN]: 密码验证模式
     
365. //                 0x60 = 验证A密钥
     
366. //                 0x61 = 验证B密钥
     
367. //          addr[IN]：块地址
     
368. //          pKey[IN]：密码
     
369. //          pSnr[IN]：卡片序列号，4字节
     
370. //返    回: 成功返回MI_OK
     
371. /////////////////////////////////////////////////////////////////////               
     
372. char PcdAuthState(unsigned char auth_mode,unsigned char addr,unsigned char *pKey,unsigned char *pSnr)
     
373. {
     
374.     char status;
     
375.     unsigned int unLen;
     
376.     unsigned char ucComMF522Buf[MAXRLEN];
     
377. 
     
378.     ucComMF522Buf[0] = auth_mode;
     
379.     ucComMF522Buf[1] = addr;
     
380.         memcpy(&ucComMF522Buf[2], pKey, 6);
     
381.         memcpy(&ucComMF522Buf[8], pSnr, 6);
     
382.    
     
383.     status = PcdComMF522(PCD_AUTHENT,ucComMF522Buf,12,ucComMF522Buf,&unLen);
     
384.     if ((status != MI_OK) || (!(ReadRawRC(Status2Reg) & 0x08)))
     
385.     {   
     
386.                 status = MI_ERR;   
     
387.         }
     
388.    
     
389.     return status;
     
390. }
     
391. 
     
392. /////////////////////////////////////////////////////////////////////
     
393. //功    能：读取M1卡一块数据
     
394. //参数说明: addr[IN]：块地址
     
395. //          pData[OUT]：读出的数据，16字节
     
396. //返    回: 成功返回MI_OK
     
397. /////////////////////////////////////////////////////////////////////
     
398. char PcdRead(unsigned char addr,unsigned char *pData)
     
399. {
     
400.     char status;
     
401.     unsigned int unLen;
     
402.     unsigned char ucComMF522Buf[MAXRLEN];
     
403. 
     
404.     ucComMF522Buf[0] = PICC_READ;
     
405.     ucComMF522Buf[1] = addr;
     
406.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
407.    
     
408.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
409.     if ((status == MI_OK) && (unLen == 0x90))
     
410.            {   
     
411.                 memcpy(pData, ucComMF522Buf, 16);   
     
412.         }
     
413.     else
     
414.     {   
     
415.                 status = MI_ERR;   
     
416.         }
     
417.    
     
418.     return status;
     
419. }
     
420. 
     
421. /////////////////////////////////////////////////////////////////////
     
422. //功    能：写数据到M1卡一块
     
423. //参数说明: addr[IN]：块地址
     
424. //          pData[IN]：写入的数据，16字节
     
425. //返    回: 成功返回MI_OK
     
426. /////////////////////////////////////////////////////////////////////                  
     
427. char PcdWrite(unsigned char addr,unsigned char *pData)
     
428. {
     
429.     char status;
     
430.     unsigned int unLen;
     
431.     unsigned char ucComMF522Buf[MAXRLEN];
     
432.    
     
433.     ucComMF522Buf[0] = PICC_WRITE;
     
434.     ucComMF522Buf[1] = addr;
     
435.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
436. 
     
437.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
438. 
     
439.     if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     
440.     {   
     
441.                 status = MI_ERR;   
     
442.         }
     
443.         
     
444.     if (status == MI_OK)
     
445.     {
     
446.         memcpy(ucComMF522Buf, pData, 16);
     
447.         CalulateCRC(ucComMF522Buf,16,&ucComMF522Buf[16]);
     
448. 
     
449.         status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,18,ucComMF522Buf,&unLen);
     
450.         if ((status != MI_OK) || (unLen != 4) || ((ucComMF522Buf[0] & 0x0F) != 0x0A))
     
451.         {   
     
452.                         status = MI_ERR;   
     
453.                 }
     
454.     }
     
455.    
     
456.     return status;
     
457. }
     
458. 
     
459. /////////////////////////////////////////////////////////////////////
     
460. //功    能：命令卡片进入休眠状态
     
461. //返    回: 成功返回MI_OK
     
462. /////////////////////////////////////////////////////////////////////
     
463. char PcdHalt(void)
     
464. {
     
465.     char status;
     
466.     unsigned int unLen;
     
467.     unsigned char ucComMF522Buf[MAXRLEN];
     
468. 
     
469.     ucComMF522Buf[0] = PICC_HALT;
     
470.     ucComMF522Buf[1] = 0;
     
471.     CalulateCRC(ucComMF522Buf,2,&ucComMF522Buf[2]);
     
472. 
     
473.     status = PcdComMF522(PCD_TRANSCEIVE,ucComMF522Buf,4,ucComMF522Buf,&unLen);
     
474. 
     
475.     return MI_OK;
     
476. }
     
477. 
     
478. /////////////////////////////////////////////////////////////////////
     
479. //功    能：复位RC522
     
480. //返    回: 成功返回MI_OK
     
481. /////////////////////////////////////////////////////////////////////
     
482. char PcdReset(void)
     
483. {
     
484.         SET_RC522RST;
     
485.     delay_ns(10);
     
486.         CLR_RC522RST;
     
487.     delay_ns(10);
     
488.         SET_RC522RST;
     
489.     delay_ns(10);
     
490.     WriteRawRC(CommandReg,PCD_RESETPHASE);
     
491.     delay_ns(10);
     
492.    
     
493.     WriteRawRC(ModeReg,0x3D);            //和Mifare卡通讯，CRC初始值0x6363
     
494.     WriteRawRC(TReloadRegL,30);           
     
495.     WriteRawRC(TReloadRegH,0);
     
496.     WriteRawRC(TModeReg,0x8D);
     
497.     WriteRawRC(TPrescalerReg,0x3E);
     
498.         
     
499.         WriteRawRC(TxAutoReg,0x40);//必须要
     
500.    
     
501.     return MI_OK;
     
502. }
     
503. //////////////////////////////////////////////////////////////////////
     
504. //设置RC632的工作方式
     
505. //////////////////////////////////////////////////////////////////////
     
506. char M500PcdConfigISOType(unsigned char type)
     
507. {
     
508.    if (type == 'A')                     //ISO14443_A
     
509.    {
     
510.        ClearBitMask(Status2Reg,0x08);
     
511.        WriteRawRC(ModeReg,0x3D);//3F
     
512.        WriteRawRC(RxSelReg,0x86);//84
     
513.        WriteRawRC(RFCfgReg,0x7F);   //4F
     
514.               WriteRawRC(TReloadRegL,30);//tmoLength);// TReloadVal = 'h6a =tmoLength(dec)
     
515.            WriteRawRC(TReloadRegH,0);
     
516.        WriteRawRC(TModeReg,0x8D);
     
517.            WriteRawRC(TPrescalerReg,0x3E);
     
518.            delay_ns(1000);
     
519.        PcdAntennaOn();
     
520.    }
     
521.    else{ return -1; }
     
522.    
     
523.    return MI_OK;
     
524. }
     
525. 
     
526. /////////////////////////////////////////////////////////////////////
     
527. //开启天线  
     
528. //每次启动或关闭天险发射之间应至少有1ms的间隔
     
529. /////////////////////////////////////////////////////////////////////
     
530. 
     
531. 
     
532. …………限于本文篇幅 余下代码请从51黑下载附件…………
     

复制代码

---

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

Powered by Discuz! X3.1