csu3_am335x/EVSE/Projects/DO360/Apps/Module_EvComm.c

/*
 * Module_EvComm.c
 *
 *  Created on: 2020年9月14日
 *      Author: Wendell
 */

#include 	<sys/time.h>
#include 	<sys/timeb.h>
#include    <sys/types.h>
#include    <sys/stat.h>
#include 	<sys/types.h>
#include 	<sys/ioctl.h>
#include 	<sys/socket.h>
#include 	<sys/ipc.h>
#include 	<sys/shm.h>
#include 	<sys/shm.h>
#include 	<sys/mman.h>
#include 	<linux/can.h>
#include 	<linux/can/raw.h>
#include 	<linux/wireless.h>
#include 	<arpa/inet.h>
#include 	<netinet/in.h>

#include 	<unistd.h>
#include 	<stdarg.h>
#include    <stdio.h>      /*標準輸入輸出定義*/
#include    <stdlib.h>     /*標準函數庫定義*/
#include    <unistd.h>     /*Unix 標準函數定義*/
#include    <fcntl.h>      /*檔控制定義*/
#include    <termios.h>    /*PPSIX 終端控制定義*/
#include    <errno.h>      /*錯誤號定義*/
#include 	<errno.h>
#include 	<string.h>
#include	<time.h>
#include	<ctype.h>
#include 	<ifaddrs.h>
#include 	<signal.h>
#include 	<net/if_arp.h>
#include	"../../define.h"
#include 	"Module_EvComm.h"
#include	"Config.h"

#define ARRAY_SIZE(A)				(sizeof(A) / sizeof(A[0]))
#define PASS						1
#define FAIL			   			-1
#define YES							1
#define NO							0
#define ON							1
#define OFF							0
#define true			    		1
#define false						0

struct SysConfigAndInfo				*ShmSysConfigAndInfo;

void PRINTF_FUNC(char *string, ...);

int StoreLogMsg(const char *fmt, ...);
#define DEBUG_INFO(format, args...) PRINTF_FUNC("[%s:%d][%s][Info] "format, __FILE__, __LINE__, __FUNCTION__, ##args)
#define DEBUG_WARN(format, args...) PRINTF_FUNC("[%s:%d][%s][Warn] "format, __FILE__, __LINE__, __FUNCTION__, ##args)
#define DEBUG_ERROR(format, args...) PRINTF_FUNC("[%s:%d][%s][Error] "format, __FILE__, __LINE__, __FUNCTION__, ##args)

int StoreLogMsg(const char *fmt, ...)
{
	char Buf[4096+256];
	char buffer[4096];
	va_list args;
	struct timeb  SeqEndTime;
	struct tm *tm;

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

	memset(Buf,0,sizeof(Buf));
	ftime(&SeqEndTime);
	SeqEndTime.time = time(NULL);
	tm=localtime(&SeqEndTime.time);

	if (ShmSysConfigAndInfo->SysConfig.SwitchDebugFlag == YES)
	{
		sprintf(Buf,"%02d:%02d:%02d:%03d - %s",
			tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm, buffer);
		printf("%s \n", Buf);
	}
	else
	{
		sprintf(Buf,"echo \"%04d-%02d-%02d %02d:%02d:%02d:%03d - %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,SeqEndTime.millitm,
			buffer,
			tm->tm_year+1900,tm->tm_mon+1);
		system(Buf);
	}

	return rc;
}

void PRINTF_FUNC(char *string, ...)
{
	va_list args;
	char buffer[4096];
	va_start(args, string);
	vsnprintf(buffer, sizeof(buffer), string, args);
	va_end(args);

	printf("%s \n", buffer);
}

void ShowSocketData(struct PACKET_STRUCTURE *packet)
{
	printf("se: %02X, id: %02X, op: %d, len: %3d, reg: %02X",
		packet->Header.se, packet->Header.id, packet->Header.op, packet->Header.len, packet->Payload.reg);

	if(packet->Header.len > 1)
	{
		printf(", Data:");
		for(int i = 0; i < packet->Header.len - 1; i++)
		{
			printf(" %02X", packet->Payload.data[i]);
		}
	}
	printf("\n");
}

//==========================================
// Init all share memory
//==========================================
int InitShareMemory()
{
	int result = PASS;
	int MeterSMId;

	//creat ShmSysConfigAndInfo
	if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo), IPC_CREAT | 0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmget ShmSysConfigAndInfo NG\n");
		#endif
		result = FAIL;
	}
	else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmat ShmSysConfigAndInfo NG\n");
		#endif
		result = FAIL;
	 }
	else
	{}
	/*
	//creat ShmStatusCodeData
	if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmget ShmStatusCodeData NG\n");
		#endif
		result = FAIL;
	}
	else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmat ShmStatusCodeData NG\n");
		#endif
		result = FAIL;
	}
	else
	{}

	//creat ShmOCPP16Data
	if ((MeterSMId = shmget(ShmOcppModuleKey, sizeof(struct OCPP16Data),  0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmget ShmOCPP16Data NG");
		#endif
		result = FAIL;
	}
	else if ((ShmOCPP16Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmat ShmOCPP16Data NG");
		#endif
		result = FAIL;
	}
	else
	{}

	//creat ShmPsuData
	if ((MeterSMId = shmget(ShmPsuKey, sizeof(struct PsuData),  0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmget ShmPsuData NG \n");
		#endif
		result = FAIL;
	}
	else if ((ShmPsuData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmat ShmPsuData NG \n");
		#endif
		result = FAIL;
	 }
	memset(ShmPsuData,0,sizeof(struct PsuData));
	*/
	return result;
}

//-------------------------------------------Socket Client Start-------------------------------------------
unsigned char seqNum = 0;

void sendCmdDispenserModelName(int socket, unsigned char se)
{
	struct PACKET_STRUCTURE sendBuffer;
	char *modelName = "DSYE601J0EW2PH";
	//char *modelName = "DSYE601J00W2PH";

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = se;
	sendBuffer.Header.id = 0xFF;
	sendBuffer.Header.op = _Header_Write;
	sendBuffer.Header.len = strlen(modelName) + 2;
	sendBuffer.Payload.reg = _Reg_Dispenser_Model_Name;
	memcpy(&sendBuffer.Payload.data[0], modelName, strlen(modelName));
	sendBuffer.Payload.data[strlen(modelName)] = 1;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void sendCmdDispenserConnectorIDRequest(int socket, unsigned char se)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = se;
	sendBuffer.Header.id = 0xFF;
	sendBuffer.Header.op = _Header_Read;
	sendBuffer.Header.len = 1;
	sendBuffer.Payload.reg = _Reg_Connector_ID;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void sendCmdPowerCabinetStatusRequest(int socket, unsigned char connector, unsigned char se)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = se;
	sendBuffer.Header.id = connector;
	sendBuffer.Header.op = _Header_Read;
	sendBuffer.Header.len = 1;
	sendBuffer.Payload.reg = _Reg_Power_Cabinet_Status;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void sendCmdWriteDispenserStatus(int socket, unsigned char connector, unsigned char se)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = se;
	sendBuffer.Header.id = connector;
	sendBuffer.Header.op = _Header_Write;
	sendBuffer.Header.len = 1;
	sendBuffer.Payload.reg = _Reg_Dispenser_Status;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void sendCmdReadChargingCapability(int socket, unsigned char connector, unsigned char se)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = se;
	sendBuffer.Header.id = connector;
	sendBuffer.Header.op = _Header_Read;
	sendBuffer.Header.len = 1;
	sendBuffer.Payload.reg = _Reg_Charging_Capability;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void sendCmdWriteChargingTarget(int socket, unsigned char connector, unsigned char se, unsigned short voltage, unsigned short current)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = se;
	sendBuffer.Header.id = connector;
	sendBuffer.Header.op = _Header_Write;
	sendBuffer.Header.len = 5;
	sendBuffer.Payload.reg = _Reg_Charging_Target;
	sendBuffer.Payload.data[0] = (voltage >> 8) & 0xFF;
	sendBuffer.Payload.data[1] = voltage & 0xFF;
	sendBuffer.Payload.data[2] = (current >> 8) & 0xFF;
	sendBuffer.Payload.data[3] = current & 0xFF;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void sendCmdWritePlugInStatus(int socket, unsigned char connector, unsigned char se)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = se;
	sendBuffer.Header.id = connector;
	sendBuffer.Header.op = _Header_Write;
	sendBuffer.Header.len = 2;
	sendBuffer.Payload.reg = _Reg_Plug_In_Status;
	sendBuffer.Payload.data[0] = se % 2 == 0 ?_PIS_UnPlugged : _PIS_PluggedIn;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void sendCmdWriteConnectorState(int socket, unsigned char connector, unsigned char se)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = se;
	sendBuffer.Header.id = connector;
	sendBuffer.Header.op = _Header_Write;
	sendBuffer.Header.len = 2;
	sendBuffer.Payload.reg = _Reg_Connector_State;
	sendBuffer.Payload.data[0] = _CRS_Idle;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void sendCmdWriteUserID(int socket, unsigned char connector, unsigned char se)
{
	struct PACKET_STRUCTURE sendBuffer;
	char *userID = "010203040506";

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = se;
	sendBuffer.Header.id = connector;
	sendBuffer.Header.op = _Header_Write;
	sendBuffer.Header.len = strlen(userID) + 1;
	sendBuffer.Payload.reg = _Reg_User_ID;
	memcpy(sendBuffer.Payload.data, userID, strlen(userID));

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void sendCmdReadChargingPermission(int socket, unsigned char connector, unsigned char se)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = se;
	sendBuffer.Header.id = connector;
	sendBuffer.Header.op = _Header_Read;
	sendBuffer.Header.len = 1;
	sendBuffer.Payload.reg = _Reg_Charging_Permission;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

int DispenserModelNameCheckIn(int socket, unsigned char se)
{
	int rxLen = 0, timeout = 0;
	struct PACKET_STRUCTURE receiveBuffer;
	int result = FAIL;

	sendCmdDispenserModelName(socket, se);
	while(1)
	{
		if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0)
		{
			if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH))
			{
				ShowSocketData(&receiveBuffer);

				if(receiveBuffer.Header.len == 2)
				{
					if(receiveBuffer.Payload.reg == _Reg_Dispenser_Model_Name && receiveBuffer.Payload.data[0] == _R_OK)
					{
						PRINTF_FUNC("Write Model Name OK");
						result = PASS;
						break;
					}
				}
			}
		}

		timeout += SOCKET_RECEIVE_INTERVAL;
		usleep((SOCKET_RECEIVE_INTERVAL * 1000));

		if(timeout >= DISPENSER_MODEL_NAME_RESEND)
		{
			//timeout
			break;
		}
	}

	return result;
}

int DispenserConnectorRequest(int socket, unsigned char se)
{
	int rxLen = 0, timeout = 0;
	struct PACKET_STRUCTURE receiveBuffer;
	int result = FAIL;

	sendCmdDispenserConnectorIDRequest(socket, se);
	while(1)
	{
		if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0)
		{
			if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH))
			{
				ShowSocketData(&receiveBuffer);

				if(receiveBuffer.Header.len == 4)
				{
					if(receiveBuffer.Payload.reg == _Reg_Connector_ID && receiveBuffer.Payload.data[0] == _R_OK)
					{
						PRINTF_FUNC("Get Connector ID: %02X, %02X", receiveBuffer.Payload.data[1], receiveBuffer.Payload.data[2]);
						result = PASS;
						break;
					}
				}
			}
		}

		timeout += SOCKET_RECEIVE_INTERVAL;
		usleep((SOCKET_RECEIVE_INTERVAL * 1000));

		if(timeout >= DISPENSER_CONNECTOR_RESEND)
		{
			//timeout
			break;
		}
	}

	return result;
}

int DispenserReadPowerCabinetStatus(int socket, unsigned char connector, unsigned char se)
{
	int rxLen = 0, timeout = 0;
	struct PACKET_STRUCTURE receiveBuffer;
	int result = FAIL;

	sendCmdPowerCabinetStatusRequest(socket, connector, se);
	while(1)
	{
		if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0)
		{
			if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH))
			{
				ShowSocketData(&receiveBuffer);

				if(receiveBuffer.Payload.reg == _Reg_Power_Cabinet_Status && receiveBuffer.Payload.data[0] == _R_OK)
				{
					PRINTF_FUNC("Get Cabinet Status Code, Len: %d", (receiveBuffer.Header.len - 2) / 6);
					result = PASS;
				}
			}
		}

		timeout += SOCKET_RECEIVE_INTERVAL;
		usleep((SOCKET_RECEIVE_INTERVAL * 1000));

		if(timeout >= CABINET_STATUS_REQUEST_RESEND)
		{
			//timeout
			break;
		}
	}

	return result;
}

int DispenserWriteStatusCode(int socket, unsigned char connector, unsigned char se)
{
	int rxLen = 0, timeout = 0;
	struct PACKET_STRUCTURE receiveBuffer;
	int result = FAIL;

	sendCmdWriteDispenserStatus(socket, connector, se);
	while(1)
	{
		if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0)
		{
			if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH))
			{
				ShowSocketData(&receiveBuffer);

				if(receiveBuffer.Header.len == 2)
				{
					if(receiveBuffer.Payload.reg == _Reg_Dispenser_Status && receiveBuffer.Payload.data[0] == _R_OK)
					{
						PRINTF_FUNC("Write Dispenser Status Code OK");
						result = PASS;
					}
				}
			}
		}

		timeout += SOCKET_RECEIVE_INTERVAL;
		usleep((SOCKET_RECEIVE_INTERVAL * 1000));

		if(timeout >= CABINET_STATUS_REQUEST_RESEND)
		{
			//timeout
			break;
		}
	}

	return result;
}

int DispenserReadChargingCapability(int socket, unsigned char connector, unsigned char se)
{
	int rxLen = 0, timeout = 0;
	struct PACKET_STRUCTURE receiveBuffer;
	int result = FAIL;
	unsigned short voltage = 0, current = 0, power = 0;

	sendCmdReadChargingCapability(socket, connector, se);
	while(1)
	{
		if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0)
		{
			if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH))
			{
				ShowSocketData(&receiveBuffer);

				if(receiveBuffer.Header.len == 8)
				{
					if(receiveBuffer.Payload.reg == _Reg_Charging_Capability && receiveBuffer.Payload.data[0] == _R_OK)
					{
						voltage = (receiveBuffer.Payload.data[1] << 8) + receiveBuffer.Payload.data[2];
						current = (receiveBuffer.Payload.data[3] << 8) + receiveBuffer.Payload.data[4];
						power = (receiveBuffer.Payload.data[5] << 8) + receiveBuffer.Payload.data[6];

						PRINTF_FUNC("Capability Voltage: %d.%dV, Current: %d.%dA, Power: %d.%dkW",
							voltage / 10, voltage % 10, current / 10, current % 10, power / 10, power % 10);
						result = PASS;
					}
				}
			}
		}

		timeout += SOCKET_RECEIVE_INTERVAL;
		usleep((SOCKET_RECEIVE_INTERVAL * 1000));

		if(timeout >= CHARGING_CAPABILITY_RESEND)
		{
			//timeout
			break;
		}
	}

	return result;
}

int DispenserWriteChargingTarget(int socket, unsigned char connector, unsigned char se)
{
	int rxLen = 0, timeout = 0;
	struct PACKET_STRUCTURE receiveBuffer;
	int result = FAIL;

	sendCmdWriteChargingTarget(socket, connector, se, 7505, 406);
	while(1)
	{
		if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0)
		{
			if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH))
			{
				ShowSocketData(&receiveBuffer);

				if(receiveBuffer.Header.len == 2)
				{
					if(receiveBuffer.Payload.reg == _Reg_Charging_Target && receiveBuffer.Payload.data[0] == _R_OK)
					{
						PRINTF_FUNC("Write Charging Target OK");
						result = PASS;
					}
				}
			}
		}

		timeout += SOCKET_RECEIVE_INTERVAL;
		usleep((SOCKET_RECEIVE_INTERVAL * 1000));

		if(timeout >= CHARGING_CAPABILITY_RESEND)
		{
			//timeout
			break;
		}
	}

	return result;
}

int DispenserWritePlugInStatus(int socket, unsigned char connector, unsigned char se)
{
	int rxLen = 0, timeout = 0;
	struct PACKET_STRUCTURE receiveBuffer;
	int result = FAIL;

	sendCmdWritePlugInStatus(socket, connector, se);
	while(1)
	{
		if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0)
		{
			if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH))
			{
				ShowSocketData(&receiveBuffer);

				if(receiveBuffer.Header.len == 2)
				{
					if(receiveBuffer.Payload.reg == _Reg_Plug_In_Status && receiveBuffer.Payload.data[0] == _R_OK)
					{
						PRINTF_FUNC("Write Plug In Status OK");
						result = PASS;
					}
				}
			}
		}

		timeout += SOCKET_RECEIVE_INTERVAL;
		usleep((SOCKET_RECEIVE_INTERVAL * 1000));

		if(timeout >= CHARGING_CAPABILITY_RESEND)
		{
			//timeout
			break;
		}
	}

	return result;
}

int DispenserWriteConnectorState(int socket, unsigned char connector, unsigned char se)
{
	int rxLen = 0, timeout = 0;
	struct PACKET_STRUCTURE receiveBuffer;
	int result = FAIL;

	sendCmdWriteConnectorState(socket, connector, se);
	while(1)
	{
		if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0)
		{
			if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH))
			{
				ShowSocketData(&receiveBuffer);

				if(receiveBuffer.Header.len == 2)
				{
					if(receiveBuffer.Payload.reg == _Reg_Connector_State && receiveBuffer.Payload.data[0] == _R_OK)
					{
						PRINTF_FUNC("Write Connector State OK");
						result = PASS;
					}
				}
			}
		}

		timeout += SOCKET_RECEIVE_INTERVAL;
		usleep((SOCKET_RECEIVE_INTERVAL * 1000));

		if(timeout >= CHARGING_CAPABILITY_RESEND)
		{
			//timeout
			break;
		}
	}

	return result;
}

int DispenserWriteUserID(int socket, unsigned char connector, unsigned char se)
{
	int rxLen = 0, timeout = 0;
	struct PACKET_STRUCTURE receiveBuffer;
	int result = FAIL;

	sendCmdWriteUserID(socket, connector, se);
	while(1)
	{
		if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0)
		{
			if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH))
			{
				ShowSocketData(&receiveBuffer);

				if(receiveBuffer.Header.len == 2)
				{
					if(receiveBuffer.Payload.reg == _Reg_User_ID && receiveBuffer.Payload.data[0] == _R_OK)
					{
						PRINTF_FUNC("Write User ID OK");
						result = PASS;
					}
				}
			}
		}

		timeout += SOCKET_RECEIVE_INTERVAL;
		usleep((SOCKET_RECEIVE_INTERVAL * 1000));

		if(timeout >= CHARGING_CAPABILITY_RESEND)
		{
			//timeout
			break;
		}
	}

	return result;
}

int DispenserReadChargingPermission(int socket, unsigned char connector, unsigned char se)
{
	int rxLen = 0, timeout = 0;
	struct PACKET_STRUCTURE receiveBuffer;
	int result = FAIL;

	sendCmdReadChargingPermission(socket, connector, se);
	while(1)
	{
		if((rxLen = recv(socket, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0)
		{
			if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH))
			{
				ShowSocketData(&receiveBuffer);

				if(receiveBuffer.Header.len == 3)
				{
					if(receiveBuffer.Payload.reg == _Reg_Charging_Permission && receiveBuffer.Payload.data[0] == _R_OK)
					{
						PRINTF_FUNC("Charging Permission: %s", receiveBuffer.Payload.data[1] == _PS_Permitted ? "Permitted" : "Not Permitted");
						result = PASS;
					}
				}
			}
		}

		timeout += SOCKET_RECEIVE_INTERVAL;
		usleep((SOCKET_RECEIVE_INTERVAL * 1000));

		if(timeout >= CHARGING_CAPABILITY_RESEND)
		{
			//timeout
			break;
		}
	}

	return result;
}

void tcpSocketClientStart(void)
{
	struct sockaddr_in 	info;
	struct timeval 		tv;
	uint8_t 			socketEnable;
	int 				sockfd = 0;
	unsigned char clientStatus = 0;
	unsigned char se = 0;

	//start dhcp client
	//udhcpc -i eth1 --script /root/dhcp_script/eth1.script
	//udhcpc -i eth1 -s /root/dhcp_script/eth1.script &
	//udhcpc -i eth0 -x hostname CSU3_DSYE601J0EW2PH-SERIALFORRD -s /root/dhcp_script/eth0.script
	for(;;)
	{
		bzero(&info,sizeof(info));
		info.sin_family = PF_INET;
		info.sin_addr.s_addr = inet_addr(SOCKET_SERVER_IP);
		info.sin_port = htons(TCP_LISTEN_PORT);

		sockfd = socket(AF_INET, SOCK_STREAM, 0);
		if (sockfd == -1)
		{
			PRINTF_FUNC("Fail to create a socket.");
			return;
		}
		PRINTF_FUNC("TCP Client Start");

		if(connect(sockfd, (struct sockaddr *)&info, sizeof(info)) == -1)
		{
			PRINTF_FUNC("Connection error");
		}
		else
		{
			PRINTF_FUNC("Connect to %s success", inet_ntoa(info.sin_addr));
			tv.tv_sec = 0;
			tv.tv_usec = 500000;
			setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (const char*)&tv, sizeof tv);
			socketEnable = ON;
		}

		while(socketEnable)
		{
			switch(clientStatus)
			{
				case 0:
					//5.1 Dispenser model name
					if(DispenserModelNameCheckIn(sockfd, se++) == PASS)
					{
						clientStatus = 1;
					}
					break;
				case 1:
					if(DispenserConnectorRequest(sockfd, se++) == PASS)
					{
						clientStatus = 2;
					}
					break;
				case 2:
					if(DispenserReadPowerCabinetStatus(sockfd, 0x01, se++) == PASS)
					{
						if(DispenserWriteStatusCode(sockfd, 0x01, se++) == PASS)
						{
							clientStatus = 3;
						}
					}
					break;
				case 3:
					if(DispenserWriteUserID(sockfd, 0x01, se++) == PASS)
					{
						clientStatus = 4;
					}
					break;
				case 4:
					if(DispenserReadChargingCapability(sockfd, 0x01, se++) == PASS)
					{

					}
					if(DispenserWriteChargingTarget(sockfd, 0x01, se++) == PASS)
					{

					}
					if(DispenserWritePlugInStatus(sockfd, 0x01, se++) == PASS)
					{

					}
					if(DispenserWriteConnectorState(sockfd, 0x01, se++) == PASS)
					{

					}
					if(DispenserReadChargingPermission(sockfd, 0x01, se++) == PASS)
					{

					}
					break;
				default:
					break;
			}
		}
		close(sockfd);
		sleep(5);
		return;
	}
}

//--------------------------------------------Socket Client End--------------------------------------------

BOOL IsAvalibleGunType(char name, unsigned char *type)
{
	char modelList[6] = {'J', 'U', 'E', 'G', 'V', 'F'};
	unsigned char typeList[6] = {0, 1, 1, 2, 1, 1};		// 0 : Chademo, 1: CCS, 2: GB

	for(int i = 0; i < 6; i++)
	{
		if(name == modelList[i])
		{
			*type = typeList[i];
			return true;
		}
	}
	return false;
}

unsigned char ConnectorQuantityTypeParsing(unsigned char *modelName, unsigned char *type)
{
	unsigned char quantity = 0;

	for(int i = 0; i < 3; i++)
	{
		if(IsAvalibleGunType(modelName[7 + i], type))
		{
			if(quantity < 2)
			{
				quantity++;
			}
			else
			{
				quantity = 0;
				break;
			}
		}
	}
	return quantity;
}

void ModelNameResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = packet->Header.se;
	sendBuffer.Header.id = 0xFF;
	sendBuffer.Header.op = _Header_Response;
	sendBuffer.Header.len = 2;
	sendBuffer.Payload.reg = _Reg_Dispenser_Model_Name;
	sendBuffer.Payload.data[0] = result;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void ConnectorIDResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result, unsigned char dispenserIndex)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = packet->Header.se;
	sendBuffer.Header.id = 0xFF;
	sendBuffer.Header.op = _Header_Response;
	sendBuffer.Header.len = 4;
	sendBuffer.Payload.reg = _Reg_Connector_ID;
	sendBuffer.Payload.data[0] = result;
	sendBuffer.Payload.data[1] = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[0];
	sendBuffer.Payload.data[2] = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[1];

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void PowerCabinetStatusResponse(int socket, struct PACKET_STRUCTURE *packet)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = packet->Header.se;
	sendBuffer.Header.id = packet->Header.id;
	sendBuffer.Header.op = _Header_Response;
	sendBuffer.Header.len = 2;
	sendBuffer.Payload.reg = _Reg_Power_Cabinet_Status;
	sendBuffer.Payload.data[0] = _R_OK;

	if(ShmSysConfigAndInfo->SysWarningInfo.WarningCount > 0)
	{
		sendBuffer.Header.len += (ShmSysConfigAndInfo->SysWarningInfo.WarningCount * 6);
		for(int i = 0; i < ShmSysConfigAndInfo->SysWarningInfo.WarningCount; i++)
		{
		    memcpy(&sendBuffer.Payload.data[1 + (i * 6)], &ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][0], 6);
		    if(ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][1] == '1')
		    {
		        sendBuffer.Payload.data[1 + (i * 6) + 1] = '4';
		    }
		}
	}

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void DispenserStatusResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = packet->Header.se;
	sendBuffer.Header.id = packet->Header.id;
	sendBuffer.Header.op = _Header_Response;
	sendBuffer.Header.len = 2;
	sendBuffer.Payload.reg = _Reg_Dispenser_Status;
	sendBuffer.Payload.data[0] = result;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void ChargingCapabilityResponse(int socket, struct PACKET_STRUCTURE *packet)
{
	struct PACKET_STRUCTURE sendBuffer;
	unsigned short voltage = 0, current = 0, power = 0;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	voltage = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.MaximumChargingVoltage;
	current = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.AvailableChargingCurrent;
	power = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.AvailableChargingPower;

	PRINTF_FUNC("Connector %d Capability Voltage: %d, Current: %d, Power: %d", packet->Header.id, (int)(voltage), (int)(current), (int)(power));

	sendBuffer.Header.se = packet->Header.se;
	sendBuffer.Header.id = packet->Header.id;
	sendBuffer.Header.op = _Header_Response;
	sendBuffer.Header.len = 8;
	sendBuffer.Payload.reg = _Reg_Charging_Capability;
	sendBuffer.Payload.data[0] = _R_OK;
	sendBuffer.Payload.data[1] = ((voltage >> 8) & 0xFF);
	sendBuffer.Payload.data[2] = (voltage & 0xFF);
	sendBuffer.Payload.data[3] = ((current >> 8) & 0xFF);
	sendBuffer.Payload.data[4] = (current & 0xFF);
	sendBuffer.Payload.data[5] = ((power >> 8) & 0xFF);
	sendBuffer.Payload.data[6] = (power & 0xFF);

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void ChargingTargetResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = packet->Header.se;
	sendBuffer.Header.id = packet->Header.id;
	sendBuffer.Header.op = _Header_Response;
	sendBuffer.Header.len = 2;
	sendBuffer.Payload.reg = _Reg_Charging_Target;
	sendBuffer.Payload.data[0] = result;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void PlugInStatusResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = packet->Header.se;
	sendBuffer.Header.id = packet->Header.id;
	sendBuffer.Header.op = _Header_Response;
	sendBuffer.Header.len = 2;
	sendBuffer.Payload.reg = _Reg_Plug_In_Status;
	sendBuffer.Payload.data[0] = result;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void ConnectorStateResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = packet->Header.se;
	sendBuffer.Header.id = packet->Header.id;
	sendBuffer.Header.op = _Header_Response;
	sendBuffer.Header.len = 2;
	sendBuffer.Payload.reg = _Reg_Connector_State;
	sendBuffer.Payload.data[0] = result;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void UserIDResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = packet->Header.se;
	sendBuffer.Header.id = packet->Header.id;
	sendBuffer.Header.op = _Header_Response;
	sendBuffer.Header.len = 3;
	sendBuffer.Payload.reg = _Reg_User_ID;
	sendBuffer.Payload.data[0] = result == _DAS_Wait ? _R_NG : _R_OK;
	sendBuffer.Payload.data[1] = result == _DAS_Allowed ? _PS_Permitted : _PS_NotPermitted;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

void ChargingPermissionResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char result)
{
	struct PACKET_STRUCTURE sendBuffer;

	memset(&sendBuffer, 0x00, sizeof(sendBuffer));
	sendBuffer.Header.se = packet->Header.se;
	sendBuffer.Header.id = packet->Header.id;
	sendBuffer.Header.op = _Header_Response;
	sendBuffer.Header.len = 3;
	sendBuffer.Payload.reg = _Reg_Charging_Permission;
	sendBuffer.Payload.data[0] = result == _DAS_Wait ? _R_NG : _R_OK;
	sendBuffer.Payload.data[1] = result == _DAS_Allowed ? _PS_Permitted : _PS_NotPermitted;

	send(socket, &sendBuffer, sendBuffer.Header.len + 4, 0);
}

BOOL FindConnectorID(unsigned char dispenserIndex, unsigned char id)
{
	BOOL find = false;

	for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorQuantity; i++)
	{
		if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[i] == id)
		{
			find = true;
			break;
		}
	}

	return find;
}

void ConnectorTypeBindingHandler(unsigned char dispenserIndex, unsigned char *type)
{
	for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorQuantity; i++)
	{
		unsigned char gunIndex = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[i] - 1;
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].ParentDispensetIndex = dispenserIndex;
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].GeneralChargingData.Type = type[i];
	}
}

BOOL IsAvailableDispenserIndexSequence(unsigned char index)
{
	if((ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status & (1 << index)) > 0)
	{
		// dispenser ever checkin
		return true;
	}
	else
	{
		for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
		{
			if(i == index)
			{
				return true;
			}

			if((ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status & (1 << index)) == 0)
			{
				// i is not check in yet before index
				return false;
			}
		}
	}
	return false;
}

void DispenserCheckInInfoUpdate(void)
{
	unsigned char dispenser = 0, connector = 0;
	BOOL change = false;

	for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
	{
		if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_None &&
			ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_Timeout)
		{
			dispenser++;
			ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status |= (1 << i);
			ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[i] = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity;
			connector += ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity;
		}
	}

	if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity != dispenser ||
		ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity != connector)
	{
		change = true;
	}
	ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity = dispenser;
	ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity = connector;

	if(change)
	{
		PRINTF_FUNC("Total Dispenser: %d, Total Connector: %d",
			ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity,
			ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity);
	}
}

void SetConnectorID(unsigned char dispenserIndex, unsigned char quantity)
{
	unsigned char currentQuantity = 0;

	ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[0] = 0x00;
	ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[1] = 0x00;

	for(int i = 0; i < dispenserIndex; i++)
	{
		currentQuantity += ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[i];
	}

	for(int i = 0; i < quantity; i++)
	{
		currentQuantity++;
		ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[i] = currentQuantity;
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[currentQuantity - 1].Enable = true;
	}
}

BOOL DispenserIdentificationHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex, unsigned char *modelName)
{
	unsigned char quantity = 0;

	unsigned char connectorType[2] = {0, 0};

	quantity = ConnectorQuantityTypeParsing(modelName, connectorType);

	if(quantity > 0)
	{
		if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus == _DS_Timeout &&
			quantity != ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[dispenserIndex])
		{
			PRINTF_FUNC("The same dispenser id (%d) but connector quantity not match", dispenserIndex + 1);
			return false;
		}
		if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus == _DS_None ||
			ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus == _DS_Timeout)
		{
			ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus = _DS_Identification;
			ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorQuantity = quantity;
			ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[dispenserIndex] = quantity;
			SetConnectorID(dispenserIndex, quantity);
			memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ModelName, packet->Payload.data, (packet->Header.len - 2));

			ConnectorTypeBindingHandler(dispenserIndex, connectorType);

			PRINTF_FUNC("Dispenser id %d identified, Connector: %d, ID: %d, %d", dispenserIndex + 1, quantity,
				ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[0],
				ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[1]);

			DispenserCheckInInfoUpdate();

			return true;
		}
		else
		{
			PRINTF_FUNC("Conflict dispenser ID: %d", dispenserIndex + 1);
		}
	}
	else
	{
		PRINTF_FUNC("Connector quantity fail, model name: %s", modelName);
	}
	return false;
}

BOOL DispenserStatusCodeHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
	BOOL find = FindConnectorID(dispenserIndex, packet->Header.id);

	if(find)
	{
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount = (packet->Header.len - 1) / 6;
		if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount > 10)
		{
			ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount = 10;
		}

		for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount; i++)
		{
			memcpy(&ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCode[i][0],
				&packet->Payload.data[i * 6], 6);
		}

		PRINTF_FUNC("Dispenser %d, Status Code Len: %d", packet->Header.id, ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount);
	}
	else
	{

	}

	return find;
}

BOOL ConnectorChargingCapabilityHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
    BOOL find = FindConnectorID(dispenserIndex, packet->Header.id);
    BOOL done = false;

    if(find)
    {
        done = true;
    }

    return done;
}

unsigned long GetTimeoutValue(struct timeval _sour_time)
{
    struct timeval _end_time;
    gettimeofday(&_end_time, NULL);

    return 1000000 * (_end_time.tv_sec - _sour_time.tv_sec) + _end_time.tv_usec - _sour_time.tv_usec;
}

struct timeval _ConnectorCapabilityTime[CONNECTOR_QUANTITY];

BOOL ConnectorChargingTargetHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
	BOOL find = FindConnectorID(dispenserIndex, packet->Header.id);
	BOOL done = false;
	float voltage = 0, current = 0;

	if(find)
	{
		voltage = (float)((packet->Payload.data[0] << 8) + packet->Payload.data[1]) / 10;
		current = (float)((packet->Payload.data[2] << 8) + packet->Payload.data[3]) / 10;

//        if(GetTimeoutValue(_ConnectorCapabilityTime[packet->Header.id - 1]) / 1000 >= 2000)
//        {
//            gettimeofday(&_ConnectorCapabilityTime[packet->Header.id - 1], NULL);
//            ShowSocketData(packet);
//        }

		if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus == S_CHARGING)
		{
			if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetVoltage != voltage ||
				ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetCurrent != current)
			{
				PRINTF_FUNC("Connector %d Target Voltage: %d, Current: %d", packet->Header.id, (int)(voltage * 10), (int)(current * 10));
			}

			ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetVoltage = (float)voltage;
			ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetCurrent = (float)current;

			done = true;
		}
		else
		{
			if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetVoltage != 0 ||
				ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetCurrent != 0)
			{
				PRINTF_FUNC("Connector %d Not Charging Status, Set Voltage & Current Fail", packet->Header.id);
			}
			ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetVoltage = 0;
			ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetCurrent = 0;
		}
	}
	else
	{

	}

	return done;
}

BOOL ConnectorPlugInHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
	BOOL find = FindConnectorID(dispenserIndex, packet->Header.id);

	if(find)
	{
		if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.ConnectorPlugIn != packet->Payload.data[0])
		{
			PRINTF_FUNC("Connector %d %s", packet->Header.id, packet->Payload.data[0] == _PIS_PluggedIn ? "Pluged In" : "Un Plugged");
		}
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.ConnectorPlugIn = packet->Payload.data[0];
	}
	else
	{

	}

	return find;
}

BOOL ConnectorStateHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
	BOOL find = FindConnectorID(dispenserIndex, packet->Header.id);

	if(find)
	{
		if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus != packet->Payload.data[0])
		{
			PRINTF_FUNC("Connector %d Remote Status: %d", packet->Header.id, packet->Payload.data[0]);

			if((packet->Payload.data[0] == _CRS_Idle && ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus != _CRS_Terminating) ||
				packet->Payload.data[0] == _CRS_Terminating)
			{
			    PRINTF_FUNC("*********** Connector id %d Set Stop Flag ***********\n", packet->Header.id);
				ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.StopChargeFlag = true;
			}
		}
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus = packet->Payload.data[0];
	}
	else
	{

	}

	return true;
}

unsigned char UserIDHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
	DispenserAck_Status authorize = _DAS_Wait;

	if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].AuthorizeStatus == _AuthorizeStatus_Idle)
	{
	    if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.AuthorizeRequest)
	    {
	        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.AuthorizeRequest = false;
	    }
	    memset(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].UserId, 0x00, 32);
	    memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].UserId, packet->Payload.data, packet->Header.len - 1);

	    PRINTF_FUNC("Dispenser id %d user id %s need authorize", dispenserIndex + 1, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].UserId);
        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.AuthorizeRequest = true;
        authorize = _DAS_Wait;
	}
	else if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].AuthorizeStatus == _AuthorizeStatus_Fail)
	{
	    PRINTF_FUNC("Dispenser id %d user id %s authorizing fail", dispenserIndex + 1, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].UserId);
	    authorize = _DAS_NotAllowed;
	}
	else if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].AuthorizeStatus == _AuthorizeStatus_Pass)
	{
	    PRINTF_FUNC("Dispenser id %d user id %s authorizing ok", dispenserIndex + 1, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].UserId);
	    authorize = _DAS_Allowed;
	}
	else
	{
	    authorize = _DAS_Wait;
	}

	return authorize;
}

unsigned char ChargingPermissionHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
	BOOL find = FindConnectorID(dispenserIndex, packet->Header.id);
	DispenserAck_Status permission = _DAS_Wait;

	if(find)
	{
	    switch(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus)
	    {
            case S_PREPARING_FOR_EV:
                if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus >= _CRS_Preparing &&
                    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus <= _CRS_Charging)
                {

                    if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.PermissionRequest)
                    {
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.PermissionRequest = true;
                        PRINTF_FUNC("Allow dispenser index %d connector id %d start to charge", dispenserIndex, packet->Header.id);
                    }
                    permission = _DAS_Allowed;
                }
                else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Terminating)
                {
                    permission = _DAS_NotAllowed;
                    PRINTF_FUNC("Allow dispenser index %d connector id %d start to charge", dispenserIndex, packet->Header.id);
                }
                else
                {
                    // keep wait
                }
                break;
            case S_CHARGING:
                if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Preparing ||
                    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Charging)
                {
                    permission = _DAS_Allowed;
                }
                else
                {
                    permission = _DAS_NotAllowed;
                    PRINTF_FUNC("Dispenser index %d connector id %d remote status not in charging mode", dispenserIndex, packet->Header.id);
                }
                break;
            default:
                break;
	    }
	}
	else
	{
	    PRINTF_FUNC("Dispenser index %d Connector id %d not found", dispenserIndex, packet->Header.id);
	    permission = _DAS_NotAllowed;
	}

//	PRINTF_FUNC("Dispenser %d Permission %s, Gun Status: %d, Connector Status: %d, Wait Plug: %d, PlugIn: %d, Available: %d, Order: %d", dispenserIndex, permission == true ? "OK" : "NG",
//		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus,
//		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus,
//		ShmSysConfigAndInfo->SysInfo.WaitForPlugit,
//		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.ConnectorPlugIn,
//		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.IsAvailable,
//		ShmSysConfigAndInfo->SysInfo.OrderCharging);

	return permission;
}

void DisableConnector(unsigned char dispenserIndex)
{
	for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorQuantity; i++)
	{
		unsigned char connector = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[i] - 1;
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Enable = false;
	}
}

void DispenserSocketProcess(int socketFd, struct sockaddr_in clientInfo, unsigned char index)
{
	int rxLen = 0, timeout = 0;
	unsigned char dispenserID = 0, dispenserIndex = 0;
	struct PACKET_STRUCTURE receiveBuffer;
	unsigned char modelName[64];
	unsigned char ackResult = _R_NG;
	DispenserAck_Status ack = _DAS_Wait;

	PRINTF_FUNC("IP %s connection(%d) is established, start dispenser process", (inet_ntoa(clientInfo.sin_addr)), index);

	for(int i = 0; i < CONNECTOR_QUANTITY; i++)
	{
	    memset(&_ConnectorCapabilityTime[i], 0x00, sizeof(struct timeval));
	}

	while(1)
	{
		if((rxLen = recv(socketFd, &receiveBuffer, sizeof(Packet_Structure), MSG_DONTWAIT )) > 0)
		{
			if(rxLen == (receiveBuffer.Header.len + PACKET_HEADER_LENGTH))
			{
				ackResult = _R_NG;
				//ShowSocketData(&receiveBuffer);

				if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[index].Status == _CNS_WaitModelName)
				{
				    // Reg: 0x01, Dispenser model name
					if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Dispenser_Model_Name)
					{
						memset(modelName, 0x00, 64);
						dispenserID = receiveBuffer.Payload.data[receiveBuffer.Header.len - 2];

						if(dispenserID > 0 && dispenserID <= GENERAL_GUN_QUANTITY)
						{
						    dispenserIndex = dispenserID - 1;
						    memcpy(modelName, receiveBuffer.Payload.data, receiveBuffer.Header.len - 2);

	                        if(IsAvailableDispenserIndexSequence(dispenserIndex))
	                        {
	                            if(DispenserIdentificationHandler(&receiveBuffer, dispenserIndex, modelName) == true)
	                            {
	                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[index].DispenserIndex = dispenserIndex;
	                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[index].Status = _CNS_DispenserMatched;
	                                PRINTF_FUNC("Dispenser id %d check in, model name: %s", dispenserID, modelName);
	                                ackResult = _R_OK;
	                            }
	                            else
	                            {
	                                // response NG: gun quantity fail
	                                PRINTF_FUNC("Dispenser ID %d Identification Fail", dispenserID);
	                            }
	                        }
	                        else
	                        {
	                            // response NG: dispenser Index fail
	                            PRINTF_FUNC("Dispenser ID %d Fail, Need Wait Another Dispenser", dispenserID);
	                        }
						}
						else
						{
						    PRINTF_FUNC("Dispenser ID: %d Over Range", dispenserID);
						}

						ModelNameResponse(socketFd, &receiveBuffer, ackResult);
					}
					else
					{
						// do nothing
					}
				}
				else if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[index].Status == _CNS_DispenserMatched)
				{
				    // Reg: 0x01, Dispenser model name
					if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Dispenser_Model_Name)
					{
						ackResult = _R_OK;
						ModelNameResponse(socketFd, &receiveBuffer, ackResult);
					}

					// Reg: 0x02, Connector ID
					if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Connector_ID)
					{
						if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorQuantity > 0)
						{
							ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus = _DS_Idle;
							ackResult = _R_OK;
						}
						PRINTF_FUNC("Dispenser ID %d Get Connector ID %s", dispenserID, ackResult == _R_OK ? "OK" : "NG");
						ConnectorIDResponse(socketFd, &receiveBuffer, ackResult, dispenserIndex);
					}

					// Reg: 0x03, Power cabinet status
					if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Power_Cabinet_Status)
					{
						PowerCabinetStatusResponse(socketFd, &receiveBuffer);
					}

					// Reg: 0x04, Dispenser status
					if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Dispenser_Status)
					{
						if(DispenserStatusCodeHandler(&receiveBuffer, dispenserIndex))
						{
							ackResult = _R_OK;
						}
						DispenserStatusResponse(socketFd, &receiveBuffer, ackResult);
					}

					// Reg: 0x05, Charging capability
					if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Charging_Capability)
					{
					    if(ConnectorChargingCapabilityHandler(&receiveBuffer, dispenserIndex))
					    {
					        ChargingCapabilityResponse(socketFd, &receiveBuffer);
					    }
					}

					// Reg: 0x06, Charging target
					if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Charging_Target)
					{
						if(receiveBuffer.Header.len == 5)
						{
							if(ConnectorChargingTargetHandler(&receiveBuffer, dispenserIndex))
							{
								ackResult = _R_OK;
							}
						}
						ChargingTargetResponse(socketFd, &receiveBuffer, ackResult);
					}

					// Reg: 0x07, Software update

					// Reg: 0x08, Plug-in status
					if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Plug_In_Status)
					{
						if(receiveBuffer.Header.len == 2)
						{
							if(ConnectorPlugInHandler(&receiveBuffer, dispenserIndex))
							{
								ackResult = _R_OK;
							}
						}
						PlugInStatusResponse(socketFd, &receiveBuffer, ackResult);
					}

					// Reg: 0x09, Connector state
					if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Connector_State)
					{
						if(ConnectorStateHandler(&receiveBuffer, dispenserIndex))
						{
							ackResult = _R_OK;
						}
						ConnectorStateResponse(socketFd, &receiveBuffer, ackResult);
					}

					// Reg: 0x0A, User ID
					if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_User_ID)
					{
					    ack = UserIDHandler(&receiveBuffer, dispenserIndex);

						UserIDResponse(socketFd, &receiveBuffer, ack);
					}

					// Reg: 0x0B, Charging permission
					if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Charging_Permission)
					{
					    ack = ChargingPermissionHandler(&receiveBuffer, dispenserIndex);

						ChargingPermissionResponse(socketFd, &receiveBuffer, ack);
					}
				}

				// clean timeout
				timeout = 0;
			}
		}
		else
		{
			timeout += SOCKET_RECEIVE_INTERVAL;
			usleep((SOCKET_RECEIVE_INTERVAL * 1000));
		}

		if(timeout >= DISPENSER_SOCKET_TIMEOUT)
		{
			//timeout
			PRINTF_FUNC("IP: %s, Socket %d connection timeout", (inet_ntoa(clientInfo.sin_addr)), index);
			if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[index].Status == _CNS_DispenserMatched)
			{
				DisableConnector(dispenserIndex);

				memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex], 0x00, sizeof(struct DispenserModule));
				ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus = _DS_Timeout;

				DispenserCheckInInfoUpdate();
			}
			break;
		}
	}
}


int GetMacAddress(int sockFd, unsigned char *mac)
{
	struct arpreq arpReq;
	struct sockaddr_in clientInfo;
	socklen_t len = sizeof(struct sockaddr_in);

	memset(mac, 0x00, 6);

	if(getpeername(sockFd, (struct sockaddr*)&clientInfo, &len) < 0)
	{
		return 0;
	}
    else
	{
		memcpy(&arpReq.arp_pa, &clientInfo, sizeof(struct sockaddr_in));
		strcpy(arpReq.arp_dev, "eth1");
		arpReq.arp_pa.sa_family = AF_INET;
		arpReq.arp_ha.sa_family = AF_UNSPEC;
		if(ioctl(sockFd, SIOCGARP, &arpReq) < 0)
		{
			return 0;
		}
		else
		{
			memcpy(mac, arpReq.arp_ha.sa_data, 6);
		}
	}

	return 1;
}

int FindFreeChannel(void)
{
	for(int i = 0; i < MAXIMUM_CONNECT_QUANTITY; i++)
	{
		if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].Status == _CNS_FREE)
		{
			return i;
		}
	}
	return FAIL;
}

BOOL IsConflictIp(uint32_t ipAddress)
{
	for(int i = 0; i < MAXIMUM_CONNECT_QUANTITY; i++)
	{
		if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].IpAddress == ipAddress)
		{
			return true;
		}
	}
	return false;
}

void InitDispenserInfo(void)
{
	for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
	{
		memset(&ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i], 0x00, sizeof(struct ConnectorInfoData));
	}
	memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo, 0x00, sizeof(struct DispenserInfoData));
}

void tcpSocketServerStart(void)
{
	int sockFd = 0;
	int clientSockFd = 0;
	int connectIndex = 0;
	pid_t forkId;

	struct sockaddr_in 	serverInfo, clientInfo;
	socklen_t 			addrlen = sizeof(clientInfo);
	//struct timeval      timeout = {3, 0};

	sockFd = socket(AF_INET, SOCK_STREAM, 0);
	if(sockFd == -1)
	{
		PRINTF_FUNC("InitSocketServer NG\n");
		sleep(5);
		return;
	}

	InitDispenserInfo();

	bzero(&serverInfo,sizeof(serverInfo));
	serverInfo.sin_family = PF_INET;
	serverInfo.sin_addr.s_addr = htonl(INADDR_ANY);
	serverInfo.sin_port = htons(TCP_LISTEN_PORT);
	bind(sockFd, (struct sockaddr *)&serverInfo, sizeof(serverInfo));
	listen(sockFd, CONNECTION_LIMIT);

	PRINTF_FUNC("TCP Server Start\n");

	signal(SIGCHLD, SIG_IGN);
	// Main loop
	while(1)
	{
		clientSockFd = accept(sockFd, (struct sockaddr*) &clientInfo, &addrlen);
		PRINTF_FUNC("Client ip: %s is accepted at port: %d", inet_ntoa(clientInfo.sin_addr), clientInfo.sin_port);

		connectIndex = FindFreeChannel();
		if(connectIndex >= 0)
		{
			if(IsConflictIp(clientInfo.sin_addr.s_addr) == false)
			{
				ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[connectIndex].Status = _CNS_WaitModelName;
				ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[connectIndex].IpAddress = clientInfo.sin_addr.s_addr;

				forkId = fork();
				if(forkId == 0)
				{
					// child process
					DispenserSocketProcess(clientSockFd, clientInfo, connectIndex);
					close(clientSockFd);
					memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[connectIndex], 0x00, sizeof(struct ConnectionInfoData));
					return;
				}
				else if(forkId == -1)
				{
					PRINTF_FUNC("fork fail");
				}
			}
			else
			{
				// conflict ip address
				PRINTF_FUNC("Conflict IP address, close socket");
				close(clientSockFd);
			}
		}
		else
		{
			// no free channel
			PRINTF_FUNC("No free channel, close socket");
			close(clientSockFd);
		}
		usleep(10000);
	}

	return;
}

int main(void)
{
	if(InitShareMemory() == FAIL)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("InitShareMemory NG\n");
		#endif

		sleep(5);
		return 0;
	}

	// wait for self test completed
	while(ShmSysConfigAndInfo->SysInfo.BootingStatus == BOOTTING);

	tcpSocketServerStart();

	//tcpSocketClientStart();

	return 0;
}