mfrc500.c

mifarea卡程序mifarea卡程序mifarea卡程序

{
    uchar status = MI_OK;

    ResetInfo(&MInfo);
    M500PcdSetTmo(3);
    SndBuffer[0] = PICC_TRANSFER;
    SndBuffer[1] = Address;
    MInfo.nBytesToSend   = 2;
    status = M500PcdCmd(PCD_TRANSCEIVE, SndBuffer, RcvBuffer, &MInfo);
    if (status != MI_NOTAGERR)
    {
        if (MInfo.nBitsReceived != 4)
        {
            status = MI_BITCOUNTERR;
        }
        else
        {
            RcvBuffer[0] &= 0x0f;
            switch(RcvBuffer[0])
            {
                case 0x00:
                    status = MI_NOTAUTHERR;
                    break;
                case 0x0a:
                    status = MI_OK;
                    break;
                case 0x01:
                    status = MI_VALERR;
                    break;
                default:
                    status = MI_CODEERR;
                    break;
            }
        }
    }
    return status;
}


///////////////////////////////////////////////////////////////////////
//                V A L U E   M A N I P U L A T I O N 
///////////////////////////////////////////////////////////////////////
char M500Value(unsigned char dd_mode, 
                   unsigned char addr, 
                   unsigned char *value,
                   unsigned char trans_addr)
{
   char status = MI_OK;

   M500PcdSetTmo(3);//255);  // 106
   // ************* Cmd Sequence ********************************** 
   ResetInfo(&MInfo);   
   SndBuffer[0] = dd_mode;        // Inc,Dec command code
   SndBuffer[1] = addr;
   MInfo.nBytesToSend   = 2;
   status = M500PcdCmd(PCD_TRANSCEIVE,
                       SndBuffer,
                       RcvBuffer,
                       &MInfo);

   if (status != MI_NOTAGERR)   // no timeout error
   {
        if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
        {
           status = MI_BITCOUNTERR;
        }
        else                     // 4 bit received
        {
           RcvBuffer[0] &= 0x0f; // mask out upper nibble
           switch(RcvBuffer[0])
           {
              case 0x00: 
                 status = MI_NOTAUTHERR;
                 break;
              case 0x0a:
                 status = MI_OK;
                 break;
              case 0x01:
                 status = MI_VALERR;
                 break;
              default:
                 status = MI_CODEERR;
                 break;
           }
        }
     }

     if ( status == MI_OK)
     {
        M500PcdSetTmo(4);//255);     // long timeout 1000

        ResetInfo(&MInfo);   
        memcpy(SndBuffer,value,4);
        MInfo.nBytesToSend   = 4;
        status = M500PcdCmd(PCD_TRANSCEIVE,
                            SndBuffer,
                            RcvBuffer,
                            &MInfo);
        
        if (status == MI_OK)    // no timeout occured
        {
            if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
            {
               status = MI_BITCOUNTERR;
            }
            else                     // 4 bit received
            {
               RcvBuffer[0] &= 0x0f; // mask out upper nibble
               switch(RcvBuffer[0])
               {
                  case 0x00: 
                     status = MI_NOTAUTHERR;
                     break;
                  case 0x01:
                     status = MI_VALERR;
                     break;
                  default:
                     status = MI_CODEERR;
                     break;
               }
            }
         }        
         else
         if (status == MI_NOTAGERR )
            status = MI_OK;  // no response after 4 byte value - 
                             // transfer command has to follow
     }
     if ( status == MI_OK)
     {
        ResetInfo(&MInfo);   
        SndBuffer[0] = PICC_TRANSFER;        // transfer command code
        SndBuffer[1] = trans_addr;
        MInfo.nBytesToSend   = 2;
        status = M500PcdCmd(PCD_TRANSCEIVE,
                            SndBuffer,
                            RcvBuffer,
                            &MInfo);
        
        if (status != MI_NOTAGERR)    // timeout occured
        {
            if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
            {
               status = MI_BITCOUNTERR;
            }
            else                     // 4 bit received
            {
               RcvBuffer[0] &= 0x0f; // mask out upper nibble
               switch(RcvBuffer[0])
               {
                  case 0x00: 
                     status = MI_NOTAUTHERR;
                     break;
                  case 0x0a:
                     status = MI_OK;
                     break;
                  case 0x01:
                     status = MI_VALERR;
                     break;
                  default:
                     status = MI_CODEERR;
                     break;
               }
            }
        }        
     }
   return status;
}

///////////////////////////////////////////////////////////////////////
//   V A L U E   M A N I P U L A T I O N   W I T H   B A C K U P
///////////////////////////////////////////////////////////////////////
/*
char M500ValueDebit(unsigned char dd_mode, 
                         unsigned char addr, 
                         unsigned char *value)
{
   char status = MI_OK;
   
   M500PcdSetTmo(3);//255);  //106
   ResetInfo(&MInfo);   
   SndBuffer[0] = dd_mode;        // Inc,Dec command code
   SndBuffer[1] = addr;
   MInfo.nBytesToSend   = 2;
   status = M500PcdCmd(PCD_TRANSCEIVE,
                       SndBuffer,
                       RcvBuffer,
                       &MInfo);
                       
   if (status != MI_NOTAGERR)   // no timeout error
   {
        if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
        {
           status = MI_BITCOUNTERR;
        }
        else                     // 4 bit received
        {
           RcvBuffer[0] &= 0x0f; // mask out upper nibble
           switch(RcvBuffer[0])
           {
              case 0x00: 
                 status = MI_NOTAUTHERR;
                 break;
              case 0x0a:
                 status = MI_OK;
                 break;
              case 0x01:
                 status = MI_VALERR;
                 break;
              default:
                 status = MI_CODEERR;
                 break;
           }
        }
     }

     if ( status == MI_OK)
     {
        M500PcdSetTmo(4);//255);     // long timeout 640

        ResetInfo(&MInfo);   
        memcpy(SndBuffer,value,4);
        MInfo.nBytesToSend   = 4;
        status = M500PcdCmd(PCD_TRANSCEIVE,
                            SndBuffer,
                            RcvBuffer,
                            &MInfo);
        
#ifdef DEBUGRC500
    ComWrite("status2: ", 7);
    ComWrite(&status, 1);
#endif

        if (status == MI_OK)    // no timeout occured
        {
            if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
            {
               status = MI_BITCOUNTERR;
            }
            else                     // 4 bit received
            {
               RcvBuffer[0] &= 0x0f; // mask out upper nibble
               switch(RcvBuffer[0])
               {
                  case 0x00: 
                     status = MI_NOTAUTHERR;
                     break;
                  case 0x0a:
                     status = MI_OK;
                     break;
                  case 0x05:
                  case 0x01:
                     status = MI_VALERR;
                     break;
                  default:
                     status = MI_CODEERR;
                     break;
               }
            }
        }        
     }

   return status;
}
*/
/****************************
 * 数据有效性检查           *
 ****************************/
bit ValueBlockValid(uchar *dts)
{
    register uchar i;

    for(i=4;i<12;i++)
    {
        if(dts[i-4] != ~dts[i])
            return FALSE;
    }
    for(i=13;i<16;i++)
    {
        if(dts[i-1] != ~dts[i])
            return FALSE;
    }
    return TRUE;
}

uchar M500ReadValue(uchar addr, uchar* value, uchar bakaddr)
{
    uchar Status;
    uchar TrueVal[16], BackVal[16];

    if(( Status = M500Read(addr, TrueVal) ) != MI_OK)
        return Status;  // 5

    if(addr != bakaddr)
    {
        if((Status = M500Read(bakaddr, BackVal)) != MI_OK)
            return Status;  // 5
    }

    if( ValueBlockValid(TrueVal))       //_dt is ok
    {
        memcpy(value, TrueVal, 4);
        // if(addr == bakaddr)
        return MI_OK;
        
        /*if(memcmp(TrueVal, BackVal, 12) == 0)
        {
            return MI_OK;
        }
        else
        {
            //if(ValueBlockValid(BackVal))  // valid but not same as true
            return MI_OK;
        }*/
    }
    else if((addr != bakaddr) && ValueBlockValid(BackVal))   // _backup is ok
    {
        memcpy(value, BackVal, 4);
        return MI_OK;   //2;
    }
    else
    {
        memset(value, 0, 4);
        return MI_VALERR;  //3;                   //_backup and _dt are all wrong
    }
}

uchar M500GetEpStatus(uchar addr, uchar bakaddr)
{
    uchar TrueVal[16], BackVal[16];
    uchar tmp, i;
    uchar epst = 0;

    if(M500Read(addr, TrueVal) != MI_OK)
        return 0;

    if(addr != bakaddr)
    {
        if(M500Read(bakaddr, BackVal) != MI_OK)
            return 0;
    }
        
    if(ValueBlockValid(TrueVal))
        epst |= 0x01;
    if(addr != bakaddr)
    {
        if(ValueBlockValid(BackVal))
            epst |= 0x02;
    }
    if(epst == 0x03)
    {
        int j;
        
        j = memcmp(TrueVal, BackVal, 4);
        if(j == 0)
            return epst;

        // compare which ep is bigger
        if(j > 0)
            epst |= 0x40;
        else
            epst |= 0x80;
        
        // swap ep buffer and compare
        for(i=0; i<2; i++)
        {
            tmp = TrueVal[i];
            TrueVal[i] = TrueVal[3-i];
            TrueVal[3-i] = tmp;
            
            tmp = BackVal[i];
            BackVal[i] = BackVal[3-i];
            BackVal[3-i] = tmp;
        }
        if(memcmp(TrueVal, BackVal, 4) > 0)         // true > back
            epst |= 0x10;
        else                                        // true < back
            epst |= 0x20;
    }
        
    return epst;
}

uchar M500WriteValue(uchar addr, uchar* value, uchar bakaddr)
{
    uchar Status;
    uchar TrueVal[16],BackVal[16];
    uchar i;

    for(i=0;i<4;i++)
    {
        BackVal[i] = value[i];
        BackVal[i+4] = ~value[i];
        BackVal[i+8] = value[i];
    }
    BackVal[12] = addr;  // +1 for common +2 for beijing yikatong
    BackVal[13] = ~addr;
    BackVal[14] = addr;
    BackVal[15] = ~addr;

    if(( Status = M500Write(addr, BackVal) )!=0)
        return Status;  //5;       // MI_CODEERR

    if(( Status = M500Read(addr, TrueVal) )!=0)
        return Status;  //5;

    if(memcmp(TrueVal, BackVal, 16) != 0)
        return MI_WRITEERR;  //5;
    
    if(addr != bakaddr)
    {
        #if 0
          if(M500Copy(addr, bakaddr) != MI_OK)
              return MI_EPBAKERR;
        #else
          return M500Copy(addr, bakaddr);
        #endif
    }
    
    return MI_OK;
    /*
    BackVal[12] = bakaddr;
    BackVal[13] = ~bakaddr;
    BackVal[14] = bakaddr;
    BackVal[15] = ~bakaddr;

    if(( Status=M500Write(bakaddr, BackVal) )!=0)
        return Status;  //5;

    if(( Status=M500Read(bakaddr, TrueVal) )!=0)
        return Status;  //5;

    return MI_OK;   //0;
    */