trf7960.c

TRF7960源代码

		return -2;
	}

	memset(TRF7963_FIFO, 0x00, sizeof(TRF7963_FIFO));
	cTmp = GetFIFOData(TRF7963_FIFO, 0);

	if (cTmp)
	{
		memcpy(cTagNO+iTagitNUM*8, TRF7963_FIFO+2, cTmp-2);
		iTagitNUM=(cTmp-2)/8;
	}

	return iTagitNUM;

}




int ResetTag(char *cTagNO)
{
	char cBuf[50];
	char length, size;
	char TRF7963_FIFO[50], cTmp1, cTmp,i;

	size = 2;
	length = 7;

	cBuf[0] = 0x8f;	// Reset FIFO command
	cBuf[1] = 0x91;	// send with CRC
	cBuf[2] = 0x3d;	// write continuous from register 1D
	cBuf[3] = (char)size>>8;// Data for register 1D,	data length
	cBuf[4] = (char)size<<4;// Data for register 1E
	cBuf[5] = 0x02;	// ISO15693 flag with Option flag set
	cBuf[6] = 0x26;	// 

	//memcpy(cBuf+7, cTagNO, 8);

	TRF7963_puts(cBuf, length, 5, 0);
	if(WaitforSignal(0x80, 1000))
	{
		return -1;
	}


	return 0;

}

int SelectTag(char *cTagNO)
{
	char cBuf[130], i,j, length, cTmp, cTmp1, TRF7963_FIFO[50];
	char size=10;	

	memset(cBuf, 0x00, sizeof(cBuf));	
	IRQ_Status = 0;


	cBuf[0] = 0x8f;	// Reset FIFO command
	cBuf[1] = 0x91;	// send with CRC
	cBuf[2] = 0x3d;	// write continuous from register 1D
	cBuf[3] = (char)size>>8;// Data for register 1D,	data length
	cBuf[4] = (char)size<<4;// Data for register 1E
	cBuf[5] = 0x22;	// ISO15693 flag with Option flag set
	cBuf[6] = 0x25;	// Read Multiple Blocks command code
	
	memcpy(cBuf+7, cTagNO, 8);
//	cBuf[7] = 0xAE;	// UID
//	cBuf[8] = 0x04;
//	cBuf[9] = 0xA3;
//	cBuf[10] = 0x01;
//	cBuf[11] = 0x00;
//	cBuf[12] = 0x00;
//	cBuf[13] = 0x07;
//	cBuf[14] = 0xE0;
	
	length = 15;

	TRF7963_puts(cBuf, length, 5, 0);

	if(WaitforSignal(0x80, 1000))
	{
		return -1;
	}

	return 0;			
}
int StayTag(char *cTagNO)
{
	char cBuf[130], i,j, length, cTmp, cTmp1, TRF7963_FIFO[50];
	char size;	

	memset(cBuf, 0x00, sizeof(cBuf));	
	IRQ_Status = 0;

	size = 10;
	cTmp = 0x22;
	length = 15;


	cBuf[0] = 0x8f;	// Reset FIFO command
	cBuf[1] = 0x91;	// send with CRC
	cBuf[2] = 0x3d;	// write continuous from register 1D
	cBuf[3] = (char)size>>8;// Data for register 1D,	data length
	cBuf[4] = (char)size<<4;// Data for register 1E
	cBuf[5] = cTmp;//0x22;	// ISO15693 flag with Option flag set
	cBuf[6] = 0x02;	// keep stay
	
	memcpy(cBuf+7, cTagNO, 8);	

	TRF7963_puts(cBuf, length, 5, 0);

	if(WaitforSignal(0x80, 1000))
	{
		return -1;
	}

	return 0;			
}


int WriteTagit(char *cTagNO, char *cData, char cMode)
{
	char cBuf[30], length, size, cFlag, cCmd;
	char TRF7963_FIFO[50];
	char bTagNO=0, bRxInt=0, bTxInt=1;
	
	memset(cBuf, 0x00, sizeof(cBuf));
	memset(TRF7963_FIFO, 0x00, sizeof(TRF7963_FIFO));
	switch(cMode)
	{
	case 0x16:// SELECT tag
		size = 10;
		cFlag = 0x22;
		length = 15;
		cCmd = 0x25;
		bTagNO =1;
		break;
	case 0x18:// reset all tag
		size = 2;
		cFlag = 0x02;
		length = 7;
		cCmd = 0x26;
		break;
	case 0x1A:// stay tag
		size = 10;
		cFlag = 0x22;
		length = 15;
		cCmd = 0x02;
		bTagNO =1;
		break;
	case 0x28:// get tagit systeme info
		size = 2;
		cFlag = 0x02;
		length = 7;
		cCmd = 0x2B;
		bTagNO =0;
		bRxInt = 1;
		break;
	case 0x26:// write AFI
		size = 3;
		cFlag = 0x42;
		length = 8;
		cCmd = 0x27;
		bTagNO =0;
		bRxInt = 1;
		bTxInt = 1;
		cBuf[7] = cData[0];	// data
		break;
	case 0x2A:// write DSFID
		size = 3;
		cFlag = 0x42;
		length = 8;
		cCmd = 0x29;
		bTagNO =0;
		bRxInt = 1;
		bTxInt = 1;
		cBuf[7] = cData[0];	// data
		break;


	default:
		return -1;
	}

	cBuf[0] = 0x8f;	// Reset FIFO command
	cBuf[1] = 0x91;	// send with CRC
	cBuf[2] = 0x3d;	// write continuous from register 1D
	cBuf[3] = (char)size>>8;// Data for register 1D,	data length
	cBuf[4] = (char)size<<4;// Data for register 1E
	cBuf[5] = cFlag;//// ISO15693 flag with Option flag set
	cBuf[6] = cCmd;	// command

	if (bTagNO)
	{
		memcpy(cBuf+7, cTagNO, 8);
	}

	TRF7963_puts(cBuf, length, 5, 0);


	if (bTxInt)
	{
		if(WaitforSignal(0x80, 1000))
		{
			return -2;
		}
	}
	
	if (bRxInt)
	{
		if (WaitforSignal(0x40, 1000))
		{
			return -3;
		}

		length = GetFIFOData(TRF7963_FIFO, 0);
		TRF7963_Init();
		memcpy(cData, TRF7963_FIFO, length);
		return length;
	}
	else
	{
		return 0;
	}
}

// return <0, err
// return >0, data length
//int ReadBlock(char cFlag, char cBlock, char *cData)
//{
//	char cBuf[130], i,j, length, cTmp, cTmp1, TRF7963_FIFO[50];
//	char size=3;
//
//	memset(cBuf, 0x00, sizeof(cBuf));	
//
//	
//	cBuf[0] = 0x8f;	// Reset FIFO command
//	cBuf[1] = 0x91;	// send with CRC
//	cBuf[2] = 0x3d;	// write continuous from register 1D
//	cBuf[3] = (char)size>>8;// Data for register 1D,	data length
//	cBuf[4] = (char)size<<4;// Data for register 1E
//	cBuf[5] = cFlag;//0x02;// // ISO15693 flag with Option flag set
//	cBuf[6] = 0x20;	// Read single Blocks command code
//	
//	/*cBuf[7] = 0x6D;
//	cBuf[8] = 0x84;
//	cBuf[9] = 0xED;
//	cBuf[10] = 0x11;
//	cBuf[11] = 0x00;
//	cBuf[12] = 0x00;
//	cBuf[13] = 0x07;
//	cBuf[14] = 0xE0;*/
//	/*cBuf[7] = 0xAE;	// UID
//	cBuf[8] = 0x04;
//	cBuf[9] = 0xA3;
//	cBuf[10] = 0x01;
//	cBuf[11] = 0x00;
//	cBuf[12] = 0x00;
//	cBuf[13] = 0x07;
//	cBuf[14] = 0xE0;*/
//	
//	cBuf[7] = cBlock;		// First Block Number
//	
//	length = 8;
//
//	TRF7963_puts(cBuf, length, 5, 0);
//	if(WaitforSignal(0x80, 1000))
//	{			
//		return -1;
//	}
//	
//	if(WaitforSignal(0x40, 1000))
//	{				
//		return -2;
//	}
//		
//	cTmp = GetFIFOData(TRF7963_FIFO);
//	if (TRF7963_FIFO[0])
//	{
//		return -3;
//	}
//	memcpy(cData, TRF7963_FIFO+1, 4);
////	for (cTmp1=1; cTmp1<cTmp; cTmp1++)
////	{
////		cData[cTmp1-1] = TRF7963_FIFO[cTmp1];
////	}
//	
//	TRF7963_Init();
//	return 4;
//			
//}



// return <0, err
// return >0, data length
int ReadMulBlock(char cFlag, char *cData, char cBlock, char cBlockNO)
{
	char cBuf[20];
	char size=4, length;
	int nLength, i;

	memset(cBuf, 0x00, sizeof(cBuf));	

	
	cBuf[0] = 0x8f;	// Reset FIFO command
	cBuf[1] = 0x91;	// send with CRC
	cBuf[2] = 0x3d;	// write continuous from register 1D
	cBuf[3] = (char)size>>8;// Data for register 1D,	data length
	cBuf[4] = (char)size<<4;// Data for register 1E
	cBuf[5] = cFlag;//0x12;//0x12;	// ISO15693 flag with Option flag set
	cBuf[6] = 0x23;	// Read mul Blocks command code
	

	cBuf[7] = cBlock;		// First Block Number
	cBuf[8] = cBlockNO;		// Block Number
	
	length = 9;

	TRF7963_puts(cBuf, length, 5, 0);
	if(WaitforSignal(0x80, 200))
	{
		return -1;
	}
	
	if(WaitforSignal(0x40, 200))
	{				
		return -2;
 	}
		
	nLength = GetFIFOData(cData, 0);
	//UART_nputs(cData+1, nLength-1);


	if (nLength>(cBlockNO*4+1))
	{
		nLength= cBlockNO*4+1;
	}
	
	for (i=0; i < nLength-1; i++)
	{
		cData[i] = cData[i+1];
	}
	
	// TRF7963_Init();
	return nLength-1;			

}
//
//
//// return <0, err
//// return >=0, OK
//int WriteBlock(char cFlag, char cBlock, char *cData)
//{
//	char cBuf[130], length, cTmp, cTmp1;
//	char TRF7963_FIFO[50];
//	char size = 7;//15;//	
//
//	memset(cBuf, 0x00, sizeof(cBuf));
//
//	
//	cBuf[0] = 0x8f;	// Reset FIFO command
//	cBuf[1] = 0x91;	// send with CRC
//	cBuf[2] = 0x3d;	// write continuous from register 1D
//	cBuf[3] = (char)size>>8;// Data for register 1D,	data length
//	cBuf[4] = (char)size<<4;// Data for register 1E
//	cBuf[5] = cFlag;//0x52;//0x52;// // ISO15693 flag with Option flag set
//	cBuf[6] = 0x21;	// write single Blocks command code
//	
//	/*cBuf[7] = 0x6D;	// UID
//	cBuf[8] = 0x84;
//	cBuf[9] = 0xED;
//	cBuf[10] = 0x11;
//	cBuf[11] = 0x00;
//	cBuf[12] = 0x00;
//	cBuf[13] = 0x07;
//	cBuf[14] = 0xE0;*/
//	/*cBuf[7] = 0xAE;	// UID
//	cBuf[8] = 0x04;
//	cBuf[9] = 0xA3;
//	cBuf[10] = 0x01;
//	cBuf[11] = 0x00;
//	cBuf[12] = 0x00;
//	cBuf[13] = 0x07;
//	cBuf[14] = 0xE0;
//	
//	cBuf[15] =cBlock;//0x02;//		// Block Number
//	
//	// Data, 32bits, 4bytes	
//	cBuf[16] = cData[0];//0x88;//		
//	cBuf[17] = cData[1];//0x11;//
//	cBuf[18] = cData[2];//0x66;//
//	cBuf[19] = cData[3];//0x89;//
//
//	length = 20;*/
//	
//	cBuf[7] = cBlock;//0x01;//		// First Block Number
//
//	// Data, 32bits, 4bytes
//	cBuf[8] = cData[0];//0x88;//		
//	cBuf[9] = cData[1];//0x77;//
//	cBuf[10] = cData[2];//0x66;//
//	cBuf[11] = cData[3];//0x55;//
//	
//	length = 12;
//
//	if( TRF7963_puts(cBuf, length, 5, 1)<0 )
//	{
//		UART_puts("Send Err\r\n");
//	}
//	// TX
////	if(WaitforSignal(0x80, 1000))
////	{UART_puts("return -1\r\n");
////		//return -1;
////	}
////	TRF7963_cmd(0x0F);
////	TRF7963_cmd(0x14);
//	
//	
//	// waitfor End of RX interrupt
//	if ( WaitforSignal(0x40, 1000))
//	{	
//		return -2;
//	}
//	memset(TRF7963_FIFO, 0x00, sizeof(TRF7963_FIFO));
//	cTmp = GetFIFOData(TRF7963_FIFO);
////	if(cTmp)
////	{
////		memset(cBuf, 0x00, sizeof(cBuf));
////		sprintf(cBuf, "\r\nFIFO data length %d   \r\n", cTmp);
////		UART_puts(cBuf);
////	
////		memset(cBuf, 0x00, sizeof(cBuf));
////		for (cTmp1=0; cTmp1<cTmp; cTmp1++)
////		{
////			sprintf(cBuf+strlen(cBuf), "%02x ", TRF7963_FIFO[cTmp1]);
////			if (strlen(cBuf) > sizeof(cBuf)-4)
////			{
////				break;
////			}
////		}
////		UART_puts(cBuf);UART_puts("\r\n");
////	}
//	TRF7963_Init();
//	if (TRF7963_FIFO[0] || TRF7963_FIFO[1])
//	{
//		return -3;
//	}
//
//	
//	return 0;
//
//}

// return <0, err
// return >=0, data length
int RdWrBlock(char cFlag, char *cData, char cMode)
{
	char cBuf[30], length, size, cCmd;
	char TRF7963_FIFO[100];
	char nDateLength, bReadMode=0;
	
	memset(cBuf, 0x00, sizeof(cBuf));
	memset(TRF7963_FIFO, 0x00, sizeof(TRF7963_FIFO));
	IRQ_Status = 0;
	
	switch(cMode)
	{
	case 0x1C:// read block
		size = 3;
		cCmd = 0x20;
		length = 8;
		nDateLength = 4;
		bReadMode=1;
		break;
	case 0x1E:// read mul-block
		size = 4;
		cCmd = 0x23;
		length = 9;
		nDateLength = 4*cData[1];
		bReadMode=1;
		break;
	case 0x20:// write block
		size = 7;
		cCmd = 0x21;
		length = 12;
		nDateLength = 0;
		break;
//	case 0x30:// write mul-block
//		size = 4+cData[1]*4;
//		cCmd = 0x24;
//		length = size+5;
//		nDateLength = 0;
//		break;
	default:
		return -1;
	}

	cBuf[0] = 0x8f;	// Reset FIFO command
	cBuf[1] = 0x91;	// send with CRC
	cBuf[2] = 0x3d;	// write continuous from register 1D
	cBuf[3] = (char)size>>8;// Data for register 1D,	data length
	cBuf[4] = (char)size<<4;// Data for register 1E
	cBuf[5] = cFlag;//// ISO15693 flag with Option flag set
	cBuf[6] = cCmd;	// command

	memcpy(cBuf+7, cData, size-2);

	TRF7963_puts(cBuf, length, 5, !bReadMode);

	if (bReadMode)
	{		
		if(WaitforSignal(0x80, 100))
		{
			return -2;
		}
	}

	if(WaitforSignal(0x40, 100))
	{		
		return -3;
	}

	length = GetFIFOData(TRF7963_FIFO, 0);
	
	if (TRF7963_FIFO[0])
	{
		return -4;
	}
	else if (nDateLength)
	{
		memcpy(cData, TRF7963_FIFO+1, nDateLength);
		//UART_nputs(TRF7963_FIFO, length);
	}

	return nDateLength;
}



int WriteMulBlock(char cFlag, char *cData, int nDataLength, char nBlockPosition )
{
	char cBuf[50], length, cTmp, cTmp1;
	char size = 7;

	memset(cBuf, 0x00, sizeof(cBuf));

	
	cBuf[0] = 0x8f;	// Reset FIFO command
	cBuf[1] = 0x91;	// send with CRC
	cBuf[2] = 0x3d;	// write continuous from register 1D
	cBuf[3] = (char)size>>8;// Data for register 1D,	data length
	cBuf[4] = (char)size<<4;// Data for register 1E
	cBuf[5] = cFlag;//0x42; // ISO15693 flag with Option flag set
	cBuf[6] = 0x21;	// write 2 Blocks command code

	
	length = 12;
	cTmp1 = (nDataLength+3)/4; // MAX Block NO.
	
	for (cTmp=0; cTmp<cTmp1; cTmp++)
	{
		cBuf[7] = cTmp+nBlockPosition;
		memcpy(cBuf+8, cData+cTmp*4, 4);
		TRF7963_puts(cBuf, length, 5, 1);
//		DelayMs(15);
		TRF7963_cmd(0x03);// TRF7963 soft init
		TRF7963_putc(0, 0x21);	// TX Enbale
	}	

	return 0;
}




void IRQ_Init(void)
{
	// INT1 的上升沿产生异步中断请求
	EICRA |= (1<<ISC11)|(1<<ISC10);
	// 外部中断请求1 使能
	//EIMSK |= (1<<INT1);
	
	// 使能全局中断
	sei();

	IRQ_Status = 0;
}


void IRQ_StartStop(char bIRQ)
{
	if(bIRQ)
	{
		// 外部中断请求1 使能
		EIMSK |= (1<<INT1);
	}
	else
	{
		// 外部中断请求1
		EIMSK &= ~(1<<INT1);
	}
	
	IRQ_Status = 0;
}


SIGNAL(SIG_INTERRUPT1) // INT1中断服务程序
{	
	IRQ_Status = TRF7963_getc(0x0C);// IRQ register
}