main.c

Mifare RC500 API Code in Keil

        while (!(MpIsrInfo->irqSource & waitFor||!(timecnt--)));
        WriteIO(RegInterruptEn,0x7F);         
        WriteIO(RegInterruptRq,0x7F);          
        SetBitMask(RegControl,0x04);          
        WriteIO(RegCommand,PCD_IDLE); 
		        
        if (!(MpIsrInfo->irqSource & waitFor))   
        {                               
            status = MI_ACCESSTIMEOUT;
        }
        else
        {
            status = MpIsrInfo->status;           
        }
        if (status == MI_OK)                    
        {
            if (tmpStatus = (ReadIO(RegErrorFlag) & 0x17))
            {
                if (tmpStatus & 0x01)
                {
                    info->collPos = ReadIO(RegCollPos);
                    status = MI_COLLERR;
                }
                else
                {
                    info->collPos = 0;
                    if (tmpStatus & 0x02)  
                    {
                        status = MI_PARITYERR;
                    }
                }
                if (tmpStatus & 0x04)   
                {
                    status = MI_FRAMINGERR;
                }
                if (tmpStatus & 0x10)   
                {
                    FlushFIFO();
                    status = MI_OVFLERR;
                }
 	            if (tmpStatus & 0x08) 
	            {
                    status = MI_CRCERR;
	            }	
                if (status == MI_OK)
                    status = MI_NY_IMPLEMENTED;
            }
            if (cmd == PCD_TRANSCEIVE)
            {
                lastBits = ReadIO(RegSecondaryStatus) & 0x07;
                if (lastBits)
                    info->nBitsReceived += (info->nBytesReceived-1) * 8 + lastBits;
                else
                    info->nBitsReceived += info->nBytesReceived * 8;
            }
        }
        else
        {
            info->collPos = 0x00;
        }
    }
    MpIsrInfo = 0;         
    MpIsrOut  = 0;
    return status;
}   

///////////////////////////////////////////////////////////////////////
// 置一个bit
///////////////////////////////////////////////////////////////////////
char SetBitMask(uchar reg,uchar mask)  
{
    char idata tmp = 0x00;

    tmp = ReadIO(reg);
    WriteIO(reg,tmp | mask);  // set bit mask
    return 0x00;
}

///////////////////////////////////////////////////////////////////////
// 清一个bit
///////////////////////////////////////////////////////////////////////
char ClearBitMask(uchar reg,uchar mask)  
{
    char idata tmp = 0x00;

    tmp = ReadIO(reg);
    WriteIO(reg,tmp & ~mask);  // clear bit mask
    return 0x00;
}

///////////////////////////////////////////////////////////////////////
//清除FIFO
///////////////////////////////////////////////////////////////////////
void FlushFIFO(void)
{  
    SetBitMask(RegControl,0x01);
}

///////////////////////////////////////////////////////////////////////
// Value format operations for Mifare Standard card ICs
// 块值操作:加.减
///////////////////////////////////////////////////////////////////////
char M500PiccValue(uchar dd_mode, 
                   uchar addr, 
                   uchar *value,
                   uchar trans_addr)
{
    char status = MI_OK;

    M500PcdSetTmo(1); 
    ResetInfo(MInfo);   
    SerBuffer[0] = dd_mode;      
    SerBuffer[1] = addr;
    MInfo.nBytesToSend = 2;
    status = M500PcdCmd(PCD_TRANSCEIVE,
                       SerBuffer,
                       &MInfo);

    if (status != MI_NOTAGERR)   
    {
        if (MInfo.nBitsReceived != 4)  
        {
            status = MI_BITCOUNTERR;
        }
        else                    
        {
            SerBuffer[0] &= 0x0f; 
            switch(SerBuffer[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(3);    
        ResetInfo(MInfo);   
        memcpy(SerBuffer,value,4);
        MInfo.nBytesToSend   = 4;
        status = M500PcdCmd(PCD_TRANSCEIVE,
                            SerBuffer,
                            &MInfo);
        
        if (status == MI_OK)    
        {
            if (MInfo.nBitsReceived != 4)   
            {
                status = MI_BITCOUNTERR;
            }
            else                    
            {
                SerBuffer[0] &= 0x0f; 
                switch(SerBuffer[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;  
        }
    }
    if (status == MI_OK)
    {
        ResetInfo(MInfo);   
        SerBuffer[0] = PICC_TRANSFER;      
        SerBuffer[1] = trans_addr;
        MInfo.nBytesToSend   = 2;
        status = M500PcdCmd(PCD_TRANSCEIVE,
                            SerBuffer,
                            &MInfo);
        if (status != MI_NOTAGERR)  
        {
            if (MInfo.nBitsReceived != 4)
            {
                status = MI_BITCOUNTERR;
            }
            else                   
            {
                SerBuffer[0] &= 0x0f; 
                switch(SerBuffer[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;
}

///////////////////////////////////////////////////////////////////////
//HALT the card
// 终止卡的操作
///////////////////////////////////////////////////////////////////////
char M500PiccHalt(void)
{
    char idata status = MI_CODEERR;

    // ************* Cmd Sequence ********************************** 
    ResetInfo(MInfo);   
    SerBuffer[0] = PICC_HALT ;      // Halt command code
    SerBuffer[1] = 0x00;            // dummy address
    MInfo.nBytesToSend = 2;
    status = M500PcdCmd(PCD_TRANSCEIVE,
                       SerBuffer,
                       &MInfo);   
    if (status)
    {
        // timeout error ==> no NAK received ==> OK
        if (status == MI_NOTAGERR || status == MI_ACCESSTIMEOUT)
        {
            status = MI_OK;
        }
    }
    //reset command register - no response from tag
    WriteIO(RegCommand,PCD_IDLE);
    return status; 
}

///////////////////////////////////////////////////////////////////////
// Reset the MF RC500 
///////////////////////////////////////////////////////////////////////
char M500PcdReset(void)
{
    char idata status = MI_OK;
    unsigned int idata timecnt=0;
    
    RC500RST = 0;  
    delay_1ms(25); 
    RC500RST = 1;  
    delay_50us(200); 
    RC500RST = 0;  
    delay_50us(50);
    timecnt=1000;
    while ((ReadIO(RegCommand) & 0x3F) && timecnt--);
    if(!timecnt)
    {
        status = MI_RESETERR;
    }
    if (status == MI_OK)
    {
        //WriteIO(RegPage,0x80);
        if (ReadIO(RegCommand) != 0x00)
        {                           
            status = MI_INTERFACEERR;
        }
    }
    return status;
}

///////////////////////////////////////////////////////////////////////
// Configures the MF RC500  配置RC500内部寄存器函数
///////////////////////////////////////////////////////////////////////
char M500PcdConfig(void)
{
    char idata status;

    if ((status = M500PcdReset()) == MI_OK)
    {
        WriteIO(RegClockQControl,0x00);
        WriteIO(RegClockQControl,0x40);
        delay_50us(2);  
        ClearBitMask(RegClockQControl,0x40);
        WriteIO(RegBitPhase,0xAD);      
        WriteIO(RegRxThreshold,0xFF);   
        WriteIO(RegRxControl2,0x01);
        WriteIO(RegFIFOLevel,0x1A);
        WriteIO(RegTimerControl,0x02);
        WriteIO(RegIRqPinConfig,0x03); 
        M500PcdRfReset(1);               
    }
    return status;
}

///////////////////////////////////////////////////////////////
// Key loading into the MF RC500's EEPROM
///////////////////////////////////////////////////////////////		            
char M500PcdLoadKeyE2(uchar key_type,
                       uchar sector,
                       uchar *uncoded_keys)
{
    signed char status = MI_OK;
    unsigned int e2addr = 0x80 + sector * 0x18;
    uchar coded_keys[12];

    if (key_type == PICC_AUTHENT1B)
    {
        e2addr += 12;           // key B offset
    }
    if ((status = M500HostCodeKey(uncoded_keys,coded_keys)) == MI_OK)
    {
        status = PcdWriteE2(e2addr,12,coded_keys);
    }
    return status;
}

///////////////////////////////////////////////////////////////////////
// Write the MF RC500's EEPROM
// 向RC500 EEPROM写数据
///////////////////////////////////////////////////////////////////////
char PcdWriteE2(unsigned int startaddr,
                uchar length,
                uchar* _data)
{
    char status = MI_OK;
    ResetInfo(MInfo);
    SerBuffer[0] = startaddr & 0xFF;
    SerBuffer[1] = (startaddr >> 8) & 0xFF;
    memcpy(SerBuffer + 2,_data,length);

    MInfo.nBytesToSend   = length + 2;
         
    status = M500PcdCmd(PCD_WRITEE2,
                       SerBuffer,
                       &MInfo); 
    return status;
}

///////////////////////////////////////////////////////////////////////
// Select Command defined in ISO14443(MIFARE)
///////////////////////////////////////////////////////////////////////
char M500PcdMfOutSelect(uchar type)
{
    WriteIO(RegMfOutSelect,type&0x7);
    return MI_OK;
}

///////////////////////////////////////////////////////////////////////
// Request Command defined in ISO14443(MIFARE)
// Request
// 寻卡
///////////////////////////////////////////////////////////////////////
char M500PiccCommonRequest(uchar req_code,uchar *atq)
{
    char idata status = MI_OK;
	
    M500PcdSetTmo(3);
    WriteIO(RegChannelRedundancy,0x03);
    ClearBitMask(RegControl,0x08);
    WriteIO(RegBitFraming,0x07);     
    SetBitMask(RegTxControl,0x03);     
    ResetInfo(MInfo);
    SerBuffer[0] = req_code;
    MInfo.nBytesToSend = 1;   
    
    status = M500PcdCmd(PCD_TRANSCEIVE,SerBuffer,&MInfo);
    if (status)     
    {
        *atq = 0;
    } 
    else 
    {
        if (MInfo.nBitsReceived != 16) 
        {
            *atq = 0;
            status = MI_BITCOUNTERR;
        } 
        else 
        {
            status = MI_OK;
            memcpy(atq,SerBuffer,2);
        }
    }
    return status; 
}

///////////////////////////////////////////////////////////////////
// Cascaded Anti-Collision Command defined in ISO14443(MIFARE)
// 防冲突 读卡的系列号 CardSnr
///////////////////////////////////////////////////////////////////
char M500PiccCascAnticoll (uchar bcnt,uchar *snr)       
{
    char idata status = MI_OK;
    char idata snr_in[4];    
    char idata nbytes = 0;
    char idata nbits = 0;
    char idata complete = 0;
    char idata i        = 0;
    char idata byteOffset = 0;
    uchar dummyShift1;
    uchar dummyShift2;
    
    M500PcdSetTmo(106);
    memcpy(snr_in,snr,4);   
   
    WriteIO(RegDecoderControl,0x28); 
    ClearBitMask(RegControl,0x08);   
    complete = 0;
    while (!complete && (status == MI_OK) )
    {
        ResetInfo(MInfo);           
        WriteIO(RegChannelRedundancy,0x03);
        nbits = bcnt % 8;
        if(nbits)
        {
            WriteIO(RegBitFraming,nbits << 4 | nbits);
            nbytes = bcnt / 8 + 1;   
            if (nbits == 7)
            {
                MInfo.cmd = PICC_ANTICOLL1;
                WriteIO(RegBitFraming,nbits); 
            }
        }  
        else
        {
            nbytes = bcnt / 8;
        }
        SerBuffer[0] = 0x93;
        SerBuffer[1] = 0x20 + ((bcnt/8) << 4) + nbits;
               
        for (i = 0; i < nbytes; i++)  
        {
            SerBuffer[i + 2] = snr_in[i];
        }
        MInfo.nBytesToSend   = 2 + nbytes;   
 
        status = M500PcdCmd(PCD_TRANSCEIVE,SerBuffer,&MInfo);
        if (nbits == 7)
        {
            dummyShift1 = 0x00;
            for (i = 0; i < MInfo.nBytesReceived; i++)
            {
                dummyShift2 = SerBuffer[i];
                SerBuffer[i] = (dummyShift1 >> (i+1)) | (SerBuffer[i] << (7-i));
                dummyShift1 = dummyShift2;
            }
            MInfo.nBitsReceived -= MInfo.nBytesReceived;       
            if ( MInfo.collPos ) MInfo.collPos += 7 - (MInfo.collPos + 6) / 9;
        }
        if ( status == MI_OK || status == MI_COLLERR)    
        {
            if ( MInfo.nBitsReceived != (40 - bcnt) )
            {
                status = MI_BITCOUNTERR; 
            } 
            else 
            {
                byteOffset = 0;
                if( nbits != 0 ) 
                {
                    snr_in[nbytes - 1] = snr_in[nbytes - 1] | SerBuffer[0];
                    byteOffset = 1;
                }

                for ( i =0; i < (4 - nbytes); i++)     
                {
                    snr_in[nbytes + i] = SerBuffer[i + byteOffset];
                }
  
                if (status != MI_COLLERR ) 
                {
                    dummyShift2 = snr_in[0] ^ snr_in[1] ^ snr_in[2] ^ snr_in[3];
                    dummyShift1 = SerBuffer[MInfo.nBytesReceived - 1];
                    if (dummyShift2 != dummyShift1)
                    {
                        status = MI_SERNRERR;
                    } 
                    else   
                    {
                        complete = 1;
                    }
                }
                else                 
                {
                    bcnt = bcnt + MInfo.collPos - nbits;
                    status = MI_OK;
                }
            }
        }
    }