mffc632.c

很强的射频卡reader源代码

/****************************************************************************
*                                                                           
* File:         MFRC632.C(for ChinaVision Internal use only)                                
*                                                                           
* Created:      2004.03.22                                                    
*                                                                           
* Editor        
*                                                                           
* Compiler:     KEIL C51 V7.00                                              
*                                                                           
* Description:  SST89E564RD-Firmware for RC500 Serial Reader               
*                                                                           
*****************************************************************************
*                                                                           
* Version | Date     |  PCB  | Description                                          
* --------+----------+-------+------------------------------------------------ 
* V100    | 2/03/04  |       | Initial version,TypeA and TypeB 
* V110    | 15/01/03 |       | reset pin control by FIFO out pins.Adding two new command
*         |          |       | (READ EEPROM C6 and WRITE EEPROM C7).
*         |          |       | delay using a fixed time,not "for loop".
*         |          |       | New routine funtions is generated in main funtion.
* V120    | 20/01/03 |       | Modify reader.h,adding rc500cmd.h          
* V130    | 08/02/03 |       | Adding some funtions about SAM
* V       | 22/03/04 |       | Adding some funtions about iso15693                                          
****************************************************************************/
#include <absacc.h>
#include "string.h"
#include "stdio.h"
#include "intrins.h"
#include "reader.h"
#include "632MfErrNo.h"
#include "Rc632CV.h"
#include "Rc632reg.h"

///////////////////////////////////////////////////////////////////////
//      M I F A R E   M O D U L E   C O N F I G U R A T I O N
///////////////////////////////////////////////////////////////////////
//bit Firstcollionflag;
bit collionflag;
extern unsigned char Tiflag;
///////////////////////////////////////////////////////////////////////
//		Register Parameters for	Standard Mode ISO 15693
///////////////////////////////////////////////////////////////////////
void init_StdMode_15693(void)
{
		Tiflag =3;

		RegModConductance = 0x02; // must be measured for 15% Modulation Index	
		RegRxControl1 = 0x8B;
		RegRxThreshold = 0x66;
		RegFIFOLevel = 0x3e;
		RegTimerControl = 0x02; // TStopRxEnd=0,TStopRxBeg=1,
					       // TStartTxEnd=1,TStartTxBeg=0
		RegTimerReload = 0x00;
		RegInterruptRq = 0x3F;
		RegCoderControl = 0x2E;
		RegDecoderControl = 0x34;
		RegRxWait = 0X08;   // 256/fc => 0x01 = 18.88 us 0x08 = 151us
		RegChannelRedundancy = 0x2C;
		RegCRCPresetLSB = 0xFF;
		RegCRCPresetMSB = 0xFF;
		RegTimerClock = 0x0B;
		RegBitPhase = 0xCD;
		RegModWidthSOF = 0x3F;
		RegModWidth = 0x3F;       // Modulation width: 9.44us
//		RegMfOutSelect = 0x02;
//		RegRxControl2 = RegRxControl2 | 0X03;
}

/////////////////////////////////////////////////////////////////////////
char ISO15693_Transceive (unsigned char *cmd, 
                          unsigned char cmdlen,
						  unsigned char *rcv)

                     
{	
	unsigned char idata TimerReload, status, err,ts,col;
	bit option_flag=0;

	status = TI_OK;	

	if (Tiflag != 3) 			init_StdMode_15693();	


	switch (cmd[1])
	{
		case ISO15693_STAY_QUIET:
			TimerReload = 0x96;  
			break;

		case ISO15693_SELECT:
			TimerReload = 0x96;  
		break;

		case ISO15693_RESET_TO_READY:
			TimerReload = 0x96;  
			break;

		case ISO15693_LOCK_AFI:
			TimerReload = 0x96;  
			if (cmd[0] & 0x40)	option_flag = 1;
			break;

		case ISO15693_LOCK_DSFID:
			TimerReload = 0x96;  
			if (cmd[0] & 0x40)	option_flag = 1;
			break;

		case ISO15693_LOCK_BLOCK:
			TimerReload = 0x96;  
			if (cmd[0] & 0x40)	option_flag = 1;
			break;

		case ISO15693_WRITE_SINGLE_BLOCK:
			TimerReload = 0x96;  
			if (cmd[0] & 0x40)	option_flag = 1;
			break;

		case ISO15693_WRITE_MULTIPLE_BLOCKS:
			TimerReload = 0x96;  
			if (cmd[0] & 0x40)	option_flag = 1;
			break;

		case ISO15693_WRITE_AFI:
			TimerReload = 0x96;  
			if (cmd[0] & 0x40)	option_flag = 1;
			break;

		case ISO15693_WRITE_DSFID:
			TimerReload = 0x96;  
			if (cmd[0] & 0x40)	option_flag = 1;
			break;

		case ISO15693_READ_SINGLE_BLOCK:
			TimerReload = 0x96;  
			break;

		case ISO15693_INVENTORY:
			TimerReload = 0x96;  
			break;

		case ISO15693_GET_SYSTEM_INFO:
			TimerReload = 0x96;  
			break;

		case ISO15693_GET_MULTIPLE_BLOCK_SECURITY:
			TimerReload = (0x04+(cmd[cmdlen-1]+0x01))*0x02 + 30;     
			break;	
												
		case ISO15693_READ_MULTIPLE_BLOCKS:
			TimerReload = (0x04+0x04*(cmd[cmdlen-1]+0x01))*0x02 + 30;    
			break;
		default:
			TimerReload = 0x96;  
			break;
	}

	RegControl=RegControl | 0x01;  //Clear the rc500 buffer

	for(ts = 0; ts < cmdlen; ts++)
	RegFIFOData = cmd[ts];         //input the data to the rc500 buffer 

	RegChannelRedundancy = 0x2C;   //crc register  rxcrcen ,txcrcen,16bit,crc3309
	RegTimerReload = TimerReload;  //refesh the value of the time register
	RegTimerControl = 0x06;		   //time control that    timestart  tx end and timestop rx first  
	RegCommand=0x00; 
	RegInterruptRq = 0x3F;         //clear the flag of the Reginterruptrq register.
     
	RegCommand = PCD_TRANSCEIVE;
	MRC500_CNT=0x00;

	while( (!(RegInterruptRq & 0x10)) && (MRC500_CNT < 30000) ) {MRC500_CNT += 1;}  
	
	if( MRC500_CNT > 20000 )  
	{
		RegCommand=0x00; 
		status= TI_ACCESSTIMEOUT;
		return status;
	}

	if(option_flag)
	{
		delay_1ms(20);
		RegCommand=0x00; 
		RegInterruptRq = 0x3F;
		RegControl = RegControl | 0x01;
	
		RegChannelRedundancy = RegChannelRedundancy &(~0x04); //crc disable
		RegTxControl = RegTxControl | 0x10; 	 //100 module
		RegCoderControl = RegCoderControl | 0x80; 	// one pusle
		RegCommand = PCD_TRANSCEIVE;
	
		MRC500_CNT=0x00;
		while( (!(RegInterruptRq & 0x10)) && (MRC500_CNT<30000) ) {MRC500_CNT+=1;}  
		
		if( MRC500_CNT > 20000 )  
		{
			RegCommand=0x00; 
			status= TI_ACCESSTIMEOUT;
			return status;
		}
	}

	MRC500_CNT=0x00;
	while ((!(RegInterruptRq & 0x28 ))&& (MRC500_CNT<30000))   {MRC500_CNT+=1;}
	if( MRC500_CNT > 20000 )  
	{
		RegCommand=0x00; 
		status= TI_ACCESSTIMEOUT;
		return status;
	}

	if (RegInterruptRq & 0x20)
	{
	   	status = I2_NO_TAG;
	}
	else 
	{
 		if(RegInterruptRq & 0x08)
		{			
			err = RegErrorFlag;
			if (err	& 0x08)
			{
				status = I2_CRCERR;
			}
			else if (err & 0x01)
			{
				status = I2_COLLERR;
				col =	RegCollPos;
			}
			else if (err & 0x04)
			{
				status = I2_FRAMINGERR;
			}
		}
	}

	if (status == TI_OK)
	{

//		Resplen = ts+1;
// 		RegTimerControl = 0x00;//2004,3,24
		rcv[0] =  RegFIFOLength;
		err = RegFIFOLength;
		for(ts=1;ts<err+1;ts++)		rcv[ts] = RegFIFOData;	     
	}
	else 
		rcv[0] =  0;

	if(option_flag)
	{
		RegCoderControl = RegCoderControl & (~0x80); 
		RegTxControl = RegTxControl & (~0x10); 	
	}
	return status;	
}
//------------------------------------------------------------------------------------------------------
//ISO15693_Inventory
//------------------------------------------------------------------------------------------------------
char ISO15693_Inventory (unsigned char flags,
						 unsigned char AFI, 
                         unsigned char masklengh, 
                         unsigned char *uid,
						 unsigned char *resp)
{
	unsigned char idata i, cnt, status;
	unsigned char idata txdatalength;
	unsigned char idata collionseat = 6;	
	unsigned char idata txbuffer[13];

	do
	{
		if(!collionflag)
		{
//			Firstcollionflag = 1;
			txbuffer[0] = flags | 0x06; 
			txbuffer[1] = ISO15693_INVENTORY;
			txdatalength= 2;
			if ( flags & 0x10 )
			{
	 			txbuffer[txdatalength] = AFI;		
				txdatalength++;
			}

			txbuffer[txdatalength] = masklengh;
			txdatalength++;
		
			if (masklengh%8)
			{
				cnt = masklengh/8 + 1;
			}
			else
				cnt = masklengh/8;
			
			if (cnt)
			{
				for(i=0;i<cnt;i++)
				{
					txbuffer[txdatalength] = *uid;
					txdatalength++;
					uid++;
				}
			}

		}
		else
		{	
			txbuffer[0] = flags | 0x06;
			txbuffer[1] = ISO15693_INVENTORY;
			txdatalength= 2;

			if ( flags & 0x10 )
			{
	 			txbuffer[txdatalength] = AFI;		
				txdatalength++;
			}

			cnt = u_ram.host.RxBuffer[collionseat]/15;
			masklengh = 4*cnt;
			txbuffer[txdatalength] = masklengh;
			txdatalength++;	
			
			for(i=0;i<cnt;i++)
			{
				txbuffer[txdatalength] = u_ram.host.RxBuffer[collionseat+3+i];
				txdatalength++;
			}
		}
				
		if (flags & 0x20)
		{
			status = ISO15693_Transceive(txbuffer, txdatalength, resp);	
//			status = TI_OK;
/*			if(!(status == TI_OK))		return status;
			else 
			{	status=I1_NO_TAG;	return 	status;}
*/	
//			if(!(status == TI_OK))		return status;



			if (status == TI_OK)		return status;
			//else if (status ==I2_COLLERR);
			else {status=I2_NO_TAG;return status;}
			



		
//			return status;
	//	set_idle();
		}
		else
		{		 
			status = ISO15693_Inventory_16(txbuffer, txdatalength, resp);

//			Firstcollionflag =0;
//			if(!(status == TI_OK))		return status;



			if (status == TI_OK)		return status;
			//else if (status ==I2_COLLERR)	;
			else {status=I2_NO_TAG; return status;}

/*			else {status==I2_NO_TAG;	return status;}
			
			if {



/*			else 
			{status=I1_NO_TAG;	return status;}*/


		
//			collionflag =0;

/*			else if((Host.RxBuffer[5] == 0) && (!(masklengh == 0)))
			{
				if(!(coltimes == 0))  
			 	{
					coltimes--;		
					collionseat += 13;
					collionflag = 1;
				}
			}					
			else if((!(Host.RxBuffer[5] == 0)) && (!(masklengh == 0)))
			{
				collionflag = 1;			
			}
			else if((Host.RxBuffer[5] == 0) && (masklengh == 0))
			{
				coltimes = 0;
				return(status);	
			}
*/
		}
	}