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"
#include    "Common.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;
ChargerInfoData                     *ShmChargerInfo;
struct ChargingInfoData             *chargingInfo[CONNECTOR_QUANTITY];
PsuGroupCollectionData              *ShmGroupCollection;
struct PsuData                      *ShmPsuData;

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
		LOG_ERROR("shmget ShmSysConfigAndInfo NG");
		#endif
		result = FAIL;
	}
	else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		LOG_ERROR("shmat ShmSysConfigAndInfo NG");
		#endif
		result = FAIL;
	 }
	else
	{

	}

    if ((MeterSMId = shmget(SM_ChargerInfoKey, sizeof(ChargerInfoData), 0777)) < 0)
    {
        #ifdef SystemLogMessage
        LOG_ERROR("shmat ChargerInfoData NG");
        #endif
        result = FAIL;
    }
    else if ((ShmChargerInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
        #ifdef SystemLogMessage
        LOG_ERROR("shmat ChargerInfoData NG");
        #endif
        result = FAIL;
    }

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

    if(result == PASS)
    {
        ShmGroupCollection = &ShmChargerInfo->PsuGrouping.GroupCollection[0];
    }

	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)
					{
						LOG_INFO("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)
					{
						LOG_INFO("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)
				{
					LOG_INFO("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)
					{
						LOG_INFO("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];

						LOG_INFO("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)
					{
						LOG_INFO("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)
					{
						LOG_INFO("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)
					{
						LOG_INFO("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)
					{
						LOG_INFO("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)
					{
						LOG_INFO("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)
		{
			LOG_INFO("Fail to create a socket.");
			return;
		}
		LOG_INFO("TCP Client Start");

		if(connect(sockfd, (struct sockaddr *)&info, sizeof(info)) == -1)
		{
			LOG_INFO("Connection error");
		}
		else
		{
			LOG_INFO("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)
{
    // 20210817 remove type "R"
	char         modelList[10] = {'J', 'U', 'V', 'E', 'F', 'G', 'T', 'D', 'K', 'P'};
	unsigned char typeList[10] = {  0,   1,   1,   1,   1,   2,   1,   1,   0,   1}; // 0 : Chademo, 1: CCS, 2: GB

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

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

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

void SendPacket(int socket, struct PACKET_STRUCTURE *packet)
{
    //ShowSocketData(packet);
    send(socket, packet, packet->Header.len + 4, 0);
}

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;

	SendPacket(socket, &sendBuffer);
}

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];

	SendPacket(socket, &sendBuffer);
}

// more message for debug
struct PACKET_STRUCTURE CabinetStatusToDispenser[4];

void PowerCabinetStatusResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
	struct PACKET_STRUCTURE sendBuffer;
	unsigned char MiscEventCode[7];

	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';
		    }
		}
	}

    if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.MiscNeedAnnouncement)
    {
        sendBuffer.Header.len += 6;
        memset(MiscEventCode, 0, sizeof(MiscEventCode));
        memcpy(MiscEventCode, "B40001", sizeof(MiscEventCode) - 1);
        memcpy(&sendBuffer.Payload.data[1 + (ShmSysConfigAndInfo->SysWarningInfo.WarningCount * 6)], &MiscEventCode[0], 6);
    }

    bool need_copy = false;
    if(sendBuffer.Header.len != CabinetStatusToDispenser[sendBuffer.Header.id].Header.len ||
        sendBuffer.Header.op != CabinetStatusToDispenser[sendBuffer.Header.id].Header.op ||
        sendBuffer.Payload.reg != CabinetStatusToDispenser[sendBuffer.Header.id].Payload.reg ||
        sendBuffer.Payload.data[0] != CabinetStatusToDispenser[sendBuffer.Header.id].Payload.data[0])
    {
        need_copy = true;
    }
    else
    {
        for(int i = 0; i < sendBuffer.Header.len - 2; i++)
        {
            if(sendBuffer.Payload.data[1 + i] != CabinetStatusToDispenser[sendBuffer.Header.id].Payload.data[1 + i])
            {
                need_copy = true;
            }
        }
    }
    if(need_copy)
    {
        char str[256];
        memcpy(&CabinetStatusToDispenser[sendBuffer.Header.id], &sendBuffer, sizeof(struct PACKET_STRUCTURE));

        sprintf(str, "Status Code Update To %d:", sendBuffer.Header.id);

        for(int i = 0; i < CabinetStatusToDispenser[sendBuffer.Header.id].Header.len - 2; i++)
        {
            char temp[8];
            sprintf(temp, " %02X", CabinetStatusToDispenser[sendBuffer.Header.id].Payload.data[1 + i]);
            strcat(str, temp);
        }
        LOG_INFO("%s", str);
    }

	SendPacket(socket, &sendBuffer);
}

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;

	SendPacket(socket, &sendBuffer);
}

struct ChargingCapabilityResponse ConnectorCapability[GENERAL_GUN_QUANTITY];

void GetPhysicalLimitVoltageAndCurrent(byte index, unsigned short *voltage, unsigned short *currrent)
{
    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemoteMaxPhysicalVoltage != 0 &&
        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemoteMaxPhysicalVoltage <= *voltage)
    {
        *voltage = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemoteMaxPhysicalVoltage;
    }

    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemoteMaxPhysicalCurrent != 0 &&
        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemoteMaxPhysicalCurrent <= *currrent)
    {
        *currrent = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemoteMaxPhysicalCurrent;
    }
}

void GetConfigLimitPowerAndCurrent(byte index, unsigned short *power, unsigned short *currrent)
{
    unsigned short limitPower = 0, limitCurrent = 0;
    unsigned char inUsingCnt = 0;

    for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
    {
        if(ShmChargerInfo->PsuGrouping.GroupCollection[i].Role == _GROLE_MASTER)
        {
            inUsingCnt += ShmChargerInfo->PsuGrouping.GroupCollection[index].GunPsuQuantity;
        }
    }

    if(ShmChargerInfo->PsuGrouping.GroupCollection[index].GunPsuQuantity != 0 && inUsingCnt != 0 &&
        ShmSysConfigAndInfo->SysConfig.MaxChargingPower != 0)
    {
        limitPower = ShmSysConfigAndInfo->SysConfig.MaxChargingPower * 10;
        limitPower = (limitPower * ShmGroupCollection[index].GunPsuQuantity) / inUsingCnt;
    }
    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].MaxTotalChargingPower = limitPower;

    if(ShmChargerInfo->PsuGrouping.GroupCollection[index].GunPsuQuantity != 0 && inUsingCnt != 0 &&
        ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent != 0)
    {
        limitCurrent = ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent * 10;
        limitCurrent = (limitCurrent * ShmGroupCollection[index].GunPsuQuantity) / inUsingCnt;
    }
    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].MaxTotalChargingCurrent = limitCurrent;

    if(limitPower != 0 && limitPower <= *power)
    {
        *power = limitPower;
    }
    if(limitCurrent != 0 && limitCurrent <= *currrent)
    {
        *currrent = limitCurrent;
    }
}

void GetChargingProfileLimit(byte index, unsigned short *power, unsigned short *currrent)
{
    if((chargingInfo[index]->SystemStatus >= S_PREPARING_FOR_EVSE && chargingInfo[index]->SystemStatus <= S_CHARGING) ||
        (chargingInfo[index]->SystemStatus >= S_CCS_PRECHARGE_ST0 && chargingInfo[index]->SystemStatus <= S_CCS_PRECHARGE_ST1))
    {
        if(chargingInfo[index]->ChargingProfilePower >= 0 && *power > ((int)chargingInfo[index]->ChargingProfilePower / 100))
        {
            *power = (int)chargingInfo[index]->ChargingProfilePower / 100;
        }

        if(chargingInfo[index]->ChargingProfileCurrent >= 0 && *currrent > (int)chargingInfo[index]->ChargingProfileCurrent)
        {
            *currrent = (int)chargingInfo[index]->ChargingProfileCurrent;
        }
    }
}

void GetMaxChargingProfileLimit(byte index, unsigned short *power, unsigned short *currrent)
{
    unsigned short limitPower = 0, limitCurrent = 0;
    unsigned char inUsingCnt = 0;

    for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
    {
        if(ShmChargerInfo->PsuGrouping.GroupCollection[i].Role == _GROLE_MASTER)
        {
            inUsingCnt += ShmChargerInfo->PsuGrouping.GroupCollection[index].GunPsuQuantity;
        }
    }

    // max charging profile
    if(ShmChargerInfo->PsuGrouping.GroupCollection[index].GunPsuQuantity != 0 && inUsingCnt != 0 &&
        ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower >= 0)
    {
        limitPower = (int)ShmSysConfigAndInfo->SysInfo.MaxChargingProfilePower / 100;
        limitPower = (limitPower * ShmGroupCollection[index].GunPsuQuantity) / inUsingCnt;

        if(*power > limitPower)
        {
            *power = limitPower;
        }

        if (chargingInfo[index]->EvBatterytargetVoltage > 0 &&
            (int)chargingInfo[index]->PresentChargingVoltage > 0)
        {
            limitCurrent = (limitPower * 100 / chargingInfo[index]->PresentChargingVoltage) * 10;

            if(*currrent > limitCurrent)
            {
                *currrent = limitCurrent;
            }
        }
    }
}

void ChargingCapabilityResponse(int socket, struct PACKET_STRUCTURE *packet)
{
	struct PACKET_STRUCTURE sendBuffer;
	unsigned short voltage = 0, current = 0, power = 0;
	unsigned char currency = 0;
	unsigned int price = 0, cost = 0, account = 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;

	GetPhysicalLimitVoltageAndCurrent(packet->Header.id - 1, &voltage, &current);
	GetConfigLimitPowerAndCurrent(packet->Header.id - 1, &power, &current);
	GetChargingProfileLimit(packet->Header.id - 1, &power, &current);
	GetMaxChargingProfileLimit(packet->Header.id - 1, &power, &current);

	currency = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Currency;
	price = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].UserPrice;
	cost = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].TotalCost;
	account = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].AccountBalance;

	if((ConnectorCapability[packet->Header.id - 1].MaxOuputVoltage / 10) != (voltage / 10) ||
        (ConnectorCapability[packet->Header.id - 1].MaxOuputCurrent / 10) != (current / 10) ||
        (ConnectorCapability[packet->Header.id - 1].MaxOuputPower / 10) != (power / 10))
	{
        LOG_INFO("Connector %d Capability Voltage: %4d.%d V, Current: %3d.%d A, Power: %d kW", packet->Header.id,
            (voltage / 10), (voltage % 10), (current / 10), (current % 10), (power / 10));
	}

	if(ConnectorCapability[packet->Header.id - 1].Currency != currency ||
        ConnectorCapability[packet->Header.id - 1].UserPrice != price ||
        ConnectorCapability[packet->Header.id - 1].TotalCost != cost ||
        ConnectorCapability[packet->Header.id - 1].AccountBalance != account)
	{
	    LOG_INFO("Connector %d Currency: %d, UserPrice: %d, Cost: %d, Account: %d", packet->Header.id, (int)(currency), (int)(price), (int)(cost), (int)(account));
	}

	ConnectorCapability[packet->Header.id - 1].MaxOuputVoltage = voltage;
	ConnectorCapability[packet->Header.id - 1].MaxOuputCurrent = current;
	ConnectorCapability[packet->Header.id - 1].MaxOuputPower = power;
	ConnectorCapability[packet->Header.id - 1].Currency = currency;
	ConnectorCapability[packet->Header.id - 1].UserPrice = price;
	ConnectorCapability[packet->Header.id - 1].TotalCost = cost;
	ConnectorCapability[packet->Header.id - 1].AccountBalance = account;

	sendBuffer.Header.se = packet->Header.se;
	sendBuffer.Header.id = packet->Header.id;
	sendBuffer.Header.op = _Header_Response;
	sendBuffer.Header.len = 21;
	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);
	sendBuffer.Payload.data[7] = currency;
	sendBuffer.Payload.data[8] = ((price >> 24) & 0xFF);
	sendBuffer.Payload.data[9] = ((price >> 16) & 0xFF);
	sendBuffer.Payload.data[10] = ((price >> 8) & 0xFF);
	sendBuffer.Payload.data[11] = (price & 0xFF);
    sendBuffer.Payload.data[12] = ((cost >> 24) & 0xFF);
    sendBuffer.Payload.data[13] = ((cost >> 16) & 0xFF);
    sendBuffer.Payload.data[14] = ((cost >> 8) & 0xFF);
    sendBuffer.Payload.data[15] = (cost & 0xFF);
    sendBuffer.Payload.data[16] = ((account >> 24) & 0xFF);
    sendBuffer.Payload.data[17] = ((account >> 16) & 0xFF);
    sendBuffer.Payload.data[18] = ((account >> 8) & 0xFF);
    sendBuffer.Payload.data[19] = (account & 0xFF);

	SendPacket(socket, &sendBuffer);
}

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;

	SendPacket(socket, &sendBuffer);
}

void FirmwareUpgradeResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex, 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_Software_Update;
    sendBuffer.Payload.data[0] = _R_OK;
    sendBuffer.Payload.data[1] = result;

    if(result == _R_NeedUpgrade)
    {
        int length = strlen(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].FwFileName);
        memcpy(&sendBuffer.Payload.data[2], ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].FwFileName, length);
        sendBuffer.Header.len += length;
    }

    SendPacket(socket, &sendBuffer);
}

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;

	SendPacket(socket, &sendBuffer);
}

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;

	SendPacket(socket, &sendBuffer);
}

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;

	SendPacket(socket, &sendBuffer);
}

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;

	SendPacket(socket, &sendBuffer);
}

void AddMiscCommand(struct PACKET_STRUCTURE *packet, struct MISC_COMMAND *misc)
{
    packet->Payload.data[packet->Header.len - 1 + 0] = ((misc->Command >> 8) & 0xFF);
    packet->Payload.data[packet->Header.len - 1 + 1] = ((misc->Command >> 0) & 0xFF);
    packet->Payload.data[packet->Header.len - 1 + 2] = ((misc->Value >> 24) & 0xFF);
    packet->Payload.data[packet->Header.len - 1 + 3] = ((misc->Value >> 16) & 0xFF);
    packet->Payload.data[packet->Header.len - 1 + 4] = ((misc->Value >>  8) & 0xFF);
    packet->Payload.data[packet->Header.len - 1 + 5] = ((misc->Value >>  0) & 0xFF);
    packet->Header.len += 6;
}

void MiscControlResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex, 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_Misc_Control;
    sendBuffer.Payload.data[0] = result;

    if(result == _R_OK)
    {
        struct MISC_COMMAND misc;

        if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.AvailabilityRequest)
        {
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.AvailabilityRequest = false;
            misc.Command = _MiscCmd_ChangeOperative;
            misc.Value = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.IsAvailable;

            LOG_INFO("Announce Connector %d Availability: %d", packet->Header.id, misc.Value);
            AddMiscCommand(&sendBuffer, &misc);
        }

        if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStartRequest)
        {
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStartRequest = false;
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStartConfirm = true;
            misc.Command = _MiscCmd_RemoteStart;
            misc.Value = true;

            LOG_INFO("Announce Connector %d Remote Start: %d", packet->Header.id, misc.Value);
            AddMiscCommand(&sendBuffer, &misc);
        }

//        if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStopRequest)
//        {
//            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStopRequest = false;
//            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStopConfirm = true;
//            misc.Command = _MiscCmd_RemoteStop;
//            misc.Value = true;

//            LOG_INFO("Announce Connector %d Remote Stop: %d", packet->Header.id, misc.Value);
//            AddMiscCommand(&sendBuffer, &misc);
//        }

//        if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.UnlockStopRequest)
//        {
//            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.UnlockStopRequest = false;
//            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.UnlockStopConfirm = true;
//            misc.Command = _MiscCmd_UnlockStop;
//            misc.Value = true;

//            LOG_INFO("Announce Connector %d Unlock Stop: %d", packet->Header.id, misc.Value);
//            AddMiscCommand(&sendBuffer, &misc);
//        }

        if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.AccountBalanceRequest)
        {
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.AccountBalanceRequest = false;
            misc.Command = _MiscCmd_AccountBalance;
            misc.Value = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].AccountBalance;

            LOG_INFO("Announce Connector %d Account Balance: %d", packet->Header.id, (misc.Value));
            AddMiscCommand(&sendBuffer, &misc);
        }

        // announce misc command to first connector of the dispenser
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[0] == packet->Header.id)
        {
            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.ConnectorTimeoutConfigRequest)
            {
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.ConnectorTimeoutConfigRequest = false;
                misc.Command = _MiscCmd_ConnectorTimeout;
                misc.Value = ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout;

                LOG_INFO("Announce Dispenser %d Connection Timeout: %d", dispenserIndex + 1, misc.Value);
                AddMiscCommand(&sendBuffer, &misc);
            }

            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DefaultPriceConfigRequest)
            {
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DefaultPriceConfigRequest = false;
                misc.Command = _MiscCmd_DefaultPrice;
                misc.Value = ShmSysConfigAndInfo->SysInfo.DispenserInfo.DefaultPrice;

                LOG_INFO("Announce Dispenser %d Default Price: %d", dispenserIndex + 1, misc.Value);
                AddMiscCommand(&sendBuffer, &misc);
            }

            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.CurrencyConfigRequest)
            {
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.CurrencyConfigRequest = false;
                misc.Command = _MiscCmd_Currency;
                misc.Value = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Currency;

                LOG_INFO("Announce Dispenser %d Currency Index: %d", dispenserIndex + 1, misc.Value);
                AddMiscCommand(&sendBuffer, &misc);
            }

            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.BackendStatusRequest)
            {
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.BackendStatusRequest = false;
                misc.Command = _MiscCmd_BackendStatus;
                misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BackendStatus;

                LOG_INFO("Announce Dispenser %d BackendStatus: %d", dispenserIndex + 1, (misc.Value));
                AddMiscCommand(&sendBuffer, &misc);
            }

            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.EthernetStatusRequest)
            {
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.EthernetStatusRequest = false;
                misc.Command = _MiscCmd_EthernetStatus;
                misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.EthernetStatus;

                LOG_INFO("Announce Dispenser %d EthernetStatus: %d", dispenserIndex + 1, (misc.Value));
                AddMiscCommand(&sendBuffer, &misc);
            }

            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.WiFiStatusRequest)
            {
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.WiFiStatusRequest = false;
                misc.Command = _MiscCmd_WiFiStatus;
                misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.WiFiStatus;

                LOG_INFO("Announce Dispenser %d WiFiStatus: %d", dispenserIndex + 1, (misc.Value));
                AddMiscCommand(&sendBuffer, &misc);
            }

            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.TelcomModemStatusRequest)
            {
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.TelcomModemStatusRequest = false;
                misc.Command = _MiscCmd_4GStatus;
                misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.TelcomModemStatus;

                LOG_INFO("Announce Dispenser %d TelcomModemStatus: %d", dispenserIndex + 1, (misc.Value));
                AddMiscCommand(&sendBuffer, &misc);
            }

            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.BillingStatusRequest)
            {
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.BillingStatusRequest = false;
                misc.Command = _MiscCmd_Billing;
                misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BillingStatus;

                LOG_INFO("Announce Dispenser %d %s Billing Information", dispenserIndex + 1, misc.Value ? "Enable" : "Disable");
                AddMiscCommand(&sendBuffer, &misc);
            }

            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.StopButtonStatusRequest)
            {
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.StopButtonStatusRequest = false;
                misc.Command = _MiscCmd_StopButton;
                misc.Value = ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.StopChargingButton;

                LOG_INFO("Announce Dispenser %d %s Stop Charging Button", dispenserIndex + 1, misc.Value ? "Enable" : "Disable");
                AddMiscCommand(&sendBuffer, &misc);
            }

            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.HardwareRebootRequest)
            {
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.HardwareRebootRequest = false;
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.HardwareRebootConfirm = true;
                misc.Command = _MiscCmd_HardwareReboot;
                misc.Value = true;

                LOG_INFO("Announce Dispenser %d Hardware Reboot: %d", dispenserIndex + 1, misc.Value);
                AddMiscCommand(&sendBuffer, &misc);
            }

            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.SoftwareResetRequest)
            {
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.SoftwareResetRequest = false;
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.SoftwareResetConfirm = true;
                misc.Command = _MiscCmd_SoftwareRestart;
                misc.Value = true;

                LOG_INFO("Announce Dispenser %d Software Reset: %d", dispenserIndex + 1, misc.Value);
                AddMiscCommand(&sendBuffer, &misc);
            }
        }
    }

    SendPacket(socket, &sendBuffer);
}

void WriteCsuVersionResponse(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_Report_Csu_Version;
    sendBuffer.Payload.data[0] = result;

    SendPacket(socket, &sendBuffer);
}

void WriteOtherVersionResponse(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_Report_Other_Version;
    sendBuffer.Payload.data[0] = result;

    SendPacket(socket, &sendBuffer);
}

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

    unsigned short voltage = 0, current = 0;
    unsigned char gun = packet->Header.id - 1;

#if 0
    // for safety test
    voltage = (unsigned short)(chargingInfo[gun]->PresentChargingVoltage * 10);
    current = (unsigned short)(chargingInfo[gun]->PresentChargingCurrent * 10);
    voltage -= ((current * 8 * 10) / 10000);
#endif

    if(chargingInfo[gun]->PantographFlag == YES)
    {
        voltage = (unsigned short)(chargingInfo[gun]->PresentChargingVoltage * 10);
        current = (unsigned short)(chargingInfo[gun]->PresentChargingCurrent * 10);
    }

    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 = 6;
    sendBuffer.Payload.reg = _Reg_Charging_Info;
    sendBuffer.Payload.data[0] = result;
    sendBuffer.Payload.data[1] = (voltage >> 8) & 0xFF;
    sendBuffer.Payload.data[2] = (voltage >> 0) & 0xFF;
    sendBuffer.Payload.data[3] = (current >> 8) & 0xFF;
    sendBuffer.Payload.data[4] = (current >> 0) & 0xFF;

    SendPacket(socket, &sendBuffer);
}

int GetChargerSystemId(char *id)
{
    int len = 0;

    strcpy((char *)id, "");

    switch(ShmChargerInfo->AuthInfo.QRCodeMode)
    {
        case _QR_MODE_Customized:
            strcpy((char *)id, (char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent);
            break;

        case _QR_MODE_ChargeBoxId:
            strcpy((char *)id, (char *)ShmSysConfigAndInfo->SysConfig.ChargeBoxId);
            break;

        case _QR_MODE_Default:
        default:
            strcat((char *)id, (char *)ShmSysConfigAndInfo->SysConfig.SystemId);
            break;
    }

    len = strlen((char *)id);

    return len;
}

void ChargerSystemIdResponse(int socket, struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex, unsigned char result)
{
    struct PACKET_STRUCTURE sendBuffer;
    char system_id[128];

    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_Charger_System_Id;
    sendBuffer.Payload.data[0] = result;
    if(result == _R_OK)
    {
        int strLen = 0;
        strLen = GetChargerSystemId(system_id);
        memcpy(&sendBuffer.Payload.data[sendBuffer.Header.len - 1], (char *)system_id, strLen);
        sendBuffer.Header.len += strLen + 1;

        char TimeSync[32];
        struct timeb  SeqEndTime;
        struct tm *tm;
        ftime(&SeqEndTime);
        SeqEndTime.time = time(NULL);
        tm=localtime(&SeqEndTime.time);
        memset(TimeSync, 0x00, 32);

        sprintf(TimeSync, "%04d-%02d-%02d %02d:%02d:%02d", tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec);
        strLen = strlen(TimeSync);
        memcpy(&sendBuffer.Payload.data[sendBuffer.Header.len - 1], TimeSync, strLen);
        sendBuffer.Header.len += strLen + 1;
        //LOG_INFO("Dispenser %d Read System Id: %s", dispenserIndex + 1, ShmSysConfigAndInfo->SysConfig.ChargeBoxId);
    }

    SendPacket(socket, &sendBuffer);
}

void WriteWaitPlugInResponse(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_WaitPlugIn;
    sendBuffer.Payload.data[0] = result;

    SendPacket(socket, &sendBuffer);
}

void GroundFaultDetectionResponse(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_GroundFaultDetection;
    sendBuffer.Payload.data[0] = result;
    sendBuffer.Payload.data[1] = result == _R_OK ? chargingInfo[packet->Header.id - 1]->GroundFaultStatus : GFD_WAIT;

    SendPacket(socket, &sendBuffer);
}

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 ConnectorPhysicalLimitBindingHandler(unsigned char connectorIndex, unsigned char physical)
{
    // 20210817 remove type "R"
    //char         modelList[11] = {'J', 'U', 'V', 'E', 'F', 'G', 'T', 'D', 'K', 'P'};
    //unsigned char typeList[11] = {  0,   1,   1,   1,   1,   2,   1,   1,   0,   1}; // 0 : Chademo, 1: CCS, 2: GB

    switch(physical)
    {
        case 'J':
        case 'K':
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = CHA_MAX_PHYSICAL_VOLTAGE;
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = CHA_NATURAL_MAX_CURRENT;
            break;

        case 'U':
        case 'E':
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = CCS_MAX_PHYSICAL_VOLTAGE;
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = CCS_NATURAL_MAX_CURRENT;
            break;

        case 'G':
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = GBT_MAX_PHYSICAL_VOLTAGE;
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = GBT_NATURAL_MAX_CURRENT;
            break;

        case 'V':
        case 'F':
        case 'P':
        //case 'R': // 20210817 remove type "R"
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = CCS_MAX_PHYSICAL_VOLTAGE;
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = CCS_LIQUID_MAX_CURRENT;
            break;

        case 'T':
        case 'D':
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = CCS_MAX_PHYSICAL_VOLTAGE;
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = CCS_NATURAL_REMA_MAX_CURRENT;
            break;

        default:
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalVoltage = 0;
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connectorIndex].RemoteMaxPhysicalCurrent = 0;
            break;
    }
}

void ConnectorPantographBindingHandler(unsigned char connectorIndex, unsigned char physical)
{
    switch(physical)
    {
        case 'P':
            chargingInfo[connectorIndex]->PantographFlag = YES;
            break;
        default:
            chargingInfo[connectorIndex]->PantographFlag = NO;
            break;
    }
}

void ConnectorTypeBindingHandler(unsigned char dispenserIndex, unsigned char *type, unsigned char *physicalType)
{
    char *str_gun_type[] = {STR_GUN_TYPE_CHADEMO, STR_GUN_TYPE_CCS, STR_GUN_TYPE_GBT};

	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.Index = gunIndex;
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].GeneralChargingData.Type = type[i];
        ConnectorPhysicalLimitBindingHandler(gunIndex, physicalType[i]);
        ConnectorPantographBindingHandler(gunIndex, physicalType[i]);

		LOG_INFO("Dispenser %d Connector %d type: %s, MaxVol: %4d, MaxCur: %4d, %s",
            dispenserIndex + 1, gunIndex + 1, str_gun_type[type[i]],
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].RemoteMaxPhysicalVoltage,
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].RemoteMaxPhysicalCurrent,
            chargingInfo[gunIndex]->PantographFlag == YES ? "Pantograph" : "Normal");
	}
}

BOOL IsAvailableDispenserIndexSequence(unsigned char index)
{
    for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
    {
        if(i == index)
        {
            return true;
        }

        if((ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status & (1 << i)) == 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++;
			connector += ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity;
		}
	}

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

	if(change)
	{
		LOG_INFO("Total Dispenser: %d, Total Connector: %d\n",
			ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentDispenserQuantity,
			ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentConnectorQuantity);
	}
}

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;
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[currentQuantity - 1].GeneralChargingData.Index = currentQuantity - 1;
	}
}

BOOL CheckNewDispenserSequence(unsigned char index, unsigned char quantity)
{
    if(index == ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence)
    {
        LOG_INFO("Get New Dispenser %d, Connector Quantity: %d\n", index + 1, quantity);

        ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status |= (1 << index);
        ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[index] = quantity;

        ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence = index + 1;
        ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity += quantity;
        ShmSysConfigAndInfo->SysConfig.WiringInfo.WiringSetting[index] = quantity;
        ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.FlashConfigChanged = true;

        ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity = ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence;
        ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity = ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity;

        return true;
    }

    return false;
}

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

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

	quantity = ConnectorQuantityTypeParsing(modelName, connectorType, physicalType);

	if(quantity > 0)
	{
		if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[dispenserIndex] != 0 &&
			quantity != ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[dispenserIndex])
		{
			LOG_INFO("The same dispenser id (%d) but connector quantity not match", dispenserIndex + 1);
			return false;
		}
        if(dispenserIndex == ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence &&
            (quantity + ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity) > ShmChargerInfo->Control.MaxConnector)
        {
            LOG_INFO("Dispenser %d connector quantity %d over range, total quantity: %d",
                dispenserIndex + 1, quantity, ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity);
            return false;
        }
		if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus == _DS_None ||
			ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus == _DS_Timeout)
		{
            CheckNewDispenserSequence(dispenserIndex, quantity);

			ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LocalStatus = _DS_Identification;
			ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorQuantity = quantity;

			SetConnectorID(dispenserIndex, quantity);
			memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ModelName, packet->Payload.data, (packet->Header.len - 2));

			ConnectorTypeBindingHandler(dispenserIndex, connectorType, physicalType);

			LOG_INFO("Dispenser id %d identified, Connector quantity: %d\n", dispenserIndex + 1, quantity);

			DispenserCheckInInfoUpdate();

			return true;
		}
		else
		{
			LOG_INFO("Conflict dispenser ID: %d", dispenserIndex + 1);
		}
	}
	else
	{
        LOG_INFO("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);
		}
/*
		BOOL needUpdate = FALSE;
		// check is there new status code
		for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount; i++)
		{
		    if(strcmp(&ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCode[i][0],
		            &LastWarningInfo[packet->Header.id - 1].WarningCode[i][0]) == 0)
		    {
		        needUpdate = TRUE;
		        break;
		    }
		}
		if(needUpdate)
		{
		    memcpy(&LastWarningInfo[packet->Header.id - 1], &ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo, sizeof(struct WARNING_CODE_INFO));
		}
*/
		char strDispenserStatus[128];
		sprintf(strDispenserStatus, "Dispenser id %d, Status Code Len: %d", packet->Header.id, ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount);
		if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount > 0)
		{
		    for(int i = 0; i < ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCount; i++)
		    {
		        char strTemp[16];
		        sprintf(strTemp, ", %s", ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].WarningInfo.WarningCode[i]);
		        strcat(strDispenserStatus, strTemp);
		    }
		}
		LOG_INFO("%s", strDispenserStatus);
	}
	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;
}

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

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

		if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetVoltage != voltage ||
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetCurrent != current)
		{
		    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetVoltage = voltage;
		    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetCurrent = current;
		    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.OutputLimitEnable)
		    {
		        LOG_INFO("Connector %d Remote Voltage: %d, Remote Current: %d", packet->Header.id, voltage, current);
		    }
		}

		GetPhysicalLimitVoltageAndCurrent(packet->Header.id - 1, &voltage, &current);
		GetConfigLimitPowerAndCurrent(packet->Header.id - 1, &power, &current);

		if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetVoltage != voltage ||
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetCurrent != current)
		{
		    if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.OutputLimitEnable)
		    {
		        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.OutputLimitEnable = true;
		        LOG_INFO("Connector %d Remote Voltage: %d, Remote Current: %d", packet->Header.id,
                    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetVoltage,
                    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteTargetCurrent);
		        LOG_INFO("Connector %d Limit Voltage: %d, Limit Current: %d", packet->Header.id, voltage, current);
		    }
		}
		else
		{
		    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.OutputLimitEnable = false;
		}
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteLimitVoltage = voltage;
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteLimitCurrent = current;

		if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus == S_PREPARING_FOR_EVSE ||
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus == S_CHARGING)
		{
		    float targetVol = (float)(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteLimitVoltage / 10);
		    float targetCur = (float)(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteLimitCurrent / 10);

			if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetVoltage != targetVol ||
				ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetCurrent != targetCur)
			{
                LOG_INFO("Connector %d Target Voltage: %d V, Current: %d A",
                    packet->Header.id, (int)(targetVol), (int)(targetCur));
			}

			ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetVoltage = targetVol;
			ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetCurrent = targetCur;

			done = true;
		}
		else
		{
			if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetVoltage != 0 ||
				ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.EvBatterytargetCurrent != 0)
			{
				LOG_INFO("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;
}

unsigned char FirmwareUpgradeHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
    unsigned char UpgradeResponse = _R_NoUpgrade;

    if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectorID[0] == packet->Header.id)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateRequest)
        {
            if(packet->Payload.data[0] == 0)
            {
                UpgradeResponse = _R_NeedUpgrade;
            }
            else
            {
                if(!ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateConfirm)
                {
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateConfirm = true;
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateRequest = false;
                    LOG_INFO("Dispenser %d Updating...", dispenserIndex + 1);
                }
            }
        }
        else
        {
            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateConfirm)
            {
                if(packet->Payload.data[0] == 0)
                {
                    if(!ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateCompleted)
                    {
                        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.FirmwareUpdateCompleted = true;
                        LOG_INFO("Dispenser %d Upgrade Completed", dispenserIndex + 1);
                    }
                }
            }
        }
    }

    return UpgradeResponse;
}

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])
		{
			LOG_INFO("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);
	unsigned char ConnectionState;
	unsigned char *AlarmCode;
	unsigned char GunTemp = 0;
	unsigned char ChillerTemp = 0;
	unsigned char noAlarm[6];

	memset(noAlarm, 0x00, 6);

	if(find)
	{
	    ConnectionState = packet->Payload.data[0];
	    AlarmCode = packet->Header.len >= 8 ? &packet->Payload.data[1] : &noAlarm[0];
	    GunTemp = packet->Header.len >= 10 ? packet->Payload.data[7] : GunTemp;
	    ChillerTemp = packet->Header.len >= 10 ? packet->Payload.data[8] : ChillerTemp;

	    chargingInfo[packet->Header.id - 1]->ConnectorTemp = GunTemp;
	    chargingInfo[packet->Header.id - 1]->ChillerTemp = ChillerTemp;

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

			switch(ConnectionState)
			{
                case _CRS_Idle:
                case _CRS_Terminating:
                    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Preparing ||
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Charging)
                    {
                        if(chargingInfo[packet->Header.id - 1]->SystemStatus != S_IDLE)
                        {
                            LOG_INFO("*********** Connector id %d Set Normal Stop Flag ***********\n", packet->Header.id);
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.NormalStopRequest = true;
                        }
                    }
                    break;

                case _CRS_Alarm:
                    memcpy(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemotenAlarmCode, AlarmCode, 6);

                    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Idle)
                    {
                        LOG_INFO("*********** Connector id %d Set Fault Status [%s] ***********", packet->Header.id,
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemotenAlarmCode);
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.FaultStatusRequest = true;
                    }
                    else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Preparing ||
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Charging)
                    {

                        LOG_INFO("*********** Connector id %d Set Alarm Stop Flag [%s] ***********", packet->Header.id,
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemotenAlarmCode);
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.AlarmStopRequest = true;
                    }
                    break;

                default:
                    break;
			}
		}
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus = ConnectionState;
	}
	else
	{

	}

	return true;
}

unsigned char UserIDHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
    BOOL find = FindConnectorID(dispenserIndex, packet->Header.id);
	DispenserAck_Status authorize = _DAS_Wait;
	unsigned char CardNumber[32];
	unsigned char *result;
	int length = 0;

	if(find || packet->Header.id == 0xFF)
	{
	    length = packet->Header.len - 1;
	    memset(CardNumber, 0x00, sizeof(CardNumber));
	    memcpy(CardNumber, packet->Payload.data, length);

	    if(packet->Header.id != 0xFF)
	    {
	        result = &ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].AuthorizingResult;
	    }
	    else
	    {
	        result = &ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].AuthResult;
	    }

	    if(*result == _AuthResult_Valid)
	    {
            LOG_INFO("Dispenser %d Target %d user id %s authorizing ok", dispenserIndex + 1, packet->Header.id, CardNumber);
            authorize = _DAS_Allowed;
	    }
	    else if(*result == _AuthResult_Invalid)
	    {
            LOG_INFO("Dispenser %d Target %d user id %s authorizing fail", dispenserIndex + 1, packet->Header.id, CardNumber);
            authorize = _DAS_NotAllowed;
	    }
	    else if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].AuthStatus == _AuthorizeStatus_Idle &&
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.AuthorizeRequest == false)
	    {
	        memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].UserId, CardNumber, sizeof(CardNumber));
	        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].AuthTarget = packet->Header.id;
	        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.AuthorizeRequest = true;

	        LOG_INFO("Dispenser %d connector %d user id %s need authorize", dispenserIndex + 1, packet->Header.id, CardNumber);
	        authorize = _DAS_Wait;
	    }
	    else
	    {
	        authorize = _DAS_Wait;
	    }
    }
	else
	{
	    authorize = _DAS_NotAllowed;
	}

	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_IDLE:
                if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Idle ||
                    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Preparing)
                {
                    permission = _DAS_Wait;
                }
                else
                {
                    permission = _DAS_NotAllowed;
                    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.ChargingPermission != permission)
                    {
                        LOG_INFO("Cabinet status idle, not allow dispenser %d connector %d charging",
                            dispenserIndex + 1, packet->Header.id);
                    }
                }
                break;

            case S_AUTHORIZING:
            case S_REASSIGN_CHECK:
            case S_REASSIGN:
            case S_PREPARNING:
                permission = _DAS_Wait;
                break;

            case S_PREPARING_FOR_EV:
                if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStopRequest ||
                    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.UnlockStopRequest)
                {
                    permission = _DAS_NotAllowed;
                    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.ChargingPermission != permission)
                    {
                        LOG_INFO("RemoteStop or UnlockStop, not allow dispenser index %d connector id %d preparing to charge", dispenserIndex, packet->Header.id);
                    }
                }
                else 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;
                        LOG_INFO("Allow dispenser index %d connector id %d start preparing to charge", dispenserIndex, packet->Header.id);
                    }
                    permission = _DAS_Allowed;
                }
                else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].RemoteStatus == _CRS_Terminating)
                {
                    permission = _DAS_NotAllowed;
                    LOG_INFO("Dispenser Terminating, Not allow dispenser index %d connector id %d preparing to charge", dispenserIndex, packet->Header.id);
                }
                else
                {
                    // keep wait
                }
                break;

            case S_PREPARING_FOR_EVSE:
                permission = _DAS_Allowed;
                break;

            case S_CHARGING:
                if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.RemoteStopRequest ||
                    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.UnlockStopRequest)
                {
                    permission = _DAS_NotAllowed;
                    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.ChargingPermission != permission)
                    {
                        LOG_INFO("RemoteStop or UnlockStop, not allow dispenser index %d connector id %d charging", dispenserIndex, packet->Header.id);
                    }
                }
                else 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;
                    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.ChargingPermission != permission)
                    {
                        LOG_INFO("Dispenser index %d connector id %d remote status not in charging mode", dispenserIndex, packet->Header.id);
                    }
                }
                break;

            case S_TERMINATING:
            case S_COMPLETE:
            case S_ALARM:
            case S_FAULT:
            case S_RESERVATION:
            case S_MAINTAIN:
                permission = _DAS_NotAllowed;
                if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.ChargingPermission != permission)
                {
                    LOG_INFO("Cabinet status(%d) not match, not allow dispenser index %d connector id %d charging",
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus,
                        dispenserIndex, packet->Header.id);
                }
                break;

            default:
                break;
	    }
	}
	else
	{
	    LOG_INFO("Dispenser index %d Connector id %d not found", dispenserIndex, packet->Header.id);
	    permission = _DAS_NotAllowed;
	}

	ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.ChargingPermission = permission;

//	LOG_INFO("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;
}

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

    if(find)
    {
        done = true;
    }

    return done;
}

unsigned char DispenserWriteCsuVersionInfoHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
    char version[32];
    BOOL writeVersion = FALSE, showVersion = FALSE;;

    memcpy(version, &packet->Payload.data[0], 32);
    if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuBootLoadFwRev, version) != 0)
    {
        memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuBootLoadFwRev, version, 32);
        showVersion = true;
    }

    memcpy(version, &packet->Payload.data[32], 32);
    if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuKernelFwRev, version) != 0)
    {
        memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuKernelFwRev, version, 32);
        showVersion = true;
    }

    memcpy(version, &packet->Payload.data[64], 32);
    if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuRootFsFwRev, version) != 0)
    {
        memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuRootFsFwRev, version, 32);
        showVersion = true;
    }

    memcpy(version, &packet->Payload.data[96], 32);
    if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuPrimFwRev, version) != 0)
    {
        memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuPrimFwRev, version, 32);
        showVersion = true;
    }

    if(showVersion)
    {
        LOG_INFO("********** Dispenser id %d:   Csu Version information **********", dispenserIndex + 1);
        LOG_INFO("********** CsuBootLoadRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuBootLoadFwRev);
        LOG_INFO("********** CsuKernelFwRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuKernelFwRev);
        LOG_INFO("********** CsuRootFsFwRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuRootFsFwRev);
        LOG_INFO("**********   CsuPrimFwRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].CsuPrimFwRev);
    }
    writeVersion = TRUE;

    return writeVersion;
}

unsigned char DispenserWriteOtherVersionInfoHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
    char version[32];
    BOOL writeVersion = FALSE, showVersion = FALSE;;

    memcpy(version, &packet->Payload.data[0], 32);
    if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].FanModuleFwRev, version) != 0)
    {
        memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].FanModuleFwRev, version, 32);
        showVersion = true;
    }

    memcpy(version, &packet->Payload.data[32], 32);
    if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].RelayModuleFwRev, version) != 0)
    {
        memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].RelayModuleFwRev, version, 32);
        showVersion = true;
    }

    memcpy(version, &packet->Payload.data[64], 32);
    if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector1FwRev, version) != 0)
    {
        memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector1FwRev, version, 32);
        showVersion = true;
    }

    memcpy(version, &packet->Payload.data[96], 32);
    if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector2FwRev, version) != 0)
    {
        memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector2FwRev, version, 32);
        showVersion = true;
    }

    memcpy(version, &packet->Payload.data[128], 32);
    if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LedModuleFwRev, version) != 0)
    {
        memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LedModuleFwRev, version, 32);
        showVersion = true;
    }

    if(showVersion)
    {
        LOG_INFO("********** Dispenser id %d: Other Version information **********", dispenserIndex + 1);
        LOG_INFO("********** FanModuleFwRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].FanModuleFwRev);
        LOG_INFO("********** RelayModuleRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].RelayModuleFwRev);
        LOG_INFO("**********  Connector1Rev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector1FwRev);
        LOG_INFO("**********  Connector2Rev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Connector2FwRev);
        LOG_INFO("********** LedModuleFwRev: %32s ***", ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].LedModuleFwRev);
    }
    writeVersion = TRUE;

    return writeVersion;
}

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

    if(find)
    {
        gun = packet->Header.id - 1;
        unsigned short diffVoltage = 0, diffCurrent = 0;
        unsigned short voltage = (packet->Payload.data[0] << 8) + (packet->Payload.data[1]);
        unsigned short current = (packet->Payload.data[2] << 8) + (packet->Payload.data[3]);
        //unsigned int time = (packet->Payload.data[4] << 24) + (packet->Payload.data[5] << 16) + (packet->Payload.data[6] << 8) + (packet->Payload.data[7]);
        unsigned char soc = (packet->Payload.data[8]);

        diffVoltage = voltage >= ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingVoltage ?
            voltage - ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingVoltage :
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingVoltage - voltage;

        diffCurrent = current >= ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingCurrent ?
            current - ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingCurrent :
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingCurrent - current;

        if(diffVoltage > 10 || diffCurrent > 10 || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteSoc != soc)
        {
            LOG_INFO("Connector %d Charging Info: Voltage: %4d.%d V, Current: %3d.%d A, Soc: %3d, Temp: %3d, Chiller: %3d",
                packet->Header.id, (voltage / 10), (voltage % 10), (current / 10), (current % 10), soc,
                chargingInfo[gun]->ConnectorTemp - 60, chargingInfo[gun]->ChillerTemp - 60);
        }

        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingVoltage = voltage;
        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteChargingCurrent = current;
        //ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteRemainChargingDuration = time;
        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].RemoteSoc = soc;
        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].GeneralChargingData.EvBatterySoc = soc;
    }
    else
    {

    }

    return find;
}

unsigned char ReadChargerSystemIdHandler(struct PACKET_STRUCTURE *packet, unsigned char dispenserIndex)
{
    BOOL find = TRUE;

    return find;
}

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

    if(find)
    {
        unsigned char StartWait = packet->Payload.data[0];

        if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus == S_AUTHORIZING)
        {
            if(StartWait)
            {
                if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.StartWaitPlug)
                {
                    LOG_INFO("Connector %d Start Wait Plug In", packet->Header.id);
                    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.SwipeRfidConfirm = true;
                }
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.StartWaitPlug = true;
            }
            else
            {
                if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.StartWaitPlug)
                {
                    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].GeneralChargingData.SystemStatus != S_IDLE)
                    {
                        LOG_INFO("Connector %d Stop Wait Plug In", packet->Header.id);
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.NeedCleanAuthorizeInfo = true;
                    }
                }
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.StartWaitPlug = false;
            }
        }
        else
        {
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[packet->Header.id - 1].Parameter.bits.StartWaitPlug = false;
        }
    }
    else
    {

    }

    return find;
}

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

    if(find)
    {
        gun = packet->Header.id - 1;
        unsigned char enable = packet->Payload.data[0];

        if(chargingInfo[gun]->PantographFlag == YES)
        {
            if(enable == _GFD_Enable &&
                (chargingInfo[gun]->SystemStatus >= S_PREPARING_FOR_EVSE && chargingInfo[gun]->SystemStatus <= S_CHARGING))
            {
                if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].Parameter.bits.GfdDetection != _GFD_Enable)
                {
                    LOG_INFO("Connector %d Gfd Detection Start", gun + 1);
                }
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].Parameter.bits.GfdDetection = _GFD_Enable;
            }
            else
            {
                if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].Parameter.bits.GfdDetection != _GFD_Disable)
                {
                    LOG_INFO("Connector %d Gfd Detection Stop", gun + 1);
                }
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun].Parameter.bits.GfdDetection = _GFD_Disable;
            }
        }
    }
    else
    {

    }

    return find;
}

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;
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.TimeoutStopRequest = true;
	}
}

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;

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

	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 &&
                            dispenserID <= ShmChargerInfo->Control.MaxDispenser)
						{
						    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;
	                                LOG_INFO("********** Dispenser id %d check in, model name: %s **********\n", dispenserID, modelName);
	                                memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ModelName, modelName, 64);
	                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].ConnectionChannel = index;
	                                ackResult = _R_OK;
	                            }
	                            else
	                            {
	                                // response NG: gun quantity fail
	                                LOG_INFO("Dispenser ID %d Identification Fail", dispenserID);
	                            }
	                        }
	                        else
	                        {
	                            // response NG: dispenser Index fail
	                            LOG_INFO("Dispenser ID %d Fail, Need Wait Another Dispenser", dispenserID);
	                        }
						}
						else
						{
						    LOG_INFO("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;
						}
						LOG_INFO("Dispenser ID %d Get Connector ID %s", dispenserID, ackResult == _R_OK ? "OK" : "NG");
						ConnectorIDResponse(socketFd, &receiveBuffer, ackResult, dispenserIndex);

						if(ackResult == _R_OK)
						{
                            if(!ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DispenserConfigSync)
                            {
                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DispenserConfigSync = true;

                                LOG_INFO("Dispenser ID %d Configuration Need To Synchronize", dispenserID);
                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.ConnectorTimeoutConfigRequest = true;
                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DefaultPriceConfigRequest = true;
                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.CurrencyConfigRequest = true;
                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.BackendStatusRequest = true;
                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.EthernetStatusRequest = true;
                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.WiFiStatusRequest = true;
                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.TelcomModemStatusRequest = true;
                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.BillingStatusRequest = true;
                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.StopButtonStatusRequest = true;
                            }
						}
					}

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

					// 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
					if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Software_Update)
					{
					    unsigned char NeedUpgrade = FirmwareUpgradeHandler(&receiveBuffer, dispenserIndex);
                        FirmwareUpgradeResponse(socketFd, &receiveBuffer, dispenserIndex, NeedUpgrade);
					}

					// 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);
					}

					// Reg: 0x0C, Misc Control
					if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Misc_Control)
					{
					    if(MiscControlHandler(&receiveBuffer, dispenserIndex))
					    {
					        ackResult = _R_OK;
					    }
					    MiscControlResponse(socketFd, &receiveBuffer, dispenserIndex, ackResult);
					}

					// Reg: 0x0D, Report csu version
					if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Report_Csu_Version)
                    {
					    if(DispenserWriteCsuVersionInfoHandler(&receiveBuffer, dispenserIndex))
                        {
                            ackResult = _R_OK;
                        }
					    WriteCsuVersionResponse(socketFd, &receiveBuffer, ackResult);
                    }

					// Reg: 0x0E, Report other version
                    if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Report_Other_Version)
                    {
                        if(DispenserWriteOtherVersionInfoHandler(&receiveBuffer, dispenserIndex))
                        {
                            ackResult = _R_OK;
                        }
                        WriteOtherVersionResponse(socketFd, &receiveBuffer, ackResult);
                    }

                    // Reg: 0x0F, Charging info
                    if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_Charging_Info)
                    {
                        if(DispenserWriteChargingInfoHandler(&receiveBuffer, dispenserIndex))
                        {
                            ackResult = _R_OK;
                        }
                        WriteChargingInfoResponse(socketFd, &receiveBuffer, ackResult);
                    }

                    // Reg: 0x10, Charger system id
                    if(receiveBuffer.Header.op == _Header_Read && receiveBuffer.Payload.reg == _Reg_Charger_System_Id)
                    {
                        if(ReadChargerSystemIdHandler(&receiveBuffer, dispenserIndex))
                        {
                            ackResult = _R_OK;
                        }
                        ChargerSystemIdResponse(socketFd, &receiveBuffer, dispenserIndex, ackResult);
                    }

                    // Reg: 0x11, Wait plug in
                    if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_WaitPlugIn)
                    {
                        if(WriteWaitPlugInHandler(&receiveBuffer, dispenserIndex))
                        {
                            ackResult = _R_OK;
                        }
                        WriteWaitPlugInResponse(socketFd, &receiveBuffer, ackResult);
                    }

                    // Reg: 0x12, Ground Fault Detection
                    if(receiveBuffer.Header.op == _Header_Write && receiveBuffer.Payload.reg == _Reg_GroundFaultDetection)
                    {
                        if(GroundFaultDetectionHandler(&receiveBuffer, dispenserIndex))
                        {
                            ackResult = _R_OK;
                        }
                        GroundFaultDetectionResponse(socketFd, &receiveBuffer, ackResult);
                    }
				}

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

        if(timeout >= DISPENSER_SOCKET_TIMEOUT || ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DuplicateIp)
        {
            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenserIndex].Setting.bits.DuplicateIp)
            {
                LOG_INFO("Dispenser %d has been kick", dispenserIndex + 1);
            }
            else
            {
                //timeout
                LOG_INFO("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)
		{
            int dispenser = ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].DispenserIndex;
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].Setting.bits.DuplicateIp = true;
			return true;
		}
	}
	return false;
}

void InitDispenserInfo(void)
{
	for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
	{
	    bool disconnect = false;

		//memset(&ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i], 0x00, sizeof(struct ConnectorInfoData));
	    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].RemoteStatus = 0;
	    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].Enable = 0;
	    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].ReadyToCharge = 0;
	    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].ParentDispensetIndex = 0;
	    disconnect = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].Parameter.bits.Disconnection;
	    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].Parameter.Value = 0;
	    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].Parameter.bits.Disconnection = disconnect;
	    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AuthorizingType = 0;
	    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AuthorizingResult = 0;
	    memset(&ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].WarningInfo, 0x00, sizeof(struct WARNING_CODE_INFO));

	    //memset(&LastWarningInfo[i], 0x00, sizeof(struct WARNING_CODE_INFO));
	}

    //memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo, 0x00, sizeof(struct DispenserInfoData));
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.DispenserQuantity = ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence;
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.TotalConnectorQuantity = ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity;
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentDispenserQuantity = 0;
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentConnectorQuantity = 0;
    for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
    {
        unsigned char localStatus = 0;
        localStatus = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus;
        memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i], 0x00, sizeof(struct DispenserModule));
        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus = localStatus;
    }

    // initial CheckInLog from WiringInfo.DispenserSequence
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status = 0;
    for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence; i++)
    {
        ShmSysConfigAndInfo->SysInfo.DispenserInfo.CheckInLog.Status |= (1 << i);
    }

    // initial ConnectorLog from WiringInfo.WiringSetting
    memset(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog, 0x00, sizeof(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog));
    for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence; i++)
    {
        if(i < GENERAL_GUN_QUANTITY)
        {
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorLog[i] = ShmSysConfigAndInfo->SysConfig.WiringInfo.WiringSetting[i];
        }
    }
    memset(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo, 0x00, sizeof(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo));
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout = 0;
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.DefaultPrice = 0;

	ShmSysConfigAndInfo->SysInfo.DispenserInfo.Currency = ShmSysConfigAndInfo->SysConfig.BillingData.Currency;
}

struct timespec _IpConflicted_time[CONNECTOR_QUANTITY];

void DispenserIpConflictedCheck(void)
{
    while(1)
    {
        for(int i = 0; i < CONNECTOR_QUANTITY; i++)
        {
            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DuplicateIp)
            {
                if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DuplicateIpConfirm == NO)
                {
                    GetClockTime(&_IpConflicted_time[i]);
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DuplicateIpConfirm = true;
                    LOG_INFO("Dispenser %d IP Conflicted Confirm", i + 1);
                }
                else
                {
                    if((GetTimeoutValue(_IpConflicted_time[i]) / mSEC_VAL) >= IP_CONFLICTED_TIME)
                    {
                        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_None &&
                            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_Timeout)
                        {
                            unsigned char channel = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectionChannel;

                            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[channel].Status != _CNS_FREE)
                            {
                                LOG_INFO("Dispenser %d IP Conflicted Stop", i + 1);
                                DisableConnector(i);
                                memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i], 0x00, sizeof(struct DispenserModule));
                                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus = _DS_Timeout;
                                DispenserCheckInInfoUpdate();
                                memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[channel], 0x00, sizeof(struct ConnectionInfoData));
                            }
                        }
                        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DuplicateIp = false;
                        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DuplicateIpConfirm = false;
                        LOG_INFO("Dispenser %d IP Conflicted Clean", i + 1);
                    }
                }
            }
        }
        usleep(500000);
    }
}

void ForkIpConflictedCheck(void)
{
    pid_t forkId;

    forkId = fork();
    if(forkId == 0)
    {
        DispenserIpConflictedCheck();
        return;
    }
    else if(forkId == -1)
    {
        LOG_INFO("fork fail");
    }
}

int tcpSocketServerStart(void)
{
    int sockFd = 0;
    int clientSockFd = 0;
    int connectIndex = 0;
    int bindStatus = 0;
    int reuseaddr = 1;
    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)
    {
        LOG_INFO("InitSocketServer NG\n");
        sleep(5);
        return FAIL;
    }

    setsockopt(sockFd, SOL_SOCKET, SO_REUSEADDR, &reuseaddr, sizeof(reuseaddr));

    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);
    bindStatus = bind(sockFd, (struct sockaddr *)&serverInfo, sizeof(serverInfo));
    if(bindStatus < 0)
    {
        LOG_INFO("socket bind fail");
        return FAIL;
    }
	listen(sockFd, CONNECTION_LIMIT);

	LOG_INFO("TCP Server Start");

	signal(SIGCHLD, SIG_IGN);

	ForkIpConflictedCheck();

	// Main loop
	while(1)
	{
		clientSockFd = accept(sockFd, (struct sockaddr*) &clientInfo, &addrlen);
		/*
		if((errno == EWOULDBLOCK) || (errno == EAGAIN) || (errno == ENONET) ||
            (errno == EPROTO) || (errno == ENOPROTOOPT) || (errno == EOPNOTSUPP) ||
            (errno == ENETDOWN) || (errno == ENETUNREACH) || (errno == EHOSTDOWN) ||
            (errno == EHOSTUNREACH) || (errno == ECONNABORTED))
		{
		    printf("accept error: %s\n", strerror(errno));
            //exit(EXIT_FAILURE);
            //break;
		}
		else if ( errno == EINTR)
		{
		    printf("accept EINTRn");
		    continue;
		}
		else
		{
            printf("AccepCb: accept error: %s\n", strerror(errno));
            //break;
            //exit(EXIT_FAILURE);
		}*/
		LOG_INFO("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 0;
				}
				else if(forkId == -1)
				{
					LOG_INFO("fork fail");
				}
			}
			else
			{
				// conflict ip address
				LOG_INFO("Conflict IP address, close socket");
				close(clientSockFd);
				memset(&ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[connectIndex], 0x00, sizeof(struct ConnectionInfoData));
			}
		}
		else
		{
			// no free channel
			LOG_INFO("No free channel, close socket");
			close(clientSockFd);
		}
		usleep(10000);
	}

	return 0;
}

void InitialConnector(void)
{
    for(int i = 0; i < CONNECTOR_QUANTITY; i++)
    {
        chargingInfo[i] = &ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData;
    }
}

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

		sleep(5);
		return 0;
	}

	InitialConnector();

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

    tcpSocketServerStart();

	//tcpSocketClientStart();

	return 0;
}