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

/*
 * main.c
 *
 *  Created on: 2020年9月10日
 *      Author: Wendell
 */

#include    <sys/types.h>
#include    <sys/stat.h>
#include 	<sys/time.h>
#include 	<sys/timeb.h>
#include 	<sys/types.h>
#include 	<sys/ioctl.h>
#include 	<sys/socket.h>
#include 	<sys/ipc.h>
#include 	<sys/shm.h>
#include 	<sys/mman.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 	<stdint.h>
#include	<time.h>
#include	<ctype.h>
#include 	<ifaddrs.h>
#include 	<math.h>
#include 	"../../define.h"
#include 	"Config.h"
#include 	<stdbool.h>
#include 	<dirent.h>
#include	"timeout.h"
#include    "Module_EvComm.h"

#define 	ARRAY_SIZE(A)		(sizeof(A) / sizeof(A[0]))
#define 	PASS				1
#define 	FAIL				-1
#define 	BUFFER_SIZE			128
#define 	YES					1
#define 	NO					0
#define     ON                  1
#define     OFF                 0
#define 	NORMAL				0
#define		ABNORMAL			1
#define 	EQUAL				0
#define 	BTN_RELEASE			0
#define 	BTN_PRESS			1
#define 	MAX_BUF 			64
#define 	MtdBlockSize 		0x300000
#define 	SYSFS_GPIO_DIR 		"/sys/class/gpio"
#define		UPGRADE_FAN			0x02
#define		UPGRADE_RB			0x03
#define		UPGRADE_PRI			0x04
#define		UPGRADE_AC			0x05
#define		UPGRADE_LED			0x06
#define     UPGRADE_DORC1       0x07
#define     UPGRADE_DORC2       0x08
#define     UPGRADE_DDRB        0x09
#define		SYSTEM_MIN_VOL		150
#define 	MIN_OUTPUT_CUR		0
#define		AC_OUTPUT_VOL		220

#define		NO_DEFINE			255
#define 	DEFAULT_AC_INDEX	2
#define  	PSU_MIN_CUR			100

#define 	DB_FILE				"/Storage/ChargeLog/localCgargingRecord.db"

#define		SELFTEST_TIMEOUT		60
#define		AUTHORIZE_TIMEOUT		30
#define 	AUTHORIZE_COMP_TIMEOUT	1
#define 	AUTHORIZE_FAIL_TIMEOUT	3
#define 	AUTHORIZE_STOP_TIMEOUT	30
#define 	RETURN_TO_CHARGING_PAGE	30
#define		GUN_PREPARE_TIMEOUT		30
#define		GUN_EV_WAIT_TIMEOUT		120
#define		GUN_EVSE_WAIT_TIMEOUT	60
#define		GUN_COMP_WAIT_TIMEOUT	10
#define		GUN_PRECHARGING_TIMEOUT	60

#define     REBOOT_TIMEOUT              10
#define     RESET_TIMEOUT               10
#define     OCPP_COST_REQ_INTERVAL      5
#define     DISPENSER_RECONNECTE_TIME   30
#define     DISPENSER_AUTH_COMP_TIME    3
#define     FORCE_BALANCE_TIME          5
#define     DISPENSER_UPGRADE_TIME      600
#define     AC_CONTACTOR_REOPEN_TIME    40
#define     PSU_FAILURE_RESUME_TIME     180
#define     MAX_AC_CONTACTOR_COUNT      3
#define     STANDBY_TIME                600
#define     FAST_STANDBY_TIME           30
#define     INDICATION_BLINK_INTERVAL   1000
#define     E4YOU_BLINK_INTERVAL        500
#define     WIRING_INFO_DELAY           30

#define     WAIT_REASSIGN_TIME          30              // unit: second
#define     MAX_REQUEST_CHARGING_TIME   15              // unit: second
#define     MIN_WAIT_PREPARNING_TIME    5               // unit: second
#define     FORCE_CHARGING_WAIT_EVSE    10              // unit: second
#define     TRY_RESET_4G_WIFI_TIME      300             // unit: second

char 	*valid_Internet[2] 	  = {"8.8.8.8", "180.76.76.76"};
unsigned char mask_table[] = { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 };
int whileLoopTime = 10000; // 10 ms
int	wtdFd = -1;
byte _authorizeIndex = NO_DEFINE;
BOOL _UpgradeNeedReboot = FALSE;

const byte Group_to_Location_2_Gun[GENERAL_GUN_QUANTITY] = {0, 1, 0, 0};
const byte Location_to_Group_2_Gun[GENERAL_GUN_QUANTITY] = {0, 1, 0, 0};
const byte GroupParallelRelay_2_Gun[GENERAL_GUN_QUANTITY][GENERAL_GUN_QUANTITY] =
{
    {0, 1, 0, 0},
    {1, 0, 0, 0},
    {0, 0, 0, 0},
    {0, 0, 0, 0}
};

//Location:  1   2   3   4
//     Gun:  1   3   4   2
//Parallel:    1   2   3
//const byte Group_to_Location_4_Gun[GENERAL_GUN_QUANTITY] = {0, 3, 1, 2};
//const byte Location_to_Group_4_Gun[GENERAL_GUN_QUANTITY] = {0, 2, 3, 1};
//const byte GroupParallelRelay_4_Gun[GENERAL_GUN_QUANTITY][GENERAL_GUN_QUANTITY] =
//{
//    {0, 3, 1, 2},       // group 0
//    {1, 0, 2, 3},       // group 1
//    {1, 3, 0, 2},       // group 2
//    {1, 3, 2, 0}        // group 3
//};

//Location:  1   2   3   4
//     Gun:  1   4   3   2
//Parallel:    1   2   3
const byte Group_to_Location_4_Gun[GENERAL_GUN_QUANTITY] = {0, 3, 2, 1};
const byte Location_to_Group_4_Gun[GENERAL_GUN_QUANTITY] = {0, 3, 2, 1};
const byte GroupParallelRelay_4_Gun[GENERAL_GUN_QUANTITY][GENERAL_GUN_QUANTITY] =
{
    {0, 3, 2, 1},       // group 0
    {1, 0, 3, 2},       // group 1
    {1, 3, 0, 2},       // group 2
    {1, 3, 2, 0}        // group 3
};

bool IsAuthorizingMode();
void ClearAuthorizedFlag();
bool isDetectPlugin();
void ClearDetectPluginFlag();
int mystrcmp(unsigned char *p1, unsigned char *p2);

long long DiffTimebWithNow(struct timeb ST);
unsigned char DetectBitValue(unsigned char _byte, unsigned char _bit);
void SetBitValue(unsigned char *_byte, unsigned char _bit, unsigned char value);
void ChargingTerminalProcess(byte gunIndex);
void ChkPrimaryStatus();
void StartSystemTimeoutDet(unsigned char flag);
void StopSystemTimeoutDet();
void StartGunInfoTimeoutDet(unsigned char gunIndex, unsigned char flag);
void StopGunInfoTimeoutDet(unsigned char gunIndex);
int StoreLogMsg_1(const char *fmt, ...);
unsigned long GetTimeoutValue(struct timeval _sour_time);
void gpio_set_value(unsigned int gpio, unsigned int value);
void PRINTF_FUNC(char *string, ...);
void ChangeGunSelectByIndex(byte sel);
void ChargingAlarmProcess(byte gunIndex);
void InformOcppErrOccur(byte codeType);

void ReleaseAlarmCode(byte gunIndex);

int DB_Open(sqlite3 *db);
int DB_Insert_Record(sqlite3 *db, int gun_index);
int DB_Update_Operactive(sqlite3 *db, uint8_t gun_index, uint8_t IsAvailable);
int DB_Get_Operactive(sqlite3 *db, uint8_t gun_index);
void InitialDHCP();
void InitialDispenserDhcpServerConfig(void);
void StartDispenserDhcpServer(void);
void _SelfTestTimeout(void);
void CheckConnectionTimeout(void);
bool IsConnectorWholeIdle();
void SetAcContactor(unsigned char OnOff);
void UpdateErrorCodeToOcpp(byte index);
bool CheckConnectorTypeStatus(void);

#define DEBUG_INFO_MSG(format, args...) StoreLogMsg_1("[%s:%d][%s][Info] "format, __FILE__, __LINE__, __FUNCTION__, ##args)
#define DEBUG_WARN_MSG(format, args...) StoreLogMsg_1("[%s:%d][%s][Warn] "format, __FILE__, __LINE__, __FUNCTION__, ##args)
#define DEBUG_ERROR_MSG(format, args...) StoreLogMsg_1("[%s:%d][%s][Error] "format, __FILE__, __LINE__, __FUNCTION__, ##args)

struct SysConfigAndInfo			*ShmSysConfigAndInfo;
struct StatusCodeData 			*ShmStatusCodeData;
struct PsuData 					*ShmPsuData;
struct CHAdeMOData				*ShmCHAdeMOData;
struct GBTData					*ShmGBTData;
struct CcsData					*ShmCcsData;
struct PrimaryMcuData			*ShmPrimaryMcuData;
struct FanModuleData			*ShmFanModuleData;
struct RelayModuleData			*ShmRelayModuleData[2];
struct LedModuleData			*ShmLedModuleData;
struct OCPP16Data				*ShmOCPP16Data;
ChargerInfoData                 *ShmChargerInfo;
PsuPositionInfoData             *ShmPsuPosition;
PsuGroupingInfoData             *ShmPsuGrouping;
PsuGroupCollectionData          *ShmGroupCollection;

struct ChargingInfoData			*chargingInfo[CONNECTOR_QUANTITY];
struct ChargingInfoData			*ac_chargingInfo[AC_QUANTITY];
struct timeb 					startChargingTime[CONNECTOR_QUANTITY];
struct timeb 					endChargingTime[CONNECTOR_QUANTITY];

struct timeval                  _ConnectorAuthorizing_Time[CONNECTOR_QUANTITY];
struct timeval                  _ConnectorAuthorizeFail_Time[CONNECTOR_QUANTITY];
struct timeval                  _DispenserAuthorizing_Time[CONNECTOR_QUANTITY];
int chargingTime[CONNECTOR_QUANTITY];
struct timeval                  _DispenserUpgrade_time;
struct timeval                  _Standby_time;
struct timeval                  _SystemStatus_Time[CONNECTOR_QUANTITY];

unsigned char                   _PsuGroupAvailable[CONNECTOR_QUANTITY];

bool _NeedReset4gWifi;
struct timeval _4gWifiReset_time;

// for initial index to check EV board type is correct
byte _gunIndex = 0;
byte _acgunIndex = 0;
byte _chademoIndex = 0;
byte _ccsIndex = 0;
byte _gb_Index = 0;
byte _ac_Index = 0;
//byte bd0_1_status = 0;
//byte bd0_2_status = 0;
//byte bd1_1_status = 0;
//byte bd1_2_status = 0;

bool isCardScan = false;
bool isModelNameMatch = true;

//int rfidFd = -1;
//char* rfidPortName = "/dev/ttyS2";
char* fwVersion = "V1.00.00.0000.00";

sqlite3 *localDb;
bool isDb_ready;

//================================================
// initial can-bus
//================================================
int InitCanBus()
{
	int 					s0,nbytes;
	struct timeval			tv;
	struct ifreq 			ifr0;
	struct sockaddr_can		addr0;

	system("/sbin/ip link set can0 down");
	system("/sbin/ip link set can0 type can bitrate 500000 restart-ms 100");
	system("/sbin/ip link set can0 up");

	s0 = socket(PF_CAN, SOCK_RAW, CAN_RAW);

	tv.tv_sec = 0;
	tv.tv_usec = 10000;
   	if (setsockopt(s0, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct	timeval)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("Set SO_RCVTIMEO NG");
		#endif
	}
	nbytes=40960;
	if (setsockopt(s0, SOL_SOCKET,  SO_RCVBUF, &nbytes, sizeof(int)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("Set SO_RCVBUF NG");
		#endif
	}
	nbytes=40960;
	if (setsockopt(s0, SOL_SOCKET, SO_SNDBUF, &nbytes, sizeof(int)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("Set SO_SNDBUF NG");
		#endif
	}

   	strcpy(ifr0.ifr_name, "can0" );
	ioctl(s0, SIOCGIFINDEX, &ifr0); /* ifr.ifr_ifindex gets filled with that device's index */
	addr0.can_family = AF_CAN;
	addr0.can_ifindex = ifr0.ifr_ifindex;
	bind(s0, (struct sockaddr *)&addr0, sizeof(addr0));
	return s0;
}

//================================================
// initial uart port
//================================================
char *_priPortName = "/dev/ttyS1";
char *_485PortName = "/dev/ttyS5";

int InitComPort(byte target)
{
	int fd;
	struct termios tios;

	if(target == UPGRADE_PRI)
		fd = open(_priPortName, O_RDWR);
	else if (target == UPGRADE_FAN ||  target == UPGRADE_RB || target == UPGRADE_AC || target == UPGRADE_LED)
		fd = open(_485PortName, O_RDWR);

	if(fd<=0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("open 407 Communication port NG \n");
		#endif
		return -1;
	}
	ioctl (fd, TCGETS, &tios);
	tios.c_cflag = B115200| 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(fd, TCIFLUSH);
	ioctl (fd, TCSETS, &tios);

	return fd;
}

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

int InitWatchDog()
{
	int fd;
	system("/usr/bin/fuser -k /dev/watchdog");
	sleep(1);
	system("echo V > /dev/watchdog");
	sleep(1);
	fd=open("/dev/watchdog", O_RDWR);

	if(fd<=0)
	{
		DEBUG_ERROR_MSG("System watch dog initial fail.\r\n");
	}
	return fd;
}

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

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

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

	if (ShmSysConfigAndInfo->SysConfig.SwitchDebugFlag == YES)
	{
		sprintf(Buf,"%02d:%02d:%02d:%03d - %s",
			tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm, buffer);
		printf("%s \n", Buf);
	}
	else
	{
		sprintf(Buf,"echo \'%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\' >> /Storage/SystemLog/[%04d.%02d]SystemLog",
			tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,SeqEndTime.millitm,
			buffer,
			tm->tm_year+1900,tm->tm_mon+1);
		system(Buf);
	}

	return rc;
}

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

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

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

int DiffTimeb(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);
}

bool CheckTimeOut(struct timeb ST)
{
	struct timeb ET;
	unsigned int StartTime, StopTime;

	ftime(&ET);
	StartTime = (unsigned int) ST.time;
	StopTime = (unsigned int) ET.time;
	return (StopTime > StartTime)? YES : NO;
}

void setChargerMode(byte gun_index, byte mode)
{
	chargingInfo[gun_index]->SystemStatus = mode;
}

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

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

long long DiffTimebWithNow(struct timeb ST)
{
	//return milli-second
	struct timeb ET;
	long long StartTime,StopTime;

	ftime(&ET);
	StartTime=(long long)ST.time;
	StopTime=(long long)ET.time;
	return ((StopTime-StartTime)*1000) + (ET.millitm-ST.millitm);
}
/*
//==========================================
// 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 CreateShareMemory()
{
	int MeterSMId;

	if ((MeterSMId = shmget(ShmSysConfigAndInfoKey,	sizeof(struct SysConfigAndInfo), IPC_CREAT | 0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmget ShmSysConfigAndInfo NG \n");
		#endif
		return 0;
	}
	else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0))	== (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmat ShmSysConfigAndInfo NG \n");
		#endif
		return 0;
	}
	memset(ShmSysConfigAndInfo, 0, sizeof(struct SysConfigAndInfo));

	if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData), IPC_CREAT | 0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmget ShmStatusCodeData NG \n");
		#endif
		return 0;
	}
	else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmat ShmStatusCodeData NG \n");
		#endif
		return 0;
	}

	memset(ShmStatusCodeData, 0, sizeof(struct StatusCodeData));

	//creat ShmPsuData
	if ((MeterSMId = shmget(ShmPsuKey, sizeof(struct PsuData), IPC_CREAT | 0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmget ShmPsuData NG \n");
		#endif
		return 0;
	}
	else if ((ShmPsuData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmat ShmPsuData NG \n");
		#endif
		return 0;
	}
	memset(ShmPsuData, 0, sizeof(struct PsuData));
/*
	if(CHAdeMO_QUANTITY > 0)
	{
		if ((MeterSMId = shmget(ShmCHAdeMOCommKey, sizeof(struct CHAdeMOData),	IPC_CREAT | 0777)) < 0)
		{
			#ifdef SystemLogMessage
			DEBUG_ERROR_MSG("[main]CreatShareMemory:shmget ShmCHAdeMOData NG \n");
			#endif
			return 0;
		}
		else if ((ShmCHAdeMOData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
		{
			#ifdef SystemLogMessage
			DEBUG_ERROR_MSG("[main]CreatShareMemory:shmat ShmCHAdeMOData NG \n");
			#endif
			return 0;
		}
		memset(ShmCHAdeMOData, 0, sizeof(struct CHAdeMOData));
	}

	if(GB_QUANTITY > 0)
	{
		if ((MeterSMId = shmget(ShmGBTCommKey, sizeof(struct GBTData),	IPC_CREAT | 0777)) < 0)
		{
			#ifdef SystemLogMessage
			DEBUG_ERROR_MSG("[main]CreatShareMemory:shmget ShmGBTData NG \n");
			#endif
			return 0;
		}
		else if ((ShmGBTData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
		{
			#ifdef SystemLogMessage
			DEBUG_ERROR_MSG("[main]CreatShareMemory:shmat ShmGBTData NG \n");
			#endif
			return 0;
		}
		memset(ShmGBTData, 0, sizeof(struct GBTData));
	}

	//creat ShmCcsData
	if(CCS_QUANTITY > 0)
	{
		if ((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData),	IPC_CREAT | 0777)) < 0)
		{
			#ifdef SystemLogMessage
			DEBUG_ERROR_MSG("[main]CreatShareMemory:shmget ShmCcsData NG \n");
			#endif
			return 0;
		}
		else if ((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
		{
			#ifdef SystemLogMessage
			DEBUG_ERROR_MSG("[main]CreatShareMemory:shmat ShmCcsData NG \n");
			#endif
			return 0;
		}
		memset(ShmCcsData, 0, sizeof(struct CcsData));
	}
*/
	//creat ShmPrimaryMcuData
	if ((MeterSMId = shmget(ShmPrimaryMcuKey, sizeof(struct PrimaryMcuData), IPC_CREAT | 0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmget ShmPrimaryMcuData NG \n");
		#endif
		return 0;
	}
	else if ((ShmPrimaryMcuData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmat ShmPrimaryMcuData NG \n");
		#endif
		return 0;
	}
	memset(ShmPrimaryMcuData, 0, sizeof(struct PrimaryMcuData));

	//creat ShmFanModuleData
	if ((MeterSMId = shmget(ShmFanBdKey, sizeof(struct FanModuleData),	IPC_CREAT | 0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmget ShmFanModuleData NG \n");
		#endif
		return 0;
	}
	else if ((ShmFanModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmat ShmFanModuleData NG \n");
		#endif
		return 0;
	}
	memset(ShmFanModuleData, 0, sizeof(struct FanModuleData));

	//creat ShmRelayModuleData
	if ((MeterSMId = shmget(ShmRelayBdKey, sizeof(struct RelayModuleData),	IPC_CREAT | 0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmget ShmRelayModuleData[0] NG \n");
		#endif
		return 0;
	}
	else if ((ShmRelayModuleData[0] = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmat ShmRelayModuleData[0] NG \n");
		#endif
		return 0;
	}
	memset(ShmRelayModuleData[0], 0, sizeof(struct RelayModuleData));

	// DO360 RC2
	if ((MeterSMId = shmget(ShmRelay2BdKey, sizeof(struct RelayModuleData), IPC_CREAT | 0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmget ShmRelayModuleData[1] NG \n");
		#endif
		return 0;
	}
	else if ((ShmRelayModuleData[1] = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmat ShmRelayModuleData[1] NG \n");
		#endif
		return 0;
	}
	memset(ShmRelayModuleData[1], 0, sizeof(struct RelayModuleData));

	if ((MeterSMId = shmget(ShmLedBdKey, sizeof(struct LedModuleData), IPC_CREAT | 0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmget ShmLedModuleData NG \n");
		#endif
		return 0;
	}
	else if ((ShmLedModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmat ShmLedModuleData NG \n");
		#endif
		return 0;
	}
	memset(ShmLedModuleData, 0, sizeof(struct LedModuleData));

	//creat ShmOCPP16Data
	if ((MeterSMId = shmget(ShmOcppModuleKey, sizeof(struct OCPP16Data), IPC_CREAT | 0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmget ShmOCPP16Data NG \n");
		#endif
		return 0;
	}
	else if ((ShmOCPP16Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("[main]CreatShareMemory:shmat ShmOCPP16Data NG \n");
		#endif
		return 0;
	}
	memset(ShmOCPP16Data,0,sizeof(struct OCPP16Data));

    //creat ShmOCPP16Data
    if ((MeterSMId = shmget(SM_ChargerInfoKey, sizeof(ChargerInfoData), IPC_CREAT | 0777)) < 0)
    {
        #ifdef SystemLogMessage
        DEBUG_ERROR_MSG("[main]CreatShareMemory:shmget ChargerInfoData NG \n");
        #endif
        return 0;
    }
    else if ((ShmChargerInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
        #ifdef SystemLogMessage
        DEBUG_ERROR_MSG("[main]CreatShareMemory:shmat ChargerInfoData NG \n");
        #endif
        return 0;
    }
    memset(ShmChargerInfo, 0, sizeof(ChargerInfoData));
    ShmPsuPosition = &ShmChargerInfo->PsuPosition;
    ShmPsuGrouping = &ShmChargerInfo->PsuGrouping;
    ShmGroupCollection = &ShmChargerInfo->PsuGrouping.GroupCollection[0];

	return 1;
}

//=================================
// LCM Page
//=================================
void ChangeLcmByIndex(byte page_index)
{
	if (ShmSysConfigAndInfo->SysWarningInfo.Level != 2 ||
			page_index == _LCM_COMPLETE || page_index == _LCM_FIX)
	{
		ShmSysConfigAndInfo->SysInfo.PageIndex = page_index;
	}
}

//======================================================
// Peripheral initial
//======================================================
void InitGPIO()
{
	/*****************0~3, 4 bank, bank x 32+ num*********************/
	/***************************************************************/
	/*************** GPIO 0 ***************************************/
	/***************************************************************/
	/* GPMC_AD8			=> 	GPIO0_22 *//*ID BD1_1*/					// no use
	system("echo 22 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio22/direction");
	/* GPMC_AD9			=>	GPIO0_23 *//*ID BD1_2*/					// no use
	system("echo 23 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio23/direction");
	/* GPMC_AD10		=>	GPIO0_26 *//*IO BD1_1*/					// no use
	system("echo 26 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio26/direction");
	system("echo 1 > /sys/class/gpio/gpio26/value");
	/* GPMC_AD11		=>	GPIO0_27 *//*IO BD1_2*/					// no use
	system("echo 27 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio27/direction");
	/* RMII1_REF_CLK		=>	GPIO0_29 *//*USB 0 OCP detection*/
	system("echo 29 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio29/direction");
	/*XDMA_EVENT_INTR0	=>	GPIO0_19 *//*AM_RFID_RST*/				// no use
	system("echo 19 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio19/direction");
	system("echo 1 > /sys/class/gpio/gpio19/value");
	/*XDMA_EVENT_INTR1	=>	GPIO0_20 *//*AM_RFID_ICC*/				// no use
	system("echo 20 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio20/direction");
	/***************************************************************/
	/*************** GPIO 1 ***************************************/
	/***************************************************************/
	/* GPMC_AD12	=> 	GPIO1_12 *//*ID BD2_1*/						// no use
	system("echo 44 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio44/direction");
	/* GPMC_AD13	=>	GPIO1_13 *//*ID BD2_2*/						// no use
	system("echo 45 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio45/direction");
	/* GPMC_AD14	=>	GPIO1_14 *//*IO BD2_1*/						// no use
	system("echo 46 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio46/direction");
	system("echo 0 > /sys/class/gpio/gpio46/value");
	/* GPMC_AD15	=>	GPIO1_15 *//*IO BD2_2*/						// no use
	system("echo 47 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio47/direction");
	/***************************************************************/
	/*************** GPIO 2 ***************************************/
	/***************************************************************/
	/*LCD_AC_BIAS_EN	=>	GPIO2_25*//*RS-485 for module DE control*/
	system("echo 89 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio89/direction");
	system("echo 1 > /sys/class/gpio/gpio89/value");
	/*LCD_HSYNC		=>	GPIO2_23*//*RS-485 for module RE control*/
	system("echo 87 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio87/direction");
	system("echo 0 > /sys/class/gpio/gpio87/value");
	/*LCD_PCLK		=>	GPIO2_24*//*CCS communication board 1 proximity*/		// no use
	system("echo 88 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio88/direction");
	/*LCD_VSYNC		=>	GPIO2_22*//*CCS communication board 2 proximity*/		// no use
	system("echo 86 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio86/direction");
	/***************************************************************/
	/*************** GPIO 3 ***************************************/
	/***************************************************************/
	/*MCASP0_FSX		=>	GPIO3_15*//*Emergency Stop button detect*/
	system("echo 111 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio111/direction");
	/*MCASP0_ACLKR	=>	GPIO3_18*//*USB1 OCP detect*/
	system("echo 114 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio114/direction");
	/*MCASP0_AHCLKR	=>	GPIO3_17*//*Emergency IO for AM3352 and STM32F407*/
	system("echo 113 > /sys/class/gpio/export");
	system("echo \"in\" > /sys/class/gpio/gpio113/direction");
	/*MCASP0_ACLKX	=>	GPIO3_14*//*Ethernet PHY reset*/
	system("echo 110 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio110/direction");
	system("echo 0 > /sys/class/gpio/gpio110/value");
	/* MCASP0_FSR		=>	GPIO3_19 *//*SMR Enable control_1 for Pskill_1*/	// no use
	system("echo 115 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio115/direction");
	system("echo 0 > /sys/class/gpio/gpio115/value");
	/* MCASP0_AXR0	=>	GPIO3_16 *//*CSU board function OK indicator.*/
	system("echo 112 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio112/direction");
	system("echo 1 > /sys/class/gpio/gpio112/value");
	/* MCASP0_AXR1	=>	GPIO3_20 *//*SMR Enable control_2 for Pskill_2*/		// no use
	system("echo 116 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio116/direction");
	system("echo 0 > /sys/class/gpio/gpio116/value");
	/* (C14) EMU0.gpio3[7] */  /*CP open/short feature enable/disable, pull low for default enable*/
	system("echo 103 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio103/direction");
	system("echo 0 > /sys/class/gpio/gpio103/value");
	/* (B14) EMU1.gpio3[8] */  /*4G module reset, pull high to reset when entry kernel, after Application start, it should be pull low.*/
	system("echo 104 > /sys/class/gpio/export");
	system("echo \"out\" > /sys/class/gpio/gpio104/direction");
	system("echo 0 > /sys/class/gpio/gpio104/value");
#ifdef SystemLogMessage
	DEBUG_INFO_MSG("[main]InitGPIO: Initial GPIO OK");
#endif
}

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

	if((buf = malloc(MtdBlockSize)) == NULL)
	{
		DEBUG_ERROR_MSG("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, MtdBlockSize);

	//================================================
	// Load configuration from mtdblock10
	//================================================
    system("nanddump /dev/mtd10 -f /mnt/EvseConfig.bin");
    fd = open("/mnt/EvseConfig.bin", O_RDWR);
	if(fd < 0)
	{
		free(buf);
		DEBUG_ERROR_MSG("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, MtdBlockSize);
	close(fd);
	if(wrd < MtdBlockSize)
	{
		free(buf);
		DEBUG_ERROR_MSG("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");
	}
	ChkSum = 0;
    for(wrd = ARRAY_SIZE(ptr->CsuBootLoadFwRev); wrd < MtdBlockSize - 4; wrd++)
    {
        ChkSum += buf[wrd];
    }
    memcpy(&ChkSumOrg, buf + (MtdBlockSize - 4), sizeof(ChkSumOrg));
    memcpy(&ptr->ModelName, buf + (ARRAY_SIZE(ptr->CsuBootLoadFwRev)), ARRAY_SIZE(ptr->ModelName));
    memcpy(&ptr->SerialNumber, buf + (ARRAY_SIZE(ptr->CsuBootLoadFwRev) + ARRAY_SIZE(ptr->ModelName) + ARRAY_SIZE(ptr->AcModelName)), ARRAY_SIZE(ptr->SerialNumber));

	//================================================
	// Load configuration from mtdblock11
	//================================================
	if(ChkSum != ChkSumOrg)
	{
		DEBUG_ERROR_MSG("Primary SysConfigData checksum NG, read backup\r\n");
        system("nanddump /dev/mtd11 -f /mnt/EvseConfig.bin");
        fd = open("/mnt/EvseConfig.bin", O_RDWR);
        if(fd < 0)
		{
			free(buf);
			DEBUG_ERROR_MSG("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, MtdBlockSize);
	    wrd = read(fd, buf, MtdBlockSize);
	    close(fd);
		if(wrd < MtdBlockSize)
		{
			free(buf);
			DEBUG_ERROR_MSG("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");
		}
        ChkSum = 0;
        for(wrd = ARRAY_SIZE(ptr->CsuBootLoadFwRev); wrd < MtdBlockSize - 4; wrd++)
        {
            ChkSum += buf[wrd];
        }
        memcpy(&ChkSumOrg, buf + (MtdBlockSize - 4), sizeof(ChkSumOrg));

		//================================================
		// Load configuration from mtdblock12 (Factory default)
		//================================================
		if(ChkSum != ChkSumOrg)
		{
			DEBUG_ERROR_MSG("backup SysConfigData checksum NG, read Factory default\r\n");
            system("nanddump /dev/mtd12 -f /mnt/EvseConfig.bin");
            fd = open("/mnt/EvseConfig.bin", O_RDWR);
            if(fd < 0)
			{
				free(buf);
				DEBUG_ERROR_MSG("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, MtdBlockSize);
	   		wrd = read(fd, buf, MtdBlockSize);
	    	close(fd);
			if(wrd < MtdBlockSize)
			{
				free(buf);
				DEBUG_ERROR_MSG("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");
			}
            ChkSum = 0;
            for(wrd = ARRAY_SIZE(ptr->CsuBootLoadFwRev); wrd < MtdBlockSize - 4; wrd++)
            {
                ChkSum += buf[wrd];
            }
            memcpy(&ChkSumOrg, buf + (MtdBlockSize - 4), sizeof(ChkSumOrg));
            memcpy(buf + (ARRAY_SIZE(ptr->CsuBootLoadFwRev)), &ptr->ModelName, ARRAY_SIZE(ptr->ModelName));
            memcpy(buf + (ARRAY_SIZE(ptr->CsuBootLoadFwRev) + ARRAY_SIZE(ptr->ModelName) + ARRAY_SIZE(ptr->AcModelName)), &ptr->SerialNumber, ARRAY_SIZE(ptr->SerialNumber));

            if(ChkSum != ChkSumOrg)
			{
				DEBUG_ERROR_MSG("factory default SysConfigData checksum NG, restore factory default\r\n");
				free(buf);
				system("cd /root;./FactoryConfig -m");
				system("rm -f /Storage/OCPP/OCPPConfiguration");
				system("sync");
				sleep(5);
				system("reboot -f");
				sleep(5);
				system("reboot -f");

				return FAIL;
			}
		}
	}

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

	system("rm -f /mnt/EvseConfig.bin");

    // SysConfig in flash is empty (0xffffffff)
    if((strlen((char*)ShmSysConfigAndInfo->SysConfig.ModelName) > ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.ModelName)) ||
        (strlen((char*)ShmSysConfigAndInfo->SysConfig.SerialNumber) > ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.SerialNumber)) ||
        (strlen((char*)ShmSysConfigAndInfo->SysConfig.SystemId) > ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.SystemId)) ||
        (ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthDhcpClient == 0xff))
    {
        if(strlen((char*)ShmSysConfigAndInfo->SysConfig.ModelName) > ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.ModelName))
        {
            PRINTF_FUNC("Model name over length.\n");
            memset(ShmSysConfigAndInfo->SysConfig.ModelName, 0x00, ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.ModelName));
        }

        if(strlen((char*)ShmSysConfigAndInfo->SysConfig.SerialNumber) > ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.SerialNumber))
        {
            PRINTF_FUNC("Model serial number over length.\n");
            memset(ShmSysConfigAndInfo->SysConfig.SerialNumber, 0x00, ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.SerialNumber));
        }

        if(strlen((char*)ShmSysConfigAndInfo->SysConfig.SystemId) > ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.SystemId))
        {
            PRINTF_FUNC("System id over length.\n");
            memset(ShmSysConfigAndInfo->SysConfig.SystemId, 0x00, ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.SystemId));
        }

        if(ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthDhcpClient == 0xff)
        {
            PRINTF_FUNC("Ethernet dhcp config is null.\n");
        }

        system("cd /root;./Module_FactoryConfig -m");
        sleep(3);
        system("/usr/bin/run_evse_restart.sh");
    }

    DEBUG_INFO_MSG("Load SysConfigData OK\r\n");
    return PASS;
}

/*
byte GetCurEthUsage()
{
	byte result = _ETHERNET_USAGE_NONE;
	FILE *fp;
	char cmd[256];
	char buf[512];
	byte targetC = 2;

	strcpy(cmd, "route -n");
	fp = popen(cmd, "r");

	if (fp != NULL)
	{
		while(fgets(buf, sizeof(buf), fp) != NULL)
		{
			if (targetC-- == 0)
			{
				if (strstr(buf, "eth0") > 0)
					result = _ETHERNET_USAGE_LAN;
				else if (strstr(buf, "mlan0") > 0)
					result = _ETHERNET_USAGE_WIFI;
				else if (strstr(buf, "ppp0") > 0)
					result = _ETHERNET_USAGE_3G_4g;
				break;
			}

//			if (strstr(buf, "inet addr:") > 0)
//			{
//			}
		}
	}
	pclose(fp);
	memset(buf, 0x00, sizeof(buf));
	return result;
}
*/

int isEthernetCablePlugIn(int ethernet)
{
    int fd, PlugInStatus = 0;
    char ch[2];
    char buffer[64];

    snprintf(buffer, sizeof(buffer), "/sys/class/net/eth%d/carrier", ethernet);
    fd = open(buffer, O_RDONLY);

    if(fd < 0)
    {
        return -1;
    }

    if(read(fd, ch, 1) < 0)
    {
        return -1;
    }
    PlugInStatus = atoi(ch);

    close(fd);

    return PlugInStatus;
}

int isRouteFail()
{
	int result = YES;
	FILE *fp;
	char buf[512];

	fp = popen("route -n", "r");
	if(fp != NULL)
	{
		while(fgets(buf, sizeof(buf), fp) != NULL)
		{
			if(strstr(buf, "eth0") != NULL)
				result = NO;
		}
	}
	pclose(fp);

	return result;
}

int isReachableInternet()
{
	int result = FAIL;
	FILE *fp;
	char cmd[256];
	char buf[512];
	char tmp[512];

//	if (ShmOCPP16Data->OcppConnStatus == PASS)
//	{
//		result = PASS;
//	}
//	else
	{
		strcpy(cmd, "ifconfig eth0");
		fp = popen(cmd, "r");

		if (fp != NULL)
		{
			while(fgets(buf, sizeof(buf), fp) != NULL)
			{
				if (strstr(buf, "inet addr:") > 0)
				{
					sscanf(buf, "%*s%s", tmp);
					substr(tmp, tmp, strspn(tmp, "addr:"), strlen(buf)-strspn(tmp, "addr:"));

					if (strcmp(tmp, (char *)ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress) != EQUAL)
					{
						strcpy((char *) ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress, tmp);
					}
				}
			}
		}
		pclose(fp);
		memset(buf, 0x00, sizeof(buf));

		for(int idx=0;idx<ARRAY_SIZE(valid_Internet);idx++)
		{
			sprintf(cmd, "ping -c 1 -w 3 -I eth0 %s", valid_Internet[idx]);
			fp = popen(cmd, "r");
			if(fp != NULL)
			{
				while(fgets(buf, sizeof(buf), fp) != NULL)
				{
					if(strstr(buf, "transmitted") > 0)
					{
						//sscanf(buf, "%*s%*s%*s%*s%*s%*s%s", tmp);

						if(strstr(buf,"100%") != NULL)
						{
						}
						else
						{
							result = PASS;
						}
						//DEBUG_INFO("%s",buf);
						//DEBUG_INFO("%s\n",tmp);
					}
				}
			}
			pclose(fp);
		}
	}

	return result;
}

void AnnounceEthernetStatus(void)
{
    for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
        {
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.EthernetStatusRequest = true;
        }
    }
}

void AnnounceWiFiStatus(void)
{
    for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
        {
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.WiFiStatusRequest = true;
        }
    }
}

void AnnounceTelcomModemStatus(void)
{
    for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
        {
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.TelcomModemStatusRequest = true;
        }
    }
}

void AnnounceBackendStatus(void)
{
    for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
        {
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.BackendStatusRequest = true;
        }
    }
}

void AnnounceBillingStatus(void)
{
    for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
        {
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.BillingStatusRequest = true;
        }
    }
}

void AnnounceStopChargingButtonStatus(void)
{
    for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_None &&
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].LocalStatus != _DS_Timeout)
        {
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.StopButtonStatusRequest = true;
        }
    }
}

void UpdateConnectionIcon(void)
{
    unsigned char status = _Connnection_Disable;

    // update ethernet connection status
    status = ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet == YES ? _Connnection_Disconnected : _Connnection_Connected;
    if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.EthernetStatus != status)
    {
        ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.EthernetStatus = status;
        AnnounceEthernetStatus();
    }

    // update wifi connection status
    if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE)
    {
        status = ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi == YES ? _Connnection_Disconnected : _Connnection_Connected;
    }
    else
    {
        status = _Connnection_Disable;
    }
    if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.WiFiStatus != status)
    {
        ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.WiFiStatus = status;
        AnnounceWiFiStatus();
    }

    // update 4g connection status
    if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES)
    {
        status = (ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == NO &&
            ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomNetworkConn == YES) ? _Connnection_Connected : _Connnection_Disconnected;
    }
    else
    {
        status = _Connnection_Disable;
    }
    if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.TelcomModemStatus != status)
    {
        ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.TelcomModemStatus = status;
        AnnounceTelcomModemStatus();
    }

    // update backend connection status
    status = ShmStatusCodeData->InfoCode.InfoEvents.bits.BackendDisconnectedViaEthernet == YES ? _Connnection_Disconnected : _Connnection_Connected;
    if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BackendStatus != status)
    {
        ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BackendStatus = status;
        AnnounceBackendStatus();
    }

    // update billing status
    status = ShmSysConfigAndInfo->SysConfig.BillingData.isBilling;
    if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BillingStatus != status)
    {
        ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BillingStatus = status;
        AnnounceBillingStatus();
    }

    // update stop charging button
    status = ShmSysConfigAndInfo->SysConfig.StopChargingByButton;
    if(ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.StopChargingButton != status)
    {
        ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.StopChargingButton = status;
        AnnounceStopChargingButtonStatus();
    }
}

void Check4gWifiReset(void)
{
    if(ShmChargerInfo->Control.SysCtrl.bits.BackendEnable)
    {
<<<<<<< HEAD
//        PRINTF_FUNC("Internet: %d, Ocpp: %d, Wifi: %d, Telcom: %d",
//                ShmSysConfigAndInfo->SysInfo.InternetConn,
//                ShmSysConfigAndInfo->SysInfo.OcppConnStatus,
//                ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode,
//                ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled);
=======
        PRINTF_FUNC("Internet: %d, Ocpp: %d, Wifi: %d, Telcom: %d",
                ShmSysConfigAndInfo->SysInfo.InternetConn,
                ShmSysConfigAndInfo->SysInfo.OcppConnStatus,
                ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode,
                ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled);
>>>>>>> db8b46994f9d394b7a00b31806c6f9c2326981a7
        if(!ShmSysConfigAndInfo->SysInfo.InternetConn && !ShmSysConfigAndInfo->SysInfo.OcppConnStatus &&
            (ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE ||
            ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES))
        {
            if(!_NeedReset4gWifi)
            {
                gettimeofday(&_4gWifiReset_time, NULL);
                PRINTF_FUNC("Backend Enable But Internet Not Available!");
            }
            _NeedReset4gWifi = true;
        }
        else
        {
            _NeedReset4gWifi = false;
        }

        if(_NeedReset4gWifi)
        {
            if(GetTimeoutValue(_4gWifiReset_time) / uSEC_VAL >= TRY_RESET_4G_WIFI_TIME)
            {
                PRINTF_FUNC("Reset 4g_Wifi Module");
                system("echo 1 > /sys/class/gpio/gpio104/value");
                sleep(1);
                system("echo 0 > /sys/class/gpio/gpio104/value");
                _NeedReset4gWifi = false;
            }
        }
    }
    else
    {
        _NeedReset4gWifi = false;
    }
}

void InitEthernet()
{
    system("ifconfig eth0 down");
    system("ifconfig eth1 down");
    sleep(2);
	char tmpbuf[256];
	// /sbin/ifconfig eth0 192.168.1.10 netmask 255.255.255.0 down
	system("echo 1 > /sys/class/gpio/gpio110/value");//reset PHY
	sleep(2);
	//Init Eth0 for internet
	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);
	//system("ifconfig lo up");
	//  /sbin/ifconfig eth0 192.168.1.10 netmask 255.255.255.0 up
    //Init Eth1 for administrator tool
	memset(tmpbuf,0,256);
	sprintf(tmpbuf,"/sbin/ifconfig eth1 %s netmask %s up", "192.168.100.1", "255.255.255.0");
	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
	system("/sbin/ifconfig eth0 down;/sbin/ifconfig eth0 up");

	if(ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthDhcpClient == 0)
	{
		sprintf(tmpbuf, "/sbin/udhcpc -i eth0 -x hostname:CSU3_%s -s /root/dhcp_script/eth0.script > /dev/null &", ShmSysConfigAndInfo->SysConfig.SystemId);
		system(tmpbuf);
	}

	//Upgrade system id to /etc/hostname
	sprintf(tmpbuf, "echo %s > /etc/hostname", ShmSysConfigAndInfo->SysConfig.SystemId);
	system(tmpbuf);

	// DO360 DHCP Server
	InitialDispenserDhcpServerConfig();
	StartDispenserDhcpServer();

	pid_t pid = fork();
	uint8_t cnt_pingDNS_Fail;

	if(pid == 0)
	{
	    ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BackendStatus = _Connnection_Disconnected;
	    ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.EthernetStatus = _Connnection_Disconnected;
	    ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.WiFiStatus = _Connnection_Disable;
	    ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.TelcomModemStatus = _Connnection_Disable;

		for(;;)
		{
		    if(isEthernetCablePlugIn(0) == YES)
		    {
                if(isRouteFail())
                {
                    PRINTF_FUNC("eth0 not in route, restart eht0. \n");
                    system("/sbin/ifconfig eth0 down;/sbin/ifconfig eth0 up");

                    if (ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthDhcpClient == 0)
                    {
                        InitialDHCP();
                    }
                    else
                    {
                        system("pgrep -f \"udhcpc -i eth0\" | xargs kill");
                        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(isReachableInternet() == PASS)
			{
			    if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet != NO)
			    {
			        PRINTF_FUNC("Internet is Reachable");
			    }
				ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet = NO;
				ShmSysConfigAndInfo->SysInfo.ethInternetConn = YES;
				cnt_pingDNS_Fail = 0;
			}
			else
			{
				if(++cnt_pingDNS_Fail > 3)
				{
				    if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet != YES)
				    {
				        PRINTF_FUNC("Internet is Disconnect Via Ethernet");
				    }
					ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet = YES;
					ShmSysConfigAndInfo->SysInfo.ethInternetConn = NO;
				}
			}

			bool ethResult = ShmSysConfigAndInfo->SysInfo.ethInternetConn;

			if(ethResult == YES)
			{
				system("/sbin/ifmetric eth0 0");

				if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE &&
                    ((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W') || (ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')))
				{
					system("/sbin/ifmetric mlan0 1");
				}

				if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES &&
                    ((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T') || (ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')))
				{
					system("/sbin/ifmetric ppp0 2");
				}
			}

			if (!ethResult &&
			        ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE &&
					(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W' || ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D'))
			{
			    ethResult = ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi == YES ? NO : YES;

				if (ethResult)
				{
					if((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W') || (ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D'))
					{
						system("/sbin/ifmetric eth0 1");
						system("/sbin/ifmetric mlan0 0");
					}

					if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES &&
                        ((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T') || (ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')))
					{
						system("/sbin/ifmetric ppp0 2");
					}
				}
			}

			if (!ethResult &&
			        ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES &&
					(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T' || ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D'))
			{
                ethResult = (ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == NO &&
                    ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomNetworkConn == YES) ? YES : NO;

				if (ethResult)
				{
					if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE &&
                        ((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W') || (ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')))
					{
						system("/sbin/ifmetric mlan0 2");
					}

					if((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T') || (ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D'))
					{
						system("/sbin/ifmetric eth0 1");
						system("/sbin/ifmetric ppp0 0");
					}
				}
			}

            if(system("pidof -s OcppBackend > /dev/null") != 0)
            {
                ShmOCPP16Data->OcppConnStatus = false;
                ShmSysConfigAndInfo->SysInfo.OcppConnStatus = false;
            }

			ShmSysConfigAndInfo->SysInfo.InternetConn = ethResult;

			ShmStatusCodeData->InfoCode.InfoEvents.bits.WiFiDisable = ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode == false ? true : false;
			ShmStatusCodeData->InfoCode.InfoEvents.bits.Telocom4GModuleDisable = ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == false ? true : false;
			ShmStatusCodeData->InfoCode.InfoEvents.bits.BackendDisconnectedViaEthernet = ShmSysConfigAndInfo->SysInfo.OcppConnStatus == false ? true : false;

			UpdateConnectionIcon();
			Check4gWifiReset();

			sleep(5);
		}
	}

	#ifdef SystemLogMessage
	DEBUG_INFO_MSG("[main]InitEthernet: Initial Ethernet OK. \n");
	#endif
}

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

void GetMacAddress()
{
	for (byte index = 0; index < 2; index++)
	{
		int fd;
		struct ifreq ifr;
		char tarEth[5];
		char Mac[18];

		sprintf(tarEth,"eth%d",index);
		fd = socket(AF_INET, SOCK_DGRAM, 0);

		ifr.ifr_addr.sa_family = AF_INET;
		strncpy(ifr.ifr_name, tarEth, IFNAMSIZ - 1);

		ioctl(fd, SIOCGIFHWADDR, &ifr);
		close(fd);

		sprintf(Mac, "%.2x:%.2x:%.2x:%.2x:%.2x:%.2x",
				ifr.ifr_hwaddr.sa_data[0], ifr.ifr_hwaddr.sa_data[1], ifr.ifr_hwaddr.sa_data[2],
				ifr.ifr_hwaddr.sa_data[3], ifr.ifr_hwaddr.sa_data[4], ifr.ifr_hwaddr.sa_data[5]);

		if (index == 0)
			strcpy((char *) ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthMacAddress, Mac);
		else
			strcpy((char *) ShmSysConfigAndInfo->SysConfig.Eth1Interface.EthMacAddress, Mac);
	}
}

void GetFirmwareVersion()
{
	// Get CSU root file system version
	sprintf((char*)ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev, fwVersion);

	byte count = 0, chademo = 0, ccs = 0, gb = 0;
	for(uint8_t idx=0;idx<3;idx++)
	{
		if (ShmSysConfigAndInfo->SysConfig.ModelName[7+idx] == 'J')
		{
			chademo++;
			count++;
		}
		else  if (ShmSysConfigAndInfo->SysConfig.ModelName[7+idx] == 'G')
		{
			gb++;
			count++;
		}
		else  if (ShmSysConfigAndInfo->SysConfig.ModelName[7+idx] == 'U' ||
				ShmSysConfigAndInfo->SysConfig.ModelName[7+idx] == 'E')
		{
			ccs++;
			count++;
		}
	}

	if (count == 1)
	{
		if (chademo > 0)
			ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[7] = '1';
		else if (ccs > 0)
			ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[7] = '2';
		else if (gb > 0)
			ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[7] = '3';
	}
	else
	{
		if (chademo > 0 && ccs > 0)
			ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[7] = '4';
		else if (chademo > 0 && gb > 0)
			ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[7] = '5';
		else if (ccs > 0 && gb > 0)
			ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[7] = '6';
	}

	// Get network option from model name
	switch(ShmSysConfigAndInfo->SysConfig.ModelName[10])
	{
		case 'B':
		case 'U':
			//Blue tooth
			ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[9] = '3';
			break;
		case 'W':
			// WIFI
			ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[9] = '1';
			break;
		case 'T':
			// 3G/4G
			ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[9] = '2';
			break;
        case 'D':
            ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[9] = '5';
            break;
		default:
			// LAN
			ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[9] = '0';
			break;
	}
	// Get rating power from model name
	memcpy(&ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev[10], &ShmSysConfigAndInfo->SysConfig.ModelName[4], 0x03);

	// Get IEC or UL
	char _buf[3] = {0};
	memcpy(_buf, &ShmSysConfigAndInfo->SysConfig.ModelName[2], 2);

	if (strcmp(_buf, "YE") == EQUAL || strcmp(_buf, "YC") == EQUAL)
		ShmSysConfigAndInfo->SysInfo.ChargerType = _CHARGER_TYPE_IEC;
	else if (strcmp(_buf, "WU") == EQUAL)
		ShmSysConfigAndInfo->SysInfo.ChargerType = _CHARGER_TYPE_UL;
}

void InitialShareMemoryInfo()
{
	FILE *fp;
	char cmd[512];
	char buf[512];

	_UpgradeNeedReboot = FALSE;

	//sprintf((char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomApn, "Internet");
	//sprintf((char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomChapPapId, " ");
	//sprintf((char *)ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomChapPapPwd, " ");

	ShmSysConfigAndInfo->SysConfig.TotalConnectorCount = 0;
	ShmSysConfigAndInfo->SysConfig.AcConnectorCount = 0;

	ShmSysConfigAndInfo->SysInfo.FactoryConfiguration = 0;
	ShmSysConfigAndInfo->SysInfo.InputVoltageR = 0;
	ShmSysConfigAndInfo->SysInfo.InputVoltageS = 0;
	ShmSysConfigAndInfo->SysInfo.InputVoltageT = 0;
	ShmSysConfigAndInfo->SysInfo.SystemFanRotaSpeed = 0;
	ShmSysConfigAndInfo->SysInfo.PsuFanRotaSpeed = 0;
	ShmSysConfigAndInfo->SysInfo.AuxPower5V = 0;
	ShmSysConfigAndInfo->SysInfo.AuxPower12V = 0;
	ShmSysConfigAndInfo->SysInfo.AuxPower24V = 0;
	ShmSysConfigAndInfo->SysInfo.AuxPower48V = 0;

	sprintf((char *)ShmSysConfigAndInfo->SysInfo.CsuHwRev, "REV:5.0");
	memcpy(ShmSysConfigAndInfo->SysInfo.CsuBootLoadFwRev, ShmSysConfigAndInfo->SysConfig.CsuBootLoadFwRev, ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.CsuBootLoadFwRev));

	sprintf(cmd, "/bin/uname -r");
	fp = popen(cmd, "r");
	if(fp == NULL)
		sprintf((char*)ShmSysConfigAndInfo->SysInfo.CsuKernelFwRev, "Unknown version");
	else
	{
		while(fgets(buf, sizeof(buf), fp) != NULL)
		{
			strcpy((char*)ShmSysConfigAndInfo->SysInfo.CsuKernelFwRev, buf);
		}
	}

	// 雙槍 CCS + Chademo
	GetFirmwareVersion();
	//sprintf((char *) ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev, fwVersion);
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.CsuPrimFwRev, " ");

	sprintf((char *) ShmSysConfigAndInfo->SysInfo.LcmHwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.LcmFwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.PsuHwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.PsuPrimFwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.PsuSecFwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.AuxPwrHwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.AuxPwrFwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.FanModuleHwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.FanModuleFwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.RelayModuleHwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.RelayModuleFwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.Relay2ModuleHwRev, " ");		//DO360 RC2
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.Relay2ModuleFwRev, " ");		//DO360 RC2
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.TelcomModemFwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.LedModuleFwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.Connector1FwRev, " ");
	sprintf((char *) ShmSysConfigAndInfo->SysInfo.Connector2FwRev, " ");
	ShmSysConfigAndInfo->SysInfo.SystemAmbientTemp = 0;
	ShmSysConfigAndInfo->SysInfo.SystemCriticalTemp = 0;
	ShmSysConfigAndInfo->SysInfo.PsuAmbientTemp = 0;
	ShmSysConfigAndInfo->SysInfo.CcsConnectorTemp = 0;
	ShmSysConfigAndInfo->SysInfo.InternetConn = 0;
	ShmSysConfigAndInfo->SysInfo.OcppConnStatus = 0;
	ShmSysConfigAndInfo->SysInfo.OrderCharging = NO_DEFINE;

	strcpy((char *) ShmSysConfigAndInfo->SysConfig.UserId, "");

	ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RelayboardStestFail = NO;
	ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FanboardStestFail = NO;
	ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PrimaryStestFail = NO;
	ShmStatusCodeData->AlarmCode.AlarmEvents.bits.ChademoboardStestFail = NO;
	ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CCSboardStestFail = NO;
	ShmStatusCodeData->AlarmCode.AlarmEvents.bits.AcContactStestFail = NO;
	ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuModuleStestFail = NO;

	memset(ShmSysConfigAndInfo->SysInfo.FanModuleFwRev, 0, ARRAY_SIZE(ShmSysConfigAndInfo->SysInfo.FanModuleFwRev));
	memset(ShmSysConfigAndInfo->SysInfo.RelayModuleFwRev, 0, ARRAY_SIZE(ShmSysConfigAndInfo->SysInfo.RelayModuleFwRev));
	memset(ShmSysConfigAndInfo->SysInfo.Relay2ModuleFwRev, 0, ARRAY_SIZE(ShmSysConfigAndInfo->SysInfo.Relay2ModuleFwRev));	//DO360 RC2
	ShmPrimaryMcuData->SelfTest_Comp = NO;
	ShmRelayModuleData[0]->SelfTest_Comp = NO;
	ShmRelayModuleData[1]->SelfTest_Comp = NO;
	ShmFanModuleData->SelfTest_Comp = NO;
	ShmLedModuleData->SelfTest_Comp = NO;
	ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_NONE;
	ShmSysConfigAndInfo->SysInfo.MainChargingMode = _MAIN_CHARGING_MODE_MAX;
	ShmSysConfigAndInfo->SysInfo.ReAssignedFlag = _REASSIGNED_NONE;
	ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc = NO_DEFINE;

	ShmFanModuleData->TestFanSpeed = 0;

	ShmStatusCodeData->AlarmCode.AlarmEvents.bits.ModelNameNoneMatchStestFail = NO;
	ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuNoResource = NO;

	char EvsePower[2];

	EvsePower[2] = '\0';
	unsigned short buf_pow = 0;
	if (strlen((char *) ShmSysConfigAndInfo->SysConfig.ModelName) >= 6)
	{
		strncpy(EvsePower, (char *)(ShmSysConfigAndInfo->SysConfig.ModelName + 4), 2);
		if (strcmp(EvsePower, "15") == EQUAL)
			buf_pow = 150;
		else if (strcmp(EvsePower, "30") == EQUAL)
			buf_pow = 30;
		else if (strcmp(EvsePower, "60") == EQUAL)
			buf_pow = 60;
		else if (strcmp(EvsePower, "12") == EQUAL)
			buf_pow = 120;
		else if (strcmp(EvsePower, "18") == EQUAL)
			buf_pow = 180;
		else if (strcmp(EvsePower, "36") == EQUAL)
			buf_pow = 360;

		ShmSysConfigAndInfo->SysConfig.RatingCurrent = (buf_pow / 30) * PSU_MIN_CUR;

		if(ShmSysConfigAndInfo->SysConfig.MaxChargingPower == 0 ||
				ShmSysConfigAndInfo->SysConfig.MaxChargingPower > buf_pow)
			ShmSysConfigAndInfo->SysConfig.MaxChargingPower = buf_pow;
	}
	ShmSysConfigAndInfo->SysConfig.SwitchDebugFlag = NO;
	ShmSysConfigAndInfo->SysConfig.AlwaysGfdFlag = NO;

    PRINTF_FUNC("DispenserSequence = %d, MaxConnectorQuantity = %d",
            ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence,
            ShmSysConfigAndInfo->SysConfig.WiringInfo.MaxConnectorQuantity);
    for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.WiringInfo.DispenserSequence; i++)
    {
        PRINTF_FUNC("Dispenser[%d] <=> %d", i, ShmSysConfigAndInfo->SysConfig.WiringInfo.WiringSetting[i]);
    }
}

int Initialization(void)
{
	// 初始化卡號驗證的 Flag
	ClearAuthorizedFlag();

	// 初始化插槍驗證的 Flag
	ClearDetectPluginFlag();

//	int pinOut[2] = { 116, 115 };
	for (byte count = 0; count < CONNECTOR_QUANTITY; count++)
	{
		chargingInfo[count]->RemoteStartFlag = NO;
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[count].Parameter.bits.RemoteStartRequest = false;
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[count].Parameter.bits.RemoteStartConfirm = false;
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[count].Parameter.bits.RemoteStopRequest = false;
		ShmSysConfigAndInfo->SysInfo.ConnectorInfo[count].Parameter.bits.RemoteStopConfirm = false;

		strcpy((char *)ShmOCPP16Data->StatusNotification[count].ErrorCode, "NoError");
	}

	PRINTF_FUNC("Initialization OK");
	return PASS;
}

void InitialPsuGroupingAndLocation(void)
{
    if(ShmChargerInfo->Control.SysCtrl.bits.SecondRelayBoardEnable)
    {
        memcpy(ShmPsuGrouping->Location, Group_to_Location_4_Gun, sizeof(ShmPsuGrouping->Location));
        memcpy(ShmPsuGrouping->Layout, Location_to_Group_4_Gun, sizeof(ShmPsuGrouping->Layout));
    }
    else
    {
        memcpy(ShmPsuGrouping->Location, Group_to_Location_2_Gun, sizeof(ShmPsuGrouping->Location));
        memcpy(ShmPsuGrouping->Layout, Location_to_Group_2_Gun, sizeof(ShmPsuGrouping->Layout));
    }
    for(int i = 0; i < CONNECTOR_QUANTITY; i++)
    {
        ShmGroupCollection[i].Index = i;
        ShmGroupCollection[i].Location = ShmPsuGrouping->Location[i];
        if(ShmChargerInfo->Control.SysCtrl.bits.SecondRelayBoardEnable)
        {
            memcpy(&ShmGroupCollection[i].ParallelConfig[0], &GroupParallelRelay_4_Gun[i][0], GENERAL_GUN_QUANTITY);
        }
        else
        {
            memcpy(&ShmGroupCollection[i].ParallelConfig[0], &GroupParallelRelay_2_Gun[i][0], GENERAL_GUN_QUANTITY);
        }
        _PsuGroupAvailable[i] = NO;
    }
}

void InitialMaxDispenserConnectorQuantity(void)
{
    if(ShmSysConfigAndInfo->SysConfig.ModelName[0] == 'D' && ShmSysConfigAndInfo->SysConfig.ModelName[1] == 'K')
    {
        ShmChargerInfo->Control.MaxDispenser = 2;
        ShmChargerInfo->Control.MaxConnector = 2;
    }
    else
    {
        ShmChargerInfo->Control.MaxDispenser = GENERAL_GUN_QUANTITY;
        ShmChargerInfo->Control.MaxConnector = GENERAL_GUN_QUANTITY;
    }
}

void InitialAuthMode(void)
{
    if(ShmSysConfigAndInfo->SysConfig.ModelName[0] == 'D' && ShmSysConfigAndInfo->SysConfig.ModelName[1] == 'K')
    {
        ShmChargerInfo->AuthInfo.AuthMode.bits.AutoStartEnable = true;
    }
}

void InitialQRCodeMode(void)
{
    if(ShmSysConfigAndInfo->SysConfig.ModelName[12] == 'A' && ShmSysConfigAndInfo->SysConfig.ModelName[13] == 'D')
    {
        ShmChargerInfo->AuthInfo.QRCodeMode = _QR_MODE_ChargeBoxId;
    }
    else
    {
        // customized
        if(ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode)
        {
            ShmChargerInfo->AuthInfo.QRCodeMode = _QR_MODE_Customized;
        }
        else
        {
            ShmChargerInfo->AuthInfo.QRCodeMode = _QR_MODE_Default;
        }
    }
}

void InitialPowerCabinetSetting(void)
{
    if(ShmSysConfigAndInfo->SysConfig.ModelName[12] == 'A' && ShmSysConfigAndInfo->SysConfig.ModelName[13] == 'D')
    {
        ShmSysConfigAndInfo->SysConfig.BillingData.isBilling = true;
    }

    ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.BillingStatus = ShmSysConfigAndInfo->SysConfig.BillingData.isBilling;
    ShmSysConfigAndInfo->SysInfo.CabinetMicsStatus.StopChargingButton = ShmSysConfigAndInfo->SysConfig.StopChargingByButton;
}

bool InitialChargerSetting(void)
{
    bool result = true;

    if(ShmSysConfigAndInfo->SysConfig.ModelName[0] == 'D' && ShmSysConfigAndInfo->SysConfig.ModelName[1] == 'O')
    {
        ShmChargerInfo->Control.PrimaryCtrl.bits.AcContactorReverse = true;
        ShmChargerInfo->Control.PrimaryCtrl.bits.DoorSensorReverse = true;
        ShmChargerInfo->Control.SysCtrl.bits.LedBoardDisable = true;
        ShmChargerInfo->Control.SysCtrl.bits.SecondRelayBoardEnable = true;

        ShmChargerInfo->Control.SysCtrl.bits.StandardLedIndication = true;
    }
    else if(ShmSysConfigAndInfo->SysConfig.ModelName[0] == 'D' && ShmSysConfigAndInfo->SysConfig.ModelName[1] == 'K')
    {
        ShmChargerInfo->Control.SysCtrl.bits.FanBoardDisable = true;
        ShmChargerInfo->Control.SysCtrl.bits.LedBoardDisable = true;

        ShmChargerInfo->Control.SysCtrl.bits.E4YOULedIndication = true;
    }
    else
    {
        result = false;
    }

    InitialMaxDispenserConnectorQuantity();
    InitialAuthMode();
    InitialQRCodeMode();
    InitialPsuGroupingAndLocation();
    InitialPowerCabinetSetting();

    if(!CheckConnectorTypeStatus())
    {
        result = false;
    }

    return result;
}

bool InitialSystemDefaultConfig()
{
	bool result = true;

	LoadSysConfigAndInfo(&ShmSysConfigAndInfo->SysConfig);
	InitGPIO();
	InitEthernet();
	GetMacAddress();

//	system("echo 1 > /sys/class/gpio/gpio110/value"); //reset PHY
//	sleep(3);
//	system("/sbin/ifconfig eth0 192.168.1.10 netmask 255.255.255.0 down");
//	sleep(1);
//	system("/sbin/ifconfig eth1 192.168.0.10 netmask 255.255.255.0 up");

	return result;
}

/*
bool DisplaySelfTestFailReason()
{
	bool result = false;
	// RB、FB、407、EV 小板中有些板子無回應
	if (ShmRelayModuleData->SelfTest_Comp == NO)
	{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RelayboardStestFail = YES; result = true; }
	if (ShmFanModuleData->SelfTest_Comp == NO)
	{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FanboardStestFail = YES; result = true; }
	if (ShmPrimaryMcuData->SelfTest_Comp == NO)
	{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PrimaryStestFail = YES; result = true; }
//	if (ShmLedModuleData->SelfTest_Comp == NO)
//	{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.LedboardStestFail = YES; }
	for (byte index = 0; index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; index++)
	{
		if (chargingInfo[index]->Type == _Type_Chademo)
		{
			if (ShmCHAdeMOData->evse[chargingInfo[index]->type_index].SelfTest_Comp == NO)
			{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.ChademoboardStestFail = YES; result = true; }
		}
		else if (chargingInfo[index]->Type == _Type_GB)
		{
			if (ShmGBTData->evse[chargingInfo[index]->type_index].SelfTest_Comp == NO)
			{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.GbtboardStestFail = YES; result = true; }
		}
		else if (chargingInfo[index]->Type == _Type_CCS_2)
		{
			if (ShmCcsData->CommProtocol == _CCS_COMM_V2GMessage_DIN70121)
			{
				if (ShmCcsData->V2GMessage_DIN70121[chargingInfo[index]->type_index].SelfTest_Comp == NO)
				{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CCSboardStestFail = YES; result = true; }
			}
		}
	}
	for (byte index = 0; index < ShmSysConfigAndInfo->SysConfig.AcConnectorCount; index++)
	{
		// 先借 GBT 顯示
		if (ac_chargingInfo[index]->SelfTest_Comp == NO)
		{ ShmStatusCodeData->AlarmCode.AlarmEvents.bits.AcConnectorStestFail = YES; result = true; }
	}

	if (ShmSysConfigAndInfo->SysInfo.AcContactorStatus == NO)
	{
		// AC Contact 未搭上
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.AcContactStestFail = YES;
		result = true;
	}
	else if (ShmPsuData->SystemAvailablePower <= 0 && ShmPsuData->SystemAvailableCurrent <= 0)
	{
		// PSU 通訊問題
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuModuleStestFail = YES;
		result = true;
	}

	return result;
}
*/

void SelfTestRun()
{
    struct timeval _selfTest_time;


	ShmRelayModuleData[0]->SelfTest_Comp = NO;
	ShmRelayModuleData[1]->SelfTest_Comp = NO;
	ShmFanModuleData->SelfTest_Comp = NO;
	ShmPrimaryMcuData->SelfTest_Comp = NO;

	ShmSysConfigAndInfo->SysInfo.SelfTestSeq = _STEST_VERSION;
	gettimeofday(&_selfTest_time, NULL);

	while (ShmSysConfigAndInfo->SysInfo.SelfTestSeq != _STEST_COMPLETE)
	{
		ChkPrimaryStatus();
		if (ShmSysConfigAndInfo->SysWarningInfo.Level == 2)
		{
			ShmSysConfigAndInfo->SysInfo.SelfTestSeq = _STEST_FAIL;
			PRINTF_FUNC("Self Test Fail: WarningInfo Level 2");
			return;
		}

		if (ShmSysConfigAndInfo->SysConfig.TotalConnectorCount > 0)
		{
			if (ShmPsuData->Work_Step == _NO_WORKING ||
					ShmSysConfigAndInfo->SysInfo.SelfTestSeq == _STEST_FAIL)
			{
				ShmSysConfigAndInfo->SysInfo.SelfTestSeq = _STEST_FAIL;
				PRINTF_FUNC("Self Test Fail: PSU No Working");
				return;
			}

			switch(ShmSysConfigAndInfo->SysInfo.SelfTestSeq)
			{
				case _STEST_VERSION:
				{
                    if ((ShmChargerInfo->Control.SysCtrl.bits.FanBoardDisable || ShmFanModuleData->SelfTest_Comp) &&
                        (ShmChargerInfo->Control.SysCtrl.bits.RelayBoardDisable || ShmRelayModuleData[0]->SelfTest_Comp) &&
                        (ShmChargerInfo->Control.SysCtrl.bits.RelayBoardDisable ||
                        ShmChargerInfo->Control.SysCtrl.bits.SecondRelayBoardEnable == false ||
                        ShmRelayModuleData[1]->SelfTest_Comp) &&
                        ShmPrimaryMcuData->SelfTest_Comp)
					{
						ShmSysConfigAndInfo->SysInfo.SelfTestSeq = _STEST_PSU_DETECT;
						PRINTF_FUNC("Self test version check ok");
						SetAcContactor(ON);
					}
				}
					break;
				case _STEST_AC_CONTACTOR:
				{
					//ShmPsuData->Work_Step = _TEST_COMPLETE;
					// 因為 30KW 以下沒有 Relay feedback 功能，所以暫時先直接跳過
					if (ShmSysConfigAndInfo->SysInfo.AcContactorStatus == YES)
					{
						ShmSysConfigAndInfo->SysInfo.SelfTestSeq = _STEST_PSU_DETECT;
						PRINTF_FUNC("Communication board pass.");
					}
				}
					break;
				case _STEST_PSU_DETECT:
				{
					if (ShmPsuData->Work_Step >= GET_SYS_CAP)
					{
						ShmSysConfigAndInfo->SysInfo.SelfTestSeq = _STEST_PSU_CAP;
					}
				}
					break;
				case _STEST_PSU_CAP:
				{
					// 此測試是要確認當前總輸出能力
					// 如果沒有 PSU 模組請 bypass
					if (ShmPsuData->Work_Step == BOOTING_COMPLETE)
					{
						sleep(1);
						ShmSysConfigAndInfo->SysInfo.SelfTestSeq = _STEST_COMPLETE;
						ShmSysConfigAndInfo->SysInfo.BootingStatus = BOOT_COMPLETE;
					}
				}
					break;
			}
		}
		else
			break;

		usleep(100000);

        if(GetTimeoutValue(_selfTest_time) / uSEC_VAL >= SELFTEST_TIMEOUT)
        {
            _SelfTestTimeout();
            break;
        }
	}
}

int SpawnTask()
{
	sleep(2);
	system("/root/Module_EventLogging &");
	system("/root/Module_PrimaryComm &");
	system("/root/Module_EvComm &");
	//system("/root/Module_LcmControl &");
	system("/root/Module_InternalComm &");
	system("/root/Module_PsuComm &");
	system("/root/Module_ProduceUtils &");

	if(strcmp((char *)ShmSysConfigAndInfo->SysConfig.OcppServerURL, "") != EQUAL &&
		strcmp((char *)ShmSysConfigAndInfo->SysConfig.ChargeBoxId, "") != EQUAL)
	{
		system("/root/OcppBackend &");
	}

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

	if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W')
	{
	    if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE)
	    {
	        system("/root/Module_Wifi &");
	    }
	}

	if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')
	{
	    if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES)
	    {
	        system("/root/Module_4g &");
	    }
	    if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE)
	    {
	        system("/root/Module_Wifi &");
	    }
	}

	return PASS;
}

int runFlashShellCmd(const char *cmd)
{
    int result = FAIL;
    char buf[256];
    FILE *fp;

    fp = popen(cmd, "r");
    if(fp != NULL)
    {
        while(fgets(buf, sizeof(buf), fp) != NULL)
        {
            DEBUG_INFO_MSG("%s\n", buf);
        }

        result = PASS;
    }
    pclose(fp);

    return result;
}

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

    Chk = 0;
    ptr = (unsigned char *)UsrData;
    if((BufTmp = malloc(MtdBlockSize)) != NULL)
    {
        memset(BufTmp, 0, MtdBlockSize);
        memcpy(BufTmp, ptr, sizeof(struct SysConfigData));
        for(i = ARRAY_SIZE(UsrData->CsuBootLoadFwRev); i < MtdBlockSize - 4; i++)
        {
            Chk += *(BufTmp+i);
        }
        memcpy(BufTmp + MtdBlockSize - 4, &Chk, 4);

        // Output configuration to file.
        fd = open("/mnt/EvseTempConfig.bin", O_RDWR | O_CREAT | O_TRUNC);
        if(fd < 0)
        {
            DEBUG_ERROR_MSG("open /mnt/EvseTempConfig.bin NG\n");

            free(BufTmp);
            return 0;
        }
        wrd = write(fd, BufTmp, MtdBlockSize);
        close(fd);
        if(wrd < MtdBlockSize)
        {
            DEBUG_ERROR_MSG("write /mnt/EvseTempConfig.bin NG\n");

            free(BufTmp);
            return 0;
        }
        DEBUG_INFO_MSG("EvseTempConfig write to file in /mnt OK.\n");

        DEBUG_INFO_MSG("Erase /dev/mtd10.\n");
        runFlashShellCmd("flash_erase /dev/mtd10 0 0");
        DEBUG_INFO_MSG("Write /dev/mtd10.\n");
        runFlashShellCmd("nandwrite -p /dev/mtd10 /mnt/EvseTempConfig.bin");

        DEBUG_INFO_MSG("Erase /dev/mtd11.\n");
        runFlashShellCmd("flash_erase /dev/mtd11 0 0");
        DEBUG_INFO_MSG("Write /dev/mtd11.\n");
        runFlashShellCmd("nandwrite -p /dev/mtd11 /mnt/EvseTempConfig.bin");

        system("rm -f /mnt/EvseTempConfig.bin");
        DEBUG_INFO_MSG("EvseTempConfig write to flash OK\n");
    }
    else
    {
        DEBUG_ERROR_MSG("alloc BlockSize NG\r\n");
        result = FAIL;
    }

    if(BufTmp != NULL)
    {
        free(BufTmp);
    }

    return result;
}

//===============================================
// Common Detect Chk - Stop Charging ?
//===============================================
bool isEvBoardStopChargeFlag(byte gunIndex)
{
	return chargingInfo[gunIndex]->ChargingStopFlag.bits.AlarmStop;
}

bool isNormalStopChargeFlag(byte gunIndex)
{
    return (chargingInfo[gunIndex]->ChargingStopFlag.bits.NormalStop || chargingInfo[gunIndex]->ChargingStopFlag.bits.ManualStop);
}

//===============================================
// 掃描插槍狀況
//===============================================
void ClearDetectPluginFlag()
{
	ShmSysConfigAndInfo->SysInfo.WaitForPlugit = NO;
	for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
	{
		if (chargingInfo[gun_index]->RemoteStartFlag == YES)
			chargingInfo[gun_index]->RemoteStartFlag = NO;
	}

	if (ShmSysConfigAndInfo->SysInfo.OrderCharging != NO_DEFINE)
		ShmSysConfigAndInfo->SysInfo.OrderCharging = NO_DEFINE;
}

void DetectPluginStart()
{
	ShmSysConfigAndInfo->SysInfo.WaitForPlugit = YES;
}

bool isDetectPlugin()
{
	if(ShmSysConfigAndInfo->SysInfo.WaitForPlugit == YES)
		return YES;

	return NO;
}

//===============================================
// Common Detect Chk - Chademo
//===============================================
bool isEvGunLocked_chademo(byte gunIndex)
{
	return (DetectBitValue(chargingInfo[gunIndex]->GunLocked , 0) == 0)? NO : YES;
}

bool isEvContactorWelding_chademo(byte gunIndex)
{
	return DetectBitValue(ShmCHAdeMOData->ev[chargingInfo[gunIndex]->type_index].EvDetection, 3);
}

bool isEvStopReq_chademo(byte gunIndex)
{
	return DetectBitValue(ShmCHAdeMOData->ev[chargingInfo[gunIndex]->type_index].EvDetection, 4);
}

bool isEvStopCharging_chademo(byte gunIndex)
{
	if (isEvGunLocked_chademo(gunIndex) == NO)
	{
		// 無鎖槍 = 停止
		PRINTF_FUNC("gun locked none (%d) \n", gunIndex);
		return YES;
	}

	return NO;
}

byte isPrechargeStatus_chademo(byte gunIndex)
{
	byte result = 0x00;

	result = ShmCHAdeMOData->ev[chargingInfo[gunIndex]->type_index].PresentMsgFlowStatus;

	return result;
}
//===============================================
// Common Detect Chk - GB
//===============================================
bool isEvGunLocked_gb(byte gunIndex)
{
	return (DetectBitValue(chargingInfo[gunIndex]->GunLocked , 0) == 0)? NO : YES;
}

bool isEvStopCharging_gb(byte gunIndex)
{
	if (isEvGunLocked_gb(gunIndex) == NO)
	{
		// 無鎖槍 = 停止
		PRINTF_FUNC("gun locked none. \n");
		return YES;
	}

	return NO;
}

byte isPrechargeStatus_gb(byte gunIndex)
{
	byte result = 0x00;

	result = ShmGBTData->ev[chargingInfo[gunIndex]->type_index].PresentMsgFlowStatus;

	return result;
}

//===============================================
// Common Detect Chk - CCS
//===============================================
bool isEvGunLocked_ccs(byte gunIndex)
{
	return (DetectBitValue(chargingInfo[gunIndex]->GunLocked , 0) == 0)? NO : YES;
}

byte isPrechargeStatus_ccs(byte gunIndex)
{
	byte result = 0x00;

	if (ShmCcsData->CommProtocol == _CCS_COMM_V2GMessage_DIN70121)
	{
		result = ShmCcsData->V2GMessage_DIN70121[chargingInfo[gunIndex]->type_index].PresentMsgFlowStatus;
	}

	return result;
}

bool isEvStopCharging_ccs(byte gunIndex)
{
	if (isEvGunLocked_ccs(gunIndex) == NO)
	{
		// 無鎖槍 = 停止
		PRINTF_FUNC("gun locked none. \n");
		return YES;
	}

	return NO;
}

//===============================================
// Callback
//===============================================
void DisplayChargingInfo()
{
	PRINTF_FUNC("*********** DisplayChargingInfo *********** \n");
	for (byte i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
	{
		if (chargingInfo[i]->SystemStatus != S_IDLE &&
				chargingInfo[i]->SystemStatus != S_RESERVATION)
		{
			ChangeGunSelectByIndex(i);
			return;
		}
	}

	if (ShmSysConfigAndInfo->SysConfig.AcConnectorCount > 0 &&
		ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc == NO_DEFINE &&
		ac_chargingInfo[0]->SystemStatus >= S_PREPARNING && ac_chargingInfo[0]->SystemStatus <= S_COMPLETE)
	{
		ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc = DEFAULT_AC_INDEX;
	}

	usleep(50000);
	ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_NONE;
}

void _AutoReturnTimeout()
{
	PRINTF_FUNC("*********** _AutoReturnTimeout %d*********** \n", ShmSysConfigAndInfo->SysInfo.PageIndex);
	if (ShmSysConfigAndInfo->SysInfo.PageIndex == _LCM_WAIT_FOR_PLUG)
	{
		ClearDetectPluginFlag();
	}
//	else if (ShmSysConfigAndInfo->SysInfo.PageIndex == _LCM_AUTHORIZ_COMP)
//	{
//		DetectPluginStart();
//	}
	usleep(50000);
	ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_NONE;
}

void _SelfTestTimeout(void)
{
	if (ShmSysConfigAndInfo->SysInfo.BootingStatus != BOOT_COMPLETE)
	{
		for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
		{
			setChargerMode(gun_index, MODE_FAULT);
		}
	}
	ShmPsuData->Work_Step = _NO_WORKING;
	ShmSysConfigAndInfo->SysInfo.SelfTestSeq = _STEST_FAIL;
	PRINTF_FUNC("Self test timeout. \n");
}

void _AuthorizedTimeout()
{
	if(IsAuthorizingMode())
	{
		PRINTF_FUNC("*********** _AuthorizedTimeout *********** \n");
		isCardScan = false;
		ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_AUTHORIZ_FAIL;
		ChangeLcmByIndex(_LCM_AUTHORIZ_FAIL);
		strcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, "");
		ClearAuthorizedFlag();
	}
}

void _DetectPlugInTimeout()
{
	PRINTF_FUNC("*********** _DetectPlugInTimeout *********** \n");
	strcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, "");
	ClearDetectPluginFlag();
	usleep(50000);
	ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_NONE;
}

void _DetectEvChargingEnableTimeout(byte gunIndex)
{
	if (chargingInfo[gunIndex]->Type == _Type_Chademo)
	{
		if(!isEvGunLocked_chademo(gunIndex))
		{
			PRINTF_FUNC("*********** _DetectEvChargingEnableTimeout (chademo) ***********\n");
		}
	}
	else if (chargingInfo[gunIndex]->Type == _Type_GB)
	{
		if(!isEvGunLocked_ccs(gunIndex))
		{
			PRINTF_FUNC("*********** _DetectEvChargingEnableTimeout (gb) ***********\n");
		}
	}
	else if (chargingInfo[gunIndex]->Type == _Type_CCS_2)
	{
		if(!isEvGunLocked_ccs(gunIndex))
		{
			PRINTF_FUNC("*********** _DetectEvChargingEnableTimeout (ccs) ***********\n");
		}
	}
	ChargingTerminalProcess(gunIndex);
	_AutoReturnTimeout();
}

void _DetectEvseChargingEnableTimeout(byte gunIndex)
{
	PRINTF_FUNC("*********** _DetectEvseChargingEnableTimeout (GFD timeout) ***********\n");
	//if (chargingInfo[gunIndex]->GroundFaultStatus != GFD_PASS)
	{
		setChargerMode(gunIndex, MODE_TERMINATING);
		_AutoReturnTimeout();
	}
}

void _PrepareTimeout(byte gunIndex)
{
	PRINTF_FUNC("*********** _PrepareTimeout ***********\n");
	setChargerMode(gunIndex, MODE_TERMINATING);
	ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuNoResource = YES;
	_AutoReturnTimeout();
}

void _CcsPrechargeTimeout(byte gunIndex)
{
	PRINTF_FUNC("*********** _CcsPrechargeTimeout ***********\n");
	setChargerMode(gunIndex, MODE_IDLE);
}

//===============================================
// 取得卡號與卡號驗證
//===============================================
bool canStartCharging()
{
	char buf2[16] = "";
	memset(buf2, 0, ARRAY_SIZE(buf2));

	for (byte index = 0; index < strlen((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status); index++)
	{
		sprintf(buf2 + (index - 1) * 2, "%02X",	ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status[index]);
	}
	sprintf(buf2, "%s",	ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status);

	// 因為無法得知實際的長度，所以只能用搜尋的方式
	if(strcmp(buf2, "Accepted") == EQUAL)
		return true;
	else
	{

	}

	return false;
}

void AuthorizingStart()
{
	ShmOCPP16Data->SpMsg.bits.AuthorizeReq = YES;
	ShmSysConfigAndInfo->SysInfo.AuthorizeFlag = YES;
}

void ClearAuthorizedFlag()
{
	ShmOCPP16Data->SpMsg.bits.AuthorizeConf = NO;
	ShmSysConfigAndInfo->SysInfo.AuthorizeFlag = NO;
}

bool isAuthorizedComplete()
{
	if (ShmOCPP16Data->SpMsg.bits.AuthorizeConf == NO)
		return false;

	return true;
}

bool IsAuthorizingMode()
{
	if(ShmSysConfigAndInfo->SysInfo.AuthorizeFlag == NO)
		return false;

	return true;
}

void ReleaseAlarmCode(byte gunIndex)
{
    if (strcmp((char *)ShmOCPP16Data->StatusNotification[gunIndex].ErrorCode, "NoError") != EQUAL)
    {
        strcpy((char *)ShmOCPP16Data->StatusNotification[gunIndex].ErrorCode, "NoError");
    }

    if (strcmp((char *)ShmOCPP16Data->StatusNotification[gunIndex].VendorErrorCode, "") != EQUAL)
    {
        strcpy((char *)ShmOCPP16Data->StatusNotification[gunIndex].VendorErrorCode, "");
    }

    if (strcmp((char *)chargingInfo[gunIndex]->ConnectorAlarmCode, "") != EQUAL)
    {
        strcpy((char *)chargingInfo[gunIndex]->ConnectorAlarmCode, "");
    }

    if (strcmp((char *)chargingInfo[gunIndex]->EvConnAlarmCode, "") != EQUAL)
    {
        strcpy((char *)chargingInfo[gunIndex]->EvConnAlarmCode, "");
    }

    if (strcmp((char *)ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].RemotenAlarmCode, "") != EQUAL)
    {
        strcpy((char *)ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].RemotenAlarmCode, "");
    }
}

//===============================================
// EmergencyStop and Charging Stop
//===============================================
void ChargingTerminalProcess(byte gunIndex)
{
	setChargerMode(gunIndex, MODE_TERMINATING);
}

void ChargingAlarmProcess(byte gunIndex)
{
    UpdateErrorCodeToOcpp(gunIndex);
    setChargerMode(gunIndex, MODE_ALARM);
}

void AcChargingTerminalProcess()
{
	ac_chargingInfo[0]->SystemStatus = MODE_TERMINATING;
}

void StopChargingProcessByString(byte level)
{
	if (level > ShmSysConfigAndInfo->SysWarningInfo.Level)
	{
		ShmSysConfigAndInfo->SysWarningInfo.Level = level;
	}
}

void ReleaseChargingProcessByString(byte level)
{
	if (level >= ShmSysConfigAndInfo->SysWarningInfo.Level)
		ShmSysConfigAndInfo->SysWarningInfo.Level = 0;
}

// 一般錯誤停止充電處理函式
void BoardErrOccurByString(byte index, char *code)
{
	byte level = 1;
	if ((chargingInfo[index]->SystemStatus > S_IDLE && chargingInfo[index]->SystemStatus < S_TERMINATING) ||
			(chargingInfo[index]->SystemStatus >= S_CCS_PRECHARGE_ST0 && chargingInfo[index]->SystemStatus <= S_CCS_PRECHARGE_ST1))
	{
		if (strncmp(code, "023730", 6) == EQUAL && ShmStatusCodeData->InfoCode.InfoEvents.bits.ChademoChargerGetEmergencyStop == NO)
		{
			ShmStatusCodeData->InfoCode.InfoEvents.bits.ChademoChargerGetEmergencyStop = YES;
		}
		ChargingTerminalProcess(index);
	}

	StopChargingProcessByString(level);
}

// 急停狀況的停止充電處理函式
void EmcOccureByString(char *code)
{
	byte level = 2;
	// 嚴重的急停有以下幾種 : EMC 按鈕、Mainbreak、Dooropen
	// 其錯誤等級為 2
	if (strncmp(code, "042251", 6) == EQUAL || strncmp(code, "042252", 6) == EQUAL ||
			strncmp(code, "042238", 6) == EQUAL || strncmp(code, "042267", 6) == EQUAL)
	{
		for (byte gun = 0; gun < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun++)
		{
			if ((chargingInfo[gun]->SystemStatus > S_IDLE && chargingInfo[gun]->SystemStatus < S_TERMINATING) ||
					(chargingInfo[gun]->SystemStatus >= S_CCS_PRECHARGE_ST0 && chargingInfo[gun]->SystemStatus <= S_CCS_PRECHARGE_ST1))
			{
                if (strncmp((char *)chargingInfo[gun]->ConnectorAlarmCode, "", 6) == EQUAL)
                {
                    memcpy(chargingInfo[gun]->ConnectorAlarmCode, code, 6);
                }

			    ChargingAlarmProcess(gun);
			}
		}

		StopChargingProcessByString(level);
		InformOcppErrOccur(4);
	}
}

void ReleaseBoardErrOccurByString(byte index, char *code)
{
	bool isTrigger = false;
	byte level = 1;

	if (strncmp(code, "023730", 6) == 0 && ShmStatusCodeData->InfoCode.InfoEvents.bits.ChademoChargerGetEmergencyStop == YES)
	{
		isTrigger = true;
		ShmStatusCodeData->InfoCode.InfoEvents.bits.ChademoChargerGetEmergencyStop = NO;
	}

	if (isTrigger)
	{
		ReleaseChargingProcessByString(level);
	}
}

void ReleaseEmsOccureByString(byte index, char *code)
{
	bool isTrigger = false;
	byte level = 2;

	if (strncmp(code, "042251", 6) == 0 && ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip == YES)
	{
		isTrigger = true;
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip = NO;
	}
	else if (strncmp(code, "042252", 6) == 0 && ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DoorOpen == YES)
	{
		isTrigger = true;
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DoorOpen = NO;
	}
	else if (strncmp(code, "042237", 6) == 0 && ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SpdTrip == YES)
	{
		isTrigger = true;
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SpdTrip = NO;
	}
	else if (strncmp(code, "042238", 6) == 0 && ShmStatusCodeData->AlarmCode.AlarmEvents.bits.MainPowerBreakerTrip == YES)
	{
		isTrigger = true;
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.MainPowerBreakerTrip = NO;
	}
    else if (strncmp(code, "042267", 6) == 0 && ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFailureAlarm == YES)
    {
        isTrigger = true;
        ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFailureAlarm = NO;
    }

	if (isTrigger)
	{
		ReleaseChargingProcessByString(level);
		InformOcppErrOccur(6);
	}
}

//===============================================
// 確認硬體 (按鈕) 狀態
//===============================================
void ChkPrimaryStatus()
{
    if(ShmChargerInfo->Control.TestCtrl.bits.ChargingSimulation)
    {
        ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip = NO;
        ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DoorOpen = NO;
        ShmStatusCodeData->AlarmCode.AlarmEvents.bits.MainPowerBreakerTrip = NO;
        ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SpdTrip = NO;
        ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByEmergency = NO;
        return;
    }

	if (ShmPrimaryMcuData->InputDet.bits.EmergencyButton == ABNORMAL)
	{
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip = YES;
		ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByEmergency = YES;
		EmcOccureByString("042251");
	}
	else
	{
		ReleaseEmsOccureByString(0, "042251");
		ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByEmergency = NO;
	}

	if (ShmPrimaryMcuData->InputDet.bits.AcMainBreakerDetec == ABNORMAL)
	{
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.MainPowerBreakerTrip = YES;
		//EmcOccureByString("042238");
	}
	else
	{
		//ReleaseEmsOccureByString(0, "042238");
	    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.MainPowerBreakerTrip = NO;
	}

	if (ShmPrimaryMcuData->InputDet.bits.SpdDetec == ABNORMAL)
	{
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SpdTrip = YES;
	}
	else
	{
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SpdTrip = NO;
	}

	if (ShmPrimaryMcuData->InputDet.bits.DoorOpen == ABNORMAL)
	{
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DoorOpen = YES;
		EmcOccureByString("042252");
	}
	else
	{
		ReleaseEmsOccureByString(0, "042252");
	}
}

struct timeval _AcContactReOpen_Time;

void ChkPsuStatus(void)
{
    if(!ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFailureAlarm)
    {
        for(int psuGroup = 0; psuGroup < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; psuGroup++)
        {
            if(ShmPsuData->PsuGroup[psuGroup].GroupErrorFlag.PsuGroupErrorValue != 0)
            {
                ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFailureAlarm = YES;
            }
        }

        if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuFailureAlarm)
        {
            EmcOccureByString("042267");
        }
    }
    else
    {
        if(ShmChargerInfo->Control.RelayCtrl.bits.AcContactor &&
            ShmChargerInfo->Control.PsuCtrl.bits.FailureResume == NO)
        {
            bool allFaultStatus = true;

            for(int gunIndex = 0; gunIndex < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gunIndex++)
            {
                if(chargingInfo[gunIndex]->SystemStatus != S_FAULT)
                {
                    allFaultStatus = false;
                }
            }

            if(allFaultStatus)
            {
                PRINTF_FUNC("PSU Failure, Need Resume");
                ShmChargerInfo->Control.PsuCtrl.bits.FailureResume = YES;
            }
        }
    }
}

int AcContactorReOpenCount = 0;

void PsuFailureResume(void)
{
    if(ShmChargerInfo->Control.PsuCtrl.bits.FailureResume)
    {
        if(ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByPsu == NO)
        {
            PRINTF_FUNC("Ac Contactor Off By Psu Failure");
            // update _AcContactReOpen_Time
            gettimeofday(&_AcContactReOpen_Time, NULL);
            ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByPsu = YES;
            AcContactorReOpenCount++;
        }
        else
        {
            if(AcContactorReOpenCount < MAX_AC_CONTACTOR_COUNT)
            {
                if(GetTimeoutValue(_AcContactReOpen_Time) / uSEC_VAL >= AC_CONTACTOR_REOPEN_TIME)
                {
                    ReleaseEmsOccureByString(0, "042267");

                    // update _AcContactReOpen_Time
                    gettimeofday(&_AcContactReOpen_Time, NULL);
                    ShmChargerInfo->Control.RelayCtrl.bits.AcContactorOffByPsu = NO;
                    ShmChargerInfo->Control.PsuCtrl.bits.FailureResume = NO;
                    PRINTF_FUNC("Psu Failure Resume");
                }
            }
        }
    }
    else
    {
        if(AcContactorReOpenCount > 0)
        {
            if(GetTimeoutValue(_AcContactReOpen_Time) / uSEC_VAL >= PSU_FAILURE_RESUME_TIME)
            {
                AcContactorReOpenCount = 0;
            }
        }
    }
}

void SetAcContactor(unsigned char OnOff)
{
    OnOff = OnOff ? ON : OFF;

    if(ShmChargerInfo->Control.RelayCtrl.bits.AcContactor != OnOff)
    {
        if(OnOff)
        {
            ShmChargerInfo->Control.RelayCtrl.bits.StandbyCountdown = NO;
        }

        PRINTF_FUNC("Set Ac Contactor %s", OnOff == ON ? "On" : "Off");
    }
    ShmChargerInfo->Control.RelayCtrl.bits.AcContactor = OnOff == ON ? ON : OFF;
}

void StandbyCheck(void)
{
    if(IsConnectorWholeIdle())
    {
        if(ShmChargerInfo->Control.RelayCtrl.bits.StandbyCountdown)
        {
            if(ShmChargerInfo->Control.RelayCtrl.bits.AcContactor)
            {
                int time = STANDBY_TIME;
                if(ShmChargerInfo->Control.TestCtrl.bits.FastStandbyTime)
                {
                    time = FAST_STANDBY_TIME;
                }

                if((GetTimeoutValue(_Standby_time) / uSEC_VAL) >= time)
                {
                    SetAcContactor(OFF);
                }
            }
        }
        else
        {
            ShmChargerInfo->Control.RelayCtrl.bits.StandbyCountdown = YES;
            gettimeofday(&_Standby_time, NULL);
        }
    }
    else
    {
        if(ShmChargerInfo->Control.RelayCtrl.bits.StandbyCountdown)
        {
            ShmChargerInfo->Control.RelayCtrl.bits.StandbyCountdown = NO;
        }
    }
}

void CheckDisconnectionStatusRecovery(void)
{
    bool recovery = true;

    // check all connector
    for(int i = 0; i < CONNECTOR_QUANTITY; i++)
    {
        if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].Parameter.bits.Disconnection)
        {
            recovery = false;
        }
    }

    if(recovery)
    {
        ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DisconnectedFromDo = false;
    }
}

//===============================================
// 確認各小板偵測的錯誤狀況
//===============================================
void CheckErrorOccurStatus(byte index)
{
    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.NormalStopRequest)
    {
        chargingInfo[index]->ChargingStopFlag.bits.NormalStop = true;
    }

    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.AlarmStopRequest)
    {
        if(strncmp((char *)chargingInfo[index]->ConnectorAlarmCode, "", 6) == EQUAL)
        {
            memcpy(chargingInfo[index]->ConnectorAlarmCode, ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].RemotenAlarmCode, 6);
        }
        if(!chargingInfo[index]->ChargingStopFlag.bits.AlarmStop)
        {
            PRINTF_FUNC("Connector %d Error Occur %s", index + 1, chargingInfo[index]->ConnectorAlarmCode);
        }
        chargingInfo[index]->ChargingStopFlag.bits.AlarmStop = true;
    }

    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.TimeoutStopRequest)
    {
        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.TimeoutStopRequest = false;
        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.Disconnection = true;
        ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DisconnectedFromDo = true;

        if(chargingInfo[index]->SystemStatus == S_PREPARNING ||
            chargingInfo[index]->SystemStatus == S_PREPARING_FOR_EV ||
            chargingInfo[index]->SystemStatus == S_PREPARING_FOR_EVSE ||
            chargingInfo[index]->SystemStatus == S_CHARGING)
        {
            if(strncmp((char *)chargingInfo[index]->ConnectorAlarmCode, "", 6) == EQUAL)
            {
                memcpy(chargingInfo[index]->ConnectorAlarmCode, "042304", 6);
            }
            if(!chargingInfo[index]->ChargingStopFlag.bits.AlarmStop)
            {
                PRINTF_FUNC("Connector %d Disconnect Alarm Occur %s", index + 1, chargingInfo[index]->ConnectorAlarmCode);
            }
            chargingInfo[index]->ChargingStopFlag.bits.AlarmStop = true;
        }
        else if(chargingInfo[index]->SystemStatus == S_REASSIGN_CHECK ||
                chargingInfo[index]->SystemStatus == S_REASSIGN)
        {
            setChargerMode(index, MODE_IDLE);
        }
    }
    if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DisconnectedFromDo)
    {
        CheckDisconnectionStatusRecovery();
    }

    if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip == YES ||
        ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DoorOpen)
    {
        if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_NONE)
        {
            ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_PRIMARY;
            StopChargingProcessByString(2);
        }

        if (strncmp((char *)chargingInfo[index]->ConnectorAlarmCode, "", 6) == EQUAL)
        {
            if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip == YES)
                memcpy(chargingInfo[index]->ConnectorAlarmCode, "042251", 6);
            else if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DoorOpen == YES)
                memcpy(chargingInfo[index]->ConnectorAlarmCode, "042252", 6);
        }
    }
    else
    {
        if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_PRIMARY)
        {
            ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_NONE;
            ReleaseChargingProcessByString(2);
        }
    }

	// RB
	if (ShmSysConfigAndInfo->SysConfig.PhaseLossPolicy == YES)
	{
		if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputUVP == YES ||
				ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputUVP == YES ||
				ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputUVP == YES)
		{
			if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_NONE)
			{
				ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_INUVP;
				StopChargingProcessByString(2);
			}

            if (strncmp((char *)chargingInfo[index]->ConnectorAlarmCode, "", 6) == EQUAL)
            {
                if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputUVP == YES)
                    memcpy(chargingInfo[index]->ConnectorAlarmCode, "042203", 6);
                else if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputUVP == YES)
                    memcpy(chargingInfo[index]->ConnectorAlarmCode, "042204", 6);
                else if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputUVP == YES)
                    memcpy(chargingInfo[index]->ConnectorAlarmCode, "042205", 6);
            }
            if(!chargingInfo[index]->ChargingStopFlag.bits.AlarmStop)
            {
                PRINTF_FUNC("Connector %d RC Board Input UVP Occur %s", index + 1, chargingInfo[index]->ConnectorAlarmCode);
            }
			chargingInfo[index]->ChargingStopFlag.bits.AlarmStop = true;
		}
		else
		{
			if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_INUVP)
			{
				ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_NONE;
				ReleaseChargingProcessByString(2);
			}
		}
	}
	else
	{
		if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_INUVP)
		{
			ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_NONE;
			ReleaseChargingProcessByString(2);
		}
	}

	if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputOVP == YES ||
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputOVP == YES ||
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputOVP == YES)
	{
		if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_NONE)
		{
			ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_INOVP;
			StopChargingProcessByString(2);
		}

        if (strncmp((char *)chargingInfo[index]->ConnectorAlarmCode, "", 6) == EQUAL)
        {
            if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputOVP == YES)
                memcpy(chargingInfo[index]->ConnectorAlarmCode, "042200", 6);
            else if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputOVP == YES)
                memcpy(chargingInfo[index]->ConnectorAlarmCode, "042201", 6);
            else if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputOVP == YES)
                memcpy(chargingInfo[index]->ConnectorAlarmCode, "042202", 6);
        }
        if(!chargingInfo[index]->ChargingStopFlag.bits.AlarmStop)
        {
            PRINTF_FUNC("Connector %d RC Board Input OVP Occur %s", index + 1, chargingInfo[index]->ConnectorAlarmCode);
        }
        chargingInfo[index]->ChargingStopFlag.bits.AlarmStop = true;
	}
	else
	{
		if (ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess == _EXTRA_ERR_PROCESS_INOVP)
		{
			ShmSysConfigAndInfo->SysWarningInfo.ExtraErrProcess = _EXTRA_ERR_PROCESS_NONE;
			ReleaseChargingProcessByString(2);
		}
	}
}

/*
//===============================================
// 確認 GPIO 狀態
//===============================================
void gpio_set_value(unsigned int gpio, unsigned int value)
{
	int fd;
	char buf[MAX_BUF];

	snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/gpio%d/value", gpio);
	fd = open(buf, O_WRONLY);
	if (fd < 0)
	{
	    perror("gpio/set-value");
	    return;
	}

	if (value)
		write(fd, "1", 2);
	else
	    write(fd, "0", 2);

	close(fd);
}

int gpio_get_value(unsigned int gpio, unsigned int *value)
{
    int fd;
    char buf[MAX_BUF];
    char ch;

    snprintf(buf, sizeof(buf), SYSFS_GPIO_DIR "/gpio%d/value", gpio);

    fd = open(buf, O_RDONLY);
    if (fd < 0) {
        perror("gpio/get-value");
        return fd;
    }

    read(fd, &ch, 1);

    if (ch != '0') {
        *value = 1;
    } else {
        *value = 0;
    }

    close(fd);
    return 0;
}

void CheckGpioInStatus()
{
	int pinIn[2] = { 27, 47 };
	unsigned int gpioValue = 0;

	for (int i = 0; i < ARRAY_SIZE(pinIn); i++)
	{
		gpio_get_value(pinIn[i], &gpioValue);
		if (gpioValue == 0x01)
		{
			switch(pinIn[i])
			{
				// 小板緊急停止
				case 47:
				{
					for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
					{
						if (chargingInfo[i]->slotsIndex == 1)
						{
							if (chargingInfo[i]->Type == _Type_Chademo)
								BoardErrOccurByString(i, "023730");
							else if (chargingInfo[i]->Type == _Type_CCS_2)
								BoardErrOccurByString(i, "013627");
							break;
						}
					}
				}
					break;
				case 27:
				{
					for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
					{
						if (chargingInfo[i]->slotsIndex == 3)
						{
							if (chargingInfo[i]->Type == _Type_Chademo)
								BoardErrOccurByString(i, "023730");
							else if (chargingInfo[i]->Type == _Type_CCS_2)
								BoardErrOccurByString(i, "013627");
							break;
						}
					}
				}
					break;
			}
		}
		else
		{
			switch (pinIn[i])
			{
				// 小板解除緊急停止
				case 47:
				{
					for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
					{
						if (chargingInfo[i]->slotsIndex == 1)
						{
							if (chargingInfo[i]->Type == _Type_Chademo)
								ReleaseBoardErrOccurByString(i, "023730");
							else if (chargingInfo[i]->Type == _Type_CCS_2)
								ReleaseBoardErrOccurByString(i, "013627");
							break;
						}
					}
				}
					break;
				case 27:
				{
					for (int i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
					{
						if (chargingInfo[i]->slotsIndex == 3)
						{
							if (chargingInfo[i]->Type == _Type_Chademo)
								ReleaseBoardErrOccurByString(i, "023730");
							else if (chargingInfo[i]->Type == _Type_CCS_2)
								ReleaseBoardErrOccurByString(i, "013627");
							break;
						}
					}
				}
				break;
			}
		}
	}
}
*/

//===============================================
// Main process
//===============================================
// 檢查 Byte 中某個 Bit 的值
// _byte : 欲改變的 byte
// _bit : 該 byte 的第幾個 bit
unsigned char DetectBitValue(unsigned char _byte, unsigned char _bit)
{
	return ( _byte & mask_table[_bit] ) != 0x00;
}

// 設定 Byte 中某個 Biｔ的值
// _byte : 欲改變的 byte
// _bit : 該 byte 的第幾個 bit
// value : 修改的值為 0 or 1
void SetBitValue(unsigned char *_byte, unsigned char _bit, unsigned char value)
{
	if(value == 1)
		*_byte |= (1 << _bit);
	else if (value == 0)
		*_byte ^= (1 << _bit);
}

void UserScanFunction()
{
}

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

	if(chargingInfo[gun_index]->SystemStatus != chargingInfo[gun_index]->PreviousSystemStatus)
	{
		result = YES;
		chargingInfo[gun_index]->PreviousSystemStatus = chargingInfo[gun_index]->SystemStatus;
	}

	return result;
}

void ScannerCardProcess()
{
}

struct timeval _StartAuthorizing_Time;

void PowerCabinetAuthorizingSettingInitial(void)
{
    ShmSysConfigAndInfo->SysInfo.AuthorizedDispenser = 0;
    ShmSysConfigAndInfo->SysInfo.AuthorizedTarget = 0;
    ShmSysConfigAndInfo->SysInfo.AuthorizedType = _AuthResult_None;
    ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Idle;
    ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.StartAuthorize = false;
    ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.AuthorizingCompleted = false;
    ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.BackendAuthorized = false;
}

void AnnounceAccountBalance(unsigned char index, int balance)
{
    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.AnnounceBalance = true;
    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].AccountBalance = balance;
    if(!ShmChargerInfo->Control.TestCtrl.bits.DisableBalance)
    {
        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.AccountBalanceRequest = true;
    }
    PRINTF_FUNC("%sAnnounce Account Balance %d To Connector %d",
        ShmChargerInfo->Control.TestCtrl.bits.DisableBalance ? "Do Not " : "", balance, index + 1);
}

void FouceAnnounceAccountBalance(unsigned char index)
{
    if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.AnnounceBalance)
    {
        AnnounceAccountBalance(index, 0);
    }
}

void CleanConnectorUserIdAndPrice(unsigned char index)
{
    if(chargingInfo[index]->SystemStatus == S_IDLE)
    {
        PRINTF_FUNC("*********** Connector %d Clean UserId & UserPrice ***********", index + 1);
        memset(chargingInfo[index]->StartUserId, 0x00, 32);
        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].UserPrice = 0;
        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].AccountBalance = -6553500;
        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].Parameter.bits.AnnounceBalance = false;
    }
}

void DispenserAuthorizationInitial(unsigned char dispenser)
{
    PRINTF_FUNC("*********** Dispenser %d Authorizing Initial ***********", dispenser + 1);

    memset(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].UserId, 0x00, 32);
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Idle;
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthTarget = 0;
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthType = _AuthType_None;
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = _AuthResult_None;
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].Setting.bits.EnableAutoGunSelection = false;
}

void ConnectorAuthorizationInitial(unsigned char connector)
{
    PRINTF_FUNC("*********** Connector %d Authorizing Initial ***********", connector + 1);

    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].AuthorizingType = _AuthType_None;
    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].AuthorizingResult = _AuthResult_None;
    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.SwipeRfidConfirm = false;
    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.RemoteStartRequest = false;
    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.RemoteStartConfirm = false;
    chargingInfo[connector]->RemoteStartFlag = false;

    CleanConnectorUserIdAndPrice(connector);
}

void SetAuthorizingTarget(unsigned char dispenser, unsigned char target, unsigned char type)
{
    memset(ShmSysConfigAndInfo->SysConfig.UserId, 0x00, 32);

    switch(type)
    {
        case _AuthType_RFID:
            PRINTF_FUNC("*********** Dispenser %d Target %02X RFID Authorize ***********", dispenser + 1, target);
            memcpy(ShmSysConfigAndInfo->SysConfig.UserId, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].UserId, 32);

            break;
        case _AuthType_RemoteStart:
            PRINTF_FUNC("*********** Connector %d Remote Start Authorize ***********", target);
            memcpy(ShmSysConfigAndInfo->SysConfig.UserId, ShmOCPP16Data->RemoteStartTransaction[target - 1].IdTag, 20);
            break;
    }
    if(target == AUTO_GUN_SELECTION)
    {
        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].Setting.bits.EnableAutoGunSelection = true;
    }
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Busy;
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthType = type;

    ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.StartAuthorize = true;
    ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.AuthorizingCompleted = false;
    ShmSysConfigAndInfo->SysInfo.AuthorizedDispenser = dispenser;
    ShmSysConfigAndInfo->SysInfo.AuthorizedTarget = target;
    ShmSysConfigAndInfo->SysInfo.AuthorizedType = type;
}

void OCPPAuthorizingStart(void)
{
    ShmOCPP16Data->SpMsg.bits.AuthorizeConf = false;
    ShmOCPP16Data->SpMsg.bits.AuthorizeReq = true;
}

void AuthorizeTimeoutProcess(void)
{
    for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
    {
        if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].AuthorizingResult == _AuthResult_Invalid)
        {
            FouceAnnounceAccountBalance(index);

            if(GetTimeoutValue(_ConnectorAuthorizeFail_Time[index]) / uSEC_VAL >= AUTHORIZE_FAIL_TIMEOUT)
            {
                PRINTF_FUNC("*********** Connector id %d Authorized Fail Return ***********", index + 1);
                ConnectorAuthorizationInitial(index);
            }
        }

        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].AuthStatus == _AuthorizeStatus_End)
        {
            int CompletedTime = 0;
            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].AuthTarget != AUTO_GUN_SELECTION)
            {
                CompletedTime = DISPENSER_AUTH_COMP_TIME;
            }
            else
            {
                if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].AuthResult == _AuthResult_Valid)
                {
                    CompletedTime = ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout;
                }
                else
                {
                    CompletedTime = AUTHORIZE_FAIL_TIMEOUT;
                }
            }

            if(GetTimeoutValue(_DispenserAuthorizing_Time[index]) / uSEC_VAL >= CompletedTime)
            {
                PRINTF_FUNC("*********** Dispenser id %d Authorized Return ***********", index + 1);

                DispenserAuthorizationInitial(index);
            }
        }
    }
}

bool IsNewAuthorizingRequest(void)
{
    bool NewRequest = false;
    bool FindRemoteStartRequest = false;

    // remote start check
    for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
    {
        if(ShmOCPP16Data->CsMsg.bits[index].RemoteStartTransactionReq == true)
        {
            unsigned char dispenser = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[index].ParentDispensetIndex;
            SetAuthorizingTarget(dispenser, index + 1, _AuthType_RemoteStart);
            ShmOCPP16Data->CsMsg.bits[index].RemoteStartTransactionReq = false;
            chargingInfo[index]->RemoteStartFlag = true;
            FindRemoteStartRequest = true;
            NewRequest = true;
            break;
        }
    }

    if(!FindRemoteStartRequest)
    {
        // local rfid authorize check
        for(int index = 0; index < GENERAL_GUN_QUANTITY; index++)
        {
            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].AuthStatus == _AuthorizeStatus_Idle &&
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.AuthorizeRequest == true)
            {
                if(strlen((char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].UserId) > 0)
                {
                    SetAuthorizingTarget(index, ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].AuthTarget, _AuthType_RFID);
                    NewRequest = true;
                }
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.AuthorizeRequest = false;
            }
        }
    }

    return NewRequest;
}

void PowerCabinetAuthorizeProcess(void)
{
    unsigned char dispenser = 0, connector = 0;

    dispenser = ShmSysConfigAndInfo->SysInfo.AuthorizedDispenser;

    AuthorizeTimeoutProcess();

    switch(ShmSysConfigAndInfo->SysInfo.AuthorizedStatus)
    {
        case _AuthorizeStatus_Idle:
            if(IsNewAuthorizingRequest())
            {
                ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Wait;
            }
            break;
        case _AuthorizeStatus_Wait:
            if(ShmSysConfigAndInfo->SysInfo.AuthorizedType == _AuthType_RemoteStart)
            {
                PRINTF_FUNC("*********** Connector %d Remote Start Authorizing Bypass ***********",
                    ShmSysConfigAndInfo->SysInfo.AuthorizedTarget);

                ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.BackendAuthorized = true;
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = _AuthResult_Valid;
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
                ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
            }
            else
            {
                if(ShmOCPP16Data->OcppConnStatus)
                {
                    PRINTF_FUNC("*********** Dispenser %d OPCC AuthorizeReq ***********", dispenser + 1);
                    OCPPAuthorizingStart();
                }
                else
                {
                    PRINTF_FUNC("*********** Dispenser %d Start Local Authorizing ***********", dispenser + 1);
                }

                // update start authorizing timeout
                gettimeofday(&_StartAuthorizing_Time, NULL);
                ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Busy;
            }
            break;
        case _AuthorizeStatus_Busy:
            if(GetTimeoutValue(_StartAuthorizing_Time) / uSEC_VAL >= AUTHORIZE_TIMEOUT)
            {
                PRINTF_FUNC("*********** Dispenser %d Authorizing Timeout ***********", dispenser + 1);
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = _AuthResult_Invalid;
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
                ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
            }
            else
            {
                if(ShmOCPP16Data->OcppConnStatus)
                {
                    if(ShmOCPP16Data->SpMsg.bits.AuthorizeConf)
                    {
                        BOOL accept = false;
                        if(strcmp((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status, "Accepted") == EQUAL)
                        {
                            accept = true;
                        }

                        PRINTF_FUNC("*********** Dispenser %d OCPP Authorize %s ***********", dispenser + 1, accept ? "OK" : "NG");

                        ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.BackendAuthorized = true;
                        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = accept ? _AuthResult_Valid : _AuthResult_Invalid;
                        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
                        ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
                    }
                }
                else
                {
                    if(ShmSysConfigAndInfo->SysConfig.OfflinePolicy == _OFFLINE_POLICY_NO_CHARGING)
                    {
                        PRINTF_FUNC("*********** Dispenser %d No Charging ***********", dispenser + 1);

                        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = _AuthResult_Invalid;
                        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
                        ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
                    }
                    else if(ShmSysConfigAndInfo->SysConfig.OfflinePolicy == _OFFLINE_POLICY_FREE_CHARGING)
                    {
                        // set authorize pass when offline policy is free charge
                        PRINTF_FUNC("*********** Dispenser %d Free Charging ***********", dispenser + 1);

                        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = _AuthResult_Valid;
                        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
                        ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
                    }
                    else if(ShmSysConfigAndInfo->SysConfig.OfflinePolicy == _OFFLINE_POLICY_LOCAL_LIST)
                    {
                        BOOL find = false;

                        // check white list
                        for(int i = 0; i < 10; i++)
                        {
                            if (strcmp((char *)ShmSysConfigAndInfo->SysConfig.LocalWhiteCard[i], "") != EQUAL)
                            {
                                if (strcmp((char *)ShmSysConfigAndInfo->SysConfig.LocalWhiteCard[i], (char *)ShmSysConfigAndInfo->SysConfig.UserId) == EQUAL)
                                {
                                    find = true;
                                    break;
                                }
                            }
                        }

                        PRINTF_FUNC("*********** Dispenser %d White Card %s   ***********", dispenser + 1, find ? "OK" : "NG");

                        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = find ? _AuthResult_Valid : _AuthResult_Invalid;
                        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
                        ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
                    }
                    else
                    {
                        PRINTF_FUNC("*********** Dispenser %d  Invalid Policy   ***********", dispenser + 1);

                        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult = _AuthResult_Invalid;
                        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_Done;
                        ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_Done;
                    }
                }
            }
            break;
        case _AuthorizeStatus_Done:
            if(ShmSysConfigAndInfo->SysInfo.AuthorizedTarget == AUTO_GUN_SELECTION)
            {
                // auto gun selection
            }
            else
            {
                connector = ShmSysConfigAndInfo->SysInfo.AuthorizedTarget - 1;

                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].AuthorizingType = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthType;
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].AuthorizingResult = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult;

                if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].GeneralChargingData.SystemStatus == S_IDLE &&
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult == _AuthResult_Valid)
                {
                    if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthType == _AuthType_RFID)
                    {
                        PRINTF_FUNC("*********** Connector %d RFID Authorize OK ***********", connector + 1);
                        memcpy(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].GeneralChargingData.StartUserId, ShmSysConfigAndInfo->SysConfig.UserId, 32);
                    }
                    if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthType == _AuthType_RemoteStart)
                    {
                        PRINTF_FUNC("*********** Connector id %d RemoteAuthorize OK ***********", connector + 1);
                        memcpy(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].GeneralChargingData.StartUserId, ShmSysConfigAndInfo->SysConfig.UserId, 32);
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.RemoteStartRequest = true;
                    }
                }
                else if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult == _AuthResult_Invalid)
                {
                    // update connector authorizing timeout
                    gettimeofday(&_ConnectorAuthorizeFail_Time[connector], NULL);
                }
            }
            // authorize completed
            ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.AuthorizingCompleted = true;

            // update dispenser authorizing timeout
            gettimeofday(&_DispenserAuthorizing_Time[dispenser], NULL);
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthStatus = _AuthorizeStatus_End;

            // update authorizing completed timeout
            gettimeofday(&_StartAuthorizing_Time, NULL);
            ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_End;
            break;
        case _AuthorizeStatus_End:
            if(GetTimeoutValue(_StartAuthorizing_Time) / uSEC_VAL >= AUTHORIZE_COMP_TIMEOUT)
            {
                PRINTF_FUNC("*********** PowerCabinet Authorize Completed ***********");
                PowerCabinetAuthorizingSettingInitial();
            }
            break;
        default:
            // update authorizing completed timeout
            gettimeofday(&_StartAuthorizing_Time, NULL);
            ShmSysConfigAndInfo->SysInfo.AuthorizedStatus = _AuthorizeStatus_End;
            break;
    }
}

BOOL IsConnectorAuthorizeSuccess(unsigned char connector)
{
    BOOL success = false;

    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].AuthorizingResult == _AuthResult_Valid)
    {
        success = true;
    }

    return success;
}

BOOL IsAutoGunSelectionAuthorizeSuccess(unsigned char connector)
{
    BOOL success = false;
    unsigned char dispenser = 0;

    dispenser = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].ParentDispensetIndex;

    if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].Setting.bits.EnableAutoGunSelection &&
        ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].AuthResult == _AuthResult_Valid)
    {
        success = true;
    }

    return success;
}
/*
bool AddGunInfoByConnector(byte typeValue, byte slots)
{
	bool result = true;

	switch (typeValue)
	{
		case '0': // none
			break;
		case '1': // IEC 62196-2 Type 1/SAE J1772 Plug
			break;
		case '2': // IEC 62196-2 Type 1/SAE J1772 Socket
			break;
		case '3': // IEC 62196-2 Type 2 Plug
		case '4': // IEC 62196-2 Type 2 Socket
			if (AC_QUANTITY > _ac_Index)
			{
				ac_chargingInfo[_acgunIndex] = &ShmSysConfigAndInfo->SysInfo.AcChargingData[_ac_Index];

				// AC 固定 index
				ac_chargingInfo[_acgunIndex]->Index = 0;
				ac_chargingInfo[_acgunIndex]->ReservationId = -1;
				ac_chargingInfo[_acgunIndex]->SystemStatus = S_IDLE;
				ac_chargingInfo[_acgunIndex]->Type = _Type_AC;
				ac_chargingInfo[_acgunIndex]->IsAvailable = YES;
				_ac_Index++;
				_acgunIndex++;
			}
			else
				result = false;
			break;
		case '5': // GB/T AC Plug
			break;
		case '6': // GB/T AC Socket
			break;
		case 'J': // CHAdeMO
		{
			if (CHAdeMO_QUANTITY > _chademoIndex)
			{
				chargingInfo[_gunIndex] = &ShmSysConfigAndInfo->SysInfo.ChademoChargingData[_chademoIndex];
				chargingInfo[_gunIndex]->Index = _gunIndex;
				chargingInfo[_gunIndex]->ReservationId = -1;
				chargingInfo[_gunIndex]->slotsIndex = slots;
				chargingInfo[_gunIndex]->SystemStatus = S_BOOTING;
				chargingInfo[_gunIndex]->Type = _Type_Chademo;
				chargingInfo[_gunIndex]->type_index = _chademoIndex;
				chargingInfo[_gunIndex]->IsAvailable = YES;
				_chademoIndex++;
				_gunIndex++;
			}
			else
				result = false;
		}
			break;
		case 'U': // CCS1 combo
		case 'E': // CCS2 combo
		{
			if (CCS_QUANTITY > _ccsIndex)
			{
				chargingInfo[_gunIndex] = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[_ccsIndex];

				chargingInfo[_gunIndex]->Index = _gunIndex;
				chargingInfo[_gunIndex]->ReservationId = -1;
				chargingInfo[_gunIndex]->slotsIndex = slots;
				chargingInfo[_gunIndex]->SystemStatus = S_BOOTING;
				chargingInfo[_gunIndex]->Type = _Type_CCS_2;
				chargingInfo[_gunIndex]->type_index = _ccsIndex;
				chargingInfo[_gunIndex]->IsAvailable = YES;
				// 現階段預設為走 DIN70121
				ShmCcsData->CommProtocol = _CCS_COMM_V2GMessage_DIN70121;
				_ccsIndex++;
				_gunIndex++;
			}
			else
				result = false;
		}
			break;
		case 'G': // GBT DC
		{
			if (GB_QUANTITY > _gb_Index)
			{
				chargingInfo[_gunIndex] = &ShmSysConfigAndInfo->SysInfo.GbChargingData[_gb_Index];

				chargingInfo[_gunIndex]->Index = _gunIndex;
				chargingInfo[_gunIndex]->ReservationId = -1;
				chargingInfo[_gunIndex]->slotsIndex = slots;
				chargingInfo[_gunIndex]->SystemStatus = S_BOOTING;
				chargingInfo[_gunIndex]->Type = _Type_GB;
				chargingInfo[_gunIndex]->type_index = _gb_Index;
				chargingInfo[_gunIndex]->IsAvailable = YES;
				_gb_Index++;
				_gunIndex++;
			}
			else
				result = false;
		}
			break;
		case 'D': // GBT DC x 2
			break;
	}
	return result;
}
*/

bool CheckConnectorTypeStatus(void)
{
	bool result = true;

	if (strlen((char *) ShmSysConfigAndInfo->SysConfig.ModelName) >= 14)
	{
		// DO360 for Audi, two gun only
		_gunIndex = ShmChargerInfo->Control.MaxConnector;
        ShmSysConfigAndInfo->SysConfig.TotalConnectorCount = _gunIndex;
        PRINTF_FUNC("DC Gun Count = %d", ShmSysConfigAndInfo->SysConfig.TotalConnectorCount);

        if(ShmSysConfigAndInfo->SysConfig.TotalConnectorCount == 0)
        {
            result = false;
        }

		//DO360 charging info default setting
		for(int i = 0; i < CONNECTOR_QUANTITY; i++)
		{
			chargingInfo[i] = &ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData;
			chargingInfo[i]->Index = 0xFF;
			chargingInfo[i]->Evboard_id = 0x00;
			chargingInfo[i]->ReservationId = -1;
			chargingInfo[i]->slotsIndex = 0;
			chargingInfo[i]->SystemStatus = S_BOOTING;
			chargingInfo[i]->Type = _Type_Unknown;
			chargingInfo[i]->type_index = 0;
			chargingInfo[i]->IsAvailable = YES;
		}
	}
	else
	{
		// Module Name 不正確 - 告警
		result = false;
	}

	return result;
}

void KillTaskExceptPrimary()
{
    ChangeLcmByIndex(_LCM_FIX);
    system("killall Module_EvComm");
    system("killall Module_InternalComm");
    system("killall Module_PsuComm");
    system("killall Module_4g &");
    system("killall Module_Wifi &");
}

void KillAllTask()
{
	ChangeLcmByIndex(_LCM_FIX);
	system("killall Module_EventLogging");
	system("killall Module_PrimaryComm");
	system("killall Module_EvComm");
	system("killall Module_LcmControl");
	system("killall Module_InternalComm");
	system("killall Module_PsuComm");
	system("killall OcppBackend &");
	system("killall Module_4g &");
	system("killall Module_Wifi &");
}

int PutDispenserImage(char *IpAddress, char *SourcePath)
{
    int isPass = PASS;
    unsigned char ftpcmdbuf[256];

    PRINTF_FUNC("Transfer image(%s) to ip: %s ", SourcePath, IpAddress);
    //Using ftpput command to transfer upgrade image,
    //User name     : root
    //User password : y42j/4cj84
    //Destination   : as same as source path
    sprintf((char*)ftpcmdbuf,"ftpput -u root -p y42j/4cj84 %s %s %s", IpAddress, SourcePath, SourcePath);

    if(system((char*)ftpcmdbuf) != 0)
    {
        isPass = FAIL;
        PRINTF_FUNC("Transfer Image NG - FTP put upgrade image to fail");
    }
    else
    {
        PRINTF_FUNC("FTP put Image OK");
    }

    return isPass;
}

void TriggerDispenserUpgrade(unsigned char index, char *FileName)
{
    memset(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].FwFileName, 0x00, 128);
    memcpy(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].FwFileName, FileName, strlen(FileName));
    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[index].Setting.bits.FirmwareUpdateRequest = true;
    PRINTF_FUNC("Trigger dispenser %d to update image %s", index + 1, FileName);
}

BOOL PutImageToAllDispenser(char *SourcePath, char *FileName)
{
    int isPass = FAIL;
    BOOL transferred = FALSE;

    for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].Status == _CNS_DispenserMatched)
        {
            char DispenserIpAddress[16];
            memset((char*)DispenserIpAddress, 0x00, 16);
            sprintf((char*)DispenserIpAddress, "%d.%d.%d.%d",
                ((ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].IpAddress >>  0) & 0xFF),
                ((ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].IpAddress >>  8) & 0xFF),
                ((ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].IpAddress >> 16) & 0xFF),
                ((ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].IpAddress >> 24) & 0xFF));

            isPass = PutDispenserImage(DispenserIpAddress, SourcePath);
            if(isPass == PASS)
            {
                TriggerDispenserUpgrade(ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectionInfo[i].DispenserIndex, FileName);
            }
            transferred = true;
        }
    }

    return transferred;
}

BOOL WaitAllDispenserUpgradeCompleted(void)
{
    BOOL completed = TRUE;

    gettimeofday(&_DispenserUpgrade_time, NULL);
    do
    {
        completed = TRUE;
        for(int i = 0; i < GENERAL_GUN_QUANTITY; i++)
        {
            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.FirmwareUpdateRequest ||
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.FirmwareUpdateConfirm)
            {
                if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.FirmwareUpdateCompleted)
                {
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.FirmwareUpdateRequest = false;
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.FirmwareUpdateConfirm = false;
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.FirmwareUpdateCompleted = false;
                    PRINTF_FUNC("Dispenser %d Upgrade Success", i + 1);
                }
                else
                {
                    completed = FALSE;
                }
            }
        }

        if(GetTimeoutValue(_DispenserUpgrade_time) / uSEC_VAL >= DISPENSER_UPGRADE_TIME)
        {
            PRINTF_FUNC("Wait Upgrade Timeout");
            completed = FALSE;
            break;
        }

        if(completed == FALSE)
        {
            sleep(1);
        }
    }while(!completed);

    return completed;
}

bool IsModelNameMatch(char *model)
{
    if(ShmSysConfigAndInfo->SysConfig.ModelName[0] == model[0] &&
        ShmSysConfigAndInfo->SysConfig.ModelName[1] == model[1] &&
        ShmSysConfigAndInfo->SysConfig.ModelName[7] == model[7] &&
        ShmSysConfigAndInfo->SysConfig.ModelName[8] == model[8] &&
        ShmSysConfigAndInfo->SysConfig.ModelName[9] == model[9] &&
        ShmSysConfigAndInfo->SysConfig.ModelName[11] == model[11] &&
        ShmSysConfigAndInfo->SysConfig.ModelName[12] == model[12] &&
        ShmSysConfigAndInfo->SysConfig.ModelName[13] == model[13])
    {
        return true;
    }
    return false;
}

char CheckUpdateProcess()
{
    char model[32];
    bool support = false;
    bool OneImageOnly = false;
    int isPass = true;
    uint8_t retSucc = 0;
    uint8_t retFail = 0;
    byte target = 0;
    char *new_str = NULL;
    unsigned char *ptr = NULL;
    int fd = 0;
    int uartFd = 0;
    unsigned int Type = 0;
    long int MaxLen = 48 * 1024 * 1024, ImageLen = 0;
    DIR *d;
    struct dirent *dir;
    char cmdBuf[128];

    d = opendir("/mnt/");

	if(d)
	{
		while((dir = readdir(d)) != NULL && !OneImageOnly)
		{
            if (strcmp(dir->d_name, ".") == 0 || strcmp(dir->d_name, "..") == 0) {
                continue;
            }

		    new_str = calloc(strlen("/mnt/") + strlen(dir->d_name) + 1, sizeof(char));
			strcat(new_str, "/mnt/");
			strcat(new_str, dir->d_name);
			fd = open(new_str, O_RDONLY);
			if(fd < 0)
			{
			    close(fd);
	            free(new_str);
			    continue;
			}

			DEBUG_INFO_MSG("%s\n", new_str);

			ptr = calloc(MaxLen, sizeof(char));     //-48 is take out the header
			memset(ptr, 0xFF, MaxLen);              //-48 is take out the header
			//get the image length
			ImageLen = read(fd, ptr, MaxLen);

			if (ImageLen > 20)
			{
			    support = false;
			    memcpy(model, ptr, 16);
			    PRINTF_FUNC("Model: %s", model);
				Type = (((unsigned int)ptr[16]) << 24 | ((unsigned int)ptr[17]) << 16 | ((unsigned int)ptr[18]) << 8 | ((unsigned int)ptr[19]));
			    PRINTF_FUNC("Typed...%x", Type);

			    //if(strcmp(model, (char *)ShmSysConfigAndInfo->SysConfig.ModelName) == EQUAL)
			    if(IsModelNameMatch(model))
			    {
                    switch (Type)
                    {
                        case 0x10000001:
                        case 0x10000002:
                        case 0x10000003:
                        case 0x10000004:
                        case 0x10000005:
                            support = true;
                            _UpgradeNeedReboot = TRUE;
                            isPass = Upgrade_Flash(Type, new_str, (char *)ShmSysConfigAndInfo->SysConfig.ModelName);
                            break;

                        case 0x10000006:            // primary mcu
                        case 0x1000000D:            // relay board
                        case 0x1000000E:            // fan board
                        case 0x10000014:            // led board
                            support = true;
                            target = 0x00;

                            if (Type == 0x10000006)
                            {
                                target = UPGRADE_PRI;
                            }
                            else if (Type == 0x1000000D)
                            {
                                target = UPGRADE_RB;
                            }
                            else if (Type == 0x1000000E)
                            {
                                target = UPGRADE_FAN;
                            }
                            else if (Type == 0x10000014)
                            {
                                target = UPGRADE_LED;
                            }

                            uartFd = InitComPort(target);

                            if(target == UPGRADE_RB)
                            {
                                isPass = Upgrade_UART(uartFd, Type, UPGRADE_DORC1, new_str, (char *)ShmSysConfigAndInfo->SysConfig.ModelName);
                                if(isPass == PASS)
                                {
                                    retSucc++;
                                }
                                else
                                {
                                    retFail++;
                                }
                                PRINTF_FUNC("Upgrade %s", isPass == PASS ? "Success" : "Fail");
                                sleep(3);
                                isPass = Upgrade_UART(uartFd, Type, UPGRADE_DORC2, new_str, (char *)ShmSysConfigAndInfo->SysConfig.ModelName);
                            }
                            else
                            {
                                isPass = Upgrade_UART(uartFd, Type, target, new_str, (char *)ShmSysConfigAndInfo->SysConfig.ModelName);
                            }

                            close(uartFd);
                            break;
                    }

                    if(support)
                    {
                        if(isPass == PASS)
                        {
                            retSucc++;
                        }
                        else
                        {
                            retFail++;
                        }
                        PRINTF_FUNC("Upgrade %s", isPass == PASS ? "Success" : "Fail");
                    }
			    }
			    else
			    {
			        if(model[0] == 'D' && (model[1] == 'D' || model[1] == 'X'))
			        {
			            OneImageOnly = true;
			            _UpgradeNeedReboot = TRUE;
			            PRINTF_FUNC("Start Put Image To All Dispenser");
			            PutImageToAllDispenser(new_str, dir->d_name);
			            WaitAllDispenserUpgradeCompleted();
			            PRINTF_FUNC("All Dispenser Upgrade Completed");
			        }
			    }
			}

		    sprintf(cmdBuf, "rm -f %s", new_str);
		    system(cmdBuf);

		    close(fd);
            free(new_str);
            free(ptr);
		}
	}
	free(dir);
	closedir(d);

    if(retFail != 0)
    {
        return FAIL;
    }

    return PASS;
}

/*
void CreateRfidFork()
{
	pid_t rfidRecPid;

	rfidRecPid = fork();
	if (rfidRecPid == 0)
	{
		while(true)
		{
			// 刷卡判斷
			RFID rfid;
			if (ShmSysConfigAndInfo->SysConfig.OfflinePolicy == _OFFLINE_POLICY_NO_CHARGING ||
					!ShmSysConfigAndInfo->SysConfig.isRFID)
			{}
			else if(getRequestCardSN(rfidFd, 0, &rfid))
			{
				PRINTF_FUNC("Get Card..-%s- \n", ShmSysConfigAndInfo->SysConfig.UserId);
				if (strlen((char *)ShmSysConfigAndInfo->SysConfig.UserId) == 0)
				{
					if (ShmSysConfigAndInfo->SysConfig.RfidCardNumEndian == RFID_ENDIAN_LITTLE)
					{
						switch (rfid.snType)
						{
						case RFID_SN_TYPE_6BYTE:
							sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
									"%02X%02X%02X%02X%02X%02X",
									rfid.currentCard[0], rfid.currentCard[1],
									rfid.currentCard[2], rfid.currentCard[3],
									rfid.currentCard[4], rfid.currentCard[5]);
							break;
						case RFID_SN_TYPE_7BYTE:
							sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
									"%02X%02X%02X%02X%02X%02X%02X",
									rfid.currentCard[0], rfid.currentCard[1],
									rfid.currentCard[2], rfid.currentCard[3],
									rfid.currentCard[4], rfid.currentCard[5],
									rfid.currentCard[6]);
							break;
						case RFID_SN_TYPE_10BYTE:
							sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
									"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
									rfid.currentCard[0], rfid.currentCard[1],
									rfid.currentCard[2], rfid.currentCard[3],
									rfid.currentCard[4], rfid.currentCard[5],
									rfid.currentCard[6], rfid.currentCard[7],
									rfid.currentCard[8], rfid.currentCard[9]);
							break;
						case RFID_SN_TYPE_4BYTE:
							sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
									"%02X%02X%02X%02X",
									rfid.currentCard[0], rfid.currentCard[1],
									rfid.currentCard[2], rfid.currentCard[3]);
							break;
						}
					}
					else if (ShmSysConfigAndInfo->SysConfig.RfidCardNumEndian == RFID_ENDIAN_BIG)
					{
						switch (rfid.snType)
						{
						case RFID_SN_TYPE_6BYTE:
							sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
									"%02X%02X%02X%02X%02X%02X",
									rfid.currentCard[5], rfid.currentCard[4],
									rfid.currentCard[3], rfid.currentCard[2],
									rfid.currentCard[1], rfid.currentCard[0]);
							break;
						case RFID_SN_TYPE_7BYTE:
							sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
									"%02X%02X%02X%02X%02X%02X%02X",
									rfid.currentCard[6], rfid.currentCard[5],
									rfid.currentCard[4], rfid.currentCard[3],
									rfid.currentCard[2], rfid.currentCard[1],
									rfid.currentCard[0]);
							break;
						case RFID_SN_TYPE_10BYTE:
							sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
									"%02X%02X%02X%02X%02X%02X%02X%02X%02X%02X",
									rfid.currentCard[9], rfid.currentCard[8],
									rfid.currentCard[7], rfid.currentCard[6],
									rfid.currentCard[5], rfid.currentCard[4],
									rfid.currentCard[3], rfid.currentCard[2],
									rfid.currentCard[1], rfid.currentCard[0]);
							break;
						case RFID_SN_TYPE_4BYTE:
							sprintf((char *) ShmSysConfigAndInfo->SysConfig.UserId,
									"%02X%02X%02X%02X",
									rfid.currentCard[3], rfid.currentCard[2],
									rfid.currentCard[1], rfid.currentCard[0]);
							break;
						}
					}

					PRINTF_FUNC("card number = %s\n", ShmSysConfigAndInfo->SysConfig.UserId);
				}
			}
			sleep(1);
		}
	}
}
*/

void StartSystemTimeoutDet(unsigned char flag)
{
	if (ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag != flag)
	{
		gettimeofday(&ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer, NULL);
	}
	ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag = flag;
}

void StopSystemTimeoutDet()
{
	gettimeofday(&ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer, NULL);
	ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag = Timeout_None;
}

void StartGunInfoTimeoutDet(unsigned char gunIndex, unsigned char flag)
{
	if (gunIndex < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount)
	{
		if (chargingInfo[gunIndex]->TimeoutFlag != flag)
		{
			gettimeofday(&chargingInfo[gunIndex]->TimeoutTimer, NULL);
		}
		chargingInfo[gunIndex]->TimeoutFlag = flag;
	}
}

void StopGunInfoTimeoutDet(unsigned char gunIndex)
{
	if (gunIndex < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount)
	{
		chargingInfo[gunIndex]->TimeoutFlag = Timeout_None;
	}
}

void TriggerDispenserConnectionTimeoutSetting(void)
{
    BOOL trigger = FALSE;

    for(int i = 0; i < CONNECTOR_QUANTITY; i++)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity > 0)
        {
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.ConnectorTimeoutConfigRequest = 1;
            trigger = TRUE;
        }
    }

    if(trigger)
    {
        PRINTF_FUNC("********** Trigger Dispenser Connector Timeout Value: %d **********\n", ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout);
    }
}

void CheckConnectionTimeout(void)
{
	if(system("pidof -s OcppBackend > /dev/null") != 0)
	{
		_connectionTimeout = CONN_PLUG_TIME_OUT;
	}
	else
	{
        if(ShmOCPP16Data->OcppConnStatus &&
            strcmp((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemData,"") != 0)
		{
			_connectionTimeout = atoi((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemData);
			if(_connectionTimeout <= 0)
			{
				_connectionTimeout = CONN_PLUG_TIME_OUT;
			}
		}
		else
		{
			_connectionTimeout = CONN_PLUG_TIME_OUT;
		}
	}

	if(_connectionTimeout != ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout)
	{
	    ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout = _connectionTimeout;
	    TriggerDispenserConnectionTimeoutSetting();
	}
}

void CreateTimeoutFork()
{
	pid_t timeoutPid;

	timeoutPid = fork();
	if (timeoutPid > 0)
	{
		gettimeofday(&_cmdSubPriority_time, NULL);
		CheckConnectionTimeout();

		while(true)
		{
			if ((GetTimeoutValue(_cmdSubPriority_time) / 1000) > 5000)
			{
				CheckConnectionTimeout();
				gettimeofday(&_cmdSubPriority_time, NULL);
			}

			//printf("Timeout ***********SystemTimeoutFlag = %d, ********\n", ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag);
			// 系統
			switch(ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag)
			{
//				case Timeout_SelftestChk:
//					if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= SELFTEST_TIMEOUT)
//					{
//						_SelfTestTimeout();
//						StopSystemTimeoutDet();
//					}
//					break;
//				case Timeout_Authorizing:
//					if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= AUTHORIZE_TIMEOUT)
//					{
//						_AuthorizedTimeout();
//						StopSystemTimeoutDet();
//					}
//					break;
//				case Timeout_VerifyFail:
//					if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= AUTHORIZE_FAIL_TIMEOUT)
//					{
//						_AutoReturnTimeout();
//						StopSystemTimeoutDet();
//					}
//					break;
//				case Timeout_VerifyComp:
//					if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= AUTHORIZE_COMP_TIMEOUT)
//					{
//						_AutoReturnTimeout();
//						StopSystemTimeoutDet();
//					}
//					break;
				case Timeout_WaitPlug:
					if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= _connectionTimeout)
					{
						_DetectPlugInTimeout();
						StopSystemTimeoutDet();
					}
					break;
				case Timeout_ReturnToChargingGunDet:
				{
					if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= RETURN_TO_CHARGING_PAGE)
					{
						DisplayChargingInfo();
						StopSystemTimeoutDet();
					}
				}
					break;
				case Timeout_AuthorizingForStop:
				{
					if (GetTimeoutValue(ShmSysConfigAndInfo->SysInfo.SystemTimeoutTimer) / uSEC_VAL >= AUTHORIZE_STOP_TIMEOUT)
					{
						strcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, "");
						ClearAuthorizedFlag();
						StopSystemTimeoutDet();
					}
				}
					break;
			}
			// 各槍
			for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
			{
				//printf("Timeout ***********TimeoutFlag = %d, ********\n", chargingInfo[gun_index]->TimeoutFlag);
				switch(chargingInfo[gun_index]->TimeoutFlag)
				{
					case Timeout_Preparing:
					{
						if (GetTimeoutValue(chargingInfo[gun_index]->TimeoutTimer) / uSEC_VAL >= GUN_PREPARE_TIMEOUT)
						{
							_PrepareTimeout(gun_index);
							StopGunInfoTimeoutDet(gun_index);
						}
					}
						break;
					case Timeout_EvChargingDet:
					{
						if (GetTimeoutValue(chargingInfo[gun_index]->TimeoutTimer) / uSEC_VAL >= GUN_EV_WAIT_TIMEOUT)
						{
							_DetectEvChargingEnableTimeout(gun_index);
							StopGunInfoTimeoutDet(gun_index);
						}
					}
						break;
					case Timeout_EvseChargingDet:
					{
						if (GetTimeoutValue(chargingInfo[gun_index]->TimeoutTimer) / uSEC_VAL >= GUN_EVSE_WAIT_TIMEOUT)
						{
							_DetectEvseChargingEnableTimeout(gun_index);
							StopGunInfoTimeoutDet(gun_index);
						}
					}
						break;
					case Timeout_EvseCompleteDet:
					{
						if (GetTimeoutValue(chargingInfo[gun_index]->TimeoutTimer) / uSEC_VAL >= GUN_COMP_WAIT_TIMEOUT)
						{
							StopGunInfoTimeoutDet(gun_index);
						}
					}
						break;
					case Timeout_ForCcsPrechargeDet:
					{
						if (GetTimeoutValue(chargingInfo[gun_index]->TimeoutTimer) / uSEC_VAL >= GUN_PRECHARGING_TIMEOUT)
						{
							_CcsPrechargeTimeout(gun_index);
							StopGunInfoTimeoutDet(gun_index);
						}
					}
						break;
				}
			}
			sleep(1);
		}
	}
}

void GetSystemTime()
{
	struct timeb csuTime;
	struct tm *tmCSU;

	ftime(&csuTime);
	tmCSU = localtime(&csuTime.time);
	PRINTF_FUNC("Time : %04d-%02d-%02d %02d:%02d:%02d \n", tmCSU->tm_year + 1900,
			tmCSU->tm_mon + 1, tmCSU->tm_mday, tmCSU->tm_hour, tmCSU->tm_min,
			tmCSU->tm_sec);

//	byte date[14];
//
//
//		 //sprintf(&date, "%d", );
//
//		 date[0] = '0' + ((tmCSU->tm_year + 1900) / 1000 % 10);

//	date[0] = (tmCSU->tm_year + 1900) / 1000 % 10;
//	date[1] = (tmCSU->tm_year + 1900) / 100 % 10;
//	date[2] = (tmCSU->tm_year + 1900) / 10 % 10;
//	date[3] = (tmCSU->tm_year + 1900) / 1 % 10;
//
//	date[4] = (tmCSU->tm_mon + 1) / 10 % 10;
//	date[5] = (tmCSU->tm_mon + 1) / 1 % 10;
//
//	date[6] = (tmCSU->tm_mday) / 10 % 10;
//	date[7] = (tmCSU->tm_mday) / 1 % 10;
//
//	date[8] = (tmCSU->tm_hour) / 10 % 10;
//	date[9] = (tmCSU->tm_hour) / 1 % 10;
//
//	date[10] = (tmCSU->tm_min) / 10 % 10;
//	date[11] = (tmCSU->tm_min) / 1 % 10;
//
//	date[12] = (tmCSU->tm_sec) / 10 % 10;
//	date[13] = (tmCSU->tm_sec) / 1 % 10;

//	PRINTF_FUNC("%x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x, %x \n", date[0], date[1], date[2], date[3],
//			date[4], date[5], date[6], date[7],
//			date[8], date[9], date[10], date[11],
//			date[12], date[13]);
}

void CheckFactoryConfigFunction(void)
{
	if(ShmSysConfigAndInfo->SysInfo.FactoryConfiguration)
	{
        char Buf[256];

        sprintf(Buf, "cd /root;./FactoryConfig -m");
        system(Buf);

        system("rm -f /Storage/OCPP/OCPPConfiguration");
		system("sync");
		sleep(5);
		system("reboot -f");
		sleep(5);
		system("reboot -f");
	}
}

void CheckFwUpdateFunction()
{
	char UpdateResult = PASS;

	if (ShmSysConfigAndInfo->SysInfo.FirmwareUpdate == YES)
	{
		DEBUG_INFO_MSG("ftp : update start.");
		//KillTask();
	    ChangeLcmByIndex(_LCM_FIX);
	    system("killall Module_PrimaryComm");
	    system("killall Module_InternalComm");

	    UpdateResult = CheckUpdateProcess();
		if (UpdateResult == PASS)
		{
			DEBUG_INFO_MSG("ftp : update complete.");
		}
		else
		{
			DEBUG_INFO_MSG("ftp : update fail.");
		}

		ShmSysConfigAndInfo->SysInfo.FirmwareUpdate = NO;
		sleep(5);
		if(_UpgradeNeedReboot)
		{
		    system("reboot -f");
		}
		else
		{
		    KillAllTask();
            system("/usr/bin/run_evse_restart.sh");
		}
	}
	else if(ShmOCPP16Data->MsMsg.bits.UpdateFirmwareReq == YES)
	{
		ShmOCPP16Data->MsMsg.bits.UpdateFirmwareReq = NO;

		if (strcmp((char *)ShmOCPP16Data->FirmwareStatusNotification.Status, "Downloaded") == EQUAL)
		{
			DEBUG_INFO_MSG("Backend : update start. \n");
			strcpy((char *)ShmOCPP16Data->FirmwareStatusNotification.Status, "");
			strcpy((char *)ShmOCPP16Data->FirmwareStatusNotification.Status, "Installing");
			ShmOCPP16Data->SpMsg.bits.FirmwareStatusNotificationReq = YES;
			//KillTask();
	        system("killall Module_PrimaryComm");
	        system("killall Module_InternalComm");

			for (byte _index = 0; _index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; _index++)
			{
				setChargerMode(_index, MODE_UPDATE);
			}

			UpdateResult = CheckUpdateProcess();
			if (UpdateResult == PASS)
			{
				DEBUG_INFO_MSG("Backend : update complete. \n");
				strcpy((char *)ShmOCPP16Data->FirmwareStatusNotification.Status, "Installed");
			}
			else
			{
				DEBUG_INFO_MSG("Backend : update fail. \n");
				strcpy((char *)ShmOCPP16Data->FirmwareStatusNotification.Status, "InstallationFailed");
			}

			//strcpy((char *)ShmOCPP16Data->FirmwareStatusNotification.Status, "Installed");
			sleep(1);
			ShmOCPP16Data->SpMsg.bits.FirmwareStatusNotificationReq = YES;
			sleep(5);

	        if(_UpgradeNeedReboot)
	        {
	            system("reboot -f");
	        }
	        else
	        {
	            KillAllTask();
	            system("/usr/bin/run_evse_restart.sh");
	        }
		}
	}
}

void ExecuteWriteWiringInfo(void)
{
    struct SysConfigData config;

    memcpy(&config, &ShmSysConfigAndInfo->SysConfig, sizeof(struct SysConfigData));
    config.SwitchDebugFlag = NO;
    strcpy((char *) config.UserId, "");

    int result = StoreUsrConfigData(&config);
    if(result != 1)
    {
        PRINTF_FUNC("Write Wiring Info NG");
    }
    else
    {
        PRINTF_FUNC("WriteWiringInfo OK");
    }
}

struct timeval _WiringInfo_time;
int CheckWiringInfoUpdate(void)
{
    if(ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.WiringInfoChanged)
    {
        ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.WiringInfoChanged = false;
        PRINTF_FUNC("Wiring Info Changed");

        gettimeofday(&_WiringInfo_time, NULL);
        ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.EnableWriteWiringInfo = true;
    }

    if(ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.EnableWriteWiringInfo)
    {
        // 30s for reboot request timeout
        if((GetTimeoutValue(_WiringInfo_time) / uSEC_VAL) >= WIRING_INFO_DELAY ||
            ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.CleanWiringInfo)
        {
            ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.EnableWriteWiringInfo = false;
            PRINTF_FUNC("Start Wirte Wiring Info To Flash");

            pid_t writePid = fork();
            if(writePid == 0)
            {
                ExecuteWriteWiringInfo();
                PRINTF_FUNC("Wirte Wiring Info OK");

                if(ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.CleanWiringInfo)
                {
                    ShmSysConfigAndInfo->SysInfo.CabinetSetting.bits.CleanWiringInfo = false;
                    ShmChargerInfo->Control.SysCtrl.bits.NeedSoftReset = true;
                    PRINTF_FUNC("Clean Wiring Info And Need Soft Reset");
                }
                return NO;
            }
            PRINTF_FUNC("Clean Wirte Wiring Info Flag");
        }
    }

    return YES;
}

void CheckSoftHardReset(void)
{
    if(ShmChargerInfo->Control.SysCtrl.bits.NeedSoftReset)
    {
        ShmChargerInfo->Control.SysCtrl.bits.NeedSoftReset = false;

        PRINTF_FUNC("********** Need Soft Reset **********");
        sleep(5);
        system("killall OcppBackend &");
        KillAllTask();
        system("/usr/bin/run_evse_restart.sh");

    }
    if(ShmChargerInfo->Control.SysCtrl.bits.NeedHardReset)
    {
        ShmChargerInfo->Control.SysCtrl.bits.NeedHardReset = false;

        PRINTF_FUNC("********** Need Hard Reset **********");
        sleep(5);
        system("reboot -f");
    }
}

//===============================================
// Check reservation date is expired
//===============================================
int isReservationExpired(unsigned char gun_index)
{
	int result = NO;
	struct tm expiredDate;
	struct timeb expiredTime;

	if (sscanf((char*) ShmOCPP16Data->ReserveNow[gun_index].ExpiryDate,
			"%4d-%2d-%2dT%2d:%2d:%2d", &expiredDate.tm_year,
			&expiredDate.tm_mon, &expiredDate.tm_mday, &expiredDate.tm_hour,
			&expiredDate.tm_min, &expiredDate.tm_sec) == 6)
	{
		expiredDate.tm_year -= 1900;
		expiredDate.tm_mon -= 1;

		expiredTime.time = mktime(&expiredDate);
		if (!CheckTimeOut(expiredTime))
		{
			result = YES;
		}
	}

	return result;
}

struct timeval _Reboot_time;

void TriggerDispenserHardwareReboot(void)
{
    BOOL trigger = FALSE;

    for(int i = 0; i < CONNECTOR_QUANTITY; i++)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity > 0)
        {
            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.HardwareRebootConfirm == 0 &&
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.HardwareRebootRequest == 0)
            {
                trigger = TRUE;
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.HardwareRebootRequest = 1;
            }
        }
    }

    if(trigger)
    {
        gettimeofday(&_Reboot_time, NULL);
        PRINTF_FUNC("********** Trigger Dispenser Hardware Reboot **********");
    }
}

BOOL IsDispenserHardwareRebootResponsed(void)
{
    BOOL response_ok = TRUE;

    for(int i = 0; i < CONNECTOR_QUANTITY; i++)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity > 0)
        {
            if(!ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.HardwareRebootConfirm)
            {
                response_ok = FALSE;

                // 10s for reboot request timeout
                if((GetTimeoutValue(_Reboot_time) / uSEC_VAL) >= REBOOT_TIMEOUT)
                {
                    response_ok = TRUE;
                    PRINTF_FUNC("Reboot request timeout");
                }
            }
        }
    }

    return response_ok;
}

struct timeval _Reset_time;

void TriggerDispenserSoftwareReset(void)
{
    BOOL trigger = FALSE;

    for(int i = 0; i < CONNECTOR_QUANTITY; i++)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity > 0)
        {
            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.SoftwareResetConfirm == 0 &&
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.SoftwareResetRequest == 0)
            {
                trigger = TRUE;
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.SoftwareResetRequest = 1;
            }
        }
    }

    if(trigger)
    {
        gettimeofday(&_Reset_time, NULL);
        PRINTF_FUNC("********** Trigger Dispenser Software Reset **********");
    }
}

BOOL IsDispenserSoftwareResetResponsed(void)
{
    BOOL response_ok = TRUE;

    for(int i = 0; i < CONNECTOR_QUANTITY; i++)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity > 0)
        {
            if(!ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.SoftwareResetConfirm)
            {
                response_ok = FALSE;

                // 10s for reset request timeout
                if((GetTimeoutValue(_Reset_time) / uSEC_VAL) >= RESET_TIMEOUT)
                {
                    response_ok = TRUE;
                    PRINTF_FUNC("Reset request timeout");
                }
            }
        }
    }

    return response_ok;
}

// the unit of return value: 0.01 dollar
int TariffParsing(char *StringItem, char *TariffCode)
{
    char *ptrSave, *ptrToken;
    char strSource[128];
    int fee = 0;

    memcpy(strSource, StringItem, 128);

    ptrToken = strtok_r(strSource, ";", &ptrSave);
    while(ptrToken != NULL)
    {
        char *strTariff = strstr(ptrToken, TariffCode);
        if(strTariff != NULL)
        {
            char *strFee = strstr(strTariff, "$");
            if(strFee != NULL)
            {
                strFee++;
                float fFee = atof(strFee);
                fee = (int)(fFee * 100);
                break;
            }
        }
        ptrToken = strtok_r(NULL, ";", &ptrSave);
    }
    return fee;
}

void DefaultPriceHandler(char *StrDefaultPrice)
{
    BOOL trigger = FALSE;
    unsigned int ConnectionFee = 0, CurrentRate = 0, OccupancyFee = 0;

    PRINTF_FUNC("********** Default Price: %s", StrDefaultPrice);
    ConnectionFee = TariffParsing(StrDefaultPrice, "Connection Fee");
    PRINTF_FUNC("**********  Connection Fee: %d.%02d **********", (ConnectionFee / 100), (ConnectionFee % 100));
    CurrentRate = TariffParsing(StrDefaultPrice, "Current Rate");
    PRINTF_FUNC("**********    Current Rate: %d.%02d **********", (CurrentRate / 100), (CurrentRate % 100));
    OccupancyFee = TariffParsing(StrDefaultPrice, "Occupancy Fee");
    PRINTF_FUNC("**********   Occupancy Fee: %d.%02d **********", (OccupancyFee / 100), (OccupancyFee % 100));

    ShmSysConfigAndInfo->SysInfo.DispenserInfo.DefaultPrice = CurrentRate;

    for(int i = 0; i < CONNECTOR_QUANTITY; i++)
    {
        if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity > 0)
        {
            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DefaultPriceConfigRequest == 0)
            {
                trigger = TRUE;
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DefaultPriceConfigRequest = 1;
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.CurrencyConfigRequest = 1;
            }
        }
    }

    if(trigger)
    {
        PRINTF_FUNC("********** Trigger Dispenser Default Price **********");
    }
}

void UserPriceHandler(char *UserId, char *UserPrice)
{
    unsigned int ConnectionFee = 0, CurrentRate = 0, OccupancyFee = 0;
    int AccountBalance = 0;

    ConnectionFee = TariffParsing((char *)ShmOCPP16Data->Cost.SetUserPrice.price, "Connection Fee");
    CurrentRate = TariffParsing((char *)ShmOCPP16Data->Cost.SetUserPrice.price, "Current Rate");
    OccupancyFee = TariffParsing((char *)ShmOCPP16Data->Cost.SetUserPrice.price, "Occupancy Fee");
    AccountBalance = TariffParsing((char *)ShmOCPP16Data->Cost.SetUserPrice.price, "Account Balance");

    PRINTF_FUNC("********** User Id: %s **********", ShmOCPP16Data->Cost.SetUserPrice.idToken);
    PRINTF_FUNC("********** User Price: %s", ShmOCPP16Data->Cost.SetUserPrice.price);
    PRINTF_FUNC("**********  Connection Fee: %d.%02d **********", (ConnectionFee / 100), (ConnectionFee % 100));
    PRINTF_FUNC("**********    Current Rate: %d.%02d **********", (CurrentRate / 100), (CurrentRate % 100));
    PRINTF_FUNC("**********   Occupancy Fee: %d.%02d **********", (OccupancyFee / 100), (OccupancyFee % 100));
    PRINTF_FUNC("********** Account Balance: %d.%02d **********", (AccountBalance / 100), (AccountBalance % 100));

    for(int i = 0; i < CONNECTOR_QUANTITY; i++)
    {
        if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData.StartUserId, UserId) == EQUAL)
        {
            if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].UserPrice != CurrentRate ||
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AccountBalance != AccountBalance)
            {
                PRINTF_FUNC("********** Connector Id %d User Price %d.%02d, Account Balance %d.%02d **********",
                    (i + 1), (CurrentRate / 100), (CurrentRate % 100), (AccountBalance / 100), (AccountBalance % 100));
            }

            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].UserPrice = CurrentRate;
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AccountBalance = AccountBalance;

            if(chargingInfo[i]->SystemStatus == S_AUTHORIZING)
            {
                AnnounceAccountBalance(i, AccountBalance);
            }
        }
    }
}

void RunningFinalCostHandler(void)
{
    unsigned int ConnectionFee = 0, SessionFee = 0, OccupancyFee = 0, TotalCost = 0;
    int AccountBalance = 0;

    for(int i = 0; i < CONNECTOR_QUANTITY; i++)
    {
        if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData.SystemStatus >= S_REASSIGN_CHECK &&
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData.SystemStatus <= S_ALARM)
        {
            if(strlen((char *)ShmOCPP16Data->Cost.RunningCost[i].description) > 0)
            {
                ConnectionFee = TariffParsing((char *)ShmOCPP16Data->Cost.RunningCost[i].description, "Connection Fee");
                SessionFee = TariffParsing((char *)ShmOCPP16Data->Cost.RunningCost[i].description, "Session Fee");
                OccupancyFee = TariffParsing((char *)ShmOCPP16Data->Cost.RunningCost[i].description, "Occupancy Fee");
                TotalCost = TariffParsing((char *)ShmOCPP16Data->Cost.RunningCost[i].description, "Total Cost");
                AccountBalance = TariffParsing((char *)ShmOCPP16Data->Cost.RunningCost[i].description, "Account Balance");

                PRINTF_FUNC("********** Connector Id: %d Running Cost **********", (i + 1));
                PRINTF_FUNC("**********  Connection Fee: %d.%02d **********", (ConnectionFee / 100), (ConnectionFee % 100));
                PRINTF_FUNC("**********     Session Fee: %d.%02d **********", (SessionFee / 100), (SessionFee % 100));
                PRINTF_FUNC("**********   Occupancy Fee: %d.%02d **********", (OccupancyFee / 100), (OccupancyFee % 100));
                PRINTF_FUNC("**********      Total Cost: %d.%02d **********", (TotalCost / 100), (TotalCost % 100));
                PRINTF_FUNC("********** Account Balance: %d.%02d **********", (AccountBalance / 100), (AccountBalance % 100));

                if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].TotalCost != TotalCost ||
                    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AccountBalance != AccountBalance)
                {
                    PRINTF_FUNC("********** Connector Id %d Total Cost %d.%02d, Account Balance %d.%02d **********",
                        (i + 1), (TotalCost / 100), (TotalCost % 100), (AccountBalance / 100), (AccountBalance % 100));
                }
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].TotalCost = TotalCost;
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AccountBalance = AccountBalance;

                memset(&ShmOCPP16Data->Cost.RunningCost[i], 0x00, sizeof(struct StrcutRunningFinalCost));
            }

            if(strlen((char *)ShmOCPP16Data->Cost.FinalCost[i].description) > 0)
            {
                ConnectionFee = TariffParsing((char *)ShmOCPP16Data->Cost.FinalCost[i].description, "Connection Fee");
                SessionFee = TariffParsing((char *)ShmOCPP16Data->Cost.FinalCost[i].description, "Session Fee");
                OccupancyFee = TariffParsing((char *)ShmOCPP16Data->Cost.FinalCost[i].description, "Occupancy Fee");
                TotalCost = TariffParsing((char *)ShmOCPP16Data->Cost.FinalCost[i].description, "Total Cost");
                AccountBalance = TariffParsing((char *)ShmOCPP16Data->Cost.FinalCost[i].description, "Account Balance");

                PRINTF_FUNC("********** Connector Id: %d Final Cost **********", (i + 1));
                PRINTF_FUNC("**********  Connection Fee: %d.%02d **********", (ConnectionFee / 100), (ConnectionFee % 100));
                PRINTF_FUNC("**********     Session Fee: %d.%02d **********", (SessionFee / 100), (SessionFee % 100));
                PRINTF_FUNC("**********   Occupancy Fee: %d.%02d **********", (OccupancyFee / 100), (OccupancyFee % 100));
                PRINTF_FUNC("**********      Total Cost: %d.%02d **********", (TotalCost / 100), (TotalCost % 100));
                PRINTF_FUNC("********** Account Balance: %d.%02d **********", (AccountBalance / 100), (AccountBalance % 100));

                if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].TotalCost != TotalCost ||
                    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AccountBalance != AccountBalance)
                {
                    PRINTF_FUNC("********** Connector Id %d Total Cost %d.%02d, Account Balance %d.%02d **********",
                        (i + 1), (TotalCost / 100), (TotalCost % 100), (AccountBalance / 100), (AccountBalance % 100));
                }
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].TotalCost = TotalCost;
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].AccountBalance = AccountBalance;

                memset(&ShmOCPP16Data->Cost.FinalCost[i], 0x00, sizeof(struct StrcutRunningFinalCost));
            }
        }
    }
}

struct timeval _Cost_Price_time;
char MyDefaultPriceString[128];
struct StrcutSetUserPrice MyUserPrice;
char MyConnectorRunningCostString[CONNECTOR_QUANTITY][128];
char MyConnectorFinalCostString[CONNECTOR_QUANTITY][128];

void CheckOcppCostAndPrice(void)
{
    // 5s for reboot request timeout
    if((GetTimeoutValue(_Cost_Price_time) / uSEC_VAL) >= OCPP_COST_REQ_INTERVAL)
    {
        gettimeofday(&_Cost_Price_time, NULL);

        if(strcmp(MyDefaultPriceString, (char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData) != EQUAL)
        {
            DefaultPriceHandler((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData);

            memcpy(MyDefaultPriceString, ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData, 128);
        }

        if(strlen((char *)ShmOCPP16Data->Cost.SetUserPrice.idToken) > 0 && strlen((char *)ShmOCPP16Data->Cost.SetUserPrice.price) > 0)
        {
            UserPriceHandler((char *)ShmOCPP16Data->Cost.SetUserPrice.idToken, (char *)ShmOCPP16Data->Cost.SetUserPrice.price);

            memset(&ShmOCPP16Data->Cost.SetUserPrice, 0x00, sizeof(struct StrcutSetUserPrice));
        }

        RunningFinalCostHandler();
    }
}

//===============================================
// OCPP
//===============================================
void CheckOcppStatus()
{
	if (ShmOCPP16Data->SpMsg.bits.BootNotificationConf == YES)
	{
		ShmOCPP16Data->SpMsg.bits.BootNotificationConf = NO;
		PRINTF_FUNC("*********************OCPP Boot Notification****************************\n");
	}

	if (ShmOCPP16Data->MsMsg.bits.ResetReq == YES)
	{
		bool canReset = true;
		if (ShmSysConfigAndInfo->SysWarningInfo.Level != 2)
		{
			for (byte _index = 0; _index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; _index++)
			{
				if (chargingInfo[_index]->SystemStatus != S_IDLE &&
						chargingInfo[_index]->SystemStatus != S_RESERVATION &&
						chargingInfo[_index]->SystemStatus != S_MAINTAIN)
				{
					canReset = false;
					if (chargingInfo[_index]->SystemStatus >= S_REASSIGN && chargingInfo[_index]->SystemStatus < S_TERMINATING)
					{
						ChargingTerminalProcess(_index);
					}
				}
			}
		}

		if(canReset)
		{
		    if(strcmp((char *)ShmOCPP16Data->Reset.Type, "Hard") == EQUAL)
		    {
                //trigger dispenser to hardware reboot
                TriggerDispenserHardwareReboot();

                if(IsDispenserHardwareRebootResponsed())
                {
                    ShmOCPP16Data->MsMsg.bits.ResetReq = NO;
                    sprintf((char*)ShmOCPP16Data->Reset.ResponseStatus, "Accepted");
                    DEBUG_ERROR_MSG("****** Hard Reboot ****** \n");

                    ShmOCPP16Data->MsMsg.bits.ResetConf = YES;

                    for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
                    {
                        setChargerMode(i, MODE_MAINTAIN);
                    }
                    sleep(3);
                    system("reboot -f");
                }
		    }

		    if(strcmp((char *)ShmOCPP16Data->Reset.Type, "Soft") == EQUAL)
		    {
                //trigger dispenser to software reset
                TriggerDispenserSoftwareReset();

                if(IsDispenserSoftwareResetResponsed())
                {
                    ShmOCPP16Data->MsMsg.bits.ResetReq = NO;
                    sprintf((char*)ShmOCPP16Data->Reset.ResponseStatus, "Accepted");
                    DEBUG_ERROR_MSG("****** Soft Reboot ****** \n");

                    ShmOCPP16Data->MsMsg.bits.ResetConf = YES;

                    for(int i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++)
                    {
                        setChargerMode(i, MODE_MAINTAIN);
                    }
                    sleep(3);
                    system("killall OcppBackend &");
                    KillAllTask();
                    system("/usr/bin/run_evse_restart.sh");
                }
		    }
		}
	}

	CheckOcppCostAndPrice();
}

void OcppStartTransation(byte gunIndex)
{
	byte _OcppGunIndex = gunIndex;

	strcpy((char *)ShmOCPP16Data->StartTransaction[_OcppGunIndex].IdTag, (char *)chargingInfo[gunIndex]->StartUserId);
	chargingInfo[gunIndex]->EvBatteryStartSoc = chargingInfo[gunIndex]->EvBatterySoc;

	PRINTF_FUNC("Gun index %d, OCPP Start Transation Index %d, IdTag = %s, StartSoc = %d",
        chargingInfo[gunIndex]->Index, _OcppGunIndex, ShmOCPP16Data->StartTransaction[_OcppGunIndex].IdTag, chargingInfo[gunIndex]->EvBatteryStartSoc);
	ShmOCPP16Data->CpMsg.bits[_OcppGunIndex].StartTransactionReq = YES;
}

void OcppStopTransation(byte gunIndex)
{
	byte _OcppGunIndex = gunIndex;

	strcpy((char *)ShmOCPP16Data->StopTransaction[_OcppGunIndex].IdTag, (char *)chargingInfo[gunIndex]->StartUserId);

	PRINTF_FUNC("Gun index %d, OCPP Stop Transation Index %d, IdTag = %s, StopSoc = %d",
        chargingInfo[gunIndex]->Index, _OcppGunIndex, ShmOCPP16Data->StopTransaction[_OcppGunIndex].IdTag, chargingInfo[gunIndex]->EvBatterySoc);
	ShmOCPP16Data->CpMsg.bits[_OcppGunIndex].StopTransactionReq = YES;
}


// no use
bool OcppRemoteStop(byte gunIndex)
{
	byte acDirIndex = ShmSysConfigAndInfo->SysConfig.AcConnectorCount;

	// 有 AC 槍的話
	if (acDirIndex > 0 && gunIndex > 0)
	{
		gunIndex += acDirIndex;
	}

	bool result = ShmOCPP16Data->CsMsg.bits[gunIndex].RemoteStopTransactionReq;

	if (ShmOCPP16Data->CsMsg.bits[gunIndex].RemoteStopTransactionReq == YES)
	{
		strcpy((char *)ShmOCPP16Data->StopTransaction[gunIndex].StopReason, "Remote");
		ShmOCPP16Data->CsMsg.bits[gunIndex].RemoteStopTransactionReq = NO;
	}

	return result;
}

void OcppRemoteStartChk()
{
	if (ShmSysConfigAndInfo->SysConfig.OfflinePolicy == _OFFLINE_POLICY_NO_CHARGING)
	{}
	else if(!isDetectPlugin())
	{
		// 如果有 AC 槍，則固定是第 2 把槍，所以索引固定為 1
		byte acDirIndex = ShmSysConfigAndInfo->SysConfig.AcConnectorCount;

		for (byte ac_index = 0; ac_index < ShmSysConfigAndInfo->SysConfig.AcConnectorCount; ac_index++)
		{
			if (ShmOCPP16Data->CsMsg.bits[acDirIndex].RemoteStartTransactionReq == YES)
			{
				if (ac_chargingInfo[ac_index]->SystemStatus == S_IDLE ||
						ac_chargingInfo[ac_index]->SystemStatus == S_RESERVATION)
				{
					ShmOCPP16Data->CsMsg.bits[acDirIndex].RemoteStartTransactionReq = NO;
					ac_chargingInfo[ac_index]->RemoteStartFlag = YES;
					ShmSysConfigAndInfo->SysInfo.OrderCharging = YES;
					//ShmSysConfigAndInfo->SysInfo.OrderCharging = DEFAULT_AC_INDEX;
					ShmOCPP16Data->CsMsg.bits[ShmSysConfigAndInfo->SysConfig.TotalConnectorCount + ac_index].RemoteStartTransactionReq = NO;
					DetectPluginStart();
					return;
				}
				ShmOCPP16Data->CsMsg.bits[acDirIndex].RemoteStartTransactionReq = NO;
			}
		}

		byte threeGunIndex = 0;
		byte dcIndex = 0;
		bool isGunUsingStatus = false;

		for (byte _index = 0; _index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; _index++)
		{
			// 如果有 AC 槍，且 DC 槍也有兩把
			if (acDirIndex == 1 && _index == 1)
				threeGunIndex = 1;

			if (ShmOCPP16Data->CsMsg.bits[_index + threeGunIndex].RemoteStartTransactionReq == YES)
				dcIndex = _index;

			if (chargingInfo[_index]->SystemStatus != S_IDLE)
			{
				isGunUsingStatus = true;
			}
		}

		// 如果是雙槍單模，只認閒置狀態的槍，如果有預約~ 則預約也算被使用
		if (isGunUsingStatus && ShmSysConfigAndInfo->SysInfo.IsAlternatvieConf)
		{
			if (dcIndex == 0)
				threeGunIndex = 0;

			ShmOCPP16Data->CsMsg.bits[dcIndex + threeGunIndex].RemoteStartTransactionReq = NO;
			return;
		}

		if (dcIndex == 0)
			threeGunIndex = 0;

		if (ShmOCPP16Data->CsMsg.bits[dcIndex + threeGunIndex].RemoteStartTransactionReq == YES)
		{
			if (chargingInfo[dcIndex]->SystemStatus == S_IDLE ||
					chargingInfo[dcIndex]->SystemStatus == S_RESERVATION)
			{
				chargingInfo[dcIndex]->RemoteStartFlag = YES;
				ShmSysConfigAndInfo->SysInfo.OrderCharging = YES;
				//ShmSysConfigAndInfo->SysInfo.OrderCharging = gun_index;
				ShmOCPP16Data->CsMsg.bits[dcIndex + threeGunIndex].RemoteStartTransactionReq = NO;
				DetectPluginStart();
			}
			ShmOCPP16Data->CsMsg.bits[dcIndex + threeGunIndex].RemoteStartTransactionReq = NO;
		}
	}
}

void ChkOcppStatus(byte gunIndex)
{
	if (chargingInfo[gunIndex]->SystemStatus == S_IDLE &&
			ShmOCPP16Data->CsMsg.bits[gunIndex].ReserveNowReq == YES)
	{
		ShmOCPP16Data->CsMsg.bits[gunIndex].ReserveNowReq = NO;
		if (isReservationExpired(gunIndex))
		{
			PRINTF_FUNC("***************ChkOcppStatus : OcppReservedStatus******************** \n");
			DEBUG_ERROR_MSG("***************ChkOcppStatus : OcppReservedStatus******************** \n");
			chargingInfo[gunIndex]->ReservationId = ShmOCPP16Data->ReserveNow[gunIndex].ReservationId;
			chargingInfo[gunIndex]->SystemStatus = S_RESERVATION;
		}
		ShmOCPP16Data->CsMsg.bits[gunIndex].ReserveNowConf = YES;
	}

	if (chargingInfo[gunIndex]->SystemStatus == S_RESERVATION &&
			ShmOCPP16Data->CsMsg.bits[gunIndex].CancelReservationReq == YES)
	{
		ShmOCPP16Data->CsMsg.bits[gunIndex].CancelReservationReq = NO;
		if (isReservationExpired(gunIndex))
		{
			PRINTF_FUNC("***************ChkOcppStatus : Cancel OcppReservedStatus******************** \n");
			DEBUG_ERROR_MSG("***************ChkOcppStatus : Cancel OcppReservedStatus******************** \n");
			chargingInfo[gunIndex]->ReservationId = 0;
			chargingInfo[gunIndex]->SystemStatus = S_IDLE;
		}
		ShmOCPP16Data->CsMsg.bits[gunIndex].CancelReservationConf = YES;
	}

	if (ShmOCPP16Data->CsMsg.bits[gunIndex].ChangeAvailabilityReq == YES)
	{
		PRINTF_FUNC("***************ChkOcppStatus : OcppChangeAvailability******************** \n");
		DEBUG_ERROR_MSG("***************ChkOcppStatus : OcppChangeAvailability******************** \n");
		ShmOCPP16Data->CsMsg.bits[gunIndex].ChangeAvailabilityReq = NO;
		if(strcmp((char *)ShmOCPP16Data->ChangeAvailability[gunIndex].Type, "Operative") == EQUAL)
		{
            if (isDb_ready)
                DB_Update_Operactive(localDb, gunIndex, true);

            chargingInfo[gunIndex]->IsAvailable = YES;
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].Parameter.bits.AvailabilityRequest = 1;

			if (chargingInfo[gunIndex]->SystemStatus == S_IDLE ||
				chargingInfo[gunIndex]->SystemStatus == S_RESERVATION ||
				chargingInfo[gunIndex]->SystemStatus == S_MAINTAIN)
			{
				setChargerMode(gunIndex, MODE_IDLE);
			}
		}
		else if (strcmp((char *)ShmOCPP16Data->ChangeAvailability[gunIndex].Type, "Inoperative") == EQUAL)
		{
            if (isDb_ready)
                DB_Update_Operactive(localDb, gunIndex, false);

            chargingInfo[gunIndex]->IsAvailable = NO;
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].Parameter.bits.AvailabilityRequest = 1;

			if (chargingInfo[gunIndex]->SystemStatus == S_IDLE ||
				chargingInfo[gunIndex]->SystemStatus == S_RESERVATION ||
				chargingInfo[gunIndex]->SystemStatus == S_MAINTAIN)
			{
				setChargerMode(gunIndex, MODE_MAINTAIN);
			}
		}
	}

	if (ShmOCPP16Data->CsMsg.bits[gunIndex].UnlockConnectorReq == YES)
	{
		ShmOCPP16Data->CsMsg.bits[gunIndex].UnlockConnectorReq = NO;

        if(chargingInfo[gunIndex]->SystemStatus == S_PREPARNING ||
                chargingInfo[gunIndex]->SystemStatus == S_PREPARING_FOR_EV ||
                chargingInfo[gunIndex]->SystemStatus == S_PREPARING_FOR_EVSE ||
                chargingInfo[gunIndex]->SystemStatus == S_CHARGING)
		{
			// 充電中，需停止充電
			strcpy((char *)ShmOCPP16Data->StopTransaction[gunIndex].StopReason, "UnlockCommand");
			ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].Parameter.bits.UnlockStopRequest = true;
			PRINTF_FUNC("********** OcppUnlockStop Gun %d **********\n", gunIndex);
		}

		strcpy((char *)ShmOCPP16Data->UnlockConnector[gunIndex].ResponseStatus, "Unlocked");
		ShmOCPP16Data->CsMsg.bits[gunIndex].UnlockConnectorConf = YES;
	}

    if (ShmOCPP16Data->CsMsg.bits[gunIndex].RemoteStopTransactionReq == YES)
    {
        ShmOCPP16Data->CsMsg.bits[gunIndex].RemoteStopTransactionReq = NO;

        if(chargingInfo[gunIndex]->SystemStatus == S_PREPARNING ||
                chargingInfo[gunIndex]->SystemStatus == S_PREPARING_FOR_EV ||
                chargingInfo[gunIndex]->SystemStatus == S_PREPARING_FOR_EVSE ||
                chargingInfo[gunIndex]->SystemStatus == S_CHARGING)
        {
            strcpy((char *)ShmOCPP16Data->StopTransaction[gunIndex].StopReason, "Remote");
            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gunIndex].Parameter.bits.RemoteStopRequest = true;
            PRINTF_FUNC("********** OcppRemoteStop Gun %d **********\n", gunIndex);
        }
    }
}

bool CheckBackendChargingTimeout(byte gunIndex)
{
	bool result = false;

	if (ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_ENABLE)
	{
		if (ShmSysConfigAndInfo->SysConfig.MaxChargingDuration > 0)
		{
			if (chargingInfo[gunIndex]->PresentChargedDuration > (ShmSysConfigAndInfo->SysConfig.MaxChargingDuration * 60))
				result = true;
		}
	}
	else if (ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_DISABLE)
	{
		// 隨插即充電的要看 offline
		if (ShmSysConfigAndInfo->SysConfig.OfflineMaxChargeDuration > 0)
		{
			if (chargingInfo[gunIndex]->PresentChargedDuration > (ShmSysConfigAndInfo->SysConfig.OfflineMaxChargeDuration * 60))
				result = true;
		}
	}

	return result;
}

bool CheckBackendChargingEnergy(byte gunIndex)
{
	bool result = false;

	if (ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_ENABLE)
	{
		if (ShmSysConfigAndInfo->SysConfig.MaxChargingEnergy > 0)
		{
			if (chargingInfo[gunIndex]->PresentChargedEnergy > ShmSysConfigAndInfo->SysConfig.MaxChargingEnergy)
				result = true;
		}
	}
	else if (ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_DISABLE)
	{
		// 隨插即充電的要看 offline
		if (ShmSysConfigAndInfo->SysConfig.OfflineMaxChargeEnergy > 0)
		{
			if (chargingInfo[gunIndex]->PresentChargedEnergy > (ShmSysConfigAndInfo->SysConfig.OfflineMaxChargeEnergy))
				result = true;
		}
	}

	return result;
}

void InformOcppErrOccur(byte codeType)
{
	char _error[25];

	switch(codeType)
	{
	case 4: strcpy(_error, "InternalError"); break;
	case 6: strcpy(_error, "NoError"); break;
	case 7: strcpy(_error, "OtherError"); break;
	case 13: strcpy(_error, "UnderVoltage"); break;
	case 14: strcpy(_error, "OverVoltage"); break;
	}

	for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
	{
		strcpy((char *)ShmOCPP16Data->StatusNotification[gun_index].ErrorCode, _error);
	}
}

//===============================================
// SQLite3 related routine
//===============================================
int DB_Open(sqlite3 *db)
{
	int result = PASS;
	char* errMsg = NULL;
	char* createRecordSql="CREATE TABLE IF NOT EXISTS charging_record("
					      "idx integer primary key AUTOINCREMENT, "
						  "reservationId text, "
						  "transactionId text, "
						  "startMethod text, "
						  "userId text, "
						  "dateTimeStart text, "
						  "dateTimeStop text,"
						  "socStart text, "
						  "socStop text, "
						  "chargeEnergy text, "
						  "stopReason text"
						  ");";

	char* createCfgSql="CREATE TABLE IF NOT EXISTS `config` ( "
					   "`idx` INTEGER PRIMARY KEY AUTOINCREMENT, "
					   "`IsAvailable` TEXT NOT NULL, "
				       "`connector` INTEGER NOT NULL, "
					   "`val` TEXT NOT NULL, unique(IsAvailable,connector) on conflict replace);";

	if(sqlite3_open(DB_FILE, &db))
	{
		result = FAIL;
		PRINTF_FUNC( "Can't open database: %s\r\n", sqlite3_errmsg(db));
		sqlite3_close(db);
	}
	else
	{
		PRINTF_FUNC( "Local charging record database open successfully.");

		if (sqlite3_exec(db, createRecordSql, 0, 0, &errMsg) != SQLITE_OK)
		{
			result = FAIL;
			PRINTF_FUNC( "Create local charging record table error message: %s", errMsg);
		}
		else
		{
			PRINTF_FUNC( "Opened local charging record table successfully");
		}

		if (sqlite3_exec(db, createCfgSql, 0, 0, &errMsg) != SQLITE_OK)
		{
			result = FAIL;
			PRINTF_FUNC( "Create local config table error message: %s", errMsg);
		}
		else
		{
			PRINTF_FUNC( "Opened local config table successfully");
		}

		sqlite3_close(db);
	}

	return result;
}

int DB_Insert_Record(sqlite3 *db, int gun_index)
{
	int result = PASS;
	char* errMsg = NULL;
	char insertSql[1024];

	sprintf(insertSql, "insert into charging_record(reservationId, transactionId, startMethod, userId, dateTimeStart, dateTimeStop, socStart, socStop, chargeEnergy, stopReason) "
					   "values('%d', '%d', '%d', '%s', '%s', '%s', '%d', '%d', '%f', '%s');",
					   ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].ReservationId,
					   ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId,
					   ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartMethod,
					   ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId,
					   ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartDateTime,
					   ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StopDateTime,
					   ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc,
					   ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc,
					   ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargedEnergy,
					   ShmOCPP16Data->StopTransaction[gun_index].StopReason);

	if(sqlite3_open("/Storage/ChargeLog/localCgargingRecord.db", &db))
	{
		result = FAIL;
		PRINTF_FUNC( "Can't open database: %s\r\n", sqlite3_errmsg(db));
		sqlite3_close(db);
	}
	else
	{
		PRINTF_FUNC( "Local charging record database open successfully.\r\n");
		if (sqlite3_exec(db, insertSql, 0, 0, &errMsg) != SQLITE_OK)
		{
			result = FAIL;
			PRINTF_FUNC( "Insert local charging record error message: %s\n", errMsg);
		}
		else
		{
			PRINTF_FUNC( "Insert local charging record successfully\n");
		}
		sqlite3_close(db);
	}

	return result;
}

int DB_Update_Operactive(sqlite3 *db, uint8_t gun_index, uint8_t IsAvailable)
{
	uint8_t result = false;
	char* errMsg = NULL;
	char sqlStr[1024];
	srand(time(NULL));

	if(sqlite3_open(DB_FILE, &db))
	{
		result = FAIL;
		PRINTF_FUNC( "Can't open database: %s\r\n", sqlite3_errmsg(db));
		sqlite3_close(db);
	}
	else
	{
		PRINTF_FUNC( "Local charging record database open successfully (%d).\r\n", IsAvailable);

		sprintf(sqlStr, "insert or replace into config (IsAvailable, connector, val) values('IsAvailable', %d, %d);", gun_index, IsAvailable);
		PRINTF_FUNC("sqlStr= %s\r\n", sqlStr);
		if (sqlite3_exec(db, sqlStr, 0, 0, &errMsg) != SQLITE_OK)
		{
			result = FAIL;
			PRINTF_FUNC( "update config error message: %s\n", errMsg);
		}
		else
		{
			PRINTF_FUNC("update connector-%d config item isOperactive to %d\r\n", gun_index, IsAvailable);
		}

		sqlite3_close(db);
	}

	return result;
}

int DB_Get_Operactive(sqlite3 *db, uint8_t gun_index)
{
	uint8_t result = true;
	char* errMsg = NULL;
	char sqlStr[1024];
	char **rs;
	int	 rows, cols;

	sprintf(sqlStr, "select * from config where IsAvailable='IsAvailable' and connector=%d;", gun_index);
	//DEBUG_INFO("sqlStr= %s\r\n", sqlStr);

	if(sqlite3_open(DB_FILE, &db))
	{
		result = FAIL;
		PRINTF_FUNC( "Can't open database: %s\r\n", sqlite3_errmsg(db));
		sqlite3_close(db);
	}
	else
	{
		PRINTF_FUNC( "Local config query database open successfully.");
		sqlite3_get_table(db, sqlStr, &rs, &rows, &cols, &errMsg);
		if(rows>0)
		{
			for(int idxRow=1;idxRow<=rows;idxRow++)
			{
				if(strcmp(rs[(idxRow*cols)+3], "0") == 0)
				{
					result = false;
				}
				PRINTF_FUNC("Query connector-%d isOperactive: %s", gun_index, rs[(idxRow*cols)+3]);
			}
		}
		else
		{
			PRINTF_FUNC("Query connector-%d fail, set default value to operactive.", gun_index);
		}

		sqlite3_free_table(rs);
		sqlite3_close(db);
	}

	return result;
}

//===============================================
// Config process
//===============================================
void AddPlugInTimes(byte gunIndex)
{
	if (chargingInfo[gunIndex]->Type == _Type_Chademo)
		ShmSysConfigAndInfo->SysConfig.ChademoPlugInTimes += 1;
	else if(chargingInfo[gunIndex]->Type == _Type_CCS_2)
		ShmSysConfigAndInfo->SysConfig.Ccs2PlugInTimes += 1;
	else if(chargingInfo[gunIndex]->Type == _Type_GB)
		ShmSysConfigAndInfo->SysConfig.GbPlugInTimes += 1;
}

void ChangeStartOrStopDateTime(byte isStart, byte gunIndex)
{
	char cmdBuf[32];
	struct timeb csuTime;
	struct tm *tmCSU;

	ftime(&csuTime);
	tmCSU = localtime(&csuTime.time);

	sprintf(cmdBuf, "%04d-%02d-%02d %02d:%02d:%02d", tmCSU->tm_year + 1900,
			tmCSU->tm_mon + 1, tmCSU->tm_mday, tmCSU->tm_hour, tmCSU->tm_min,
			tmCSU->tm_sec);
	if (isStart)
		strcpy((char *)chargingInfo[gunIndex]->StartDateTime, cmdBuf);
	else
		strcpy((char *)chargingInfo[gunIndex]->StopDateTime, cmdBuf);
}

void zipLogFiles()
{
	const char* logPath = "/Storage/SystemLog";
	// 獲取目錄
	DIR* pDir = opendir(logPath);
	if (pDir != NULL)
	{
		struct timeb csuTime;
		struct tm *tmCSU;

		ftime(&csuTime);
		tmCSU = localtime(&csuTime.time);
//		PRINTF_FUNC("Time : %04d-%02d-%02d %02d:%02d:%02d \n", tmCSU->tm_year + 1900,
//			tmCSU->tm_mon + 1, tmCSU->tm_mday, tmCSU->tm_hour, tmCSU->tm_min,
//			tmCSU->tm_sec);

		// Read items inside the folder
		struct dirent* pEntry = NULL;
		while ((pEntry = readdir(pDir)) != NULL)
		{
			if (strcmp(pEntry->d_name, ".") != 0 &&
					strcmp(pEntry->d_name, "..") != 0 &&
					strncmp(pEntry->d_name, "[", 1) == 0 &&
					strstr(pEntry->d_name, "tar") < 0)
			{
				char yearC[5];
				unsigned short year = 0;
				char monthC[3];
				unsigned short month = 0;

				yearC[4] = '\0';
				strncpy(yearC, pEntry->d_name + 1, 4);
				monthC[2] = '\0';
				strncpy(monthC, pEntry->d_name + 6, 2);

				year = atoi(yearC);
				month = atoi(monthC);

				if (year != 0)
				{
					if (year < tmCSU->tm_year + 1900 ||
							(year >= tmCSU->tm_year + 1900 && month < tmCSU->tm_mon + 1))
					{
						DEBUG_INFO_MSG("tar file name : %s \n", pEntry->d_name);
						char file[256];

						memset(file, 0x00, sizeof(file));
						strcat(file, "tar zcvf ");
						strcat(file, logPath);
						strncat(file, "/", 1);
						strcat(file, pEntry->d_name);
						strcat(file, ".tar");
						strncat(file, " ", 1);
						strcat(file, logPath);
						strncat(file, "/", 1);
						strcat(file, pEntry->d_name);
						PRINTF_FUNC("zip = %s \n", file);
						system(file);
					}
				}
			}
		}
	}
	// Close folder
	closedir(pDir);
}

void ChangeGunSelectByIndex(byte sel)
{
	ShmSysConfigAndInfo->SysInfo.CurGunSelected = sel;
	ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc = NO_DEFINE;
}

void StopProcessingLoop()
{
	for (;;)
	{
		CheckFactoryConfigFunction();
		CheckFwUpdateFunction();
        if (ShmSysConfigAndInfo->SysWarningInfo.Level == 2)
        {
            ChkPrimaryStatus();
            if (ShmSysConfigAndInfo->SysWarningInfo.Level == 0)
            {
                PRINTF_FUNC("Soft reboot for retry self-tets (Primary). \n");
                KillAllTask();
                sleep(3);
                system("/usr/bin/run_evse_restart.sh");
                return;
            }
        }

        if(ShmOCPP16Data->MsMsg.bits.ResetReq == YES)
        {
            if(strcmp((char *)ShmOCPP16Data->Reset.Type, "Hard") == EQUAL)
            {
                ShmChargerInfo->Control.SysCtrl.bits.NeedHardReset = true;
            }

            if(strcmp((char *)ShmOCPP16Data->Reset.Type, "Soft") == EQUAL)
            {
                ShmChargerInfo->Control.SysCtrl.bits.NeedSoftReset = true;
            }
        }

        CheckSoftHardReset();
		sleep(1);
	}
}

void CreateWatchdog()
{
	if (ShmSysConfigAndInfo->SysConfig.SwitchDebugFlag == NO)
	{
		wtdFd = InitWatchDog();

		if (wtdFd < 0)
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
	}
}

bool IsConnectorWholeIdle()
{
	bool result = true;

	for (byte count = 0; count < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; count++)
	{
		if (chargingInfo[count]->SystemStatus != S_IDLE &&
            chargingInfo[count]->SystemStatus != S_RESERVATION &&
            chargingInfo[count]->SystemStatus != S_FAULT &&
            chargingInfo[count]->SystemStatus != S_MAINTAIN)
		{
			result = false;
			break;
		}
	}

	return result;
}

void ClearAlarmCodeWhenAcOff()
{
	if (!ShmSysConfigAndInfo->SysInfo.AcContactorStatus)
	{
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuNoResource = NO;
	}
}

//==========================================
// Check task processing
//==========================================
void CheckTask()
{
	if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T' || ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')
	{
	    if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == YES)
	    {
            if(system("pidof -s Module_4g > /dev/null") != 0)
            {
                DEBUG_ERROR_MSG("Module_4g not running, restart it.\r\n");
                system("/root/Module_4g &");
            }
	    }
	}

	if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W' || ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')
	{
	    if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE)
	    {
            if(system("pidof -s Module_Wifi > /dev/null") != 0)
            {
                DEBUG_ERROR_MSG("Module_Wifi not running, restart it.\r\n");
                system("/root/Module_Wifi &");
            }
	    }
	}

	if(strcmp((char *)ShmSysConfigAndInfo->SysConfig.OcppServerURL, "") != EQUAL &&
			strcmp((char *)ShmSysConfigAndInfo->SysConfig.ChargeBoxId, "") != EQUAL)
	{
	    ShmChargerInfo->Control.SysCtrl.bits.BackendEnable = true;

        if((time((time_t*)NULL) - ShmOCPP16Data->procDogTime) > 180)
        {
            DEBUG_ERROR_MSG("OcppBackend watch dog timeout task restart.\n");
            ShmOCPP16Data->procDogTime =  time((time_t*)NULL);
            system("pkill OcppBackend");
        }

		if(system("pidof -s OcppBackend > /dev/null") != 0)
		{
			DEBUG_ERROR_MSG("OcppBackend not running, restart it.\r\n");
			system("/root/OcppBackend &");
		}
	}
	else
	{
	    ShmChargerInfo->Control.SysCtrl.bits.BackendEnable = false;
	}

	if(system("pidof -s Module_ProduceUtils > /dev/null") != 0)
	{
		DEBUG_ERROR_MSG("Module_ProduceUtils not running, restart it.\r\n");
		system ("/root/Module_ProduceUtils &");
	}

    if(system("pidof -s Module_EvComm > /dev/null") != 0)
    {
        DEBUG_ERROR_MSG("Module_EvComm not running, restart it.\r\n");
        system ("/root/Module_EvComm &");
    }
}

void InitialDHCP()
{
	char tmpbuf[256];
	memset(tmpbuf,0,256);
	system("pgrep -f \"udhcpc -i eth0\" | xargs kill");
	sprintf(tmpbuf, "/sbin/udhcpc -i eth0 -x hostname:CSU3_%s -s /root/dhcp_script/eth0.script > /dev/null &", ShmSysConfigAndInfo->SysConfig.SystemId);
	system(tmpbuf);
}

void InitialDispenserDhcpServerConfig(void)
{
	system("echo 'start           192.168.100.10'        >  /etc/udhcpd_eth1.conf");
	system("echo 'end             192.168.100.20'        >> /etc/udhcpd_eth1.conf");
	system("echo 'interface       eth1'                  >> /etc/udhcpd_eth1.conf");
	system("echo 'opt             dns     8.8.8.8'       >> /etc/udhcpd_eth1.conf");
	system("echo 'option          subnet  255.255.255.0' >> /etc/udhcpd_eth1.conf");
	system("echo 'opt             router  192.168.100.1' >> /etc/udhcpd_eth1.conf");
	system("echo 'option          domain  local'         >> /etc/udhcpd_eth1.conf");
	system("echo 'option          lease   86400'         >> /etc/udhcpd_eth1.conf");

	usleep(1000);
}

void StartDispenserDhcpServer(void)
{
	system("pgrep -f \"udhcpd /etc/udhcpd_eth1.conf\" | xargs kill");
	system("/usr/sbin/udhcpd /etc/udhcpd_eth1.conf > /dev/null &");
}

//==========================================
// Check Smart Charging Profile
//==========================================
int GetStartScheduleTime(unsigned char *time)
{
	int result = -1;
	struct tm tmScheduleStart;
	struct timeb tbScheduleStart;

	if((sscanf((char *)time, "%4d-%2d-%2dT%2d:%2d:%2d", &tmScheduleStart.tm_year, &tmScheduleStart.tm_mon, &tmScheduleStart.tm_mday, &tmScheduleStart.tm_hour, &tmScheduleStart.tm_min, &tmScheduleStart.tm_sec) == 6))
	{
		tmScheduleStart.tm_year -= 1900;
		tmScheduleStart.tm_mon -= 1;
		tbScheduleStart.time = mktime(&tmScheduleStart);
		tbScheduleStart.millitm = 0;

		result = DiffTimebWithNow(tbScheduleStart) / 1000;
	}

	return result;
}

void CheckSmartChargeProfile(byte _index)
{
	if (ShmOCPP16Data->CSUMsg.bits[_index].ChargingProfileConf == NO)
	{
		if (ShmOCPP16Data->CSUMsg.bits[_index].ChargingProfileReq == NO)
			ShmOCPP16Data->CSUMsg.bits[_index].ChargingProfileReq = YES;
	}
	else
	{
		// Get Charging Profile
		ShmOCPP16Data->CSUMsg.bits[_index].ChargingProfileConf = NO;
		if (strcmp((char *)ShmOCPP16Data->SmartChargingProfile[_index].ChargingProfileKind, "Absolute") == EQUAL)
		{
			int _time = GetStartScheduleTime(ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.StartSchedule);
			byte _startCount = NO_DEFINE;
			byte _maxCount = ARRAY_SIZE(ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod);

			for (byte _count = 0; _count < _maxCount; _count++)
			{
				// 預設最小輸出電流 (MIN_OUTPUT_CUR) A
				if (_time >= ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[_count].StartPeriod &&
						ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[_count].Limit > MIN_OUTPUT_CUR)
				{
					_startCount = _count;
				}
			}

			PRINTF_FUNC("_startCount = %d \n", _startCount);
			if (_startCount < _maxCount)
			{
				PRINTF_FUNC("*********Limit = %f \n", ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[_startCount].Limit);
				chargingInfo[_index]->ChargingProfileCurrent = ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[_startCount].Limit * 10;
				chargingInfo[_index]->ChargingProfilePower = ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[_startCount].Limit * chargingInfo[_index]->EvBatterytargetVoltage / 100;

				//chargingInfo[_index]->ChargingProfilePower = ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[_startCount].Limit * AC_OUTPUT_VOL;
//				if ((chargingInfo[_index]->EvBatterytargetVoltage * 10) > 0)
//				{
//					chargingInfo[_index]->ChargingProfileCurrent = chargingInfo[_index]->ChargingProfilePower / (chargingInfo[_index]->EvBatterytargetVoltage * 10);
//				}
			}
			else
			{
				chargingInfo[_index]->ChargingProfilePower = -1;
				chargingInfo[_index]->ChargingProfileCurrent = -1;
			}

			PRINTF_FUNC("ChargingProfilePower = %f \n", chargingInfo[_index]->ChargingProfilePower);
			PRINTF_FUNC("ChargingProfileCurrent = %f \n", chargingInfo[_index]->ChargingProfileCurrent);
		}
//
//		printf("-------------Schedule------------\n");
//		printf("index = %d \n", _index);
//		printf("StartSchedule = %s \n", ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.StartSchedule);
//		printf("ChargingRateUnit = %s \n", ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingRateUnit);
//		printf("----------SchedulePeriod---------\n");
//		for (int v = 0; v < 10; v++)
//		{
//			printf("StartPeriod = %d \n", ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[v].StartPeriod);
//			printf("Limit = %f \n", ShmOCPP16Data->SmartChargingProfile[_index].ChargingSchedule.ChargingSchedulePeriod[v].Limit);
//		}
//		printf("---------------------------------\n");
	}
}

void TheEndCharging(byte gun_index)
{
    ftime(&endChargingTime[gun_index]);
    if (chargingInfo[gun_index]->PresentChargedDuration != 0)
            chargingInfo[gun_index]->PresentChargedDuration = DiffTimeb(startChargingTime[gun_index], endChargingTime[gun_index]);

    chargingInfo[gun_index]->isRemoteStart = NO;

    StopGunInfoTimeoutDet(gun_index);
    StartGunInfoTimeoutDet(gun_index, Timeout_EvseCompleteDet);
    ChangeStartOrStopDateTime(NO, gun_index);
    //DB_Insert_Record(localDb, gun_index);
}

void UpdateErrorCodeToOcpp(byte index)
{
    //printf("ConnectorAlarmCode = %s \n", chargingInfo[index]->ConnectorAlarmCode);
    if (strcmp((char *)chargingInfo[index]->ConnectorAlarmCode, "") != EQUAL)
    {
        strcpy((char *)ShmOCPP16Data->StatusNotification[index].ErrorCode, "InternalError");
        strcpy((char *)ShmOCPP16Data->StatusNotification[index].VendorErrorCode, (char *)chargingInfo[index]->ConnectorAlarmCode);
    }
    else if (strcmp((char *)chargingInfo[index]->EvConnAlarmCode, "") != EQUAL)
    {
        strcpy((char *)ShmOCPP16Data->StatusNotification[index].ErrorCode, "OtherError");
        strcpy((char *)ShmOCPP16Data->StatusNotification[index].VendorErrorCode, (char *)chargingInfo[index]->EvConnAlarmCode);
    }
}

void CheckMiscCommandRequirement(void)
{
    BOOL NeedAnnouncement = FALSE;
    unsigned char connector = 0;

    if(ShmSysConfigAndInfo->SysInfo.FirmwareUpdate != YES)
    {
        for(int i = 0; i < CONNECTOR_QUANTITY; i++)
        {
            NeedAnnouncement = FALSE;

            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_None &&
                ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].LocalStatus != _DS_Timeout)
            {
                if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.ConnectorTimeoutConfigRequest ||
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.DefaultPriceConfigRequest ||
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.CurrencyConfigRequest ||
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.HardwareRebootRequest ||
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.SoftwareResetRequest ||
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.BackendStatusRequest ||
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.EthernetStatusRequest ||
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.WiFiStatusRequest ||
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.TelcomModemStatusRequest ||
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.BillingStatusRequest ||
                    ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.StopButtonStatusRequest)
                {
                    NeedAnnouncement = TRUE;
                }

                for(int j = 0; j < ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorQuantity; j++)
                {
                    connector = ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].ConnectorID[j] - 1;

                    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.AvailabilityRequest ||
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.RemoteStartRequest ||
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.AccountBalanceRequest)
                    {
                        NeedAnnouncement = TRUE;
                    }
                }

                if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.MiscNeedAnnouncement != NeedAnnouncement)
                {
                    if(NeedAnnouncement)
                    {
                        PRINTF_FUNC("********** Dispenser %d Misc Command Need Announcement **********", i + 1);
                    }
                    else
                    {
                        PRINTF_FUNC("********** Dispenser %d Misc Command Announced **********", i + 1);
                    }
                }
            }
            ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[i].Setting.bits.MiscNeedAnnouncement = NeedAnnouncement;
        }
    }
}

void CheckDispenserVersionUpdateRequirement(void)
{

}


// connector: connector infex, 0 ~ 3
void SetLedIndicationStatus(unsigned char connector, unsigned char indication)
{
    int greenOffset = 0, redOffset = 0;

    if(ShmChargerInfo->Control.SysCtrl.bits.StandardLedIndication)
    {
        greenOffset = 2;
        redOffset = 3;
    }
    if(ShmChargerInfo->Control.SysCtrl.bits.E4YOULedIndication)
    {
        if(connector == 0)
        {
            greenOffset = 4;
            redOffset = 5;
        }
        else if(connector == 1)
        {
            greenOffset = 2;
            redOffset = 3;
        }
        else
        {
            return;
        }
    }

    switch(indication)
    {
        case _LED_INDICATION_OFF:
            ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] &= ~(0x01 << greenOffset);       // green off
            ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] &= ~(0x01 << redOffset);         // red off
            break;
        case _LED_INDICATION_RUN:
            ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] |= (0x01 << greenOffset);        // green on
            ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] &= ~(0x01 << redOffset);         // red off
            break;
        case _LED_INDICATION_FAULT:
            ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] &= ~(0x01 << greenOffset);       // green off
            ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] |= (0x01 << redOffset);          // red on
            break;
        case _LED_INDICATION_ON:
            ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] |= (0x01 << greenOffset);        // green on
            ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] |= (0x01 << redOffset);          // red on
            break;
        case _LED_INDICATION_GREEN_TOGGLE:
            if(ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] & (0x01 << greenOffset))
            {
                ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] &= ~(0x01 << greenOffset);   // green off
            }
            else
            {
                ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] |= (0x01 << greenOffset);    // green on
            }
            break;
        case _LED_INDICATION_RED_TOGGLE:
            if(ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] & (0x01 << redOffset))
            {
                ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] &= ~(0x01 << redOffset);     // red off
            }
            else
            {
                ShmPrimaryMcuData->OutputDrv.OutputDrvValue[0] |= (0x01 << redOffset);      // red on
            }
            break;
    }
}

struct timeval _standardIndication_time;
unsigned char _standardLedStatus, _preStandardLedStatus;
unsigned char _e4youLedStatus[2], _preE4youLedStatus[2];
struct timeval _e4youIndication_time[2];

void LedIndicationProcess(void)
{
    if(ShmChargerInfo->Control.SysCtrl.bits.StandardLedIndication)
    {
        if(ShmSysConfigAndInfo->SysWarningInfo.Level == 2)
        {
            _standardLedStatus = _STANDARD_LED_Alarm;
            if(_preStandardLedStatus != _standardLedStatus)
            {
                _preStandardLedStatus = _standardLedStatus;
            }

            SetLedIndicationStatus(0, _LED_INDICATION_FAULT);
        }
        else
        {
            if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.PresentDispenserQuantity == 0)
            {
                _standardLedStatus = _STANDARD_LED_Disconnection;
                if(_preStandardLedStatus != _standardLedStatus)
                {
                    _preStandardLedStatus = _standardLedStatus;

                    // reset led status & indication time
                    gettimeofday(&_standardIndication_time, NULL);
                    SetLedIndicationStatus(0, _LED_INDICATION_OFF);
                }

                if((GetTimeoutValue(_standardIndication_time) / mSEC_VAL) >= INDICATION_BLINK_INTERVAL)
                {
                    SetLedIndicationStatus(0, _LED_INDICATION_GREEN_TOGGLE);
                    SetLedIndicationStatus(0, _LED_INDICATION_RED_TOGGLE);
                    gettimeofday(&_standardIndication_time, NULL);
                }
            }
            else
            {
                _standardLedStatus = _STANDARD_LED_Running;
                if(_preStandardLedStatus != _standardLedStatus)
                {
                    _preStandardLedStatus = _standardLedStatus;
                }

                SetLedIndicationStatus(0, _LED_INDICATION_RUN);
            }
        }
    }
    if(ShmChargerInfo->Control.SysCtrl.bits.E4YOULedIndication)
    {
        for(int i = 0; i < 2; i++)
        {
            if((ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData.SystemStatus == S_FAULT ||
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData.SystemStatus == S_ALARM) &&
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].Enable)
            {
                _e4youLedStatus[i] = _E4YOU_LED_Alarm;
                if(_preE4youLedStatus[i] != _e4youLedStatus[i])
                {
                    _preE4youLedStatus[i] = _e4youLedStatus[i];
                }

                SetLedIndicationStatus(i, _LED_INDICATION_FAULT);
            }
            else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].Enable == false)
            {
                _e4youLedStatus[i] = _E4YOU_LED_Disconnection;
                if(_preE4youLedStatus[i] != _e4youLedStatus[i])
                {
                    _preE4youLedStatus[i] = _e4youLedStatus[i];

                    // reset led status & indication time
                    gettimeofday(&_e4youIndication_time[i], NULL);
                    SetLedIndicationStatus(i, _LED_INDICATION_OFF);
                }

                if((GetTimeoutValue(_e4youIndication_time[i]) / mSEC_VAL) >= INDICATION_BLINK_INTERVAL)
                {
                    gettimeofday(&_e4youIndication_time[i], NULL);
                    SetLedIndicationStatus(i, _LED_INDICATION_GREEN_TOGGLE);
                    SetLedIndicationStatus(i, _LED_INDICATION_RED_TOGGLE);
                }
            }
            else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData.SystemStatus == S_IDLE ||
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData.SystemStatus == S_MAINTAIN ||
                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData.SystemStatus == S_RESERVATION)
            {
                _e4youLedStatus[i] = _E4YOU_LED_Idle;
                if(_preE4youLedStatus[i] != _e4youLedStatus[i])
                {
                    _preE4youLedStatus[i] = _e4youLedStatus[i];
                }

                SetLedIndicationStatus(i, _LED_INDICATION_RUN);
            }
            else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData.SystemStatus >= S_REASSIGN_CHECK &&
                    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[i].GeneralChargingData.SystemStatus <= S_COMPLETE)
            {
                _e4youLedStatus[i] = _E4YOU_LED_Charging;
                if(_preE4youLedStatus[i] != _e4youLedStatus[i])
                {
                    _preE4youLedStatus[i] = _e4youLedStatus[i];

                    // reset led status & indication time
                    gettimeofday(&_e4youIndication_time[i], NULL);
                    SetLedIndicationStatus(i, _LED_INDICATION_OFF);
                }

                if((GetTimeoutValue(_e4youIndication_time[i]) / mSEC_VAL) >= E4YOU_BLINK_INTERVAL)
                {
                    gettimeofday(&_e4youIndication_time[i], NULL);
                    SetLedIndicationStatus(i, _LED_INDICATION_GREEN_TOGGLE);
                }
            }
        }
    }
}

void CreateLedIndicationFork(void)
{
    pid_t pid;

    pid = fork();
    if(pid == 0)
    {
        while(1)
        {
            LedIndicationProcess();
            usleep(100000);
        }
    }
}

void CheckConnectorDisconnectionRecovery(unsigned char connector)
{
    unsigned char dispenser = 0;

    dispenser = ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].ParentDispensetIndex;

    if(ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[dispenser].LocalStatus != _DS_Timeout)
    {
        PRINTF_FUNC("Connector %d Disconnection Recovery", connector + 1);
        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[connector].Parameter.bits.Disconnection = false;
    }
}

bool ConnectorRequestToCharging(unsigned char connector)
{
    unsigned char role = 0;
    bool done = false;

    role = ShmGroupCollection[connector].Role;

    switch(role)
    {
        case _GROLE_IDLE:
            if(!ShmGroupCollection[connector].GroupCtrl.bits.ChargingRequest)
            {
                PRINTF_FUNC("Request Gun %d To Start Charging", connector + 1);
            }
            ShmGroupCollection[connector].GroupCtrl.bits.ChargingRequest = true;
            break;

        case _GROLE_MASTER:
            done = true;
            break;

        case _GROLE_SLAVE:
            if(!ShmGroupCollection[connector].GroupCtrl.bits.SlaveChargingRequest)
            {
                PRINTF_FUNC("Gun %d Wait For Re-Grouping", connector + 1);
            }
            ShmGroupCollection[connector].GroupCtrl.bits.SlaveChargingRequest = true;
            break;

        case _GROLE_REQUEST_TO_CHARGING:
            done = true;
            break;

        default:
            break;
    }

    return done;
}

bool IsConnectorGroupingCompleted(unsigned char connector)
{
    unsigned char role = 0;
    bool completed = false;

    role = ShmGroupCollection[connector].Role;

    switch(role)
    {
        case _GROLE_MASTER:
            completed = true;
            break;

        default:
            break;
    }

    return completed;
}

int main(void)
{
    int time = 0;

	if(CreateShareMemory() == 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR_MSG("CreatShareMemory NG \n");
		#endif
		if(ShmStatusCodeData!=NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory = 1;
		}
		sleep(5);
		system("reboot -f");
		sleep(5);
		system("reboot -f");
	}
	PRINTF_FUNC("===== Boot and Initialization start ===== \n");

	if (!InitialSystemDefaultConfig())
	{
		DEBUG_ERROR_MSG("InitialSystemDefaultConfig NG \n");
		StopProcessingLoop();
	}

    PRINTF_FUNC("ModelName: [%s], SN: [%s], SW Version: [%s]",
        ShmSysConfigAndInfo->SysConfig.ModelName, ShmSysConfigAndInfo->SysConfig.SerialNumber, fwVersion);

	PRINTF_FUNC("InitialShareMemoryInfo");
	InitialShareMemoryInfo();

	PRINTF_FUNC("ChargerType (IEC or UL) = %d", ShmSysConfigAndInfo->SysInfo.ChargerType);
	ChangeLcmByIndex(_LCM_INIT);
    if(!InitialChargerSetting())
    {
        isModelNameMatch = false;
    }

	Initialization();

	PRINTF_FUNC("Spawn all Task.");
	SpawnTask();

	if (!isModelNameMatch)
	{
		PRINTF_FUNC("Module Name & HW info none match.");
		ShmStatusCodeData->AlarmCode.AlarmEvents.bits.ModelNameNoneMatchStestFail = YES;
		ChangeLcmByIndex(_LCM_FIX);
		// Module Name 與硬體對應不正確
		DEBUG_ERROR_MSG("Module Name & HW info none match.");
		sleep(3);
		KillAllTask();
		StopProcessingLoop();
	}
	PRINTF_FUNC("Module Name & HW info correct. Initialize.......");
	CreateTimeoutFork();
	PRINTF_FUNC("Self test.");

    if(ShmChargerInfo->Control.SysCtrl.bits.StandardLedIndication)
    {
        _standardLedStatus = _STANDARD_LED_None;
        _preStandardLedStatus = _STANDARD_LED_None;
        SetLedIndicationStatus(0, _LED_INDICATION_ON);
    }
    if(ShmChargerInfo->Control.SysCtrl.bits.E4YOULedIndication)
    {
        _e4youLedStatus[0] = _E4YOU_LED_None;
        _e4youLedStatus[1] = _E4YOU_LED_None;
        _preE4youLedStatus[0] = _E4YOU_LED_None;
        _preE4youLedStatus[1] = _E4YOU_LED_None;
        SetLedIndicationStatus(0, _LED_INDICATION_ON);
        SetLedIndicationStatus(1, _LED_INDICATION_ON);
    }

	SelfTestRun();
//	StopSystemTimeoutDet();
	SetAcContactor(ON);
	PRINTF_FUNC("SelfTestSeq = %d, Work_Step = %d", ShmSysConfigAndInfo->SysInfo.SelfTestSeq, ShmPsuData->Work_Step);
	if (ShmSysConfigAndInfo->SysInfo.SelfTestSeq == _STEST_FAIL ||
			ShmPsuData->Work_Step == _NO_WORKING)
	{
		for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
		{
			setChargerMode(gun_index, MODE_FAULT);
		}
		ChangeLcmByIndex(_LCM_FIX);
		sleep(3);
        if (ShmSysConfigAndInfo->SysWarningInfo.Level == 2)
        {
            KillTaskExceptPrimary();
        }
        else
        {
            KillAllTask();
        }
		StopProcessingLoop();
	}
	else
	{
		for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
		{
			setChargerMode(gun_index, MODE_IDLE);

            if(ShmPsuData->PsuGroup[gun_index].GroupPresentPsuQuantity > 0)
            {
                _PsuGroupAvailable[gun_index] = YES;
            }
		}
	}

	// Local DB
	if(DB_Open(localDb) != PASS)
	{
		PRINTF_FUNC("DB_Open fail.");
		isDb_ready = false;
	}
	else
	{
		isDb_ready = true;
		for(int _index=0; _index< ShmSysConfigAndInfo->SysConfig.TotalConnectorCount;_index++)
		{
			chargingInfo[_index]->IsAvailable = DB_Get_Operactive(localDb, _index);
		}
	}

	ChangeLcmByIndex(_LCM_IDLE);
	sleep(1);

	CreateLedIndicationFork();

	// Main loop
	PRINTF_FUNC("****************************Main Loop********************************** \n");
	gettimeofday(&_cmdMainPriority_time, NULL);
	for (;;)
	{
		CheckOcppStatus();
		ChkPrimaryStatus();
		ChkPsuStatus();
		PsuFailureResume();
		if ((IsConnectorWholeIdle() || ShmSysConfigAndInfo->SysInfo.PageIndex == _LCM_FIX) &&
				ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag != Timeout_ReturnToChargingGunDet)
		{
			CheckFactoryConfigFunction();

			CheckFwUpdateFunction();
		}

        if(CheckWiringInfoUpdate() != YES)
        {
            // return fork process
            return 0;
        }
        CheckSoftHardReset();

		StandbyCheck();

		// OCPP 邏輯
		//OcppRemoteStartChk();
		// 讀卡邏輯
		//ScannerCardProcess();

		PowerCabinetAuthorizeProcess();

		// 當 AC 沒有搭上時，清除一些錯誤碼
		ClearAlarmCodeWhenAcOff();

		if ((GetTimeoutValue(_cmdMainPriority_time) / 1000) > 5000)
		{
			CheckTask();
			for (byte _index = 0; _index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; _index++)
			{
				if (chargingInfo[_index]->SystemStatus == S_CHARGING)
					CheckSmartChargeProfile(_index);
			}

			gettimeofday(&_cmdMainPriority_time, NULL);
		}

        //LedIndicationProcess();

		CheckMiscCommandRequirement();
		CheckDispenserVersionUpdateRequirement();

		for (byte gun_index = 0; gun_index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gun_index++)
		{
			//CheckGpioInStatus();
			CheckErrorOccurStatus(gun_index);
			ChkOcppStatus(gun_index);

			//PRINTF_FUNC("index = %d, ErrorCode = %s \n", gun_index, ShmOCPP16Data->StatusNotification[gun_index].ErrorCode);
			switch(chargingInfo[gun_index]->SystemStatus)
			{
                case S_MAINTAIN:
                    if(isModeChange(gun_index))
                    {
                        PRINTF_FUNC("==================      S_MAINTAIN (%x)      ================== \n", gun_index + 1);
                    }

                    if(chargingInfo[gun_index]->IsAvailable == YES &&
                        (_PsuGroupAvailable[gun_index] == YES || ShmPsuData->PsuGroup[gun_index].GroupPresentPsuQuantity > 0))
                    {
                        setChargerMode(gun_index, MODE_IDLE);
                    }
                    break;

				case S_IDLE:
				case S_RESERVATION:
				case S_FAULT:
				{
					// clean PermissionRequest flag
					ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PermissionRequest = false;
					ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable = true;

					if(isModeChange(gun_index))
                    {
                        if (chargingInfo[gun_index]->SystemStatus == S_IDLE)
                        {
                            PRINTF_FUNC("==================        S_IDLE (%x)        ================== \n", gun_index + 1);
                            chargingInfo[gun_index]->PresentChargedDuration = 0;
                            chargingInfo[gun_index]->RemainChargingDuration = 0;
                            chargingTime[gun_index] = 0;
                            strcpy((char *)chargingInfo[gun_index]->StartDateTime, "");
                            strcpy((char *)chargingInfo[gun_index]->StopDateTime, "");
                            strcpy((char *)chargingInfo[gun_index]->StartUserId, "");
                            strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "");
                            ReleaseAlarmCode(gun_index);

                            // clean connector infomation
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteChargingVoltage = 0;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteChargingCurrent = 0;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteRemainChargingDuration = 0;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteSoc = 0;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].UserPrice = 0;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].TotalCost = 0;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].AccountBalance = -6553500;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.AnnounceBalance = false;

                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.StartWaitPlug = false;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.NeedCleanAuthorizeInfo = false;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.OutputLimitEnable = false;

                            chargingInfo[gun_index]->EvBatterytargetVoltage = 0;
                            chargingInfo[gun_index]->EvBatterytargetCurrent = 0;
                            chargingInfo[gun_index]->EvBatteryMaxVoltage = 0;
                            chargingInfo[gun_index]->EvBatterySoc = 0;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteTargetVoltage = 0;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteTargetCurrent = 0;

                            // clean RemoteStart & RemoteStop flag
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.RemoteStartRequest = false;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.RemoteStartConfirm = false;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.RemoteStopRequest = false;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.RemoteStopConfirm = false;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.UnlockStopRequest = false;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.UnlockStopConfirm = false;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.NormalStopRequest = false;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.AlarmStopRequest = false;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.FaultStatusRequest = false;
                            memset(chargingInfo[gun_index]->ConnectorAlarmCode, 0x00, sizeof(chargingInfo[gun_index]->ConnectorAlarmCode));

                            memset(&ShmOCPP16Data->Cost.RunningCost[gun_index], 0x00, sizeof(struct StrcutRunningFinalCost));
                            memset(&ShmOCPP16Data->Cost.FinalCost[gun_index], 0x00, sizeof(struct StrcutRunningFinalCost));
                            chargingInfo[gun_index]->PresentChargedEnergy = 0;
                            chargingInfo[gun_index]->PresentChargingPower = 0;

                            // clean force charging info
                            memset(&ShmChargerInfo->Control.FCharging[gun_index], 0x00, sizeof(ForceCharging));
                        }
                        else if (chargingInfo[gun_index]->SystemStatus == S_RESERVATION)
                        {
                            PRINTF_FUNC("==================    S_RESERVATION (%x)     ================== \n", gun_index + 1);
                            ShmOCPP16Data->CsMsg.bits[gun_index].ReserveNowConf = YES;
                        }
                        else if (chargingInfo[gun_index]->SystemStatus == S_FAULT)
                        {
                            PRINTF_FUNC("==================       S_FAULT (%x)        ================== \n", gun_index + 1);
                        }
                    }

                    if (chargingInfo[gun_index]->IsAvailable == NO ||
                        (_PsuGroupAvailable[gun_index] == NO && ShmPsuData->PsuGroup[gun_index].GroupPresentPsuQuantity == 0))
                    {
                        setChargerMode(gun_index, MODE_MAINTAIN);
                        continue;
                    }

                    if (ShmSysConfigAndInfo->SysWarningInfo.Level == 2 ||
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteStatus == _CRS_Alarm ||
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.FaultStatusRequest ||
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.Disconnection)
                    {
                        if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.FaultStatusRequest)
                        {
                            if(strncmp((char *)chargingInfo[gun_index]->ConnectorAlarmCode, "", 6) == EQUAL)
                            {
                                memcpy(chargingInfo[gun_index]->ConnectorAlarmCode, ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemotenAlarmCode, 6);
                            }
                        }
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.FaultStatusRequest = false;

                        if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.Disconnection)
                        {
                            if(strncmp((char *)chargingInfo[gun_index]->ConnectorAlarmCode, "", 6) == EQUAL)
                            {
                                memcpy(chargingInfo[gun_index]->ConnectorAlarmCode, "042304", 6);
                                PRINTF_FUNC("Connector %d Disconnect Occur", gun_index + 1);
                            }
                        }

                        if(chargingInfo[gun_index]->SystemStatus != S_FAULT)
                        {
                            ClearDetectPluginFlag();
                            UpdateErrorCodeToOcpp(gun_index);
                            setChargerMode(gun_index, MODE_FAULT);
                        }
                        else
                        {
                            if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.Disconnection)
                            {
                                CheckConnectorDisconnectionRecovery(gun_index);
                            }
                        }
                    }
					else
					{
					    if (chargingInfo[gun_index]->SystemStatus == S_FAULT)
						{
					        ReleaseAlarmCode(gun_index);
                            setChargerMode(gun_index, MODE_IDLE);
						}

						// clean stop charge flag
						chargingInfo[gun_index]->StopChargeFlag = false;
						chargingInfo[gun_index]->ChargingStopFlag.ChargingStopValue = 0;

						{ // Idle 正常程序起點
							// 判斷是否有啟用檢查插槍
                            if(IsConnectorAuthorizeSuccess(gun_index))
							{
                                if(chargingInfo[gun_index]->IsAvailable &&
                                    chargingInfo[gun_index]->SystemStatus == S_IDLE)
                                {
                                    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].AuthorizingType == _AuthType_RemoteStart)
                                    {
                                        PRINTF_FUNC("Connector %d remote start charging", gun_index + 1);
                                    }
                                    else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].AuthorizingType == _AuthType_RFID)
                                    {
                                        PRINTF_FUNC("Connector %d swipe rfid start charging", gun_index + 1);
                                    }

                                    setChargerMode(gun_index, MODE_AUTHORIZING);
                                    continue;
                                }
							}
                            else if(IsAutoGunSelectionAuthorizeSuccess(gun_index))
                            {
                                if(chargingInfo[gun_index]->IsAvailable &&
                                    chargingInfo[gun_index]->SystemStatus == S_IDLE &&
                                    chargingInfo[gun_index]->ConnectorPlugIn &&
                                    ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteStatus == _CRS_Preparing)
                                {
                                    strcpy((char *)chargingInfo[gun_index]->StartUserId, (char *)ShmSysConfigAndInfo->SysInfo.DispenserInfo.Dispenser[ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].ParentDispensetIndex].UserId);
                                    PRINTF_FUNC("Auto Gun Selection %d, CardNumber = %s", gun_index, chargingInfo[gun_index]->StartUserId);
                                    DispenserAuthorizationInitial(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].ParentDispensetIndex);
                                    setChargerMode(gun_index, MODE_REASSIGN_CHECK);
                                    continue;
                                }
                            }
							else if (chargingInfo[gun_index]->SystemStatus == S_RESERVATION)
							{
								if (!isReservationExpired(gun_index))
								{
									chargingInfo[gun_index]->SystemStatus = S_IDLE;
								}
							}
                            // only for test & debug purpose
                            else if(ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.EnableForceCharging &&
                                ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.StartForceCharging)
                            {
                                ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.StartForceCharging = false;
                                PRINTF_FUNC("Gun %d Start Force Charging", gun_index + 1);
                                setChargerMode(gun_index, MODE_REASSIGN_CHECK);
                                continue;
                            }
							else
							{

							}
						} // Idle 正常程序終點
					}
				}
					break;
				case S_AUTHORIZING:
                    if(isModeChange(gun_index))
                    {
                        PRINTF_FUNC("==================    S_AUTHORIZING (%x)     ================== \n", gun_index + 1);
                        ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_NONE;
                        if (ShmSysConfigAndInfo->SysInfo.OrderCharging != NO_DEFINE)
                            ShmSysConfigAndInfo->SysInfo.OrderCharging = NO_DEFINE;
                        StopSystemTimeoutDet();
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable = false;
                        SetAcContactor(ON);
                        gettimeofday(&_ConnectorAuthorizing_Time[gun_index], NULL);
                    }

                    if(GetTimeoutValue(_ConnectorAuthorizing_Time[gun_index]) / uSEC_VAL >= FORCE_BALANCE_TIME)
                    {
                        FouceAnnounceAccountBalance(gun_index);
                    }

                    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].AuthorizingType == _AuthType_RemoteStart)
                    {
                        if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.RemoteStartConfirm)
                        {
                            // sync with dispenser
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.RemoteStartConfirm = false;
                            gettimeofday(&_ConnectorAuthorizing_Time[gun_index], NULL);
                            PRINTF_FUNC("Sync with Connector %d through remote start", gun_index + 1);
                            FouceAnnounceAccountBalance(gun_index);
                        }
                    }

                    if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].AuthorizingType == _AuthType_RFID)
                    {
                        if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.SwipeRfidConfirm)
                        {
                            // sync with dispenser
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.SwipeRfidConfirm = false;
                            gettimeofday(&_ConnectorAuthorizing_Time[gun_index], NULL);
                            PRINTF_FUNC("Sync with Connector %d through swipe rfid", gun_index + 1);
                        }
                    }

                    if(GetTimeoutValue(_ConnectorAuthorizing_Time[gun_index]) / uSEC_VAL >= ShmSysConfigAndInfo->SysInfo.DispenserInfo.ConnectorTimeout)
                    {
                        if(!chargingInfo[gun_index]->ConnectorPlugIn)
                        {
                            PRINTF_FUNC("*********** Connector %d Plug In Timeout  ***********", gun_index + 1);
                        }
                        else
                        {
                            PRINTF_FUNC("*********** Connector %d Preparing State Timeout ***********", gun_index + 1);
                        }
                        setChargerMode(gun_index, MODE_IDLE);
                        ConnectorAuthorizationInitial(gun_index);
                    }
                    else
                    {
                        if(chargingInfo[gun_index]->ConnectorPlugIn &&
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteStatus == _CRS_Preparing)
                        {
                            AddPlugInTimes(gun_index);
                            PRINTF_FUNC("index = %d, CardNumber = %s \n", gun_index, chargingInfo[gun_index]->StartUserId);
                            setChargerMode(gun_index, MODE_REASSIGN_CHECK);
                            ConnectorAuthorizationInitial(gun_index);
                        }
                        else if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.NeedCleanAuthorizeInfo)
                        {
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.StartWaitPlug = false;
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.NeedCleanAuthorizeInfo = false;

                            PRINTF_FUNC("*********** Connector id %d User Stop Plug In ***********\n", gun_index + 1);
                            setChargerMode(gun_index, MODE_IDLE);
                            ConnectorAuthorizationInitial(gun_index);
                        }
                    }
				    break;
				case S_REASSIGN_CHECK:
				{
					if (isModeChange(gun_index))
					{
					    PRINTF_FUNC("==================   S_REASSIGN_CHECK (%x)   ================== \n", gun_index + 1);
						ShmSysConfigAndInfo->SysInfo.SystemPage = _LCM_NONE;
						if (ShmSysConfigAndInfo->SysInfo.OrderCharging != NO_DEFINE)
							ShmSysConfigAndInfo->SysInfo.OrderCharging = NO_DEFINE;
						StopSystemTimeoutDet();
						ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable = false;
						ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxTotalChargingCurrent = ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent * 10;
						ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxTotalChargingPower = ShmSysConfigAndInfo->SysConfig.MaxChargingPower * 10;
						ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxOutputEnergy = ShmSysConfigAndInfo->SysConfig.MaxChargingEnergy;
						ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxOutputDuration = ShmSysConfigAndInfo->SysConfig.MaxChargingDuration;

						PRINTF_FUNC("Max Total Current %d, Max Total Power %d, Total Energy %d, Total Duration %d",
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxTotalChargingCurrent,
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxTotalChargingPower,
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxOutputEnergy,
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].MaxOutputDuration);
						SetAcContactor(ON);
						gettimeofday(&_SystemStatus_Time[gun_index], NULL);
					}

                    time = GetTimeoutValue(_SystemStatus_Time[gun_index]) / uSEC_VAL;

                    if(ConnectorRequestToCharging(gun_index))
                    {
                        setChargerMode(gun_index, MODE_REASSIGN);
                    }
                    else if(time >= WAIT_REASSIGN_TIME)
                    {
                        if(ShmPsuData->Work_Step != _WORK_CHARGING)
                        {
                            PRINTF_FUNC("Gun %d Wait PSU Work Step Timeout", gun_index + 1);
                        }
                        else
                        {
                            PRINTF_FUNC("Gun %d Request Charging Timeout", gun_index + 1);
                        }
                        setChargerMode(gun_index, MODE_IDLE);
                    }
				}
					break;
				case S_REASSIGN:
				{
					if (isModeChange(gun_index))
					{
					    PRINTF_FUNC("==================      S_REASSIGN (%x)      ================== \n", gun_index + 1);
						gettimeofday(&_toAverage_time, NULL);
						gettimeofday(&_SystemStatus_Time[gun_index], NULL);
					}

                    time = GetTimeoutValue(_SystemStatus_Time[gun_index]) / uSEC_VAL;

                    if(IsConnectorGroupingCompleted(gun_index))
                    {
                        setChargerMode(gun_index, MODE_PRECHARGE);
                    }
                    else if(time >= MAX_REQUEST_CHARGING_TIME)
                    {
                        PRINTF_FUNC("Gun %d Grouping Timeout", gun_index + 1);
                        setChargerMode(gun_index, MODE_IDLE);
                    }
				}
					break;
				case S_PREPARNING:
				{
					if (isModeChange(gun_index))
					{
					    PRINTF_FUNC("==================     S_PREPARNING (%x)     ================== \n", gun_index + 1);
						StopGunInfoTimeoutDet(gun_index);
						StartGunInfoTimeoutDet(gun_index, Timeout_Preparing);
						SetAcContactor(ON);
						gettimeofday(&_SystemStatus_Time[gun_index], NULL);
					}

					time = GetTimeoutValue(_SystemStatus_Time[gun_index]) / uSEC_VAL;

                    if ((chargingInfo[gun_index]->AvailableChargingPower > 10) && time >= MIN_WAIT_PREPARNING_TIME)
                    {
                        setChargerMode(gun_index, MODE_PREPARE_FOR_EV);
                        continue;
                    }

					if (isEvBoardStopChargeFlag(gun_index) == YES)
					{
						// 板端或後臺要求停止
					    PRINTF_FUNC("********** Gun %d Alarm Stop (S_PREPARNING) **********", gun_index + 1);
                        if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
                        {
                            strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "Local");
                        }
					    ChargingAlarmProcess(gun_index);
					}
					else if(isNormalStopChargeFlag(gun_index) == YES)
					{
                        PRINTF_FUNC("********** Gun %d Normal Stop (S_PREPARNING) %s**********", gun_index + 1,
                            chargingInfo[gun_index]->ChargingStopFlag.bits.ManualStop ? "(ManualStop)" : "");
                        if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
                        {
                            strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "EVDisconnected");
                        }
					    ChargingTerminalProcess(gun_index);
					}
					/*
					if(time >= GUN_PREPARE_TIMEOUT)
					{
					    PRINTF_FUNC("********** Gun %d PrepareTimeout **********", gun_index + 1);
					    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.PsuNoResource = YES;
					    ChargingTerminalProcess(gun_index);
					}
					*/
				}
					break;
				case S_PREPARING_FOR_EV: // 等待車端的通訊 (EV 小板)，待車端回報後，開始樁端的測試
				{
					if (isModeChange(gun_index))
					{
					    PRINTF_FUNC("==================  S_PREPARING_FOR_EV (%x)  ================== \n", gun_index + 1);
						//strcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, "");
						StopGunInfoTimeoutDet(gun_index);
						StartGunInfoTimeoutDet(gun_index, Timeout_EvChargingDet);
						gettimeofday(&_SystemStatus_Time[gun_index], NULL);
					}

					if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PermissionRequest)
					{
					    setChargerMode(gun_index, MODE_PREPARE_FOR_EVSE);
					}
                    // only for test & debug purpose
                    else if(ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.EnableForceCharging)
                    {
                        PRINTF_FUNC("Gun %d [Force Charging] S_PREPARING_FOR_EV OK", gun_index + 1);
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PermissionRequest = true;
                    }

					if (isEvBoardStopChargeFlag(gun_index) == YES)
					{
						// 板端或後臺要求停止
					    PRINTF_FUNC("********** Gun %d Alarm Stop (S_PREPARING_FOR_EV) **********", gun_index + 1);
                        if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
                        {
                            strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "Local");
                        }
					    ChargingAlarmProcess(gun_index);
					}
                    else if(isNormalStopChargeFlag(gun_index) == YES)
                    {
                        PRINTF_FUNC("********** Gun %d Normal Stop (S_PREPARING_FOR_EV) %s**********", gun_index + 1,
                            chargingInfo[gun_index]->ChargingStopFlag.bits.ManualStop ? "(ManualStop)" : "");
                        if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
                        {
                            strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "EVDisconnected");
                        }
                        ChargingTerminalProcess(gun_index);
                    }
				}
					break;
				case S_PREPARING_FOR_EVSE: // 等待 RB 通訊及測試，並將狀態回報， CSU 確認 Pass 後，開始進入充電
				{
					if (isModeChange(gun_index))
					{
					    PRINTF_FUNC("================== S_PREPARING_FOR_EVSE (%x) ================== \n", gun_index + 1);
						StopGunInfoTimeoutDet(gun_index);
						StartGunInfoTimeoutDet(gun_index, Timeout_EvseChargingDet);
						gettimeofday(&_SystemStatus_Time[gun_index], NULL);
					}

                    // only for test & debug purpose
                    if(ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.EnableForceCharging)
                    {
                        float voltage = (float)ShmChargerInfo->Control.FCharging[gun_index].FTargetVoltage / 10;
                        float current = (float)ShmChargerInfo->Control.FCharging[gun_index].FTargetCurrent / 10;

                        if(chargingInfo[gun_index]->EvBatterytargetVoltage != voltage || chargingInfo[gun_index]->EvBatterytargetCurrent != current)
                        {
                            PRINTF_FUNC("Gun %d Set Force Charging Voltage %4d V, Current: %4d A", gun_index + 1, (int)voltage, (int)current);
                        }
                        chargingInfo[gun_index]->EvBatterytargetVoltage = voltage;
                        chargingInfo[gun_index]->EvBatterytargetCurrent = current;
                    }

					if(ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteStatus == _CRS_Charging)
					{
                        setChargerMode(gun_index, MODE_CHARGING);
					}
                    // only for test & debug purpose
                    else if(ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.EnableForceCharging)
                    {
                        time = GetTimeoutValue(_SystemStatus_Time[gun_index]) / uSEC_VAL;

                        if(time >= FORCE_CHARGING_WAIT_EVSE)
                        {
                            PRINTF_FUNC("Gun %d [Charging Simulation] S_PREPARING_FOR_EVSE OK", gun_index + 1);
                            setChargerMode(gun_index, MODE_CHARGING);
                        }
                    }

					if (isEvBoardStopChargeFlag(gun_index) == YES)
					{
						// 板端或後臺要求停止
					    PRINTF_FUNC("********** Gun %d Alarm Stop (S_PREPARING_FOR_EVSE) **********", gun_index + 1);
                        if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
                        {
                            strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "Local");
                        }
					    ChargingAlarmProcess(gun_index);
					}
                    else if(isNormalStopChargeFlag(gun_index) == YES)
                    {
                        PRINTF_FUNC("********** Gun %d Normal Stop (S_PREPARING_FOR_EVSE) %s**********", gun_index + 1,
                            chargingInfo[gun_index]->ChargingStopFlag.bits.ManualStop ? "(ManualStop)" : "");
                        if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
                        {
                            strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "EVDisconnected");
                        }
                        ChargingTerminalProcess(gun_index);
                    }
				}
					break;
				case S_CHARGING: // 剛進入充電狀態，等待 EV 小板要求的輸出電流後開始輸出
				{
					if (isModeChange(gun_index))
					{
					    PRINTF_FUNC("==================      S_CHARGING (%x)      ================== \n", gun_index + 1);
						StopGunInfoTimeoutDet(gun_index);
						ftime(&startChargingTime[gun_index]);
						ChangeStartOrStopDateTime(YES, gun_index);
						OcppStartTransation(gun_index);
					}

                    // only for test & debug purpose
                    if(ShmChargerInfo->Control.FCharging[gun_index].FCtrl.bits.EnableForceCharging)
                    {
                        float voltage = (float)ShmChargerInfo->Control.FCharging[gun_index].FTargetVoltage / 10;
                        float current = (float)ShmChargerInfo->Control.FCharging[gun_index].FTargetCurrent / 10;

                        if(chargingInfo[gun_index]->EvBatterytargetVoltage != voltage || chargingInfo[gun_index]->EvBatterytargetCurrent != current)
                        {
                            PRINTF_FUNC("Gun %d Set Force Charging Voltage %4d V, Current: %4d A", gun_index + 1, (int)voltage, (int)current);
                        }
                        chargingInfo[gun_index]->EvBatterytargetVoltage = voltage;
                        chargingInfo[gun_index]->EvBatterytargetCurrent = current;
                    }

					ftime(&endChargingTime[gun_index]);
					chargingInfo[gun_index]->PresentChargedDuration = DiffTimeb(startChargingTime[gun_index], endChargingTime[gun_index]);

                    // 計算 Power
                    //chargingInfo[gun_index]->PresentChargingPower = ((float)((chargingInfo[gun_index]->PresentChargingVoltage) * (chargingInfo[gun_index]->PresentChargingCurrent)) / 1000);
                    chargingInfo[gun_index]->PresentChargingPower = (((float)((ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteChargingVoltage) * (ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteChargingCurrent))) / 1000 / 100);

                    if (chargingTime[gun_index] == 0 || chargingTime[gun_index] > chargingInfo[gun_index]->PresentChargedDuration)
                    {
                        chargingTime[gun_index] = chargingInfo[gun_index]->PresentChargedDuration;
                    }
                    else
                    {
                        int passTime = chargingInfo[gun_index]->PresentChargedDuration - chargingTime[gun_index];

                        if(passTime > 0)
                        {
                            float changingPow = (chargingInfo[gun_index]->PresentChargingPower) * passTime / 3600;
                            if (ShmSysConfigAndInfo->SysConfig.BillingData.isBilling)
                            {
                                chargingInfo[gun_index]->ChargingFee += changingPow * ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee;
                            }

                            chargingInfo[gun_index]->PresentChargedEnergy += changingPow;
                            chargingInfo[gun_index]->PowerConsumption += changingPow;
                            chargingTime[gun_index] = chargingInfo[gun_index]->PresentChargedDuration;
                        }
                    }

					if (isEvBoardStopChargeFlag(gun_index))
					{
					    PRINTF_FUNC("********** Gun %d Alarm Stop (S_CHARGING) **********", gun_index + 1);
                        if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
                        {
                            strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "Local");
                        }
					    ChargingAlarmProcess(gun_index);
					}
                    else if(isNormalStopChargeFlag(gun_index) == YES)
                    {
                        PRINTF_FUNC("********** Gun %d Normal Stop (S_CHARGING) %s**********", gun_index + 1,
                            chargingInfo[gun_index]->ChargingStopFlag.bits.ManualStop ? "(ManualStop)" : "");
                        if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
                        {
                            strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "EVDisconnected");
                        }
                        ChargingTerminalProcess(gun_index);
                    }
					else if(CheckBackendChargingTimeout(gun_index) ||
                        CheckBackendChargingEnergy(gun_index) ||
                        (ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionConf &&
                        strcmp((char *)ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.Status, "Invalid") == EQUAL))
					{
					    PRINTF_FUNC("********** Gun %d Backend Stop (S_CHARGING) **********", gun_index + 1);
						// 板端或後臺要求停止
						ChargingTerminalProcess(gun_index);
					}

                    if(ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionConf)
                    {
                        ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionConf = NO;
                    }
				}
					break;
				case S_ALARM:
				case S_TERMINATING:
				{
					if (isModeChange(gun_index))
					{
                        if (strcmp((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "") == EQUAL)
                        {
                            strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, "Other");
                        }

                        if (chargingInfo[gun_index]->SystemStatus == S_ALARM)
                        {
                            PRINTF_FUNC("==================       S_ALARM (%x)        ================== \n", gun_index + 1);
                            UpdateErrorCodeToOcpp(gun_index);

                            if (strcmp((char *)chargingInfo[gun_index]->StartDateTime, "") != EQUAL)
                            {
                                OcppStopTransation(gun_index);
                            }

                            TheEndCharging(gun_index);
                        }
                        else
                        {
                            PRINTF_FUNC("==================    S_TERMINATING (%x)     ================== \n", gun_index + 1);
                        }

						StopGunInfoTimeoutDet(gun_index);
					}

                    if (chargingInfo[gun_index]->SystemStatus == S_ALARM)
                    {
                        if(GetTimeoutValue(chargingInfo[gun_index]->TimeoutTimer) >= 10000000)
                        {
                            if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable)
                            {
                                PRINTF_FUNC ("********** Gun %d psu is releasable **********\n", gun_index + 1);
                                ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable = true;
                            }
                        }

                        if((ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteStatus == _CRS_Idle || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Enable == false) &&
                            ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable)
                        {
                            setChargerMode(gun_index, MODE_IDLE);
                        }
                    }
                    else
                    {
                        setChargerMode(gun_index, MODE_COMPLETE);
                    }
				}
					break;
				case S_COMPLETE:
				{
					if (isModeChange(gun_index))
					{
					    PRINTF_FUNC("==================      S_COMPLETE (%x)      ================== \n", gun_index + 1);
						if (strcmp((char *)chargingInfo[gun_index]->StartDateTime, "") != EQUAL)
						{
							OcppStopTransation(gun_index);
						}

						TheEndCharging(gun_index);
					}

					if(GetTimeoutValue(chargingInfo[gun_index]->TimeoutTimer) >= 10000000)
					{
					    if(!ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable)
					    {
					        PRINTF_FUNC ("********** Gun %d psu is releasable **********\n", gun_index + 1);
					        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable = true;
					    }
					}

                    if((ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].RemoteStatus == _CRS_Idle || ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Enable == false) &&
                        ShmSysConfigAndInfo->SysInfo.ConnectorInfo[gun_index].Parameter.bits.PsuReleasable)
					{
						setChargerMode(gun_index, MODE_IDLE);
					}
				}
					break;

				case S_CCS_PRECHARGE_ST0:
					if (isModeChange(gun_index))
					{
						PRINTF_FUNC("CCS Precharge Processing 1....................%x \n", gun_index);
						StopGunInfoTimeoutDet(gun_index);
						StartGunInfoTimeoutDet(gun_index, Timeout_ForCcsPrechargeDet);
					}
					break;

				case S_CCS_PRECHARGE_ST1:
					if (isModeChange(gun_index))
					{
						PRINTF_FUNC("CCS Precharge Processing 2....................%x \n", gun_index);
					}
					break;
			}
		}

		if (ShmSysConfigAndInfo->SysInfo.SystemPage != _LCM_NONE)
		{
			ChangeLcmByIndex(ShmSysConfigAndInfo->SysInfo.SystemPage);
		}
		else
		{
			bool dcPageRun = true;

			if (dcPageRun)
				ChangeLcmByIndex(ShmSysConfigAndInfo->SysInfo.ConnectorPage);
		}

		write(wtdFd, "a", 1);
		usleep(whileLoopTime);
	}

	return FAIL;
}