csu3_am335x/EVSE/Projects/AW-CCS/Apps/LCM/Module_LcmControl.c

/*
 * Module_LcmControl.c
 *
 * Created on : 2020-10-20
 * Update on : 2021-12-14
 * Author : Folus Wen, Eason Yang
 * Version : V0.24
 *
 */

#include 	<sys/time.h>
#include	"define.h"
#include	"main.h"
#include 	"lcmComm_dgus.h"
#include	"cbmp.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);
void string2ByteArray(uint8_t *input, uint8_t *output);

//=======================================
// Declare Control panel function
//=======================================
void setRTC();
void setRfidIcon();
void setWifi4GIcon();
void setQRCodeIcon();
void setBackendIcon();
void setQRCodeAlarm();
void setEthernetIcon();
uint8_t getCurrentPage();
void setAlarmCodeAndIcon();
void setBillingFromWebsite();
int isEthConnected(char *eth);
void setUserPrice(uint8_t type);
void setCurrentPage(uint8_t page);
void setDefaultPrice(uint8_t type);
void setPresentFinalCost(float cost);
void setTextToEmpty(uint8_t gun_index);
void setWarningStatus(uint8_t gun_index);
void setQRCodeReceipt(uint8_t gun_index);
void setCurrencyFromWebsite(uint8_t unit);
void setPriceFromWebsite(float monry_rate);
void setAuthorizationPage(uint8_t gun_index);
float getPresentFinalCost(uint8_t gun_index);
void setGunPluginAnimation(uint8_t gun_index);
void setPresentChargedEnergy(uint8_t gun_index);
void setPresentChargedgPower(uint8_t gun_index);
void setPlugAndChargeAnimation(uint8_t gun_index);
void setPresentChargedDuration(uint8_t gun_index);
void setPresentPowerConsumption(uint8_t gun_index);
void setFinalCost(uint8_t gun_index, uint8_t type);
void setPresentConnectionTimeout(uint8_t gun_index);
void setRunningCost(uint8_t gun_index, uint8_t type);
void setDisplayValue(uint16_t address, uint8_t value);
void setDisplayValue2(uint16_t address, uint8_t value);
void setDefaultValue(uint8_t gun_index, uint8_t system_mode);
void setQRcodeContent(char *input, uint8_t length, uint8_t mode);
void setBillingFromBackend(uint8_t gun_index, uint8_t system_mode);
void setConnectionAnimation(uint8_t gun_index, uint8_t system_mode);
void setMarqueeControl(uint16_t address, uint8_t gun_index, uint8_t type);
void setCurrencyAndUnitFromBackend(uint8_t type_price,uint8_t type_currency_unit, uint8_t gun_index);

//=======================================
// Declare Timer
//=======================================
enum TMR_IDX
{
	TMR_IDX_0=0,
	TMR_IDX_CONNECTION,
	TMR_IDX_PLUGIN,
	TMR_IDX_ALARM,
	TMR_IDX_PRICE,
	TMR_IDX_5,
	TMR_IDX_6,
	TMR_IDX_7,
	TMR_IDX_8,
	TMR_IDX_SHOW_AUTH_RESULT
};

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
#define TIME_REFRESH_TIME				5000
#define TIME_AUTH_RESULT_TIME			5000

//=======================================
// Declare Variable
//=======================================
uint8_t CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
uint8_t GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_0;
uint8_t WarningCount = 255;

int Uart1Fd;

//=======================================
// Record version and date
//=======================================
char *FIRMWARE_UPDATE_IMAGE[3] = {"V0.24", "2021-12-14", "REV.02.00"};

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

void trim_string(char *s, unsigned char len)
{
	for(unsigned char i = 0 ; i < len; i++)
	{
		if (!(s[i] =='.')&& !((s[i]>='0') && (s[i]<='9')))
		{
			s[i] = s[i + 1];
			strncpy(s + i, s + i + 1, len);
			i -= 1;
			len -= 1;
		}
	}
	s[len + 1] = '\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);
	}

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

//======================================================
// OCPP routine
//======================================================
uint8_t ocpp_get_isRemoteStartWait()
{
	uint8_t result = OFF;

	if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
	{
		result = ShmOCPP16Data->MsMsg.bits.isRemoteStartWaitReq;
	}
	else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
	{
		result = ShmOCPP20Data->MsMsg.bits.isRemoteStartWaitReq;
	}

	return result;
}

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

void page_idle(uint8_t gun_index, uint8_t system_mode)
{
	if(ocpp_get_isRemoteStartWait())
	{
		if((getCurrentPage() != SYSTEM_SCREEN_PREPARING))
		{
			setCurrentPage(SYSTEM_SCREEN_PREPARING);
			DEBUG_INFO("Setting page to preparing.\n");
			DEBUG_INFO("Remote Start Transaction without connector Id.\n");
		}
		else
		{
			setPresentConnectionTimeout(gun_index);
			setConnectionAnimation(gun_index, system_mode);
			setGunPluginAnimation(gun_index);
		}
	}
	else
	{
		if(ShmCharger->gun_info[gun_index].isSleepOn == YES)
		{
			if((getCurrentPage() != SYSTEM_SCREEN_SLEEP))
			{
				setCurrentPage(SYSTEM_SCREEN_SLEEP);
			}
			else
			{}
		}
		else
		{
			if(ShmCharger->gun_info[gun_index].isCheckPowerConsumption == YES)
			{
				setCurrentPage(SYSTEM_SCREEN_POWER_CONSUMPTION);
				setDisplayValue(ICON_POWER_CONSUMPTION, APPEAR);
				setPresentPowerConsumption(gun_index);
			}
			else
			{
				if(ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_DISABLE)
				{
					if((getCurrentPage() != SYSTEM_SCREEN_PLUG_AND_CHARGE))
					{
						setCurrentPage(SYSTEM_SCREEN_PLUG_AND_CHARGE);
					}
					else
					{
						setPlugAndChargeAnimation(gun_index);
					}
				}
				else
				{
					if((getCurrentPage() != SYSTEM_SCREEN_IDLE) && (ShmCharger->gun_info[gun_index].resultAuthorization != VALIDATED_RFID))
					{
						setCurrentPage(SYSTEM_SCREEN_IDLE);
						setDefaultValue(gun_index, system_mode);
						DEBUG_INFO("Setting page to idle.\n");
					}
					else
					{
						setRfidIcon();
						setQRCodeIcon();
						setConnectionAnimation(gun_index, system_mode);
					}
				}
			}
		}
	}
}

void page_authorizing(uint8_t gun_index)
{
	setAuthorizationPage(gun_index);
	if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
	{
		if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
		{
			if((strcmp((char*)ShmSysConfigAndInfo->SysConfig.UserId, (char *)ShmOCPP16Data->Cost.SetUserPrice.idToken) == 0) && ((strcmp((char *)ShmOCPP16Data->Cost.SetUserPrice.idToken,"") != 0)))
			{
				setUserPrice(ACCOUNT_BALANCE);
			}
			else
			{
				setDisplayValue(ICON_USER_ACCOUNT_BALANCE, DISAPPEAR);
				setDisplayValue(TEXT_USER_ACCOUNT_BALANCE, DISAPPEAR);
			}
		}
		else
		{
			// DISPLAY BY OCPP 2.0.1
		}
	}
	else
	{
		setDisplayValue(ICON_USER_ACCOUNT_BALANCE, DISAPPEAR);
		setDisplayValue(TEXT_USER_ACCOUNT_BALANCE, DISAPPEAR);
	}
}

void page_preparing(uint8_t gun_index, uint8_t system_mode)
{
	if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
	{
		if((getCurrentPage() != SYSTEM_SCREEN_PREPARE_FOR_EVSE))
		{
			setCurrentPage(SYSTEM_SCREEN_PREPARE_FOR_EVSE);
			setDefaultValue(gun_index, system_mode);
			DEBUG_INFO("Setting page to prepare for EVSE.\n");
		}
		else
		{
			setConnectionAnimation(gun_index, system_mode);
		}
	}
	else
	{
		if((getCurrentPage() != SYSTEM_SCREEN_PREPARING))
		{
			setCurrentPage(SYSTEM_SCREEN_PREPARING);
			setDefaultValue(gun_index, system_mode);
			DEBUG_INFO("Setting page to preparing.\n");
		}
		else
		{
			setPresentConnectionTimeout(gun_index);
			setConnectionAnimation(gun_index, system_mode);
			setGunPluginAnimation(gun_index);
		}
	}
}

void page_charging(uint8_t gun_index, uint8_t system_mode)
{
	if((getCurrentPage() != SYSTEM_SCREEN_CHARGING) && (!ShmCharger->isAuthrizing && !ShmCharger->isGetAuthResult))
	{
		setCurrentPage(SYSTEM_SCREEN_CHARGING);
		setDefaultValue(gun_index, system_mode);
		DEBUG_INFO("Setting page to charging.\n");
	}
	else
	{
		setConnectionAnimation(gun_index, system_mode);
		setPresentChargedDuration(gun_index);
		setPresentChargedEnergy(gun_index);
		setPresentChargedgPower(gun_index);

		if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
		{
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				setRunningCost(gun_index, TOTAL_COST);
			}
			else
			{
				// DISPLAY BY OCPP 2.0.1
			}
		}
		else
		{
			if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
			{
				setDisplayValue(ICON_CHARGING_COST, APPEAR);
				setPresentFinalCost(getPresentFinalCost(gun_index));
			}
			else
			{
				// User spend cost
				setDisplayValue(ICON_CHARGING_COST, DISAPPEAR);
				setDisplayValue(TEXT_CHARGING_COST, DISAPPEAR);

				// User account balance
				setDisplayValue(ICON_COMPLETE_WALLET, DISAPPEAR);
				setDisplayValue(TEXT_REMAINING_ACCOUNT_BALANCE, DISAPPEAR);
			}
		}
	}
}

void page_complete(uint8_t gun_index, uint8_t system_mode)
{
	if((strcmp((char *)&ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL,"") == 0))
	{
		if(getCurrentPage() != SYSTEM_SCREEN_COMPLETE)
		{
			setCurrentPage(SYSTEM_SCREEN_COMPLETE);
			DEBUG_INFO("Setting page to complete.\n");
		}
		else
		{}
	}
	else
	{
		if(getCurrentPage() != SYSTEM_SCREEN_COMPLETE_WITH_QRCODE)
		{
			setCurrentPage(SYSTEM_SCREEN_COMPLETE_WITH_QRCODE);
			setQRCodeReceipt(gun_index);
			DEBUG_INFO("Setting page to complete with receipt qr code.\n");
		}
		else
		{
			setQRCodeReceipt(gun_index);
		}
	}

	setPresentChargedDuration(gun_index);
	setPresentChargedEnergy(gun_index);

	if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
	{
		if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
		{
			setFinalCost(gun_index, TOTAL_COST);
			setFinalCost(gun_index, ACCOUNT_BALANCE);
			//setCurrencyAndUnitFromBackend(FINAL_COST, ACCOUNT_BALANCE, gun_index);
		}
		else
		{
			// DISPLAY BY OCPP 2.0.1
		}
	}
	else
	{
		if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
		{
			setDisplayValue(ICON_CHARGING_COST, APPEAR);
			setPresentFinalCost(getPresentFinalCost(gun_index));

			setDisplayValue(ICON_COMPLETE_WALLET, DISAPPEAR);
			setDisplayValue(TEXT_REMAINING_ACCOUNT_BALANCE, DISAPPEAR);
		}
		else
		{
			// User spend cost
			setDisplayValue(ICON_CHARGING_COST, DISAPPEAR);
			setDisplayValue(TEXT_CHARGING_COST, DISAPPEAR);

			// User account balance
			setDisplayValue(ICON_COMPLETE_WALLET, DISAPPEAR);
			setDisplayValue(TEXT_REMAINING_ACCOUNT_BALANCE, DISAPPEAR);
		}
	}
}

void page_terminating(uint8_t gun_index, uint8_t system_mode)
{
	if((getCurrentPage() != SYSTEM_SCREEN_TERMINATING) && (!ShmCharger->isAuthrizing && !ShmCharger->isGetAuthResult))
	{
		setCurrentPage(SYSTEM_SCREEN_TERMINATING);
		setDefaultValue(gun_index, system_mode);
		DEBUG_INFO("Setting page to terminating.\n");
	}
	else
	{
		setPresentChargedDuration(gun_index);
		setPresentChargedEnergy(gun_index);
		setPresentChargedgPower(gun_index);

		if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
		{
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				setRunningCost(gun_index, TOTAL_COST);
			}
			else
			{
				// DISPLAY BY OCPP 2.0.1
			}
		}
		else
		{
			if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
			{
				setDisplayValue(ICON_CHARGING_COST, APPEAR);
				setPresentFinalCost(getPresentFinalCost(gun_index));
			}
			else
			{
				// User spend cost
				setDisplayValue(ICON_CHARGING_COST, DISAPPEAR);
				setDisplayValue(TEXT_CHARGING_COST, DISAPPEAR);

				// User account balance
				setDisplayValue(ICON_COMPLETE_WALLET, DISAPPEAR);
				setDisplayValue(TEXT_REMAINING_ACCOUNT_BALANCE, DISAPPEAR);
			}
		}
	}
}

void page_alarm()
{
	if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip != ON)
	{
		if(getCurrentPage() != SYSTEM_SCREEN_ALARM)
		{
			setCurrentPage(SYSTEM_SCREEN_ALARM);
			setQRCodeAlarm();
			DEBUG_INFO("Setting page to alarm.\n");
		}
		else
		{
			setQRCodeAlarm();
		}
	}
	else
	{
		if(getCurrentPage() != SYSTEM_SCREEN_EMERGENCY)
		{
			setCurrentPage(SYSTEM_SCREEN_EMERGENCY);
			DEBUG_INFO("Setting page to emergency.\n");
		}
		else
		{}
	}
}

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

void page_maintain()
{
	if(getCurrentPage() != SYSTEM_SCREEN_MAINTENANCE)
	{
		setCurrentPage(SYSTEM_SCREEN_MAINTENANCE);
		DEBUG_INFO("Setting page to maintain.\n");
	}
	else
	{}
}

void page_update()
{
	if(getCurrentPage() != SYSTEM_SCREEN_MAINTENANCE)
	{
		setCurrentPage(SYSTEM_SCREEN_MAINTENANCE);
		DEBUG_INFO("Setting page to update.\n");
	}
	else
	{}
}

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

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

void page_debug()
{
	if(getCurrentPage() != SYSTEM_SCREEN_MAINTENANCE)
	{
		setCurrentPage(SYSTEM_SCREEN_MAINTENANCE);
		DEBUG_INFO("Setting page to debug.\n");
	}
	else
	{}
}

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

void page_header(uint8_t gun_index, uint8_t system_mode)
{
	setEthernetIcon();
	setBackendIcon();
	setWifi4GIcon();
	setWarningStatus(gun_index);

	// CHANGE LCD BRIGHNESS ( POWER SAVING MODE )
	if((ShmCharger->isLcdOn == ON))
		setDisplayValue(REG_ADDRESS_WRITE_BRIGHTNESS,BRIGHTNESS_100);
	else
		setDisplayValue(REG_ADDRESS_WRITE_BRIGHTNESS,BRIGHTNESS_10);

	// SET BILLING
	if((ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON) && (ShmSysConfigAndInfo->SysInfo.OcppConnStatus != ON))
	{
		setBillingFromWebsite();
		setDisplayValue2(MARQUEES_DEFAULT_PRICE, DISAPPEAR);
	}
	else
	{
		// EVERY 5 SECONDS TO UPDATE PRICE
		if(DiffTimebWithNow(startTime[gun_index][TMR_IDX_PRICE]) > (TIME_REFRESH_TIME))
		{
			ftime(&startTime[gun_index][TMR_IDX_PRICE]);
			setBillingFromBackend(gun_index, system_mode);
		}
	}
}

void page_footer()
{
	setRTC();
}

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

void setDisplayValue2(uint16_t address, uint8_t value)
{
	uint8_t data[4];

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

	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (address+3), 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)))
	{
		result = currentPage[1];

		// DEBUG_INFO("currentPage[0] : %X\n", currentPage[0]);
		// DEBUG_INFO("currentPage[1] : %X\n", currentPage[1]);
		// DEBUG_INFO("Getting current page : [%d] \n", result);
	}
	else
	{
		DEBUG_INFO("Getting 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)))
	{
		if((ShmCharger->gun_info[0].isSleepOn == YES) || (ShmCharger->gun_info[1].isSleepOn == YES))
		{

		}
		else
		{
			DEBUG_INFO("Setting current page to : [%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++];
    }
    output[loop] = '\0';
}

//=======================================
// Setting [ RFID ] Icon Status
//=======================================
void setRfidIcon()
{
	if(ShmSysConfigAndInfo->SysConfig.isRFID == ON)
		setDisplayValue(ICON_RFID, RFID_ENABLE);
	else
		setDisplayValue(ICON_RFID, RFID_DISABLE);
}

//========================================
// Setting [ BACKEND ] Icon Status
//========================================
void setBackendIcon()
{
	if(ShmSysConfigAndInfo->SysInfo.OcppConnStatus != ON)
		setDisplayValue(ICON_BACKEND_CONNECTION,BACKEND_OFFLINE);
	else
		setDisplayValue(ICON_BACKEND_CONNECTION,BACKEND_ONLINE);
}

//========================================
// Setting [ ETHERNET ] Icon Status
//========================================
void setEthernetIcon()
{
	char ethernet [16];
	strcpy((char*)ethernet, "eth0");

	if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet == ON)
	{
		if(isEthConnected(ethernet) == YES)
			setDisplayValue(ICON_ETHERENT_CONNECTION, ETHERNET_CONNECTED_WITHOUT_INTERNET);
		else
			setDisplayValue(ICON_ETHERENT_CONNECTION, ETHERNET_DISCONNECTED_INTERNET);
	}
	else
	{
		setDisplayValue(ICON_ETHERENT_CONNECTION, ETHERNET_CONNECTED_INTERNET);
	}
}

//=======================================
// Setting [ WIFI / 4G] icon status
//=======================================
void setWifi4GIcon()
{
	// SET WIFI + 4G ICON STATUS ( ONLINE OR OFFLINE )
	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);

				// 4G Internet connection status: Connected: OFF / Disconnected: ON
				if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == ON)
				{
					// 4G APN connection status: Connected: OFF / Disconnected: ON
					if(ShmStatusCodeData->InfoCode.InfoEvents.bits.ApnDisconnectVia4Gi == ON)
						setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_DISCONNECTED_INTERNET);
					else
						setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_CONNECTED_WITHOUT_INTERNET);
				}
				else
					setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_CONNECTED_INTERNET);
			}
		}
		else
		{
			if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode == WIFI_STATION)
			{
				// Wifi Internet connection status: Connected = OFF / Disconnected = ON
				if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi == ON)
				{
					// Wifi Access point connection status: Connected = OFF / Disconnected = ON
					if(ShmStatusCodeData->InfoCode.InfoEvents.bits.ApDisconnectViaWiFi == ON)
						setDisplayValue(ICON_WIFI_CONNECTION, WIFI_DISCONNECTED_INTERNET);
					else
						setDisplayValue(ICON_WIFI_CONNECTION, WIFI_CONNECTED_WITHOUT_INTERNET);
				}
				else
					setDisplayValue(ICON_WIFI_CONNECTION, WIFI_CONNECTED_INTERNET);
			}
			else if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode == WIFI_ACCESS_POINT)
				setDisplayValue(ICON_WIFI_CONNECTION, WIFI_CONNECTED_WITHOUT_INTERNET);
			else
				setDisplayValue(ICON_WIFI_CONNECTION, DISAPPEAR);

			if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == DISABLE_4G)
				setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
			else
			{
				// 4G Internet connection status: Connected: OFF / Disconnected: ON
				if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == ON)
				{
					// 4G APN connection status: Connected: OFF / Disconnected: ON
					if(ShmStatusCodeData->InfoCode.InfoEvents.bits.ApnDisconnectVia4Gi == ON)
						setDisplayValue(ICON_4G_CONNECTION, TELECOM_DISCONNECTED_INTERNET);
					else
						setDisplayValue(ICON_4G_CONNECTION, TELECOM_CONNECTED_WITHOUT_INTERNET);
				}
				else
					setDisplayValue(ICON_4G_CONNECTION, TELECOM_CONNECTED_INTERNET);
			}
		}
	}
	else if(ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'E')
	{
		setDisplayValue(ICON_WIFI_CONNECTION, DISAPPEAR);
		setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
	}
	else
	{
		// SET 4G ICON STATUS ( ONLINE OR OFFLINE )
		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:

					setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);

					// 4G Internet connection status: Connected: OFF / Disconnected: ON
					if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == ON)
					{
						// 4G APN connection status: Connected: OFF / Disconnected: ON
						if(ShmStatusCodeData->InfoCode.InfoEvents.bits.ApnDisconnectVia4Gi == ON)
							setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_DISCONNECTED_INTERNET);
						else
							setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_CONNECTED_WITHOUT_INTERNET);
					}
					else
						setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_CONNECTED_INTERNET);

					break;
				default:
					break;
			}
		}

		// SET WIFI ICON STATUS ( ONLINE OR OFFLINE)
		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:

					setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);

					// Wifi Internet connection status: Connected = OFF / Disconnected = ON
					if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi == ON)
					{
						// Wifi Access point connection status: Connected = OFF / Disconnected = ON
						if(ShmStatusCodeData->InfoCode.InfoEvents.bits.ApDisconnectViaWiFi == ON)
							setDisplayValue(ICON_WIFI_CONNECTION, WIFI_DISCONNECTED_INTERNET);
						else
							setDisplayValue(ICON_WIFI_CONNECTION, WIFI_CONNECTED_WITHOUT_INTERNET);
					}
					else
						setDisplayValue(ICON_WIFI_CONNECTION, WIFI_CONNECTED_INTERNET);

					break;
				case WIFI_ACCESS_POINT:

					setDisplayValue(ICON_WIFI_CONNECTION, WIFI_CONNECTED_WITHOUT_INTERNET);

					break;
				default:
					break;
			}
		}
	}
}

//========================================
// 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 [ Billing ] ( WEB PAGE )
//=======================================
void setBillingFromWebsite()
{
	struct timeb csuTime;
	struct tm *tmCSU;
	ftime(&csuTime);
	tmCSU = localtime(&csuTime.time);

	setDisplayValue(ICON_PRICE, APPEAR);

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

	// CURRENCY UNIT ( 53 COUNTRIES )
	if(ShmSysConfigAndInfo->SysConfig.BillingData.Currency <= 53)
	{
		setCurrencyFromWebsite(ShmSysConfigAndInfo->SysConfig.BillingData.Currency);
	}
}

//=======================================
// Setting [ Currency ] ( WEB PAGE )
//=======================================
void setCurrencyFromWebsite(uint8_t unit)
{
	uint8_t data[16];
	uint8_t currency[16];
	unsigned char kWh [16];
	uint8_t final_currency[16];

	memset(data, 0x00, ARRAY_SIZE(data));
	memset(currency, 0x00, ARRAY_SIZE(currency));
	memset(final_currency, 0x00, ARRAY_SIZE(final_currency));
	strcpy((char*)kWh, "/kWh");
	memcpy((char*)currency, Currency[unit], 3);

	sprintf((char *)final_currency, "%s%s", currency,kWh);
	string2ByteArray(final_currency, data);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CURRENCY_UNIT, data, ARRAY_SIZE(data));
}

//=======================================
// Setting [ Price ] ( WEB PAGE )
//=======================================
void setPriceFromWebsite(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 Cost ] ( WEB PAGE )
//=======================================
void setPresentFinalCost(float cost)
{
	uint8_t data[16];
	uint8_t finalCost[16];

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

	sprintf((char *)finalCost, "%.2f", cost);
	string2ByteArray(finalCost, data);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_COST, data, ARRAY_SIZE(data));
}

//=======================================
// Getting [ Final cost ] ( WEB PAGE )
//=======================================
float getPresentFinalCost(uint8_t gun_index)
{
	float result = 0.0f;

	for(int idx=0;idx<ARRAY_SIZE(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].presentChargedEnergyPeriod);idx++)
	{
		result += ((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].presentChargedEnergyPeriod[idx]) * ShmSysConfigAndInfo->SysConfig.BillingData.Fee[idx]);
	}

	return result;
}

//=======================================
// Setting [ Billing ] ( BACKEND )
//=======================================
void setBillingFromBackend(uint8_t gun_index, uint8_t system_mode)
{
	if((system("pidof -s OcppBackend > /dev/null") != 0))
	{
		setDisplayValue(ICON_PRICE, DISAPPEAR);
		setDisplayValue(TEXT_PRICE, DISAPPEAR);
		setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
		setDisplayValue2(MARQUEES_DEFAULT_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))
				{
					if(system_mode == SYS_MODE_IDLE)
					{
						setDisplayValue(TEXT_PRICE, DISAPPEAR);
						setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
						setDisplayValue(ICON_PRICE, APPEAR);
						setMarqueeControl(MARQUEES_DEFAULT_PRICE, gun_index, DEFAULE_PRICE);
					}
					else
					{
						/*
						 * 1. IF STARTUSERID IS NOT MATCH WITH IDTOKEN ALSO VALUE CAN'T BE NULL, OTHERWISE THE SYSTEM MUST USE DEFAULT PRICE
						 */
						if((strcmp((char*)ShmSysConfigAndInfo->SysConfig.UserId, (char *)ShmOCPP16Data->Cost.SetUserPrice.idToken) == 0) && ((strcmp((char *)ShmOCPP16Data->Cost.SetUserPrice.idToken,"") != 0)))
						{
							setMarqueeControl(MARQUEES_DEFAULT_PRICE, gun_index, SET_USER_PRICE);
						}
						else
						{
							setDisplayValue(TEXT_PRICE, DISAPPEAR);
							setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
							setDisplayValue(ICON_PRICE, APPEAR);
							setMarqueeControl(MARQUEES_DEFAULT_PRICE, gun_index, DEFAULE_PRICE);
						}
					}
				}
				else
				{
					setDisplayValue(ICON_PRICE, DISAPPEAR);
					setDisplayValue(TEXT_PRICE, DISAPPEAR);
					setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
					setDisplayValue2(MARQUEES_DEFAULT_PRICE, DISAPPEAR);
				}
			}
			else
			{
				// DISPLAY BY OCPP 2.0.1
			}
		}
		else
		{
			setDisplayValue(ICON_PRICE, DISAPPEAR);
			setDisplayValue(TEXT_PRICE, DISAPPEAR);
			setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
			setDisplayValue2(MARQUEES_DEFAULT_PRICE, DISAPPEAR);
		}
	}
}

//=======================================
// Setting [ UserPrice ] ( BACKEND )
//=======================================
void setUserPrice(uint8_t type)
{
	uint8_t length;
	uint8_t output_data[32];
	char input_data[32];
	char tmp[256];
	char *splitString[10];
	const char *Symbol = ";";

	memset(tmp, 0, ARRAY_SIZE(tmp));
	memset(input_data, 0x00, ARRAY_SIZE(input_data));
	memset(output_data, 0x00, ARRAY_SIZE(output_data));

	switch(type)
	{
		case CONNECTION_FEE:
			break;
		case CURRENT_RATE:
			if(strstr((char *)ShmOCPP16Data->Cost.SetUserPrice.price, "Current Rate:") > 0)
			{
				// APPEAR PRICE ICON
				setDisplayValue(ICON_PRICE, APPEAR);

				// APPEAR PRICE TEXT
				strcpy((char*)tmp,(char *)ShmOCPP16Data->Cost.SetUserPrice.price);
				split((char**)splitString, tmp, Symbol);
				memcpy(input_data, splitString[1], strlen(splitString[1]));
				length = strlen(input_data);
				trim_string(input_data,length);
				memcpy(output_data ,input_data, strlen(input_data));
				lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRICE, output_data, ARRAY_SIZE(output_data));
			}
			else
			{
				// DISAPPEAR PRICE ICON AND PRICE TEXT
				setDisplayValue(ICON_PRICE, DISAPPEAR);
				setDisplayValue(TEXT_PRICE, DISAPPEAR);
			}
			break;
		case OCCUPANCY_FEE:
			break;
		case ACCOUNT_BALANCE:
			if(strstr((char *)ShmOCPP16Data->Cost.SetUserPrice.price, "Account Balance:") > 0)
			{
				// APPEAR ACCOUNT BALANCE ICON
				setDisplayValue(ICON_USER_ACCOUNT_BALANCE, APPEAR);

				// APPEAR ACCOUNT BALANCE TEXT
				strcpy((char*)tmp,(char *)ShmOCPP16Data->Cost.SetUserPrice.price);
				split((char**)splitString, tmp, Symbol);
				memcpy(input_data, splitString[3], strlen(splitString[3]));
				length = strlen(input_data);
				trim_string(input_data,length);
				memcpy(output_data ,input_data, strlen(input_data));
				lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_USER_ACCOUNT_BALANCE, output_data, ARRAY_SIZE(output_data));
			}
			else
			{
				// DISAPPEAR BALANCE ICON AND BALANCE TEXT
				setDisplayValue(ICON_USER_ACCOUNT_BALANCE, DISAPPEAR);
				setDisplayValue(TEXT_USER_ACCOUNT_BALANCE, DISAPPEAR);
			}
			break;
		default:
			break;
	}
}

//=======================================
// Setting [ DefaultPrice ] ( BACKEND )
//=======================================
void setDefaultPrice(uint8_t type)
{
	uint8_t length;
	uint8_t output_data[32];
	char input_data[32];
	char tmp[256];
	char *splitString[10];
	const char *Symbol = ";";

	memset(tmp, 0, ARRAY_SIZE(tmp));
	memset(input_data, 0x00, ARRAY_SIZE(input_data));
	memset(output_data, 0x00, ARRAY_SIZE(output_data));

	switch(type)
	{
		case CONNECTION_FEE:
			break;
		case CURRENT_RATE:
			if(strstr((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData, "Current Rate:") > 0)
			{
				// APPEAR PRICE ICON
				setDisplayValue(ICON_PRICE, APPEAR);

				// APPEAR PRICE TEXT
				strcpy((char*)tmp,(char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData);
				split((char**)splitString, tmp, Symbol);
				memcpy(input_data, splitString[1], strlen(splitString[1]));
				length = strlen(input_data);
				trim_string(input_data,length);
				memcpy(output_data ,input_data, strlen(input_data));
				lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRICE, output_data, ARRAY_SIZE(output_data));
			}
			else
			{
				setDisplayValue(TEXT_PRICE, DISAPPEAR);
				setDisplayValue(ICON_PRICE, DISAPPEAR);
			}
			break;
		case OCCUPANCY_FEE:
			break;
		default:
			break;
	}
}

//=======================================
// Setting [ FinalCost ] ( BACKEND )
//=======================================
void setFinalCost(uint8_t gun_index, uint8_t type)
{
	uint8_t length;
	uint8_t output_data[32];
	char input_data[32];
	char tmp[256];
	char *splitString[10];
	const char *Symbol = ";";
	unsigned char cost_empty[32];
	unsigned char balance_empty[32];

	memset(tmp, 0, ARRAY_SIZE(tmp));
	memset(output_data, 0x00, ARRAY_SIZE(output_data));
	memset(input_data, 0x00, ARRAY_SIZE(input_data));
	memset(cost_empty, 0x00, ARRAY_SIZE(cost_empty));
	memset(balance_empty, 0x00, ARRAY_SIZE(balance_empty));

	switch(type)
	{
		case CONNECTION_FEE:
			break;
		case SESSION_FEE:
			break;
		case OCCUPANCY_FEE:
			break;
		case TOTAL_COST:
			if(ShmOCPP16Data->StopTransaction[gun_index].TransactionId != ShmOCPP16Data->Cost.FinalCost[gun_index].txId)
			{
				setDisplayValue(ICON_CHARGING_COST, APPEAR);

				strcpy((char*)cost_empty, "-----");
				string2ByteArray(cost_empty, output_data);
				lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_COST, output_data, ARRAY_SIZE(output_data));
			}
			else
			{
				if((strstr((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description, "Total Cost:") > 0))
				{
					// APPEAR COST ICON
					setDisplayValue(ICON_CHARGING_COST, APPEAR);

					// APPEAR COST TEXT
					strcpy((char*)tmp,(char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description);
					split((char**)splitString, tmp, Symbol);
					memcpy(input_data, splitString[3], strlen(splitString[3]));
					length = strlen(input_data);
					trim_string(input_data,length);
					memcpy(output_data ,input_data, strlen(input_data));
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_COST, output_data, ARRAY_SIZE(output_data));
				}
				else
				{
					setDisplayValue(ICON_CHARGING_COST, APPEAR);

					strcpy((char*)cost_empty, "-----");
					string2ByteArray(cost_empty, output_data);
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_COST, output_data, ARRAY_SIZE(output_data));
				}
			}
			break;
		case ACCOUNT_BALANCE:
			if(ShmOCPP16Data->StopTransaction[gun_index].TransactionId != ShmOCPP16Data->Cost.FinalCost[gun_index].txId)
			{
				setDisplayValue(ICON_COMPLETE_WALLET, APPEAR);

				strcpy((char*)balance_empty, "-----");
				string2ByteArray(balance_empty, output_data);

				lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_REMAINING_ACCOUNT_BALANCE, output_data, ARRAY_SIZE(output_data));
			}
			else
			{
				if((strstr((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description, "Account Balance:") > 0))
				{
					// APPEAR BALANCE ICON
					setDisplayValue(ICON_COMPLETE_WALLET, APPEAR);

					// APPEAR BALANCE TEXT
					strcpy((char*)tmp,(char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description);
					split((char**)splitString, tmp, Symbol);
					memcpy(input_data, splitString[4], strlen(splitString[4]));
					length = strlen(input_data);
					trim_string(input_data,length);
					memcpy(output_data ,input_data, strlen(input_data));
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_REMAINING_ACCOUNT_BALANCE, output_data, ARRAY_SIZE(output_data));
				}
				else
				{	
					setDisplayValue(ICON_COMPLETE_WALLET, APPEAR);

					strcpy((char*)balance_empty, "-----");
					string2ByteArray(balance_empty, output_data);

					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_REMAINING_ACCOUNT_BALANCE, output_data, ARRAY_SIZE(output_data));
				}
			}
			break;
		default:
			break;
	}
}

//=======================================
// Setting [ RunningCost ] ( BACKEND )
//=======================================
void setRunningCost(uint8_t gun_index, uint8_t type)
{
	uint8_t length;
	uint8_t output_data[32];
	char input_data[32];
	char tmp[256];
	char *splitString[10];
	const char *Symbol = ";";
	unsigned char cost_empty[32];

	memset(tmp, 0, ARRAY_SIZE(tmp));
	memset(output_data, 0x00, ARRAY_SIZE(output_data));
	memset(input_data, 0x00, ARRAY_SIZE(input_data));
	memset(cost_empty, 0x00, ARRAY_SIZE(cost_empty));

	switch(type)
	{
		case CONNECTION_FEE:
			break;
		case SESSION_FEE:
			break;
		case OCCUPANCY_FEE:
			break;
		case TOTAL_COST:
			if(ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId != ShmOCPP16Data->Cost.RunningCost[gun_index].txId)
			{
				setDisplayValue(ICON_CHARGING_COST, APPEAR);

				strcpy((char*)cost_empty, "-----");
				string2ByteArray(cost_empty, output_data);
				lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_COST, output_data, ARRAY_SIZE(output_data));
			}
			else
			{
				if((strstr((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].description, "Total Cost:") > 0))
				{
					// APPEAR COST ICON
					setDisplayValue(ICON_CHARGING_COST, APPEAR);

					// APPEAR COST TEXT
					strcpy((char*)tmp,(char*)ShmOCPP16Data->Cost.RunningCost[gun_index].description);
					split((char**)splitString, tmp, Symbol);
					memcpy(input_data, splitString[3], strlen(splitString[3]));
					length = strlen(input_data);
					trim_string(input_data,length);
					memcpy(output_data ,input_data, strlen(input_data));
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_COST, output_data, ARRAY_SIZE(output_data));
				}
				else
				{
					setDisplayValue(ICON_CHARGING_COST, APPEAR);

					strcpy((char*)cost_empty, "-----");
					string2ByteArray(cost_empty, output_data);
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_COST, output_data, ARRAY_SIZE(output_data));
				}
			}

			break;
		case ACCOUNT_BALANCE:
			break;
		default:
			break;
	}
}

//=======================================
// Setting [ Currency ] ( BACKEND )
//=======================================
void setCurrencyAndUnitFromBackend(uint8_t type_price ,uint8_t type_currency_unit,uint8_t gun_index)
{
	uint8_t length;
	uint8_t output_data[32];
	char input_data[32];
	char tmp[256];
	char *splitString[10];
	const char *Symbol = ";";

	memset(tmp, 0, ARRAY_SIZE(tmp));
	memset(input_data, 0x00, ARRAY_SIZE(input_data));
	memset(output_data, 0x00, ARRAY_SIZE(output_data));

	if(type_price == DEFAULE_PRICE)
	{
		switch(type_currency_unit)
		{
			case CONNECTION_FEE:
				break;
			case CURRENT_RATE:
				if(strstr((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData, "Current Rate:") > 0)
				{
					strcpy((char*)tmp,(char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData);
					split((char**)splitString, tmp, Symbol);
					memcpy(input_data, splitString[1], strlen(splitString[1]));
					length = strlen(input_data);
					memcpy(output_data , input_data+(length-7), 7);
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CURRENCY_UNIT, output_data, ARRAY_SIZE(output_data));
				}
				else
				{
					setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
				}
				break;
			case OCCUPANCY_FEE:
				break;
			default:
				break;
		}
	}
	else if(type_price == SET_USER_PRICE)
	{
		switch(type_currency_unit)
		{
			case CONNECTION_FEE:
				break;
			case CURRENT_RATE:
				if(strstr((char *)ShmOCPP16Data->Cost.SetUserPrice.price, "Current Rate:") > 0)
				{
					strcpy((char*)tmp,(char *)ShmOCPP16Data->Cost.SetUserPrice.price);
					split((char**)splitString, tmp, Symbol);
					memcpy(input_data, splitString[1], strlen(splitString[1]));
					length = strlen(input_data);
					memcpy(output_data , input_data+(length-7), 7);
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CURRENCY_UNIT, output_data, ARRAY_SIZE(output_data));
				}
				else
				{
					setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
				}
				break;
			case OCCUPANCY_FEE:
				break;
			case ACCOUNT_BALANCE:
				break;
			default:
				break;
		}
	}
	else if(type_price == FINAL_COST)
	{
		switch(type_currency_unit)
		{
			case CONNECTION_FEE:
				break;
			case SESSION_FEE:
				break;
			case OCCUPANCY_FEE:
				break;
			case TOTAL_COST:
				break;
			case ACCOUNT_BALANCE:
				if(ShmOCPP16Data->StopTransaction[gun_index].TransactionId != ShmOCPP16Data->Cost.FinalCost[gun_index].txId)
				{
					setDisplayValue(TEXT_USER_CURRENCY, DISAPPEAR);
				}
				else
				{
					if((strstr((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description, "Account Balance:") > 0))
					{
						strcpy((char*)tmp,(char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description);
						split((char**)splitString, tmp, Symbol);
						memcpy(input_data, splitString[4], strlen(splitString[4]));
						length = strlen(input_data);
						memcpy(output_data , input_data+(length-3), 3);
						lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_USER_CURRENCY, output_data, ARRAY_SIZE(output_data));
					}
					else
					{
						setDisplayValue(TEXT_USER_CURRENCY, DISAPPEAR);
					}
				}
				break;
			default:
				break;
		}
	}
	else
	{}
}

//=======================================
// Setting QRCODE icon status
//=======================================
void setQRCodeIcon()
{
	uint8_t length = 0;

	if(ShmSysConfigAndInfo->SysConfig.isQRCode == ON)
	{
		setDisplayValue(ICON_QR_CODE,QRCODE_ENABLE);
		if(ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode == NO)
		{
			length = strlen((char *)ShmSysConfigAndInfo->SysConfig.SystemId);
			setQRcodeContent((char *)ShmSysConfigAndInfo->SysConfig.SystemId, length, QRCODE_FOR_IDLE);
		}
		else
		{
			length = strlen((char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent);
			setQRcodeContent((char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent, length, QRCODE_FOR_IDLE);
		}
	}
	else
	{
		setDisplayValue(TEXT_QRCODE_CONTENT, DISAPPEAR);
		setDisplayValue(ICON_QR_CODE,QRCODE_DISABLE);
	}
}

//=======================================
// Setting QRCODE icon for receipt
//=======================================
void setQRCodeReceipt(uint8_t gun_index)
{
	uint8_t length = 0;
	uint8_t data[512];
	int TransactionId;
	unsigned char QRCodeContent[512];
	unsigned char QRCodeReceipt[512];

	memset(QRCodeContent, 0x00, ARRAY_SIZE(QRCodeContent));
	memset(QRCodeReceipt, 0x00, ARRAY_SIZE(QRCodeReceipt));
	memset(data, 0x00, ARRAY_SIZE(data));

	memcpy((char*)QRCodeContent, (char*)ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL, ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL));
	if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
	{
		TransactionId = ShmOCPP16Data->StopTransaction[gun_index].TransactionId;
	}
	else
	{
		// TO DO OCPP 2.0
	}

	sprintf((char *)QRCodeReceipt, "%s%d", QRCodeContent,TransactionId);
	string2ByteArray(QRCodeReceipt, data);

	length = strlen((char *)data);
	setQRcodeContent((char *)data, length, QRCODE_FOR_COMPLETE);
}

//=======================================
// Setting QRCODE for alarm
//=======================================
void setQRCodeAlarm()
{
	uint8_t length = 0;
	uint8_t data[512];
	unsigned char QRCodeAlarm[512];

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

	sprintf((char *)QRCodeAlarm, "%s", "https://evsc.phihong.com.tw/");
	string2ByteArray(QRCodeAlarm, data);
	length = strlen((char *)data);
	setQRcodeContent((char *)data, length, QRCODE_FOR_ALARM);
}

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

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

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

	switch(mode)
	{
		case QRCODE_FOR_IDLE:
			lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_QRCODE_CONTENT, output, ARRAY_SIZE(output)+1);
			break;
		case QRCODE_FOR_COMPLETE:
			lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_QRCODE_RECEIPT, output, ARRAY_SIZE(output)+1);
			break;
		case QRCODE_FOR_ALARM:
			lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_QRCODE_ALARM, output, ARRAY_SIZE(output)+1);
			break;
		default:
			lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_QRCODE_CONTENT, output, ARRAY_SIZE(output)+1);
			break;
	}
}

//=======================================
// Setting warning page switch
//=======================================
void setWarningStatus(uint8_t gun_index)
{
	/*
	 * 1. WARNING COUNT IS DIFFERENT BETWEEN BEGINNING CHANGE DISPLAY
	 * 2. WARNING COUNT BIGGER THAN 4 AND EVERY 5 SECONDS CHANGE NEXT PAGE
	 */
	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 TEXT (XXXXXX)
		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));

		// ALARM CODE 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 connection icon animation
//=======================================
void setConnectionAnimation(uint8_t gun_index, uint8_t system_mode)
{
	switch(system_mode)
	{
		case SYS_MODE_IDLE:
			if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
			{
				if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
				{
					setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_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_PRECHARGING_ANIMATION, CONNECTION_FLASHING_2);
					CONNECTION_LEVEL_STATUS =  CONNECTION_LEVEL_0;
					ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
				}
			}
			else
			{
				if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
				{
					setDisplayValue(ICON_PREPARING_ANIMATION, CONNECTION_FLASHING_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_PREPARING_ANIMATION, CONNECTION_FLASHING_2);
					CONNECTION_LEVEL_STATUS =  CONNECTION_LEVEL_0;
					ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
				}
			}

			break;
		case SYS_MODE_PREPARING:
			if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
			{
				if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
				{
					setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_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_PRECHARGING_ANIMATION, CONNECTION_FLASHING_2);
					CONNECTION_LEVEL_STATUS =  CONNECTION_LEVEL_0;
					ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
				}
			}
			else
			{
				if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
				{
					setDisplayValue(ICON_PREPARING_ANIMATION, CONNECTION_FLASHING_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_PREPARING_ANIMATION, CONNECTION_FLASHING_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_CHARGING_ANIMATION, CONNECTION_FLASHING_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_CHARGING_ANIMATION, CONNECTION_FLASHING_2);
				CONNECTION_LEVEL_STATUS =  CONNECTION_LEVEL_0;
				ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
			}
			break;
		case SYS_MODE_TERMINATING:
			break;
		default:
			break;
	}
}

//=======================================
// Setting [ Gun Plug-in ] Animation
//=======================================
void setGunPluginAnimation(uint8_t gun_index)
{
	if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_B) ||
	   (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_C) ||
	   (ShmCharger->gun_info[gun_index].primaryMcuState.socket_e.isSocketEPinOn == ON))
	{
		setDisplayValue(ICON_PREPARING_PLUG_ARROW, PLUGIN_ARROW_2);
	}
	else
	{
		if((GUN_PLUGING_LEVEL_STATUS == GUN_PLUGING_LEVEL_0) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_PLUGIN]) > (TIME_ANIMATION_PLUGIN)))
		{
			setDisplayValue(ICON_PREPARING_PLUG_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_PREPARING_PLUG_ARROW, PLUGIN_ARROW_2);
			GUN_PLUGING_LEVEL_STATUS =  GUN_PLUGING_LEVEL_0;
			ftime(&startTime[gun_index][TMR_IDX_PLUGIN]);
		}
	}
}

//=======================================
// Setting [ Plug & Charge ] Animation
//=======================================
void setPlugAndChargeAnimation(uint8_t gun_index)
{
	if((GUN_PLUGING_LEVEL_STATUS == GUN_PLUGING_LEVEL_0) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_PLUGIN]) > (TIME_ANIMATION_PLUGIN)))
	{
		setDisplayValue(ICON_PLUG_AND_CHARGE_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_PLUG_AND_CHARGE_ARROW, PLUGIN_ARROW_2);
		GUN_PLUGING_LEVEL_STATUS =  GUN_PLUGING_LEVEL_0;
		ftime(&startTime[gun_index][TMR_IDX_PLUGIN]);
	}
}

//=======================================
// Setting Connection Timeout
//=======================================
void setPresentConnectionTimeout(uint8_t gun_index)
{
	int time;
	uint8_t data[16];
	uint8_t conntectionTimeout[16];
	unsigned char not_counting[16];

	memset(data, 0x00, ARRAY_SIZE(data));
	memset(conntectionTimeout, 0x00, ARRAY_SIZE(conntectionTimeout));
	memset(not_counting, 0x00, ARRAY_SIZE(not_counting));

	if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_B) ||
	   (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_C) ||
	   (ShmCharger->gun_info[gun_index].primaryMcuState.socket_e.isSocketEPinOn == ON))
	{
		strcpy((char*)not_counting, "-----");
		string2ByteArray(not_counting, data);
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_CONNECTION_TIMER, data, ARRAY_SIZE(data));
	}
	else
	{
		time = ShmCharger->timeoutSpec.Handshake_Timeout;
		if(time <= 0)
		{
			strcpy((char*)not_counting, "000");
			string2ByteArray(not_counting, data);
			lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_CONNECTION_TIMER, data, ARRAY_SIZE(data));
		}
		else
		{
			sprintf((char *)conntectionTimeout, "%03d ", time);
			string2ByteArray(conntectionTimeout, data);
			lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_CONNECTION_TIMER, data, ARRAY_SIZE(data));
		}
	}
}

//=======================================
// Setting Present Charging [ Power ]
//=======================================
void setPresentChargedgPower(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_CHARGING_POWER, data, ARRAY_SIZE(data));
}

//=======================================
// Setting Present Charging [ 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_CHARGING_ENERGY, data, ARRAY_SIZE(data));
}

//=======================================
// Setting Present Charging [ Duration ]
//=======================================
void setPresentChargedDuration(uint8_t gun_index)
{
	uint8_t data[16];
	uint8_t time[16];
	uint16_t hour;
	uint16_t minute;
	uint16_t second;
	uint32_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_CHARGING_TIMER, data, ARRAY_SIZE(data));
}

//=======================================
// Setting Present [ Power Consumption ]
//=======================================
void setPresentPowerConsumption(uint8_t gun_index)
{
	uint8_t data[32];
	uint8_t powerConsumption[32];

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

	sprintf((char *)powerConsumption, "%.4f kWh", ((float)ShmCharger->gun_info[gun_index].powerConsumptionTotal.power_consumption/10000.0));
	string2ByteArray(powerConsumption, data);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_POWER_CONSUMPTION, data, ARRAY_SIZE(data));
}

//=======================================
// Setting authorization page
//=======================================
void setAuthorizationPage(uint8_t gun_index)
{
	switch(ShmCharger->gun_info[gun_index].resultAuthorization)
	{
		case VALIDATED_RFID:
			if(getCurrentPage() != SYSTEM_SCREEN_AUTH_PASS)
			{
				setCurrentPage(SYSTEM_SCREEN_AUTH_PASS);
				DEBUG_INFO("Setting page to authorizing : Validated RFID.\n");
			}
			else
			{}
			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
			{}
			break;
		case UNKNOW_RFID:
			if(getCurrentPage() != SYSTEM_SCREEN_AUTH_UNKNOWN)
			{
				setCurrentPage(SYSTEM_SCREEN_AUTH_UNKNOWN);
				DEBUG_INFO("Setting page to authorizing : Unknown RFID\n");
			}
			else
			{}
			break;
		case DEFAULT_RFID:
			break;
		default:
			break;
	}
}

//=======================================
// Setting default values
//=======================================
void setDefaultValue(uint8_t gun_index, uint8_t system_mode)
{
	switch(system_mode)
	{
		case SYS_MODE_BOOTING:
			break;
		case SYS_MODE_IDLE:
			setTextToEmpty(gun_index);
			if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
			{
				setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_1);
				CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
				ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
			}
			else
			{
				setDisplayValue(ICON_PREPARING_PLUG_ARROW, PLUGIN_ARROW_1);
				GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_0;
				ftime(&startTime[gun_index][TMR_IDX_PLUGIN]);
			}
			break;
		case SYS_MODE_AUTHORIZING:
			break;
		case SYS_MODE_PREPARING:
			if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
			{
				setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_1);
				CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
				ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
			}
			else
			{
				setDisplayValue(ICON_PREPARING_PLUG_ARROW, PLUGIN_ARROW_1);
				GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_0;
				ftime(&startTime[gun_index][TMR_IDX_PLUGIN]);
			}
			break;
		case SYS_MODE_CHARGING:
			setDisplayValue(ICON_CHARGING_ANIMATION, CONNECTION_FLASHING_1);
			ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
			CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
			break;
		case SYS_MODE_TERMINATING:
			break;
		case SYS_MODE_COMPLETE:
			break;
		case SYS_MODE_ALARM:
			break;
		case SYS_MODE_FAULT:
			break;
		case SYS_MODE_MAINTAIN:
			break;
		case SYS_MODE_UPDATE:
			break;
		case SYS_MODE_RESERVATION:
			break;
		case SYS_MODE_BOOKING:
			break;
		case SYS_MODE_DEBUG:
			break;
		default:
			break;
	}
}

//=======================================
// Setting text to empty
//=======================================
void setTextToEmpty(uint8_t gun_index)
{
	uint8_t data[32];
	uint8_t text_empty[32];

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

	strcpy((char*)text_empty, "    ");
	string2ByteArray(text_empty, data);

	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_COST, data, ARRAY_SIZE(data));
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_REMAINING_ACCOUNT_BALANCE, data, ARRAY_SIZE(data));
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_USER_ACCOUNT_BALANCE, data, ARRAY_SIZE(data));
}

//=======================================
// Setting marquee control
//=======================================
void setMarqueeControl(uint16_t address, uint8_t gun_index, uint8_t type)
{
	uint8_t data[250];
	unsigned char Content[250];

	memset(Content, 0xFF, ARRAY_SIZE(Content));
	memset(data, 0xFF, ARRAY_SIZE(data));

	switch(type)
	{
		case DEFAULE_PRICE:
			sprintf((char *)Content, "%s", (char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData);
			string2ByteArray(Content,data);
			lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (address+3), data, ARRAY_SIZE(data));
			break;
		case SET_USER_PRICE:
			sprintf((char *)Content, "%s", (char *)ShmOCPP16Data->Cost.SetUserPrice.price);
			string2ByteArray(Content,data);
			lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (address+3), data, ARRAY_SIZE(data));
			break;
		case FINAL_COST:
			break;
		case RUNNING_COST:
			break;
		default:
			break;
	}
}

//=======================================
// Initial 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\n");
		result = FAIL;
	}
	else if ((ShmCharger = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		DEBUG_ERROR("shmat ShmChargerKey NG\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;
}

//=======================================
// Initial communication port
//=======================================
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;
}

//=======================================
// Download image
//=======================================
int downloadBMP(uint8_t picIdx, char *filename)
{
	int result = PASS;
	BMP *bmp;
	struct stat fileSt;
	uint32_t pageSize = 0xf0;
	uint32_t pixelSize;
	uint32_t transferedByte=0;
	uint16_t bufferRamAddr = 0x8000;
	uint32_t dataLen = 0;
	uint32_t startAddr=0;

	// Reset LCD
	uint8_t cmd_reset[] = {0x55, 0xaa, 0x5a, 0xa5};
	while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, 0x04, cmd_reset, ARRAY_SIZE(cmd_reset)) != PASS)
	{
		DEBUG_INFO("LCD reset fail.\n");
	}
	sleep(1);

	// Get image file size
	stat(filename, &fileSt);
	bmp = bopen(filename);
	uint8_t buf[bmp->width*bmp->height*2];

	DEBUG_INFO("Target address: %d\n", picIdx);
	DEBUG_INFO("Image filename: %s\n", filename);
	DEBUG_INFO("Image width: %d height: %d\n", bmp->width, bmp->height);
	DEBUG_INFO("Image data size: %d\n", ARRAY_SIZE(buf));

	// Get bmp pixel data and convert to 16 bit color
	for(uint16_t idxY=0 ; idxY<bmp->height ; idxY++)
	{
		for(uint16_t idxX=0 ; idxX<bmp->width ; idxX++)
		{
			uint8_t r, g, b;
			get_pixel_rgb(bmp, idxX, (bmp->height-idxY-1), &r, &g, &b);
			buf[(2*((idxY*bmp->width) + idxX)) + 0] = ((((r>>3)<<11) | ((g>>2)<<5) | (b>>3)) >> 8) & 0xff;
			buf[(2*((idxY*bmp->width) + idxX)) + 1] = ((((r>>3)<<11) | ((g>>2)<<5) | (b>>3)) >> 0) & 0xff;
		}
	}
	bclose(bmp);

	// Transfer pixel to screen page
	pixelSize = ARRAY_SIZE(buf);
	for(uint16_t idxSrcData=0;idxSrcData<(((pixelSize%pageSize)==0)?(pixelSize/pageSize):(pixelSize/pageSize)+1);idxSrcData++)
	{
		//DEBUG_INFO("Buffer start data address: 0x%08X\n", (idxSrcData*pageSize));
		//DEBUG_INFO("  Image start ram address: 0x%08X\n", ((idxSrcData*pageSize) >> 1));
		uint8_t display_cmd[] ={0x5a, (bufferRamAddr>>8)&0xff, (bufferRamAddr>>0)&0xff, 0x00, 0x00, 0x00, 0x00, 0x00};

		if((idxSrcData+1) != (((pixelSize%pageSize)==0)?(pixelSize/pageSize):(pixelSize/pageSize)+1))
		{
			// Data transfer
			while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (bufferRamAddr+(dataLen>>1)), &buf[(idxSrcData*pageSize)], pageSize) != PASS)
			{
				DEBUG_INFO("Transfer data to ram 0x%04X fail.\n", transferedByte);
			}
			transferedByte += pageSize;
			dataLen += pageSize;
		}
		else
		{
			// Last data transfer
			while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (bufferRamAddr+(dataLen>>1)), &buf[(idxSrcData*pageSize)], (pixelSize-(idxSrcData*pageSize))) != PASS)
			{
				DEBUG_INFO("Transfer data to ram 0x%04X fail.\n", transferedByte);
			}
			transferedByte += (pixelSize-(idxSrcData*pageSize));
			dataLen += (pixelSize-(idxSrcData*pageSize));
		}

		// Move data from ram to flash
		if((dataLen >= (pageSize*10)) || (idxSrcData == (((pixelSize%pageSize)==0)?(pixelSize/pageSize):(pixelSize/pageSize)+1)-1))
		{
			display_cmd[3] = ((dataLen>>1) >> 8) & 0xff;							// Data length high byte
			display_cmd[4] = ((dataLen>>1) >> 0) & 0xff;							// Data length low byte
			display_cmd[5] = (((startAddr)>>1) >> 16) & 0xff;				// Screen on ram address 1st byte
			display_cmd[6] = (((startAddr)>>1) >> 8) & 0xff;				// Screen on ram address 2nd byte
			display_cmd[7] = (((startAddr)>>1) >> 0) & 0xff;				// Screen on ram address 3th byte

			while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, 0xa2, display_cmd, ARRAY_SIZE(display_cmd)) != PASS)
			{
				DEBUG_INFO("Write data to display buffer 0x%04X fail.\n", transferedByte);
			}
			startAddr += dataLen;
			dataLen = 0;
		}
	}

	// Save image to target address
	uint8_t save_cmd[] ={0x5a, 0x02, ((picIdx>>8)&0xff), (picIdx&0xff)};
	while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, 0x84, save_cmd, ARRAY_SIZE(save_cmd)) != PASS)
	{
		DEBUG_INFO("Save image fail.\n");
	}
	DEBUG_INFO("Save image success.\n");
	sleep(1);

	return result;
}

//=======================================
// Download image
//=======================================
int downloadBIN(uint8_t targetAddr, char *filename)
{
	int result = PASS;
	int fd;
	struct stat fileSt;
	uint32_t pageSize = 128;
	uint32_t blocklSize = 32768;
	uint32_t transferedByte=0;
	uint16_t bufferRamAddr = 0x8000;

	// Reset LCD
	uint8_t cmd_reset[] = {0x55, 0xaa, 0x5a, 0xa5};
	while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, 0x04, cmd_reset, ARRAY_SIZE(cmd_reset)) != PASS)
	{
		DEBUG_INFO("LCD reset fail.\n");
	}
	sleep(1);

	// Get image file size
	stat(filename, &fileSt);
	uint8_t buf[(fileSt.st_size%32768==0?(fileSt.st_size/32768)*32768:(fileSt.st_size/32768)+1)*32768];

	DEBUG_INFO("Target address: %d\n", targetAddr);
	DEBUG_INFO("Bin filename: %s\n", filename);
	DEBUG_INFO("Bin data size: %d\n", fileSt.st_size);

	fd = open(filename, O_RDWR);
	if (fd < 0)
	{
		DEBUG_WARN("Bin can not be open.\n");
		result = FAIL;
	}
	else
	{
		// Read data from bin file
		memset(buf, 0x00, ARRAY_SIZE(buf));
		read(fd, buf, ARRAY_SIZE(buf));
		close(fd);

		for(uint8_t idxBinSrc=0;idxBinSrc<(fileSt.st_size%32768==0?fileSt.st_size/32768:(fileSt.st_size/32768)+1);idxBinSrc++)
		{
			// Transfer data to ram
			for(uint16_t idxSrcData=0;idxSrcData<(((blocklSize%pageSize)==0)?(blocklSize/pageSize):(blocklSize/pageSize)+1);idxSrcData++)
			{
				//DEBUG_INFO("Buffer start data address: 0x%08X\n", (idxBinSrc*blocklSize)+(idxSrcData*pageSize));
				//DEBUG_INFO("  Image start ram address: 0x%08X\n", ((idxSrcData*pageSize) >> 1));
				if((idxSrcData+1) != (((blocklSize%pageSize)==0)?(blocklSize/pageSize):(blocklSize/pageSize)+1))
				{
					// Data transfer
					while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, bufferRamAddr+((idxSrcData*pageSize)>>1), &buf[(idxBinSrc*blocklSize)+(idxSrcData*pageSize)], pageSize) != PASS)
					{
						DEBUG_INFO("Transfer data to ram 0x%04X fail.\n", transferedByte);
					}
					transferedByte += pageSize;
				}
				else
				{
					// Last data transfer
					while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, bufferRamAddr+((idxSrcData*pageSize)>>1), &buf[(idxBinSrc*blocklSize)+(idxSrcData*pageSize)], (blocklSize-(idxSrcData*pageSize)))!= PASS)
					{
						DEBUG_INFO("Transfer data to ram 0x%04X fail.\n", transferedByte);
					}
					transferedByte += (blocklSize-(idxSrcData*pageSize));
				}
			}

			// Move data from ram to flash
			uint8_t save_cmd[] ={0x5a, 0x02, ((((targetAddr*8)+idxBinSrc)>>8)&0xff), ((((targetAddr*8)+idxBinSrc)>>0)&0xff), ((bufferRamAddr>>8)&0xff), ((bufferRamAddr>>0)&0xff), 0x00, 0x01, 0x00, 0x00, 0x00, 0x00};
			while(lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, 0xaa, save_cmd, ARRAY_SIZE(save_cmd)) != PASS)
			{
				DEBUG_INFO("Save bin file to 0x%04X fail.\n", ((targetAddr*8)+idxBinSrc));
			}
			DEBUG_INFO("Save bin file on 0x%04X success.\n", ((targetAddr*8)+idxBinSrc));
			sleep(1);
		}
	}

	return result;
}

//=======================================
// LCD upgrade
//=======================================
int lcdUpgrade(char *forlder)
{
	int result = PASS;
	DIR *dir;
	struct dirent *file;
	struct stat fileSt;

	if ((dir = opendir (forlder)) != NULL)
	{
		/* print all the files and directories within directory */
		while ((file = readdir (dir)) != NULL)
		{
			if((strlen(file->d_name)>2))
			{
				int targetAddr;
				stat(file->d_name, &fileSt);

				if(sscanf(file->d_name, "%d", &targetAddr) == 1)
				{
					char targetFile[384];

					sprintf(targetFile, "/mnt/lcd/%s", file->d_name);
					if(strstr(file->d_name, ".bmp") != NULL)
					{
						downloadBMP(targetAddr, targetFile);
					}
					else
					{
						downloadBIN(targetAddr, targetFile);
					}
				}
				else
				{
					DEBUG_WARN("%s can not parse target address.\n", file->d_name);
				}
			}
			else
			{
				if(strlen(file->d_name) >= 3)
				{
					DEBUG_ERROR("File name error.\n");
					result = FAIL;
				}
				else
				{
					DEBUG_INFO("Searching file.\n");
				}
			}
			sleep(1);
		}
		closedir (dir);
	}
	else
	{
		DEBUG_ERROR("%s does not valid.\n", forlder);
		result = FAIL;
	}

	return result;
}

//=======================================
// Ethernet connection status
//=======================================
int isEthConnected(char *eth)
{
	int result = NO;
	FILE *fp;
	char buf[512];

	sprintf(buf, "/sbin/ethtool %s", eth);
	fp = popen(buf, "r");
	if(fp != NULL)
	{
		while(fgets(buf, sizeof(buf), fp) != NULL)
		{
			if((strstr(buf, "Link detected") != NULL) && (strstr(buf, "yes") != NULL))
			{
				result = YES;
			}
		}
	}
	pclose(fp);

	return result;
}

//=======================================
// 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");
	DEBUG_INFO("Latest Firmware Version : [%s] \n", FIRMWARE_UPDATE_IMAGE[0]);
	DEBUG_INFO("Latest Upgrade Date : [%s]. \n", FIRMWARE_UPDATE_IMAGE[1]);
	DEBUG_INFO("Latest Image Version : [%s]. \n", FIRMWARE_UPDATE_IMAGE[2]);

	for(;;)
	{
		if(ShmCharger->isUpgradeLcmReq)
		{
			ShmCharger->isUpgradeLcmSuccess = ((lcdUpgrade("/mnt/lcd") == PASS) ? YES : NO);
			ShmCharger->isUpgradeLcmReq = OFF;
		}
		else
		{
			if(previousMode != ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus)
			{
				previousMode = ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus;
			}

			if(ShmCharger->isAuthrizing || ShmCharger->isGetAuthResult)
			{
				if(DiffTimebWithNow(startTime[ShmCharger->gun_selectd][TMR_IDX_SHOW_AUTH_RESULT]) >= TIME_AUTH_RESULT_TIME)
					ShmCharger->isGetAuthResult = FALSE;

				if(DiffTimebWithNow(startTime[ShmCharger->gun_selectd][TMR_IDX_SHOW_AUTH_RESULT]) < TIME_AUTH_RESULT_TIME)
				{
					page_authorizing(ShmCharger->gun_selectd);
					ShmCharger->gun_info[ShmCharger->gun_selectd].isHandshakeTimerRefresh = YES;
				}
				else if(((ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus == SYS_MODE_IDLE) || (ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus == SYS_MODE_RESERVATION)) && (ShmCharger->gun_info[ShmCharger->gun_selectd].resultAuthorization == VALIDATED_RFID))
				{
					page_preparing(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
					ShmCharger->gun_info[ShmCharger->gun_selectd].isHandshakeTimerRefresh = NO;
				}
			}
			else
			{
				ftime(&startTime[ShmCharger->gun_selectd][TMR_IDX_SHOW_AUTH_RESULT]);

				switch(ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus)
				{
					case SYS_MODE_BOOTING:
						page_booting();
						break;
					case SYS_MODE_IDLE:
						page_idle(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
						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, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
						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();
						page_idle(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
						break;
					case SYS_MODE_BOOKING:
						page_booking();
						break;
					case SYS_MODE_DEBUG:
						page_debug();
						break;
					default:
						page_unknown();
						break;
				}
			}

			page_header(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
			page_footer();
		}

		usleep(100000);
	}

	return FAIL;
}