/*
 * Module_LcmControl.c
 *
 * Created on : 2020-10-20
 * Update on : XXXX-XX-XX
 * Author : Folus Wen, Eason Yang
 * Version : D0.01
 *
 */

#include 	<sys/time.h>
#include	"define.h"
#include	"main.h"
#include 	"lcmComm_dgus.h"

//========================================
// Declare share memory
//========================================
struct SysConfigAndInfo			*ShmSysConfigAndInfo;
struct StatusCodeData 			*ShmStatusCodeData;
struct OCPP16Data				*ShmOCPP16Data;
struct OCPP20Data				*ShmOCPP20Data;
struct Charger					*ShmCharger;

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

//========================================
// Declare Control panel function
//========================================
void string2ByteArray(uint8_t *input, uint8_t *output);
void setCurrentPage(uint8_t page);
void setDisplayValue(uint16_t address, uint8_t value);
void setQRcodeContent(char *input, uint8_t length);
void setBatteryAnimation(uint8_t gun_index, uint8_t system_mode);
void setConnectionAnimation(uint8_t gun_index, uint8_t system_mode);
void setGunPluginAnimation(uint8_t gun_index);
void setPresentChargedDuration(uint8_t gun_index);
void setPresentChargedEnergy(uint8_t gun_index);
void setPresentChargingPower(uint8_t gun_index);
void setCurrencyUnit(char *unit);
void setPriceValue(float monry_rate);
void setWarningStatus(uint8_t gun_index);
void setBillingFromBackend(uint8_t gun_index);
void setFinalTotalCost(uint8_t gun_indxe);

uint8_t getCurrentPage();
void setEthernetIcon();
void setBackendIcon();
void setWifi4GIcon();
void setRfidIcon();
void setQRCodeIcon();
void setBillingFromWebsite();
void setRTC();
void setAlarmCodeAndIcon();


//========================================
// Declare Timer
//========================================
#define TMR_IDX_BATTERY					0
#define TMR_IDX_CONNECTION				1
#define TMR_IDX_PLUGIN					2
#define TMR_IDX_ALARM					3
#define TMR_IDX_4						4
#define TMR_IDX_5						5
#define TMR_IDX_6						6
#define TMR_IDX_7						7
#define TMR_IDX_8						8
#define TMR_IDX_9 						9

struct timeb					startTime[AC_QUANTITY][10];

#define TIME_ANIMATION_PLUGIN			1000
#define TIME_ANIMATION_BATTERY			1000
#define TIME_ANIMATION_CONNECTION		1000
#define TIME_ANIMATION_ALARM			5000

//========================================
// Declare variable
//========================================

uint8_t BATTERY_LEVEL_STATUS = BATTERY_LEVEL_5;
uint8_t CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
uint8_t GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_0;
uint8_t WarningCount = 255;
//uint8_t ChangeWarningRefresh;

int Uart1Fd;

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

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

	memset(Buf,0,sizeof(Buf));
	CurrentTime = time(NULL);
	tm=localtime(&CurrentTime);
	gettimeofday(&tv, NULL); // get microseconds, 10^-6

	sprintf(Buf,"echo -n \'[%04d.%02d.%02d %02d:%02d:%02d.%06ld]%s\' >> /Storage/SystemLog/[%04d.%02d]Module_LcmControlLog",
						tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,tv.tv_usec,
						buffer,
						tm->tm_year+1900,tm->tm_mon+1);

#ifdef SystemLogMessage
	system(Buf);
#endif

#ifdef ConsloePrintLog
	printf("[%04d.%02d.%02d %02d:%02d:%02d.%06ld]%s", tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,tv.tv_usec, buffer);
#endif

	return rc;
}

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

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

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

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

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

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

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

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

uint8_t split(char **arr, char *str, const char *del)
{
	uint8_t result = 0;
	char *s = strtok(str, del);

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

	printf("result : %d \r\n ", result);
	return result;
}

void getDateTimeString(char* result)
{
	time_t CurrentTime;
	struct tm *tm;

	CurrentTime = time(NULL);
	tm=localtime(&CurrentTime);

	sprintf(result, "%04d/%02d/%02d %02d:%02d", tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min);
}

//========================================
// Function to page routine
//========================================
void page_booting()
{
	if(getCurrentPage() != SYSTEM_SCREEN_BOOTING)
	{
		setCurrentPage(SYSTEM_SCREEN_BOOTING);
		DEBUG_INFO("Setting page to booting.\n");
	}
	else
	{
		//DEBUG_INFO("Page booting.\n");
	}

}

void page_idle()
{
	if(getCurrentPage() != SYSTEM_SCREEN_IDLE)
	{
		setCurrentPage(SYSTEM_SCREEN_IDLE);
		//DEBUG_INFO("Setting page to idle.\n");
	}
	else
	{
		setRfidIcon();
		setQRCodeIcon();
		//DEBUG_INFO("Page idle.\n");
	}
}

void page_authorizing(uint8_t gun_index)
{
	// Emulator
	uint8_t AUTHORIZE_STATUS = 0;

	// TO DO
	// Need to pass something into logic for checking authorizing results

	switch(AUTHORIZE_STATUS)
	{
		case VALIDATED_RFID:

			if(getCurrentPage() != SYSTEM_SCREEN_AUTH_PASS)
			{
				setCurrentPage(SYSTEM_SCREEN_AUTH_PASS);
				DEBUG_INFO("Setting page to authorizing : Validated RFID.\n");
			}
			else
			{
				DEBUG_INFO("Page authorizing validated.\n");
			}
			break;

		case UNVALIDATED_RFID:

			if(getCurrentPage() != SYSTEM_SCREEN_AUTH_FAIL)
			{
				setCurrentPage(SYSTEM_SCREEN_AUTH_FAIL);
				DEBUG_INFO("Setting page to authorizing : Unvalidated RFID.\n");
			}
			else
			{
				DEBUG_INFO("Page authorizing unvalidated.\n");
			}
			break;

		case UNKNOW_RFID:

			if(getCurrentPage() != SYSTEM_SCREEN_AUTH_UNKNOW)
			{
				setCurrentPage(SYSTEM_SCREEN_AUTH_UNKNOW);
				DEBUG_INFO("Setting page to authorizing : Unknow RFID\n");
			}
			else
			{
				DEBUG_INFO("Page authorizing unknow.\n");
			}
			break;
	}
}

void page_preparing(uint8_t gun_index, uint8_t system_mode)
{

	// Emulator
	uint8_t IS_NORMAL_MODE = 0;

	// TO DO
	// Need to pass something into logic for checking Normal mode / CCS mode

	if(IS_NORMAL_MODE == 0)
	{
		if((getCurrentPage() != SYSTEM_SCREEN_PREPARING))
		{
			setCurrentPage(SYSTEM_SCREEN_PREPARING);
			setDisplayValue(ICON_PLUGIN_ARROW, PLUGIN_ARROW_1);
			ftime(&startTime[gun_index][TMR_IDX_PLUGIN]);
			GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_0;

			DEBUG_INFO("Setting page to preparing.\n");
		}
		else
		{
			setGunPluginAnimation(gun_index);

			//DEBUG_INFO("Page preparing.\n");
		}
	}
	else
	{
		if((getCurrentPage() != SYSTEM_SCREEN_PREPARE_FOR_EVSE))
		{
			setCurrentPage(SYSTEM_SCREEN_PREPARE_FOR_EVSE);
			setDisplayValue(ICON_BATTERY_PRECHARGING, BATTERY_CAPACITY_EMPTY);
			setDisplayValue(ICON_CONNECTION_PRECHARGING, CONNECTION_QUESTION_MARK_1);
			ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
			CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;

			DEBUG_INFO("Setting page to prepare for EVSE.\n");
		}
		else
		{
			setConnectionAnimation(gun_index, system_mode);

			//DEBUG_INFO("Page pre-charging.\n");
		}
	}
}

void page_charging(uint8_t gun_index, uint8_t system_mode)
{
	if((getCurrentPage() != SYSTEM_SCREEN_CHARGING))
	{
		setCurrentPage(SYSTEM_SCREEN_CHARGING);
		setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_EMPTY);
		setDisplayValue(ICON_CONNECTION_CHARGING, CONNECTION_ELECTRIC_MARK_1);
		ftime(&startTime[gun_index][TMR_IDX_BATTERY]);
		ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
		BATTERY_LEVEL_STATUS = BATTERY_LEVEL_5;
		CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;

		DEBUG_INFO("Setting page to charging.\n");
	}
	else
	{
		setConnectionAnimation(gun_index, system_mode);
		setBatteryAnimation(gun_index, system_mode);
		setPresentChargedDuration(gun_index);
		setPresentChargedEnergy(gun_index);
		setPresentChargingPower(gun_index);

		//DEBUG_INFO("Page charging.\n");
	}
}

void page_complete(uint8_t gun_index)
{
	if(getCurrentPage() != SYSTEM_SCREEN_COMPLETE)
	{
		setCurrentPage(SYSTEM_SCREEN_COMPLETE);

		DEBUG_INFO("Setting page to complete.\n");
	}
	else
	{
		setDisplayValue(ICON_BATTERY_COMPLETE, BATTERY_SOC_100);
		setPresentChargedDuration(gun_index);
		setPresentChargedEnergy(gun_index);
		setFinalTotalCost(gun_index);

		//DEBUG_INFO("Page complete.\n");
	}
}

void page_terminating(uint8_t gun_index, uint8_t system_mode)
{
	if((getCurrentPage() != SYSTEM_SCREEN_TERMINATING))
	{
		setCurrentPage(SYSTEM_SCREEN_TERMINATING);
		setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_EMPTY);
		setDisplayValue(ICON_CONNECTION_CHARGING, CONNECTION_QUESTION_MARK_1);
		ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
		BATTERY_LEVEL_STATUS = BATTERY_LEVEL_5;
		CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;

		DEBUG_INFO("Setting page to terminating.\n");
	}
	else
	{
		setConnectionAnimation(gun_index, system_mode);
		setBatteryAnimation(gun_index, system_mode);
		setPresentChargedDuration(gun_index);
		setPresentChargedEnergy(gun_index);
		setPresentChargingPower(gun_index);

		//DEBUG_INFO("Page terminating.\n");
	}
}

void page_alarm()
{
	//DEBUG_INFO("Page alarm.\n");
}

void page_fault()
{
	DEBUG_INFO("Page fault.\n");
}

void page_maintain()
{
	if(getCurrentPage() != SYSTEM_SCREEN_MAINTAIN)
	{
		setCurrentPage(SYSTEM_SCREEN_MAINTAIN);

		DEBUG_INFO("Setting page to maintain.\n");
	}
	else
	{
		//DEBUG_INFO("Page maintain.\n");
	}
}

void page_update()
{
	if(getCurrentPage() != SYSTEM_SCREEN_MAINTAIN)
	{
		setCurrentPage(SYSTEM_SCREEN_MAINTAIN);

		DEBUG_INFO("Setting page to update.\n");
	}
	else
	{
		//DEBUG_INFO("Page update.\n");
	}
}

void page_reservation()
{
	DEBUG_INFO("Page reservation.\n");
}

void page_booking()
{
	DEBUG_INFO("Page booking.\n");
}

void page_debug()
{
	if(getCurrentPage() != SYSTEM_SCREEN_MAINTAIN)
	{
		setCurrentPage(SYSTEM_SCREEN_MAINTAIN);

		DEBUG_INFO("Setting page to debug.\n");
	}
	else
	{
		//DEBUG_INFO("Page debug.\n");
	}
}

void page_unknown()
{
	DEBUG_INFO("Page unknown.\n");
}

void page_header(uint8_t gun_index)
{

	setEthernetIcon();
	setBackendIcon();
	setWifi4GIcon();
	setRTC();
	setWarningStatus(gun_index);

	if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
	{
		setBillingFromWebsite();
	}
	else
	{
		setBillingFromBackend(gun_index);
	}

	//DEBUG_INFO("Page heading.\n");
}

//========================================
// Setting icon display value
//========================================
void setDisplayValue(uint16_t address, uint8_t value)
{
	uint8_t data[2];

	data[0] = value >> 8;
	data[1] = value & 0X00FF;

	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, address, data, ARRAY_SIZE(data));
}

//========================================
// Getting current page
//========================================
uint8_t getCurrentPage()
{
	uint8_t currentPage[2];
	uint8_t result = 255;

	if(lcdRegisterRead(Uart1Fd, REG_TYPE_CONTROL, REG_ADDRESS_READ_PAGE_ID, currentPage, ARRAY_SIZE(currentPage)))
	{
		// DEBUG_INFO("currentPage[0] : %X\n", currentPage[0]);
		// DEBUG_INFO("currentPage[1] : %X\n", currentPage[1]);
		result = currentPage[1];
		//DEBUG_INFO("getCurrentPage : %d \n", result);
	}
	else
	{
		DEBUG_INFO("Get current page fail! \n");
	}

	return result;
}

//========================================
// Setting current page
//========================================
void setCurrentPage(uint8_t page)
{
	uint8_t settingPage[2] = {0x00, page};

	if(lcdRegisterWrite(Uart1Fd, REG_TYPE_CONTROL, REG_ADDRESS_SET_PAGE_ID, settingPage, ARRAY_SIZE(settingPage)))
	{
		DEBUG_INFO("setCurrentPage : %d \n", page);
	}
	else
	{
		DEBUG_INFO("Setting current page fail! \n");
	}
}

//========================================
// Convert string to byte array
//========================================
void string2ByteArray(unsigned char *input, uint8_t *output)
{
    int loop;
    int i;

    loop = 0;
    i = 0;

    while(input[loop] != '\0')
    {
        output[i++] = input[loop++];
    }
}

//========================================
// Setting ETHERNET icon status online / off-line
//========================================
void setEthernetIcon()
{
	if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet == ON)
		setDisplayValue(ICON_ETHERENT_CONNECTION, ETHERENT_OFFLINE);
	else
		setDisplayValue(ICON_ETHERENT_CONNECTION, EHTERNET_ONLINE);
}

//========================================
// Setting BACKEND icon status online / off-line
//========================================
void setBackendIcon()
{
	if(ShmSysConfigAndInfo->SysInfo.OcppConnStatus != ON)
		setDisplayValue(ICON_BACKEND_CONNECTION,BACKEND_OFFLINE);
	else
		setDisplayValue(ICON_BACKEND_CONNECTION,BACKEND_ONLINE);
}

//========================================
// Setting WIFI / 4G icon status online / off-line
//========================================
void setWifi4GIcon()
{
	//==============================================
	// Setting WIFI + 4G icon status online / off-line
	//==============================================
	if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D')
	{
		if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode == DISABLE_WIFI)
		{
			if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == DISABLE_4G)
			{
				setDisplayValue(ICON_WIFI_CONNECTION, DISAPPEAR);
				setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
			}
			else
			{
				setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
				if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == ON)
					setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_OFFLINE);
				else
					setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_ONLINE);
			}
		}
		else
		{
			if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode == WIFI_STATION)
			{
				if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi == ON)
					setDisplayValue(ICON_WIFI_CONNECTION, WIFI_OFFLINE);
				else
					setDisplayValue(ICON_WIFI_CONNECTION, WIFI_ONLINE);
			}
			else
				setDisplayValue(ICON_WIFI_CONNECTION, WIFI_OFFLINE);

			if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == DISABLE_4G)
			{
				setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
			}
			else
			{
				if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == ON)
					setDisplayValue(ICON_4G_CONNECTION, TELECOM_OFFLINE);
				else
					setDisplayValue(ICON_4G_CONNECTION, TELECOM_ONLINE);
			}
		}
	}
	else
	{
		//========================================
		// Setting 4G icon status online / off-line
		//========================================
		if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T')
		{
			switch(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled)
			{
				case DISABLE_4G:

					setDisplayValue(ICON_WIFI_CONNECTION, DISAPPEAR);
					setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);

					break;
				case ENABLE_4G:

					if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == ON)
						setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_OFFLINE);
					else
						setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_ONLINE);

					break;
			}
		}

		//========================================
		// Setting WIFI icon status online / off-line
		//========================================
		if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W')
		{
			switch(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode)
			{
				case DISABLE_WIFI:

					setDisplayValue(ICON_WIFI_CONNECTION, DISAPPEAR);
					setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);

					break;
				case WIFI_STATION:

					if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi == ON)
						setDisplayValue(ICON_WIFI_CONNECTION, WIFI_OFFLINE);
					else
						setDisplayValue(ICON_WIFI_CONNECTION, WIFI_ONLINE);

					break;
				case WIFI_ACCESS_POINT:

					setDisplayValue(ICON_WIFI_CONNECTION, WIFI_OFFLINE);

					break;
			}
		}
	}
}

//========================================
// Setting billing icon status
//========================================
void setBillingFromWebsite()
{
	if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
	{
		setDisplayValue(ICON_PRICE, PRICE_APPEAR);

		struct timeb csuTime;
		struct tm *tmCSU;
		ftime(&csuTime);
		tmCSU = localtime(&csuTime.time);

		if(tmCSU->tm_hour <= 23)
		{
			ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee = ShmSysConfigAndInfo->SysConfig.BillingData.Fee[tmCSU->tm_hour];
			setPriceValue(ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee);
		}

		// Currency unit 53 countries
		if(ShmSysConfigAndInfo->SysConfig.BillingData.Currency <= 53)
		{
			setCurrencyUnit((char *)Currency[ShmSysConfigAndInfo->SysConfig.BillingData.Currency]);
		}
	}
	else
	{
		setDisplayValue(ICON_PRICE, PRICE_DISAPPEAR);
		setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
		setDisplayValue(TEXT_PRICE, DISAPPEAR);
	}
}

//========================================
// Setting billing from the backend
//========================================
void setBillingFromBackend(uint8_t gun_index)
{
	float Default_Price;
	float Set_User_Price;

	if(system("pidof -s OcppBackend > /dev/null") != 0)
	{
		setDisplayValue(ICON_PRICE, PRICE_DISAPPEAR);
		setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
		setDisplayValue(TEXT_PRICE, DISAPPEAR);
	}
	else
	{
		if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
		{
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				if((strcmp((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData,"") != 0))
				{
					setDisplayValue(ICON_PRICE, PRICE_APPEAR);

					Default_Price = atof((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData);
					Set_User_Price = atof((char *)ShmOCPP16Data->Cost.SetUserPrice.price);

					//DEBUG_INFO("Default_Price : %.2f \r\n", Default_Price);
					//DEBUG_INFO("Set_User_Price : %.2f \r\n", Set_User_Price);

					if((Set_User_Price != 0.0) &&
					   (Default_Price != Set_User_Price) &&
					   (strcmp((char*)ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId, (char *)ShmOCPP16Data->Cost.SetUserPrice.idToken) == 0))
					{
						setPriceValue(Set_User_Price);
					}
					else
					{
						setPriceValue(Default_Price);
					}
				}
			}
			else
			{
				/*
				 * TODO:
				 * 	1. Display default price by OCPP 2.0.1
				 */
			}
		}
		else
		{
			setDisplayValue(ICON_PRICE, PRICE_DISAPPEAR);
			setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
			setDisplayValue(TEXT_PRICE, DISAPPEAR);
		}
	}
}


//========================================
// Setting RTC value
//========================================
void setRTC()
{
	uint8_t data[32];
	uint8_t rtc[32];

	memset(data, 0x00, ARRAY_SIZE(data));
	memset(rtc, 0x00, ARRAY_SIZE(rtc));

	getDateTimeString((char*)rtc);

	string2ByteArray(rtc, data);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_RTC, data, ARRAY_SIZE(data));
}

//========================================
// Setting RFID icon status
//========================================
void setRfidIcon()
{
	//========================================
	// AX-Series Generation 1
	//========================================
	if((ShmSysConfigAndInfo->SysConfig.ModelName[0] == 'A') &&
	   (ShmSysConfigAndInfo->SysConfig.ModelName[1] == 'X') &&
	   (ShmSysConfigAndInfo->SysConfig.ModelName[11] == '1'))
	{
		if(ShmSysConfigAndInfo->SysConfig.isRFID == ON)
			setDisplayValue(ICON_RFID, RFID_ENABLE);
		else
			setDisplayValue(ICON_RFID, RFID_DISABLE);
	}

	//========================================
	// AX-Series Generation 2/3/4
	//========================================
	if((ShmSysConfigAndInfo->SysConfig.ModelName[0] == 'A') &&
	   (ShmSysConfigAndInfo->SysConfig.ModelName[1] == 'X') &&
	   ((ShmSysConfigAndInfo->SysConfig.ModelName[11] == '2') || (ShmSysConfigAndInfo->SysConfig.ModelName[11] == '3') || (ShmSysConfigAndInfo->SysConfig.ModelName[11] == '4')))
	{
		if(ShmSysConfigAndInfo->SysConfig.isRFID == ON)
			setDisplayValue(ICON_RFID, VISA_ENABLE);
		else
			setDisplayValue(ICON_RFID, VISA_DISABLE);
	}

	//========================================
	// AW-Series Generation
	//========================================
	if((ShmSysConfigAndInfo->SysConfig.ModelName[0] == 'A') &&
	   (ShmSysConfigAndInfo->SysConfig.ModelName[1] == 'w'))
	{
		if(ShmSysConfigAndInfo->SysConfig.isRFID == ON)
			setDisplayValue(ICON_RFID, RFID_ENABLE);
		else
			setDisplayValue(ICON_RFID, RFID_DISABLE);
	}
}

//========================================
// Setting QRCODE icon status
//========================================
void setQRCodeIcon()
{
	uint8_t length = 0;
	if(ShmSysConfigAndInfo->SysConfig.isQRCode == ON)
	{
		setDisplayValue(ICON_QRCODE,QRCODE_ENABLE);
		if(ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode == NO)
		{
			length = strlen((char *)ShmSysConfigAndInfo->SysConfig.SystemId);
			setQRcodeContent((char *)ShmSysConfigAndInfo->SysConfig.SystemId, length);
		}
		else
		{
			length = strlen((char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent);
			setQRcodeContent((char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent, length);
		}
	}
	else
	{
		setDisplayValue(TEXT_QRCODE_CONTENT, DISAPPEAR);
		setDisplayValue(ICON_QRCODE,QRCODE_DISABLE);
	}
}

//========================================
// Setting QR code content
//========================================
void setQRcodeContent(char *input, uint8_t length)
{
	uint8_t output[length];
	int loop = 0;

	input[length] = '\0';
	output[length] = '\0';

	while(input[loop] != '0')
	{
		output[loop] = input[loop];
		loop++;
	}

	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_QRCODE_CONTENT, output, ARRAY_SIZE(output)+1);
}

//========================================
// Setting alarm code and icon status
//========================================
void setWarningStatus(uint8_t gun_index)
{
	if(WarningCount != ShmSysConfigAndInfo->SysWarningInfo.WarningCount)
	{
		WarningCount = ShmSysConfigAndInfo->SysWarningInfo.WarningCount;
		ShmSysConfigAndInfo->SysWarningInfo.PageIndex = 0;

		setAlarmCodeAndIcon();
	}
	else if (ShmSysConfigAndInfo->SysWarningInfo.WarningCount > 4 && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_ALARM]) > (TIME_ANIMATION_ALARM)))
	{
		ftime(&startTime[gun_index][TMR_IDX_ALARM]);
		if(ShmSysConfigAndInfo->SysWarningInfo.PageIndex == 0)
			ShmSysConfigAndInfo->SysWarningInfo.PageIndex = 1;
		else
			ShmSysConfigAndInfo->SysWarningInfo.PageIndex = 0;

		setAlarmCodeAndIcon();
	}
}


//========================================
// Setting alarm code and icon status
//========================================
void setAlarmCodeAndIcon()
{
	uint8_t cmd[7];
	uint8_t index = 0;

	for(index = 0; (index + ShmSysConfigAndInfo->SysWarningInfo.PageIndex * 4) < ShmSysConfigAndInfo->SysWarningInfo.WarningCount; index++)
	{
		memset(cmd, 0x00, sizeof(cmd));
		if(index >= 4)
		{
			break;
		}
		// Alarm code
		string2ByteArray(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[index + ShmSysConfigAndInfo->SysWarningInfo.PageIndex * 4][0], cmd);
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_ALARM_CODE_1 + (index * 6), cmd, ARRAY_SIZE(cmd));

		// Icon status
		memset(cmd, 0x00, sizeof(cmd));

		cmd[0] = 0x00;
		cmd[1] = 0x01;
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, ICON_ALARM_1 + index, cmd, 2);
	}

	memset(cmd, 0x00, sizeof(cmd));
	for(; index < 4; index++)
	{
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_ALARM_CODE_1 + (index * 6), cmd, ARRAY_SIZE(cmd));
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, ICON_ALARM_1 + index, cmd, 2);
	}
}

//========================================
// Setting Battery icon animation
//========================================
void setBatteryAnimation(uint8_t gun_index, uint8_t system_mode)
{
	switch(system_mode)
	{
		case SYS_MODE_CHARGING:

			if((BATTERY_LEVEL_STATUS == BATTERY_LEVEL_5))
			{
				setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_EMPTY);
				BATTERY_LEVEL_STATUS = BATTERY_LEVEL_0;
			}
			else if((BATTERY_LEVEL_STATUS == BATTERY_LEVEL_0) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_BATTERY]) > (TIME_ANIMATION_BATTERY)))
			{
				setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_20);
				BATTERY_LEVEL_STATUS = BATTERY_LEVEL_1;
			}
			else if((BATTERY_LEVEL_STATUS == BATTERY_LEVEL_1) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_BATTERY]) > (TIME_ANIMATION_BATTERY*2)))
			{
				setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_40);
				BATTERY_LEVEL_STATUS = BATTERY_LEVEL_2;
			}
			else if((BATTERY_LEVEL_STATUS == BATTERY_LEVEL_2) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_BATTERY]) > (TIME_ANIMATION_BATTERY*3)))
			{
				setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_60);
				BATTERY_LEVEL_STATUS = BATTERY_LEVEL_3;
			}
			else if((BATTERY_LEVEL_STATUS == BATTERY_LEVEL_3) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_BATTERY]) > (TIME_ANIMATION_BATTERY*4)))
			{
				setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_80);
				BATTERY_LEVEL_STATUS = BATTERY_LEVEL_4;
			}
			else if((BATTERY_LEVEL_STATUS == BATTERY_LEVEL_4) &&  (DiffTimebWithNow(startTime[gun_index][TMR_IDX_BATTERY]) > (TIME_ANIMATION_BATTERY*5)))
			{
				setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_100);
				BATTERY_LEVEL_STATUS = BATTERY_LEVEL_5;
				ftime(&startTime[gun_index][TMR_IDX_BATTERY]);
			}

			break;

		case SYS_MODE_TERMINATING:

			setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_EMPTY);

			break;
	}
}

//========================================
// Setting connection icon animation
//========================================
void setConnectionAnimation(uint8_t gun_index, uint8_t system_mode)
{
	switch(system_mode)
	{
		case SYS_MODE_PREPARING:

			if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
			{
				setDisplayValue(ICON_CONNECTION_PRECHARGING, CONNECTION_QUESTION_MARK_1);
				CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_1;
			}
			else if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_1) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
			{
				setDisplayValue(ICON_CONNECTION_PRECHARGING, CONNECTION_QUESTION_MARK_2);
				CONNECTION_LEVEL_STATUS =  CONNECTION_LEVEL_0;
				ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
			}

			break;

		case SYS_MODE_CHARGING:

			if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
			{
				setDisplayValue(ICON_CONNECTION_CHARGING, CONNECTION_ELECTRIC_MARK_1);
				CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_1;
			}
			else if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_1) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
			{
				setDisplayValue(ICON_CONNECTION_CHARGING, CONNECTION_ELECTRIC_MARK_2);
				CONNECTION_LEVEL_STATUS =  CONNECTION_LEVEL_0;
				ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
			}

			break;

		case SYS_MODE_TERMINATING:

			if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
			{
				setDisplayValue(ICON_CONNECTION_CHARGING, CONNECTION_QUESTION_MARK_1);
				CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_1;
			}
			else if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_1) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
			{
				setDisplayValue(ICON_CONNECTION_CHARGING, CONNECTION_QUESTION_MARK_2);
				CONNECTION_LEVEL_STATUS =  CONNECTION_LEVEL_0;
				ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
			}

			break;
	}
}

//========================================
// Setting gun plug-in arrow animation
//========================================
void setGunPluginAnimation(uint8_t gun_index)
{
	if(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState != CP_STATE_B)
	{
		if((GUN_PLUGING_LEVEL_STATUS ==  GUN_PLUGING_LEVEL_0) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_PLUGIN]) > (TIME_ANIMATION_PLUGIN)))
		{
			setDisplayValue(ICON_PLUGIN_ARROW, PLUGIN_ARROW_1);
			GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_1;
		}
		else if((GUN_PLUGING_LEVEL_STATUS ==  GUN_PLUGING_LEVEL_1) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_PLUGIN]) > (TIME_ANIMATION_PLUGIN*2)))
		{
			setDisplayValue(ICON_PLUGIN_ARROW, PLUGIN_ARROW_2);
			GUN_PLUGING_LEVEL_STATUS =  GUN_PLUGING_LEVEL_0;
			ftime(&startTime[gun_index][TMR_IDX_PLUGIN]);
		}
	}
	else
	{
		setDisplayValue(ICON_PLUGIN_ARROW, PLUGIN_ARROW_2);
	}
}

//========================================
// Setting present charging power
//========================================
void setPresentChargingPower(uint8_t gun_index)
{
	uint8_t data[16];
	uint8_t power[16];

	memset(data, 0x00, ARRAY_SIZE(data));
	memset(power, 0x00, ARRAY_SIZE(power));

	sprintf((char *)power, "%.2f kW", ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargingPower);
	string2ByteArray(power, data);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_POWER_CHARGING, data, ARRAY_SIZE(data));
}

//========================================
// Setting present charged energy
//========================================
void setPresentChargedEnergy(uint8_t gun_index)
{
	uint8_t data[16];
	uint8_t energy[16];

	memset(data, 0x00, ARRAY_SIZE(data));
	memset(energy, 0x00, ARRAY_SIZE(energy));

	sprintf((char *)energy, "%.4f kWh", ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargedEnergy);
	string2ByteArray(energy, data);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_ENERGY_CHARGING, data, ARRAY_SIZE(data));
}

//========================================
// Setting present charged duration
//========================================
void setPresentChargedDuration(uint8_t gun_index)
{
	uint8_t data[16];
	uint8_t time[16];
	uint16_t hour;
	uint16_t minute;
	uint16_t second;
	uint16_t PresentChargedDuration = ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargedDuration;

	memset(data, 0x00, ARRAY_SIZE(data));
	memset(time, 0x00, ARRAY_SIZE(time));

	hour = (PresentChargedDuration / 3600);
	minute = (PresentChargedDuration - (3600 * hour)) / 60;
	second = (PresentChargedDuration - (3600 * hour) - (minute * 60));

	sprintf((char *)time, "%02d:%02d:%02d", hour, minute, second);
	string2ByteArray(time, data);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_TIMER_CHARGING, data, ARRAY_SIZE(data));
}

//========================================
// Setting currency value
//========================================
void setCurrencyUnit(char *unit)
{
	uint8_t data[16];
	uint8_t currency[16];

	memset(data, 0x00, ARRAY_SIZE(data));
	memset(currency, 0x00, ARRAY_SIZE(currency));

	*(unit + 3) = '\0';
	sprintf((char *) currency, "%s", unit);
	string2ByteArray(currency, data);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CURRENCY_UNIT, data, ARRAY_SIZE(data));
}

//========================================
// Setting present price from web site
//========================================
void setPriceValue(float monry_rate)
{
	uint8_t data[16];
	uint8_t price[16];

	memset(data, 0x00, ARRAY_SIZE(data));
	memset(price, 0x00, ARRAY_SIZE(price));

	sprintf((char *)price, "%.2f", monry_rate);
	string2ByteArray(price, data);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRICE, data, ARRAY_SIZE(data));
}

//========================================
// Setting final total cost (From backend)
//========================================
void setFinalTotalCost(uint8_t gun_indxe)
{
	uint8_t data[32];
	uint8_t balance[32];
	char org_data[256];
	char tmp[256];
	char *splitString[10];
	const char *Symbol = ";";
	uint8_t Split_String_Count;
	uint8_t isEmulator = YES; // Emulator ON : YES OFF : NO
	// Emulator

	memset(tmp, 0, ARRAY_SIZE(tmp));
	memset(balance, 0x00, ARRAY_SIZE(balance));

	if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
	{
		if(strcmp((char *)&ShmOCPP16Data->Cost.FinalCost[gun_indxe].description,"") != 0)
		{
			strcpy((char*)tmp,(char*)ShmOCPP16Data->Cost.FinalCost[gun_indxe].description);
			Split_String_Count = split((char**)splitString, tmp, Symbol);

			//DEBUG_INFO("String split into %d\n", Split_String_Count);

			/*
			for(uint8_t idx=0;idx<Split_String_Count;idx++)
			{
				DEBUG_INFO("splitStr[%d]: %s\r\n", idx, splitString[idx]);
			}
			*/
			sscanf(splitString[3],"%*s%*s%s",balance);
			memcpy(data, balance + 1,ARRAY_SIZE(balance));
			//DEBUG_INFO("data : %s \r\n", data);

			lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_COST_COMPLETE, data, ARRAY_SIZE(data));
		}

		// Emulator
		if(isEmulator == YES)
		{
			sprintf((char*)org_data, "FinalCos: Connection Fee: $0 NTD;Session Fee: $2.81 NTD;Occupancy Fee: $0 NTD;Total Cost: $1000.81 NTD;Account Balance: $19500 NTD");
			strcpy((char*)tmp,(char*)org_data);
			Split_String_Count = split((char**)splitString, tmp, Symbol);

			//DEBUG_INFO("String split to %d\n", Split_First_String);
			for(uint8_t idx=0;idx<Split_String_Count;idx++)
			{
				DEBUG_INFO("splitString[%d]: %s \r\n", idx, splitString[idx]);
			}

			sscanf(splitString[3],"%*s%*s%s",balance);
			memcpy(data, balance + 1,ARRAY_SIZE(balance));
			DEBUG_INFO("data : %s \r\n", data);
			lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_COST_COMPLETE, data, ARRAY_SIZE(data));
		}
	}
	else
	{
		/*
		 * TODO:
		 * 	1. Display final cost by OCPP 2.0.1
		 */
	}
}

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

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

   	// Initial ShmStatusCodeData
   	if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData), 0777)) < 0)
    {
   		DEBUG_ERROR("shmget ShmStatusCodeData NG\n");
   		result = FAIL;
	}
    else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
    	DEBUG_ERROR("shmat ShmStatusCodeData NG\n");
    	result = FAIL;
   	}
    else
    {}

   	// Initial ShmCharger
	if ((MeterSMId = shmget(ShmChargerKey, sizeof(struct Charger), 0777)) < 0)
	{
		DEBUG_ERROR("shmget ShmChargerKey NG\r\n");
		result = FAIL;
	}
	else if ((ShmCharger = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		DEBUG_ERROR("shmat ShmChargerKey NG\r\n");
		result = FAIL;
	}

	// Initial ShmOCPP16Data
	if ((MeterSMId = shmget(ShmOcppModuleKey, sizeof(struct OCPP16Data), 0777)) < 0)
	{
		DEBUG_ERROR("shmget ShmOCPP16Data NG\n");
		result = FAIL;
	}
	else if ((ShmOCPP16Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		DEBUG_ERROR("shmat ShmOCPP16Data NG\n");
		result = FAIL;
	}

	// Initial ShmOCPP20Data
	if ((MeterSMId = shmget(ShmOcpp20ModuleKey, sizeof(struct OCPP20Data), 0777)) < 0)
	{
		DEBUG_ERROR("shmget ShmOCPP20Data NG\n");
		result = FAIL;
	}
	else if ((ShmOCPP20Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		DEBUG_ERROR("shmat ShmOCPP20Data NG\n");
		result = FAIL;
	}

    return result;
}

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

	fd = open("/dev/ttyS3", O_RDWR);
	if(fd<=0)
	{
		DEBUG_ERROR("open /dev/ttyS3 NG\n");
		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)5;		// timeout 500ms
	tios.c_lflag=0;
	tcflush(fd, TCIFLUSH);
	ioctl (fd, TCSETS, &tios);

	return fd;
}

//========================================
// Main process
//========================================
int main(void)
{
	uint8_t previousMode = 0xff;

	if(InitShareMemory() == FAIL)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("InitShareMemory NG\n");
		#endif
		if(ShmStatusCodeData!=NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory=1;
		}
		sleep(5);
		return FAIL;
	}

	Uart1Fd=InitComPort();
	if(Uart1Fd<0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("InitComPort NG\n");
		#endif
		if(ShmStatusCodeData!=NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
		}
		sleep(5);
		return FAIL;
	}
	else
	{}

	DEBUG_INFO("Initial completed\n");

	for(;;)
	{
		if(previousMode != ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus)
		{
			previousMode = ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus;
		}

		switch(ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus)
		{
			case SYS_MODE_BOOTING:
				page_booting();
				break;
			case SYS_MODE_IDLE:
				page_idle();
				break;
			case SYS_MODE_AUTHORIZING:
				page_authorizing(ShmCharger->gun_selectd);
				break;
			case SYS_MODE_PREPARING:
				page_preparing(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
				break;
			case SYS_MODE_CHARGING:
				page_charging(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
				break;
			case SYS_MODE_TERMINATING:
				page_terminating(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
				break;
			case SYS_MODE_COMPLETE:
				page_complete(ShmCharger->gun_selectd);
				break;
			case SYS_MODE_ALARM:
				page_alarm();
				break;
			case SYS_MODE_FAULT:
				page_fault();
				break;
			case SYS_MODE_MAINTAIN:
				page_maintain();
				break;
			case SYS_MODE_UPDATE:
				page_update();
				break;
			case SYS_MODE_RESERVATION:
				page_reservation();
				break;
			case SYS_MODE_BOOKING:
				page_booking();
				break;
			case SYS_MODE_DEBUG:
				page_debug();
				break;
			default:
				page_unknown();
				break;
		}

		page_header(ShmCharger->gun_selectd);
		usleep(100000);
	}

	return FAIL;
}