csu3_am335x/EVSE/Modularization/Module_RFID.c

/*
 * 	Module_RFID.c
 *
 *  Created on: 2019-10-24
 *  Update: 2020-10-19
 *  Author: Eason Yang
 *	Version: V0.03
 *
 * History 
 * 1. Added : Reyax code.
 *
 *
 *
 *
 *
 */

#include "Module_RFID.h"

//==================================
// PRINT OUT LOG FORMAT
//==================================
#define SystemLogMessage
#define DEBUG_INFO_1(format, args...) StoreLogMessage("[%s:%d][%s][Info] "format, __FILE__, __LINE__, __FUNCTION__, ##args)
#define DEBUG_WARN_1(format, args...) StoreLogMessage("[%s:%d][%s][Warn] "format, __FILE__, __LINE__, __FUNCTION__, ##args)
#define DEBUG_ERROR_1(format, args...) StoreLogMessage("[%s:%d][%s][Error] "format, __FILE__, __LINE__, __FUNCTION__, ##args)

//==================================
// SYSTEM CONSTANT
//==================================
#define Debug
#define ARRAY_SIZE(A)		(sizeof(A) / sizeof(A[0]))
#define PASS				1
#define FAIL				-1

//==================================
// RFID CMD CONSTANT
//==================================
unsigned int RFID_CMD_ISO1443A_REQUEST				= 0x20;
unsigned int RFID_CMD_ISO1443B_REQUEST				= 0x60;
unsigned int RFID_CMD_FELICA_POLLING_REQUEST		= 0x2F;
unsigned int RFID_CMD_HALT_14443A					= 0x28;
unsigned int RFID_CMD_BLOCK_READ					= 0x21;
unsigned int RFID_CMD_BLOCK_WRITE					= 0x22;
unsigned int RFID_CMD_BUZZER_SET					= 0x14;
unsigned int RFID_CMD_RF_OUTPUT_LEVEL_SET			= 0x02;
unsigned int RFID_CMD_DEFAULT_AUTO_DETECTING_CARD	= 0x1D;

//==================================
// RFID MODE CONSTANT
//==================================
unsigned char WUPA	= 0;
unsigned char REQA	= 1;
unsigned char AFI	= 0;

//==================================
// MIFARE CARD LENGTH
//==================================
unsigned int LENGTH_0	= 0;
unsigned int LENGTH_4	= 4;
unsigned int LENGTH_6	= 6;
unsigned int LENGTH_7	= 7;
unsigned int LENGTH_10	= 10;

//==================================
// RF output Level constant
//==================================
unsigned int RF_STRONGEST	= 0x00;
unsigned int RF_STRONGER	= 0x01;
unsigned int RF_WEAK		= 0x02;
unsigned int RF_WEAKEST		= 0x03;

//==================================
// Default of Automatic Detecting constant
//==================================
unsigned int TURN_OFF 			= 0x00;
unsigned int TURN_ON  			= 0X01;
unsigned int TURN_TEMPORARILY	= 0x11;

//==================================
// MIFARE SECTOR SPACE
//==================================
#define ROW					6
#define COLUMN				16

unsigned char sectorKeyA[COLUMN][ROW] = {	{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
	 	 	 	 	 	 	 	 	 	 };

unsigned char serialNumber[32];
unsigned int cardLength;

//==================================
// SystemLog message
//==================================
#ifdef SystemLogMessage
int StoreLogMessage(const char *fmt, ...)
{
	char Buf[4096 + 256];
	char buffer[4096];
	time_t CurrentTime;
	struct tm *tm;
	va_list args;

	va_start(args, fmt);
	int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
	va_end(args);

	memset(Buf, 0, sizeof(Buf));
	CurrentTime = time(NULL);
	tm = localtime(&CurrentTime);
	sprintf(Buf,
			"echo \"[%04d.%02d.%02d %02d:%02d:%02d] - %s\" >> /Storage/SystemLog/[%04d.%02d]RFID_SystemLog",
			tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour,
			tm->tm_min, tm->tm_sec, buffer, tm->tm_year + 1900, tm->tm_mon + 1);
	system(Buf);
	#ifdef Debug
	printf("[%04d.%02d.%02d %02d:%02d:%02d] - %s", tm->tm_year + 1900,
			tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
			buffer);
	#endif

	return rc;
}
#endif

//==========================================
// Module's command send/receive
//==========================================
int system_command(int uart, unsigned char* cmd,int length, unsigned char* rx)
{
	int len;

	//sleep(2); //required to make flush work, for some reason
	tcflush(uart,TCIOFLUSH);
	if(write(uart, cmd, length) >= 0)
	{
		usleep(100000);
		len = read(uart, rx, 256);
	}
	else
	{
		DEBUG_ERROR_1("system command %s response fail.\n", cmd);
	}

	return len;
}

//==========================================
// Module's AT command send/receive (REYAX)
//==========================================
int at_command(int uart, unsigned char* cmd,int length, unsigned char* rx)
{
	int len;
	
	//sleep(2); //required to make flush work, for some reason
	tcflush(uart,TCIOFLUSH);
	if(write(uart, cmd, length) >= ARRAY_SIZE(cmd))
	{
		usleep(100000);
		len = read(uart, rx, 512);
	}
	else
	{
		DEBUG_ERROR_1("AT command %s response fail.\n", cmd);
	}

	return len;
}

//==========================================
// Calculation checksum function
//==========================================
char ClaCheckSum(unsigned char *buffer, int len)
{
	int idx;
	char chksum = 0;

	for(idx = 0 ; idx < len-1 ; idx++)
	{
		chksum ^= *(buffer+idx);
	}

	return chksum;
}

bool getRequestCardSN(int Fd, int moduleType, RFID* rfid)
{
	bool isSuccess = false;

	if(ISO14443A_REQUEST_SN(Fd,moduleType,serialNumber) == true)
	{
		rfid->cardType = ISO14443A;

		if(cardLength == LENGTH_4)
		{
			rfid->snType = RFID_SN_TYPE_4BYTE;
			memcpy(rfid->currentCard, &serialNumber, 32);
		}
		else if(cardLength == LENGTH_7)
		{
			rfid->snType = RFID_SN_TYPE_7BYTE;
			memcpy(rfid->currentCard, &serialNumber, 32);
		}

		isSuccess = true;
	}
	else if(ISO14443B_REQUEST_SN(Fd,moduleType,serialNumber) == true)
	{
		rfid->cardType = IS014443B;
		rfid->snType = RFID_SN_TYPE_4BYTE;
		memcpy(rfid->currentCard, &serialNumber, 32);
		sleep(2);

		isSuccess = true;
	}
	else if(FELICA_REQUEST_SN(Fd,moduleType,serialNumber) == true)
	{
		rfid->cardType = FELICA;
		rfid->snType = RFID_SN_TYPE_6BYTE;
		memcpy(rfid->currentCard, &serialNumber, 32);
		sleep(2);

		isSuccess = true;
	}
	else
	{}

	return isSuccess;
}

//==========================================
// ISO14443A Request SN function
//==========================================
bool ISO14443A_REQUEST_SN(int Fd, int moduleType, unsigned char *data)
{
	bool isSuccess = false;
	int tx_len = 4;
	unsigned char txByte[tx_len];
	unsigned char rxByte[254];
	unsigned char tmp[254];
	
	unsigned char TX_MESSAGE[254];
	unsigned char RX_MESSAGE[254];
	unsigned char TMP_MESSAGE[254];
	unsigned char TX_LENGTH;
	unsigned char RX_LENGTH;

	switch(moduleType)
	{
		case MODULE_EWT:
		default:
			//===============================
			// Command
			//===============================
			txByte[0] = tx_len-1;
			txByte[1] = RFID_CMD_ISO1443A_REQUEST;
			txByte[2] = REQA;
			txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));

			if(Fd > 0)
			{
				memset(rxByte, 0, sizeof (rxByte));
				if(system_command(Fd, txByte, tx_len, rxByte) > 0)
				{
					memset(tmp, 0, sizeof tmp);
					memcpy(tmp, rxByte, sizeof(rxByte));
					if(tmp[1] == RFID_CMD_ISO1443A_REQUEST)
					{
						if(tmp[0] == 0x09)
						{
							DEBUG_INFO_1("MIFARE CLASSIC.\n");

							cardLength = LENGTH_4;
							memcpy(data, rxByte+2, cardLength);

							isSuccess = true;
						}
						else if(tmp[0] == 0x0C)
						{
							DEBUG_INFO_1("MIFARE PLUS.\n");

							cardLength = LENGTH_7;
							memcpy(data, rxByte+2, cardLength);

							isSuccess = true;
						}
						else
						{}
					}
					else if (tmp[1] == 0xDF)
					{
						cardLength = LENGTH_0;
						isSuccess = false;
					}
					else
					{}
				}
				else
				{}
			}
			else
			{}

			break;
		case MODULE_REYAX:
			if(Fd > 0)
			{
				memset(TX_MESSAGE, 0, sizeof(TX_MESSAGE));
				memset(RX_MESSAGE, 0, sizeof(RX_MESSAGE));
				strcpy((char*)TX_MESSAGE, "AT+SCAN=1\r\n");
				TX_LENGTH = strlen((char*)TX_MESSAGE);
				
				//DEBUG_INFO_1("ISO14443A TX_LENGTH : %d.\n", TX_LENGTH);
				//DEBUG_INFO_1("ISO14443A TX_MESSAGE : %s.\n", TX_MESSAGE);

				if((RX_LENGTH = at_command(Fd, TX_MESSAGE, TX_LENGTH, RX_MESSAGE)) > 0)
				{	
					//DEBUG_INFO_1("ISO14443A RX_LENGTH : %d.\n", RX_LENGTH);
					//DEBUG_INFO_1("ISO14443A RX_MESSAGE : %s.\n", RX_MESSAGE);
				
					memset(TMP_MESSAGE, 0, sizeof(TMP_MESSAGE));
					if(strstr((char*)RX_MESSAGE, "+SCAN=ISO14443A:"))
					{
						if(RX_LENGTH == 26)
						{
							cardLength = LENGTH_4;
							memcpy(TMP_MESSAGE, RX_MESSAGE+16, (LENGTH_4*2));
							DEBUG_INFO_1("Mifare Classic tmp message : %s.\n", TMP_MESSAGE);

							sscanf((char*)TMP_MESSAGE, "%2X%2X%2X%2X", (unsigned int *)&data[0], 
																	   (unsigned int *)&data[1],
																	   (unsigned int *)&data[2], 
																	   (unsigned int *)&data[3]);

							isSuccess = true;
						}
						else if(RX_LENGTH == 32)
						{
							cardLength = LENGTH_7;
							memcpy(TMP_MESSAGE, RX_MESSAGE+16, (RFID_SN_TYPE_7BYTE*2));
							DEBUG_INFO_1("Mifare Plus tmp message : %s.\n", TMP_MESSAGE);

							sscanf((char*)TMP_MESSAGE, "%2X%2X%2X%2X%2X%2X%2X", (unsigned int *)&data[0],
																				(unsigned int *)&data[1],
																				(unsigned int *)&data[2],
																				(unsigned int *)&data[3],
																				(unsigned int *)&data[4],
																				(unsigned int *)&data[5],
																				(unsigned int *)&data[6]);

							isSuccess = true;
						}
						else
						{
							cardLength = LENGTH_0;
							isSuccess = false;
						}
					}
					else
					{}
				}
				else
				{}
			}
			else
			{}

			break;
	}

	return isSuccess;
}

//==========================================
// ISO14443B Request SN function
//==========================================
bool ISO14443B_REQUEST_SN(int Fd, int moduleType, unsigned char *data)
{
	bool isSuccess = false;
	int cardLength;
	int tx_len = 5;
	unsigned char txByte[tx_len];
	unsigned char rxByte[254];
	unsigned char tmp[254];
	
	/*
	unsigned char TX_MESSAGE[254];
	unsigned char RX_MESSAGE[254];
	unsigned char TMP_MESSAGE[254];
	unsigned char TX_LENGTH;
	unsigned char RX_LENGTH;
	*/

	switch(moduleType)
	{
		case MODULE_EWT:
		default:
			//===============================
			// Command
			//===============================
			txByte[0] = tx_len-1;
			txByte[1] = RFID_CMD_ISO1443B_REQUEST;
			txByte[2] = WUPA;
			txByte[3] = AFI;
			txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));

			if(Fd > 0)
			{
				memset(rxByte, 0, sizeof (rxByte));
				if(system_command(Fd, txByte, tx_len, rxByte) > 0)
				{
					memset(tmp, 0, sizeof tmp);
					memcpy(tmp, rxByte, sizeof(rxByte));
					if(tmp[1] == RFID_CMD_ISO1443B_REQUEST)
					{
						DEBUG_INFO_1("ISO14443 TYPE B.\n");

						cardLength = LENGTH_4;
						memcpy(data, rxByte+3, cardLength);

						isSuccess = true;
					}
					else if(tmp[1] == 0x9F)
					{
						cardLength = LENGTH_0;
						isSuccess = false;
					}
					else
					{}
				}
				else
				{}
			}
			else
			{}

			break;
		case MODULE_REYAX:
			/*
			if(Fd > 0)
			{
				memset(TX_MESSAGE, 0, sizeof(TX_MESSAGE));
				memset(RX_MESSAGE, 0, sizeof(RX_MESSAGE));
				strcpy((char*)TX_MESSAGE, "AT+SCAN=2\r\n");
				TX_LENGTH = strlen((char*)TX_MESSAGE);

				//DEBUG_INFO_1("IS014443B TX_LENGTH : %d.\n", TX_LENGTH);
				//DEBUG_INFO_1("IS014443B TX_MESSAGE : %s.\n", TX_MESSAGE);
				
				if((RX_LENGTH = at_command(Fd, TX_MESSAGE, TX_LENGTH, RX_MESSAGE);) > 0)
				{	
					//DEBUG_INFO_1("IS014443B RX_LENGTH : %d.\n", RX_LENGTH);
					//DEBUG_INFO_1("IS014443B RX MESSAGE : %s.\n", RX_MESSAGE);

					memset(TMP_MESSAGE, 0, sizeof TMP_MESSAGE);
					if(strstr((char*)RX_MESSAGE,"+SCAN=Felica:"))
					{
						if(RX_MESSAGE_LENGTH == 31)
						{
							cardLength = LENGTH_6;
							memcpy(TMP_MESSAGE, RX_MESSAGE+17, (LENGTH_6*2));
							DEBUG_INFO_1("IS014443B tmp message : %s...\n", TMP_MESSAGE);

							sscanf((char*)TMP_MESSAGE, "%2X%2X%2X%2X%2X%2X", (unsigned int *)&data[0], 
																			 (unsigned int *)&data[1],
																			 (unsigned int *)&data[2], 
																			 (unsigned int *)&data[3],
																			 (unsigned int *)&data[4],
																			 (unsigned int *)&data[5]);
							
							isSuccess = true;
						}
						else
						{
							cardLength = LENGTH_0;
							isSuccess = false;
						}
					}
					else
					{}
				}
				else
				{}
			}
			else
			{}
			*/
			
			break;
	}

	return isSuccess;
}

//==========================================
// FELICA Request SN function
//==========================================
bool FELICA_REQUEST_SN(int Fd, int moduleType, unsigned char *data)
{
	bool isSuccess = false;
	int cardLength;
	int tx_len = 9;
	unsigned char txByte[tx_len];
	unsigned char rxByte[254];
	unsigned char tmp[254];
	
	unsigned char TX_MESSAGE[254];
	unsigned char RX_MESSAGE[254];
	unsigned char TMP_MESSAGE[254];
	unsigned char TX_LENGTH;
	unsigned char RX_LENGTH;

	switch(moduleType)
	{
		case MODULE_EWT:
		default:
			//===============================
			// Command
			//===============================
			txByte[0] = tx_len-1;
			txByte[1] = RFID_CMD_FELICA_POLLING_REQUEST;
			txByte[2] = 0x06;
			txByte[3] = 0x00;
			txByte[4] = 0xFF;
			txByte[5] = 0xFF;
			txByte[6] = 0x01;
			txByte[7] = 0x00;
			txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));

			if(Fd > 0)
			{
				memset(rxByte, 0, sizeof (rxByte));
				if(system_command(Fd, txByte, tx_len, rxByte) > 0)
				{
					memset(tmp, 0, sizeof tmp);
					memcpy(tmp, rxByte, sizeof(rxByte));
					if(tmp[1] == RFID_CMD_FELICA_POLLING_REQUEST)
					{
						DEBUG_INFO_1("FELICA.\n");

						cardLength = LENGTH_6;
						memcpy(data, rxByte+6, cardLength);

						isSuccess = true;
					}
					else if(tmp[1] == 0xD0)
					{
						cardLength = LENGTH_0;
						isSuccess = false;
					}
					else
					{}
				}
				else
				{}
			}
			else
			{}

			break;
		case MODULE_REYAX:
			if(Fd > 0)
			{
				memset(TX_MESSAGE, 0, sizeof(TX_MESSAGE));
				memset(RX_MESSAGE, 0, sizeof(RX_MESSAGE));
				strcpy((char*)TX_MESSAGE, "AT+SCAN=4\r\n");
				TX_LENGTH = strlen((char*)TX_MESSAGE);
				
				//DEBUG_INFO_1("FELICA TX_LENGTH : %d.\n", TX_LENGTH);
				//DEBUG_INFO_1("FELICA TX_MESSAGE : %s.\n", TX_MESSAGE);

				if((RX_LENGTH = at_command(Fd, TX_MESSAGE, TX_LENGTH, RX_MESSAGE)) > 0)
				{
					//DEBUG_INFO_1("FELICA RX_LENGTH : %d.\n", RX_LENGTH);
					//DEBUG_INFO_1("FELICA RX_MESSAGE : %s.\n", RX_MESSAGE);
					
					memset(TMP_MESSAGE, 0, sizeof(TMP_MESSAGE));
					if(strstr((char*)RX_MESSAGE,"+SCAN=Felica:"))
					{
						if(RX_LENGTH == 31)
						{
							cardLength = LENGTH_6;
							memcpy(TMP_MESSAGE, RX_MESSAGE+17, (LENGTH_6*2));
							DEBUG_INFO_1("Felica tmp message : %s.\n", TMP_MESSAGE);

							sscanf((char*)TMP_MESSAGE, "%2X%2X%2X%2X%2X%2X", (unsigned int *)&data[0], 
																			 (unsigned int *)&data[1],
																			 (unsigned int *)&data[2], 
																			 (unsigned int *)&data[3],
																			 (unsigned int *)&data[4],
																			 (unsigned int *)&data[5]);

							isSuccess = true;
						}
						else
						{
							cardLength = LENGTH_0;
							isSuccess = false;
						}
					}
					else
					{}
				}
				else
				{}
			}
			else
			{}

			break;
	}

	return isSuccess;
}

//==========================================
// Read block data from RFID card
//==========================================
bool getBlockRead(int Fd, int moduleType, int block, unsigned char keyId, unsigned char *data)
{
	bool isSuccess = false;
	int i;
	int j = 0;
	int len = 11;
	unsigned char txByte[len];
	unsigned char rxByte[254];
	unsigned char tmp[254];

	switch(moduleType)
	{
		case MODULE_EWT:
		default:
			//===============================
			// Command
			//===============================
			txByte[0] = 0x0A;
			txByte[1] = RFID_CMD_BLOCK_READ;
			txByte[2] = keyId;
			txByte[3] = block;
			for(i = 4; i < 10; i++)
			{
				if( j < sizeof (sectorKeyA[0]))
				{
					txByte[i] = sectorKeyA[(int)(block/4)][j];
					j++;
				}
			}
			txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));

			if(Fd > 0)
			{
				memset(rxByte, 0, sizeof(rxByte));
				if(system_command(Fd, txByte, len, rxByte) > 0)
				{
					memset(tmp, 0, sizeof tmp);
					memcpy(tmp, rxByte, sizeof (rxByte));
					if((tmp[1] == RFID_CMD_BLOCK_READ))
					{
						DEBUG_INFO_1("Read block successfully.\n");

						memcpy(data, rxByte+2, 16);

						isSuccess = true;
					}
					else if (tmp[1] == 0xDE)
					{
						DEBUG_INFO_1("Read block unsuccessfully.\n");
					}
					else
					{}
				}
				else
				{}
			}
			else
			{}

			break;
	}

	return isSuccess;
}

//==========================================
// Write data into RFID card block
//==========================================
bool setBlockWrite(int Fd, int moduleType, int block, unsigned char keyid, unsigned char *data)
{
	bool isSuccess = false;
	int i;
	int j = 0;
	int len = 27;
	unsigned char txByte[len];
	unsigned char rxByte[254];
	unsigned char tmp[254];

	switch(moduleType)
	{
		case MODULE_EWT:
		default:
			//===============================
			// Command
			//===============================
			txByte[0] = 0x1A;
			txByte[1] = RFID_CMD_BLOCK_WRITE;
			txByte[2] = keyid;
			txByte[3] = block;

			for(i = 4; i < 10; i++)
			{
				if( j < sizeof (sectorKeyA[0]))
				{
					txByte[i] = sectorKeyA[(int)(block/4)][j];
					j++;
				}
			}
			memcpy(txByte+10, data, 16);
			txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,(ARRAY_SIZE(txByte)));

			if(Fd > 0)
			{
				memset(rxByte, 0, sizeof(rxByte));
				if(system_command(Fd, txByte, len, rxByte) > 0)
				{
					memset(tmp, 0, sizeof tmp);
					memcpy(tmp, rxByte, sizeof (rxByte));
					if(tmp[1] == RFID_CMD_BLOCK_WRITE)
					{
						DEBUG_INFO_1("Write block successfully.\n");

						isSuccess = true;
					}
					else if(tmp[1] == 0xDD)
					{
						DEBUG_INFO_1("Write block unsuccessfully.\n");

						isSuccess = false;
					}
					else
					{}
				}
				else
				{}
			}
			else
			{}

			break;
	}

	return isSuccess;
}

//==========================================
// Buzzer set (EWT Module)
//==========================================
void setBuzzer(int Fd, int moduleType, unsigned char time)
{
	int len = 4;
	unsigned char txByte[len];
	unsigned char rxByte[254];
	unsigned char tmp[254];

	switch(moduleType)
	{
		case MODULE_EWT:
		default:
			//===============================
			// Command
			//===============================
			txByte[0] = 0x03;
			txByte[1] = RFID_CMD_BUZZER_SET;
			if(time > 0x0A)
			{
				time = 0x05;
				txByte[2] = time;

				DEBUG_WARN_1("Value is out of range.\n");
			}
			else
			{
				txByte[2] = time;
			}
			txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));

			if(Fd > 0)
			{
				memset(rxByte, 0, sizeof(rxByte));
				if(system_command(Fd, txByte, len, rxByte) > 0)
				{
					memset(tmp, 0, sizeof tmp);
					memcpy(tmp, rxByte, sizeof (rxByte));
					if(tmp[1] == 0x14)
					{
						DEBUG_INFO_1("Set Buzzer ok.\n");
						DEBUG_INFO_1("Set Buzzer %d ms.\n",time);
					}
					else if(tmp[1] == 0xEC)
					{
						DEBUG_INFO_1("Set Buzzer fail.\n");
					}
					else
					{}
				}
				else
				{}
			}
			else
			{}

			break;
	}
}

//==========================================
// Halt RFID card (EWT)
//==========================================
void sethaltCard(int Fd, int moduleType)
{
	int len = 3;
	unsigned char txByte[len];
	unsigned char rxByte[254];
	unsigned char tmp[254];

	switch(moduleType)
	{
		case MODULE_EWT:
		default:
			//===============================
			// Command
			//===============================
			txByte[0] = 0x02;
			txByte[1] = RFID_CMD_HALT_14443A;
			txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));

			if(Fd > 0)
			{
				memset(rxByte, 0, sizeof(rxByte));
				if(system_command(Fd, txByte, len, rxByte) > 0)
				{
					memset(tmp, 0, sizeof tmp);
					memcpy(tmp, rxByte, sizeof (rxByte));
					if(tmp[1] == 0x28)
					{
						DEBUG_INFO_1("Halt card pass.\n");
					}
					else if(tmp[1] == 0xD7)
					{
						DEBUG_INFO_1("Halt card fail.\n");
					}
					else
					{}
				}
				else
				{}
			}
			else
			{}

			break;
	}
}

//==========================================
// Set the RF Output Level
//==========================================
bool setRfOutputLevel(int Fd, int moduleType, int Value)
{
	bool isSuccess = false;
	int len = 4;
	unsigned char txByte[len];
	unsigned char rxByte[254];
	unsigned char tmp[254];

	switch(moduleType)
	{
		case MODULE_EWT:
		default:
			//===============================
			// Command
			//===============================
			txByte[0] = 0x03;
			txByte[1] = RFID_CMD_RF_OUTPUT_LEVEL_SET;
			txByte[2] = Value;
			txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));
			
			if(Fd > 0)
			{
				memset(rxByte, 0, sizeof(rxByte));
				if(system_command(Fd, txByte, len, rxByte) > 0)
				{
					memset(tmp, 0, sizeof tmp);
					memcpy(tmp, rxByte, sizeof (rxByte));
					if(tmp[1] == RFID_CMD_RF_OUTPUT_LEVEL_SET)
					{
						DEBUG_INFO_1("Set the RF Output Level : Pass...\n");
						
						if(Value == RF_STRONGEST)
						{
							DEBUG_INFO_1("Strongest...\n");
						}
						else if(Value == RF_STRONGER)
						{
							DEBUG_INFO_1("Strong...\n");
						}	
						else if(Value == RF_WEAK)
						{
							DEBUG_INFO_1("Weak...\n");
						}
						else if(Value == RF_WEAKEST)
						{
							DEBUG_INFO_1("Weakest...\n");
						}
					
						isSuccess = true;
					}
					else if(tmp[1] == 0xFD)
					{
						DEBUG_INFO_1("Set the RF Output Level : Fail...\n");
						DEBUG_INFO_1("Unknow value !!! \n");
						DEBUG_INFO_1("Strongest : SET_RF_STRONGEST...\n");
						DEBUG_INFO_1("Strong    : SET_RF_STRONGER...\n");
						DEBUG_INFO_1("Weak      : SET_RF_WEAK...\n");
						DEBUG_INFO_1("Weakest   : SET_RF_WEAKEST...\n");
						
						isSuccess = false;
					}
					else
					{}
				}
				else
				{}
			}
			else
			{}
			
			break;			
	}
	
	return isSuccess;
}

//==========================================
// Set the Default of Automatic Detecting Card
//==========================================
bool setDefaultOfAutomaticDetectingCard(int Fd, int moduleType, int Value)
{
	bool isSuccess = false;
	int len = 4;
	unsigned char txByte[len];
	unsigned char rxByte[254];
	unsigned char tmp[254];
	
	switch(moduleType)
	{
		case MODULE_EWT:
		default:
			//===============================
			// Command
			//===============================
			txByte[0] = 0x03;
			txByte[1] = RFID_CMD_DEFAULT_AUTO_DETECTING_CARD;
			txByte[2] = Value;
			txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));
	
			if(Fd > 0)
			{
				memset(rxByte, 0, sizeof(rxByte));
				if(system_command(Fd, txByte, len, rxByte) > 0)
				{
					memset(tmp, 0, sizeof tmp);
					memcpy(tmp, rxByte, sizeof (rxByte));
					if(tmp[1] == RFID_CMD_DEFAULT_AUTO_DETECTING_CARD)
					{
						if(Value == TURN_OFF)
						{
							DEBUG_INFO_1("Default of Automatic Detecting Card : OFF...\n");
						}
						else if (Value == TURN_ON)
						{
							DEBUG_INFO_1("Default of Automatic Detecting Card : ON...\n");
						}
						else if (Value == TURN_TEMPORARILY)
						{
							DEBUG_INFO_1("Default of Automatic Detecting Card : Temporarily open and close automatically detect card...\n");
						}
						
						isSuccess = true;
					}
					else if(tmp[1] == 0xE2)
					{
						DEBUG_INFO_1("Value : SET_DETECTING_OFF = OFF...\n");
						DEBUG_INFO_1("Value : SET_DETECTING_ON = ON...\n");
						DEBUG_INFO_1("Value : SET_DETECTING_TEMPORARILY = Temporarily open and close...\n");
						
						isSuccess = false;
					}
					else
					{}
				}
				else
				{}
			}
			else
			{}

			break;
	}
	
	return isSuccess;
}