#include	"define.h"
#include 	"main.h"

//==========================
// Basic sample constant
//==========================
#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 BUFFER_SIZE							128

//==========================
// Timer interval
//==========================
#define TMR_IDX_HANDSHAKING			0
#define TMR_IDX_AUTH				1
#define TMR_IDX_2					2
#define TMR_IDX_3					3
#define TMR_IDX_4					4
#define TMR_IDX_5					5
#define TMR_IDX_6					6
#define TMR_IDX_7					7
#define TMR_IDX_8					8
#define TMR_IDX_9 					9

#define TIMEOUT_SPEC_HANDSHAKING	180000
#define TIMEOUT_SPEC_AUTH			30000

//==========================
// Declare method
//==========================
void trim(char *s);
int mystrcmp(char *p1,char *p2);
void substr(char *dest, const char* src, unsigned int start, unsigned int cnt);
void split(char **arr, char *str, const char *del);

int InitialRfidPort(void);
int GetAlarmValue(void);
int GetInfoValue(void);
int GetFaultValue(void);
int GetCardSerialNumber();
void setLedMotion(unsigned char gun_index,unsigned char led_mode);
void setRelay(unsigned char gun_index,unsigned char isOn);

//==========================
// Declare information method
//==========================
void GetInfoFromWebServer();
void GetInfoFromWifiModule();
void GetInfoFrom4gModule();

//==========================
// Declare RFID module type
//==========================
#define MODULE_EWT		0

//==========================
// Declare share memory
//==========================
struct SysConfigAndInfo			*ShmSysConfigAndInfo;
struct StatusCodeData			*ShmStatusCodeData;
struct PsuData					*ShmPsuData;
struct CHAdeMOData				*ShmCHAdeMOData;
struct CcsData					*ShmCcsData;
struct PrimaryMcuData			*ShmPrimaryMcuData;
struct FanModuleData			*ShmFanModuleData;
struct RelayModuleData			*ShmRelayModuleData;
struct OCPP16Data				*ShmOCPP16Data;
struct Charger					*ShmCharger;

struct timeb					startTime[10];
struct timeb					startChargingTime[AC_QUANTITY];
struct timeb					endChargingTime[AC_QUANTITY];

int rfidFd = -1;
char* rfidPortName = "/dev/ttyS2";
RFID rfid;

//=================================
// Common routine
//=================================
void trim(char *s)
{
    int i=0, j, k, l=0;

    while((s[i]==' ')||(s[i]=='\t')||(s[i]=='\n'))
        i++;

    j = strlen(s)-1;
    while((s[j]==' ')||(s[j]=='\t')||(s[j]=='\n'))
        j--;

    if(i==0 && j==strlen(s)-1) { }
    else if(i==0) s[j+1] = '\0';
    else {
        for(k=i; k<=j; k++) s[l++] = s[k];
        s[l] = '\0';
    }
}

int mystrcmp(char *p1,char *p2)
{
    while(*p1==*p2)
    {
        if(*p1=='\0' || *p2=='\0')
            break;
        p1++;
        p2++;
    }
    if(*p1=='\0' && *p2=='\0')
        return(PASS);
    else
        return(FAIL);
}

void substr(char *dest, const char* src, unsigned int start, unsigned int cnt)
{
	strncpy(dest, src + start, cnt);
	dest[cnt] = 0;
}

void split(char **arr, char *str, const char *del)
{
	char *s = strtok(str, del);

	while(s != NULL)
	{
		*arr++ = s;
		s = strtok(NULL, del);
	}
}

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

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

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

	printf("[%04d.%02d.%02d %02d:%02d:%02d] - %s", tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec, buffer);

	return rc;
}

int DiffTimeb(struct timeb ST)
{
	//return milli-second
	struct timeb ET;
	unsigned int StartTime,StopTime;

	ftime(&ET);
	StartTime=(unsigned int)ST.time;
	StopTime=(unsigned int)ET.time;
	return (StopTime-StartTime)*1000+ET.millitm-ST.millitm;
}

int DiffTimeb2(struct timeb ST, struct timeb ET)
{
	//return milli-second
	unsigned int StartTime,StopTime;

	StartTime=(unsigned int)ST.time;
	StopTime=(unsigned int)ET.time;
	//return (StopTime-StartTime)*1000+ET.millitm-ST.millitm;
	return (StopTime-StartTime);
}

//======================================================
// Check interface status
//======================================================
int isInterfaceUp(const char *interface)
{
	int result = FAIL;

	FILE *fp;
	char cmd[256];
	char buf[512];

	strcpy(cmd, "ifconfig");;
	fp = popen(cmd, "r");
	if(fp != NULL)
	{
		while(fgets(buf, sizeof(buf), fp) != NULL)
		{
			if(strstr(buf, interface) > 0)
			{
				result = PASS;
			}
		}
	}
	pclose(fp);

	return result;
}

//=================================
// Create all share memory
//=================================
int CreatShareMemory()
{
	int result = PASS;
	int MeterSMId;

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

		DEBUG_ERROR("shmat ShmSysConfigAndInfo NG\r\n");

		result = FAIL;
	}
	memset(ShmSysConfigAndInfo,0,sizeof(struct SysConfigAndInfo));

	//creat ShmStatusCodeData
	if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData), IPC_CREAT | 0777)) < 0)
	{

		DEBUG_ERROR("shmget ShmStatusCodeData NG\r\n");

		result = FAIL;
	}
	else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{

		DEBUG_ERROR("shmat ShmStatusCodeData NG\r\n");

		result = FAIL;
	}
	memset(ShmStatusCodeData, 0, sizeof(struct StatusCodeData));

	//creat ShmPsuData
	if ((MeterSMId = shmget(ShmPsuKey, sizeof(struct PsuData), IPC_CREAT | 0777)) < 0)
	{

		DEBUG_ERROR("shmget ShmPsuData NG\r\n");

		result = FAIL;
	}
	else if ((ShmPsuData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{

		DEBUG_ERROR("shmat ShmPsuData NG\r\n");

		result = FAIL;
	}
	memset(ShmPsuData,0,sizeof(struct PsuData));

	//creat ShmCHAdeMOData
	if ((MeterSMId = shmget(ShmCHAdeMOCommKey, sizeof(struct CHAdeMOData), IPC_CREAT | 0777)) < 0)
	{

		DEBUG_ERROR("shmget ShmCHAdeMOData NG1\r\n");

		result = FAIL;
	}
	else if ((ShmCHAdeMOData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{

		DEBUG_ERROR("shmat ShmCHAdeMOData NG2\r\n");

		result = FAIL;
	}
	memset(ShmCHAdeMOData,0,sizeof(struct CHAdeMOData));

	//creat ShmCcsData
	if ((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData), IPC_CREAT | 0777)) < 0)
	{

		DEBUG_ERROR("shmget ShmCcsData NG\r\n");

		result = FAIL;
	}
	else if ((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{

		DEBUG_ERROR("shmat ShmCcsData NG\r\n");

		result = FAIL;
	}
	memset(ShmCcsData,0,sizeof(struct CcsData));

	//creat ShmPrimaryMcuData
	if ((MeterSMId = shmget(ShmPrimaryMcuKey, sizeof(struct PrimaryMcuData), IPC_CREAT | 0777)) < 0)
	{

		DEBUG_ERROR("shmget ShmPrimaryMcuData NG\r\n");

		result = FAIL;
	}
	else if ((ShmPrimaryMcuData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{

		DEBUG_ERROR("shmat ShmPrimaryMcuData NG\r\n");

		result = FAIL;
	}
	memset(ShmPrimaryMcuData,0,sizeof(struct PrimaryMcuData));

	 /*
	 //creat ShmFanModuleData
	if ((MeterSMId = shmget(ShmFanBdKey, sizeof(struct FanModuleData), IPC_CREAT | 0777)) < 0)
	{

		DEBUG_ERROR("shmget ShmFanModuleData NG\r\n");

		result = FAIL;
	}
	else if ((ShmFanModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{

		DEBUG_ERROR("shmat ShmFanModuleData NG\r\n");

		result = FAIL;
	 }
	 memset(ShmFanModuleData,0,sizeof(struct FanModuleData));

	 //creat ShmRelayModuleData
	if ((MeterSMId = shmget(ShmRelayBdKey, sizeof(struct RelayModuleData), IPC_CREAT | 0777)) < 0)
	{

		DEBUG_ERROR("shmget ShmRelayModuleData NG\r\n");

		result = FAIL;
	}
	else if ((ShmRelayModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{

		DEBUG_ERROR("shmat ShmRelayModuleData NG\r\n");

		result = FAIL;
	}
	memset(ShmRelayModuleData,0,sizeof(struct RelayModuleData));*/

	//creat ShmOCPP16Data
	if ((MeterSMId = shmget(ShmOcppModuleKey, sizeof(struct OCPP16Data), IPC_CREAT | 0777)) < 0)
	{

		DEBUG_ERROR("shmget ShmOCPP16Data NG\r\n");

		result = FAIL;
	}
	else if ((ShmOCPP16Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{

		DEBUG_ERROR("shmat ShmOCPP16Data NG\r\n");

		result = FAIL;
	}
	memset(ShmOCPP16Data,0,sizeof(struct OCPP16Data));

	//creat ShmCharger
	if ((MeterSMId = shmget(ShmChargerKey, sizeof(struct Charger), IPC_CREAT | 0777)) < 0)
	{

		DEBUG_ERROR("shmget ShmCharger NG\r\n");

		result = FAIL;
	}
	else if ((ShmCharger = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{

		DEBUG_ERROR("shmat ShmCharger NG\r\n");

		result = FAIL;
	}
	memset(ShmCharger,0,sizeof(struct Charger));

	return result;
}

//======================================================
// Peripheral initial
//======================================================
void InitGPIO()
{
	/*****************0~3, 4 bank, bank x 32+ num*********************/
	/***************************************************************/
	/*************** INPUT PIN ***************************************/
	/***************************************************************/

	/***************************************************************/
	/*************** OUTPUT PIN ************************************/
	/***************************************************************/
	/*MCU request:GPIO3_20 => H:ON; L:OFF*/
	system("echo 116 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio116/direction");
	system("echo 0 > /sys/class/gpio/gpio116/value");

	/*Rfid:GPIO0_19 => Reset_PING H:ON; L:OFF*/
	system("echo 19 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio19/direction");
	system("echo 1 > /sys/class/gpio/gpio19/value");

	/*Speaker:GPIO2_1 => H:ON; L:OFF*/
	system("echo 65 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio65/direction");
	system("echo 0 > /sys/class/gpio/gpio65/value");

	DEBUG_INFO("Initial GPIO OK\r\n");
}

int LoadSysConfigAndInfo(struct SysConfigData *ptr)
{
	int fd,wrd;
	struct SysConfigData *buf;
	unsigned char *PtrBuf;
	unsigned int ChkSum,ChkSumOrg;

	if((buf=malloc(sizeof(struct SysConfigData)))==NULL)
	{

		DEBUG_ERROR("malloc buffer NG,rebooting..\r\n");

		if(ShmStatusCodeData!=NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
		}
		sleep(5);
		system("reboot -f");
		sleep(5);
		system("reboot -f");
	}
	memset(buf, 0, sizeof(struct SysConfigData));

	//================================================
	// Load configuration from mtdblock10
	//================================================
	fd = open("/dev/mtdblock10", O_RDWR);
	if (fd < 0)
	{
		free(buf);

		DEBUG_ERROR("open mtdblock10 NG,rebooting..\r\n");

		if(ShmStatusCodeData!=NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
		}
		sleep(5);
		system("reboot -f");
		sleep(5);
		system("reboot -f");
	}
    wrd=read(fd, buf,sizeof(struct SysConfigData));
	close(fd);
	if(wrd!=(sizeof(struct SysConfigData)))
	{
		free(buf);

		DEBUG_ERROR("read SysConfigData data NG,rebooting..\r\n");

		if(ShmStatusCodeData!=NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
		}
		sleep(5);
		system("reboot -f");
		sleep(5);
		system("reboot -f");
	}
	PtrBuf=(unsigned char *)buf;
	ChkSum=0;
	for(wrd=0;wrd<(sizeof(struct SysConfigData)-4);wrd++)
	{
		ChkSum+=PtrBuf[wrd];
	}
	ChkSumOrg=buf->Checksum;

	//================================================
	// Load configuration from mtdblock11
	//================================================
	if(ChkSum!=ChkSumOrg)
	{

		DEBUG_ERROR("Primary SysConfigData checksum NG, read backup\r\n");

		fd = open("/dev/mtdblock11", O_RDWR);
		if (fd < 0)
		{
			free(buf);

			DEBUG_ERROR("open mtdblock11 (backup) NG,rebooting..\r\n");

			if(ShmStatusCodeData!=NULL)
			{
				ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
			}
			sleep(5);
			system("reboot -f");
			sleep(5);
			system("reboot -f");
	    }
	    memset(buf, 0, sizeof(struct SysConfigData));
   		wrd=read(fd, buf,sizeof(struct SysConfigData));
    	close(fd);
		if(wrd!=sizeof(struct SysConfigData))
		{
			free(buf);

			DEBUG_ERROR("read backup SysConfigData data NG,rebooting..\r\n");

			if(ShmStatusCodeData!=NULL)
			{
				ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
			}
			sleep(5);
			system("reboot -f");
			sleep(5);
			system("reboot -f");
		}
		PtrBuf=(unsigned char *)buf;
		ChkSum=0;
		for(wrd=0;wrd<(sizeof(struct SysConfigData)-4);wrd++)
		{
			ChkSum+=PtrBuf[wrd];
		}
		ChkSumOrg=buf->Checksum;

		//================================================
		// Load configuration from mtdblock12 (Factory default)
		//================================================
		if(ChkSum!=ChkSumOrg)
		{

			DEBUG_WARN("backup SysConfigData checksum NG, read Factory default\r\n");

			fd = open("/dev/mtdblock12", O_RDWR);
			if (fd < 0)
			{
				free(buf);

				DEBUG_ERROR("open mtdblock12 (Factory default) NG,rebooting..\r\n");

				if(ShmStatusCodeData!=NULL)
				{
					ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
				}
				sleep(5);
				system("reboot -f");
				sleep(5);
				system("reboot -f");
	    	}
	    	memset(buf, 0, sizeof(struct SysConfigData));
   			wrd=read(fd, buf,sizeof(struct SysConfigData));
    		close(fd);
			if(wrd!=sizeof(struct SysConfigData))
			{
				free(buf);

				DEBUG_ERROR("read factory default  SysConfigData data NG,rebooting..\r\n");

				if(ShmStatusCodeData!=NULL)
				{
					ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
				}
				sleep(5);
				system("reboot -f");
				sleep(5);
				system("reboot -f");
			}
			PtrBuf=(unsigned char *)buf;
			ChkSum=0;
			for(wrd=0;wrd<(sizeof(struct SysConfigData)-4);wrd++)
			{
				ChkSum+=PtrBuf[wrd];
			}
			ChkSumOrg=buf->Checksum;
			if(ChkSum!=ChkSumOrg)
			{
				DEBUG_WARN("factory default  SysConfigData checksum NG, restore factory default\r\n");

				system("cd /root;./Module_FactoryConfig");
				system("sync");
				sleep(5);
				system("reboot -f");
				sleep(5);
				system("reboot -f");

				return FAIL;
			}
		}
	}

	//load OK
	memcpy((struct SysConfigData *)ptr,(struct SysConfigData *)buf,sizeof(struct SysConfigData));
	free(buf);

	DEBUG_INFO("Load SysConfigData OK\r\n");

	return PASS;

}

void InitEthernet()
{
	char tmpbuf[256];
	//unsigned int address;

	//Init Eth0 for internet
	if(isInterfaceUp("eth0")==PASS)
	{
		memset(tmpbuf,0,256);
		sprintf(tmpbuf,"/sbin/ifconfig eth0 %s netmask %s up",
		ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress,
		ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthSubmaskAddress);
		system(tmpbuf);
		memset(tmpbuf,0,256);
		sprintf(tmpbuf,"route add default gw %s eth0 ",
		ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthGatewayAddress);
		system(tmpbuf);
	}

	if(isInterfaceUp("eth1")==PASS)
	{
		//Init Eth1 for administrator tool
		memset(tmpbuf,0,256);
		sprintf(tmpbuf,"/sbin/ifconfig eth1 %s netmask %s up",
		ShmSysConfigAndInfo->SysConfig.Eth1Interface.EthIpAddress,
		ShmSysConfigAndInfo->SysConfig.Eth1Interface.EthSubmaskAddress);
		system(tmpbuf);
	}


    //Run DHCP client if enabled
	system("killall udhcpc");
	system("rm -rf /etc/resolv.conf");
	system("echo nameserver 8.8.8.8 > /etc/resolv.conf");		//Google DNS server
	system("echo nameserver 180.76.76.76 > /etc/resolv.conf");	//Baidu DNS server

	if(ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthDhcpClient==0)
		system("/sbin/udhcpc -i eth0 -s /root/simple.script > /dev/null &");


	DEBUG_INFO("Initial Ethernet OK\r\n");

}

int SpawnTask()
{

	system ("pkill Module_4g");
	system ("pkill Module_Wifi");
	system ("pkill Module_EventLogging");
	//system ("pkill Module_OcppBackend");
	system ("pkill Module_AlarmDetect");
	system ("pkill Module_InternalComm");

	if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T')
	{
		system("/root/Module_4g &");
	}
	else if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W')
	{
		system("/root/Module_Wifi &");
	}

	system("/root/Module_EventLogging &");
	//system("/root/Module_OcppBackend &");
	system("/root/Module_AlarmDetect &");
	system("/root/Module_InternalComm &");


	return PASS;
}

int StoreUsrConfigData(struct SysConfigData *UsrData)
{
	int result = PASS;
	int fd,wrd;
	unsigned int i,Chk;
	unsigned char *ptr;

	Chk=0;
	ptr=(unsigned char *)UsrData;
	for(i=0;i<sizeof(struct SysConfigData)-4;i++)
	{
		Chk+=*(ptr+i);
	}
	UsrData->Checksum=Chk;

	fd = open("/dev/mtdblock10", O_RDWR);
	if (fd < 0)
	{

		DEBUG_ERROR("open /dev/mtdblock10 NG\r\n");

		result = FAIL;
	}
   	wrd=write(fd, UsrData, sizeof(struct SysConfigData));
	close(fd);
	if(wrd!=(sizeof(struct SysConfigData)))
	{

    	DEBUG_ERROR("write /dev/mtdblock10 NG\r\n");

    	result = FAIL;
	}

	fd = open("/dev/mtdblock11", O_RDWR);
	if (fd < 0)
	{

		DEBUG_ERROR("open /dev/mtdblock11(backup) NG\r\n");

		result = FAIL;
    }
    wrd=write(fd, UsrData, sizeof(struct SysConfigData));
    close(fd);
   	if(wrd!=(sizeof(struct SysConfigData)))
	{

   		DEBUG_ERROR("write /dev/mtdblock11(backup) NG\r\n");

   		result = FAIL;
	}

	return result;
}

int Initialization()
{
	LoadSysConfigAndInfo(&ShmSysConfigAndInfo->SysConfig);

	InitGPIO();

	//InitEthernet();

	rfidFd = InitialRfidPort();

	// Configuration initial for test
//	ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode = 1;
//	sprintf((char*)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiSsid, "ASUS_AP");
//	sprintf((char*)ShmSysConfigAndInfo->SysConfig.AthInterface.WifiPassword , "1231231238");
//
//	sprintf((char*)ShmOCPP16Data->OcppServerURL, "ws://test.evsocket.phihong.com.cn:2012/ocpp/");
//	sprintf((char*)ShmOCPP16Data->ChargeBoxId, (char*)ShmSysConfigAndInfo->SysConfig.SystemId);
//
//	sprintf((char*)ShmOCPP16Data->BootNotification.CpFwVersion, (char*)ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev);
//	sprintf((char*)ShmOCPP16Data->BootNotification.CpMeterSerialNumber, "N/A");
//	sprintf((char*)ShmOCPP16Data->BootNotification.CpMeterType, "AC");
//
//	DEBUG_INFO("Wifi SSID: %s\r\n",  ShmSysConfigAndInfo->SysConfig.AthInterface.WifiSsid);
//	DEBUG_INFO("Wifi password: %s\r\n",  ShmSysConfigAndInfo->SysConfig.AthInterface.WifiPassword);

	DEBUG_INFO("Initialization OK\r\n");

	return PASS;
}

//=====================================================
// Common routine
//=====================================================
char* getSystemModeName(unsigned char mode)
{
	char* result;

	switch(mode)
	{
		case MODE_BOOTING:
			result = "booting";
			break;
		case MODE_IDLE:
			result = "idle";
			break;
		case MODE_AUTHORIZING:
			result = "authorizing";
			break;
		case MODE_PREPARING:
			result = "preparing";
			break;
		case MODE_CHARGING:
			result = "charging";
			break;
		case MODE_TERMINATING:
			result = "terminating";
			break;
		case MODE_ALARM:
			result = "alarm";
			break;
		case MODE_FAULT:
			result = "fault";
			break;
		case MODE_MAINTAIN:
			result = "maintain";
			break;
		case MODE_RESERVATION:
			result = "reservation";
			break;
		case MODE_BOOKING:
			result = "booking";
			break;
	}

	return result;
}

void setChargerMode(unsigned char gun_index, unsigned char mode)
{
	ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PreviousSystemStatus = ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].SystemStatus;
	ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].SystemStatus = mode;

	DEBUG_INFO("Gun-%02d mode switch from %s to %s\r\n", gun_index, getSystemModeName(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PreviousSystemStatus), getSystemModeName(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].SystemStatus));
}

unsigned char isMode(unsigned char gun_index, unsigned char mode)
{
	return ((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].SystemStatus == mode)?YES:NO);
}

unsigned char isModeChange(unsigned char gun_index)
{
	unsigned char result = NO;

	if(!isMode(gun_index, ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PreviousSystemStatus))
	{
		result = YES;
		ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PreviousSystemStatus = ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].SystemStatus;
	}

	return result;
}

//===============================================
// Set led motion
//===============================================
void setLedMotion(unsigned char gun_index,unsigned char led_mode)
{
	switch(led_mode)
	{
		case LED_ACTION_INIT:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_INIT;
			break;
		case LED_ACTION_IDLE:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_IDLE;
			break;
		case LED_ACTION_AUTHED:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_AUTHED;
			break;
		case LED_ACTION_CONNECTED:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_CONNECTED;
			break;
		case LED_ACTION_CHARGING:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_CHARGING;
			break;
		case LED_ACTION_STOP:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_STOP;
			break;
		case LED_ACTION_ALARM:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_ALARM;
			break;
		case LED_ACTION_MAINTAIN:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_MAINTAIN;
			break;
		case LED_ACTION_RFID_PASS:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_RFID_PASS;
			break;
		case LED_ACTION_RFID_FAIL:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_RFID_FAIL;
			break;
		case LED_ACTION_BLE_CONNECT:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_BLE_CONNECT;
			break;
		case LED_ACTION_BLE_DISABLE:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_BLE_DISABLE;
			break;
		case LED_ACTION_DEBUG:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_DEBUG;
			break;
		case LED_ACTION_ALL_OFF:
			ShmCharger->gun_info[gun_index].primaryMcuLed.mode = LED_ACTION_ALL_OFF;
			break;
	}
}

//===============================================
// Relay on/off request
//===============================================
void setRelay(unsigned char gun_index,unsigned char isOn)
{
	if(isOn == ON)
	{
		if(ShmCharger->gun_info[gun_index].legacyRequest.isLegacyRequest == OFF)
		{
			ShmCharger->gun_info[gun_index].legacyRequest.isLegacyRequest = ON;
			DEBUG_INFO("Gun-%d Output relay sts: ON \r\n",gun_index);
		}
	}
	else
	{
		if(ShmCharger->gun_info[gun_index].legacyRequest.isLegacyRequest == ON)
		{
			ShmCharger->gun_info[gun_index].legacyRequest.isLegacyRequest = OFF;
			DEBUG_INFO("Gun-%d Output relay sts: OFF \r\n",gun_index);
		}
	}
}

//===============================================
// Initialization RFID communication port
//===============================================
int InitialRfidPort()
{
	int uartO2 = open(rfidPortName, O_RDWR);
		struct termios tios;

	if (uartO2 != FAIL)
	{
		ioctl (uartO2, TCGETS, &tios);
		tios.c_cflag = B19200 | CS8 | CLOCAL | CREAD;
		tios.c_lflag = 0;
		tios.c_iflag = 0;
		tios.c_oflag = 0;
		tios.c_cc[VMIN] = 0;
		tios.c_cc[VTIME] = (unsigned char) 1;
		tios.c_lflag = 0;
		tcflush(uartO2, TCIFLUSH);
		ioctl(uartO2, TCSETS, &tios);
	}

	if (uartO2 < 0)
	{
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RfidModuleCommFail = 1;
	}

	return uartO2;
}

//==========================
//	Read RFID Serial Number
//==========================
int GetCardSerialNumber()
{
	int isSuccess = FAIL;
	int module_type = MODULE_EWT;

	if(getRequestCardSN(rfidFd,module_type,&rfid))
	{
		if(rfid.cardType == ISO14443A)
		{
			if(rfid.snType == RFID_SN_TYPE_4BYTE)
			{
				isSuccess = PASS;
			}
			else if (rfid.snType == RFID_SN_TYPE_7BYTE)
			{
				isSuccess = PASS;
			}
		}
		else if(rfid.cardType == IS014443B)
		{
			isSuccess = PASS;
		}
		else if(rfid.cardType == FELICA)
		{
			isSuccess = PASS;
		}
		else
		{}
	}
	else
	{}

	return isSuccess;
}

//====================================================
// Upgrade routine
//====================================================
int upgrade_check()
{
	int result = PASS;
	int fd;
	DIR *dir;
	struct dirent *file;
	char cmd[512];
	long int MaxLen=48*1024*1024;

	if ((dir = opendir ("/mnt")) != NULL)
	{
		/* print all the files and directories within directory */
		while ((file = readdir (dir)) != NULL)
		{
			if(strlen(file->d_name)>2)
			{
				memset(&ShmCharger->fwUpgradeInfo, 0xFF, sizeof(Fw_Upgrade_Info));
				DEBUG_INFO("New firmware file: %s\n", file->d_name);
				sprintf(ShmCharger->fwUpgradeInfo.location, "/mnt/%s", file->d_name);

				if((fd=open(ShmCharger->fwUpgradeInfo.location, O_RDONLY)) >= 0)
				{
					unsigned char *ptr = malloc(MaxLen); //-48 is take out the header
					memset(ptr, 0xFF, MaxLen);  //-48 is take out the header
					read(fd, ptr, MaxLen);
					close(fd);

					ShmCharger->fwUpgradeInfo.fwType = ((ptr[0x13]<<0) | (ptr[0x12]<<8) | (ptr[0x11]<<16) | (ptr[0x10]<<24));
					substr(ShmCharger->fwUpgradeInfo.modelName, (char *)ptr, 0, 0x10);
					DEBUG_INFO("New firmware type: %X\r\n", ShmCharger->fwUpgradeInfo.fwType);
					DEBUG_INFO("New firmware model name: %s, %s\r\n", ShmCharger->fwUpgradeInfo.modelName, ShmSysConfigAndInfo->SysConfig.ModelName);

					if((strcmp(ShmCharger->fwUpgradeInfo.modelName, (char*)ShmSysConfigAndInfo->SysConfig.ModelName)==0) && (ShmCharger->fwUpgradeInfo.fwType>0))
					{
						switch(ShmCharger->fwUpgradeInfo.fwType)
						{
							case CSU_BOOTLOADER:
							case CSU_KERNEL_CONFIGURATION:
							case CSU_KERNEL_IMAGE:
							case CSU_ROOT_FILE_SYSTEM:
							case CSU_USER_CONFIGURATION:
							case CSU_PRIMARY_CONTROLLER:
								if(!Upgrade_Flash(ShmCharger->fwUpgradeInfo.fwType, ShmCharger->fwUpgradeInfo.location, ShmCharger->fwUpgradeInfo.modelName))
									result = FAIL;

								sprintf(cmd, "yes|rm %s", ShmCharger->fwUpgradeInfo.location);
								system(cmd);
								break;
							case AC_WALLMOUNT_CONTROLLER:
								for(int gun_index = 0;gun_index<AC_QUANTITY;gun_index++)
									ShmCharger->gun_info[gun_index].mcuFlag.isMcuUpgradeReq = ON;
								break;
							default:
								DEBUG_WARN("Image file is unknown type.\r\n");
								sprintf(cmd, "yes|rm %s", ShmCharger->fwUpgradeInfo.location);
								system(cmd);
								break;
						}
					}

					free(ptr);
				}
				else
				{
					// File open error
					DEBUG_ERROR("New firmware open error.\r\n");
				}
			}
		}
		closedir (dir);
	}
	else
	{
	  DEBUG_ERROR("/mnt does not valid.\r\n");
	}

	return result;
}

//===============================================
// 4g module info check
//===============================================
void GetInfoFrom4gModule()
{
	DEBUG_INFO("==============================\r\n");
	DEBUG_INFO("TelcomIpAddress: %s\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomIpAddress);
	DEBUG_INFO("Telecom4GModuleCommFail: %d\r\n", ShmStatusCodeData->AlarmCode.AlarmEvents.bits.Telecom4GModuleCommFail);
	DEBUG_INFO("Telecom4GModuleBroken: %d\r\n", ShmStatusCodeData->FaultCode.FaultEvents.bits.Telecom4GModuleBroken);
	DEBUG_INFO("TelcomNetworkConn: %d\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomNetworkConn);
	DEBUG_INFO("TelcomModemMode: %d\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomModemMode);
	DEBUG_INFO("TelcomModemImei: %s\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomModemImei);
	DEBUG_INFO("TelcomSimImsi: %s\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomSimImsi);
	DEBUG_INFO("TelcomModemFwRev: %s\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomSoftwareVer);
	DEBUG_INFO("TelcomSimStatus: %d\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomSimStatus);
	DEBUG_INFO("TelcomSimIccid: %.20s\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomSimIccid);
	DEBUG_INFO("TelcomRssi: %d\r\n", ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomRssi);
	DEBUG_INFO("==============================\r\n");

	sleep(5);
}

//===============================================
// Wifi module info check
//===============================================
void GetInfoFromWifiModule()
{
	DEBUG_INFO("==============================\r\n");
	DEBUG_INFO("WifiMode: %d\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode);
	DEBUG_INFO("WifiSsid: %s\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiSsid);
	DEBUG_INFO("WifiPassword: %s\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiPassword);
	DEBUG_INFO("WifiRssi: %d\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiRssi);
	DEBUG_INFO("WifiDhcpServer: %d\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiDhcpServer);
	DEBUG_INFO("WifiDhcpClient: %d\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiDhcpClient);
	DEBUG_INFO("WifiMacAddress: %s\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMacAddress);
	DEBUG_INFO("WifiIpAddress: %s\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiIpAddress);
	DEBUG_INFO("WifiSubmaskAddress: %s\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiSubmaskAddress);
	DEBUG_INFO("WifiGatewayAddress: %s\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiGatewayAddress);
	DEBUG_INFO("WifiNetworkConn: %d\r\n", ShmSysConfigAndInfo->SysConfig.AthInterface.WifiNetworkConn);
	DEBUG_INFO("==============================\r\n");

	sleep(5);
}

//===============================================
// WebSer module info check
//===============================================
void GetInfoFromWebServer()
{
	DEBUG_INFO("==============================\r\n");

	DEBUG_INFO("ModelName : %s\r\n", ShmSysConfigAndInfo->SysConfig.ModelName);
	DEBUG_INFO("SerialNumber : %s\r\n", ShmSysConfigAndInfo->SysConfig.SerialNumber);


	DEBUG_INFO("SystemId : %s\r\n ",ShmSysConfigAndInfo->SysConfig.SystemId);
	DEBUG_INFO("RfidCardNumEndian : %d\r\n",ShmSysConfigAndInfo->SysConfig.RfidCardNumEndian);
	DEBUG_INFO("AcPhaseCount : %d\r\n ",ShmSysConfigAndInfo->SysConfig.AcPhaseCount);
	DEBUG_INFO("AuthorisationMode : %d\r\n ",ShmSysConfigAndInfo->SysConfig.AuthorisationMode);
	DEBUG_INFO("MaxChargingEnergy : %d\r\n ",ShmSysConfigAndInfo->SysConfig.MaxChargingEnergy);
	DEBUG_INFO("MaxChargingPower : %d\r\n ",ShmSysConfigAndInfo->SysConfig.MaxChargingPower);
	DEBUG_INFO("MaxChargingCurrent : %d\r\n ",ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent);
	DEBUG_INFO("MaxChargingDuration : %d\r\n ",ShmSysConfigAndInfo->SysConfig.MaxChargingDuration);

	DEBUG_INFO("FtpServer : %s\r\n ",ShmSysConfigAndInfo->SysConfig.FtpServer);
	DEBUG_INFO("EthDhcpClient : %d\r\n ",ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthDhcpClient);
	DEBUG_INFO("EthMacAddress : %s\r\n ",ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthMacAddress);
	DEBUG_INFO("EthIpAddress : %s\r\n ",ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress);
	DEBUG_INFO("EthSubmaskAddress : %s\r\n ",ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthSubmaskAddress);
	DEBUG_INFO("EthGatewayAddress : %s\r\n ",ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthGatewayAddress);

	DEBUG_INFO("BackendConnTimeout : %d\r\n ",ShmSysConfigAndInfo->SysConfig.BackendConnTimeout);
	DEBUG_INFO("OfflinePolicy : %d\r\n ",ShmSysConfigAndInfo->SysConfig.OfflinePolicy);
	DEBUG_INFO("OfflineMaxChargeEnergy : %d\r\n ",ShmSysConfigAndInfo->SysConfig.OfflineMaxChargeEnergy);
	DEBUG_INFO("OfflineMaxChargeDuration : %d\r\n ",ShmSysConfigAndInfo->SysConfig.OfflineMaxChargeDuration);
	DEBUG_INFO("OcppConnStatus : %d\r\n ",ShmSysConfigAndInfo->SysInfo.OcppConnStatus);
	DEBUG_INFO("OcppServerURL : %s\r\n ",ShmSysConfigAndInfo->SysConfig.OcppServerURL);
	DEBUG_INFO("ChargeBoxId : %s\r\n ",ShmSysConfigAndInfo->SysConfig.ChargeBoxId);

	DEBUG_INFO("==============================\r\n");
	sleep(5);
}

//===============================================
// Alarm value check
//===============================================
int GetAlarmValue()
{
	int result = PASS;

	if( (ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[0] > 0) ||
		(ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[1] > 0) ||
		(ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[2] > 0) ||
		(ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[3] > 0) ||
		(ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[4] > 0) ||
		(ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[5] > 0) ||
		(ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[6] > 0) ||
		(ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[7] > 0))
	{
		result = FAIL;
	}

	return result;
}

//===============================================
// Info value check
//===============================================
int GetInfoValue()
{
	int result = PASS;

	if( (ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[0] > 0) ||
		(ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[1] > 0) ||
		(ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[2] > 0) ||
		(ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[3] > 0) ||
		(ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[4] > 0) ||
		(ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[5] > 0) ||
		(ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[6] > 0) ||
		(ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[7] > 0) ||
		(ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[8] > 0) ||
		(ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[9] > 0))
	{
		result = FAIL;
	}

	return result;
}

//===============================================
// Fault value check
//===============================================
int GetFaultValue()
{
	int result = PASS;

	if( (ShmStatusCodeData->FaultCode.FaultEvents.FaultVal[0] > 0) ||
		(ShmStatusCodeData->FaultCode.FaultEvents.FaultVal[1] > 0) ||
		(ShmStatusCodeData->FaultCode.FaultEvents.FaultVal[2] > 0) ||
		(ShmStatusCodeData->FaultCode.FaultEvents.FaultVal[3] > 0))
	{
		result = FAIL;
	}

	return result;
}

//===============================================
// Main process
//===============================================
int main(void)
{
	//Create all share memory
	if(CreatShareMemory()==0)
	{

		DEBUG_ERROR("CreatShareMemory NG\r\n");

		if(ShmStatusCodeData!=NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory=1;
		}
		sleep(5);
		system("reboot -f");
		sleep(5);
		system("reboot -f");
	}
	else
	{
		DEBUG_INFO("CreatShareMemory OK\r\n");
	}

	for(int gun_index = 0;gun_index<AC_QUANTITY;gun_index++)
	{
		ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PreviousSystemStatus = 0xff;
	}

	// Main loop
	for(;;)
	{
		//==========================================
		// Something need run in Idle mode
		//==========================================
		if((ShmSysConfigAndInfo->SysInfo.AcChargingData[0].SystemStatus==MODE_IDLE) &&
		   (AC_QUANTITY>1?(ShmSysConfigAndInfo->SysInfo.AcChargingData[1].SystemStatus==MODE_IDLE):true))
		{
			//======================================
			// Check restore factory setting request
			//======================================
			if(ShmSysConfigAndInfo->SysInfo.FactoryConfiguration)
			{
				system("cd /root;./Module_FactoryConfig");
				system("sync");
				sleep(5);
				system("reboot -f");
				sleep(5);
				system("reboot -f");
			}

			//======================================
			// Check upgrade firmware request
			//======================================
			if(ShmSysConfigAndInfo->SysInfo.FirmwareUpdate)
			{
				if(upgrade_check())
				{

					ShmSysConfigAndInfo->SysInfo.FirmwareUpdate = OFF;
				}
			}
		}

		//==========================================
		// Check RFID
		//==========================================
		if(!ShmCharger->rfidReq)
		{
			if(GetCardSerialNumber()!= FAIL)
			{
				ShmCharger->rfidReq = ON;
			}
		}

		for(int gun_index = 0;gun_index<AC_QUANTITY;gun_index++)
		{
			/*
			 *	TODO:
			 *	1. How to identify each connector alarm code?...
			 *	2. Check alarm have occur
			 */
			if((GetAlarmValue() == FAIL) ||
			   (GetFaultValue() == FAIL) ||
			   (ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode>0))
			{
				if(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].SystemStatus != MODE_ALARM)
				{
					/*
					 *	TODO:
					 *	1. CP switch to E state
					 */
					setChargerMode(gun_index, MODE_ALARM);
				}
			}
			else
			{
				if(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].SystemStatus == MODE_ALARM)
				{
					/*
					 *	TODO:
					 *	1. CP switch to normal state
					 */
				}
				else if(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].SystemStatus == 0XFF)
				{
					setChargerMode(gun_index, MODE_BOOTING);
				}
			}

			switch(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].SystemStatus)
			{
				case MODE_BOOTING:
					if(isModeChange(gun_index))
					{
						//CSU Initialization & task spawn
						if((Initialization() != PASS) ||
						   (SpawnTask() != PASS) )
						{
							ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = ON;
						}
					}

					if(ShmCharger->gun_info[gun_index].mcuFlag.isReadFwVerPass &&
					   ShmCharger->gun_info[gun_index].mcuFlag.isSetModelNamePass &&
					   ShmCharger->gun_info[gun_index].mcuFlag.isSetSerialNumberPass)
					{
						/*
						 * TODO:
						 * 1. If control pilot state != STATE_A, cancel cold load pick up request
						 * 2. Debug mode into request check
						 */
						sprintf((char*)ShmSysConfigAndInfo->SysInfo.CsuHwRev, "REV5.0");
						sprintf((char*)ShmSysConfigAndInfo->SysInfo.CsuBootLoadFwRev, "U-Boot-2017-09");
						sprintf((char*)ShmSysConfigAndInfo->SysInfo.CsuKernelFwRev, "4.9.59-ga75d8e9305");
						sprintf((char*)ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev, "AW-Regular");
						strcpy((char*)ShmSysConfigAndInfo->SysInfo.CsuPrimFwRev, ShmCharger->gun_info[gun_index].ver.Version_FW);
						sprintf((char*)ShmSysConfigAndInfo->SysConfig.chargePointVendor, "Phihong");

						setChargerMode(gun_index, MODE_IDLE);
					}

					setLedMotion(gun_index,LED_ACTION_INIT);

					break;
				case MODE_IDLE:
					if(isModeChange(gun_index))
					{
						setRelay(gun_index,OFF);
						ShmCharger->rfidReq = OFF;
						ShmSysConfigAndInfo->SysConfig.Bluetooth.isRequestStart = OFF;
						ShmSysConfigAndInfo->SysConfig.Bluetooth.isRequestStop = OFF;
						ShmOCPP16Data->CsMsg.bits[gun_index].RemoteStartTransactionReq = OFF;
						ShmOCPP16Data->CsMsg.bits[gun_index].RemoteStopTransactionReq = OFF;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode = 0x00;
						ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent = ShmCharger->gun_info[gun_index].primaryMcuState.rating_current;
						ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargedDuration = 0;
						ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargedEnergy = 0;
					}

					//GetInfoFromWebServer();

					if(((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_B) && (ShmCharger->rfidReq == ON)) ||
					   (ShmSysConfigAndInfo->SysConfig.Bluetooth.isRequestStart == ON) ||
					   (ShmOCPP16Data->CsMsg.bits[gun_index].RemoteStartTransactionReq == ON))
					{
						if((ShmCharger->rfidReq == ON))
						{
							ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartMethod = START_METHOD_RFID;
						}
						else if(ShmOCPP16Data->CsMsg.bits[gun_index].RemoteStartTransactionReq)
						{
							ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartMethod = START_METHOD_BACKEND;
						}
						else if(ShmSysConfigAndInfo->SysConfig.Bluetooth.isRequestStart == ON)
						{
							ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartMethod = START_METHOD_BLE;
						}
						else
						{
							ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartMethod = START_METHOD_MANUAL;
						}

						ShmCharger->rfidReq = OFF;
						ShmOCPP16Data->CsMsg.bits[gun_index].RemoteStartTransactionReq = OFF;
						ShmSysConfigAndInfo->SysConfig.Bluetooth.isRequestStart = OFF;

						setChargerMode(gun_index, MODE_AUTHORIZING);
					}
					else
					{}

					setLedMotion(gun_index,LED_ACTION_IDLE);

					break;
				case MODE_AUTHORIZING:
					if(isModeChange(gun_index))
					{
						/*
						 * 	TODO:
						 * 	1. LED control as AUTH
						 * 	2. Enable authorization watch dog in 30 seconds
						 */

						DEBUG_INFO("Authorizing timer refresh...\r\n");
						ftime(&startTime[TMR_IDX_AUTH]);
						setLedMotion(gun_index,LED_ACTION_AUTHED);
					}

					if(DiffTimeb(startTime[TMR_IDX_AUTH]) > TIMEOUT_SPEC_AUTH)
					{
						/*
						 * 	TODO:
						 * 	1. Authorization timeout process.
						 */

						setChargerMode(gun_index, MODE_IDLE);
					}
					else
					{
						/*
						 * 	TODO:
						 * 	1. RFID authorization result check(local or remote).
						 * 	2. OCPP remote start request authorization demand check
						 * 	3. All authorization method need to consider off line policy
						 */

						switch(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartMethod)
						{
							case START_METHOD_MANUAL:
							case START_METHOD_BLE:
								setChargerMode(gun_index, MODE_PREPARING);
								break;
							case START_METHOD_BACKEND:
							case START_METHOD_RFID:
								if(1)
								{
									/*
									 * TODO: Authorize pass process here
									 */
									setChargerMode(gun_index, MODE_PREPARING);
								}
								else
								{
									/*
									 * TODO: Authorize fail process here
									 */
								}

								break;
						}
					}

					break;
				case MODE_PREPARING:
					if(isModeChange(gun_index))
					{
						/*
						 *	TODO:
						 * 	1. Request MCU start charging
						 * 	2. Enable handshaking watch dog in 180 seconds
						 */
						DEBUG_INFO("Handshaking timer refresh...\r\n");
						ftime(&startTime[TMR_IDX_HANDSHAKING]);
						setRelay(gun_index,ON);
					}

					if(DiffTimeb(startTime[TMR_IDX_HANDSHAKING]) > TIMEOUT_SPEC_HANDSHAKING)
					{
						/*
						 * 	TODO:
						 * 	1. HANDSHAKING timeout process
						 */
						setChargerMode(gun_index, MODE_IDLE);
					}
					else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_C))
					{
						ShmOCPP16Data->StartTransaction[gun_index].MeterStart = ((float)ShmCharger->gun_info[gun_index].powerConsumption.power_consumption/100);
						ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].OutputEnergy = 0;

						switch(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartMethod)
						{
							case START_METHOD_MANUAL:
								sprintf((char*)ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId, "Manual");
								break;
							case START_METHOD_BLE:
								memcpy((char*)ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId, ShmSysConfigAndInfo->SysConfig.Bluetooth.LoginCentralID, sizeof(ShmSysConfigAndInfo->SysConfig.Bluetooth.LoginCentralID));
								break;
							case START_METHOD_BACKEND:
								memcpy((char*)ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId, (char*)ShmOCPP16Data->RemoteStartTransaction[gun_index].IdTag, sizeof(ShmOCPP16Data->RemoteStartTransaction[gun_index].IdTag));
								break;
							case START_METHOD_RFID:

								if(ShmSysConfigAndInfo->SysConfig.RfidCardNumEndian == 0)
								{
									for(int idx = 0; idx < rfid.snType ; idx++)
									{
										ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[idx] = rfid.currentCard[idx];
										ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].CardNumber[idx] = rfid.currentCard[idx];
									}

									if(rfid.cardType == ISO14443A)
									{
										if(rfid.snType == RFID_SN_TYPE_4BYTE)
										{
											printf("RFID SERIAL NUMBER: %02X%02X%02X%02X.\n",
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[0],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[1],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[2],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[3]);
										}
										else if (rfid.snType == RFID_SN_TYPE_7BYTE)
										{
											printf("RFID SERIAL NUMBER: %02X%02X%02X%02X%02X%02X%02X.\n",
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[0],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[1],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[2],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[3],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[4],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[5],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[6]);
										}
									}
									else if(rfid.cardType == IS014443B)
									{
										printf("RFID SERIAL NUMBER: %02X%02X%02X%02X.\n",
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[0],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[1],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[2],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[3]);
									}
									else if(rfid.cardType == FELICA)
									{
										printf("RFID SERIAL NUMBER: %02X%02X%02X%02X%02X%02X.\n",
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[0],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[1],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[2],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[3],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[4],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[5]);
									}
								}
								else
								{
									for(int i = 0,j = (rfid.snType-1); i < rfid.snType; i++,j--)
									{
										ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[i] = rfid.currentCard[j];
										ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].CardNumber[i] = rfid.currentCard[j];
									}

									if(rfid.cardType == ISO14443A)
									{
										if(rfid.snType == RFID_SN_TYPE_4BYTE)
										{
											printf("RFID SERIAL NUMBER: %02X%02X%02X%02X.\n",
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[0],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[1],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[2],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[3]);
										}
										else if (rfid.snType == RFID_SN_TYPE_7BYTE)
										{
											printf("RFID SERIAL NUMBER: %02X%02X%02X%02X%02X%02X%02X.\n",
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[0],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[1],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[2],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[3],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[4],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[5],
													ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[6]);
										}
									}
									else if(rfid.cardType == IS014443B)
									{

										printf("RFID SERIAL NUMBER: %02X%02X%02X%02X.\n",
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[0],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[1],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[2],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[3]);
									}
									else if(rfid.cardType == FELICA)
									{
										printf("RFID SERIAL NUMBER: %02X%02X%02X%02X%02X%02X.\n",
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[0],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[1],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[2],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[3],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[4],
												ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId[5]);
									}
								}

								break;
						}

						ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionReq = ON;
						setChargerMode(gun_index, MODE_CHARGING);
					}

					if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_B))
					{
						setLedMotion(gun_index,LED_ACTION_CONNECTED);
					}

					break;
				case MODE_CHARGING:
					if(isModeChange(gun_index))
					{
						ShmCharger->rfidReq = OFF;
						ftime(&startChargingTime[gun_index]);
					}

					/*
					 * 	TODO:
					 * 	1. Check BLE stop request.
					 * 	2. Check RFID stop request.
					 * 	3. Check OCPP stop request.
					 */

					if((ShmCharger->rfidReq == ON) ||
					   (ShmSysConfigAndInfo->SysConfig.Bluetooth.isRequestStop == ON) ||
					   (ShmOCPP16Data->CsMsg.bits[gun_index].RemoteStopTransactionReq == ON)||
					   (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState != CP_STATE_C))
					{
						/*
						 * 	TODO:
						 * 	1. CP state not equal STATE_C switch to MODE_TERMINATION
						 */

						setLedMotion(gun_index,LED_ACTION_STOP);
						setChargerMode(gun_index, MODE_TERMINATING);
					}
					else
					{
						/*
						 * 	TODO:
						 * 	1. LED control as CHARGING
						 * 	2. Update charging cycle information.
						 * 	3. CP PWM duty dynamic control logic.
						 */

						setRelay(gun_index,ON);
						setLedMotion(gun_index,LED_ACTION_CHARGING);
						ShmOCPP16Data->StopTransaction[gun_index].MeterStop = ((float)ShmCharger->gun_info[gun_index].powerConsumption.power_consumption/100.0) - ShmOCPP16Data->StartTransaction[gun_index].MeterStart;
						ftime(&endChargingTime[gun_index]);
						ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargedDuration = DiffTimeb2(startChargingTime[gun_index], endChargingTime[gun_index]);
					}

					break;
				case MODE_TERMINATING:
					if(isModeChange(gun_index))
					{
						if(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargedDuration != 0)
						{
							ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargedDuration = DiffTimeb2(startChargingTime[gun_index], endChargingTime[gun_index]);
						}
					}

					if((ShmCharger->rfidReq == ON) ||
					   (ShmSysConfigAndInfo->SysConfig.Bluetooth.isRequestStop == ON) ||
					   (ShmOCPP16Data->CsMsg.bits[gun_index].RemoteStopTransactionReq == ON) ||
					   (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_A))
					{
						/*
						 * 	TODO:
						 * 	1. Record charging history.
						 * 	2. OCPP send stop transaction request.
						 */
						ShmSysConfigAndInfo->SysConfig.Bluetooth.isRequestStop = OFF;
						ShmOCPP16Data->CsMsg.bits[gun_index].RemoteStopTransactionReq = OFF;
						ShmOCPP16Data->CpMsg.bits[gun_index].StopTransactionReq = ON;

						setRelay(gun_index,OFF);
						ShmCharger->rfidReq = OFF;
						setChargerMode(gun_index, MODE_IDLE);
					}
					else
					{
						 if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_C))
						 {
							 setChargerMode(gun_index, MODE_CHARGING);
						 }
					}
					setLedMotion(gun_index,LED_ACTION_STOP);
					break;
				case MODE_ALARM:

					if((GetAlarmValue() == PASS) &&
					   (GetFaultValue() == PASS) &&
					   (ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode == 0))
					{
						if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PreviousSystemStatus == MODE_CHARGING) ||
						   (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PreviousSystemStatus == MODE_TERMINATING))
						{
							setChargerMode(gun_index, ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PreviousSystemStatus);
						}
						else
						{
							setChargerMode(gun_index, MODE_IDLE);
						}
					}

					setLedMotion(gun_index,LED_ACTION_ALARM);
					break;
				case MODE_FAULT:
					if(isModeChange(gun_index))
					{
						/*
						 * TODO:
						 * 1. LED control depend on relay status
						 * 2. Alarm latch & release logic
						 */
					}

					break;
				case MODE_MAINTAIN:
					if(isModeChange(gun_index))
					{
						/*
						 * TODO:
						 * 1. LED control depend on relay status
						 * 2. Wait maintenance release command
						 */
					}

					setLedMotion(gun_index,LED_ACTION_MAINTAIN);
					break;
				case MODE_RESERVATION:
					if(isModeChange(gun_index))
					{
						/*
						 * TODO:
						 * 1. LED control depend on relay status
						 * 2. check reservation is overtime?
						 */
					}

					break;
				case MODE_BOOKING:
					if(isModeChange(gun_index))
					{
						/*
						 * TODO:
						 * 1. LED control depend on relay status
						 * 2. Check booking start is on time?
						 */
					}
					break;
				case MODE_DEBUG:
					if(isModeChange(gun_index))
					{
						/*
						 * TODO:
						 * 1. LED control depend on relay status
						 * 2. Check booking start is on time?
						 */
					}

					setLedMotion(gun_index,LED_ACTION_DEBUG);
					break;
			}
		}

		usleep(50000);
	}

	return FAIL;
}