rc500.c

用PICC开发的RC500的完整C源程序。单片机用PIC16f73。

            ret_status = MI_ACCESSTIMEOUT;
            }
        else
            {
            ret_status = MpIsrInfo->status;         // set status
            }
        if (ret_status == MI_OK)                    // no timeout error occured
            {
            if ((tmpStatus = (ReadRC(RegErrorFlag) & 0x17))) // error occured
                {
                if (tmpStatus & 0x01)   // collision detected
                    {
                    MInfo.collPos = ReadRC(RegCollPos); // read collision position
                    ret_status = MI_COLLERR;
                    }
                else
                    {
                    MInfo.collPos = 0;
                    if (tmpStatus & 0x02)   // parity error
                        {
                        ret_status = MI_PARITYERR;
                        }
                    }
                if (tmpStatus & 0x04)   // framing error
                    {
                    ret_status = MI_FRAMINGERR;
                    }
                if (tmpStatus & 0x10)   // FIFO overflow
                    {
                    FlushFIFO();
                    ret_status = MI_OVFLERR;
                    }
                if (tmpStatus & 0x08) // CRC error
                    {
                    ret_status = MI_CRCERR;
                    }
                        // if (ret_status == MI_OK)
                        // ret_status = MI_NY_IMPLEMENTED;
                }

            if (cmd == 0x1E)
                {
                lastBits = ReadRC(RegSecondaryStatus) & 0x07;
                if (lastBits)
                    {
                    MInfo.nBitsReceived += (MInfo.nBytesReceived-1) * 8 + lastBits;
                    }
                else
                    MInfo.nBitsReceived += MInfo.nBytesReceived * 8;
                }
            }
        else
            {
            MInfo.collPos = 0x00;
            }
        }
    MpIsrInfo = 0;  // reset interface variables for ISR
    MpIsrOut = 0;
    MpIsrIn = 0;

    return ret_status;
}

// char M500PiccValue(unsigned char dd_mode,unsigned char addr,unsigned long value)
// //char M500PiccValue( unsigned char iTimeOut_mode,unsigned char aiTimeOutr,unsigned long value )
// {
//     //-----------------------------------------------//
//     //- exp: Inc or Dec buffer value                -//
//     //- par: iTimeOut_mode: <in> Inc: 0x51          -//
//     //-                     Dec: 0x50               -//
//     //-     aiTimeOutr: <in>block number            -//
//     //-     value: <in>value to be handled          -//
//     //- rtn: operation status                       -//
//     //-----------------------------------------------//
//     signed char ret_status = MI_OK;
//
//     PcdSetTmo(1);   // short timeout
//     // ************* Cmd Sequence **********************************
//     ResetInfo(MInfo);
//     MSndBuffer[0] = dd_mode; // Inc,Dec command code
//     MSndBuffer[1] = addr;
//     MInfo.nBytesToSend = 2;
//     ret_status = PcdSingleResponseCmd(0x1e);    // PCD_TRANSCEIVE;
//
//     if (ret_status != MI_NOTAGERR)      // no timeout error
//         {
//         if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
//             {
//             ret_status = MI_BITCOUNTERR;
//             }
//         else                    // 4 bit received
//             {
//             MRcvBuffer[0] &= 0x0f; // mask out upper nibble
//             switch(MRcvBuffer[0])
//                 {
//                 case 0x00:
//                     ret_status = MI_NOTAUTHERR;
//                     break;
//                 case 0x0a:
//                     ret_status = MI_OK;
//                     break;
//                 case 0x01:
//                     ret_status = MI_VALERR;
//                     break;
//                 default:
//                     ret_status = MI_CODEERR;
//                     break;
//                 }
//             }
//         }
//
//     if ( ret_status == MI_OK)
//         {
//         PcdSetTmo(3);   // long timeout
//
//         ResetInfo(MInfo);
//         MSndBuffer[0] = value ;
//         MSndBuffer[1] = value >> 8;
//         MSndBuffer[2] = value >> 16;
//         MSndBuffer[3] = value >> 24;
//
//         //memcpy(MSndBuffer,value,4);
//
//         MInfo.nBytesToSend = 4;
//         ret_status = PcdSingleResponseCmd(0x1e);    // rr modified
//
//         if (ret_status == MI_OK)    // no timeout occured
//             {
//             if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
//                 {
//                 ret_status = MI_BITCOUNTERR;
//                 }
//             else                    // 4 bit received
//                 {
//                 MRcvBuffer[0] &= 0x0f; // mask out upper nibble
//
//                 switch(MRcvBuffer[0])
//                     {
//                     case 0x00:
//                         ret_status = MI_NOTAUTHERR;
//                         break;
//                     case 0x01:
//                         ret_status = MI_VALERR;
//                         break;
//                     default:
//                         ret_status = MI_CODEERR;
//                         break;
//                     }
//                 }
//             }
//         else if (ret_status == MI_NOTAGERR )
//             ret_status = MI_OK;     // no response after 4 byte value -
//         }
//
//     return ret_status;
// }
//
// char M500PiccTransfer(unsigned char trans_addr)
// //char M500PiccTransfer( unsigned char trans_aiTimeOutr )
// {
//     //------------------------------------------------//
//     //- exp: transfer buffer value to card          -//
//     //- par: trans_aiTimeOutr: <in>block to be handled      -//
//     //- rtn: operation status                       -//
//     //------------------------------------------------//
//     signed char ret_status = MI_OK;
//     PcdSetTmo(4);   // LONG timeout
//     if ( ret_status == MI_OK)
//     {
//         ResetInfo(MInfo);
//
//         MSndBuffer[0] = PICC_TRANSFER;   // transfer command code
//         MSndBuffer[1] = trans_addr;
//         MInfo.nBytesToSend = 2;
//         ret_status = PcdSingleResponseCmd(0x1e);    // PCD_TRANSCEIVE,
//
//         if (ret_status != MI_NOTAGERR)      // timeout occured
//         {
//             if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
//             {
//                 ret_status = MI_BITCOUNTERR;
//             }
//             else                    // 4 bit received
//             {
//                 MRcvBuffer[0] &= 0x0f; // mask out upper nibble
//                 switch(MRcvBuffer[0])
//                 {
//                     case 0x00:
//                         ret_status = MI_NOTAUTHERR;
//                         break;
//                     case 0x0a:
//                         ret_status = MI_OK;
//                         break;
//                     case 0x01:
//                         ret_status = MI_VALERR;
//                         break;
//                     default:
//                         ret_status = MI_CODEERR;
//                         break;
//                 }
//             }
//         }
//     }
//     return ret_status;
// }
//
// char M500PiccRestore(unsigned char addr)
// //char M500Piccrestore(unsigned char aiTimeOutr )
// {
//     //-----------------------------------------------//
//     //- exp: restore card value to buffer           -//
//     //- par: aiTimeOutr: <in>block to be handled    -//
//     //- rtn: operation status                       -//
//     //-----------------------------------------------//
//     signed char ret_status = MI_OK;
//     PcdSetTmo(3);   // short timeout
//     ResetInfo(MInfo);
//     MInfo.nBytesToSend = 2;
//
//     MSndBuffer[0] = PICC_RESTORE;    // PICC_RESTORE command code
//     MSndBuffer[1] = addr;
//
//     ret_status = PcdSingleResponseCmd(0x1e);    //      PCD_TRANSCEIVE);
//
//     if (ret_status != MI_NOTAGERR)      // no timeout error
//     {
//         if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
//         {
//             ret_status = MI_BITCOUNTERR;
//         }
//         else                    // 4 bit received
//         {
//             MRcvBuffer[0] &= 0x0f; // mask out upper nibble
//             switch(MRcvBuffer[0])
//             {
//                 case 0x00:
//                     ret_status = MI_NOTAUTHERR;
//                     break;
//                 case 0x0a:
//                     ret_status = MI_OK;
//                     break;
//                 case 0x01:
//                     ret_status = MI_VALERR;
//                     break;
//                 default:
//                     ret_status = MI_CODEERR;
//                     break;
//             }//end switch
//         } // end else
//     } // end if1
//
//     if(ret_status!=MI_OK)
//         return ret_status;
//
//     if ( ret_status == MI_OK)
//     {
//         PcdSetTmo(3);   // long timeout
//         ResetInfo(MInfo);
//         memcpy(MSndBuffer,0x00,4);
//         MInfo.nBytesToSend = 4;
//         ret_status = PcdSingleResponseCmd(0x1e);    // rr modified
//
//         if (ret_status == MI_OK)    // no timeout occured
//         {
//             if (MInfo.nBitsReceived != 4)   // 4 bits are necessary
//             {
//                 ret_status = MI_BITCOUNTERR;
//             }
//             else                    // 4 bit received
//             {
//                 MRcvBuffer[0] &= 0x0f; // mask out upper nibble
//                 switch(MRcvBuffer[0])
//                 {
//                     case 0x00:
//                         ret_status = MI_NOTAUTHERR;
//                         break;
//                     case 0x0a:
//                         ret_status = MI_OK;
//                         break;
//                     case 0x01:
//                         ret_status = MI_VALERR;
//                         break;
//                     default:
//                         ret_status = MI_CODEERR;
//                         break;
//                 }//end switch
//             }
//         }       // END IF OK
//         else if (ret_status==MI_NOTAGERR)
//         {
//             ret_status = MI_OK;
//         }
//     }
//     return ret_status;
// }
// /*
// char ISO14443A_Halt(void)
// {
//     char ret_status = MI_CODEERR;
//
//     PcdSetTmo(106);
//
//     ResetInfo(MInfo);
//
//     MInfo.nBytesToSend = 2;
//
//     Buf.iso14443A_buf.MSndBuffer[0] = PICC_HALT; // Halt command code
//     Buf.iso14443A_buf.MSndBuffer[1] = 0x00; // dummy aiTimeOutress
//
//     ret_status = PcdSingleResponseCmd( 0x1e );
//     if( ret_status )
//         {
//         if( ret_status == MI_NOTAGERR || ret_status == MI_ACCESSTIMEOUT )
//             {
//             ret_status = MI_OK;
//             }
//         }
//     WriteRC( RegCommand, 0x00 );
//     return ret_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
// {
//    char            status = MI_OK;
//
//    status = Mf500PiccAuthE2(  key_type,
//                               Snr_RC500,
//                               key_addr,
//                               block);
//    return status;
// }
//
// char Mf500PiccAuthE2(unsigned char auth_mode,   // PICC_AUTHENT1A or PICC_AUTHENT1B
//                      unsigned char *snr,        // 4 bytes card serial number
//                      unsigned char key_sector,  // 0 <= key_sector <= 15
//                      unsigned char block)      //  0 <= block <= 256
// {
//    char status = MI_OK;
//    // eeprom address calculation
//    // 0x80 ... offset
//    // key_sector ... sector
//    // 0x18 ... 2 * 12 = 24 = 0x18
//    unsigned short e2addr = 0x80 + key_sector * 0x18;
//    unsigned char *e2addrbuf = (unsigned char*)&e2addr;
//
//    PcdSetTmo(106);
//    if (auth_mode == PICC_AUTHENT1B)
//       e2addr += 12; // key B offset
//    FlushFIFO();    // empty FIFO
//    ResetInfo(MInfo);
//
//    memcpy(MSndBuffer,e2addrbuf,2); // write low and high byte of address
//    MInfo.nBytesToSend   = 2;
//     // write load command
//    if ((status=PcdSingleResponseCmd(PCD_LOADKEYE2)) == MI_OK)
//    {
//       // execute authentication
//       status = Mf500PiccAuthState(auth_mode,snr,block);
//    }
//    return status;
// }
//
// ///////////////////////////////////////////////////////////////////////
// //          R E A D   S N R   O F   R E A D E R   I C
// ///////////////////////////////////////////////////////////////////////
char RC500GetSnr(unsigned char* snr)
{
   signed char status;

   status = PcdReadE2(0x08,0x04,snr);
   return status;
}
//
// ///////////////////////////////////////////////////////////////////////
// //          E E P R O M   R E A D
// ///////////////////////////////////////////////////////////////////////
char PcdReadE2(unsigned short startaddr,
               unsigned char length,
               unsigned char* data)
{
   char status = MI_OK;

     // ************* Cmd Sequence **********************************
     ResetInfo(MInfo);
     MSndBuffer[0] = startaddr & 0xFF;
     MSndBuffer[1] = (startaddr >> 8) & 0xFF;
     MSndBuffer[2] = length;
     MInfo.nBytesToSend   = 3;
     status = PcdSingleResponseCmd(PCD_READE2);
    if (status == MI_OK)
    {
       memcpy(data,MRcvBuffer,length);
    }
    else   // Response Processing
    {
       data[0] = 0;
    }
    return status ;
}
//
//
// ///////////////////////////////////////////////////////////////////////
// //          E E P R O M   W R I T E
// ///////////////////////////////////////////////////////////////////////
char PcdWriteE2(  unsigned short startaddr,
                      unsigned char length,
                      unsigned char* data)
{
   char status = MI_OK;

     // ************* Cmd Sequence **********************************
   ResetInfo(MInfo);
   MSndBuffer[0] = startaddr & 0xFF;
   MSndBuffer[1] = (startaddr >> 8) & 0xFF;
   memcpy(MSndBuffer + 2,data,length);

   MInfo.nBytesToSend   = length + 2;

   status = PcdSingleResponseCmd(PCD_WRITEE2); // write e2
   return status;
}