mfrc500uc._c

该程序是医院用的CPCR记录仪的终端控制程序

#include <string.h>
#include <stdio.h>
#include <d:\gkdoor\chensoft\MfRc500.h>
#include <d:\gkdoor\chensoft\main.h>
#include <iom128v.h>
unsigned char MLastSelectedSnr[5];
#define TCLFSDSNDMAX   8   ///< max. frame size send
#define TCLFSDRECMAX   8   ///< max. frame size rcv
#define TCLDSMAX       3   ///< max. baudrate divider PICC --> PCD
#define TCLDRMAX       3   ///< max. baudrate divider PCD --> PICC
#define TCLDSDFLT      0   ///< default baudrate divider PICC --> PCD
#define TCLDRDFLT      0   ///< default baudrate divider PCD --> PICC
unsigned char *MSndBuffer;
unsigned char *MRcvBuffer;
MfCmdInfo MInfo;

MfCmdInfo     *MpIsrInfo = 0; 
unsigned char *MpIsrOut = 0; 
unsigned char *MpIsrIn = 0;   
unsigned char CountDown;
unsigned char T2IR;

unsigned char RicRxTxBuffer[256];
unsigned char MFIFOLength = DEF_FIFO_LENGTH;
char Mf500PiccAuthState(unsigned char auth_mode,// PICC_AUTHENT1A, PICC_AUTHENT1B
                       unsigned char *snr,    // 4 byte serial number
                       unsigned char sector); // 0 <= sector <= 15
unsigned char mc500_time=0;
char Mf500PcdConfig(void)
{
   unsigned char i;
   int status = MI_RESETERR;
   unsigned short RstLoopCnt = 0;
   unsigned short CmdWaitCnt = 0;
   MSndBuffer = RicRxTxBuffer;  // initialise send buffer 
   MRcvBuffer = RicRxTxBuffer;  // initialise receive buffer
   status = PcdReset();
   if (status == MI_OK)
   {
     WriteRC(RegClockQControl,0x0);
	 for(i=0;i<105;i++);
     ClearBitMask(RegClockQControl,0x40); // clear bit ClkQCalib for 
     WriteRC(RegBitPhase,0xAD);      
     WriteRC(RegRxThreshold,0xFF);   
     WriteRC(RegRxControl2,00);
     WriteRC(RegFIFOLevel,0x1A); // initialize to 26d 
     WriteRC(RegTimerControl,0x02);  // TStopRxEnd=0,TStopRxBeg=0,
     WriteRC(RegIRqPinConfig,0x3); // interrupt active low enable
     PcdRfReset(1);            // Rf - reset and enable output driver   
   }
   return status;
}

char Mf500PiccRequest(unsigned char req_code, // request code ALL = 0x52 
                                           // or IDLE = 0x26 
                   unsigned char *atq)     // answer to request
{
  return Mf500PiccCommonRequest(req_code,atq);
}
char Mf500PiccCommonRequest(unsigned char req_code,unsigned char *atq)
{
      int status = MI_OK;
    //************* initialize ******************************
   	  PcdSetTmo(106);
      WriteRC(RegChannelRedundancy,0x03); // RxCRC and TxCRC disable, parity enable
      ClearBitMask(RegControl,0x08);      // disable crypto 1 unit   
      WriteRC(RegBitFraming,0x07);        // set TxLastBits to 7 
      ResetInfo(MInfo);   
      MSndBuffer[0] = req_code;
      MInfo.nBytesToSend   = 1;   
      status = PcdSingleResponseCmd(0x1e,MSndBuffer,MRcvBuffer,&MInfo);
      if (status)      // error occured
      {
      *atq = 0;
      } 
      else 
      {
         if (MInfo.nBitsReceived != 16) // 2 bytes expected
         {
            status = MI_BITCOUNTERR;
         } 
         else 
         {
            status = MI_OK;
            memcpy(atq,MRcvBuffer,2);
         }
      }
   return status; 
}
///////////////////////////////////////////////////////////////////////
//          M I F A R E    A N T I C O L L I S I O N
// for standard select
///////////////////////////////////////////////////////////////////////
char Mf500PiccAnticoll (unsigned char bcnt,
                     unsigned char *snr)
{
   return Mf500PiccCascAnticoll(0x93,bcnt,snr); // first cascade level
}
char Mf500PiccCascAnticoll(unsigned char select_code,unsigned char bcnt,unsigned char *snr)       
{
   int  status = MI_OK;
   char  snr_in[4];         // copy of the input parameter snr
   char  nbytes = 0;        // how many bytes received
   char  nbits = 0;         // how many bits received
   char  complete = 0;      // complete snr recived
   char  i        = 0;
   char  byteOffset = 0;
   unsigned char snr_crc;   // check byte calculation
   unsigned char snr_check;
   unsigned char dummyShift1;       // dummy byte for snr shift
   unsigned char dummyShift2;       // dummy byte for snr shift   
   //************* Initialisierung ******************************
   if ((status = Mf500PcdSetDefaultAttrib()) == MI_OK)
   {
      PcdSetTmo(106);
      memcpy(snr_in,snr,4);   
      WriteRC(RegDecoderControl,0x28); // ZeroAfterColl aktivieren   
      ClearBitMask(RegControl,0x08);    // disable crypto 1 unit
      //************** Anticollision Loop ***************************
      complete=0;
      while (!complete && (status == MI_OK) )
      {
         ResetInfo(MInfo);
         WriteRC(RegChannelRedundancy,0x03); // RxCRC and TxCRC disable, parity enable
         nbits = bcnt % 8;   // remaining number of bits
         if (nbits)
         {
            WriteRC(RegBitFraming,nbits << 4 | nbits); // TxLastBits/RxAlign auf nb_bi
            nbytes = bcnt / 8 + 1;   
            if (nbits == 7 )
            {
               MInfo.cmd = PICC_ANTICOLL1;   // pass command flag to ISR        
               WriteRC(RegBitFraming,nbits); // reset RxAlign to zero
            }
         } 
         else
         {
            nbytes = bcnt / 8;
         }
         MSndBuffer[0] = select_code;
         MSndBuffer[1] = 0x20 + ((bcnt/8) << 4) + nbits; //number of bytes send
         for (i = 0; i < nbytes; i++)  // Sende Buffer beschreiben
         {
            MSndBuffer[i + 2] = snr_in[i];
         }
         MInfo.nBytesToSend = 2 + nbytes;    
        status = PcdSingleResponseCmd(0x1e,
                            MSndBuffer,
                            MRcvBuffer,
                            &MInfo);
       if (nbits == 7)
         {
            dummyShift1 = 0x00;
            for (i = 0; i < MInfo.nBytesReceived; i++)
            {
                dummyShift2 = MRcvBuffer[i];
                MRcvBuffer[i] = (dummyShift1 >> (i+1)) | (MRcvBuffer[i] << (7-i));
                dummyShift1 = dummyShift2;
            }
            MInfo.nBitsReceived -= MInfo.nBytesReceived; // subtract received parity bits
            if ( MInfo.collPos ) MInfo.collPos += 7 - (MInfo.collPos + 6) / 9;
         }
         if ( status == MI_OK || status == MI_COLLERR)    // no other occured
         {
             if ( MInfo.nBitsReceived != (40 - bcnt) ) // not 5 bytes answered
            {
               status = MI_BITCOUNTERR;
            } 
            else 
            {
               byteOffset = 0;
               if ( nbits != 0 )           // last byte was not complete
               {
                  snr_in[nbytes - 1] = snr_in[nbytes - 1] | MRcvBuffer[0];
                  byteOffset = 1;
               }
               for ( i =0; i < (4 - nbytes); i++)     
               {
                  snr_in[nbytes + i] = MRcvBuffer[i + byteOffset];
               }
               if (status != MI_COLLERR ) // no error and no collision
               {
                  snr_crc = snr_in[0] ^ snr_in[1] ^ snr_in[2] ^ snr_in[3];
                  snr_check = MRcvBuffer[MInfo.nBytesReceived - 1];
                  if (snr_crc != snr_check)
                  {
                     status = MI_SERNRERR;
                  } 
                  else   
                  {
                     complete = 1;
                  }
               }
               else                   // collision occured
               {
                  bcnt = bcnt + MInfo.collPos - nbits;
                  status = MI_OK;
               }
            }
        }
      }
   }
   if (status == MI_OK)
   {
       memcpy(snr,snr_in,4);
   }
   else
   {
//      memcpy(snr,"0000",4);
		;
   }
    ClearBitMask(RegDecoderControl,0x20); // ZeroAfterColl disable
    return status;  
}
char Mf500PiccSelect(unsigned char *snr,unsigned char *sak)
{
   return Mf500PiccCascSelect(0x93,snr,sak); // first cascade level
}

char Mf500PiccCascSelect(unsigned char select_code,unsigned char *snr,unsigned char *sak)
{
   int   status = MI_OK; 
   if ((status = Mf500PcdSetDefaultAttrib()) == MI_OK)
   {
      PcdSetTmo(106);
      WriteRC(RegChannelRedundancy,0x0F); // RxCRC,TxCRC, Parity enable
      ClearBitMask(RegControl,0x08);    // disable crypto 1 unit
      //************* Cmd Sequence ********************************** 
      ResetInfo(MInfo);   
      MSndBuffer[0] = select_code;
      MSndBuffer[1] = 0x70;         // number of bytes send
      memcpy(MSndBuffer + 2,snr,4);
      MSndBuffer[6] = MSndBuffer[2] 
                      ^ MSndBuffer[3] 
                      ^ MSndBuffer[4] 
                      ^ MSndBuffer[5];
      MInfo.nBytesToSend   = 7;
      status = PcdSingleResponseCmd(0x1e,
                          MSndBuffer,
                          MRcvBuffer,
                          &MInfo);
       *sak = 0;   
      if (status == MI_OK)    // no timeout occured
      {
         if (MInfo.nBitsReceived != 8)    // last byte is not complete
         {
            status = MI_BITCOUNTERR;
         }
         else
         {
            *sak = MRcvBuffer[0];
            memcpy(MLastSelectedSnr,snr,4);            
         }
      }
   }
   return status;
}
char Mf500PcdSetDefaultAttrib(void)
{
   int   status = MI_OK;
   return status;
}
char Mf500PiccAuth(unsigned char key_type,    // PICC_AUTHENT1A or PICC_AUTHENT1B
                   unsigned char key_addr,    // key address in reader storage
                   unsigned char block)       // block number which should be 
                                              // authenticated
{
   int            status = MI_OK;
   status = Mf500PiccAuthE2(  key_type,
                              MLastSelectedSnr,
                              key_addr,
                              block);
   return status;
}
char Mf500HostCodeKey(  unsigned char *uncoded, // 6 bytes key value uncoded
                     unsigned char *coded)   // 12 bytes key value coded
{
   int status = MI_OK;
   unsigned char cnt = 0;
   unsigned char ln  = 0;     // low nibble
   unsigned char hn  = 0;     // high nibble
    for (cnt = 0; cnt < 6; cnt++)
   {
      ln = uncoded[cnt] & 0x0F;
      hn = uncoded[cnt] >> 4;
      coded[cnt * 2 + 1]     =  (~ln << 4) | ln;
      coded[cnt * 2 ] =  (~hn << 4) | hn;
   }
   return MI_OK;
}
char Mf500PiccAuthKey(unsigned char auth_mode,
                     unsigned char *snr,       
                     unsigned char *keys,      
                     unsigned char block)      
{
   int status     = MI_OK;
   unsigned char i = 0;
   PcdSetTmo(106);
   FlushFIFO();    // empty FIFO
   ResetInfo(MInfo);
   memcpy(MSndBuffer,keys,12);                  // write 12 bytes of the key
   MInfo.nBytesToSend = 12;
   if ((status=PcdSingleResponseCmd(0x19,MSndBuffer,MRcvBuffer,&MInfo)) == MI_OK)
   {      
       status = Mf500PiccAuthState(auth_mode,snr,block); 
   }
   return status;
}
char Mf500PiccAuthState(   unsigned char auth_mode,
                        unsigned char *snr,
                        unsigned char block)
{
   int status = MI_OK;
   unsigned char i = 0;
   status = ReadRC(RegErrorFlag);    // read error flags of the previous
   if (status != MI_OK)
   {
      if (status & 0x40)            // key error flag set
         status = MI_KEYERR;
      else
         status = MI_AUTHERR;       // generic authentication error 
   }
   else
   {
      PcdSetTmo(106);
      MSndBuffer[0] = auth_mode;        // write authentication command
      MSndBuffer[1] = block;    // write block number for authentication
      memcpy(MSndBuffer + 2,snr,4); // write 4 bytes card serial number 
      ResetInfo(MInfo);
      MInfo.nBytesToSend = 6;
      if ((status = PcdSingleResponseCmd(0x0C,
                               MSndBuffer,
                               MRcvBuffer,
                               &MInfo)) == MI_OK)
      {
         if (ReadRC(RegSecondaryStatus) & 0x07) // RxLastBits mu