2019-11-06 /Eason Yang

1.Change Module_RFID.c Reason: Added logic for ISO14443A / ISO14443B / FELICA.
2.Change Module_RFID.h Reason: Fixed API function.

EVSE/Modularization/Module_RFID.c

@@ -1,3 +1,11 @@
+/*
+ * Module_RFID.c
+ *
+ *  Created on: 2019¦~10¤ë28¤é
+ *      Author: Eason Yang
+ *     Version: D0.01
+ */
+
 #include "Module_RFID.h"
 
 //==================================
@@ -21,21 +29,33 @@
 //==================================
 #define NO_MODULE			-1
 #define MODULE_EWT			0
-#define MODULE_ELATEC		1
 
 //==================================
-// ACTION CONSTANT
+// RFID CMD CONSTANT
 //==================================
-#define SEARCH				1
-#define READ				2
-#define WRITE				3
+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;
 
 //==================================
 // RFID MODE CONSTANT
 //==================================
-unsigned char WUPA = 0;
-unsigned char REQA = 1;
-unsigned int STATUS = 0;
+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;
 
 //==================================
 // MIFARE SECTOR SPACE
@@ -61,14 +81,8 @@ unsigned char sectorKeyA[COLUMN][ROW] = {	{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF},
 											{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
 	 	 	 	 	 	 	 	 	 	 };
 
-//==================================
-// RFID CMD CONSTANT
-//==================================
-unsigned int RFID_CMD_REQUEST_SN    = 0x20;
-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 char serialNumber[32];
+unsigned int cardLength;
 
 //==================================
 // SystemLog message
@@ -76,7 +90,7 @@ unsigned int RFID_CMD_BUZZER_SET	= 0X14;
 #ifdef SystemLogMessage
 int StoreLogMessage(const char *fmt, ...)
 {
-	char Buf[4096+256];
+	char Buf[4096 + 256];
 	char buffer[4096];
 	time_t CurrentTime;
 	struct tm *tm;
@@ -86,38 +100,24 @@ int StoreLogMessage(const char *fmt, ...)
 	int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
 	va_end(args);
 
-	memset(Buf,0,sizeof(Buf));
+	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]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);
+	tm = localtime(&CurrentTime);
+	sprintf(Buf,
+			"echo \"[%04d.%02d.%02d %02d:%02d:%02d] - %s\" >> /Storage/SystemLog/[%04d.%02d]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);
+	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
 
-//=================================
-// Common routine
-//=================================
-char* getTimeString(void)
-{
-	char *result=malloc(21);
-	time_t timep;
-	struct tm *p;
-	time(&timep);
-	p=gmtime(&timep);
-
-	sprintf(result, "[%04d-%02d-%02d %02d:%02d:%02d]", (1900+p->tm_year), (1+p->tm_mon), p->tm_mday, p->tm_hour, p->tm_hour, p->tm_sec);
-
-	return result;
-}
-
 //==========================================
 // Module's command send/receive
 //==========================================
@@ -129,7 +129,7 @@ int system_command(int uart, unsigned char* cmd,int length, unsigned char* rx)
 	tcflush(uart,TCIOFLUSH);
 	if(write(uart, cmd, length) >= 0)
 	{
-		usleep(500000);
+		usleep(100000);
 		len = read(uart, rx, 256);
 	}
 	else
@@ -158,15 +158,61 @@ char ClaCheckSum(unsigned char *buffer, int len)
 	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);
+		}
+
+		sethaltCard(Fd,moduleType);
+
+		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;
+}
+
 //==========================================
-// Read RFID card's serial number
+// ISO14443A Request SN function
 //==========================================
-bool getRequestCardSN(int Fd, int moduleType, unsigned char *serialNumber)
+bool ISO14443A_REQUEST_SN(int Fd, int moduleType, unsigned char *data)
 {
 	bool isSuccess = false;
-	int cardLength;
-	int len = 4;
-	unsigned char txByte[len];
+	int tx_len = 4;
+	unsigned char txByte[tx_len];
 	unsigned char rxByte[254];
 	unsigned char tmp[254];
 
@@ -174,10 +220,11 @@ bool getRequestCardSN(int Fd, int moduleType, unsigned char *serialNumber)
 	{
 		case MODULE_EWT:
 		default:
-
+			//===============================
 			// Command
-			txByte[0] = 0x03;
-			txByte[1] =	RFID_CMD_REQUEST_SN;
+			//===============================
+			txByte[0] = tx_len-1;
+			txByte[1] = RFID_CMD_ISO1443A_REQUEST;
 			txByte[2] = REQA;
 			txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));
 
@@ -185,50 +232,41 @@ bool getRequestCardSN(int Fd, int moduleType, unsigned char *serialNumber)
 			{
 				memset(rxByte, 0, sizeof (rxByte));
 
-				// Send commands
-				if(system_command(Fd, txByte, len, rxByte) > 0)
+				if(system_command(Fd, txByte, tx_len, rxByte) > 0)
 				{
 					memset(tmp, 0, sizeof tmp);
 					memcpy(tmp, rxByte, sizeof(rxByte));
 
-					if(tmp[1] == RFID_CMD_REQUEST_SN)
+					if(tmp[1] == RFID_CMD_ISO1443A_REQUEST)
 					{
 						if(tmp[0] == 0x09)
 						{
 							#ifdef SystemLogMessage
-							DEBUG_INFO_1("Card type : MIFARE classic.\n");
+							DEBUG_INFO_1("MIFARE CLASSIC.\n");
 							#endif
 
-							cardLength = 4;
-							*(serialNumber) = cardLength;
-							memcpy(serialNumber+1, rxByte+2, cardLength);
+							cardLength = LENGTH_4;
+							memcpy(data, rxByte+2, cardLength);
 
 							isSuccess = true;
 						}
 						else if(tmp[0] == 0x0C)
 						{
-
 							#ifdef SystemLogMessage
-							DEBUG_INFO_1("Card type : Plus, UltraLight or DESFire.\n");
+							DEBUG_INFO_1("MIFARE PLUS.\n");
 							#endif
 
-							cardLength = 7;
-							*(serialNumber) = cardLength;
-							memcpy(serialNumber+1, rxByte+2, cardLength);
+							cardLength = LENGTH_7;
+							memcpy(data, rxByte+2, cardLength);
 
 							isSuccess = true;
 						}
 						else
-						{
-							#ifdef SystemLogMessage
-							DEBUG_INFO_1("Please try again.\n");
-							#endif
-							isSuccess = false;
-						}
+						{}
 					}
 					else if (tmp[1] == 0xDF)
 					{
-						cardLength = 0;
+						cardLength = LENGTH_0;
 						isSuccess = false;
 					}
 				}
@@ -239,7 +277,135 @@ bool getRequestCardSN(int Fd, int moduleType, unsigned char *serialNumber)
 			{}
 
 			break;
-		case MODULE_ELATEC:
+	}
+
+	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];
+
+	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)
+					{
+						#ifdef SystemLogMessage
+						DEBUG_INFO_1("ISO14443 TYPE B.\n");
+						#endif
+
+						cardLength = LENGTH_4;
+						memcpy(data, rxByte+3, cardLength);
+
+						isSuccess = true;
+					}
+					else if(tmp[1] == 0x9F)
+					{
+						cardLength = LENGTH_0;
+						isSuccess = false;
+					}
+				}
+				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];
+
+	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)
+					{
+						#ifdef SystemLogMessage
+						DEBUG_INFO_1("FELICA.\n");
+						#endif
+
+						cardLength = LENGTH_6;
+						memcpy(data, rxByte+6, cardLength);
+
+						isSuccess = true;
+					}
+					else if(tmp[1] == 0xD0)
+					{
+						cardLength = LENGTH_0;
+						isSuccess = false;
+					}
+				}
+				else
+				{}
+			}
+			else
+			{}
+
 			break;
 	}
 
@@ -256,15 +422,16 @@ bool getBlockRead(int Fd, int moduleType, int block, unsigned char keyId, unsign
 	int j = 0;
 	int len = 11;
 	unsigned char txByte[len];
-	unsigned char rxByte[19];
-	unsigned char tmp[19];
+	unsigned char rxByte[254];
+	unsigned char tmp[254];
 
 	switch(moduleType)
 	{
 		case MODULE_EWT:
-			default:
-
+		default:
+			//===============================
 			// Command
+			//===============================
 			txByte[0] = 0x0A;
 			txByte[1] = RFID_CMD_BLOCK_READ;
 			txByte[2] = keyId;
@@ -283,7 +450,6 @@ bool getBlockRead(int Fd, int moduleType, int block, unsigned char keyId, unsign
 			{
 				memset(rxByte, 0, sizeof(rxByte));
 
-				// Send commands
 				if(system_command(Fd, txByte, len, rxByte) > 0)
 				{
 					memset(tmp, 0, sizeof tmp);
@@ -315,9 +481,6 @@ bool getBlockRead(int Fd, int moduleType, int block, unsigned char keyId, unsign
 			{}
 
 			break;
-
-		case MODULE_ELATEC:
-			break;
 	}
 
 	return isSuccess;
@@ -333,15 +496,16 @@ bool setBlockWrite(int Fd, int moduleType, int block, unsigned char keyid, unsig
 	int j = 0;
 	int len = 27;
 	unsigned char txByte[len];
-	unsigned char rxByte[3];
-	unsigned char tmp[3];
+	unsigned char rxByte[254];
+	unsigned char tmp[254];
 
 	switch(moduleType)
 	{
 		case MODULE_EWT:
-			default:
-
+		default:
+			//===============================
 			// Command
+			//===============================
 			txByte[0] = 0x1A;
 			txByte[1] = RFID_CMD_BLOCK_WRITE;
 			txByte[2] = keyid;
@@ -362,7 +526,6 @@ bool setBlockWrite(int Fd, int moduleType, int block, unsigned char keyid, unsig
 			{
 				memset(rxByte, 0, sizeof(rxByte));
 
-				// Send commands
 				if(system_command(Fd, txByte, len, rxByte) > 0)
 				{
 					memset(tmp, 0, sizeof tmp);
@@ -391,8 +554,6 @@ bool setBlockWrite(int Fd, int moduleType, int block, unsigned char keyid, unsig
 			else
 			{}
 
-			break;
-		case MODULE_ELATEC:
 			break;
 	}
 
@@ -406,15 +567,16 @@ void setBuzzer(int Fd, int moduleType, unsigned char time)
 {
 	int len = 4;
 	unsigned char txByte[len];
-	unsigned char rxByte[3];
-	unsigned char tmp[3];
+	unsigned char rxByte[254];
+	unsigned char tmp[254];
 
 	switch(moduleType)
 	{
 		case MODULE_EWT:
-			default:
-
+		default:
+			//===============================
 			// Command
+			//===============================
 			txByte[0] = 0x03;
 			txByte[1] = RFID_CMD_BUZZER_SET;
 			if(time > 0x0A)
@@ -436,7 +598,6 @@ void setBuzzer(int Fd, int moduleType, unsigned char time)
 			{
 				memset(rxByte, 0, sizeof(rxByte));
 
-				// Send commands
 				if(system_command(Fd, txByte, len, rxByte) > 0)
 				{
 					memset(tmp, 0, sizeof tmp);
@@ -464,9 +625,6 @@ void setBuzzer(int Fd, int moduleType, unsigned char time)
 			{}
 
 			break;
-
-		case MODULE_ELATEC:
-			break;
 	}
 }
 
@@ -477,370 +635,51 @@ void sethaltCard(int Fd, int moduleType)
 {
 	int len = 3;
 	unsigned char txByte[len];
-	unsigned char rxByte[3];
-	unsigned char tmp[3];
+	unsigned char rxByte[254];
+	unsigned char tmp[254];
 
 	switch(moduleType)
 	{
 		case MODULE_EWT:
-				default:
+		default:
+			//===============================
+			// Command
+			//===============================
+			txByte[0] = 0x02;
+			txByte[1] = RFID_CMD_HALT_14443A;
+			txByte[ARRAY_SIZE(txByte)-1] = ClaCheckSum(txByte,ARRAY_SIZE(txByte));
 
-				// 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(Fd > 0)
+				if(system_command(Fd, txByte, len, rxByte) > 0)
 				{
-					memset(rxByte, 0, sizeof(rxByte));
+					memset(tmp, 0, sizeof tmp);
+					memcpy(tmp, rxByte, sizeof (rxByte));
 
-					// Send commands
-					if(system_command(Fd, txByte, len, rxByte) > 0)
+					if(tmp[1] == 0x28)
 					{
-						memset(tmp, 0, sizeof tmp);
-						memcpy(tmp, rxByte, sizeof (rxByte));
-
-						if(tmp[1] == 0x28)
-						{
-							#ifdef SystemLogMessage
-							DEBUG_INFO_1("Halt card pass.\n");
-							#endif
-						}
-						else if(tmp[1] == 0xD7)
-						{
-							#ifdef SystemLogMessage
-							DEBUG_INFO_1("Halt card fail.\n");
-							#endif
-						}
-						else
-						{}
+						#ifdef SystemLogMessage
+						DEBUG_INFO_1("Halt card pass.\n");
+						#endif
+					}
+					else if(tmp[1] == 0xD7)
+					{
+						#ifdef SystemLogMessage
+						DEBUG_INFO_1("Halt card fail.\n");
+						#endif
 					}
 					else
 					{}
 				}
 				else
 				{}
-
-				break;
-
-		case MODULE_ELATEC:
-			break;
-	}
-}
-
-//==========================================
-// Searchtag function (ELATEC Module)
-//==========================================
-bool searchTag(int Fd, int moduleType, unsigned char *serialNumber, int status)
-{
-	bool isSuccess = false;
-	int cardLength;
-	int len = 5;
-	unsigned char txByte[len];
-	unsigned char rxByte[254];
-	unsigned char tmp[254];
-
-	// Command
-	txByte[0] = 0x03;
-	txByte[1] = 0x00;
-	txByte[2] = 0x05;
-	txByte[3] = 0x00;
-	txByte[4] = 0x10;
-
-	// Open port
-	if(Fd > 0)
-	{
-		memset(rxByte, 0, sizeof (rxByte));
-
-		// Send commands
-		if(system_command(Fd, txByte, len, rxByte) > 0)
-		{
-			memset(tmp, 0, sizeof tmp);
-			memcpy(tmp, rxByte, sizeof(rxByte));
-
-			if(tmp[3] == 0x01)
-			{
-				if(tmp[6] == 0x04)
-				{
-					if(status == SEARCH)
-					{
-						cardLength = 4;
-						*(serialNumber) = cardLength;
-						memcpy(serialNumber+1, rxByte+7, cardLength);
-					}
-
-					#ifdef SystemLogMessage
-					DEBUG_INFO_1("Card type: MIFARE classic.\n");
-					#endif
-				}
-				else if (tmp[6] == 0x07)
-				{
-					cardLength = 7;
-					*(serialNumber) = cardLength;
-					memcpy(serialNumber+1, rxByte+7, cardLength);
-
-					#ifdef SystemLogMessage
-					DEBUG_INFO_1("Card type: Plus, UltraLight or DESFire.\n");
-					#endif
-				}
-
-				isSuccess = true;
-			}
-			else if(tmp[3] == 0x00)
-			{
-				cardLength = 0;
-				isSuccess = false;
-			}
-		}
-		else
-		{}
-	}
-	else
-	{}
-
-	return isSuccess;
-}
-
-//==========================================
-// MifareClassic_Login function (ELATEC Module)
-//==========================================
-bool MifareClassic_Login(int Fd, int moduleType, int block, unsigned char keyid)
-{
-	bool isSuccess = false;
-	int i;
-	int j = 0;
-	int len = 12;
-	unsigned char txByte[len];
-	unsigned char rxByte[254];
-	unsigned char tmp[254];
-
-	// Command
-	txByte[0] = 0x0A;
-	txByte[1] = 0x00;
-	txByte[2] = 0x0B;
-	txByte[3] = 0x00;
-	for(i = 4; i < 10; i++)
-	{
-		if( j < sizeof (sectorKeyA[0]))
-		{
-			txByte[i] = sectorKeyA[(int)(block/4)][j];
-			j++;
-		}
-	}
-	txByte[10] = keyid;
-	txByte[11] = block/4;
-
-	if(Fd > 0)
-	{
-		memset(rxByte, 0, sizeof (rxByte));
-
-		// Send commands
-		if(system_command(Fd, txByte, len, rxByte) > 0)
-		{
-			memset(tmp, 0, sizeof tmp);
-			memcpy(tmp, rxByte, sizeof(rxByte));
-
-			if(tmp[3] == 0x01)
-			{
-				#ifdef SystemLogMessage
-				DEBUG_INFO_1("MIFARE classic login pass.\n");
-				#endif
-				isSuccess = true;
-			}
-			else if(tmp[3] == 0x00)
-			{
-				#ifdef SystemLogMessage
-				DEBUG_INFO_1("MIFARE classic login fail.\n");
-				#endif
-				isSuccess = false;
 			}
 			else
-			{
-				#ifdef SystemLogMessage
-				DEBUG_WARN_1("Please try again.\n");
-				#endif
-				isSuccess = false;
-			}
-		}
-		else
-		{}
-	}
-	else
-	{}
-
-	return isSuccess;
-}
-
-//==========================================
-// MifareClassic_ReadBlock (ELATEC Module)
-//==========================================
-bool MifareClassic_ReadBlock(int Fd, int moduleType, int block,unsigned char *data)
-{
-	bool isSuccess = false;
-	int len = 5;
-	unsigned char txByte[len];
-	unsigned char rxByte[254];
-	unsigned char tmp[254];
-
-	// Command
-	txByte[0] = 0x03;
-	txByte[1] = 0x00;
-	txByte[2] = 0x0B;
-	txByte[3] = 0x01;
-	txByte[4] = block;
-
-	if(Fd > 0)
-	{
-		memset(rxByte, 0, sizeof (rxByte));
-
-		// Send commands
-		if(system_command(Fd, txByte, len, rxByte) > 0)
-		{
-			memset(tmp, 0, sizeof tmp);
-			memcpy(tmp, rxByte, sizeof(rxByte));
-
-			if(tmp[3] == 0x01)
-			{
-				#ifdef SystemLogMessage
-				DEBUG_INFO_1("Read block successfully.\n");
-				#endif
-
-				memcpy(data, rxByte+4, 16);
-
-				isSuccess = true;
-			}
-			else if(tmp[3] == 0x00)
-			{
-				#ifdef SystemLogMessage
-				DEBUG_INFO_1("Unsuccessful to read block.\n");
-				#endif
-
-				isSuccess = false;
-			}
-			else
-			{
-				#ifdef SystemLogMessage
-				DEBUG_WARN_1("Please try again.\n");
-				#endif
-
-				isSuccess = false;
-			}
-		}
-		else
-		{}
-	}
-	else
-	{}
-
-	return isSuccess;
-}
-
-//==========================================
-// MifareClassic_WriteBlock (ELATEC Module)
-//==========================================
-bool MifareClassic_WriteBlock(int Fd, int moduleType, int block, unsigned char *data)
-{
-	bool isSuccess = false;
-	int len = 21;
-	unsigned char txByte[len];
-	unsigned char rxByte[254];
-	unsigned char tmp[254];
-
-	// Command
-	txByte[0] = 0x13;
-	txByte[1] = 0x00;
-	txByte[2] = 0x0B;
-	txByte[3] = 0x02;
-	txByte[4] = block;
-	memcpy(txByte+5, data, 16);
-
-	if(Fd > 0)
-	{
-		memset(rxByte, 0, sizeof (rxByte));
-
-		// Send command
-		if(system_command(Fd, txByte, len, rxByte) > 0)
-		{
-			memset(tmp, 0, sizeof tmp);
-			memcpy(tmp, rxByte, sizeof(rxByte));
-
-			if(tmp[3] == 0x01)
-			{
-				#ifdef SystemLogMessage
-				DEBUG_INFO_1("Write block successfully.\n");
-				#endif
-
-				memcpy(data, rxByte+4, 16);
-				isSuccess = true;
-			}
-			else if(tmp[3] == 0x00)
-			{
-				#ifdef SystemLogMessage
-				DEBUG_INFO_1("Unsuccessful to Write block.\n");
-				#endif
-
-				isSuccess = false;
-			}
-			else
-			{
-				#ifdef SystemLogMessage
-				DEBUG_WARN_1("Please try again.\n");
-				#endif
+			{}
 
-				isSuccess = false;
-			}
-		}
-		else
-		{}
+			break;
 	}
-	else
-	{}
-
-	return isSuccess;
 }
 
-//==========================================
-// Beep (ELATEC Module)
-//==========================================
-bool SetBeep(int Fd, int moduleType, unsigned char sound)
-{
-	bool isSuccess = false;
-	int len = 11;
-	unsigned char txByte[len];
-	unsigned char rxByte[254];
-	unsigned char tmp[254];
-
-	// Command
-	txByte[0] = 0x09;
-	txByte[1] = 0x00;
-	txByte[2] = 0x04;
-	txByte[3] = 0x07;
-	txByte[4] = sound;
-	txByte[5] = 0x60;
-	txByte[6] = 0x09;
-	txByte[7] = 0xF4;
-	txByte[8] = 0x01;
-	txByte[9] = 0xF4;
-	txByte[10] = 0x01;
-
-	if(Fd > 0)
-	{
-		memset(rxByte, 0, sizeof(rxByte));
-
-		// Send command
-		if(system_command(Fd, txByte, len, rxByte) > 0)
-		{
-			memset(tmp, 0, sizeof tmp);
-			memcpy(tmp, rxByte, sizeof(rxByte));
-			isSuccess = true;
-		}
-		else
-		{
-			isSuccess = true;
-		}
-	}
-	else
-	{}
-
-	return isSuccess;
-}

EVSE/Modularization/Module_RFID.h

@@ -1,8 +1,8 @@
 /*
  * Module_RFID.h
  *
- *  Created on: 2019¦~8¤ë12¤é
- *      Author: USER
+ *  Created on: 2019¦~10¤ë24¤é
+ *      Author: Eason Yang
  */
 #ifndef LIB_RFID_H_
 #define LIB_RFID_H_
@@ -36,16 +36,40 @@
 #include 	<ifaddrs.h>
 #include	<stdbool.h>
 
+typedef struct Rfid
+{
+	uint8_t     snType;             // 4 bytes or 6 bytes or 7 bytes or 10 bytes
+	uint8_t		cardType;			// 0: NONE 1: ISO14443A  2: ISO14443B  4: FELICA
+	uint8_t		currentCard[32];    // Current charging cycle start card number
+	uint8_t     targetBlock;        // RFID read/write target block
+	uint8_t     keyType;            // 0: Key-A  1: Key-B
+	uint8_t		data_Block[32];     // RFID operation block data
+}RFID;
+
+//==================================
+// Card Length
+//==================================
+#define RFID_SN_TYPE_4BYTE		4
+#define RFID_SN_TYPE_6BYTE		6
+#define RFID_SN_TYPE_7BYTE      7
+#define RFID_SN_TYPE_10BYTE     10
+
+//==================================
+// Card Type
+//==================================
+#define NONE					0
+#define ISO14443A				1
+#define IS014443B				2
+#define FELICA					3
+
 char ClaCheckSum(unsigned char *buffer, int len);
 int system_command(int uart, unsigned char* cmd,int length, unsigned char* rx);
-bool getRequestCardSN(int Fd, int moduleType, unsigned char *serialNumber);
+bool getRequestCardSN(int Fd, int moduleType,RFID *rfid);
+bool ISO14443A_REQUEST_SN(int Fd, int moduleType, unsigned char *serialNumber);
+bool ISO14443B_REQUEST_SN(int Fd, int moduleType, unsigned char *serialNumber);
+bool FELICA_REQUEST_SN(int Fd, int moduleType, unsigned char *serialNumber);
 bool getBlockRead(int Fd, int moduleType,int block, unsigned char keyid, unsigned char *data);
 bool setBlockWrite(int Fd, int moduleType,int block, unsigned char keyid, unsigned char *data);
-bool searchTag(int Fd, int moduleType, unsigned char *serialNumber, int status);
-bool MifareClassic_Login(int Fd, int moduleType, int block, unsigned char keyId);
-bool MifareClassic_ReadBlock(int Fd, int moduleType, int block, unsigned char *data);
-bool MifareClassic_WriteBlock(int Fd, int moduleType, int block, unsigned char *data);
-bool SetBeep(int Fd, int moduleType, unsigned char sound);
 void setBuzzer(int Fd, int moduleType, unsigned char time);
 void sethaltCard(int Fd, int moduleType);