设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

搜索
»论坛 › 电子技术分类讨论区 › 资料共享 › FM1702SL 51单片机测试程序
返回列表 发新帖
查看: 3832|回复: 5
收起左侧

FM1702SL 51单片机测试程序

[复制链接]
ID:442251 发表于 2018-12-8 16:57 | 显示全部楼层 |阅读模式
FM1702SL源码：
  1. /****************************************************************************
  2. * File :  main.c                                                            *
  3. * COPYRIGHT BY HUOYAN LTD.COMPANY                                           *
  4. * Version:      V1.3                                                                      *
  5. * Author:       NIL                                                         *
  6. *                                                                           *
  7. * Compiler:     KEIL C51 V7.10                                              *
  8. *                                                                           *
  9. * Description:  AT89S52-Firmware for FM1702 Demo Serial Reader             *
  10. *                                                                           *
  11. ****************************************************************************/
  12. #include <reg52.h>
  13. #define __SRC
  14. #include "main.h"
  15. #undef  __SRC
  16. #include <intrins.h>
  17. //#include <string.h>
  18. //#include <stdio.h>
  19. //#include <absacc.h>



  23. #include "FM1702.h"


  26. #define uchar        unsigned char
  27. #define uint        unsigned int
  28. //pin define  mcu控制管脚定义          

  30. sbit RF_MISO        =        P1^0;
  31. sbit RF_MOSI        =        P1^1;
  32. sbit RF_SCK                =        P1^2;
  33. sbit RF_NSS                =        P1^3;
  34. sbit RF_RST          =   P1^4;        //由高变低时启动内部复位程序       

  36. sbit CARD_LED        =        P2^0;
  37. sbit SPEAKER    =   P2^0;
  38.                                

  40.                                                                                        



  44. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
  45. //名称: spi_byte_transceive                                                    //
  46. //功能: 该函数实现SPI通讯的数据收发                                            //
  47. //                                                                               //
  48. //输入:                                                                        //
  49. //      发送数据                                                               //
  50. //                                                                             //
  51. //输出:                                                                        //
  52. //      接收数据                                                               //
  53. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
  54. char spi_byte_transceive(char sendbyte)
  55. {
  56.   char i,temp;
  57.   for(i=0;i<8;i++)
  58.    {  
  59.     RF_SCK=0;
  60.     if(sendbyte & 0x80)                      //位运算，判断最高位是否为1
  61.      {
  62.       RF_MOSI=1;
  63.      }
  64.     else
  65.      {
  66.       RF_MOSI=0;
  67.      }
  68.     sendbyte <<= 1;
  69.     RF_SCK=1;
  70.     temp <<= 1;
  71.     if(RF_MISO)
  72.     temp |= 0x01;
  73.    }
  74.     RF_SCK=0;
  75.      _nop_();
  76.          _nop_();
  77.     RF_MOSI=0;
  78.     return (temp);
  79. }

  81. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
  82. //名称: rc531_register_write                                                   //
  83. //功能: 该函数实现通过SPI接口对RC531中一个寄存器写入值                         //
  84. //                                                                             //
  85. //输入:                                                                        //
  86. //     RC531目标寄存器地址和写入值                                             //
  87. //                                                                             //
  88. //输出:                                                                        //
  89. //     N/A                                                                     //
  90. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
  91. void SPIWrite(char reg_ad,char reg_data)
  92. {   
  93.     RF_SCK=0;
  94.     reg_ad <<= 1;
  95.     RF_NSS=0;
  96.     reg_ad &= 0x7F;
  97.     spi_byte_transceive(reg_ad);
  98.     spi_byte_transceive(reg_data);
  99.     RF_NSS=1;
  100.     return;
  101. }

  103. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
  104. //名称: rc531_register_read                                                    //
  105. //功能: 该函数实现通过SPI接口读取RC531中一个寄存器的值                         //
  106. //                                                                             //
  107. //输入:                                                                        //
  108. //     RC531目标寄存器地址                                                     //
  109. //                                                                             //
  110. //输出:                                                                        //
  111. //     目标寄存器的值                                                          //
  112. //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
  113. unsigned char SPIRead(char reg_ad)
  114. {   char temp;
  115.     RF_SCK=0;
  116.      _nop_();
  117.      _nop_();
  118.     RF_NSS=0;
  119.     reg_ad <<= 1;
  120.     reg_ad |= 0x80;
  121.     spi_byte_transceive(reg_ad);
  122.     temp=spi_byte_transceive(0x00);
  123.     RF_NSS=1;
  124.     return (temp);
  125. }

  127.                                        






  134. ///////////////////////////////////////////////////////////////////////
  135. // 主函数
  136. ///////////////////////////////////////////////////////////////////////
  137. void main(void)
  138. {         //设置变量
  139.     uchar baud;
  140.        

  142.     InitSystem();     //初始化系统
  143.     while (1)
  144.     {

  146.                 //检查命令标志       
  147.             if (CmdValid)                //if LEVEL 1
  148.             {
  149.                     CmdValid = FALSE;
  150.                     if(RevBuffer[0]==11)         //if LEVEL 2   
  151.                     {
  152.                             RevBuffer[2]=RevBuffer[1];
  153.                               RevBuffer[0]=1;         
  154.                             RevBuffer[1]=0;
  155.                             CALL_isr_UART();                //equal to 'SETB TI', defined in main.h
  156.                             SPEAKER=0;              //开蜂鸣器和指示灯
  157.                                 delay_10ms(RevBuffer[2]);
  158.                             SPEAKER=1;
  159.                     }
  160.                      else if(RevBuffer[0]==13)   //设置通讯波特率 //if LEVEL 2
  161.                     {
  162.                             switch(RevBuffer[1])
  163.                             {
  164.                                     case 0:
  165.                                             baud=BAUD_9600;
  166.                                             break;
  167.                                     case 1:
  168.                                             baud=BAUD_14400;
  169.                                             break;
  170.                                     case 2:
  171.                                             baud=BAUD_19200;
  172.                                             break;
  173.                                     case 3:
  174.                                             baud=BAUD_28800;
  175.                                             break;
  176.                                     case 4:
  177.                                             baud=BAUD_38400;
  178.                                             break;
  179.                                     case 5:
  180.                                             baud=BAUD_57600;
  181.                                             break;
  182.                                     case 6:
  183.                                             baud=BAUD_115200;
  184.                                             break;
  185.                                     default:
  186.                                             baud=BAUD_19200;
  187.                                             break;
  188.                             }        //switch body                       
  189.                             RevBuffer[0]=1;                //contact
  190.                             RevBuffer[1]=0;
  191.                             CALL_isr_UART();
  192.                             delay_10ms(5);                       
  193.                             TR1   = 0;
  194.                             TH1   = baud;
  195.                             TL1   = TH1;
  196.                             delay_10ms(2);
  197.                             TR1   = TRUE;
  198.                     }//if LEVEL 2
  199.                        else
  200.                     {
  201.                             cmd_process();        // 进入IC卡处理程序
  202.                             CALL_isr_UART();
  203.                     }
  204.             }
  205.     }//while循环体
  206. }//main函数
  207. ///////////////////////////////////////////////////////////////////////
  208. // 系统初始化
  209. ///////////////////////////////////////////////////////////////////////
  210. void InitSystem(void)
  211. {
  212.     RF_NSS=1;               
  213.         RF_RST=0;       
  214.         ET2 = 0;         //Timer 2 disabled
  215.         T2CON = 0x04;        //start Timer 2(internal timer, auto reload)
  216.     PCON = 0x80;    //baud rate double   
  217.     SCON = 0x70;    //UART mode 1, enable receive, if No valid stop bit, RI not activated.

  219.         //TMOD = 0x22;
  220.     TMOD = 0x21;    //Timer 1 8bit auto reload TR1 control
  221.                                         //Timer 0 16bit TR0 control

  223.         TH1   = BAUD_19200;  //默认波特率
  224.         TL1   = TH1;
  225.         TR1   = TRUE;        // 波特率发生器
  226.        
  227.         TH0 = 0x60;
  228.     TL0 = 0x60;
  229.     TR0 = 0;        //Timer 0 doesn't run
  230.    
  231.     ET0=0;
  232.         ET1=0;
  233.         EA=1;
  234.         EX0=1;
  235.         IT0 = 1;       
  236.         TR2=0;
  237.         ES = TRUE;    //enable UART interrupt
  238.         CmdValid=0;         //flag initiation
  239.                                                 //喇叭和指示灯测试



  243.         SPEAKER=0;
  244.         delay_10ms(10);
  245.         delay_10ms(10);
  246.         SPEAKER=1;                  
  247.         Init_FM1702(0);                 

  249. }
  250. ///////////////////////////////////////////////////////////////////////
  251. // 串口接收和发送中断
  252. ///////////////////////////////////////////////////////////////////////
  253. void isr_UART(void) interrupt 4 using 1
  254. {
  255.     uchar len, i;
  256.           unsigned int j=0;
  257.          
  258.           if(RI)
  259.         {               
  260.                 len=SBUF;
  261.                 RI=0;       
  262.                 for(i=0;i<len;i++)
  263.                 {
  264.                         while(!RI)
  265.                         {
  266.                                 j++;
  267.                                 if(j>1000)
  268.                                 {
  269.                                     break;
  270.                                 }
  271.                         }
  272.                         if(j<1000)
  273.                         {
  274.                                 RevBuffer[i]=SBUF;
  275.                                 RI=0;
  276.                                 j=0;
  277.                         }
  278.                         else
  279.                         {
  280.                             break;
  281.                         }
  282.                 }
  283.                 if(i==len)
  284.                 {
  285.                         REN=0;
  286.                         CmdValid=1;
  287.                 }
  288.         }
  289.         else if(!RI && TI)
  290.         {
  291.                 TI=0;
  292.                 len=RevBuffer[0];
  293.                 for(i=0;i<len+1;i++)
  294.                 {
  295.                         SBUF=RevBuffer[i];
  296.                         while(!TI);
  297.                         TI=0;                       
  298.                 }
  299.                 REN=1;
  300.         }
  301. }
  302. ///////////////////////////////////////////////////////////////////////
  303. // IC卡处理函数
  304. ///////////////////////////////////////////////////////////////////////
  305. void cmd_process(void)
  306. {
  307.     uchar cmd;
  308.     uchar status;
  309.        
  310.         cmd = RevBuffer[0];
  311.         switch(cmd)
  312.         {
  313.                 case 1:     // Halt the card     //终止卡的操作
  314.                         status=MIF_Halt();                       
  315.                         RevBuffer[0]=1;
  316.                         RevBuffer[1]=status;
  317.                         break;                       
  318.                 case 2:     
  319.                 status = Request(RF_CMD_REQUEST_ALL);        //RF_CMD_REQUEST_STD=0x26, request Idle
  320.                 if(status != FM1702_OK)
  321.                 {
  322.                     status = Request(RF_CMD_REQUEST_ALL);               
  323.                     if(status != FM1702_OK)
  324.                     {
  325.                         RevBuffer[0] = 1;
  326.                         RevBuffer[1] = FM1702_REQERR;

  328.                         break;
  329.                     }
  330.                 }
  331.                         if(tagtype[0]==2)
  332.                                 cardtype=mifarepro;     // Mifare Pro 卡
  333.                         else if(tagtype[0]==4)
  334.                                 cardtype=mifare1;       // Mifare One 卡
  335.                         else if(tagtype[0]==16)
  336.                                 cardtype=mifarelight;   // Mifare Light 卡
  337.                         else
  338.                                 cardtype=unknowncard;
  339.                         RevBuffer[0]=3;       
  340.                         RevBuffer[1]=status;
  341.                         RevBuffer[2]=tagtype[0];
  342.                         RevBuffer[3]=tagtype[1];
  343.                         break;
  344.             case 3:                         // 防冲突 读卡的系列号 MLastSelectedSnr
  345.                         status = AntiColl();;
  346.                         if(status!=FM1702_OK)
  347.                         {
  348.                                 RevBuffer[0]=1;       
  349.                                 RevBuffer[1]=FM1702_ANTICOLLERR;
  350.                                 break;
  351.                         }
  352.                         //memcpy(MLastSelectedSnr,&RevBuffer[2],4);
  353.                         RevBuffer[0]=5;
  354.                         RevBuffer[1]=status;
  355.                         RevBuffer[2]=UID[0];
  356.                         RevBuffer[3]=UID[1];
  357.                         RevBuffer[4]=UID[2];
  358.                         RevBuffer[5]=UID[3];
  359.                         break;       
  360.                 case 4:                                    // 选择卡 Select Card
  361.                         status=Select_Card();
  362.                         if(status!=FM1702_OK)
  363.                         {
  364.                                 RevBuffer[0]=1;       
  365.                                 RevBuffer[1]=FM1702_SELERR;
  366.                                 break;
  367.                         }
  368.                         RevBuffer[0]=1;
  369.                         RevBuffer[1]=status;                       
  370.                         break;

  372.         case 5:                        //下载密钥
  373.                         status = Load_keyE2(RevBuffer[2],RevBuffer[1]);   //%40
  374.                         status = Authentication(UID, RevBuffer[2], RevBuffer[1]);       
  375.                 if(status != FM1702_OK)
  376.                 {
  377.                         RevBuffer[0]=1;
  378.                             RevBuffer[1]=status;
  379.                             break;
  380.                 }
  381.                         RevBuffer[0]=1;
  382.                         RevBuffer[1]=status;                       
  383.                         break;       


  386.                 case 6:            // Key loading into the MF RC500's EEPROM
  387.                             // 校验卡密码(E2)                   Load_keyE2_CPY(uchar Secnr, uchar Mode)

  389.                         status = Load_keyE2_CPY(RevBuffer[2],RevBuffer[1]);   //%40
  390.                 if(status != FM1702_OK)
  391.                 {
  392.                         RevBuffer[0]=1;
  393.                             RevBuffer[1]=status;
  394.                             break;
  395.                 }
  396.                         RevBuffer[0]=1;
  397.                         RevBuffer[1]=status;                       
  398.                         break;       


  401.                 case 8:                       //读卡
  402.                         status=MIF_READ(&RevBuffer[2],RevBuffer[1]);
  403.                         if(status != FM1702_OK)
  404.                         {
  405.                             RevBuffer[0]=1;
  406.                             RevBuffer[1]=status;
  407.                             break;
  408.                         }
  409.                         else
  410.                         {
  411.                                 if(cardtype==mifare1||cardtype==mifarepro)
  412.                                         RevBuffer[0]=17;
  413.                                 else if(cardtype==1)
  414.                                         RevBuffer[0]=9;
  415.                                 else
  416.                                         RevBuffer[0]=16;
  417.                         }
  418.                         RevBuffer[1]=status;                       
  419.                         break;       
  420.                 case 9:                  //写卡
  421.                         status=MIF_Write(&RevBuffer[2],RevBuffer[1]);
  422.                         RevBuffer[0]=1;
  423.                         RevBuffer[1]=status;                       
  424.                         break;       
  425.                 case 10:                //加值减值
  426.                         if(RevBuffer[1] == RF_CMD_INC)
  427.                         {
  428.                             status = MIF_Increment(&RevBuffer[3],RevBuffer[2]);
  429.                             MIF_Transfer(RevBuffer[2]);
  430.                         }
  431.                         else if(RevBuffer[1] == RF_CMD_DEC)
  432.                         {
  433.                             status = MIF_Decrement(&RevBuffer[3],RevBuffer[2]);   
  434.                             MIF_Transfer(RevBuffer[2]);
  435.                         }
  436.                         else
  437.                         {
  438.                             status = 1;
  439.                         }
  440.                         RevBuffer[0]=1;       
  441.                         RevBuffer[1]=status;
  442.                         break;
  443.                 case 12:   
  444.                         RevBuffer[0]=1;
  445.                         RevBuffer[1]=0;
  446.                         break;
  447.                 default:
  448.                     RevBuffer[0] = 1;
  449.                     RevBuffer[1] = 1;
  450.                     break;       
  451.         }
  452. }



  456. /****************************************************************/
  457. /*名称: Clear_FIFO */
  458. /*功能: 该函数实现清空FM1702中FIFO的数据*/
  459. /*输入: N/A */
  460. /*输出: TRUE, FIFO被清空*/
  461. /* FALSE, FIFO未被清空*/
  462. /****************************************************************/
  463. uchar Clear_FIFO(void)
  464. {
  465.         uchar        temp;
  466.         uint        i;
  467.         temp = SPIRead(Control);                        /* 清空FIFO */
  468.         temp = (temp | 0x01);
  469.         SPIWrite(Control,temp);
  470.         for(i = 0; i < RF_TimeOut; i++) /* 检查FIFO是否被清空 */
  471.         {
  472.                 temp = SPIRead(FIFO_Length);
  473.                 if(temp == 0)
  474.                 {
  475.                         return TRUE;
  476.                 }
  477.         }

  479.         return FALSE;
  480. }

  482. /****************************************************************/
  483. /*名称: Write_FIFO */
  484. /*功能: 该函数实现向FM1702的FIFO中写入x bytes数据*/
  485. /*输入: count, 待写入字节的长度*/
  486. /* buff, 指向待写入数据的指针*/
  487. /*输出: N/A */
  488. /****************************************************************/
  489. void Write_FIFO(uchar count, uchar idata *buff)
  490. {
  491.         uchar        i;
  492.        
  493.         for(i = 0; i < count; i++)
  494.         {
  495.                 SPIWrite(FIFO,*(buff + i));
  496.         }
  497. }

  499. /****************************************************************/
  500. /*名称: Read_FIFO */
  501. /*功能: 该函数实现从FM1702的FIFO中读出x bytes数据*/
  502. /*输入: buff, 指向读出数据的指针*/
  503. /*输出: N/A */
  504. /****************************************************************/
  505. uchar Read_FIFO(uchar idata *buff)
  506. {
  507.         uchar        temp;
  508.         uchar        i;
  509.        
  510.         temp = SPIRead(FIFO_Length);
  511.         if(temp == 0)
  512.         {
  513.                 return 0;
  514.         }

  516.         if(temp >= 24)               
  517.         {
  518.        
  519.                 temp = 24;       
  520.         }

  522.         for(i = 0; i < temp; i++)
  523.         {
  524.                 *(buff + i) = SPIRead(FIFO);
  525.         }

  527.         return temp;
  528. }

  530. /****************************************************************/
  531. /*名称: Judge_Req */
  532. /*功能: 该函数实现对卡片复位应答信号的判断*/
  533. /*输入: *buff, 指向应答数据的指针*/
  534. /*输出: TRUE, 卡片应答信号正确*/
  535. /* FALSE, 卡片应答信号错误*/
  536. /****************************************************************/
  537. uchar Judge_Req(uchar idata *buff)
  538. {
  539.        
  540.         uchar        temp1, temp2;
  541.        
  542.         temp1 = *buff;
  543.         temp2 = *(buff + 1);
  544.         if((temp1 == 0x02) || (temp1 == 0x04) || (temp1 == 0x05) || (temp1 == 0x53) || (temp1 == 0x03))
  545.         {
  546.                 if (temp2 == 0x00)
  547.                 {
  548.                         return TRUE;
  549.                 }
  550.         }
  551.         return FALSE;
  552. }

  554. /****************************************************************/
  555. /*名称: Check_UID */
  556. /*功能: 该函数实现对收到的卡片的序列号的判断*/
  557. /*输入: N/A */
  558. /*输出: TRUE: 序列号正确*/
  559. /* FALSE: 序列号错误*/
  560. /****************************************************************/
  561. uchar Check_UID(void)
  562. {
  563.        
  564.         uchar        temp;
  565.         uchar        i;
  566.        
  567.         temp = 0x00;
  568.         for(i = 0; i < 5; i++)
  569.         {
  570.                 temp = temp ^ UID[i];
  571.         }

  573.         if(temp == 0)
  574.         {
  575.                 return TRUE;
  576.         }

  578.         return FALSE;
  579. }

  581. /****************************************************************/
  582. /*名称: Save_UID */
  583. /*功能: 该函数实现保存卡片收到的序列号*/
  584. /*输入: row: 产生冲突的行*/
  585. /* col: 产生冲突的列*/
  586. /* length: 接収到的UID数据长度*/
  587. /*输出: N/A */
  588. /****************************************************************/
  589. void Save_UID(uchar row, uchar col, uchar length)
  590. {
  591.         uchar        i;
  592.         uchar        temp;
  593.         uchar        temp1;
  594.        
  595.         if((row == 0x00) && (col == 0x00))
  596.         {
  597.                 for(i = 0; i < length; i++)
  598.                 {
  599.                         UID[i] = RevBuffer[i];
  600.                 }
  601.         }
  602.         else
  603.         {
  604.                 temp = RevBuffer[0];
  605.                 temp1 = UID[row - 1];
  606.                 switch(col)
  607.                 {
  608.                 case 0:                temp1 = 0x00; row = row + 1; break;
  609.                 case 1:                temp = temp & 0xFE; temp1 = temp1 & 0x01; break;
  610.                 case 2:                temp = temp & 0xFC; temp1 = temp1 & 0x03; break;
  611.                 case 3:                temp = temp & 0xF8; temp1 = temp1 & 0x07; break;
  612.                 case 4:                temp = temp & 0xF0; temp1 = temp1 & 0x0F; break;
  613.                 case 5:                temp = temp & 0xE0; temp1 = temp1 & 0x1F; break;
  614.                 case 6:                temp = temp & 0xC0; temp1 = temp1 & 0x3F; break;
  615.                 case 7:                temp = temp & 0x80; temp1 = temp1 & 0x7F; break;
  616.                 default:        break;
  617.                 }

  619.                 RevBuffer[0] = temp;
  620.                 UID[row - 1] = temp1 | temp;
  621.                 for(i = 1; i < length; i++)
  622.                 {
  623.                         UID[row - 1 + i] = RevBuffer[i];
  624.                 }
  625.         }
  626. }

  628. /****************************************************************/
  629. /*名称: Set_BitFraming */
  630. /*功能: 该函数设置待发送数据的字节数*/
  631. /*输入: row: 产生冲突的行*/
  632. /* col: 产生冲突的列*/
  633. /*输出: N/A */
  634. /****************************************************************/
  635. void Set_BitFraming(uchar row, uchar col)
  636. {
  637.         switch(row)
  638.         {
  639.         case 0:                RevBuffer[1] = 0x20; break;
  640.         case 1:                RevBuffer[1] = 0x30; break;
  641.         case 2:                RevBuffer[1] = 0x40; break;
  642.         case 3:                RevBuffer[1] = 0x50; break;
  643.         case 4:                RevBuffer[1] = 0x60; break;
  644.         default:        break;
  645.         }

  647.         switch(col)
  648.         {
  649.         case 0:                SPIWrite(Bit_Frame,0x00); break;
  650.         case 1:                SPIWrite(Bit_Frame,0x11); RevBuffer[1] = (RevBuffer[1] | 0x01); break;
  651.         case 2:                SPIWrite(Bit_Frame,0x22); RevBuffer[1] = (RevBuffer[1] | 0x02); break;
  652.         case 3:                SPIWrite(Bit_Frame,0x33); RevBuffer[1] = (RevBuffer[1] | 0x03); break;
  653.         case 4:                SPIWrite(Bit_Frame,0x44); RevBuffer[1] = (RevBuffer[1] | 0x04); break;
  654.         case 5:                SPIWrite(Bit_Frame,0x55); RevBuffer[1] = (RevBuffer[1] | 0x05); break;
  655.         case 6:                SPIWrite(Bit_Frame,0x66); RevBuffer[1] = (RevBuffer[1] | 0x06); break;
  656.         case 7:                SPIWrite(Bit_Frame,0x77); RevBuffer[1] = (RevBuffer[1] | 0x07); break;
  657.         default:        break;
  658.         }
  659. }

  661. /****************************************************************/
  662. /*名称: Init_FM1702 */
  663. /*功能: 该函数实现对FM1702初始化操作*/
  664. /*输入: mode:工作模式, 0:TYPEA模式*/
  665. /* 1:TYPEB模式*/
  666. /* 2:上海模式*/
  667. /*输出: N/A */
  668. /****************************************************************/
  669. void Init_FM1702(uchar mode)
  670. {
  671.        
  672.         uchar temp;
  673.         uint        i;
  674.        
  675. //    unsigned int idata timecnt=0;
  676.         RF_SCK = 1;
  677.         RF_MISO = 1;
  678.         RF_MOSI = 1;
  679.         RF_RST = 1;                                    /* FM1702复位 */
  680.         for(i = 0; i < 0x1fff; i++)
  681.         {
  682.                 _nop_();                     /*等待约140ms, 11.0592*/
  683.         }

  685.         RF_RST = 0;
  686.         for(i = 0; i < 0x1fff; i++)      
  687.         {
  688.                 _nop_();
  689.         }


  692. ////////////////////////////////////////////////////////////////////////////
  693.        
  694.         while(temp = SPIRead(Command) != 0)                        /* 等待Command = 0,FM1702复位成功 */
  695.         {
  696.                 _nop_();
  697.         }
  698. ////////////////////////////////////////////////////////////////////////////
  699. //        delay_10ms(1);
  700.     SPIWrite(Page_Sel,0x80);       


  703.         for(i = 0; i < 0x1fff; i++) /* 延时 */
  704.         {
  705.                 if(temp=SPIRead(Command) == 0x00)       
  706.                 {
  707.                         SPIWrite(Page_Sel,0x00);
  708.                 }
  709.         }


  712. //           P2 = SPIRead(TimerClock);           //for debug


  715.         SPIWrite(TimerClock,0x0b);                   //address 2AH    /* 定时器周期设置寄存器 */   

  717.         SPIWrite(TimerControl,0x02);           //address 2BH        /* 定时器控制寄存器 */   
  718.         SPIWrite(TimerReload,0x42);               //address 2CH    /* 定时器初值寄存器 */          
  719.    
  720.         SPIWrite(InterruptEn,0x7f);                   //address 06H    /* 中断使能/禁止寄存器 */     

  722. //        temp = SPIRead(InterruptEn);
  723.         SPIWrite(Int_Req,0x7f);            //address 07H    /* 中断请求标识寄存器 */
  724.         SPIWrite(MFOUTSelect,0x02);                   //address 26H    /* mf OUT 选择配置寄存器 */     

  726. //设置调制器的输入源为内部编码器, 并且设置TX1和TX2
  727.         SPIWrite(TxControl,0x5b);                   //address 11H    /* 发送控制寄存器 */
  728.         SPIWrite(RxControl2,0x01);
  729. //        SPIWrite(RxControl1,0x73);
  730.         SPIWrite(RxWait,0x07);
  731.         if(mode ==2)
  732.         {
  733.                 SPIWrite(TypeSH,0x01);
  734.         }
  735.         else
  736.         {
  737.                 SPIWrite(TypeSH,0x00);
  738.         }

  740. }

  742. /****************************************************************/
  743. /*名称: Command_Send */
  744. /*功能: 该函数实现向FM1702发送命令集的功能*/
  745. /*输入: count, 待发送命令集的长度*/
  746. /* buff, 指向待发送数据的指针*/
  747. /* Comm_Set, 命令码*/
  748. /*输出: TRUE, 命令被正确执行*/
  749. /* FALSE, 命令执行错误*/
  750. /****************************************************************/
  751. uchar Command_Send(uchar count, uchar idata *buff, uchar Comm_Set)
  752. {

  754.         uint                j;
  755.         uchar idata        temp, temp1;
  756.        
  757.         SPIWrite(Command,0x00);
  758.         Clear_FIFO();
  759.         Write_FIFO(count, buff);

  761.        
  762.         SPIWrite(Command,Comm_Set);                /* 命令执行 */
  763.         for(j = 0; j < RF_TimeOut; j++) /* 检查命令执行否 */
  764.         {
  765.                 temp = SPIRead(Command);
  766.                 temp1 = SPIRead(Int_Req) & 0x80;
  767.                 if(temp == 0x00)
  768.                 {
  769.                         return TRUE;
  770.                 }
  771.         }

  773.         return FALSE;
  774. }

  776. /****************************************************************/
  777. /*名称: Read_E2 */
  778. /*功能: 该函数实现从FM1702的EE中读出数据*/
  779. /*输入: lsb, EE地址(低字节) */
  780. /* msb, EE地址(高字节) */
  781. /* count, 待读出数据EE的字节个数*/
  782. /* buff, 指向待读出数据的指针*/
  783. /*输出: TRUE, EE数据正确读出*/
  784. /* FALSE, EE数据读出有误*/
  785. /****************************************************************/
  786. uchar Read_E2(uchar lsb, uchar msb, uchar count, uchar idata *buff)
  787. {
  788.        
  789.         uchar        temp;
  790.        
  791.         *buff = lsb;
  792.         *(buff + 1) = msb;
  793.         *(buff + 2) = count;
  794.         temp = Command_Send(3, buff, ReadE2);
  795.         Read_FIFO(buff);
  796.         if(temp == FALSE) return(TRUE);
  797.         return(FALSE);
  798. }

  800. /****************************************************************/
  801. /*名称: Write_E2 */
  802. /*功能: 该函数实现向FM1702的EE中写入数据*/
  803. /*输入: lsb, EE地址(低字节) */
  804. /* msb, EE地址(高字节) */
  805. /* count, 待写入数据EE的字节个数*/
  806. /* buff, 指向待写入数据的指针*/
  807. /*输出: TRUE, EE数据正确写入*/
  808. /* FALSE, EE数据写入有误*/
  809. /****************************************************************/
  810. uchar Write_E2(uchar lsb, uchar msb, uchar count, uchar idata *buff)
  811. {

  813.         uchar idata        temp, i;

  815.         for(i = 0; i < count; i++)
  816.         {
  817.                 *(buff + count - i + 2) = *(buff - i + count);
  818.         }

  820.         *buff = lsb;
  821.         *(buff + 1) = msb;
  822.         temp = Command_Send(count + 2, buff, WriteE2);
  823.         temp = SPIRead(SecondaryStatus);
  824.         temp = temp & 0x40;
  825.         if(temp == 0x40)
  826.         {
  827.                 SPIWrite(Command,0x00);                        //added 2006/03/15
  828.                 return TRUE;
  829.         }

  831.         return FALSE;
  832. }

  834. /****************************************************************/
  835. /*名称: MIF_Halt */
  836. /*功能: 该函数实现暂停MIFARE卡*/
  837. /*输入: N/A */
  838. /*输出: FM1702_OK: 应答正确*/
  839. /* FM1702_PARITYERR: 奇偶校验错*/
  840. /* FM1702_CRCERR: CRC校验错*/
  841. /* FM1702_NOTAGERR: 无卡*/
  842. /****************************************************************/
  843. uchar MIF_Halt(void)
  844. {

  846.         uchar        temp;
  847.         uint        i;
  848.        
  849.         SPIWrite(CRCPresetLSB,0x63);
  850.         SPIWrite(CWConductance,0x3f);
  851.         SPIWrite(ChannelRedundancy,0x03);
  852.         *RevBuffer = RF_CMD_HALT;
  853.         *(RevBuffer + 1) = 0x00;
  854.         temp = Command_Send(2, RevBuffer, Transmit);
  855.         if(temp == TRUE)
  856.         {
  857.                 for(i = 0; i < 0x50; i++)
  858.                 {
  859.                         _nop_();
  860.                 }

  862.                 return FM1702_OK;
  863.         }
  864.         else
  865.         {
  866.                 temp = SPIRead(ErrorFlag);
  867.                 if((temp & 0x02) == 0x02)
  868.                 {
  869.                         return(FM1702_PARITYERR);
  870.                 }

  872.                 if((temp & 0x04) == 0x04)
  873.                 {
  874.                         return(FM1702_FRAMINGERR);
  875.                 }

  877.                 return(FM1702_NOTAGERR);
  878.         }
  879. }

  881. ///////////////////////////////////////////////////////////////////////
  882. // 转换密钥格式
  883. ///////////////////////////////////////////////////////////////////////
  884. char M500HostCodeKey(  uchar *uncoded, uchar *coded)   
  885. {
  886.     char idata status = FM1702_OK;
  887.     uchar idata cnt = 0;
  888.     uchar idata ln  = 0;     
  889.     uchar idata hn  = 0;      
  890.     for (cnt = 0; cnt < 6; cnt++)
  891.     {
  892.         ln = uncoded[cnt] & 0x0F;
  893.         hn = uncoded[cnt] >> 4;
  894.         coded[cnt * 2 + 1] = (~ln << 4) | ln;
  895.         coded[cnt * 2 ] = (~hn << 4) | hn;
  896.     }
  897.     return FM1702_OK;
  898. }






  905. /****************************************************************/
  906. /*名称: Load_keyE2 */
  907. /*功能: 该函数实现把E2中密码存入FM1702的keyRevBuffer中*/
  908. /*输入: Secnr: EE起始地址*/
  909. /*输出: True: 密钥装载成功*/
  910. /* False: 密钥装载失败*/
  911. /****************************************************************/
  912. uchar Load_keyE2_CPY(uchar Secnr, uchar Mode)
  913. {
  914.         char idata status;
  915.         uchar        temp;       
  916.         uchar        msb = 0;
  917.         uchar        lsb = 0;
  918.         uchar coded_keys[12];

  920.         uchar        temp1;
  921.         if(Secnr >= 0x20)
  922.         {
  923.           temp1 = Secnr - 0x20;
  924.           Secnr = 0x20 + temp1 * 4;
  925.         }

  927.         temp = Secnr * 12;

  929.         if(Mode == RF_CMD_AUTH_LA)
  930.         {
  931.                 if(temp >= 0x80)       
  932.                 {
  933.                         lsb = temp - 0x80;
  934.                         msb = 0x01;
  935.                 }
  936.                 else
  937.                 {
  938.                         lsb = temp + 0x80;
  939.                         msb = 0x00;
  940.                 }
  941.         }
  942.         else
  943.         {
  944.                 msb = 0x01;
  945.                 lsb = temp + 0x40;
  946.         }
  947.        
  948.         status = M500HostCodeKey(&RevBuffer[3],coded_keys);////////////////
  949.         status = Write_E2(lsb, msb, 12, coded_keys);             ////////////////
  950.         if(status != FM1702_OK)
  951.         {
  952.                 return FALSE;
  953.         }

  955.         return TRUE;       

  957. }


  960. /****************************************************************/
  961. /*名称: Load_keyE2 */
  962. /*功能: 该函数实现把E2中密码存入FM1702的keyRevBuffer中*/
  963. /*输入: Secnr: EE起始地址*/
  964. /*输出: True: 密钥装载成功*/
  965. /* False: 密钥装载失败*/
  966. /****************************************************************/
  967. uchar Load_keyE2(uchar Secnr, uchar Mode)
  968. {
  969.         uchar        temp;       
  970.         uchar        msb = 0;
  971.         uchar        lsb = 0;

  973.         uchar        temp1;
  974.         if(Secnr >= 0x20)
  975.         {
  976.           temp1 = Secnr - 0x20;
  977.           Secnr = 0x20 + temp1 * 4;
  978.         }

  980.         temp = Secnr * 12;

  982.         if(Mode == RF_CMD_AUTH_LA)
  983.         {
  984.                 if(temp >= 0x80)       
  985.                 {
  986.                         lsb = temp - 0x80;
  987.                         msb = 0x01;
  988.                 }
  989.                 else
  990.                 {
  991.                         lsb = temp + 0x80;
  992.                         msb = 0x00;
  993.                 }
  994.         }
  995.         else
  996.         {
  997.                 msb = 0x01;
  998.                 lsb = temp + 0x40;
  999.         }
  1000.        
  1001.         RevBuffer[0] = lsb;
  1002.         RevBuffer[1] = msb;
  1003.        
  1004.         temp = Command_Send(2, RevBuffer, LoadKeyE2);
  1005.         temp = SPIRead(ErrorFlag) & 0x40;
  1006.         if(temp == 0x40)
  1007.         {
  1008.                 return FALSE;
  1009.         }

  1011.         return TRUE;
  1012. }


  1015. /****************************************************************/
  1016. /*名称: Request */
  1017. /*功能: 该函数实现对放入FM1702操作范围之内的卡片的Request操作*/
  1018. /*输入: mode: ALL(监测所以FM1702操作范围之内的卡片) */
  1019. /* STD(监测在FM1702操作范围之内处于HALT状态的卡片) */
  1020. /*输出: FM1702_NOTAGERR: 无卡*/
  1021. /* FM1702_OK: 应答正确*/
  1022. /* FM1702_REQERR: 应答错误*/
  1023. /****************************************************************/
  1024. uchar Request(uchar mode)
  1025. {
  1026.        
  1027.         uchar idata        temp;
  1028.        
  1029. //        SPIWrite(CRCPresetLSB,0x63);                //CRCPresetLSB address is 0x23
  1030. //        SPIWrite(CWConductance,0x3f);
  1031.         RevBuffer[0] = mode;       
  1032.         SPIWrite(Bit_Frame,0x07);               
  1033.         SPIWrite(ChannelRedundancy,0x03);       
  1034.         temp = SPIRead(Control);
  1035.         temp = temp & (0xf7);
  1036.         SPIWrite(Control,temp);                        //Control reset value is 00
  1037.         temp = Command_Send(1, RevBuffer, Transceive);   //Transceive=0x1E
  1038.         if(temp == FALSE)
  1039.         {
  1040.                 return FM1702_NOTAGERR;
  1041.         }

  1043.         Read_FIFO(RevBuffer);       
  1044.         temp = Judge_Req(RevBuffer);
  1045.         if(temp == TRUE)
  1046.         {
  1047.                 tagtype[0] = RevBuffer[0];
  1048.                 tagtype[1] = RevBuffer[1];
  1049.                 return FM1702_OK;
  1050.         }                                                       

  1052.         return FM1702_REQERR;
  1053. }

  1055. /****************************************************************/
  1056. /*名称: AntiColl */
  1057. /*功能: 该函数实现对放入FM1702操作范围之内的卡片的防冲突检测*/
  1058. /*输入: N/A */
  1059. /*输出: FM1702_NOTAGERR: 无卡*/
  1060. /* FM1702_BYTECOUNTERR: 接收字节错误*/
  1061. /* FM1702_SERNRERR: 卡片序列号应答错误*/
  1062. /* FM1702_OK: 卡片应答正确*/
  1063. /****************************************************************/
  1064. uchar AntiColl(void)
  1065. {
  1066.        
  1067.         uchar        temp;
  1068.         uchar        i;
  1069.         uchar        row, col;
  1070.         uchar        pre_row;
  1071.        
  1072.         row = 0;
  1073.         col = 0;
  1074.         pre_row = 0;
  1075.         SPIWrite(CRCPresetLSB,0x63);
  1076.         SPIWrite(CWConductance,0x3f);
  1077. //        SPIWrite(ModConductance,0x3f);
  1078.         RevBuffer[0] = RF_CMD_ANTICOL;
  1079.         RevBuffer[1] = 0x20;
  1080.         SPIWrite(ChannelRedundancy,0x03);
  1081.         temp = Command_Send(2, RevBuffer, Transceive);
  1082.         while(1)
  1083.         {
  1084.                 if(temp == FALSE)
  1085.                 {
  1086.                         return(FM1702_NOTAGERR);
  1087.                 }

  1089.                 //temp = ErrorFlag;

  1091.                 temp = SPIRead(FIFO_Length);
  1092.                 if(temp == 0)
  1093.                 {
  1094.                         return FM1702_BYTECOUNTERR;
  1095.                 }

  1097.                 Read_FIFO(RevBuffer);
  1098.                 Save_UID(row, col, temp);                        /* 将收到的UID放入UID数组中 */
  1099.                
  1100.                
  1101.                 temp = SPIRead(ErrorFlag);                                    /* 判断接収数据是否出错 */
  1102.                 temp = temp & 0x01;
  1103.                 if(temp == 0x00)
  1104.                 {
  1105.                         temp = Check_UID();                        /* 校验收到的UID */
  1106.                         if(temp == FALSE)
  1107.                         {
  1108.                                 return(FM1702_SERNRERR);
  1109.                         }

  1111.                         return(FM1702_OK);
  1112.                 }
  1113.                 else
  1114.                 {
  1115.                         temp = SPIRead(CollPos);                                /* 读取冲突检测寄存器 */
  1116.                         row = temp / 8;
  1117.                         col = temp % 8;
  1118.                         RevBuffer[0] = RF_CMD_ANTICOL;
  1119.                         Set_BitFraming(row + pre_row, col);        /* 设置待发送数据的字节数 */
  1120.                         pre_row = pre_row + row;
  1121.                         for(i = 0; i < pre_row + 1; i++)
  1122.                         {
  1123.                                 RevBuffer[i + 2] = UID[i];
  1124.                         }

  1126.                         if(col != 0x00)
  1127.                         {
  1128.                                 row = pre_row + 1;
  1129.                         }
  1130.                         else
  1131.                         {
  1132.                                 row = pre_row;
  1133.                         }

  1135.                         temp = Command_Send(row + 2, RevBuffer, Transceive);
  1136.                 }
  1137.         }
  1138. }

  1140. /****************************************************************/
  1141. /*名称: Select_Card */
  1142. /*功能: 该函数实现对放入FM1702操作范围之内的某张卡片进行选择*/
  1143. /*输入: N/A */
  1144. /*输出: FM1702_NOTAGERR: 无卡*/
  1145. /* FM1702_PARITYERR: 奇偶校验错*/
  1146. /* FM1702_CRCERR: CRC校验错*/
  1147. /* FM1702_BYTECOUNTERR: 接收字节错误*/
  1148. /* FM1702_OK: 应答正确*/
  1149. /* FM1702_SELERR: 选卡出错*/
  1150. /****************************************************************/
  1151. uchar Select_Card(void)
  1152. {
  1153.        
  1154.         uchar        temp, i;
  1155.        
  1156.         SPIWrite(CRCPresetLSB,0x63);
  1157.         SPIWrite(CWConductance,0x3f);
  1158.         RevBuffer[0] = RF_CMD_SELECT;
  1159.         RevBuffer[1] = 0x70;
  1160.         for(i = 0; i < 5; i++)
  1161.         {
  1162.                 RevBuffer[i + 2] = UID[i];
  1163.         }

  1165.         SPIWrite(ChannelRedundancy,0x0f);       
  1166.         temp = Command_Send(7, RevBuffer, Transceive);
  1167.         if(temp == FALSE)
  1168.         {
  1169.                 return(FM1702_NOTAGERR);
  1170.         }
  1171.         else
  1172.         {
  1173.                 temp = SPIRead(ErrorFlag);
  1174.                 if((temp & 0x02) == 0x02) return(FM1702_PARITYERR);
  1175.                 if((temp & 0x04) == 0x04) return(FM1702_FRAMINGERR);
  1176.                 if((temp & 0x08) == 0x08) return(FM1702_CRCERR);
  1177.                 temp = SPIRead(FIFO_Length);
  1178.                 if(temp != 1) return(FM1702_BYTECOUNTERR);
  1179.                 Read_FIFO(RevBuffer);        /* 从FIFO中读取应答信息 */
  1180.                 temp = *RevBuffer;

  1182.                 if((temp == 0x18) || (temp == 0x08) || (temp == 0x88) || (temp == 0x53))        /* 判断应答信号是否正确 */
  1183.                         return(FM1702_OK);
  1184.                 else
  1185.                         return(FM1702_SELERR);
  1186.         }
  1187. }

  1189. /****************************************************************/
  1190. /*名称: Authentication */
  1191. /*功能: 该函数实现密码认证的过程*/
  1192. /*输入: UID: 卡片序列号地址*/
  1193. /* SecNR: 扇区号*/
  1194. /* mode: 模式*/
  1195. /*输出: FM1702_NOTAGERR: 无卡*/
  1196. /* FM1702_PARITYERR: 奇偶校验错*/
  1197. /* FM1702_CRCERR: CRC校验错*/
  1198. /* FM1702_OK: 应答正确*/
  1199. /* FM1702_AUTHERR: 权威认证有错*/
  1200. /****************************************************************/
  1201. uchar Authentication(uchar idata *UID, uchar SecNR, uchar mode)
  1202. {
  1203.        
  1204.         uchar idata        i;
  1205.         uchar idata        temp, temp1;

  1207.         uchar temp0;
  1208.         if(SecNR >= 0x20)
  1209.         {
  1210.                 temp0 = SecNR -0x20;
  1211.                 SecNR = 0x20 + temp0 * 4;
  1212.         }
  1213.        
  1214.         SPIWrite(CRCPresetLSB,0x63);
  1215.         SPIWrite(CWConductance,0x3f);
  1216. //        SPIWrite(ModConductance,0X3f);
  1217. //        temp1 = SPIRead(Control);
  1218. //        temp1 = temp1 & 0xf7;
  1219. //        SPIWrite(Control,temp1);
  1220.         if(mode == RF_CMD_AUTH_LB)                       
  1221.                 RevBuffer[0] = RF_CMD_AUTH_LB;
  1222.         else
  1223.                 RevBuffer[0] = RF_CMD_AUTH_LA;
  1224.         RevBuffer[1] = SecNR * 4 + 3;
  1225.         for(i = 0; i < 4; i++)
  1226.         {
  1227.                 RevBuffer[2 + i] = UID[i];
  1228.         }

  1230.         SPIWrite(ChannelRedundancy,0x0f);       
  1231.         temp = Command_Send(6, RevBuffer, Authent1);
  1232.         if(temp == FALSE)
  1233.         {
  1234.                
  1235.                 return 0x99;
  1236.         }

  1238.         temp = SPIRead(ErrorFlag);             //ErrorFlag address is 0x0A.
  1239.         if((temp & 0x02) == 0x02) return FM1702_PARITYERR;
  1240.         if((temp & 0x04) == 0x04) return FM1702_FRAMINGERR;
  1241.         if((temp & 0x08) == 0x08) return FM1702_CRCERR;
  1242.         temp = Command_Send(0, RevBuffer, Authent2);       
  1243.         if(temp == FALSE)
  1244.         {
  1245.                
  1246.                 return 0x88;
  1247.         }

  1249.         temp = SPIRead(ErrorFlag);
  1250.         if((temp & 0x02) == 0x02) return FM1702_PARITYERR;
  1251.         if((temp & 0x04) == 0x04) return FM1702_FRAMINGERR;
  1252.         if((temp & 0x08) == 0x08) return FM1702_CRCERR;
  1253.         temp1 = SPIRead(Control);
  1254.         temp1 = temp1 & 0x08;       
  1255.         if(temp1 == 0x08)
  1256.         {
  1257.                 return FM1702_OK;
  1258.         }

  1260.         return FM1702_AUTHERR;
  1261. }

  1263. /****************************************************************/
  1264. /*名称: MIF_Read */
  1265. /*功能: 该函数实现读MIFARE卡块的数值*/
  1266. /*输入: buff: 缓冲区首地址*/
  1267. /* Block_Adr: 块地址*/
  1268. /*输出: FM1702_NOTAGERR: 无卡*/
  1269. /* FM1702_PARITYERR: 奇偶校验错*/
  1270. /* FM1702_CRCERR: CRC校验错*/
  1271. /* FM1702_BYTECOUNTERR: 接收字节错误*/
  1272. /* FM1702_OK: 应答正确*/
  1273. /****************************************************************/
  1274. uchar MIF_READ(uchar idata *buff, uchar Block_Adr)
  1275. {
  1276.        
  1277.         uchar idata        temp;
  1278.        
  1279.         SPIWrite(CRCPresetLSB,0x63);
  1280.         SPIWrite(CWConductance,0x3f);
  1281.         SPIWrite(ModConductance,0x3f);
  1282.         SPIWrite(ChannelRedundancy,0x0f);

  1284.         buff[0] = RF_CMD_READ;
  1285.         buff[1] = Block_Adr;
  1286.         temp = Command_Send(2, buff, Transceive);
  1287.         if(temp == 0)
  1288.         {
  1289.                 return FM1702_NOTAGERR;
  1290.         }

  1292.         temp = SPIRead(ErrorFlag);
  1293.         if((temp & 0x02) == 0x02) return FM1702_PARITYERR;
  1294.         if((temp & 0x04) == 0x04) return FM1702_FRAMINGERR;
  1295.         if((temp & 0x08) == 0x08) return FM1702_CRCERR;
  1296.         temp = SPIRead(FIFO_Length);
  1297.         if(temp == 0x10)       
  1298.         {
  1299.                 Read_FIFO(buff);
  1300.                 return FM1702_OK;
  1301.         }
  1302.         else if(temp == 0x04)       
  1303.         {
  1304.                 Read_FIFO(buff);
  1305.                 return FM1702_OK;
  1306.         }
  1307.         else
  1308.         {
  1309.                 return FM1702_BYTECOUNTERR;
  1310.         }
  1311. }

  1313. /****************************************************************/
  1314. /*名称: MIF_Write */
  1315. /*功能: 该函数实现写MIFARE卡块的数值*/
  1316. /*输入: buff: 缓冲区首地址*/
  1317. /* Block_Adr: 块地址*/
  1318. /*输出: FM1702_NOTAGERR: 无卡*/
  1319. /* FM1702_BYTECOUNTERR: 接收字节错误*/
  1320. /* FM1702_NOTAUTHERR: 未经权威认证*/
  1321. /* FM1702_EMPTY: 数据溢出错误*/
  1322. /* FM1702_CRCERR: CRC校验错*/
  1323. /* FM1702_PARITYERR: 奇偶校验错*/
  1324. /* FM1702_WRITEERR: 写卡块数据出错*/
  1325. /* FM1702_OK: 应答正确*/
  1326. /****************************************************************/
  1327. uchar MIF_Write(uchar idata *buff, uchar Block_Adr)
  1328. {

  1330.         uchar idata        temp;
  1331.         uchar idata        *F_buff;

  1333.         SPIWrite(CRCPresetLSB,0x63);
  1334.         SPIWrite(CWConductance,0x3f);
  1335.         F_buff = buff + 0x10;
  1336.         SPIWrite(ChannelRedundancy,0x07);    /* Note: this line is for 1702, different from RC500*/
  1337.         *F_buff = RF_CMD_WRITE;
  1338.         *(F_buff + 1) = Block_Adr;
  1339.         temp = Command_Send(2, F_buff, Transceive);
  1340.         if(temp == FALSE)
  1341.         {
  1342.                 return(FM1702_NOTAGERR);
  1343.         }

  1345.         temp = SPIRead(FIFO_Length);
  1346.         if(temp == 0)
  1347.         {
  1348.                 return(FM1702_BYTECOUNTERR);
  1349.         }

  1351.         Read_FIFO(F_buff);
  1352.         temp = *F_buff;
  1353.         switch(temp)
  1354.         {
  1355.         case 0x00:        return(FM1702_NOTAUTHERR);       
  1356.         case 0x04:        return(FM1702_EMPTY);
  1357.         case 0x0a:        break;
  1358.         case 0x01:        return(FM1702_CRCERR);
  1359.         case 0x05:        return(FM1702_PARITYERR);
  1360.         default:        return(FM1702_WRITEERR);
  1361.         }

  1363.         temp = Command_Send(16, buff, Transceive);
  1364.         if(temp == TRUE)
  1365.         {
  1366.                 return(FM1702_OK);
  1367.         }
  1368.         else
  1369.         {
  1370.                 temp = SPIRead(ErrorFlag);
  1371.                 if((temp & 0x02) == 0x02)
  1372.                         return(FM1702_PARITYERR);
  1373.                 else if((temp & 0x04) == 0x04)
  1374.                         return(FM1702_FRAMINGERR);
  1375.                 else if((temp & 0x08) == 0x08)
  1376.                         return(FM1702_CRCERR);
  1377.                 else
  1378.                         return(FM1702_WRITEERR);
  1379.         }
  1380. }

  1382. /****************************************************************/
  1383. /*名称: MIF_Increment */
  1384. /*功能: 该函数实现MIFARE卡自动增值操作*/
  1385. /*输入: buff: 四个字节数值起始地址*/
  1386. /* Block_Adr: 块地址*/
  1387. /*输出: FM1702_NOTAGERR: 无卡*/
  1388. /* FM1702_BYTECOUNTERR: 接收字节错误*/
  1389. /* FM1702_NOTAUTHERR: 未经权威认证*/
  1390. /* FM1702_EMPTY: 数据溢出错误*/
  1391. /* FM1702_CRCERR: CRC校验错*/
  1392. /* FM1702_PARITYERR: 奇偶校验错*/
  1393. /* FM1702_INCRERR: 卡片增款操作失败*/
  1394. /* FM1702_OK: 应答正确*/
  1395. /****************************************************************/
  1396. uchar MIF_Increment(uchar idata *buff, uchar Block_Adr)
  1397. {
  1398.        
  1399.         uchar                temp;
  1400.         uchar idata        *F_buff;
  1401.        
  1402.         SPIWrite(CRCPresetLSB,0x63);
  1403.         SPIWrite(CWConductance,0x3f);
  1404.         F_buff = buff + 4;
  1405.         *F_buff = RF_CMD_INC;
  1406.         *(F_buff + 1) = Block_Adr;
  1407.         SPIWrite(ChannelRedundancy,0x07);
  1408.         temp = Command_Send(2, F_buff, Transceive);
  1409.         if(temp == FALSE)
  1410.         {
  1411.                 return FM1702_NOTAGERR;
  1412.         }

  1414.         temp = SPIRead(FIFO_Length);
  1415.         if(temp == 0)
  1416.         {
  1417.                 return FM1702_BYTECOUNTERR;
  1418.         }

  1420.         Read_FIFO(F_buff);
  1421.         temp = *F_buff;
  1422.         switch(temp)
  1423.         {
  1424.         case 0x00:        /* break; */return(FM1702_NOTAUTHERR);
  1425.         case 0x04:        return(FM1702_EMPTY);
  1426.         case 0x0a:        break;
  1427.         case 0x01:        return(FM1702_CRCERR);
  1428.         case 0x05:        return(FM1702_PARITYERR);
  1429.         default:        return(FM1702_INCRERR);
  1430.         }
  1431.         
  1432.         temp = Command_Send(4, buff, Transmit);
  1433.         if(temp == FALSE)
  1434.         {
  1435.                 return FM1702_INCRERR;
  1436.         }

  1438.         return FM1702_OK;
  1439. }

  1441. /****************************************************************/
  1442. /*名称: MIF_Decrement */
  1443. /*功能: 该函数实现MIFARE卡自动减值操作*/
  1444. /*输入: buff: 四个字节数值起始地址*/
  1445. /* Block_Adr: 块地址*/
  1446. /*输出: FM1702_NOTAGERR: 无卡*/
  1447. /* FM1702_BYTECOUNTERR: 接收字节错误*/
  1448. /* FM1702_NOTAUTHERR: 未经权威认证*/
  1449. /* FM1702_EMPTY: 数据溢出错误*/
  1450. /* FM1702_CRCERR: CRC校验错*/
  1451. /* FM1702_PARITYERR: 奇偶校验错*/
  1452. /* FM1702_DECRERR: 卡片扣款操作失败*/
  1453. /* FM1702_OK: 应答正确*/
  1454. /****************************************************************/
  1455. uchar MIF_Decrement(uchar idata *buff, uchar Block_Adr)
  1456. {
  1457.        
  1458.         uchar                temp;
  1459.         uchar idata        *F_buff;
  1460.        
  1461.         SPIWrite(CRCPresetLSB,0x63);
  1462.         SPIWrite(CWConductance,0x3f);
  1463.         F_buff = buff + 4;
  1464.         *F_buff = RF_CMD_DEC;
  1465.         *(F_buff + 1) = Block_Adr;
  1466.         SPIWrite(ChannelRedundancy,0x07);
  1467.         temp = Command_Send(2, F_buff, Transceive);
  1468.         if(temp == FALSE)
  1469.         {
  1470.                 return FM1702_NOTAGERR;
  1471.         }

  1473.         temp = SPIRead(FIFO_Length);
  1474.         if(temp == 0)
  1475.         {
  1476.                 return FM1702_BYTECOUNTERR;
  1477.         }

  1479.         Read_FIFO(F_buff);
  1480.         temp = *F_buff;
  1481.         switch(temp)
  1482.         {
  1483.         case 0x00:        /* break; */return(FM1702_NOTAUTHERR);       
  1484.         case 0x04:        return(FM1702_EMPTY);
  1485.         case 0x0a:        break;
  1486.         case 0x01:        return(FM1702_CRCERR);
  1487.         case 0x05:        return(FM1702_PARITYERR);
  1488.         default:        return(FM1702_DECRERR);
  1489.         }

  1491.         temp = Command_Send(4, buff, Transmit);
  1492.         if(temp == FALSE)
  1493.         {
  1494.                 return(FM1702_DECRERR);
  1495.         }

  1497.         return FM1702_OK;
  1498. }

  1500. /****************************************************************/
  1501. /*名称: MIF_Restore */
  1502. /*功能: 该函数实现MIFARE卡自动恢复,备份操作*/
  1503. /*输入: Block_Adr: 块地址*/
  1504. /*输出: FM1702_NOTAGERR: 无卡*/
  1505. /* FM1702_BYTECOUNTERR: 接收字节错误*/
  1506. /* FM1702_NOTAUTHERR: 未经权威认证*/
  1507. /* FM1702_EMPTY: 数据溢出错误*/
  1508. /* FM1702_CRCERR: CRC校验错*/
  1509. /* FM1702_PARITYERR: 奇偶校验错*/
  1510. /* FM1702_RESTERR: 卡片恢复,备份操作失败*/
  1511. /* FM1702_OK: 应答正确*/
  1512. /****************************************************************/
  1513. uchar MIF_Restore(uchar Block_Adr)
  1514. {
  1515.        
  1516.         uchar        temp, i;
  1517.        
  1518.         SPIWrite(CRCPresetLSB,0x63);
  1519.         SPIWrite(CWConductance,0x3f);
  1520.         SPIWrite(ChannelRedundancy,0x07);
  1521.         *RevBuffer = RF_CMD_RESTORE;
  1522.         *(RevBuffer + 1) = Block_Adr;
  1523.         temp = Command_Send(2, RevBuffer, Transceive);
  1524.         if(temp == FALSE)
  1525.         {
  1526.                 return FM1702_NOTAGERR;
  1527.         }

  1529.         temp = SPIRead(FIFO_Length);
  1530.         if(temp == 0)
  1531.         {
  1532.                 return FM1702_BYTECOUNTERR;
  1533.         }

  1535.         Read_FIFO(RevBuffer);
  1536.         temp = *RevBuffer;
  1537.         switch(temp)
  1538.         {
  1539.         case 0x00:        /* break; */return(FM1702_NOTAUTHERR);       
  1540.         case 0x04:        return(FM1702_EMPTY);
  1541.         case 0x0a:        break;
  1542.         case 0x01:        return(FM1702_CRCERR);
  1543.         case 0x05:        return(FM1702_PARITYERR);
  1544.         default:        return(FM1702_RESTERR);
  1545.         }

  1547.         for(i = 0; i < 4; i++) RevBuffer[i] = 0x00;
  1548.         temp = Command_Send(4, RevBuffer, Transmit);
  1549.         if(temp == FALSE)
  1550.         {
  1551.                 return FM1702_RESTERR;
  1552.         }

  1554.         return FM1702_OK;
  1555. }

  1557. /****************************************************************/
  1558. /*名称: MIF_Transfer */
  1559. /*功能: 该函数实现MIFARE卡电子钱包保存操作*/
  1560. /*输入: Block_Adr: 块地址*/
  1561. /*输出: FM1702_NOTAGERR: 无卡*/
  1562. /* FM1702_BYTECOUNTERR: 接收字节错误*/
  1563. /* FM1702_NOTAUTHERR: 未经权威认证*/
  1564. /* FM1702_EMPTY: 数据溢出错误*/
  1565. /* FM1702_CRCERR: CRC校验错*/
  1566. /* FM1702_PARITYERR: 奇偶校验错*/
  1567. /* FM1702_TRANSERR: 卡片恢复,备份操作失败*/
  1568. /* FM1702_OK: 应答正确*/
  1569. /****************************************************************/
  1570. uchar MIF_Transfer(uchar Block_Adr)
  1571. {
  1572.        
  1573.         uchar        temp;
  1574.         SPIWrite(CRCPresetLSB,0x63);
  1575.         SPIWrite(CWConductance,0x3f);
  1576.         SPIWrite(ChannelRedundancy,0x07);       
  1577.         RevBuffer[0] = RF_CMD_TRANSFER;
  1578.         RevBuffer[1] = Block_Adr;
  1579.         temp = Command_Send(2, RevBuffer, Transceive);
  1580.         if(temp == FALSE)
  1581.         {
  1582.                 return FM1702_NOTAGERR;
  1583.         }

  1585.         temp = SPIRead(FIFO_Length);
  1586.         if(temp == 0)
  1587.         {
  1588.                 return FM1702_BYTECOUNTERR;
  1589.         }

  1591.         Read_FIFO(RevBuffer);
  1592.         temp = *RevBuffer;
  1593.         switch(temp)
  1594.         {
  1595.         case 0x00:        /* break; */return(FM1702_NOTAUTHERR);       
  1596.         case 0x04:        return(FM1702_EMPTY);
  1597.         case 0x0a:        return(FM1702_OK);
  1598.         case 0x01:        return(FM1702_CRCERR);
  1599.         case 0x05:        return(FM1702_PARITYERR);
  1600.         default:        return(FM1702_TRANSERR);
  1601.         }
  1602. }

  1604. #if 0
  1605. /****************************************************************/
  1606. /*名称: HL_Active */
  1607. /*功能: 该函数实现高级MIFARE卡激活命令*/
  1608. /*输入: Secnr: 扇区号*/
  1609. /* Block_Adr: 块地址*/
  1610. /*输出: 操作状态码*/
  1611. /* 读出数据存于RevBuffer中*/
  1612. /****************************************************************/
  1613. uchar HL_Active(uchar Block_Adr, uchar Mode)
  1614. {
  1615.        
  1616.         uchar        temp;
  1617.        
  1618.         Secnr = Block_Adr / 4;
  1619.         MIF_Halt();        /* Halt */
  1620.         temp = Request(RF_CMD_REQUEST_STD);               
  1621.         if(temp != FM1702_OK)
  1622.         {
  1623.                 return(FM1702_REQERR);
  1624.         }

  1626.         temp = AntiColl();                               
  1627.         if(temp != FM1702_OK)
  1628.         {
  1629.                 return(FM1702_ANTICOLLERR);
  1630.         }

  1632.         temp = Select_Card();                               
  1633.         if(temp != FM1702_OK)
  1634.         {
  1635.                 return(FM1702_SELERR);
  1636.         }

  1638.         Load_keyE2_CPY(Secnr, Mode);        //%40       
  1639. ……………………

  1641. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:

1702SL开发板源码.rar (42.75 KB, 下载次数: 37)
回复

使用道具 举报

ID:1 发表于 2018-12-9 00:51 | 显示全部楼层
补全原理图或者详细说明一下电路连接即可获得100+黑币
回复

使用道具 举报

ID:461708 发表于 2019-1-4 13:14 | 显示全部楼层
不错！~~~~~
回复

使用道具 举报

ID:29579 发表于 2022-8-19 14:14 | 显示全部楼层
谢谢分享
回复

使用道具 举报

ID:1096636 发表于 2023-10-20 09:01 | 显示全部楼层
可否提供原理图学习呀，谢谢！
回复

使用道具 举报

ID:1100683 发表于 2023-11-21 17:35 | 显示全部楼层
请问，是什么型号的单片机？
回复

使用道具 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

手机版|小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表