51单片机 Rc632射频识别器件驱动源码

51单片机，RC632射频识别器件，可以实现对支持14443A/B、15693协议的IC卡进行非接触读写操作-51 MCU，RC632 RFID IC,ISO14443A/B、ISO15693，READ&WRITE


全部下载：
CLRC632_RFID_CODE.rar (235.83 KB, 下载次数: 101)

2017-3-16 17:54 上传

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

主程序：

1. #include <reg52.h>
   
2. #include <string.h>
   
3. #include <intrins.h>
   
4. #include "main.h"
   
5. #include "slrc632.h"
   
6. #include "iso14443a.h"
   
7. #include "iso14443b.h"
   
8. #include "iso15693.h"
   
9. 
   
10. //硬件版本号         
    
11. unsigned char code hardmodel[12]  = {"SL601F-0512"};  
    
12. 
    
13. bit g_bReceOk;                                              //正确接收到上位机指令标志
    
14. bit g_bReceAA;                                              //接收到上位机发送的AA字节标志
    
15. bit g_bRc632Ok;                                             //RC632复位正常标志
    
16. 
    
17. 
    
18. unsigned int idata g_cReceNum;                              //接收到上位机的字节数
    
19. unsigned int  data g_cCommand;                              //接收到的命令码
    
20. unsigned char data g_cSNR[4];                               //M1卡序列号
    
21. unsigned char g_cIcdevH;                                    //设备标记
    
22. unsigned char g_cIcdevL;                                    //设备标记
    
23. unsigned char g_cFWI;                                       //
    
24. unsigned char idata  g_cCidNad;                             //
    
25. unsigned char idata g_cReceBuf[64];                         //和上位机通讯时的缓冲区
    
26. 
    
27. struct TranSciveBuffer{unsigned char MfCommand;
    
28.                        unsigned int  MfLength;
    
29.                        unsigned char MfData[64];
    
30.                       };
    
31.                                           
    
32.                                           
    
33. 
    
34. void delay(unsigned int i)
    
35. {
    
36.    unsigned char j;
    
37.    while(i--) for(j=0;j<200;j++);
    
38. }
    
39. 
    
40. void BEEP(unsigned char i)
    
41. {
    
42.     unsigned char k;
    
43.         k=i*200;
    
44.     sond =  0;
    
45.         delay(k);
    
46.         sond =1;
    
47.    
    
48. }
    
49. 
    
50. void REDON(void)
    
51. {
    
52.     redled =  1;
    
53. }
    
54. 
    
55. void REDOFF(void)
    
56. {
    
57.     redled =  0;
    
58. }
    
59. void BLUEON(void)
    
60. {
    
61.     blueled =  1;
    
62. }
    
63. 
    
64. void BLUEOFF(void)
    
65. {
    
66.     blueled =  0;
    
67. }
    
68. 
    
69. 
    
70.                                           
    
71. void main( )
    
72. {   
    
73.      
    
74.      InitializeSystem( );
    
75.      Rc632Ready( );
    
76.      PcdConfigISOType( 'A' );
    
77.      BEEP(1);
    
78.          REDON();
    
79.          BLUEOFF();
    
80.      while ( 1 )
    
81.      {   
    
82.          if (g_bReceOk)
    
83.          {
    
84.    
    
85.                  g_bReceOk = 0;  
    
86.                  RC632_CE=0;   
    
87.                  switch(g_cCommand)
    
88.                  {
    
89.                      case 0x0101:
    
90.                         ComSetBound();               break;
    
91.                      case 0x0104:
    
92.                         ComGetHardModel();           break;
    
93.                      case 0x0108:
    
94.                         ComM632PcdConfigISOType();   break;  
    
95.                      case 0x010C:
    
96.                         ComPcdAntenna();             break;
    
97.                                  
    
98.                      case 0x0201:
    
99.                         ComRequestA();               break;  
    
100.                      case 0x0202:
     
101.                         ComAnticoll();               break;        
     
102.                      case 0x0203:
     
103.                         ComSelect();                 break;
     
104.                      case 0x0204:
     
105.                         ComHlta();                   break;
     
106.                      case 0x0207:
     
107.                         ComAuthentication();         break;
     
108.                      case 0x0208:
     
109.                         ComM1Read();                 break;
     
110.                      case 0x0209:
     
111.                         ComM1Write();                break;
     
112.                      case 0x020A:
     
113.                         ComM1Initval();              break;
     
114.                      case 0x020B:
     
115.                         ComM1Readval();              break;
     
116.                      case 0x020C:
     
117.                         ComM1Decrement();            break;
     
118.                      case 0x020D:
     
119.                         ComM1Increment();            break;  
     
120.                      case 0x020E:
     
121.                         ComM1Restore();              break;
     
122.                      case 0x020F:
     
123.                         ComM1Transfer();             break;
     
124.                      case 0x0212:
     
125.                         ComUL_PcdAnticoll();         break;      
     
126.                      case 0x0213:
     
127.                         ComUL_PcdWrite();            break;  
     
128. 
     
129.                      case 0x0301:
     
130.                         ComTypeBRst();               break;  
     
131.                   // case 0x1E:
     
132.                   //      ComAttrib();    break;
     
133.                      case 0x0302:
     
134.                         ComHltb();                   break;
     
135.                      case 0x0303:
     
136.                         ComCL_Deselect();            break;   
     
137. 
     
138.                      case 0x0401:
     
139.                         ComRF020Check();             break;
     
140.                      case 0x0402:
     
141.                         ComRF020Read();              break;
     
142.                      case 0x0403:
     
143.                         ComRF020Write();             break;
     
144.                      case 0x0404:
     
145.                         ComRF020Lock();              break;
     
146.                      case 0x0405:        
     
147.                         ComRF020Count();             break;
     
148.                      case 0x0406:        
     
149.                         ComRF020Deselect();          break;
     
150. 
     
151.                      case 0x0501:
     
152.                         ComSelectSR();               break;
     
153.                      case 0x0502:
     
154.                         ComCompletionSR();           break;
     
155.                      case 0x0503:
     
156.                         ComReadSR176();              break;  
     
157.                      case 0x0504:
     
158.                         ComWriteSR176();             break;   
     
159.                      case 0x0505:
     
160.                         ComProtectSR176();           break;  
     
161.                      case 0x0506:
     
162.                         ComReadSR4K();               break;  
     
163.                      case 0x0507:
     
164.                         ComWriteSR4K();              break;      
     
165.                      case 0x0508:
     
166.                         ComAuthSR4K();               break;  
     
167.                      case 0x0509:
     
168.                         ComGetUIDSR4K();             break;
     
169.                      case 0x050A:
     
170.                         ComProtectSR4K();            break;
     
171.                                     
     
172.                
     
173.                      case 0x1000:
     
174.                         ComISO15693_Inventory16();   break;
     
175.                      case 0x1001:
     
176.                         ComISO15693_Inventory();     break;
     
177.                      case 0x1002:
     
178.                         ComISO15693_Stay_Quiet();    break;
     
179.                      case 0x1003:
     
180.                         ComISO15693_Select();        break;
     
181.                      case 0x1004:
     
182.                         ComISO15693_Reset_To_Ready();break;
     
183.                      case 0x1005:
     
184.                         ComISO15693_Read_sm();       break;
     
185.                      case 0x1006:
     
186.                         ComISO15693_Write_sm();      break;
     
187.                      case 0x1007:
     
188.                         ComISO15693_Lock_Block();    break;
     
189.                      case 0x1008:
     
190.                         ComISO15693_Write_AFI();     break;
     
191.                      case 0x1009:
     
192.                         ComISO15693_Lock_AFI();      break;
     
193.                      case 0x100A:
     
194.                         ComISO15693_Write_DSFID();   break;
     
195.                      case 0x100B:
     
196.                         ComISO15693_Lock_DSFID();    break;
     
197.                      case 0x100C:
     
198.                         ComISO15693_Get_System_Information();     break;
     
199.                      case 0x100D:
     
200.                         ComISO15693_Get_Multiple_Block_Security();break;  
     
201. 
     
202.                      default:
     
203.                         AnswerErr( FAULT11 );         break;
     
204.                  }
     
205.                      REDOFF();
     
206.                       BLUEON();
     
207.              sond =  1;
     
208.                      REDON();
     
209.                      BLUEOFF();
     
210.              RC632_CE=1;
     
211.              ES = 1;
     
212.                          EA=1;
     
213.           }
     
214.      }
     
215. }
     
216. 
     
217. 
     
218. 
     
219. /////////////////////////////////////////////////////////////////////
     
220. //系统初始化
     
221. /////////////////////////////////////////////////////////////////////
     
222. 
     
223. void InitializeSystem()
     
224. {
     
225.     TMOD &= 0x0F;
     
226.     TMOD |= 0x21;
     
227.     PCON |= 0x80;
     
228.     SCON  = 0x50;
     
229.     TH1 = TL1 = BOUND19200;
     
230.     TR1=1;
     
231.     P0 = P1 = P2 = P3 = 0xFF;
     
232.     IE |= 0x90;
     
233. }
     
234. 
     
235. 
     
236. /////////////////////////////////////////////////////////////////////
     
237. //初始化RC632
     
238. /////////////////////////////////////////////////////////////////////
     
239. void Rc632Ready()
     
240. {
     
241.     char status;
     
242.     delay(100);
     
243.     status = PcdReset();
     
244.     if(status != MI_OK)
     
245.     {
     
246.         delay(10);
     
247.         status = PcdReset();
     
248.     }
     
249.     if(status != MI_OK)
     
250.     {
     
251.         delay(10);
     
252.         status = PcdReset();
     
253.     }
     
254.     if(status == MI_OK)
     
255.     {
     
256.         g_bRc632Ok = 1;
     
257.     }      
     
258. }
     
259.         
     
260. /////////////////////////////////////////////////////////////////////
     
261. //响应上位机发送的设置波特率命令
     
262. /////////////////////////////////////////////////////////////////////
     
263. void ComSetBound()
     
264. {
     
265.     unsigned char bound = g_cReceBuf[6];
     
266.     if (bound > 7)
     
267.     {   AnswerErr(FAULT12);    }
     
268.     else
     
269.     {
     
270.             AnswerCommandOk();
     
271.             TR1 = 0;
     
272.          
     
273.             switch(bound)
     
274.         {
     
275.                  case 0:
     
276.                       TH1=TL1=BOUND4800;
     
277.                       break;
     
278.                  case 1:
     
279.                       TH1=TL1=BOUND9600;
     
280.                       break;
     
281.                  case 2:
     
282.                       TH1=TL1=BOUND14400;
     
283.                       break;
     
284.                  case 3:
     
285.                       TH1=TL1=BOUND19200;
     
286.                       break;
     
287.                  case 4:
     
288.                       TH1=TL1=BOUND28800;
     
289.                       break;
     
290.                  case 5:
     
291.                       TH1=TL1=BOUND38400;
     
292.                       break;
     
293.                  case 6:
     
294.                       TH1=TL1=BOUND57600;
     
295.                       break;
     
296.                  case 7:
     
297.                       TH1=TL1=BOUND115200;
     
298.                       break;
     
299.                  default:
     
300.                       break;
     
301.         }
     
302.             TR1 = 1;
     
303.      }           
     
304. }
     
305. 
     
306. 
     
307. /////////////////////////////////////////////////////////////////////
     
308. //响应上位机发送的读取硬件版本号命令
     
309. /////////////////////////////////////////////////////////////////////
     
310. void ComGetHardModel()
     
311. {
     
312.     memcpy(&g_cReceBuf[0], &hardmodel[0], sizeof(hardmodel));
     
313.     AnswerOk(&g_cReceBuf[0], sizeof(hardmodel));
     
314. }   
     
315. 
     
316.    
     
317. /////////////////////////////////////////////////////////////////////
     
318. //响应上位机发送的设置RC632协议命令，ISO14443A/B或ISO15693
     
319. /////////////////////////////////////////////////////////////////////
     
320. void ComM632PcdConfigISOType()
     
321. {
     
322.      if (MI_OK == PcdConfigISOType(g_cReceBuf[6]))
     
323.      {    AnswerCommandOk();    }
     
324.      else
     
325.      {    AnswerErr(-1);   }  
     
326. }
     
327.    
     
328. /////////////////////////////////////////////////////////////////////
     
329. //响应上位机发送的天线命令
     
330. /////////////////////////////////////////////////////////////////////
     
331. void ComPcdAntenna()
     
332. {
     
333.     char status;
     
334.     if (!g_cReceBuf[6])
     
335.     {   status = PcdAntennaOff();   }
     
336.     else
     
337.     {  
     
338.         DelayMs(10);
     
339.         status = PcdAntennaOn();
     
340.         DelayMs(10);
     
341.     }
     
342.     if (status == MI_OK)
     
343.     {   AnswerCommandOk();    }
     
344.     else
     
345.     {   AnswerErr(FAULT10);   }
     
346. }   
     
347. 
     
348. /////////////////////////////////////////////////////////////////////
     
349. //响应上位机发送的寻A卡命令
     
350. /////////////////////////////////////////////////////////////////////
     
351. void ComRequestA()
     
352. {
     
353.     unsigned char atq[2];
     
354.         char status;
     
355.         status = PcdRequest(g_cReceBuf[6], atq);
     
356.         if (status != MI_OK)
     
357.         {    status = PcdRequest(g_cReceBuf[6], atq);   }
     
358.     if (status == MI_OK)
     
359.     {    AnswerOk(atq,2);     }
     
360.     else
     
361.     {    AnswerErr(FAULT20);   }            
     
362. }
     
363. 
     
364. /////////////////////////////////////////////////////////////////////
     
365. //响应上位机发送的A卡防冲撞命令
     
366. /////////////////////////////////////////////////////////////////////
     
367. void ComAnticoll()
     
368. {
     
369.     if (MI_OK == PcdAnticoll(&g_cSNR))
     
370.     {    AnswerOk(&g_cSNR,4);  }
     
371.     else
     
372.     {    AnswerErr(FAULT10);   }            
     
373. }
     
374. 
     
375. /////////////////////////////////////////////////////////////////////
     
376. //响应上位机发送的A卡锁定命令
     
377. /////////////////////////////////////////////////////////////////////
     
378. void ComSelect()
     
379. {
     
380.     if (MI_OK == PcdSelect(&g_cReceBuf[6], &g_cReceBuf[0]))
     
381.     {    AnswerOk(&g_cReceBuf[0], 1);      }
     
382.     else
     
383.     {    AnswerErr(FAULT10);   }            
     
384. }
     
385. 
     
386. /////////////////////////////////////////////////////////////////////
     
387. //响应上位机发送的A卡休眠命令
     
388. /////////////////////////////////////////////////////////////////////
     
389. void ComHlta()
     
390. {
     
391.     if (MI_OK == PcdHalt())
     
392.     {    AnswerCommandOk();    }
     
393.     else
     
394.     {    AnswerErr(FAULT10);   }            
     
395. }
     
396. 
     
397. /////////////////////////////////////////////////////////////////////
     
398. //响应上位机发送的A卡验证密钥命令
     
399. /////////////////////////////////////////////////////////////////////
     
400. void ComAuthentication()
     
401. {        
     
402.     char status = MI_COM_ERR;
     
403.     unsigned char *pkeys,*pSNR;
     
404.     pkeys = &g_cReceBuf[20];
     
405.     pSNR  = &g_cSNR;
     
406.     if (MI_OK == ChangeCodeKey(&g_cReceBuf[8],pkeys))                       //转换密钥格式
     
407.     {   
     
408.             if (MI_OK == PcdAuthKey(pkeys))                                     //传送密钥到RC500FIFO
     
409.         {
     
410.              status = PcdAuthState(g_cReceBuf[6], g_cReceBuf[7], pSNR);     //验证密钥
     
411.         }
     
412.     }
     
413.     if (status == MI_OK)
     
414.     {    AnswerCommandOk();    }
     
415.     else
     
416.     {    AnswerErr(FAULT22);   }
     
417. }   
     
418. 
     
419. /////////////////////////////////////////////////////////////////////
     
420. //响应上位机读M1卡命令
     
421. /////////////////////////////////////////////////////////////////////
     
422. void ComM1Read()
     
423. {
     
424.     if (MI_OK == PcdRead(g_cReceBuf[6], &g_cReceBuf[0]))
     
425.     {         AnswerOk(&g_cReceBuf[0], 16);  }
     
426.     else
     
427.     {    AnswerErr(FAULT23);            }
     
428. }
     
429. 
     
430. /////////////////////////////////////////////////////////////////////
     
431. //响应上位机写M1卡命令
     
432. /////////////////////////////////////////////////////////////////////
     
433. void ComM1Write()
     
434. {
     
435.     if (MI_OK == PcdWrite(g_cReceBuf[6], &g_cReceBuf[7]))
     
436.     {    AnswerCommandOk();    }
     
437.     else
     
438.     {    AnswerErr(FAULT24);   }
     
439. }
     
440. 
     
441. /////////////////////////////////////////////////////////////////////
     
442. //响应上位机初始化钱包命令
     
443. /////////////////////////////////////////////////////////////////////
     
444. void ComM1Initval()
     
445. {
     
446.     g_cReceBuf[11]=~g_cReceBuf[7];g_cReceBuf[12]=~g_cReceBuf[8];
     
447.     g_cReceBuf[13]=~g_cReceBuf[9];g_cReceBuf[14]=~g_cReceBuf[10];
     
448.     g_cReceBuf[15]=g_cReceBuf[7];g_cReceBuf[16]=g_cReceBuf[8];
     
449.     g_cReceBuf[17]=g_cReceBuf[9];g_cReceBuf[18]=g_cReceBuf[10];
     
450.     g_cReceBuf[19]=g_cReceBuf[6];g_cReceBuf[20]=~g_cReceBuf[6];
     
451.     g_cReceBuf[21]=g_cReceBuf[6];g_cReceBuf[22]=~g_cReceBuf[6];
     
452.     if (MI_OK == PcdWrite(g_cReceBuf[6], &g_cReceBuf[7]))
     
453.     {    AnswerCommandOk();    }
     
454.     else
     
455.     {    AnswerErr(FAULT24);   }
     
456. }
     
457. 
     
458. /////////////////////////////////////////////////////////////////////
     
459. //响应上位机读钱包命令
     
460. /////////////////////////////////////////////////////////////////////
     
461. void ComM1Readval()
     
462. {
     
463.     if (MI_OK == PcdRead(g_cReceBuf[6], &g_cReceBuf[0]))
     
464.     {         AnswerOk(&g_cReceBuf[0], 4);   }
     
465.     else
     
466.     {    AnswerErr(FAULT23);         }
     
467. }
     
468. 
     
469. /////////////////////////////////////////////////////////////////////
     
470. //响应上位机扣款命令
     
471. /////////////////////////////////////////////////////////////////////
     
472. void ComM1Decrement()
     
473. {
     
474.     if (MI_OK == PcdValue(PICC_DECREMENT, g_cReceBuf[6], &g_cReceBuf[7]))
     
475.     {    AnswerCommandOk();    }
     
476.     else
     
477.     {    AnswerErr(FAULT24);   }
     
478. }
     
479.    
     
480. /////////////////////////////////////////////////////////////////////
     
481. //响应上位机充值命令
     
482. /////////////////////////////////////////////////////////////////////
     
483. void ComM1Increment()
     
484. {
     
485.     if (MI_OK == PcdValue(PICC_INCREMENT, g_cReceBuf[6], &g_cReceBuf[7]))
     
486.     {    AnswerCommandOk();    }
     
487.     else
     
488.     {    AnswerErr(FAULT24);   }
     
489. }
     
490. 
     
491. /////////////////////////////////////////////////////////////////////
     
492. //响应上位机M1卡回传命令
     
493. /////////////////////////////////////////////////////////////////////
     
494. void ComM1Restore()
     
495. {
     
496.     if (MI_OK == PcdRestore(g_cReceBuf[6]))
     
497.     {    AnswerCommandOk();    }
     
498.     else
     
499.     {    AnswerErr(FAULT23);   }
     
500. }
     
501. 
     
502. /////////////////////////////////////////////////////////////////////
     
503. //响应上位机M1卡值传送命令
     
504. /////////////////////////////////////////////////////////////////////
     
505. void ComM1Transfer()
     
506. {
     
507.     if (MI_OK == PcdTransfer(g_cReceBuf[6]))
     
508.     {    AnswerCommandOk();    }
     
509.     else
     
510.     {    AnswerErr(FAULT24);   }
     
511. }
     
512. 
     
513. /////////////////////////////////////////////////////////////////////
     
514. //响应上位机ultra light防冲撞命令
     
515. /////////////////////////////////////////////////////////////////////
     
516. void ComUL_PcdAnticoll()
     
517. {
     
518.     if (MI_OK == UL_PcdAnticoll(&g_cReceBuf[0]))
     
519.     {   AnswerOk(&g_cReceBuf[0], 7);  }
     
520.     else
     
521.     {   AnswerErr(FAULT10);    }   
     
522. }
     
523. 
     
524. /////////////////////////////////////////////////////////////////////
     
525. //响应上位机ultra light写卡命令
     
526. /////////////////////////////////////////////////////////////////////
     
527. void ComUL_PcdWrite()
     
528. {
     
529.     if (MI_OK == UL_PcdWrite(g_cReceBuf[6], &g_cReceBuf[7]))
     
530.     {   AnswerCommandOk();   }
     
531.     else
     
532.     {   AnswerErr(FAULT24);  }   
     
533. }
     
534. 
     
535. 
     
536. 
     
537. 
     
538. /////////////////////////////////////////////////////////////////////
     
539. //响应上位机高级复位TYPEB卡命令
     
540. /////////////////////////////////////////////////////////////////////
     
541. void ComTypeBRst()
     
542. {
     
543.     unsigned char status;
     
544.         
     
545.     if ((status = M531PiccRequestB(g_cReceBuf[6], 0, 0, &g_cReceBuf[0])) == MI_OK)
     
546.     {        
     
547.             g_cFWI    = 0xFF;//g_cReceBuf[11] >> 4;
     
548.             g_cCidNad = 8;//((g_cReceBuf[11]&0x02)<<1) | ((g_cReceBuf[11]&0x01)<<3);
     
549. //       status = M531PiccAttrib(&g_cReceBuf[1], g_cReceBuf[10]&0x0F, &g_cReceBuf[12]);   
     
550.   //  }
     
551. 
     
552. //   if (status == MI_OK)                {
     
553.        AnswerOk(&g_cReceBuf[0], 12);   }
     
554.     else
     
555.     {   AnswerErr(FAULT21);    }
     
556. }                    
     
557.                     
     
558. 
     
559. /////////////////////////////////////////////////////////////////////
     
560. //响应上位机HLTB3命令
     
561. /////////////////////////////////////////////////////////////////////
     
562. void ComHltb()
     
563. {
     
564.     if (MI_OK == M531PiccHltb(&g_cReceBuf[6]))
     
565.     {    AnswerCommandOk();    }
     
566.     else
     
567.     {    AnswerErr(FAULT10);   }
     
568.         M531PiccAttrib(&g_cReceBuf[1], g_cReceBuf[10]&0x0F, &g_cReceBuf[12]);
     
569. }
     
570. 
     
571. /////////////////////////////////////////////////////////////////////
     
572. //响应上位机HLTB4命令
     
573. /////////////////////////////////////////////////////////////////////
     
574. void ComCL_Deselect()
     
575. {
     
576.     if (MI_OK == CL_Deselect(0))
     
577.     {    AnswerCommandOk();    }
     
578.     else
     
579.     {    AnswerErr(FAULT10);   }
     
580. }
     
581. 
     
582. /////////////////////////////////////////////////////////////////////
     
583. //响应上位机AT88RF020卡验证密钥命令
     
584. /////////////////////////////////////////////////////////////////////
     
585. void ComRF020Check()        
     
586. {
     
587.     if (MI_OK == At88rf020Check(&g_cReceBuf[6]))
     
588.     {    AnswerCommandOk();    }
     
589.     else
     
590.     {    AnswerErr(FAULT22);   }
     
591. }
     
592. 
     
593. /////////////////////////////////////////////////////////////////////
     
594. //响应上位机AT88RF020卡读命令
     
595. /////////////////////////////////////////////////////////////////////
     
596. void ComRF020Read()        
     
597. {
     
598.     if (MI_OK == At88rf020Read(g_cReceBuf[6], &g_cReceBuf[0]))
     
599.     {    AnswerOk(&g_cReceBuf[0],8);   }
     
600.     else
     
601.     {    AnswerErr(FAULT23);         }
     
602. }
     
603. 
     
604. /////////////////////////////////////////////////////////////////////
     
605. //响应上位机AT88RF020卡写命令
     
606. /////////////////////////////////////////////////////////////////////
     
607. void ComRF020Write()        
     
608. {
     
609.     if (MI_OK == At88rf020Write(g_cReceBuf[6], &g_cReceBuf[7]))
     
610.     {    AnswerCommandOk();    }
     
611.     else
     
612.     {    AnswerErr(FAULT24);   }
     
613. }
     
614. 
     
615. /////////////////////////////////////////////////////////////////////
     
616. //响应上位机AT88RF020卡LOCK命令
     
617. /////////////////////////////////////////////////////////////////////
     
618. void ComRF020Lock()        
     
619. {
     
620.     if (MI_OK == At88rf020Lock(&g_cReceBuf[6]))
     
621.     {    AnswerCommandOk();    }
     
622.     else
     
623.     {    AnswerErr(FAULT24);   }
     
624. }
     
625. 
     
626. /////////////////////////////////////////////////////////////////////
     
627. //响应上位机AT88RF020卡COUNT命令
     
628. /////////////////////////////////////////////////////////////////////
     
629. void ComRF020Count()        
     
630. {
     
631.     if (MI_OK == At88rf020Count(&g_cReceBuf[6]))
     
632.     {    AnswerCommandOk();    }
     
633.     else
     
634.     {    AnswerErr(FAULT24);   }
     
635. }
     
636. 
     
637. /////////////////////////////////////////////////////////////////////
     
638. //响应上位机AT88RF020卡DESELECT命令
     
639. /////////////////////////////////////////////////////////////////////
     
640. void ComRF020Deselect()        
     
641. {
     
642.     if (MI_OK == At88rf020Deselect())
     
643.     {    AnswerCommandOk();    }
     
644.     else
     
645.     {    AnswerErr(FAULT10);   }
     
646. }
     
647. 
     
648. 
     
649. /////////////////////////////////////////////////////////////////////
     
650. //响应上位机激活ST卡片命令
     
651. /////////////////////////////////////////////////////////////////////
     
652. void ComSelectSR()
     
653. {
     
654.     if(MI_OK == SelectSR(&g_cReceBuf[0]))
     
655.     {    AnswerOk(&g_cReceBuf[0],1);   }
     
656.     else
     
657.     {    AnswerErr(FAULT20);    }   
     
658. }
     
659. 
     
660. /////////////////////////////////////////////////////////////////////
     
661. //响应上位机SR176读块命令
     
662. /////////////////////////////////////////////////////////////////////
     
663. void ComReadSR176()
     
664. {
     
665.     if (MI_OK == ReadSR176(g_cReceBuf[6], &g_cReceBuf[0]))
     
666.     {    AnswerOk(&g_cReceBuf[0],2);   }
     
667.     else
     
668.     {    AnswerErr(FAULT23);    }   
     
669. }
     
670. 
     
671. /////////////////////////////////////////////////////////////////////
     
672. //响应上位机SR176写块命令
     
673. /////////////////////////////////////////////////////////////////////
     
674. void ComWriteSR176()
     
675. {
     
676.     char status;
     
677.     if((status = WriteSR176(g_cReceBuf[6], &g_cReceBuf[7])) == MI_OK)
     
678.     {
     
679.         DelayMs(5);
     
680.         status = ReadSR176(g_cReceBuf[6], &g_cReceBuf[0]);
     
681.         if((status==MI_OK) && (g_cReceBuf[0]==g_cReceBuf[7]) && (g_cReceBuf[1]==g_cReceBuf[8]))
     
682.         {   AnswerCommandOk();   }
     
683.         else
     
684.         {   AnswerErr(FAULT24);  }
     
685.     }
     
686.     else
     
687.     {    AnswerErr(FAULT24);    }   
     
688. }
     
689. 
     
690. /////////////////////////////////////////////////////////////////////
     
691. //响应上位机SR176块锁定命令
     
692. /////////////////////////////////////////////////////////////////////
     
693. void ComProtectSR176()
     
694. {
     
695.     char status;
     
696.     if ((status = GetProtSR176(g_cReceBuf[0])) == MI_OK)
     
697.     {
     
698.         status = ProtectSR176(g_cReceBuf[6]);
     
699.         if (status == MI_OK)
     
700.         {
     
701.              DelayMs(5);
     
702.              status = GetProtSR176(g_cReceBuf[1]);
     
703.              if ((g_cReceBuf[0]|g_cReceBuf[6]) != g_cReceBuf[1])
     
704.                  {    status = MI_COM_ERR;   }
     
705.         }
     
706.     }   
     
707.     if (status == MI_OK)
     
708.     {   AnswerCommandOk();   }
     
709.     else
     
710.     {   AnswerErr(FAULT24);  }
     
711. }
     
712. 
     
713. /////////////////////////////////////////////////////////////////////
     
714. //响应上位机SR176卡COMPLETION命令
     
715. /////////////////////////////////////////////////////////////////////
     
716. void ComCompletionSR()
     
717. {
     
718.     if (MI_OK == CompletionSR())
     
719.     {    AnswerCommandOk();   }
     
720.     else
     
721.     {    AnswerErr(FAULT10);  }   
     
722. }
     
723. 
     
724. /////////////////////////////////////////////////////////////////////
     
725. //响应上位机SRIX4K读块命令
     
726. /////////////////////////////////////////////////////////////////////
     
727. void ComReadSR4K()
     
728. {
     
729.     if (MI_OK == ReadSR4K(g_cReceBuf[6], &g_cReceBuf[0]))
     
730.     {    AnswerOk(&g_cReceBuf[0],4);    }
     
731.     else
     
732.     {    AnswerErr(FAULT23);    }   
     
733. }
     
734. 
     
735. /////////////////////////////////////////////////////////////////////
     
736. //响应上位机SRIX4K写块命令
     
737. /////////////////////////////////////////////////////////////////////
     
738. void ComWriteSR4K()
     
739. {
     
740.     char status;
     
741.     if ((status = WriteSR4K(g_cReceBuf[6], &g_cReceBuf[7])) == MI_OK)
     
742.     {
     
743.         DelayMs(7);
     
744.         status = ReadSR4K(g_cReceBuf[6], &g_cReceBuf[0]);
     
745.         if ((status==MI_OK) && (g_cReceBuf[0]==g_cReceBuf[7]) && (g_cReceBuf[1]==g_cReceBuf[8])
     
746.             && (g_cReceBuf[2]==g_cReceBuf[9]) && (g_cReceBuf[3]==g_cReceBuf[10]))
     
747.         {   AnswerCommandOk();   }
     
748.         else
     
749.         {   AnswerErr(FAULT24);  }
     
750.     }
     
751.     else
     
752.     {   AnswerErr(FAULT24);    }   
     
753. }
     
754. 
     
755. /////////////////////////////////////////////////////////////////////
     
756. //响应上位机SRIX4K卡AUTHENTICATE命令
     
757. /////////////////////////////////////////////////////////////////////
     
758. void ComAuthSR4K()
     
759. {
     
760.     if (MI_OK == AuthSR4K(&g_cReceBuf[6], &g_cReceBuf[0]))
     
761.     {   AnswerOk(&g_cReceBuf[0], 3);  }
     
762.     else
     
763.     {   AnswerErr(FAULT22);    }   
     
764. }
     
765. 
     
766. /////////////////////////////////////////////////////////////////////
     
767. //响应上位机SRIX4K读UID命令
     
768. /////////////////////////////////////////////////////////////////////
     
769. void ComGetUIDSR4K()
     
770. {
     
771.     if (MI_OK == GetUIDSR4K(&g_cReceBuf[0]))
     
772.     {   AnswerOk(&g_cReceBuf[0], 8);  }
     
773.     else
     
774.     {   AnswerErr(FAULT23);    }   
     
775. }
     
776. 
     
777. /////////////////////////////////////////////////////////////////////
     
778. //响应上位机SRIX4K块锁定命令
     
779. /////////////////////////////////////////////////////////////////////
     
780. void ComProtectSR4K()
     
781. {
     
782.     char status;
     
783.     if ((status = ReadSR4K(0xFF, &g_cReceBuf[0])) == MI_OK)
     
784.     {
     
785.         status = WriteSR4K(0xFF, &g_cReceBuf[6]);
     
786.         if (status == MI_OK)
     
787.         {
     
788.              DelayMs(7);
     
789.              status = ReadSR4K(0xFF, &g_cReceBuf[1]);
     
790.              if ((g_cReceBuf[0]&g_cReceBuf[6]) != g_cReceBuf[1])
     
791.                  {    status = MI_COM_ERR;   }
     
792.         }
     
793.     }   
     
794.     if (status == MI_OK )
     
795.     {   AnswerCommandOk();   }
     
796.     else
     
797.     {   AnswerErr(FAULT24);  }
     
798. }
     
799. 
     
800. 
     
801. /////////////////////////////////////////////////////////////////////
     
802. //响应上位机ISO15693_Inventory命令
     
803. /////////////////////////////////////////////////////////////////////
     
804. void ComISO15693_Inventory16()
     
805. {
     
806.      if (MI_OK == ISO15693_Inventory16(0x16,0x00,0x00,&g_cReceBuf[0],&g_cReceBuf[0], &g_cReceBuf[1]))
     
807.      {   AnswerOk(&g_cReceBuf[1], g_cReceBuf[0]);  }
     
808.      else
     
809.      {   AnswerErr( FAULT20 );   }
     
810. }
     
811. 
     
812. /////////////////////////////////////////////////////////////////////
     
813. //响应上位机ISO15693_Inventory命令
     
814. /////////////////////////////////////////////////////////////////////
     
815. void ComISO15693_Inventory()
     
816. {
     
817.      if (MI_OK == ISO15693_Inventory(0x36,0x00,0x00,&g_cReceBuf[0],&g_cReceBuf[0]))
     
818.      {   AnswerOk(&g_cReceBuf[0], 9);  }
     
819.      else
     
820.      {   AnswerErr( FAULT20 );   }
     
821. }
     
822.      
     
823. /////////////////////////////////////////////////////////////////////
     
824. //响应上位机ISO15693_Stay_Quiet命令
     
825. /////////////////////////////////////////////////////////////////////
     
826. void ComISO15693_Stay_Quiet()
     
827. {
     
828.      if (MI_OK == ISO15693_Stay_Quiet(0x22, &g_cReceBuf[6]))
     
829.      {   AnswerCommandOk();   }
     
830.      else
     
831.      {   AnswerErr(FAULT10);  }
     
832. }
     
833. 
     
834. /////////////////////////////////////////////////////////////////////
     
835. //响应上位机ISO15693_Select命令
     
836. /////////////////////////////////////////////////////////////////////     
     
837. void ComISO15693_Select()
     
838. {
     
839.      if (MI_OK == ISO15693_Select(0x22, &g_cReceBuf[6]))
     
840.      {   AnswerCommandOk();   }
     
841.      else
     
842.      {   AnswerErr(FAULT10);  }
     
843. }
     
844. 
     
845. /////////////////////////////////////////////////////////////////////
     
846. //响应上位机ISO15693_Reset_To_Ready命令
     
847. /////////////////////////////////////////////////////////////////////     
     
848. void ComISO15693_Reset_To_Ready()
     
849. {
     
850.      unsigned char flags = 0x02;
     
851.      flags |= g_cReceBuf[6] << 4;
     
852.      if (MI_OK == ISO15693_Reset_To_Ready(flags, &g_cReceBuf[7]) )
     
853.      {   AnswerCommandOk();   }
     
854.      else
     
855.      {   AnswerErr(FAULT10);  }
     
856. }
     
857. 
     
858. /////////////////////////////////////////////////////////////////////
     
859. //响应上位机ISO15693_Read命令
     
860. /////////////////////////////////////////////////////////////////////     
     
861. void ComISO15693_Read_sm()
     
862. {
     
863.      unsigned char flags = 0x02;
     
864.      flags |= g_cReceBuf[6] << 4;
     
865.      if (MI_OK == ISO15693_Read_sm(flags,&g_cReceBuf[7],g_cReceBuf[15],g_cReceBuf[16],&g_cReceBuf[0],&g_cReceBuf[1]))
     
866.      {   AnswerOk(&g_cReceBuf[1],g_cReceBuf[0]);  }
     
867.      else
     
868.      {   AnswerErr(FAULT23);    }
     
869. }
     
870. 
     
871. /////////////////////////////////////////////////////////////////////
     
872. //响应上位机ISO15693_Write命令
     
873. /////////////////////////////////////////////////////////////////////     
     
874. void ComISO15693_Write_sm()
     
875. {
     
876.      unsigned char flags = 0x02;
     
877.      flags |= g_cReceBuf[6] << 4;
     
878.      if (MI_OK == ISO15693_Write_sm(flags, &g_cReceBuf[7], g_cReceBuf[15], &g_cReceBuf[16]) )
     
879.      {   AnswerCommandOk();   }
     
880.      else
     
881.      {   AnswerErr(FAULT24);  }
     
882. }
     
883. 
     
884. /////////////////////////////////////////////////////////////////////
     
885. //响应上位机ISO15693_Lock_Block命令
     
886. /////////////////////////////////////////////////////////////////////     
     
887. void ComISO15693_Lock_Block()
     
888. {
     
889.      unsigned char flags = 0x02;
     
890.      flags |= g_cReceBuf[6] << 4;
     
891.      if (MI_OK == ISO15693_Lock_Block(flags, &g_cReceBuf[7], g_cReceBuf[15]))
     
892.      {   AnswerCommandOk();   }
     
893.      else
     
894.      {   AnswerErr(FAULT24);  }
     
895. }
     
896. 
     
897. /////////////////////////////////////////////////////////////////////
     
898. //响应上位机ISO15693_Write_AFI命令
     
899. /////////////////////////////////////////////////////////////////////     
     
900. void ComISO15693_Write_AFI()
     
901. {
     
902.      unsigned char flags = 0x02;
     
903.      flags |= g_cReceBuf[6] << 4;
     
904.      if (MI_OK == ISO15693_Write_AFI(flags, &g_cReceBuf[7], g_cReceBuf[15]))
     
905.      {   AnswerCommandOk();   }
     
906.      else
     
907.      {   AnswerErr(FAULT24);  }
     
908. }
     
909. 
     
910. /////////////////////////////////////////////////////////////////////
     
911. //响应上位机ISO15693_Lock_AFI命令
     
912. /////////////////////////////////////////////////////////////////////     
     
913. void ComISO15693_Lock_AFI()
     
914. {
     
915.      unsigned char flags = 0x02;
     
916.      flags |= g_cReceBuf[6] << 4;
     
917.      if (MI_OK == ISO15693_Lock_AFI(flags, &g_cReceBuf[7]) )
     
918.      {   AnswerCommandOk();   }
     
919.      else
     
920.      {   AnswerErr(FAULT24);  }
     
921. }
     
922. 
     
923. /////////////////////////////////////////////////////////////////////
     
924. //响应上位机ISO15693_Write_DSFID命令
     
925. /////////////////////////////////////////////////////////////////////     
     
926. void ComISO15693_Write_DSFID()
     
927. {
     
928.      unsigned char flags = 0x02;
     
929.      flags |= g_cReceBuf[6] << 4;
     
930.      if (MI_OK == ISO15693_Write_DSFID(flags, &g_cReceBuf[7], g_cReceBuf[15]) )
     
931.      {   AnswerCommandOk();   }
     
932.      else
     
933.      {   AnswerErr(FAULT24);  }
     
934. }
     
935. 
     
936. /////////////////////////////////////////////////////////////////////
     
937. //响应上位机ISO15693_Lock_DSFID命令
     
938. /////////////////////////////////////////////////////////////////////     
     
939. void ComISO15693_Lock_DSFID()
     
940. {
     
941.      unsigned char flags = 0x02;
     
942.      flags |= g_cReceBuf[6] << 4;
     
943.      if (MI_OK == ISO15693_Lock_DSFID(flags, &g_cReceBuf[7]))
     
944.      {   AnswerCommandOk();   }
     
945.      else
     
946.      {   AnswerErr(FAULT24);  }
     
947. }
     
948. 
     
949. /////////////////////////////////////////////////////////////////////
     
950. //响应上位机ISO15693_Get_System_Information命令
     
951. /////////////////////////////////////////////////////////////////////     
     
952. void ComISO15693_Get_System_Information()
     
953. {
     
954.      unsigned char flags = 0x02;
     
955.      flags |= g_cReceBuf[6] << 4;
     
956.      if (MI_OK == ISO15693_Get_System_Information(flags, &g_cReceBuf[7], &g_cReceBuf[0], &g_cReceBuf[1]))
     
957.      {   AnswerOk(&g_cReceBuf[1],g_cReceBuf[0]);  }
     
958.      else
     
959.      {   AnswerErr(FAULT23);   }
     
960. }
     
961. 
     
962. /////////////////////////////////////////////////////////////////////
     
963. //响应上位机ISO15693_Get_Multiple_Block_Security命令
     
964. /////////////////////////////////////////////////////////////////////     
     
965. void ComISO15693_Get_Multiple_Block_Security()
     
966. {
     
967.      unsigned char flags = 0x02;
     
968.      flags |= g_cReceBuf[6] << 4;
     
969.      if (MI_OK == ISO15693_Get_Multiple_Block_Security(flags,&g_cReceBuf[7],g_cReceBuf[15],g_cReceBuf[16],&g_cReceBuf[0],&g_cReceBuf[1]))
     
970.      {   AnswerOk(&g_cReceBuf[1],g_cReceBuf[0]);  }
     
971.      else
     
972.      {   AnswerErr(FAULT23);  }
     
973. }
     
974. 
     
975. /////////////////////////////////////////////////////////////////////
     
976. //正确执行完上位机指令，应答（无返回数据）
     
977. /////////////////////////////////////////////////////////////////////
     
978. void AnswerCommandOk()
     
979. {   
     
980.      unsigned char i,chkdata;
     
981.      chkdata = 0;
     
982.      
     
983.      TI   = 0;                         //发送命令头         
     
984.      SBUF = 0xAA;
     
985.      while (!TI);           
     
986.      TI   = 0;
     
987.      SBUF = 0xBB;
     
988.      while (!TI);
     
989.      
     
990.      TI   = 0;                         //发送长度字
     
991.      SBUF = 0x06;
     
992.      while (!TI);           
     
993.      TI   = 0;
     
994.      SBUF = 0x00;
     
995.      while (!TI);           
     
996.          
     
997.      TI   = 0;                         //发送设备标识
     
998.      SBUF = g_cIcdevH;
     
999.      while (!TI);
     
1000.      if (g_cIcdevH == 0xAA)
      
1001.      {
      
1002.              TI   = 0;
      
1003.              SBUF = 0;
      
1004.              while (!TI);
      
1005.      }
      
1006.      TI   = 0;
      
1007.      SBUF = g_cIcdevL;
      
1008.      while (!TI);
      
1009.      if (g_cIcdevL == 0xAA)
      
1010.      {
      
1011.              TI   = 0;
      
1012.              SBUF = 0;
      
1013.              while (!TI);
      
1014.      }
      
1015.      
      
1016.      TI   = 0;                         //发送命令码                     
      
1017.      i = (unsigned char)(g_cCommand & 0xFF);
      
1018.      SBUF = i;
      
1019.      chkdata ^= i;
      
1020.      while (!TI);
      
1021. 
      
1022.      TI   = 0;                         //发送命令码
      
1023.      i = (unsigned char)((g_cCommand >>8) & 0xFF);
      
1024.      SBUF = i;
      
1025.      chkdata ^= i;
      
1026.      while (!TI);
      
1027. 
      
1028.      TI   = 0;                         //发送状态字
      
1029.      SBUF = 0;
      
1030.      while (!TI);           
      
1031.      
      
1032.      TI   = 0;                         //发送效验字
      
1033.      chkdata ^= g_cIcdevH^ g_cIcdevL;
      
1034.      SBUF = chkdata;
      
1035.      while (!TI);           
      
1036.      if (chkdata == 0xAA)
      
1037.      {
      
1038.              TI   = 0;
      
1039.              SBUF = 0;
      
1040.              while (!TI);
      
1041.      }
      
1042.      TI = 0;
      
1043.      ES = 1;
      
1044. }
      
1045. 
      
1046. /////////////////////////////////////////////////////////////////////
      
1047. //正确执行完上位机指令，应答（有返回数据）
      
1048. //input：answerdata = 应答数据
      
1049. //       answernum  = 数据长度
      
1050. /////////////////////////////////////////////////////////////////////
      
1051. void AnswerOk(unsigned char *answerdata, unsigned int answernum)
      
1052. {   
      
1053.      unsigned char chkdata;
      
1054.      unsigned int i;
      
1055.      
      
1056.      TI   = 0;                         //发送命令头         
      
1057.      SBUF = 0xAA;
      
1058.      while (!TI);           
      
1059.      TI   = 0;
      
1060.      SBUF = 0xBB;
      
1061.      while (!TI);
      
1062.      
      
1063.      TI   = 0;                         //长度字，包括状态字和效验字
      
1064.      chkdata = (((unsigned char)((answernum + 6) & 0xFF)));
      
1065.      SBUF = chkdata;
      
1066.      while (!TI);           
      
1067.      TI   = 0;
      
1068.      chkdata = (((unsigned char)(((answernum + 6)>>8) & 0xFF)));
      
1069.      SBUF = chkdata;
      
1070.      while (!TI);           
      
1071.      
      
1072.      TI   = 0;                         //发送设备标识
      
1073.      SBUF = g_cIcdevH;
      
1074.      while(!TI);
      
1075.      if (g_cIcdevH == 0xAA)
      
1076.      {
      
1077.              TI   = 0;
      
1078.              SBUF = 0;
      
1079.              while (!TI);
      
1080.      }
      
1081.      TI   = 0;
      
1082.      SBUF = g_cIcdevL;
      
1083.      while(!TI);
      
1084.      if (g_cIcdevL == 0xAA)
      
1085.      {
      
1086.              TI   = 0;
      
1087.              SBUF = 0;
      
1088.              while (!TI);
      
1089.      }
      
1090.      
      
1091.      TI   = 0;                         //发送命令码
      
1092.      i = (unsigned char)(g_cCommand & 0xFF);
      
1093.          SBUF = i;
      
1094.          chkdata ^= i;
      
1095.      while (!TI);
      
1096. 
      
1097.          TI   = 0;                         //发送命令码
      
1098.      i = (unsigned char)((g_cCommand >>8) & 0xFF);
      
1099.          SBUF = i;
      
1100.          chkdata ^= i;
      
1101.      while (!TI);
      
1102.      
      
1103.      TI   = 0;                         //状态字
      
1104.      SBUF = 0;
      
1105.      while (!TI);           
      
1106.      
      
1107.      chkdata ^= g_cIcdevH ^ g_cIcdevL;
      
1108.      for (i=0; i<answernum; i++)
      
1109.      {   
      
1110.                TI   = 0;
      
1111.                chkdata ^= *(answerdata+i);
      
1112.                SBUF = *(answerdata+i);               
      
1113.           while (!TI);
      
1114.           if (*(answerdata + i) == 0xAA)
      
1115.           {
      
1116.               TI   = 0;
      
1117.               SBUF = 0;
      
1118.               while (!TI);
      
1119.           }
      
1120.      }
      
1121.      
      
1122.      TI   = 0;                         //效验字
      
1123.      SBUF = chkdata;
      
1124.      while(!TI);           
      
1125.      
      
1126.      if (chkdata == 0xAA)
      
1127.      {
      
1128.          TI=0;
      
1129.          SBUF=0;
      
1130.          while (!TI);
      
1131.      }
      
1132.      
      
1133.      TI = 0;
      
1134.      ES = 1;
      
1135. }
      
1136. 
      
1137. /////////////////////////////////////////////////////////////////////
      
1138. //未能正确执行上位机指令，应答
      
1139. //input:faultcode = 错误代码
      
1140. /////////////////////////////////////////////////////////////////////
      
1141. void AnswerErr(char faultcode)
      
1142. {   
      
1143.      unsigned char i,chkdata;
      
1144.      chkdata = 0;
      
1145. 
      
1146.      TI   = 0;                         //发送命令头         
      
1147.      SBUF = 0xAA;
      
1148.      while (!TI);           
      
1149.      TI   = 0;
      
1150.      SBUF = 0xBB;
      
1151.      while (!TI);
      
1152.      
      
1153.      TI   = 0;                         //发送长度字
      
1154.      SBUF = 0x06;
      
1155.      while (!TI);           
      
1156.      TI   = 0;
      
1157.      SBUF = 0x00;
      
1158.      while (!TI);           
      
1159.          
      
1160.      TI   = 0;                         //发送设备标识
      
1161.      SBUF = g_cIcdevH;
      
1162.      while (!TI);
      
1163.      if (g_cIcdevH == 0xAA)
      
1164.      {
      
1165.              TI   = 0;
      
1166.              SBUF = 0;
      
1167.              while (!TI);
      
1168.      }
      
1169.      TI   = 0;
      
1170.      SBUF = g_cIcdevL;
      
1171.      while (!TI);
      
1172.      if (g_cIcdevL == 0xAA)
      
1173.      {
      
1174.              TI   = 0;
      
1175.              SBUF = 0;
      
1176.              while (!TI);
      
1177.      }
      
1178.      
      
1179.      TI   = 0;                         //发送命令码                     
      
1180.      i = (unsigned char)(g_cCommand & 0xFF);
      
1181.          SBUF = i;
      
1182.          chkdata ^= i;
      
1183.      while (!TI);
      
1184. 
      
1185.          TI   = 0;                         //发送命令码
      
1186.      i = (unsigned char)((g_cCommand >>8) & 0xFF);
      
1187.          SBUF = i;
      
1188.          chkdata ^= i;
      
1189.      while (!TI);
      
1190. 
      
1191.      TI   = 0;                         //发送错误代码
      
1192.      SBUF = faultcode;
      
1193.      while (!TI);              
      
1194.      
      
1195.      chkdata = g_cIcdevH ^ g_cIcdevL ^ faultcode;
      
1196.      TI   = 0;                         //效验字
      
1197.      SBUF = chkdata;
      
1198.      while (!TI);
      
1199.      
      
1200.      TI   = 0;
      
1201.      ES   = 1;
      
1202. }
      
1203. 
      
1204. /////////////////////////////////////////////////////////////////////
      
1205. //串行中断，接收上位机数据
      
1206. /////////////////////////////////////////////////////////////////////
      
1207. seri_int () interrupt 4 using 1
      
1208. 
      
1209. {
      
1210.    unsigned int i,j;
      
1211.    unsigned char rece_data = SBUF;
      
1212.    unsigned char verify = 0;
      
1213.    if (RI)
      
1214.    {   
      
1215.        RI = 0;
      
1216.            if (g_bReceAA)
      
1217.            {  
      
1218.                g_bReceAA = 0;
      
1219.                switch (rece_data)
      
1220.                {   
      
1221.                         case 0x00:
      
1222.                       break;
      
1223.                    case 0xBB:
      
1224.                       g_cReceNum = 0;
      
1225.                       break;
      
1226.                    default:
      
1227.                       i = g_cReceNum;
      
1228.                       g_cReceBuf[i] = rece_data;
      
1229.                       break;
      
1230.                }
      
1231.            }
      
1232.            else
      
1233.            {   
      
1234.                switch (rece_data)
      
1235.                {   
      
1236.                         case 0xAA:
      
1237.                       g_bReceAA = 1;
      
1238.                    default:
      
1239.                       i = g_cReceNum++;
      
1240.                       g_cReceBuf[i] = rece_data;
      
1241.                       break;
      
1242.                }
      
1243.            }
      
1244.            i = (((unsigned int)(g_cReceBuf[1]<<8)) + (unsigned int)(g_cReceBuf[0]));
      
1245.            if ((g_cReceNum == i + 2) && ( i != 0 ))
      
1246.        {   
      
1247.             for (j=1; j<g_cReceNum; j++)
      
1248.             {   verify ^= g_cReceBuf[j];    }
      
1249.             if (!verify)
      
1250.                 {   
      
1251.                         g_bReceOk  = 1;
      
1252.                         g_cCommand = (((unsigned int)(g_cReceBuf[5]<<8)) + (unsigned int)(g_cReceBuf[4]));
      
1253.                         g_bReceAA  = 0;
      
1254.                                 sond =  0;
      
1255.                         ES = 0;
      
1256.                 }
      
1257.         }
      
1258. 
      
1259.         if (g_cReceNum >= sizeof(g_cReceBuf))
      
1260.         {   g_cReceNum=0;   }
      
1261.     }
      
1262.     if (TI)
      
1263.     {        TI = 0;   }
      
1264. }
      
1265. 
      
1266. 
      
1267. void DelayMs(unsigned int _MS)
      
1268. {
      
1269.         unsigned char  i=0;
      
1270.         while(_MS--)
      
1271.         {
      
1272.        for(i=0;i<120;i++)
      
1273.           {
      
1274.                  _nop_();_nop_();_nop_();_nop_();
      
1275.          
      
1276.           }
      
1277.    }
      
1278. }
      
1279. void Delay_50us(unsigned char _50us)
      
1280. {
      
1281.     unsigned char i;
      
1282.         while(_50us--)
      
1283.         for(i=0;i<25;i++);
      
1284. }
      
1285. 
      
1286. 
      

复制代码

支持一下~~~~~~~~~

看看~~~~~~~~~~~~~~~

好东西，  正好需要。

不是SPI接口的！

感谢大佬，有用有用

感谢~感谢~感谢

学习一下，代码不是SPI的驱动。

资料太少