rc500.c

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

            }
        }
//     }
    return ret_status;
}
//
// char Mf500HostCodeKey(  unsigned char *uncoded, // 6 bytes key value uncoded
//                         unsigned char *coded)   // 12 bytes key value coded
// {
//     unsigned char cnt = 0;
//     unsigned char an = 0;
//     unsigned char ln = 0;     // low nibble
//     unsigned char hn = 0;     // high nibble
//
//     for (cnt = 0; cnt < 6; cnt++)
//     {
//         ln = uncoded[cnt] & 0x0F;
//         an = uncoded[cnt];
//         hn = an >> 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)
// {
//     char ret_status = MI_OK;
//
//     Mf500HostCodeKey(keys,MSndBuffer);
//
//     PcdSetTmo(106);
//     FlushFIFO();    // empty FIFO
//     ResetInfo(MInfo);
//     MInfo.nBytesToSend = 12;
//     ret_status=PcdSingleResponseCmd(0x19);
//     if (ret_status == MI_OK)
//     {
//         ret_status = Mf500PiccAuthState(auth_mode,snr,block);
//     }
//     return ret_status;
// }
//
// char Mf500PiccRead(unsigned char addr,unsigned char *data1)             //卡块读
// {
//     unsigned char i,temp;
//     signed char ret_status = MI_OK;
//
//     FlushFIFO();    // empty FIFO
//     PcdSetTmo(4);
//     WriteRC(RegChannelRedundancy,0xF); //新改,原为 0xF, RxCRC, TxCRC, Parity enable
//     ResetInfo(MInfo);
//     MSndBuffer[0] = PICC_READ;       // read command code
//     MSndBuffer[1] = addr;
//     MInfo.nBytesToSend = 2;
//     ret_status = PcdSingleResponseCmd(0x1e);
//     if (ret_status != MI_OK)
//     {
//         if (ret_status != MI_NOTAGERR ) // no timeout occured
//         {
//             if (MInfo.nBitsReceived == 4)   // NACK
//             {
//                 MRcvBuffer[0] &= 0x0f;   // mask out upper nibble
//                 if ((MRcvBuffer[0] & 0x0a) == 0)
//                 {
//                     ret_status = MI_NOTAUTHERR;
//                 }
//                 else
//                 {
//                     ret_status = MI_CODEERR;
//                 }
//             }
//         }
//         for(i=0;i<16;i++)
//             data1[i]=0;
//             //memcpy(data,"0000000000000000",16); // in case of an error initialise
//     }
//     else    // Response Processing
//         {
//         temp=MInfo.nBytesReceived;
//         if (MInfo.nBytesReceived != 16)
//             {
//             ret_status = MI_BYTECOUNTERR;
//             for(i=0;i<16;i++)
//                 data1[i]=0;
//             // memcpy(data,"0000000000000000",16);
//             }
//         else
//             {
//             memcpy(data1,MRcvBuffer,16);
//             }
//         }
//     PcdSetTmo(1);
//     return ret_status;
// }
//
// char Mf500PiccWrite( unsigned char addr,unsigned char *data1)   //卡块写
// {
//     signed char ret_status = MI_OK;
// //     unsigned char TempBuf[16];
//
//     FlushFIFO();
//
//     PcdSetTmo(4);   // long timeout
//
//     WriteRC(RegChannelRedundancy,0x0F); // RxCRC, TxCRC, Parity enable
//     ResetInfo(MInfo);
//     MSndBuffer[0] = PICC_WRITE;      // Write command code
//     MSndBuffer[1] = addr;
//     MInfo.nBytesToSend = 2;
//     ret_status = PcdSingleResponseCmd(0x1e);
//
//     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;
//                 default:
//                 ret_status = MI_CODEERR;
//                 break;
//                 }
//             }
//         }
//
//     if ( ret_status == MI_OK)
//         {
//         FlushFIFO();
//         PcdSetTmo(3);
//         ResetInfo(MInfo);
//         memcpy(MSndBuffer,data1,16);
//         MInfo.nBytesToSend = 16;
//         ret_status = PcdSingleResponseCmd(0x1e);
//         if (ret_status != MI_NOTAGERR)      // 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_WRITEERR;
//                             break;
//                     case 0x0a:
//                             ret_status = MI_OK;
//                             break;
//                     default:
//                             ret_status = MI_CODEERR;
//                             break;
//                     }
//                 }
//             }
//         PcdSetTmo(1);
//         }
//
// //     if (ret_status == MI_OK)
// //         {
// //         ret_status = Mf500PiccRead(addr,TempBuf);
// //         if (ret_status == MI_OK)
// //             {
// //             if (memcmp(data1,TempBuf,16) == 0)
// //                 ret_status = MI_OK;
// //             else
// //                 ret_status = MI_RW_ERROR;
// //             }
// //         }
//
//     return ret_status;
// }
//
// char Mf500PiccHalt(void)
// {
//     signed char ret_status = MI_CODEERR;
//
//     PcdSetTmo(106);
//     ResetInfo(MInfo);
//     MSndBuffer[0] = PICC_HALT ;      // Halt command code
//     MSndBuffer[1] = 0x00;    // dummy address
//     MInfo.nBytesToSend = 2;
//     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 Mf500PcdSetDefaultAttrib(void)
// {
//     char ret_status = MI_OK;
//     return ret_status;
// }
//
char PcdRfReset(unsigned char ms)
{
    char ret_status = MI_OK;
    unsigned int i;


    ClearBitMask(RegTxControl,0x03);    // Tx2RF-En, Tx1RF-En disablen
    if (ms > 0)
        {
        for(i=0;i<1050;i++);
        SetBitMask(RegTxControl,0x03);  // Tx2RF-En, Tx1RF-En enable
        }

/*
    WriteRC(RegTxControl,0x50);    // Tx2RF-En, Tx1RF-En disablen
    if (ms > 0)
        {
        for(i=0;i<1050;i++);
        WriteRC(RegTxControl,0x5b);  // Tx2RF-En, Tx1RF-En enable
        }
*/
    return ret_status;
}
//
void PcdSetTmo(unsigned int tmoLength)
{
    switch(tmoLength)
    {
        case 1:                 // short timeout (1,0 ms)
            WriteRC(RegTimerClock,0x07); // TAutoRestart=0,TPrescale=128
            WriteRC(RegTimerReload,0x6a);// TReloadVal = 'h6a =106(dec)
            break;
        case 2:                 // medium timeout (1,5 ms)
            WriteRC(RegTimerClock,0x07); // TAutoRestart=0,TPrescale=128
            WriteRC(RegTimerReload,0xa0);// TReloadVal = 'ha0 =160(dec)
            break;
        case 3:                 // long timeout (6 ms)
            WriteRC(RegTimerClock,0x09); // TAutoRestart=0,TPrescale=4*128
            WriteRC(RegTimerReload,0xa0);// TReloadVal = 'ha0 =160(dec)
            break;
        case 4:                 // long timeout (9.6 ms)
            WriteRC(RegTimerClock,0x09); // TAutoRestart=0,TPrescale=4*128
            WriteRC(RegTimerReload,0xff);// TReloadVal = 'ff =255(dec)
            break;
        default:                        // short timeout (1,0 ms)
            WriteRC(RegTimerClock,0x07); // TAutoRestart=0,TPrescale=128
            WriteRC(RegTimerReload,tmoLength);// TReloadVal = tmoLength
            break;
    }
}
//
void SetBitMask(unsigned char reg,unsigned char mask) // ok
{
    unsigned char tmp = 0x0;
    tmp = ReadRC(reg);
    WriteRC(reg,tmp | mask);        // set bit mask
}
//
void ClearBitMask(unsigned char reg,unsigned char mask) // ok
{
    unsigned char tmp = 0x0;
    tmp = ReadRC(reg);
    WriteRC(reg,tmp & ~mask);       // clear bit mask
}
//
void FlushFIFO(void)                    //ok
{
    SetBitMask(RegControl,0x01);
}
//
// char Mf500PiccAuthState(unsigned char auth_mode,unsigned char *snr,unsigned char block)
// {
//     char ret_status = MI_OK;
//
//     ret_status = ReadRC(RegErrorFlag);  // read error flags of the previous
//     if (ret_status != MI_OK)
//         {
//         if (ret_status & 0x40)              // key error flag set
//             ret_status = MI_KEYERR;
//         else
//             ret_status = MI_AUTHERR;    // generic authentication error
//         }
//     else
//         {
//         PcdSetTmo(4);
//         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;
//         ret_status = PcdSingleResponseCmd(0x0C);
//         if (ret_status == MI_OK)
//             {
//             if (ReadRC(RegSecondaryStatus) & 0x07) // RxLastBits mu?leer sein
//                 {
//                 ret_status = MI_BITCOUNTERR;
//                 }
//             else
//                 {
//                 ResetInfo(MInfo);
//                 MInfo.nBytesToSend = 0;
//                 ret_status = PcdSingleResponseCmd(0x14);
//                 if (ret_status == MI_OK)
//                     {
//                     if ( ReadRC(RegControl) & 0x08 ) // Crypto1 activated
//                         {
//                         ret_status = MI_OK;
//                         }
//                     else
//                         {
//                         ret_status = MI_AUTHERR;
//                         }
//                     }
//                 }
//             }
//         }
//     return ret_status;
// }
//
char PcdSingleResponseCmd(unsigned char cmd)    //ok
{
    char ret_status = MI_OK;
    unsigned char tmpStatus ;
    unsigned char lastBits;
    unsigned char irqEn = 0x0;
    unsigned char waitFor=0x0;
    unsigned int count01,count02;

    WriteRC(RegInterruptEn,0x3F); // disable all interrupts
    WriteRC(RegInterruptRq,0x7F); // reset interrupt requests
    WriteRC(RegCommand,0x00); // terminate probably running command
    FlushFIFO();            // flush FIFO buffer
    MpIsrInfo = &MInfo;
    MpIsrOut = MSndBuffer;
    MpIsrIn = MRcvBuffer;

    MInfo.irqSource = 0x0; // reset interrupt flags
    switch(cmd)
        {
        case 0x00:              //Idle
            irqEn = 0x00;
            waitFor = 0x00;
            break;
        case 0x01:              //WriteE2, 写 FIFO 数据到 E2PROM 命令
            irqEn = 0x11;       //TxIEN,LoAlertIEN
            waitFor = 0x10;
            break;
        case 0x03:              //ReadE2, 读 E2PROM 数据到 FIFO 命令
            irqEn = 0x07;       //IdleIEN, HiAlertIEN, LoAlertIEN
            waitFor = 0x04;
            break;
        case 0x07:              //LoadConfig, 读 E2PROM 数据到初始化 RC500 寄存器
        case 0x0B:              //LoadKeyE2, 从 E2PROM 中读密码数据到密码缓冲区
        case 0x0C:              //Authent1, 执行第一加密处理
            irqEn = 0x05;       //IdleIEN, LoAlertIEN
            waitFor = 0x04;
            break;
        case 0x12:              //CalcCRC, CRC 计算
            irqEn = 0x11;       //TxIEN,LoAlertIEN
            waitFor = 0x10;
            break;
        case 0x14:              //Authent2, 执行第二加密处理
            irqEn = 0x04;       //IdleIEN
            waitFor = 0x04;
            break;
        case 0x16:              //Reiceiv, 接收
            MInfo.nBitsReceived = -(ReadRC(RegBitFraming) >> 4);
            irqEn = 0x06;       //IdleIEN, HiAlertIEN
            waitFor = 0x04;
            break;
        case 0x19:              //LoadKey, 从 FIFO 中读数据进密码缓冲区
            irqEn = 0x05;       //IdleIEN, LoAlertIEN
            waitFor = 0x04;
            break;
        case 0x1A:              //Transmit, 发送
            irqEn = 0x05;       //IdleIEN, LoAlertIEN
            waitFor = 0x04;
            break;
        case 0x1E:              //Transceive, 收发命令
            MInfo.nBitsReceived = -(ReadRC(RegBitFraming) >> 4);
            irqEn = 0x3D;       //TimerIEN, TxIEN, RxIEN, IdleIEN, LoAlertIEN
            waitFor = 0x04;
            break;
        default:
            ret_status = MI_UNKNOWN_COMMAND;
        }
    if (ret_status == MI_OK)
        {
        irqEn |= 0x20;                  // always enable timout irq
        waitFor |= 0x20;                // always wait for timeout
        count01=Timecount;              //start_timeout(2);             // initialise and start guard timer for reader
        count02=20;
        WriteRC(RegInterruptEn,irqEn | 0x80);   //necessary interrupts are enabled
        WriteRC(RegCommand,cmd);                //start command

        while (!(MpIsrInfo->irqSource & waitFor))
            {
            ISR_RC500();
            if (count02 == 0)
                break;
            count01--;
            if (count01==0)
                {
                count01=Timecount;
                count02--;
                }
            };              // wait for cmd completion or timeout

        WriteRC(RegInterruptEn,0x3F);           // disable all interrupts
        WriteRC(RegInterruptRq,0x7F);           // clear all interrupt requests
        SetBitMask(RegControl,0x04);            // stop timer now

        WriteRC(RegCommand,0x00);               // reset command register
        //if (!(MpIsrInfo->irqSource & waitFor))        // reader has not terminated
        if (count02==0)
            {