m500auc.c

51+rc500阅读器源码程序

    return status;
}

///////////////////////////////////////////////////////////////////////
// Write the MF RC500's EEPROM  
//写MF RC500的EEPROM
///////////////////////////////////////////////////////////////////////
char PcdWriteE2(unsigned int startaddr,
                unsigned char length,
                unsigned char* _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) 
//ISO14443(MIFARE)定义的选择命令
///////////////////////////////////////////////////////////////////////
char M500PcdMfOutSelect(unsigned char type)
{
    WriteIO(RegMfOutSelect,type&0x7);
    return MI_OK;
}

///////////////////////////////////////////////////////////////////////
// Request Command defined in ISO14443(MIFARE)
// Request,Anticoll,Select,return CardType(2 bytes)+CardSerialNo(4 bytes)    
// 寻卡，防冲突，选择卡    返回卡类型（2 bytes）+ 卡系列号(4 bytes)
///////////////////////////////////////////////////////////////////////
char M500PiccCommonRequest(unsigned char req_code,unsigned char *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)
// 防冲突 读卡的系列号 MLastSelectedSnr
///////////////////////////////////////////////////////////////////
char M500PiccCascAnticoll (unsigned char bcnt,unsigned char *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;
    unsigned char dummyShift1;       
    unsigned char 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;
                }
            }
        }
    }
    if (status == MI_OK)
    {
        memcpy(snr,snr_in,4);
    }
    else
    {
        memcpy(snr,"0000",4);
    }
    ClearBitMask(RegDecoderControl,0x20); 
   
    return status;  
}

//////////////////////////////////////////////////////////////////
// Cascaded Select command defined in ISO14443(MIFARE)
// 选择卡 Select Card
//////////////////////////////////////////////////////////////////
char M500PiccCascSelect(unsigned char *snr,unsigned char *sak)
{
    char idata status = MI_OK; 
 
    M500PcdSetTmo(106);
	
    WriteIO(RegChannelRedundancy,0x0F); 
    ClearBitMask(RegControl,0x08);    
    ResetInfo(MInfo);   
    SerBuffer[0] = 0x93;
    SerBuffer[1] = 0x70;        
   
    memcpy(SerBuffer + 2,snr,4);
    SerBuffer[6] = SerBuffer[2] ^ SerBuffer[3] ^ SerBuffer[4] ^ SerBuffer[5];
    MInfo.nBytesToSend   = 7;
    status = M500PcdCmd(PCD_TRANSCEIVE,SerBuffer,&MInfo);

    *sak = 0;   
    if (status == MI_OK)  
    {
        if (MInfo.nBitsReceived != 8)   
        {
            status = MI_BITCOUNTERR;
        }
        else
        {
	        *sak = SerBuffer[0];
        }	
    }
    return status;
}

///////////////////////////////////////////////////////////////////////
// Key loading into the MF RC500's EEPROM
// 校验卡密码(E2)
///////////////////////////////////////////////////////////////////////
char M500PiccAuthE2( unsigned char auth_mode,unsigned char *snr,      
                     unsigned char keynr,unsigned char block)     
                                              
{
    char idata status = MI_OK;
    unsigned int e2addr = 0x80 + keynr * 0x18;
    //unsigned char *e2addrbuf = (unsigned char*)&e2addr;
    unsigned char *e2addrbuf;
    
    e2addrbuf = (unsigned char *)&e2addr;
    if (auth_mode == PICC_AUTHENT1B)
    {
        e2addr += 12; 
    }
    FlushFIFO();    
    ResetInfo(MInfo);

    memcpy(SerBuffer,e2addrbuf,2); 
    SerBuffer[2] = SerBuffer[0];      
    SerBuffer[0] = SerBuffer[1]; 
    SerBuffer[1] = SerBuffer[2];
    MInfo.nBytesToSend   = 2;
    if ((status=M500PcdCmd(PCD_LOADKEYE2,SerBuffer,&MInfo)) == MI_OK)
    {  
        status = M500PiccAuthState(auth_mode,snr,block);  //11.9
    }
    return status;
}                        

///////////////////////////////////////////////////////////////////////
// Authentication key coding
///////////////////////////////////////////////////////////////////////
char M500HostCodeKey(  unsigned char *uncoded, unsigned char *coded)   
{
    char idata status = MI_OK;
    unsigned char idata cnt = 0;
    unsigned char idata ln  = 0;     
    unsigned char idata hn  = 0;      
    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;
}

///////////////////////////////////////////////////////////////////
// Authentication with direct key loading from the uC
// 直接校验密码
//////////////////////////////////////////////////////////////////
char M500PiccAuthKey(  unsigned char auth_mode,
                       unsigned char *snr,       
                       unsigned char *keys,      
                       unsigned char block)      
{
    char idata status = MI_OK;
    //PcdSetTmo(2);
    FlushFIFO();   
    ResetInfo(MInfo);
    memcpy(SerBuffer,keys,12);                 
    MInfo.nBytesToSend = 12;
    if ((status=M500PcdCmd(PCD_LOADKEY,SerBuffer,&MInfo)) == MI_OK)
    {      
        status = M500PiccAuthState(auth_mode,snr,block); 
    }
    return status;
}

///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
char M500PiccAuthState( unsigned char auth_mode,unsigned char *snr,unsigned char block)
{
    char idata status = MI_OK;
    unsigned char idata i = 0;
   
    status = ReadIO(RegErrorFlag);                                     
    if (status != MI_OK)
    {
        if (status & 0x40)           
        {
            status = MI_KEYERR;
        }
        else
        {
            status = MI_AUTHERR;    
        }
    }
    else
    {
        SerBuffer[0] = auth_mode;    

        SerBuffer[1] = block;  
        memcpy(SerBuffer + 2,snr,4); 
        ResetInfo(MInfo);
        MInfo.nBytesToSend = 6;
        if ((status = M500PcdCmd(PCD_AUTHENT1,SerBuffer,&MInfo)) == MI_OK)
        {
            if (ReadIO(RegSecondaryStatus) & 0x07) 
            {
                status = MI_BITCOUNTERR;
            }
            else
            {
                ResetInfo(MInfo);
                MInfo.nBytesToSend = 0;
                if ((status = M500PcdCmd(PCD_AUTHENT2,
                                     SerBuffer,
                                     &MInfo)) == MI_OK) 
                {
                    if ( ReadIO(RegControl) & 0x08 ) 
                    {
                        status = MI_OK;
                    }
                    else
                    {
                        status = MI_AUTHERR;
                    }
                }
            }
        }
    }
    return status;
}

////////////////////////////////////////////////////////////////
// Read the mifare card
// 读卡
////////////////////////////////////////////////////////////////
char M500PiccRead(unsigned char addr,unsigned char *_data)
{
    char idata status = MI_OK;
    char idata tmp    = 0;

    FlushFIFO();    

    M500PcdSetTmo(3);  
    WriteIO(RegChannelRedundancy,0x0F);
    ResetInfo(MInfo);   
    SerBuffer[0] = PICC_READ;   
    SerBuffer[1] = addr;
    MInfo.nBytesToSend   = 2;   
    status = M500PcdCmd(PCD_TRANSCEIVE,SerBuffer,&MInfo);

    if (status != MI_OK)
    {
        if (status != MI_NOTAGERR ) 
        {
            if (MInfo.nBitsReceived == 4)  
            {
                SerBuffer[0] &= 0x0f;  
                if ((SerBuffer[0] & 0x0a) == 0)
                {
                    status = MI_NOTAUTHERR;
                }
                else
                {
                    status = MI_CODEERR;
                }
            }
        }
        memcpy(_data,"0000000000000000",16); 
    }
    else                // Response Processing
    {
        if (MInfo.nBytesReceived != 16)
        {
            status = MI_BYTECOUNTERR;
            memcpy(_data,"0000000000000000",16);
        }
        else
        {
            memcpy(_data,SerBuffer,16);
        }
    }
    M500PcdSetTmo(1);             
    return status; 
}

////////////////////////////////////////////////////////////////
// Write the mifare card
// 写卡  下载密码
////////////////////////////////////////////////////////////////
char M500PiccWrite( unsigned char addr,unsigned char *_data)
{
    char idata status = MI_OK;
    
    ResetInfo(MInfo);   
    SerBuffer[0] = PICC_WRITE; 
    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; 
            if ((SerBuffer[0] & 0x0a) == 0)
            {
                status = MI_NOTAUTHERR;                   
            }
            else
            {
                if (SerBuffer[0] == 0x0a)
                {
                    status = MI_OK;
                }
                else 
                {
                    status = MI_CODEERR;
                }
            }
        }
    }

    if ( status == MI_OK)
    {
        M500PcdSetTmo(3);    

        ResetInfo(MInfo);   
        memcpy(SerBuffer,_data,16);
        MInfo.nBytesToSend   = 16;
        status = M500PcdCmd(PCD_TRANSCEIVE,SerBuffer,&MInfo);
        
        if (status & 0x80)   
        {
            status = MI_NOTAGERR;
        }
        else
        {
            if (MInfo.nBitsReceived != 4) 
            {
                status = MI_BITCOUNTERR;
            }
            else                  
            {
                SerBuffer[0] &= 0x0f; 
                if ((SerBuffer[0] & 0x0a) == 0)
                {
                    status = MI_WRITEERR;
                }
                else
                {
                    if (SerBuffer[0] == 0x0a)
                    {
                        status = MI_OK;
                    }
                    else 
                    {
                        status = MI_CODEERR;
                    }
                }     
            }
        }        
        M500PcdSetTmo(1);  
    }
    return status;
}

///////////////////////////////////////////////////////////////////////
// Reset Rf Card
///////////////////////////////////////////////////////////////////////
char M500PcdRfReset(unsigned char ms)
{
    char idata status = MI_OK;
	
    if(ms)
    {
        ClearBitMask(RegTxControl,0x03); 
        delay_1ms(2);                
        SetBitMask(RegTxControl,0x03); 
    }