开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > RFID编程 > 查看源码
FM1702.c
资源名称：FM1702.rar　[点击查看]
上传用户：guangya188
上传日期：2019-10-26
资源大小：4644k
文件大小：27k
源码类别：

RFID编程

开发平台：

C/C++

FM1702.c：源码内容
  3. #include <reg52.h>
  4. #define __SRC
  5. #include "main.h"
  6. #undef  __SRC
  7. #include <intrins.h>
  8. //#include <string.h>
  9. //#include <stdio.h>
  10. //#include <absacc.h>
  14. #include "FM1702.h"
  17. #define uchar unsigned char
  18. #define uint unsigned int
  19.    
  21. sbit RF_MISO = P1^0;
  22. sbit RF_MOSI = P1^1;
  23. sbit RF_SCK = P1^2;
  24. sbit RF_NSS = P1^3;
  25. sbit RF_RST   =   P1^4;
  27. sbit CARD_LED = P2^0;
  28. sbit SPEAKER    =   P2^0; 
  30. char spi_byte_transceive(char sendbyte)
  31. {
  32.   char i,temp;
  33.   for(i=0;i<8;i++)
  34.    {  
  35.     RF_SCK=0;
  36.     if(sendbyte & 0x80)                         { 
  37.       RF_MOSI=1;
  38.      }
  39.     else
  40.      { 
  41.       RF_MOSI=0;
  42.      }
  43.     sendbyte <<= 1;
  44.     RF_SCK=1;
  45.     temp <<= 1;
  46.     if(RF_MISO)
  47.     temp |= 0x01;
  48.    }
  49.     RF_SCK=0;
  50.      _nop_();
  51.  _nop_();
  52.     RF_MOSI=0;
  53.     return (temp);
  54. }
  56. void SPIWrite(char reg_ad,char reg_data)
  57. {   
  58.     RF_SCK=0;
  59.     reg_ad <<= 1;
  60.     RF_NSS=0;
  61.     reg_ad &= 0x7F;
  62.     spi_byte_transceive(reg_ad);
  63.     spi_byte_transceive(reg_data);
  64.     RF_NSS=1;
  65.     return;
  66. }
  69. unsigned char SPIRead(char reg_ad)
  70. {   char temp;
  71.     RF_SCK=0;
  72.      _nop_();
  73.      _nop_();
  74.     RF_NSS=0;
  75.     reg_ad <<= 1;
  76.     reg_ad |= 0x80;
  77.     spi_byte_transceive(reg_ad);
  78.     temp=spi_byte_transceive(0x00);
  79.     RF_NSS=1;
  80.     return (temp);
  81. }
  84. void main(void)
  85. { 
  86.     uchar baud;
  87.     InitSystem();        
  88.  while (1)
  89.     {
  91. //检查命令标志
  92.       if (CmdValid)     {
  93.     CmdValid = FALSE;
  94.     if(RevBuffer[0]==11)  
  95.     {
  96.      RevBuffer[2]=RevBuffer[1];
  97.         RevBuffer[0]=1;         
  98.      RevBuffer[1]=0;
  99.      CALL_isr_UART();
  100.      SPEAKER=0;              
  101. delay_10ms(RevBuffer[2]);
  102.      SPEAKER=1;
  103.     }
  104.       else if(RevBuffer[0]==13)         {
  105.      switch(RevBuffer[1])
  106.      {
  107.      case 0:
  108.      baud=BAUD_9600;
  109.      break;
  110.      case 1:
  111.      baud=BAUD_14400;
  112.      break;
  113.      case 2:
  114.      baud=BAUD_19200;
  115.      break;
  116.      case 3:
  117.      baud=BAUD_28800;
  118.      break;
  119.      case 4:
  120.      baud=BAUD_38400;
  121.      break;
  122.      case 5:
  123.      baud=BAUD_57600;
  124.      break;
  125.      case 6:
  126.      baud=BAUD_115200;
  127.      break;
  128.      default:
  129.      baud=BAUD_19200;
  130.      break;
  131.      }
  132.      RevBuffer[0]=1;         
  133.      RevBuffer[1]=0;
  134.      CALL_isr_UART();
  135.      delay_10ms(5);
  136.      TR1   = 0;
  137.      TH1   = baud;
  138.      TL1   = TH1;
  139.      delay_10ms(2);
  140.      TR1   = TRUE;
  141.      }//if LEVEL 2
  142.         else
  143.      {
  144.      cmd_process();        
  145.      CALL_isr_UART();
  146.      }
  147.      }
  148.     }//while循环体
  149. }
  152. void InitSystem(void)
  153. {
  154.     RF_NSS=1;
  155. RF_RST=0;
  156. ET2 = 0; 
  157. T2CON = 0x04;
  158.     PCON = 0x80;        
  159.     SCON = 0x70;    
  161. //TMOD = 0x22;
  162.     TMOD = 0x21;    
  164. TH1   = BAUD_19200;  
  165. TL1   = TH1;
  166. TR1   = TRUE;        
  168. TH0 = 0x60;
  169.     TL0 = 0x60;
  170.     TR0 = 0;
  171.     
  172.     ET0=0;
  173. ET1=0;
  174. EA=1;
  175. EX0=1;
  176. IT0 = 1;
  177. TR2=0;
  178.   ES = TRUE;    
  179. CmdValid=0; 
  182. SPEAKER=0;
  183. delay_10ms(10);
  184. delay_10ms(10);
  185. SPEAKER=1;    
  186. Init_FM1702(0);                 
  188. }
  189. void isr_UART(void) interrupt 4 using 1
  190. {
  191.     uchar len, i;
  192.    unsigned int j=0;
  193.   
  194.    if(RI)
  195. {
  196. len=SBUF;
  197. RI=0;
  198. for(i=0;i<len;i++)
  199. {
  200. while(!RI)
  201. {
  202. j++;
  203. if(j>1000)
  204. {
  205.     break;
  206. }
  207. }
  208. if(j<1000)
  209. {
  210. RevBuffer[i]=SBUF;
  211. RI=0;
  212. j=0;
  213. }
  214. else
  215. {
  216.     break;
  217. }
  218. }
  219. if(i==len)
  220. {
  221. REN=0;
  222. CmdValid=1;
  223. }
  224. }
  225. else if(!RI && TI)
  226. {
  227. TI=0;
  228. len=RevBuffer[0];
  229. for(i=0;i<len+1;i++)
  230. {
  231. SBUF=RevBuffer[i];
  232. while(!TI);
  233. TI=0;
  234. }
  235. REN=1;
  236. }
  237. }
  238. void cmd_process(void)
  239. {
  240.     uchar cmd;
  241.     uchar status;
  243. cmd = RevBuffer[0];
  244. switch(cmd)
  245. {
  246. case 1:     
  247. status=MIF_Halt();
  248. RevBuffer[0]=1;
  249. RevBuffer[1]=status;
  250. break;
  251. case 2:     
  252.          status = Request(RF_CMD_REQUEST_ALL);
  253.          if(status != FM1702_OK)
  254.          {
  255.              status = Request(RF_CMD_REQUEST_ALL);
  256.              if(status != FM1702_OK)
  257.              {
  258.                  RevBuffer[0] = 1;
  259.                  RevBuffer[1] = FM1702_REQERR;
  261.                  break;
  262.              }
  263.          }
  264. if(tagtype[0]==2)
  265. cardtype=mifarepro;     
  266. else if(tagtype[0]==4)
  267. cardtype=mifare1;       
  268. else if(tagtype[0]==16)
  269. cardtype=mifarelight;   
  270. else
  271. cardtype=unknowncard;
  272. RevBuffer[0]=3;
  273. RevBuffer[1]=status;
  274. RevBuffer[2]=tagtype[0];
  275. RevBuffer[3]=tagtype[1];
  276. break;
  277.     case 3:                         
  278. status = AntiColl();;
  279. if(status!=FM1702_OK)
  280. {
  281. RevBuffer[0]=1;
  282. RevBuffer[1]=FM1702_ANTICOLLERR;
  283. break;
  284. }
  285. //memcpy(MLastSelectedSnr,&RevBuffer[2],4);
  286. RevBuffer[0]=5;
  287. RevBuffer[1]=status;
  288. RevBuffer[2]=UID[0];
  289. RevBuffer[3]=UID[1];
  290. RevBuffer[4]=UID[2];
  291. RevBuffer[5]=UID[3];
  292. break;
  293. case 4:                     
  294. status=Select_Card();
  295. if(status!=FM1702_OK)
  296. {
  297. RevBuffer[0]=1;
  298. RevBuffer[1]=FM1702_SELERR;
  299. break;
  300. }
  301. RevBuffer[0]=1;
  302. RevBuffer[1]=status;
  303. break;
  305.         case 5:                       
  306. status = Load_keyE2(RevBuffer[2],RevBuffer[1]);   
  307. status = Authentication(UID, RevBuffer[2], RevBuffer[1]);
  308.          if(status != FM1702_OK)
  309.          {
  310.          RevBuffer[0]=1;
  311.     RevBuffer[1]=status;
  312.     break;
  313.          }
  314. RevBuffer[0]=1;
  315. RevBuffer[1]=status;
  316. break;
  319. case 6:     
  320.              
  321. status = Load_keyE2_CPY(RevBuffer[2],RevBuffer[1]);   //%40
  322.          if(status != FM1702_OK)
  323.          {
  324.          RevBuffer[0]=1;
  325.     RevBuffer[1]=status;
  326.     break;
  327.          }
  328. RevBuffer[0]=1;
  329. RevBuffer[1]=status;
  330. break;
  333. case 8:                       
  334. status=MIF_READ(&RevBuffer[2],RevBuffer[1]);
  335. if(status != FM1702_OK)
  336. {
  337.     RevBuffer[0]=1;
  338.     RevBuffer[1]=status;
  339.     break;
  340. }
  341. else
  342. {
  343. if(cardtype==mifare1||cardtype==mifarepro)
  344. RevBuffer[0]=17;
  345. else if(cardtype==1)
  346. RevBuffer[0]=9;
  347. else
  348. RevBuffer[0]=16;
  349. }
  350. RevBuffer[1]=status;
  351. break;
  352. case 9:                  
  353. status=MIF_Write(&RevBuffer[2],RevBuffer[1]);
  354. RevBuffer[0]=1;
  355. RevBuffer[1]=status;
  356. break;
  357. case 10:                
  358. if(RevBuffer[1] == RF_CMD_INC)
  359. {
  360.     status = MIF_Increment(&RevBuffer[3],RevBuffer[2]);
  361.     MIF_Transfer(RevBuffer[2]);
  362. }
  363. else if(RevBuffer[1] == RF_CMD_DEC)
  364. {
  365.     status = MIF_Decrement(&RevBuffer[3],RevBuffer[2]);   
  366.     MIF_Transfer(RevBuffer[2]);
  367. }
  368. else
  369. {
  370.     status = 1;
  371. }
  372. RevBuffer[0]=1;
  373. RevBuffer[1]=status;
  374. break;
  375. case 12:    
  376. RevBuffer[0]=1;
  377. RevBuffer[1]=0;
  378. break;
  379. default:
  380.     RevBuffer[0] = 1;
  381.     RevBuffer[1] = 1;
  382.     break;
  383. }
  384. }
  388. uchar Clear_FIFO(void)
  389. {
  390. uchar temp;
  391. uint i;
  392. temp = SPIRead(Control);
  393. temp = (temp | 0x01);
  394. SPIWrite(Control,temp);
  395. for(i = 0; i < RF_TimeOut; i++) 
  396. {
  397. temp = SPIRead(FIFO_Length);
  398. if(temp == 0)
  399. {
  400. return TRUE;
  401. }
  402. }
  404. return FALSE;
  405. }
  407. void Write_FIFO(uchar count, uchar idata *buff)
  408. {
  409. uchar i;
  411. for(i = 0; i < count; i++)
  412. {
  413. SPIWrite(FIFO,*(buff + i));
  414. }
  415. }
  417. uchar Read_FIFO(uchar idata *buff)
  418. {
  419. uchar temp;
  420. uchar i;
  422. temp = SPIRead(FIFO_Length);
  423. if(temp == 0)
  424. {
  425. return 0;
  426. }
  428. if(temp >= 24)
  429. {
  431. temp = 24;
  432. }
  434. for(i = 0; i < temp; i++)
  435. {
  436. *(buff + i) = SPIRead(FIFO);
  437. }
  439. return temp;
  440. }
  442. uchar Judge_Req(uchar idata *buff)
  443. {
  445. uchar temp1, temp2;
  447. temp1 = *buff;
  448. temp2 = *(buff + 1);
  449. if((temp1 == 0x02) || (temp1 == 0x04) || (temp1 == 0x05) || (temp1 == 0x53) || (temp1 == 0x03))
  450. {
  451. if (temp2 == 0x00)
  452. {
  453. return TRUE;
  454. }
  455. }
  456. return FALSE;
  457. }
  459. uchar Check_UID(void)
  460. {
  462. uchar temp;
  463. uchar i;
  465. temp = 0x00;
  466. for(i = 0; i < 5; i++)
  467. {
  468. temp = temp ^ UID[i];
  469. }
  471. if(temp == 0)
  472. {
  473. return TRUE;
  474. }
  476. return FALSE;
  477. }
  480. void Save_UID(uchar row, uchar col, uchar length)
  481. {
  482. uchar i;
  483. uchar temp;
  484. uchar temp1;
  486. if((row == 0x00) && (col == 0x00))
  487. {
  488. for(i = 0; i < length; i++)
  489. {
  490. UID[i] = RevBuffer[i];
  491. }
  492. }
  493. else
  494. {
  495. temp = RevBuffer[0];
  496. temp1 = UID[row - 1];
  497. switch(col)
  498. {
  499. case 0: temp1 = 0x00; row = row + 1; break;
  500. case 1: temp = temp & 0xFE; temp1 = temp1 & 0x01; break;
  501. case 2: temp = temp & 0xFC; temp1 = temp1 & 0x03; break;
  502. case 3: temp = temp & 0xF8; temp1 = temp1 & 0x07; break;
  503. case 4: temp = temp & 0xF0; temp1 = temp1 & 0x0F; break;
  504. case 5: temp = temp & 0xE0; temp1 = temp1 & 0x1F; break;
  505. case 6: temp = temp & 0xC0; temp1 = temp1 & 0x3F; break;
  506. case 7: temp = temp & 0x80; temp1 = temp1 & 0x7F; break;
  507. default: break;
  508. }
  510. RevBuffer[0] = temp;
  511. UID[row - 1] = temp1 | temp;
  512. for(i = 1; i < length; i++)
  513. {
  514. UID[row - 1 + i] = RevBuffer[i];
  515. }
  516. }
  517. }
  519. void Set_BitFraming(uchar row, uchar col)
  520. {
  521. switch(row)
  522. {
  523. case 0: RevBuffer[1] = 0x20; break;
  524. case 1: RevBuffer[1] = 0x30; break;
  525. case 2: RevBuffer[1] = 0x40; break;
  526. case 3: RevBuffer[1] = 0x50; break;
  527. case 4: RevBuffer[1] = 0x60; break;
  528. default: break;
  529. }
  531. switch(col)
  532. {
  533. case 0: SPIWrite(Bit_Frame,0x00); break;
  534. case 1: SPIWrite(Bit_Frame,0x11); RevBuffer[1] = (RevBuffer[1] | 0x01); break;
  535. case 2: SPIWrite(Bit_Frame,0x22); RevBuffer[1] = (RevBuffer[1] | 0x02); break;
  536. case 3: SPIWrite(Bit_Frame,0x33); RevBuffer[1] = (RevBuffer[1] | 0x03); break;
  537. case 4: SPIWrite(Bit_Frame,0x44); RevBuffer[1] = (RevBuffer[1] | 0x04); break;
  538. case 5: SPIWrite(Bit_Frame,0x55); RevBuffer[1] = (RevBuffer[1] | 0x05); break;
  539. case 6: SPIWrite(Bit_Frame,0x66); RevBuffer[1] = (RevBuffer[1] | 0x06); break;
  540. case 7: SPIWrite(Bit_Frame,0x77); RevBuffer[1] = (RevBuffer[1] | 0x07); break;
  541. default: break;
  542. }
  543. }
  545. void Init_FM1702(uchar mode)
  546. {
  548. uchar temp;
  549. uint i;
  551. //    unsigned int idata timecnt=0;
  552. RF_SCK = 1;
  553. RF_MISO = 1;
  554. RF_MOSI = 1;
  555. RF_RST = 1;             
  556. for(i = 0; i < 0x1fff; i++)
  557. {
  558. _nop_();                     
  559. }
  561. RF_RST = 0;
  562. for(i = 0; i < 0x1fff; i++)      
  563. {
  564. _nop_();
  565. }
  568. ////////////////////////////////////////////////////////////////////////////
  570. while(temp = SPIRead(Command) != 0)
  571. {
  572. _nop_();
  573. }
  574. ////////////////////////////////////////////////////////////////////////////
  575. // delay_10ms(1);
  576.     SPIWrite(Page_Sel,0x80);
  579. for(i = 0; i < 0x1fff; i++) /* 延时 */
  580. {
  581. if(temp=SPIRead(Command) == 0x00)
  582. {
  583. SPIWrite(Page_Sel,0x00);
  584. }
  585. }
  588. //    P2 = SPIRead(TimerClock);           
  590. SPIWrite(TimerClock,0x0b);   
  592. SPIWrite(TimerControl,0x02);  
  593. SPIWrite(TimerReload,0x42);      
  594.    
  595. SPIWrite(InterruptEn,0x7f);      
  597. // temp = SPIRead(InterruptEn);
  598. SPIWrite(Int_Req,0x7f);            
  600. SPIWrite(TxControl,0x5b);
  601. SPIWrite(RxControl2,0x01);
  602. // SPIWrite(RxControl1,0x73);
  603. SPIWrite(RxWait,0x07);
  604. if(mode ==2)
  605. {
  606. SPIWrite(TypeSH,0x01);
  607. }
  608. else
  609. {
  610. SPIWrite(TypeSH,0x00);
  611. }
  613. }
  616. uchar Command_Send(uchar count, uchar idata *buff, uchar Comm_Set)
  617. {
  619. uint j;
  620. uchar idata temp, temp1;
  622. SPIWrite(Command,0x00);
  623. Clear_FIFO();
  624. Write_FIFO(count, buff);
  627. SPIWrite(Command,Comm_Set); /* 命令执行 */
  628. for(j = 0; j < RF_TimeOut; j++) /* 检查命令执行否 */
  629. {
  630. temp = SPIRead(Command);
  631. temp1 = SPIRead(Int_Req) & 0x80;
  632. if(temp == 0x00)
  633. {
  634. return TRUE;
  635. }
  636. }
  638. return FALSE;
  639. }
  642. uchar Read_E2(uchar lsb, uchar msb, uchar count, uchar idata *buff)
  643. {
  645. uchar temp;
  647. *buff = lsb;
  648. *(buff + 1) = msb;
  649. *(buff + 2) = count;
  650. temp = Command_Send(3, buff, ReadE2);
  651. Read_FIFO(buff);
  652. if(temp == FALSE) return(TRUE);
  653. return(FALSE);
  654. }
  657. uchar Write_E2(uchar lsb, uchar msb, uchar count, uchar idata *buff)
  658. {
  660. uchar idata temp, i;
  662. for(i = 0; i < count; i++)
  663. {
  664. *(buff + count - i + 2) = *(buff - i + count);
  665. }
  667. *buff = lsb;
  668. *(buff + 1) = msb;
  669. temp = Command_Send(count + 2, buff, WriteE2);
  670. temp = SPIRead(SecondaryStatus);
  671. temp = temp & 0x40;
  672. if(temp == 0x40)
  673. {
  674. SPIWrite(Command,0x00);
  675. return TRUE;
  676. }
  678. return FALSE;
  679. }
  682. uchar MIF_Halt(void)
  683. {
  685. uchar temp;
  686. uint i;
  688. SPIWrite(CRCPresetLSB,0x63);
  689. SPIWrite(CWConductance,0x3f);
  690. SPIWrite(ChannelRedundancy,0x03);
  691. *RevBuffer = RF_CMD_HALT;
  692. *(RevBuffer + 1) = 0x00;
  693. temp = Command_Send(2, RevBuffer, Transmit);
  694. if(temp == TRUE)
  695. {
  696. for(i = 0; i < 0x50; i++)
  697. {
  698. _nop_();
  699. }
  701. return FM1702_OK;
  702. }
  703. else
  704. {
  705. temp = SPIRead(ErrorFlag);
  706. if((temp & 0x02) == 0x02)
  707. {
  708. return(FM1702_PARITYERR);
  709. }
  711. if((temp & 0x04) == 0x04)
  712. {
  713. return(FM1702_FRAMINGERR);
  714. }
  716. return(FM1702_NOTAGERR);
  717. }
  718. }
  721. char M500HostCodeKey(  uchar *uncoded, uchar *coded)   
  722. {
  723.     char idata status = FM1702_OK;
  724.     uchar idata cnt = 0;
  725.     uchar idata ln  = 0;     
  726.     uchar idata hn  = 0;      
  727.     for (cnt = 0; cnt < 6; cnt++)
  728.     {
  729.         ln = uncoded[cnt] & 0x0F;
  730.         hn = uncoded[cnt] >> 4;
  731.         coded[cnt * 2 + 1] = (~ln << 4) | ln;
  732.         coded[cnt * 2 ] = (~hn << 4) | hn;
  733.     }
  734.     return FM1702_OK;
  735. }
  738. uchar Load_keyE2_CPY(uchar Secnr, uchar Mode)
  739. {
  740. char idata status;
  741. uchar temp;
  742. uchar msb = 0;
  743. uchar lsb = 0;
  744. uchar coded_keys[12];
  746. uchar temp1;
  747. if(Secnr >= 0x20)
  748. {
  749.   temp1 = Secnr - 0x20;
  750.   Secnr = 0x20 + temp1 * 4;
  751. }
  753. temp = Secnr * 12;
  755. if(Mode == RF_CMD_AUTH_LA)
  756. {
  757. if(temp >= 0x80)
  758. {
  759. lsb = temp - 0x80;
  760. msb = 0x01;
  761. }
  762. else
  763. {
  764. lsb = temp + 0x80;
  765. msb = 0x00;
  766. }
  767. }
  768. else
  769. {
  770. msb = 0x01;
  771. lsb = temp + 0x40;
  772. }
  774. status = M500HostCodeKey(&RevBuffer[3],coded_keys);////////////////
  775. status = Write_E2(lsb, msb, 12, coded_keys);      ////////////////
  776. if(status != FM1702_OK)
  777. {
  778. return FALSE;
  779. }
  781. return TRUE;
  783. }
  787. uchar Load_keyE2(uchar Secnr, uchar Mode)
  788. {
  789. uchar temp;
  790. uchar msb = 0;
  791. uchar lsb = 0;
  793. uchar temp1;
  794. if(Secnr >= 0x20)
  795. {
  796.   temp1 = Secnr - 0x20;
  797.   Secnr = 0x20 + temp1 * 4;
  798. }
  800. temp = Secnr * 12;
  802. if(Mode == RF_CMD_AUTH_LA)
  803. {
  804. if(temp >= 0x80)
  805. {
  806. lsb = temp - 0x80;
  807. msb = 0x01;
  808. }
  809. else
  810. {
  811. lsb = temp + 0x80;
  812. msb = 0x00;
  813. }
  814. }
  815. else
  816. {
  817. msb = 0x01;
  818. lsb = temp + 0x40;
  819. }
  821. RevBuffer[0] = lsb;
  822. RevBuffer[1] = msb;
  824. temp = Command_Send(2, RevBuffer, LoadKeyE2);
  825. temp = SPIRead(ErrorFlag) & 0x40;
  826. if(temp == 0x40)
  827. {
  828. return FALSE;
  829. }
  831. return TRUE;
  832. }
  836. uchar Request(uchar mode)
  837. {
  839. uchar idata temp;
  841. // SPIWrite(CRCPresetLSB,0x63);
  842. // SPIWrite(CWConductance,0x3f);
  843. RevBuffer[0] = mode;
  844. SPIWrite(Bit_Frame,0x07);
  845. SPIWrite(ChannelRedundancy,0x03);
  846. temp = SPIRead(Control);
  847. temp = temp & (0xf7);
  848. SPIWrite(Control,temp); //Control reset value is 00
  849. temp = Command_Send(1, RevBuffer, Transceive);   //Transceive=0x1E
  850. if(temp == FALSE)
  851. {
  852. return FM1702_NOTAGERR;
  853. }
  855. Read_FIFO(RevBuffer);
  856. temp = Judge_Req(RevBuffer);
  857. if(temp == TRUE)
  858. {
  859. tagtype[0] = RevBuffer[0];
  860. tagtype[1] = RevBuffer[1];
  861. return FM1702_OK;
  862. }
  864. return FM1702_REQERR;
  865. }
  868. uchar AntiColl(void)
  869. {
  871. uchar temp;
  872. uchar i;
  873. uchar row, col;
  874. uchar pre_row;
  876. row = 0;
  877. col = 0;
  878. pre_row = 0;
  879. SPIWrite(CRCPresetLSB,0x63);
  880. SPIWrite(CWConductance,0x3f);
  881. // SPIWrite(ModConductance,0x3f);
  882. RevBuffer[0] = RF_CMD_ANTICOL;
  883. RevBuffer[1] = 0x20;
  884. SPIWrite(ChannelRedundancy,0x03);
  885. temp = Command_Send(2, RevBuffer, Transceive);
  886. while(1)
  887. {
  888. if(temp == FALSE)
  889. {
  890. return(FM1702_NOTAGERR);
  891. }
  893. //temp = ErrorFlag;
  895. temp = SPIRead(FIFO_Length);
  896. if(temp == 0)
  897. {
  898. return FM1702_BYTECOUNTERR;
  899. }
  901. Read_FIFO(RevBuffer);
  902. Save_UID(row, col, temp);
  905. temp = SPIRead(ErrorFlag);
  906. temp = temp & 0x01;
  907. if(temp == 0x00)
  908. {
  909. temp = Check_UID();
  910. if(temp == FALSE)
  911. {
  912. return(FM1702_SERNRERR);
  913. }
  915. return(FM1702_OK);
  916. }
  917. else
  918. {
  919. temp = SPIRead(CollPos); row = temp / 8;
  920. col = temp % 8;
  921. RevBuffer[0] = RF_CMD_ANTICOL;
  922. Set_BitFraming(row + pre_row, col);
  923. pre_row = pre_row + row;
  924. for(i = 0; i < pre_row + 1; i++)
  925. {
  926. RevBuffer[i + 2] = UID[i];
  927. }
  929. if(col != 0x00)
  930. {
  931. row = pre_row + 1;
  932. }
  933. else
  934. {
  935. row = pre_row;
  936. }
  938. temp = Command_Send(row + 2, RevBuffer, Transceive);
  939. }
  940. }
  941. }
  943. uchar Select_Card(void)
  944. {
  946. uchar temp, i;
  948. SPIWrite(CRCPresetLSB,0x63);
  949. SPIWrite(CWConductance,0x3f);
  950. RevBuffer[0] = RF_CMD_SELECT;
  951. RevBuffer[1] = 0x70;
  952. for(i = 0; i < 5; i++)
  953. {
  954. RevBuffer[i + 2] = UID[i];
  955. }
  957. SPIWrite(ChannelRedundancy,0x0f);
  958. temp = Command_Send(7, RevBuffer, Transceive);
  959. if(temp == FALSE)
  960. {
  961. return(FM1702_NOTAGERR);
  962. }
  963. else
  964. {
  965. temp = SPIRead(ErrorFlag);
  966. if((temp & 0x02) == 0x02) return(FM1702_PARITYERR);
  967. if((temp & 0x04) == 0x04) return(FM1702_FRAMINGERR);
  968. if((temp & 0x08) == 0x08) return(FM1702_CRCERR);
  969. temp = SPIRead(FIFO_Length);
  970. if(temp != 1) return(FM1702_BYTECOUNTERR);
  971. Read_FIFO(RevBuffer);
  972. temp = *RevBuffer;
  973. if((temp == 0x18) || (temp == 0x08) || (temp == 0x88) || (temp ==0x53)) return(FM1702_OK);
  974. else
  975. return(FM1702_SELERR);
  976. }
  977. }
  979. uchar Authentication(uchar idata *UID, uchar SecNR, uchar mode)
  980. {
  982. uchar idata i;
  983. uchar idata temp, temp1;
  985. uchar temp0;
  986. if(SecNR >= 0x20)
  987. {
  988. temp0 = SecNR -0x20;
  989. SecNR = 0x20 + temp0 * 4;
  990. }
  992. SPIWrite(CRCPresetLSB,0x63);
  993. SPIWrite(CWConductance,0x3f);
  994. // SPIWrite(ModConductance,0X3f);
  995. // temp1 = SPIRead(Control);
  996. // temp1 = temp1 & 0xf7;
  997. // SPIWrite(Control,temp1);
  998. if(mode == RF_CMD_AUTH_LB)
  999. RevBuffer[0] = RF_CMD_AUTH_LB;
  1000. else
  1001. RevBuffer[0] = RF_CMD_AUTH_LA;
  1002. RevBuffer[1] = SecNR * 4 + 3;
  1003. for(i = 0; i < 4; i++)
  1004. {
  1005. RevBuffer[2 + i] = UID[i];
  1006. }
  1008. SPIWrite(ChannelRedundancy,0x0f);
  1009. temp = Command_Send(6, RevBuffer, Authent1);
  1010. if(temp == FALSE)
  1011. {
  1013. return 0x99;
  1014. }
  1016. temp = SPIRead(ErrorFlag);             //ErrorFlag address is 0x0A.
  1017. if((temp & 0x02) == 0x02) return FM1702_PARITYERR;
  1018. if((temp & 0x04) == 0x04) return FM1702_FRAMINGERR;
  1019. if((temp & 0x08) == 0x08) return FM1702_CRCERR;
  1020. temp = Command_Send(0, RevBuffer, Authent2);
  1021. if(temp == FALSE)
  1022. {
  1024. return 0x88;
  1025. }
  1027. temp = SPIRead(ErrorFlag);
  1028. if((temp & 0x02) == 0x02) return FM1702_PARITYERR;
  1029. if((temp & 0x04) == 0x04) return FM1702_FRAMINGERR;
  1030. if((temp & 0x08) == 0x08) return FM1702_CRCERR;
  1031. temp1 = SPIRead(Control);
  1032. temp1 = temp1 & 0x08;
  1033. if(temp1 == 0x08)
  1034. {
  1035. return FM1702_OK;
  1036. }
  1038. return FM1702_AUTHERR;
  1039. }
  1041. uchar MIF_READ(uchar idata *buff, uchar Block_Adr)
  1042. {
  1044. uchar idata temp;
  1046. SPIWrite(CRCPresetLSB,0x63);
  1047. SPIWrite(CWConductance,0x3f);
  1048. SPIWrite(ModConductance,0x3f);
  1049. SPIWrite(ChannelRedundancy,0x0f);
  1051. buff[0] = RF_CMD_READ;
  1052. buff[1] = Block_Adr;
  1053. temp = Command_Send(2, buff, Transceive);
  1054. if(temp == 0)
  1055. {
  1056. return FM1702_NOTAGERR;
  1057. }
  1059. temp = SPIRead(ErrorFlag);
  1060. if((temp & 0x02) == 0x02) return FM1702_PARITYERR;
  1061. if((temp & 0x04) == 0x04) return FM1702_FRAMINGERR;
  1062. if((temp & 0x08) == 0x08) return FM1702_CRCERR;
  1063. temp = SPIRead(FIFO_Length);
  1064. if(temp == 0x10)
  1065. {
  1066. Read_FIFO(buff);
  1067. return FM1702_OK;
  1068. }
  1069. else if(temp == 0x04)
  1070. {
  1071. Read_FIFO(buff);
  1072. return FM1702_OK;
  1073. }
  1074. else
  1075. {
  1076. return FM1702_BYTECOUNTERR;
  1077. }
  1078. }
  1080. uchar MIF_Write(uchar idata *buff, uchar Block_Adr)
  1081. {
  1083. uchar idata temp;
  1084. uchar idata *F_buff;
  1086. SPIWrite(CRCPresetLSB,0x63);
  1087. SPIWrite(CWConductance,0x3f);
  1088. F_buff = buff + 0x10;
  1089. SPIWrite(ChannelRedundancy,0x07);    /* Note: this line is for 1702, different from RC500*/
  1090. *F_buff = RF_CMD_WRITE;
  1091. *(F_buff + 1) = Block_Adr;
  1092. temp = Command_Send(2, F_buff, Transceive);
  1093. if(temp == FALSE)
  1094. {
  1095. return(FM1702_NOTAGERR);
  1096. }
  1098. temp = SPIRead(FIFO_Length);
  1099. if(temp == 0)
  1100. {
  1101. return(FM1702_BYTECOUNTERR);
  1102. }
  1104. Read_FIFO(F_buff);
  1105. temp = *F_buff;
  1106. switch(temp)
  1107. {
  1108. case 0x00: return(FM1702_NOTAUTHERR);
  1109. case 0x04: return(FM1702_EMPTY);
  1110. case 0x0a: break;
  1111. case 0x01: return(FM1702_CRCERR);
  1112. case 0x05: return(FM1702_PARITYERR);
  1113. default: return(FM1702_WRITEERR);
  1114. }
  1116. temp = Command_Send(16, buff, Transceive);
  1117. if(temp == TRUE)
  1118. {
  1119. return(FM1702_OK);
  1120. }
  1121. else
  1122. {
  1123. temp = SPIRead(ErrorFlag);
  1124. if((temp & 0x02) == 0x02)
  1125. return(FM1702_PARITYERR);
  1126. else if((temp & 0x04) == 0x04)
  1127. return(FM1702_FRAMINGERR);
  1128. else if((temp & 0x08) == 0x08)
  1129. return(FM1702_CRCERR);
  1130. else
  1131. return(FM1702_WRITEERR);
  1132. }
  1133. }
  1135. uchar MIF_Increment(uchar idata *buff, uchar Block_Adr)
  1136. {
  1138. uchar temp;
  1139. uchar idata *F_buff;
  1141. SPIWrite(CRCPresetLSB,0x63);
  1142. SPIWrite(CWConductance,0x3f);
  1143. F_buff = buff + 4;
  1144. *F_buff = RF_CMD_INC;
  1145. *(F_buff + 1) = Block_Adr;
  1146. SPIWrite(ChannelRedundancy,0x07);
  1147. temp = Command_Send(2, F_buff, Transceive);
  1148. if(temp == FALSE)
  1149. {
  1150. return FM1702_NOTAGERR;
  1151. }
  1153. temp = SPIRead(FIFO_Length);
  1154. if(temp == 0)
  1155. {
  1156. return FM1702_BYTECOUNTERR;
  1157. }
  1159. Read_FIFO(F_buff);
  1160. temp = *F_buff;
  1161. switch(temp)
  1162. {
  1163. case 0x00: /* break; */return(FM1702_NOTAUTHERR);
  1164. case 0x04: return(FM1702_EMPTY);
  1165. case 0x0a: break;
  1166. case 0x01: return(FM1702_CRCERR);
  1167. case 0x05: return(FM1702_PARITYERR);
  1168. default: return(FM1702_INCRERR);
  1169. }
  1170.         
  1171. temp = Command_Send(4, buff, Transmit);
  1172. if(temp == FALSE)
  1173. {
  1174. return FM1702_INCRERR;
  1175. }
  1177. return FM1702_OK;
  1178. }
  1180. uchar MIF_Decrement(uchar idata *buff, uchar Block_Adr)
  1181. {
  1183. uchar temp;
  1184. uchar idata *F_buff;
  1186. SPIWrite(CRCPresetLSB,0x63);
  1187. SPIWrite(CWConductance,0x3f);
  1188. F_buff = buff + 4;
  1189. *F_buff = RF_CMD_DEC;
  1190. *(F_buff + 1) = Block_Adr;
  1191. SPIWrite(ChannelRedundancy,0x07);
  1192. temp = Command_Send(2, F_buff, Transceive);
  1193. if(temp == FALSE)
  1194. {
  1195. return FM1702_NOTAGERR;
  1196. }
  1198. temp = SPIRead(FIFO_Length);
  1199. if(temp == 0)
  1200. {
  1201. return FM1702_BYTECOUNTERR;
  1202. }
  1204. Read_FIFO(F_buff);
  1205. temp = *F_buff;
  1206. switch(temp)
  1207. {
  1208. case 0x00: /* break; */return(FM1702_NOTAUTHERR);
  1209. case 0x04: return(FM1702_EMPTY);
  1210. case 0x0a: break;
  1211. case 0x01: return(FM1702_CRCERR);
  1212. case 0x05: return(FM1702_PARITYERR);
  1213. default: return(FM1702_DECRERR);
  1214. }
  1216. temp = Command_Send(4, buff, Transmit);
  1217. if(temp == FALSE)
  1218. {
  1219. return(FM1702_DECRERR);
  1220. }
  1222. return FM1702_OK;
  1223. }
  1225. uchar MIF_Restore(uchar Block_Adr)
  1226. {
  1228. uchar temp, i;
  1230. SPIWrite(CRCPresetLSB,0x63);
  1231. SPIWrite(CWConductance,0x3f);
  1232. SPIWrite(ChannelRedundancy,0x07);
  1233. *RevBuffer = RF_CMD_RESTORE;
  1234. *(RevBuffer + 1) = Block_Adr;
  1235. temp = Command_Send(2, RevBuffer, Transceive);
  1236. if(temp == FALSE)
  1237. {
  1238. return FM1702_NOTAGERR;
  1239. }
  1241. temp = SPIRead(FIFO_Length);
  1242. if(temp == 0)
  1243. {
  1244. return FM1702_BYTECOUNTERR;
  1245. }
  1247. Read_FIFO(RevBuffer);
  1248. temp = *RevBuffer;
  1249. switch(temp)
  1250. {
  1251. case 0x00: /* break; */return(FM1702_NOTAUTHERR);
  1252. case 0x04: return(FM1702_EMPTY);
  1253. case 0x0a: break;
  1254. case 0x01: return(FM1702_CRCERR);
  1255. case 0x05: return(FM1702_PARITYERR);
  1256. default: return(FM1702_RESTERR);
  1257. }
  1259. for(i = 0; i < 4; i++) RevBuffer[i] = 0x00;
  1260. temp = Command_Send(4, RevBuffer, Transmit);
  1261. if(temp == FALSE)
  1262. {
  1263. return FM1702_RESTERR;
  1264. }
  1266. return FM1702_OK;
  1267. }
  1269. uchar MIF_Transfer(uchar Block_Adr)
  1270. {
  1272. uchar temp;
  1273. SPIWrite(CRCPresetLSB,0x63);
  1274. SPIWrite(CWConductance,0x3f);
  1275. SPIWrite(ChannelRedundancy,0x07);
  1276. RevBuffer[0] = RF_CMD_TRANSFER;
  1277. RevBuffer[1] = Block_Adr;
  1278. temp = Command_Send(2, RevBuffer, Transceive);
  1279. if(temp == FALSE)
  1280. {
  1281. return FM1702_NOTAGERR;
  1282. }
  1284. temp = SPIRead(FIFO_Length);
  1285. if(temp == 0)
  1286. {
  1287. return FM1702_BYTECOUNTERR;
  1288. }
  1290. Read_FIFO(RevBuffer);
  1291. temp = *RevBuffer;
  1292. switch(temp)
  1293. {
  1294. case 0x00: /* break; */return(FM1702_NOTAUTHERR);
  1295. case 0x04: return(FM1702_EMPTY);
  1296. case 0x0a: return(FM1702_OK);
  1297. case 0x01: return(FM1702_CRCERR);
  1298. case 0x05: return(FM1702_PARITYERR);
  1299. default: return(FM1702_TRANSERR);
  1300. }
  1301. }
  1303. #if 0
  1305. uchar HL_Active(uchar Block_Adr, uchar Mode)
  1306. {
  1308. uchar temp;
  1310. Secnr = Block_Adr / 4;
  1311. MIF_Halt(); /* Halt */
  1312. temp = Request(RF_CMD_REQUEST_STD);
  1313. if(temp != FM1702_OK)
  1314. {
  1315. return(FM1702_REQERR);
  1316. }
  1318. temp = AntiColl();
  1319. if(temp != FM1702_OK)
  1320. {
  1321. return(FM1702_ANTICOLLERR);
  1322. }
  1324. temp = Select_Card();
  1325. if(temp != FM1702_OK)
  1326. {
  1327. return(FM1702_SELERR);
  1328. }
  1330. Load_keyE2_CPY(Secnr, Mode); //%40
  1331. temp = Authentication(UID, Secnr, Mode);
  1332. if(temp != FM1702_OK)
  1333. {
  1334. return(FM1702_AUTHERR);
  1335. }
  1337. return FM1702_OK;
  1338. }
  1341. uchar MIF_Initival(uchar idata *buff, uchar Block_Adr)
  1342. {
  1344. uchar idata temp;
  1345. uchar i;
  1347. for(i = 0; i < 4; i++)
  1348. {
  1349. *(buff + 4 + i) = ~(*(buff + i));
  1350. }
  1352. for(i = 0; i < 4; i++)
  1353. {
  1354. *(buff + 8 + i) = *(buff + i);
  1355. }
  1357. *(buff + 12) = Block_Adr;
  1358. *(buff + 13) = ~Block_Adr;
  1359. *(buff + 14) = Block_Adr;
  1360. *(buff + 15) = ~Block_Adr;
  1361. temp = MIF_Write(buff, Block_Adr);
  1362. return temp;
  1363. }
  1364. #endif
  1366. #if 0
  1367. uchar HL_Read(uchar idata *buff, uchar Block_Adr, uchar Mode)
  1368. {
  1370. uchar temp;
  1372. temp = HL_Active(Block_Adr, Mode);
  1373. if(temp != FM1702_OK)
  1374. {
  1375. return temp;
  1376. }
  1379. temp = MIF_READ(buff, Block_Adr);
  1380. if(temp != FM1702_OK)
  1381. {
  1382. return temp;
  1383. }
  1385. return FM1702_OK;
  1386. }
  1389. uchar HL_Write(uchar idata *buff, uchar Block_Adr, uchar Mode)
  1390. {
  1392. uchar temp;
  1395. temp = HL_Active(Block_Adr, Mode);
  1396. if(temp != FM1702_OK)
  1397. {
  1398. return temp;
  1399. }
  1402. temp = MIF_Write(buff, Block_Adr);
  1403. if(temp != FM1702_OK)
  1404. {
  1405. return FM1702_WRITEERR;
  1406. }
  1408. return FM1702_OK;
  1409. }
  1410. #endif
  1412. ///////////////////////////////////////////////////////////////////////
  1413. // Delay 50us
  1414. ///////////////////////////////////////////////////////////////////////
  1415. ///////////////////////////////////////////////////////////////////////
  1416. // Delay 50us
  1417. ///////////////////////////////////////////////////////////////////////
  1418. void delay_50us(unsigned char _50us)
  1419. {
  1420.     while(_50us--)
  1421. {
  1422.     _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  1423.     _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  1424.     _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  1425.     _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  1426.     _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  1427.     _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  1428.     _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  1429.     _nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();_nop_();
  1430.     }
  1431. }
  1433. ///////////////////////////////////////////////////////////////////////
  1434. // Delay 10ms
  1435. ///////////////////////////////////////////////////////////////////////
  1436. void delay_10ms(unsigned int _10ms)
  1437. {
  1438. #ifndef NO_TIMER2
  1439.     RCAP2LH = RCAP2_10ms;
  1440.     T2LH    = RCAP2_10ms;
  1441.     
  1442.     TR2 = TRUE;
  1443.     while (_10ms--)
  1444.     {
  1445.     while (!TF2);
  1446.     TF2 = FALSE;
  1447.     }
  1448.     TR2 = FALSE;
  1449. #else
  1450.     while (_10ms--)
  1451.     {
  1452.     delay_50us(19);
  1453.     if (CmdValid)
  1454.         return;
  1455.     delay_50us(20);
  1456.     if (CmdValid)
  1457.         return;
  1458.     delay_50us(20);
  1459.     if (CmdValid)
  1460.         return;
  1461.     delay_50us(20);
  1462.     if (CmdValid)
  1463.         return;
  1464.     delay_50us(20);
  1465.     if (CmdValid )
  1466.         return;
  1467.     delay_50us(20);
  1468.     if (CmdValid)
  1469.         return;
  1470.     delay_50us(20);
  1471.     if (CmdValid)
  1472.         return;
  1473.     delay_50us(20);
  1474.     if (CmdValid)
  1475.         return;
  1476.     delay_50us(20);
  1477.     if (CmdValid)
  1478.         return;
  1479.     delay_50us(19);
  1480.     if (CmdValid)
  1481.         return;
  1482.     }
  1483. #endif
  1484. }