main.c

51控制RC500读写程序源代码

    }
    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(uchar *snr,uchar *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( uchar auth_mode,uchar *snr,
                     uchar keynr,uchar block)

{
    char idata status = MI_OK;
    unsigned int e2addr = 0x80 + keynr * 0x18;
    uchar *e2addrbuf;

    e2addrbuf = (uchar *)&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);
    }
    return status;
}

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

///////////////////////////////////////////////////////////////////////
//校验状态
///////////////////////////////////////////////////////////////////////
char M500PiccAuthState( uchar auth_mode,uchar *snr,uchar block)
{
    char idata status = MI_OK;
    uchar 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(uchar addr,uchar *_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( uchar addr,uchar *_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(uchar ms)
{
    char idata status = MI_OK;

    if(ms)
    {
        ClearBitMask(RegTxControl,0x03);
        delay_1ms(2);
        SetBitMask(RegTxControl,0x03);
    }
    else
    {
        ClearBitMask(RegTxControl,0x03);
    }
    return status;
}

#pragma noaregs

///////////////////////////////////////////////////////////////////////
// Delay 50us
///////////////////////////////////////////////////////////////////////
void delay_50us(uchar _50us)
{
  RCAP2LH = RCAP2_50us;
  T2LH    = RCAP2_50us;
  ET2 = 0; 	// Disable timer2 interrupt
  T2CON = 0x04;	// 16-bit auto-reload, clear TF2, start timer

  while (_50us--)
  {
	while (!TF2);
	TF2 = FALSE;
  }

  TR2 = FALSE;

}

///////////////////////////////////////////////////////////////////////
// Delay 1ms
///////////////////////////////////////////////////////////////////////
void delay_1ms(uchar _1ms)
{
  RCAP2LH = RCAP2_1ms;
  T2LH    = RCAP2_1ms;
  ET2 = 0; 	// Disable timer2 interrupt
  T2CON = 0x04;	// 16-bit auto-reload, clear TF2, start timer

  while (_1ms--)
  {
	while (!TF2);
	TF2 = FALSE;
  }
  TR2 = FALSE;
}

///////////////////////////////////////////////////////////////////////
// Delay 10ms
///////////////////////////////////////////////////////////////////////
void delay_10ms(uint _10ms)
{
  RCAP2LH = RCAP2_10ms;
  T2LH    = RCAP2_10ms;
  ET2 = 0; 	// Disable timer2 interrupt
  T2CON = 0x04;	// 16-bit auto-reload, clear TF2, start timer

  while (_10ms--)
  {
	while (!TF2)
	{
	  if (bCmd)
	  {
		TR2 = FALSE;
		TF2 = FALSE;
		return;
	  }
	}
	TF2 = FALSE;
  }
  TR2 = FALSE;

}

///////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////
void RC500ISR (void) interrupt 0 using 1
{
    static uchar idata irqBits;
    static uchar idata irqMask;
    static uchar idata nbytes;
    static uchar idata cnt;

    IE0 = 0;
    WriteRawIO(0,0x80);
    if (MpIsrInfo && MpIsrOut)
    {
        while( ReadRawIO(RegPrimaryStatus) & 0x08)
        {
            irqMask = ReadRawIO(RegInterruptEn);
            irqBits = ReadRawIO(RegInterruptRq) & irqMask;
            MpIsrInfo->irqSource |= irqBits;
            if (irqBits & 0x01)
            {
                nbytes = 64 - ReadRawIO(RegFIFOLength);
                if ((MpIsrInfo->nBytesToSend - MpIsrInfo->nBytesSent) <= nbytes)
                {
                    nbytes = MpIsrInfo->nBytesToSend - MpIsrInfo->nBytesSent;
                    WriteRawIO(RegInterruptEn,0x01);
                }
                for ( cnt = 0;cnt < nbytes;cnt++)
                {
                    WriteRawIO(RegFIFOData,MpIsrOut[MpIsrInfo->nBytesSent]);
                    MpIsrInfo->nBytesSent++;
                }
                WriteRawIO(RegInterruptRq,0x01);
            }
            if (irqBits & 0x10)
            {
                WriteRawIO(RegInterruptRq,0x10);
                WriteRawIO(RegInterruptEn,0x82);
                if (MpIsrInfo->cmd == PICC_ANTICOLL1)
	            {
                    WriteIO(RegChannelRedundancy,0x02);
                    WriteRawIO(0,0x80);
	            }
            }
            if (irqBits & 0x0E)
            {
                nbytes = ReadRawIO(RegFIFOLength);
                for ( cnt = 0; cnt < nbytes; cnt++)
                {
                    MpIsrOut[MpIsrInfo->nBytesReceived] = ReadRawIO(RegFIFOData);
                    MpIsrInfo->nBytesReceived++;
                }
                WriteRawIO(RegInterruptRq,0x0A & irqBits);
            }
            if (irqBits & 0x04)
            {
                WriteRawIO(RegInterruptEn,0x20);
                WriteRawIO(RegInterruptRq,0x20);
                irqBits &= ~0x20;
                MpIsrInfo->irqSource &= ~0x20;
                WriteRawIO(RegInterruptRq,0x04);
            }
            if (irqBits & 0x20)
            {
                WriteRawIO(RegInterruptRq,0x20);
                MpIsrInfo->status = MI_NOTAGERR;
            }
        }
    }
}



///////////////////////////////////////////////////////////////////////
// MF RC500 Config
///////////////////////////////////////////////////////////////////////
char MfConfig(void)
{
	char status=MI_OK;

	M500PcdConfig();
	M500PcdMfOutSelect(2);
	return status;
}
/////////////////////////////////////////////////////////////////////////
//Beep(n);n为鸣叫的声音次数
/////////////////////////////////////////////////////////////////////////
void beep(uchar n)
{
	uchar i;
	for(i=0;i<n;i++)
	{
	    SPEAKER=0;          //产生周期为1s的方波
	    delay_10ms(50);     //delay 0.5s
		SPEAKER=1;
		delay_10ms(50);
		SPEAKER=0;
	}
}
/////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////
//LED闪烁次数
////////////////////////////////////////////////////////////////////////
void splash(uchar n)
{
	uchar i;
	for(i=0;i<n;i++)
	{
		CARD_LED=OFF;
		delay_10ms(50);     //delay 0.5s
		CARD_LED=ON;
		delay_10ms(50);
		CARD_LED=OFF;
		}
}


/*******************************END OF FILE****************************/