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

/*
 * Module_LcmControl.c
 *
 * Created on : 2020-10-20
 * Update on : 2022-10-18
 * Author : Folus Wen, Eason Yang
 * Version : V0.31
 *
 */

#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();
void setCsuRootFsFwRev();
uint8_t getCurrentPage();
void setAlarmCodeAndIcon();
void setPresentSessionFee();
void setPresentParkingFee();
void setBillingFromWebsite();
int isEthConnected(char *eth);
void setUserPrice(uint8_t type);
void setTimeTitle(uint8_t isOn);
void setEnergyTitle(uint8_t isOn);
void setCurrentPage(uint8_t page);
void setPresentFinalCost(float cost);
void setFinalCostTitle(uint8_t isOn);
void setSessionFeeTitle(uint8_t isOn);
void setParkingFeeTitle(uint8_t isOn);
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 setPresentChargedPower(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 setPressStartButtonAnimation(uint8_t gun_index);
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, int 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 setPresentChargedEnergy(uint8_t gun_index, uint8_t system_mode);
void setMarqueeControl(uint16_t address, uint8_t gun_index, uint8_t type);

void setPrechargingTimerToDefault();
void setPrechargingEnergyToDefault();
void setPrechargingSessionFeeToDefault();
void setPrechargingParkingFeeToDefault();
void setPrechargingCostToDefault();
void setPrechargingPowerToDefault();
void setClearPrechargingValueToEmpty();
//=======================================
// Declare Timer
//=======================================
enum TMR_IDX
{
	TMR_IDX_0=0,
	TMR_IDX_CONNECTION,
	TMR_IDX_PLUGIN,
	TMR_IDX_ALARM,
	TMR_IDX_PRICE,
	TMR_IDX_REFRESH_INFO,
	TMR_IDX_STARTBUTTON,
	TMR_IDX_7,
	TMR_IDX_8,
	TMR_IDX_SHOW_AUTH_RESULT,
	TMR_IDX_FINAL_COUNTER
};

struct timespec					startTime[AC_QUANTITY][TMR_IDX_FINAL_COUNTER];

//=======================================
// Declare Variable CDFA 2.0
//=======================================
struct StrcutLcmRunningCost
{
	unsigned char PREVIOUS_TIMESTAMP[36];
	unsigned char PREVIOUS_TIMESTAMP_FOR_GRACE_MINUTES[36];
	unsigned int PREVIOUS_METER_VALUE;
	unsigned int PREVIOUS_REAL_TIME_IN_SECONDS;
	double PREVIOUS_HOUR_PRICE;
	double PREVIOUS_KWH_PRICE;
	double END_OF_SESSION_KWH_PRICE;
	double END_OF_SESSION_HOUR_PRICE;
	double END_OF_SESSION_IDLE_PRICE;
	unsigned int GRACE_MINUTES_PERIOD_COUNTER;
};

struct StructCaliforniaPricing
{
	struct StrcutLcmRunningCost		LcmRunningCost[AC_QUANTITY];

}CaliforniaPricing;

#define TIME_ANIMATION_PLUGIN			1 // Unit: Second
#define TIME_ANIMATION_BATTERY			1 // Unit: Second
#define TIME_ANIMATION_CONNECTION		1 // Unit: Second
#define TIME_ANIMATION_START_PRESS		1 // Unit: Second
#define TIME_ANIMATION_ALARM			5 // Unit: Second
#define TIME_REFRESH_TIME				5 // Unit: Second
#define TIME_AUTH_RESULT_TIME			5 // Unit: Second
#define TIME_REFRESH_INFO				3 // Unit: Second

#define is_error(ptr) 					((unsigned long)ptr > (unsigned long)-4000L)

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

int Uart1Fd;
int GettingCurrentPage = 255;
int SettingCurrentPage = 255;
int CheckCurrentPageCounter = 0;

//=======================================
// Record version and date
//=======================================
char *FIRMWARE_UPDATE_IMAGE[3] = {"V0.31", "2022-10-18", "REV.03.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;
}

void refreshStartTimer(struct timespec *timer)
{
	clock_gettime(CLOCK_MONOTONIC, timer);
}

int getDiffSecNow(struct timespec timer)
{
	struct timespec timerNow;

	clock_gettime(CLOCK_MONOTONIC, &timerNow);

	return (int)((((unsigned long)(timerNow.tv_sec - timer.tv_sec) * 1000) + ((unsigned long)((timerNow.tv_nsec / 1000000) - (timer.tv_nsec / 1000000))))/1000);
}

int getDiffSecBetween(struct timespec start, struct timespec end)
{
	return (int)((((unsigned long)(end.tv_sec - start.tv_sec) * 1000) + ((unsigned long)((end.tv_nsec / 1000000) - (start.tv_nsec / 1000000))))/1000);
}

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

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

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

int ElapsedTime(uint8_t *start)
{
	int time = 0;
	struct ParsingResult
	{
		int result;
		int scanedElement;
		int year;
		int month;
		int mday;
		int hour;
		int min;
		int sec;
		int tz_hour;
		int tz_min;
		float minSec;
	}parsingResult;

	struct tm tmStart;
	struct timeb tbStart;

	memset(&parsingResult, 0x00, sizeof(struct ParsingResult));

	if(strstr((char*)start, ".") != NULL)
	{
		// Original data with mini second
		if(strstr((char*)start, "Z") != NULL)
		{
			// Original data with Z
			parsingResult.scanedElement = sscanf((char*)start, "%d-%d-%dT%d:%d:%d.%fZ",
																&parsingResult.year,
																&parsingResult.month,
																&parsingResult.mday,
																&parsingResult.hour,
																&parsingResult.min,
																&parsingResult.sec,
																&parsingResult.minSec);
		}
		else
		{
			// Original data without Z
			parsingResult.scanedElement = sscanf((char*)start, "%d-%d-%dT%d:%d:%d.%f%d:%d",
												&parsingResult.year,
												&parsingResult.month,
												&parsingResult.mday,
												&parsingResult.hour,
												&parsingResult.min,
												&parsingResult.sec,
												&parsingResult.minSec,
												&parsingResult.tz_hour,
												&parsingResult.tz_min);
		}
	}
	else
	{
		// Original data without mini second
		if(strstr((char*)start, "Z") != NULL)
		{
			// Original data with Z
			parsingResult.scanedElement = sscanf((char*)start, "%d-%d-%dT%d:%d:%dZ",
												&parsingResult.year,
												&parsingResult.month,
												&parsingResult.mday,
												&parsingResult.hour,
												&parsingResult.min,
												&parsingResult.sec);
		}
		else
		{
			// Original data without Z
			parsingResult.scanedElement = sscanf((char*)start, "%d-%d-%dT%d:%d:%d%d:%d",
												&parsingResult.year,
												&parsingResult.month,
												&parsingResult.mday,
												&parsingResult.hour,
												&parsingResult.min,
												&parsingResult.sec,
												&parsingResult.tz_hour,
												&parsingResult.tz_min);
		}
	}

	if(parsingResult.scanedElement >= 6)
	{
		tmStart.tm_year = parsingResult.year - 1900;
		tmStart.tm_mon = parsingResult.month - 1;
		tmStart.tm_mday = parsingResult.mday;
		tmStart.tm_hour = parsingResult.hour;
		tmStart.tm_min = parsingResult.min;
		tmStart.tm_sec = parsingResult.sec;
		tmStart.tm_gmtoff = 0;
		tbStart.time = mktime(&tmStart);
		tbStart.timezone = 0;
		tbStart.millitm = 0;

		tbStart.time -= (parsingResult.tz_hour*3600) + (parsingResult.tz_min*60*(parsingResult.tz_hour>=0?1:-1));

		if(DiffTimebWithNowSec(tbStart) <= 0)
			time = 0;
		else
			time = DiffTimebWithNowSec(tbStart);
	}
	else
	{
		DEBUG_WARN("Start date parsing error.\n");
	}

	return time;
}

void getDateTimeString(char* result)
{
	struct ParsingResult
	{
		int scanedElement;
		int tz_hour;
		int tz_min;
	}timeOffset;
	time_t CurrentTime;
	struct tm *tmOrg;
	struct tm *tmTarget;
	struct timeb tbTarget;

	CurrentTime = time(NULL);
	tmOrg=localtime(&CurrentTime);
	tmOrg->tm_gmtoff = 0;
	tbTarget.time = mktime(tmOrg);
	tbTarget.timezone = 0;

	if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
	{
		if((timeOffset.scanedElement = sscanf((char*)ShmOCPP16Data->ConfigurationTable.CoreProfile[TimeOffset].ItemData, "%d:%d", &timeOffset.tz_hour, &timeOffset.tz_min)) == 2)
		{
			tbTarget.time += (timeOffset.tz_hour*3600) + (timeOffset.tz_min*60*(timeOffset.tz_hour>=0?1:-1));
		}
	}
	else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
	{
		// OCPP 2.0.1
	}

	tmTarget = gmtime(&tbTarget.time);
	//sprintf(result, "%04d/%02d/%02d %02d:%02d", tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min);
	//sprintf(result, "%04d/%02d/%02d %02d:%02d %s", tmTarget->tm_year+1900,tmTarget->tm_mon+1,tmTarget->tm_mday,(tmTarget->tm_hour%12),tmTarget->tm_min,((tmTarget->tm_hour/12)>0?"p.m":"a.m"));

	if((tmTarget->tm_hour%12) == 0)
		sprintf(result, "%04d/%02d/%02d %02d:%02d %s", tmTarget->tm_year+1900,tmTarget->tm_mon+1,tmTarget->tm_mday,((tmTarget->tm_hour%12)==0?12:(tmTarget->tm_hour%12)),tmTarget->tm_min,((tmTarget->tm_hour/12)==1?"p.m.":"a.m."));
	else
		sprintf(result, "%04d/%02d/%02d %02d:%02d %s", tmTarget->tm_year+1900,tmTarget->tm_mon+1,tmTarget->tm_mday,(tmTarget->tm_hour%12),tmTarget->tm_min,((tmTarget->tm_hour/12)>0?"p.m.":"a.m."));
}

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

uint8_t ocpp_compare_reserve_id_with_user(uint8_t gun_index)
{
	uint8_t result = OFF;

	if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
	{
		if(strcmp((char*)ShmSysConfigAndInfo->SysConfig.UserId, (char*)ShmOCPP16Data->ReserveNow[gun_index].IdTag) == 0)
			result = ON;
	}
	else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
	{
		if(strcmp((char*)ShmSysConfigAndInfo->SysConfig.UserId, (char*)ShmOCPP20Data->ReserveNow[gun_index].idToken.idToken) == 0)
			result = ON;
	}

	return result;
}

uint8_t ocpp_compare_reserve_id_with_remote_user(uint8_t gun_index)
{
	uint8_t result = OFF;

	if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
	{
		if(strcmp((char*)ShmOCPP16Data->RemoteStartTransaction[gun_index].IdTag, (char*)ShmOCPP16Data->ReserveNow[gun_index].IdTag) == 0)
		{
			result = ON;
			memcpy(ShmSysConfigAndInfo->SysConfig.UserId, ShmOCPP16Data->RemoteStartTransaction[gun_index].IdTag, ARRAY_SIZE(ShmOCPP16Data->RemoteStartTransaction[gun_index].IdTag));
		}
	}
	else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
	{
		if(strcmp((char*)ShmOCPP20Data->RequestStartTransaction[gun_index].idToken.idToken, (char*)ShmOCPP20Data->ReserveNow[gun_index].idToken.idToken) == 0)
		{
			result = ON;
			memcpy(ShmSysConfigAndInfo->SysConfig.UserId, ShmOCPP20Data->RequestStartTransaction[gun_index].idToken.idToken, ARRAY_SIZE(ShmSysConfigAndInfo->SysConfig.UserId));
		}
	}

	return result;
}

//=======================================
// Function to page routine
//=======================================
void page_booting()
{
	if(getCurrentPage() != SYSTEM_SCREEN_BOOTING)
	{
		setCurrentPage(SYSTEM_SCREEN_BOOTING);
	}
	else
	{
		setClearPrechargingValueToEmpty();
	}
}

void page_idle(uint8_t gun_index, uint8_t system_mode)
{
	setPrechargingTimerToDefault();
	setPrechargingEnergyToDefault();
	setPrechargingSessionFeeToDefault();
	setPrechargingParkingFeeToDefault();
	setPrechargingCostToDefault();
	setPrechargingPowerToDefault();

	if(ocpp_get_isRemoteStartWait())
	{
		if((getCurrentPage() != SYSTEM_SCREEN_PREPARING))
		{
			setCurrentPage(SYSTEM_SCREEN_PREPARING);
		}
		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);
				setPressStartButtonAnimation(gun_index);
				START_PRESS_LEVEL_STATIS = PRESS_START_LEVEL_0;
			}
			else
			{
				setPressStartButtonAnimation(gun_index);
			}
		}
		else
		{
			if(ShmCharger->gun_info[gun_index].isCheckPowerConsumption == YES)
			{
				setCurrentPage(SYSTEM_SCREEN_POWER_CONSUMPTION);
				setDisplayValue(ICON_POWER_CONSUMPTION, APPEAR);
				setPresentPowerConsumption(gun_index);
				setCsuRootFsFwRev();
			}
			else
			{
				if(ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_DISABLE)
				{
					if((getCurrentPage() != SYSTEM_SCREEN_PLUG_AND_CHARGE))
					{
						setCurrentPage(SYSTEM_SCREEN_PLUG_AND_CHARGE);
						setDefaultValue(gun_index, system_mode);
					}
					else
					{
						setPlugAndChargeAnimation(gun_index);
					}
				}
				else
				{
					if((ShmSysConfigAndInfo->SysConfig.isAuthrizeByEVCCID && (ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_ENABLE)) &&
					   (ShmCharger->isCcsEnable) &&
					   (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_B) &&
					   (ShmCharger->gun_info[gun_index].isGetEvCCIDTimeout == OFF) &&
					   (ShmCharger->gun_info[gun_index].resultAuthorization != VALIDATED_RFID) &&
					   (ShmCharger->gun_info[gun_index].isRemoteStartWait != ON) &&
					   (ShmCharger->gun_info[gun_index].isEvCCIDAuthorizeFail != YES))
					{
						if((getCurrentPage() != SYSTEM_SCREEN_PREPARE_FOR_EVSE))
						{
							setCurrentPage(SYSTEM_SCREEN_PREPARE_FOR_EVSE);
						}
						else
						{
							setConnectionAnimation(gun_index, system_mode);
						}
					}
					else
					{
						if((getCurrentPage() != SYSTEM_SCREEN_IDLE) && (ShmCharger->gun_info[gun_index].resultAuthorization != VALIDATED_RFID))
						{
							setCurrentPage(SYSTEM_SCREEN_IDLE);
							setDefaultValue(gun_index, system_mode);
						}
						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 if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
		{
			// 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);
		}
		else
		{
			setPrechargingTimerToDefault();
			setPrechargingEnergyToDefault();
			setPrechargingSessionFeeToDefault();
			setPrechargingParkingFeeToDefault();
			setPrechargingCostToDefault();
			setPrechargingPowerToDefault();
			setConnectionAnimation(gun_index, system_mode);
			setPresentChargedEnergy(gun_index, system_mode);
		}
	}
	else
	{
		if((getCurrentPage() != SYSTEM_SCREEN_PREPARING))
		{
			setCurrentPage(SYSTEM_SCREEN_PREPARING);
			setDefaultValue(gun_index, system_mode);
		}
		else
		{
			setPresentConnectionTimeout(gun_index);
			setConnectionAnimation(gun_index, system_mode);
			setGunPluginAnimation(gun_index);
			setPresentChargedEnergy(gun_index, system_mode);
		}
	}
}

void page_charging(uint8_t gun_index, uint8_t system_mode)
{
	static char runningCost[1024] = {0};

	if((getCurrentPage() != SYSTEM_SCREEN_CHARGING) && (!ShmCharger->isAuthrizing && !ShmCharger->isGetAuthResult))
	{
		setCurrentPage(SYSTEM_SCREEN_CHARGING);
		setDefaultValue(gun_index, system_mode);
	}
	else
	{
		setConnectionAnimation(gun_index, system_mode);
		setPresentChargedDuration(gun_index);
		setPresentChargedPower(gun_index);
		setTimeTitle(ON);
		setEnergyTitle(ON);

		if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
		{
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				// Title appear
				setSessionFeeTitle(ON);
				setParkingFeeTitle(ON);
				setFinalCostTitle(ON);
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// DISPLAY BY OCPP 2.0.1
			}
		}
		else
		{
			if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
			{
				// Title appear
				setSessionFeeTitle(ON);
				setParkingFeeTitle(ON);
				setFinalCostTitle(ON);
			}
			else
			{
				// Title disappear
				setSessionFeeTitle(OFF);
				setParkingFeeTitle(OFF);
				setFinalCostTitle(OFF);
			}
		}

		if((getDiffSecNow(startTime[gun_index][TMR_IDX_REFRESH_INFO]) >= TIME_REFRESH_INFO) || (ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16?(strcmp((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].description, runningCost) != 0):YES))
		{
			setPresentChargedEnergy(gun_index, system_mode);
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				memcpy((char*) runningCost,(char*)ShmOCPP16Data->Cost.RunningCost[gun_index].description,ARRAY_SIZE(ShmOCPP16Data->Cost.RunningCost[gun_index].description));
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// OCPP 2.0.1
			}

			if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
			{
				if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
				{
					setRunningCost(gun_index, SESSION_FEE);
					setRunningCost(gun_index, OCCUPANCY_FEE);
					setRunningCost(gun_index, TOTAL_COST);
				}
				else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
				{
					// DISPLAY BY OCPP 2.0.1
				}
			}
			else
			{
				if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
				{
					setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
					setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
					setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);

					setPresentFinalCost(getPresentFinalCost(gun_index));
					//setPresentSessionFee();
					setPresentParkingFee();
				}
				else
				{
					// Total cost disappear
					setDisplayValue(ICON_CHARGING_TOTAL_COST, DISAPPEAR);
					setDisplayValue(TEXT_CHARGING_TOTAL_COST, DISAPPEAR);

					// Session fee disappear
					setDisplayValue(ICON_CHARGING_SESSION_FEE, DISAPPEAR);
					setDisplayValue(TEXT_CHARGING_SESSION_FEE, DISAPPEAR);

					// Parking fee disappear
					setDisplayValue(ICON_CHARGING_PARKING_FEE, DISAPPEAR);
					setDisplayValue(TEXT_CHARGING_PARKING_FEE, DISAPPEAR);

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

			refreshStartTimer(&startTime[gun_index][TMR_IDX_REFRESH_INFO]);
		}
	}
}

void page_complete(uint8_t gun_index, uint8_t system_mode)
{
	if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus != ON))
	{
		if(getCurrentPage() != SYSTEM_SCREEN_COMPLETE)
		{
			setCurrentPage(SYSTEM_SCREEN_COMPLETE);
		}
		else
		{}
	}
	else
	{
		if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
		{
			if(ShmOCPP16Data->StopTransaction[gun_index].TransactionId != ShmOCPP16Data->Cost.FinalCost[gun_index].txId)
			{
				if(getCurrentPage() != SYSTEM_SCREEN_COMPLETE)
				{
					setCurrentPage(SYSTEM_SCREEN_COMPLETE);
				}
				else
				{}
			}
			else
			{
				if((strcmp((char *)ShmOCPP16Data->Cost.FinalCost[gun_index].qrCodeText,"") != 0))
				{
					if(getCurrentPage() != SYSTEM_SCREEN_COMPLETE_WITH_QRCODE)
					{
						setCurrentPage(SYSTEM_SCREEN_COMPLETE_WITH_QRCODE);
						setQRCodeReceipt(gun_index);
						DEBUG_INFO("[CDFA 2.0].\n");
					}
					else
					{
						setQRCodeReceipt(gun_index);
					}
				}
				else
				{
					if((strcmp((char *)&ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL,"") != 0))
					{
						if(getCurrentPage() != SYSTEM_SCREEN_COMPLETE_WITH_QRCODE)
						{
							setCurrentPage(SYSTEM_SCREEN_COMPLETE_WITH_QRCODE);
							setQRCodeReceipt(gun_index);
							DEBUG_INFO("[CDFA 1.0].\n");
						}
						else
						{
							setQRCodeReceipt(gun_index);
						}
					}
					else
					{
						if(getCurrentPage() != SYSTEM_SCREEN_COMPLETE)
						{
							setCurrentPage(SYSTEM_SCREEN_COMPLETE);
						}
						else
						{}
					}
				}
			}
		}
		else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
		{
			// DISPLAY BY OCPP 2.0.1
		}
		else
		{}
	}

	setPresentChargedDuration(gun_index);
	setPresentChargedEnergy(gun_index, system_mode);
	setTimeTitle(ON);
	setEnergyTitle(ON);

	if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
	{
		if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
		{
			setFinalCost(gun_index, TOTAL_COST);
			setFinalCost(gun_index, SESSION_FEE);
			setFinalCost(gun_index, OCCUPANCY_FEE);
			setFinalCost(gun_index, ACCOUNT_BALANCE);

			// Title appear
			setSessionFeeTitle(ON);
			setParkingFeeTitle(ON);
			setFinalCostTitle(ON);
		}
		else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
		{
			// DISPLAY BY OCPP 2.0.1
		}
	}
	else
	{
		if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
		{
			setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
			setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
			setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);

			setPresentFinalCost(getPresentFinalCost(gun_index));
			//setPresentSessionFee();
			setPresentParkingFee();

			setDisplayValue(ICON_COMPLETE_WALLET, DISAPPEAR);
			setDisplayValue(TEXT_REMAINING_ACCOUNT_BALANCE, DISAPPEAR);

			// Title appear
			setSessionFeeTitle(ON);
			setParkingFeeTitle(ON);
			setFinalCostTitle(ON);
		}
		else
		{
			// Total cost disappear
			setDisplayValue(ICON_CHARGING_TOTAL_COST, DISAPPEAR);
			setDisplayValue(TEXT_CHARGING_TOTAL_COST, DISAPPEAR);

			// Session fee disappear
			setDisplayValue(ICON_CHARGING_SESSION_FEE, DISAPPEAR);
			setDisplayValue(TEXT_CHARGING_SESSION_FEE, DISAPPEAR);

			// Parking fee disappear
			setDisplayValue(ICON_CHARGING_PARKING_FEE, DISAPPEAR);
			setDisplayValue(TEXT_CHARGING_PARKING_FEE, DISAPPEAR);

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

			// Title disappear
			setSessionFeeTitle(OFF);
			setParkingFeeTitle(OFF);
			setFinalCostTitle(OFF);
		}
	}
}

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);
	}
	else
	{
		setPresentChargedDuration(gun_index);
		setPresentChargedEnergy(gun_index, system_mode);
		setPresentChargedPower(gun_index);
		setTimeTitle(ON);
		setEnergyTitle(ON);

		if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
		{
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				setRunningCost(gun_index, TOTAL_COST);
				setRunningCost(gun_index, SESSION_FEE);
				setRunningCost(gun_index, OCCUPANCY_FEE);

				// Title appear
				setSessionFeeTitle(ON);
				setParkingFeeTitle(ON);
				setFinalCostTitle(ON);
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// DISPLAY BY OCPP 2.0.1
			}
		}
		else
		{
			if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
			{
				setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
				setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
				setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);

				setPresentFinalCost(getPresentFinalCost(gun_index));
				//setPresentSessionFee();
				setPresentParkingFee();

				// Title appear
				setSessionFeeTitle(ON);
				setParkingFeeTitle(ON);
				setFinalCostTitle(ON);
			}
			else
			{
				// Total cost disappear
				setDisplayValue(ICON_CHARGING_TOTAL_COST, DISAPPEAR);
				setDisplayValue(TEXT_CHARGING_TOTAL_COST, DISAPPEAR);

				// Session fee disappear
				setDisplayValue(ICON_CHARGING_SESSION_FEE, DISAPPEAR);
				setDisplayValue(TEXT_CHARGING_SESSION_FEE, DISAPPEAR);

				// Parking fee disappear
				setDisplayValue(ICON_CHARGING_PARKING_FEE, DISAPPEAR);
				setDisplayValue(TEXT_CHARGING_PARKING_FEE, DISAPPEAR);

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

				// Title disappear
				setSessionFeeTitle(OFF);
				setParkingFeeTitle(OFF);
				setFinalCostTitle(OFF);
			}
		}
	}
}

void page_alarm()
{
	if(ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip != ON)
	{
		if(getCurrentPage() != SYSTEM_SCREEN_ALARM)
		{
			setCurrentPage(SYSTEM_SCREEN_ALARM);
			setQRCodeAlarm();
		}
		else
		{
			setQRCodeAlarm();
		}
	}
	else
	{
		if(getCurrentPage() != SYSTEM_SCREEN_EMERGENCY)
		{
			setCurrentPage(SYSTEM_SCREEN_EMERGENCY);
		}
		else
		{}
	}
}

void page_maintain()
{
	if(getCurrentPage() != SYSTEM_SCREEN_MAINTENANCE)
	{
		setCurrentPage(SYSTEM_SCREEN_MAINTENANCE);
	}
	else
	{}
}

void page_update()
{
	if(getCurrentPage() != SYSTEM_SCREEN_MAINTENANCE)
	{
		setCurrentPage(SYSTEM_SCREEN_MAINTENANCE);
	}
	else
	{}
}

void page_debug()
{
	if(getCurrentPage() != SYSTEM_SCREEN_MAINTENANCE)
	{
		setCurrentPage(SYSTEM_SCREEN_MAINTENANCE);
	}
	else
	{}
}

void page_reservation(){}

void page_booking(){}

void page_fault(){}

void page_unknown(){}

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(getDiffSecNow(startTime[gun_index][TMR_IDX_PRICE]) > (TIME_REFRESH_TIME))
		{
			refreshStartTimer(&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));
}

//=======================================
// SETTING MARQUEE CONTROL DISPLAY VALUE
//=======================================
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));
}

//=======================================
// PRINT OUT SCREEN MODE
//=======================================
char* getDisplayModeName(unsigned char mode)
{
	char* result;

	switch(mode)
	{
		case SYSTEM_SCREEN_BOOTING:
			result = "BOOTING";
			break;
		case SYSTEM_SCREEN_IDLE:
			result = "IDLE";
			break;
		case SYSTEM_SCREEN_PREPARING:
			result = "PREPARING";
			break;
		case SYSTEM_SCREEN_PREPARE_FOR_EVSE:
			result = "PREPARE_FOR_EVSE";
			break;
		case SYSTEM_SCREEN_CHARGING:
			result = "CHARGING";
			break;
		case SYSTEM_SCREEN_COMPLETE:
			result = "COMPLETE";
			break;
		case SYSTEM_SCREEN_MAINTENANCE:
			result = "MAINTENANCE";
			break;
		case SYSTEM_SCREEN_AUTH_PASS:
			result = "AUTH_PASS";
			break;
		case SYSTEM_SCREEN_AUTH_FAIL:
			result = "AUTH_FAIL";
			break;
		case SYSTEM_SCREEN_AUTH_UNKNOWN:
			result = "AUTH_UNKNOWN";
			break;
		case SYSTEM_SCREEN_TERMINATING:
			result = "TERMINATING";
			break;
		case SYSTEM_SCREEN_EMERGENCY:
			result = "EMERGENCY";
			break;
		case SYSTEM_SCREEN_SLEEP:
			result = "SLEEP";
			break;
		case SYSTEM_SCREEN_SLEEP2:
			result = "SLEEP2";
			break;
		case SYSTEM_SCREEN_ALARM:
			result = "ALARM";
			break;
		case SYSTEM_SCREEN_PLUG_AND_CHARGE:
			result = "PLUG_AND_CHARGE";
			break;
		case SYSTEM_SCREEN_COMPLETE_WITH_QRCODE:
			result = "COMPLETE_WITH_QRCODE";
			break;
		case SYSTEM_SCREEN_POWER_CONSUMPTION:
			result = "POWER_CONSUMPTION";
			break;
		default:
			result = "UNKNOWN";
			break;
	}

	return result;
}

//=======================================
// GETTING CURRENT SCREEN 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];

		/*
		if((GettingCurrentPage != result))
		{
			if(CheckCurrentPageCounter >= 3)
			{
				GettingCurrentPage = result;
				DEBUG_INFO("Getting current page: [%s].\n", getDisplayModeName((unsigned char)GettingCurrentPage));
			}
			CheckCurrentPageCounter++;
		}
		else
		{
			CheckCurrentPageCounter = 0;
		}
		*/
	}
	else
	{
		DEBUG_INFO("Getting current page: [Fail].\n");
	}

	return result;
}

//=======================================
// SETTING CURRENT SCREEN PAGE
//=======================================
void setCurrentPage(uint8_t page)
{
	uint8_t settingPage[2];
	settingPage[0] = 0x00;
	settingPage[1] = page;

	if(lcdRegisterWrite(Uart1Fd, REG_TYPE_CONTROL, REG_ADDRESS_SET_PAGE_ID, settingPage, ARRAY_SIZE(settingPage)))
	{
		if(SettingCurrentPage != page)
		{
			SettingCurrentPage = page;
			DEBUG_INFO("Setting current page: [%s].\n", getDisplayModeName((unsigned char)SettingCurrentPage), SettingCurrentPage);

			if(ocpp_get_isRemoteStartWait())
			{
				DEBUG_INFO("[Remote to start without the connector id].\n");
			}
			else
			{}
		}
	}
	else
	{
		DEBUG_INFO("Setting current page: [Fail].\n");
	}
}

//=======================================
// CONVERT STRING TO BYTE ARRAY
//=======================================
void string2ByteArray(uint8_t *input, uint8_t *output)
{
    int loop;
    int i;

    loop = 0;
    i = 0;

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

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

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

//========================================
// SETTING ICON [ETHERNET]
//========================================
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 ICON [WIFI/4G]
//=======================================
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 CONTENT [RTC]
//========================================
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 CONTENT [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 CONTNET [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 CONTENT [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 CONTENT [FINAL COST] WEB PAGE
//=======================================
void setPresentFinalCost(float cost)
{
	uint8_t data[32];
	uint8_t finalCost[32];

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

	sprintf((char *)finalCost, "$ %.2f", cost);
	string2ByteArray(finalCost, data);

	// Total Cost
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, data, ARRAY_SIZE(data));

	// Session Fee
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, data, ARRAY_SIZE(data));
}

//=======================================
// SETTING CONTENT [SESSION FEE] WEB PAGE
//=======================================
void setPresentSessionFee()
{
	uint8_t data[32];
	uint8_t sessionFee[32];

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

	strcpy((char*)sessionFee, "$ -----");
	string2ByteArray(sessionFee, data);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, data, ARRAY_SIZE(data));
}

//=======================================
// SETTING CONTENT [PARKING FEE] WEB PAGE
//=======================================
void setPresentParkingFee()
{
	uint8_t data[32];
	uint8_t parkingFee[32];

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

	strcpy((char*)parkingFee, "$ -----");
	string2ByteArray(parkingFee, data);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, data, ARRAY_SIZE(data));
}

//=======================================
// GETTING VALUE [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 BACKEND [BILLING]
//=======================================
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)))
						{
							setDisplayValue(ICON_PRICE, APPEAR);
							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
				{
					if(system_mode == SYS_MODE_IDLE)
					{
						setDisplayValue(TEXT_PRICE, DISAPPEAR);
						setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
						setDisplayValue(ICON_PRICE, DISAPPEAR);
						setDisplayValue2(MARQUEES_DEFAULT_PRICE, DISAPPEAR);
					}
					else
					{
						if((strcmp((char*)ShmSysConfigAndInfo->SysConfig.UserId, (char *)ShmOCPP16Data->Cost.SetUserPrice.idToken) == 0) && ((strcmp((char *)ShmOCPP16Data->Cost.SetUserPrice.idToken,"") != 0)))
						{
							setDisplayValue(TEXT_PRICE, DISAPPEAR);
							setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
							setDisplayValue(ICON_PRICE, APPEAR);
							setMarqueeControl(MARQUEES_DEFAULT_PRICE, gun_index, SET_USER_PRICE);
						}
						else
						{
							setDisplayValue(TEXT_PRICE, DISAPPEAR);
							setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
							setDisplayValue(ICON_PRICE, DISAPPEAR);
							setDisplayValue2(MARQUEES_DEFAULT_PRICE, DISAPPEAR);

						}
					}
				}
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// DISPLAY BY OCPP 2.0.1
			}
		}
		else
		{
			if(strstr((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData, "priceTextOffline") > 0)
			{
				setDisplayValue(TEXT_PRICE, DISAPPEAR);
				setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
				setDisplayValue(ICON_PRICE, APPEAR);
				setMarqueeControl(MARQUEES_DEFAULT_PRICE, gun_index, DEFAULE_PRICE);
			}
			else
			{
				setDisplayValue(TEXT_PRICE, DISAPPEAR);
				setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
				setDisplayValue(ICON_PRICE, DISAPPEAR);
				setDisplayValue2(MARQUEES_DEFAULT_PRICE, DISAPPEAR);
			}
		}
	}
}

//=======================================
// SETTING BACKEDN [USER PRICE]
//=======================================
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(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				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);
				}
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// OCPP 2.0.1
			}
			break;
		case OCCUPANCY_FEE:
			break;
		case ACCOUNT_BALANCE:
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				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);
				}
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// OCPP 2.0.1
			}
			break;
		default:
			break;
	}
}

//=======================================
// SETTING BACKEND [FINAL COST]
//=======================================
void setFinalCost(uint8_t gun_index, uint8_t type)
{
	uint8_t output_data[32];
	unsigned char cost_empty[32];
	unsigned char balance_empty[32];
	unsigned char session_empty[32];
	unsigned char occupancy_empty[32];
	unsigned char priceText[1024];
	json_object *jsonDescription;

	memset(output_data, 0x00, ARRAY_SIZE(output_data));
	memset(cost_empty, 0x00, ARRAY_SIZE(cost_empty));
	memset(balance_empty, 0x00, ARRAY_SIZE(balance_empty));
	memset(session_empty, 0x00, ARRAY_SIZE(session_empty));
	memset(occupancy_empty, 0x00, ARRAY_SIZE(occupancy_empty));
	memset(priceText, 0x00, ARRAY_SIZE(priceText));

	switch(type)
	{
		case CONNECTION_FEE:
			break;
		case SESSION_FEE:
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				if(ShmOCPP16Data->StopTransaction[gun_index].TransactionId != ShmOCPP16Data->Cost.FinalCost[gun_index].txId)
				{
					setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);

					strcpy((char*)session_empty, "$ -----");
					string2ByteArray(session_empty, output_data);
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, output_data, ARRAY_SIZE(output_data));
				}
				else
				{
					if((strcmp((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description,"") != 0))
					{
						//========================
						// CDFA 1.0 Structure
						//========================
						double chargingCost = 0;
						jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description);

						if(!is_error(jsonDescription))
						{
							if(json_object_object_get(jsonDescription,"chargingFee") != NULL)
							{
								chargingCost += json_object_get_double(json_object_object_get(jsonDescription,"chargingFee"));
							}

							if(chargingCost> 0)
								sprintf((char*)output_data, "$ %.2f", chargingCost);
							else
								sprintf((char*)output_data, "$ -----");

							// APPEAR COST ICON
							setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
							lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, output_data, ARRAY_SIZE(output_data));
						}
						json_object_put(jsonDescription);
					}
					else
					{
						//========================
						// CDFA 2.0 Structure
						//========================
						double FLAT_FEE = 0;
						double INPUT_COST = 0;
						double OUTPUT_COST = 0;
						double END_OF_SESSION_HOUR_PRICE = 0;
						double END_OF_SESSION_IDLE_PRICE = 0;

						// Final cost [Cost]
						if(ShmOCPP16Data->Cost.FinalCost[gun_index].cost != 0)
						{
							INPUT_COST = ShmOCPP16Data->Cost.FinalCost[gun_index].cost;

							// Running cost [Flat fee]
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.flatFee != 0)
							{
								FLAT_FEE = ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.flatFee;
							}

							// Running cost [Hour price]
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.hourPrice != 0)
							{
								if(CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_HOUR_PRICE > 0)
								{
									// Save at last [Hour price] from running cost
									END_OF_SESSION_HOUR_PRICE = CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_HOUR_PRICE;
								}
							}

							// Running cost [Idle -> Hour price]
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].idlePrice.hourPrice != 0)
							{
								if(CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_IDLE_PRICE > 0)
								{
									// Save at last [Idle -> Hour price] from running cost
									END_OF_SESSION_IDLE_PRICE = CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_IDLE_PRICE;
								}
							}

							// Running cost [kWh price]
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.kWhPrice != 0)
							{
								// [Cost] - [Flat fee] - [Hour price] - [Idle -> Hour price] = [kWh price]
								OUTPUT_COST = INPUT_COST - FLAT_FEE - END_OF_SESSION_HOUR_PRICE - END_OF_SESSION_IDLE_PRICE;
							}
						}

						if(OUTPUT_COST > 0)
							sprintf((char*)output_data, "$ %.2f", OUTPUT_COST);
						else
							sprintf((char*)output_data, "$ -----");

						// APPEAR COST ICON
						setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
						lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, output_data, ARRAY_SIZE(output_data));
					}
				}
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// OCPP 2.0.1
			}
			break;
		case OCCUPANCY_FEE:
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				if(ShmOCPP16Data->StopTransaction[gun_index].TransactionId != ShmOCPP16Data->Cost.FinalCost[gun_index].txId)
				{
					setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);

					strcpy((char*)occupancy_empty, "$ -----");
					string2ByteArray(occupancy_empty, output_data);
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, output_data, ARRAY_SIZE(output_data));
				}
				else
				{
					if((strcmp((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description,"") != 0))
					{
						//========================
						// CDFA 1.0 Structure
						//========================
						double parkingCost = 0;
						jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description);

						if(!is_error(jsonDescription))
						{
							if(json_object_object_get(jsonDescription,"parkingFee") != NULL)
							{
								parkingCost += json_object_get_double(json_object_object_get(jsonDescription,"parkingFee"));
							}

							if(parkingCost > 0)
								sprintf((char*)output_data, "$ %.2f", parkingCost);
							else
								sprintf((char*)output_data, "$ -----");

							setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);
							lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, output_data, ARRAY_SIZE(output_data));
						}
						json_object_put(jsonDescription);
					}
					else
					{
						//========================
						// CDFA 2.0 Structure
						//========================
						double INPUT_COST = 0;
						double OUTPUT_COST = 0;
						double FLAT_FEE = 0;
						double END_OF_SESSION_KWH_PRICE = 0;
						double END_OF_SESSION_IDLE_PRICE = 0;

						// Final cost [Cost]
						if(ShmOCPP16Data->Cost.FinalCost[gun_index].cost != 0)
						{
							INPUT_COST = ShmOCPP16Data->Cost.FinalCost[gun_index].cost;

							// Running cost [Flat fee]
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.flatFee != 0)
							{
								FLAT_FEE = ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.flatFee;
							}

							// Running cost [kWh price]
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.kWhPrice != 0)
							{
								if(CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_KWH_PRICE > 0)
								{
									// Save at last [kWh price] from running cost
									END_OF_SESSION_KWH_PRICE = CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_KWH_PRICE;
								}
							}

							// Running cost [Idle -> Hour price]
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].idlePrice.hourPrice != 0)
							{
								if(CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_IDLE_PRICE > 0)
								{
									// Save at last [Idle -> Hour price] from running cost
									END_OF_SESSION_IDLE_PRICE = CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_IDLE_PRICE;
								}
							}

							// [Hour price] sending from the central system
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.hourPrice != 0)
							{
								// [Cost] - [Flat fee] - [kWh price] - [Idle -> Hour price] = [Hour price]
								OUTPUT_COST = INPUT_COST - FLAT_FEE - END_OF_SESSION_KWH_PRICE - END_OF_SESSION_IDLE_PRICE;
							}
						}

						if(OUTPUT_COST > 0)
							sprintf((char*)output_data, "$ %.2f", OUTPUT_COST);
						else
							sprintf((char*)output_data, "$ -----");

						setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);
						lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, output_data, ARRAY_SIZE(output_data));
					}
				}
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// OCPP 2.0.1
			}
			break;
		case TOTAL_COST:
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				if(ShmOCPP16Data->StopTransaction[gun_index].TransactionId != ShmOCPP16Data->Cost.FinalCost[gun_index].txId)
				{
					setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);

					strcpy((char*)cost_empty, "$ -----");
					string2ByteArray(cost_empty, output_data);
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, output_data, ARRAY_SIZE(output_data));
				}
				else
				{
					if((strcmp((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description,"") != 0))
					{
						//========================
						// CDFA 1.0 Structure
						//========================
						double chargingCost = 0;
						double parkingCost = 0;
						jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description);

						if(!is_error(jsonDescription))
						{
							if(json_object_object_get(jsonDescription,"chargingFee") != NULL)
							{
								chargingCost += json_object_get_double(json_object_object_get(jsonDescription,"chargingFee"));
							}

							if(json_object_object_get(jsonDescription,"parkingFee") != NULL)
							{
								parkingCost += json_object_get_double(json_object_object_get(jsonDescription,"parkingFee"));
							}

							if((chargingCost + parkingCost) > 0)
								sprintf((char*)output_data, "$ %.2f", (chargingCost + parkingCost));
							else
								sprintf((char*)output_data, "$ -----");

							// APPEAR COST ICON
							setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
							lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, output_data, ARRAY_SIZE(output_data));
						}
						json_object_put(jsonDescription);
					}
					else
					{
						//========================
						// CDFA 2.0 Structure
						//========================
						double OUTPUT_COST = 0;

						// Final cost [Cost]
						if(ShmOCPP16Data->Cost.FinalCost[gun_index].cost != 0)
						{
							OUTPUT_COST = ShmOCPP16Data->Cost.FinalCost[gun_index].cost;
						}

						if(OUTPUT_COST > 0)
							sprintf((char*)output_data, "$ %.2f", OUTPUT_COST);
						else
							sprintf((char*)output_data, "$ -----");

						// APPEAR COST ICON
						setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
						lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, output_data, ARRAY_SIZE(output_data));
					}
				}
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// OCPP 2.0.1
			}
			break;
		case ACCOUNT_BALANCE:
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				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
				{
					double accountBalance = 0;
					jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description);

					if(!is_error(jsonDescription))
					{
						if(json_object_object_get(jsonDescription,"accountBalance") != NULL)
						{
							accountBalance += json_object_get_double(json_object_object_get(jsonDescription,"accountBalance"));
						}

						if(accountBalance > 0)
							sprintf((char*)output_data, "$ %.2f", accountBalance);
						else
							sprintf((char*)output_data, "$ -----");


						// APPEAR COST ICON
						setDisplayValue(ICON_COMPLETE_WALLET, APPEAR);
						lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_REMAINING_ACCOUNT_BALANCE, output_data, ARRAY_SIZE(output_data));
					}
					json_object_put(jsonDescription);
				}
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// OCPP 2.0.1
			}
			break;
		case PRICE_TEXT:
			if(ShmOCPP16Data->StopTransaction[gun_index].TransactionId != ShmOCPP16Data->Cost.FinalCost[gun_index].txId)
			{

			}
			else
			{
				memcpy((char*) priceText,(char*)ShmOCPP16Data->Cost.FinalCost[gun_index].priceText,ARRAY_SIZE(priceText));
			}
			break;
		default:
			break;
	}
}

//=======================================
// SETTING BACKEND [RUNNING COST]
//=======================================
void setRunningCost(uint8_t gun_index, uint8_t type)
{
	uint8_t output_data[32];
	unsigned char cost_empty[32];
	unsigned char session_empty[32];
	unsigned char occupancy_empty[32];
	json_object *jsonDescription;

	memset(output_data, 0x00, ARRAY_SIZE(output_data));
	memset(cost_empty, 0x00, ARRAY_SIZE(cost_empty));
	memset(session_empty, 0x00, ARRAY_SIZE(session_empty));
	memset(occupancy_empty, 0x00, ARRAY_SIZE(occupancy_empty));

	switch(type)
	{
		case CONNECTION_FEE:
			break;
		case SESSION_FEE:
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				if(ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId != ShmOCPP16Data->Cost.RunningCost[gun_index].txId)
				{
					setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);

					strcpy((char*)session_empty, "$ -----");
					string2ByteArray(session_empty, output_data);
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, output_data, ARRAY_SIZE(output_data));
				}
				else
				{
					if((strcmp((char *)&ShmOCPP16Data->Cost.RunningCost[gun_index].description,"") != 0))
					{
						//========================
						// CDFA 1.0 Structure
						//========================
						double chargingCost = 0;
						jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].description);

						if(!is_error(jsonDescription))
						{
							if(json_object_object_get(jsonDescription,"chargingFee") != NULL)
							{
								chargingCost += json_object_get_double(json_object_object_get(jsonDescription,"chargingFee"));
							}

							if(chargingCost> 0)
								sprintf((char*)output_data, "$ %.2f", chargingCost);
							else
								sprintf((char*)output_data, "$ -----");

							// APPEAR COST ICON
							setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
							lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, output_data, ARRAY_SIZE(output_data));
						}
						json_object_put(jsonDescription);
					}
					else
					{
						//========================
						// CDFA 2.0 Structure
						//========================
						double INPUT_COST = 0;
						double OUTPUT_COST = 0;
						double FLAT_FEE = 0;
						double PRESENT_KWH_PRICE = 0;
						double PREVIOUS_KWH_PRICE = 0;
						double PRESENT_HOUR_PRICE = 0;

						if(strcmp((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].state ,"Charging") == 0)
						{
							// Running cost [Cost]
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].cost != 0)
							{
								INPUT_COST = ShmOCPP16Data->Cost.RunningCost[gun_index].cost;
							}

							// Running cost [Flat fee]
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.flatFee != 0)
							{
								FLAT_FEE = ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.flatFee;
							}

							// Running cost [Hour price]
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.hourPrice != 0)
							{
								if((strcmp((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].timestamp, "") != 0) && (ElapsedTime(ShmOCPP16Data->Cost.RunningCost[gun_index].timestamp) > 0))
								{
									PRESENT_HOUR_PRICE = (((float)ElapsedTime(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP)/3600)*ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.hourPrice);
									if(strcmp((char*)CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP, (char*)ShmOCPP16Data->Cost.RunningCost[gun_index].timestamp) != 0)
									{
										CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_HOUR_PRICE = PRESENT_HOUR_PRICE + CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_HOUR_PRICE;
										strcpy((char*)CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP, (char*)ShmOCPP16Data->Cost.RunningCost[gun_index].timestamp);
									}
								}
								else
								{
									CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_HOUR_PRICE = 0;
									memset(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP, 0x00, ARRAY_SIZE(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP));
								}
							}
							else
							{
								CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_HOUR_PRICE = 0;
								memset(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP, 0x00, ARRAY_SIZE(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP));
							}

							// Running cost [kWh price]
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.kWhPrice != 0)
							{
								PREVIOUS_KWH_PRICE = INPUT_COST;
								if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.flatFee != 0)
								{
									PREVIOUS_KWH_PRICE = INPUT_COST - FLAT_FEE;
									if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.hourPrice != 0)
									{
										PREVIOUS_KWH_PRICE = INPUT_COST - FLAT_FEE - CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_HOUR_PRICE;
									}
								}
								else
								{
									if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.hourPrice != 0)
									{
										PREVIOUS_KWH_PRICE = INPUT_COST - CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_HOUR_PRICE;
									}
								}

								PRESENT_KWH_PRICE = ((float)(((ShmCharger->gun_info[gun_index].powerConsumptionTotal.power_consumption/10) - ShmOCPP16Data->Cost.RunningCost[gun_index].meterValue)/1000.00)*ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.kWhPrice);
								OUTPUT_COST = PREVIOUS_KWH_PRICE + PRESENT_KWH_PRICE;
								CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_KWH_PRICE = OUTPUT_COST;
							}
						}
						else if(strcmp((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].state ,"Idle") == 0)
						{
							// Shown at last value for kWh price
							OUTPUT_COST = CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_KWH_PRICE;
						}
						else
						{}

						if(OUTPUT_COST > 0)
							sprintf((char*)output_data, "$ %.2f", OUTPUT_COST);
						else
							sprintf((char*)output_data, "$ -----");

						// APPEAR COST ICON
						setDisplayValue(ICON_CHARGING_SESSION_FEE, APPEAR);
						lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, output_data, ARRAY_SIZE(output_data));
					}
				}
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// OCPP 2.0.1
			}
			break;
		case OCCUPANCY_FEE:
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				if(ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId != ShmOCPP16Data->Cost.RunningCost[gun_index].txId)
				{
					setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);

					strcpy((char*)occupancy_empty, "$ -----");
					string2ByteArray(occupancy_empty, output_data);
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, output_data, ARRAY_SIZE(output_data));
				}
				else
				{
					if((strcmp((char *)&ShmOCPP16Data->Cost.RunningCost[gun_index].description,"") != 0))
					{
						//========================
						// CDFA 1.0 Structure
						//========================
						double parkingCost = 0;
						jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].description);

						if(!is_error(jsonDescription))
						{
							if(json_object_object_get(jsonDescription,"parkingFee") != NULL)
							{
								parkingCost += json_object_get_double(json_object_object_get(jsonDescription,"parkingFee"));
							}

							if(parkingCost > 0)
								sprintf((char*)output_data, "$ %.2f", parkingCost);
							else
								sprintf((char*)output_data, "$ -----");

							setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);
							lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, output_data, ARRAY_SIZE(output_data));
						}
						json_object_put(jsonDescription);
					}
					else
					{
						//========================
						// CDFA 2.0 Structure
						//========================
						double INPUT_COST = 0;
						double OUTPUT_COST = 0;
						double FLAT_FEE = 0;
						double PRESENT_KWH_PRICE = 0;
						double PREVIOUS_HOUR_PRICE = 0;
						double PRESENT_HOUR_PRICE = 0;

						if(strcmp((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].state ,"Charging") == 0)
						{
							// [Cost] sending from the central system
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].cost != 0)
							{
								INPUT_COST = ShmOCPP16Data->Cost.RunningCost[gun_index].cost;
							}

							// [Flat fee] sending from the central system
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.flatFee != 0)
							{
								FLAT_FEE = ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.flatFee;
							}

							// [kWh price] sending from the central system
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.kWhPrice != 0)
							{
								if((ShmOCPP16Data->Cost.RunningCost[gun_index].meterValue != 0) || (((ShmCharger->gun_info[gun_index].powerConsumptionTotal.power_consumption/10) - ShmOCPP16Data->Cost.RunningCost[gun_index].meterValue) != 0))
								{
									PRESENT_KWH_PRICE = ((float)(((ShmCharger->gun_info[gun_index].powerConsumptionTotal.power_consumption/10) - CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_METER_VALUE)/1000.00)*ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.kWhPrice);
									if(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_METER_VALUE != ShmOCPP16Data->Cost.RunningCost[gun_index].meterValue)
									{
										CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_KWH_PRICE = PRESENT_KWH_PRICE + CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_KWH_PRICE;
										CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_METER_VALUE = ShmOCPP16Data->Cost.RunningCost[gun_index].meterValue;
									}
								}
								else
								{
									CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_KWH_PRICE = 0;
									CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_METER_VALUE = 0;
								}
							}
							else
							{
								CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_KWH_PRICE = 0;
								CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_METER_VALUE = 0;
							}

							// [Hour price] sending from the central system
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.hourPrice != 0)
							{
								PREVIOUS_HOUR_PRICE = INPUT_COST;
								if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.flatFee != 0)
								{
									PREVIOUS_HOUR_PRICE = INPUT_COST - FLAT_FEE;
									if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.kWhPrice != 0)
									{
										PREVIOUS_HOUR_PRICE = INPUT_COST - FLAT_FEE - CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_KWH_PRICE;
									}
								}
								else
								{
									if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.kWhPrice != 0)
									{
										PREVIOUS_HOUR_PRICE = INPUT_COST - CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_KWH_PRICE;
									}
								}

								PRESENT_HOUR_PRICE = (((float)ElapsedTime(ShmOCPP16Data->Cost.RunningCost[gun_index].timestamp)/3600)*ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.hourPrice);
								OUTPUT_COST = PRESENT_HOUR_PRICE + PREVIOUS_HOUR_PRICE;
								CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_HOUR_PRICE = OUTPUT_COST;
							}
						}
						else if(strcmp((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].state ,"Idle") == 0)
						{
							// Shown at last value for [Hour price]
							OUTPUT_COST = CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_HOUR_PRICE;
						}
						else
						{}

						if(OUTPUT_COST > 0)
						{
							sprintf((char*)output_data, "$ %.2f", OUTPUT_COST);
						}
						else
							sprintf((char*)output_data, "$ -----");

						setDisplayValue(ICON_CHARGING_PARKING_FEE, APPEAR);
						lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, output_data, ARRAY_SIZE(output_data));
					}
				}
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// OCPP 2.0.1
			}
			break;
		case TOTAL_COST:
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				if(ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId != ShmOCPP16Data->Cost.RunningCost[gun_index].txId)
				{
					setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);

					strcpy((char*)cost_empty, "$ -----");
					string2ByteArray(cost_empty, output_data);
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, output_data, ARRAY_SIZE(output_data));
				}
				else
				{
					if((strcmp((char *)&ShmOCPP16Data->Cost.RunningCost[gun_index].description,"") != 0))
					{
						//========================
						// CDFA 1.0 Structure
						//========================
						double chargingCost = 0;
						double parkingCost = 0;
						jsonDescription = json_tokener_parse((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].description);

						if(!is_error(jsonDescription))
						{
							if(json_object_object_get(jsonDescription,"chargingFee") != NULL)
							{
								chargingCost += json_object_get_double(json_object_object_get(jsonDescription,"chargingFee"));
							}

							if(json_object_object_get(jsonDescription,"parkingFee") != NULL)
							{
								parkingCost += json_object_get_double(json_object_object_get(jsonDescription,"parkingFee"));
							}

							if((chargingCost + parkingCost) > 0)
								sprintf((char*)output_data, "$ %.2f", (chargingCost + parkingCost));
							else
								sprintf((char*)output_data, "$ -----");

							// APPEAR COST ICON
							setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
							lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, output_data, ARRAY_SIZE(output_data));
						}
						json_object_put(jsonDescription);
					}
					else
					{
						//========================
						// CDFA 2.0 Structure
						//========================
						int GRACE_MINUTES_IN_SECONDS = 0;
						int TOTAL_REAL_TIME_IN_SECONDS = 0;
						int PRESENT_REAL_TIME_IN_SECONDS = 0;
						double INPUT_COST = 0;
						double OUTPUT_COST = 0;
						double PRESENT_KWH_PRICE = 0;
						double PRESENT_HOUR_PRICE = 0;
						double PRESENT_IDLE_PRICE = 0;

						if(strcmp((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].state ,"Charging") == 0)
						{
							// [Cost] sending from the central system
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].cost != 0)
							{
								INPUT_COST = ShmOCPP16Data->Cost.RunningCost[gun_index].cost;
							}

							// [kWh price] sending from the central system
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.kWhPrice != 0)
							{
								if((ShmOCPP16Data->Cost.RunningCost[gun_index].meterValue != 0) || (((ShmCharger->gun_info[gun_index].powerConsumptionTotal.power_consumption/10) - ShmOCPP16Data->Cost.RunningCost[gun_index].meterValue) != 0))
								{
									PRESENT_KWH_PRICE = ((float)(((ShmCharger->gun_info[gun_index].powerConsumptionTotal.power_consumption/10) - ShmOCPP16Data->Cost.RunningCost[gun_index].meterValue)/1000.00)*ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.kWhPrice);
								}
							}

							// [Hour price] sending from the central system
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.hourPrice != 0)
							{
								if((strcmp((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].timestamp, "") != 0) && (ElapsedTime(ShmOCPP16Data->Cost.RunningCost[gun_index].timestamp) > 0))
								{
									PRESENT_HOUR_PRICE = (((float)ElapsedTime(ShmOCPP16Data->Cost.RunningCost[gun_index].timestamp)/3600)*ShmOCPP16Data->Cost.RunningCost[gun_index].chargingPrice.hourPrice);
								}
							}

							OUTPUT_COST = INPUT_COST + PRESENT_KWH_PRICE + PRESENT_HOUR_PRICE;
						}
						else if(strcmp((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].state ,"Idle") == 0)
						{
							// [Cost] sending from the central system
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].cost != 0)
							{
								INPUT_COST = ShmOCPP16Data->Cost.RunningCost[gun_index].cost;
							}

							// [Grace minutes] sending from the central system
							if(ShmOCPP16Data->Cost.RunningCost[gun_index].idlePrice.graceMinutes != 0)
							{
								GRACE_MINUTES_IN_SECONDS = (ShmOCPP16Data->Cost.RunningCost[gun_index].idlePrice.graceMinutes*60);
							}

							// Calculation total real time
							if((strcmp((char*)ShmOCPP16Data->Cost.RunningCost[gun_index].timestamp, "") != 0) && (ElapsedTime(ShmOCPP16Data->Cost.RunningCost[gun_index].timestamp) > 0))
							{
								PRESENT_REAL_TIME_IN_SECONDS = ElapsedTime(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP_FOR_GRACE_MINUTES);
								if(strcmp((char*)CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP_FOR_GRACE_MINUTES, (char*)ShmOCPP16Data->Cost.RunningCost[gun_index].timestamp) != 0)
								{
									CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_REAL_TIME_IN_SECONDS = PRESENT_REAL_TIME_IN_SECONDS + CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_REAL_TIME_IN_SECONDS;
									strcpy((char*)CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP_FOR_GRACE_MINUTES, (char*)ShmOCPP16Data->Cost.RunningCost[gun_index].timestamp);

									CaliforniaPricing.LcmRunningCost[gun_index].GRACE_MINUTES_PERIOD_COUNTER++;
								}

								TOTAL_REAL_TIME_IN_SECONDS = PRESENT_REAL_TIME_IN_SECONDS + CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_REAL_TIME_IN_SECONDS;
							}

							if(ShmOCPP16Data->Cost.RunningCost[gun_index].idlePrice.hourPrice != 0)
							{
								if(ShmOCPP16Data->Cost.RunningCost[gun_index].idlePrice.graceMinutes != 0)
								{
									if(TOTAL_REAL_TIME_IN_SECONDS >= GRACE_MINUTES_IN_SECONDS)
									{
										if(CaliforniaPricing.LcmRunningCost[gun_index].GRACE_MINUTES_PERIOD_COUNTER == 1)
										{
											PRESENT_IDLE_PRICE = (((float)(PRESENT_REAL_TIME_IN_SECONDS - GRACE_MINUTES_IN_SECONDS)/3600)*ShmOCPP16Data->Cost.RunningCost[gun_index].idlePrice.hourPrice);
											OUTPUT_COST = INPUT_COST + PRESENT_IDLE_PRICE;
										}
										else
										{
											PRESENT_IDLE_PRICE = (((float)(PRESENT_REAL_TIME_IN_SECONDS)/3600)*ShmOCPP16Data->Cost.RunningCost[gun_index].idlePrice.hourPrice);
											OUTPUT_COST = INPUT_COST + PRESENT_IDLE_PRICE;
										}

										CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_IDLE_PRICE = (((float)(TOTAL_REAL_TIME_IN_SECONDS - GRACE_MINUTES_IN_SECONDS)/3600)*ShmOCPP16Data->Cost.RunningCost[gun_index].idlePrice.hourPrice);
									}
									else
									{
										// A user completed the session before grace minutes start counting.
										CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_IDLE_PRICE = 0;
										OUTPUT_COST = INPUT_COST;
									}
								}
								else
								{
									PRESENT_IDLE_PRICE = (((float)(PRESENT_REAL_TIME_IN_SECONDS)/3600)*ShmOCPP16Data->Cost.RunningCost[gun_index].idlePrice.hourPrice);
									OUTPUT_COST = INPUT_COST + PRESENT_IDLE_PRICE;

									CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_IDLE_PRICE = (((float)(TOTAL_REAL_TIME_IN_SECONDS)/3600)*ShmOCPP16Data->Cost.RunningCost[gun_index].idlePrice.hourPrice);
									CaliforniaPricing.LcmRunningCost[gun_index].GRACE_MINUTES_PERIOD_COUNTER = 0;
								}
							}
							else
							{
								CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_IDLE_PRICE = 0;
								CaliforniaPricing.LcmRunningCost[gun_index].GRACE_MINUTES_PERIOD_COUNTER = 0;
								memset(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP_FOR_GRACE_MINUTES, 0x00, ARRAY_SIZE(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP_FOR_GRACE_MINUTES));

								OUTPUT_COST = INPUT_COST;
							}
						}
						else
						{}

						if(OUTPUT_COST > 0)
							sprintf((char*)output_data, "$ %.2f", OUTPUT_COST);
						else
							sprintf((char*)output_data, "$ -----");

						// APPEAR COST ICON
						setDisplayValue(ICON_CHARGING_TOTAL_COST, APPEAR);
						lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, output_data, ARRAY_SIZE(output_data));
					}
				}
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// OCPP 2.0.1
			}
			break;
		case ACCOUNT_BALANCE:
			break;
		default:
			break;
	}
}

//=======================================
// SETTING CONTENT [QR CODE CUSTOMIZED]
//=======================================
void setQRCodeIcon()
{
	int 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 CONTENT [QR CODE RECEIPT]
//=======================================
void setQRCodeReceipt(uint8_t gun_index)
{
	int LENGTH = 0;
	int TRANSACTION_ID;
	uint8_t DISPLAY_DATA[512];
	uint8_t QR_CODE_CONTENT[512];
	uint8_t QR_CODE_RECEIPT[512];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(QR_CODE_CONTENT, 0x00, ARRAY_SIZE(QR_CODE_CONTENT));
	memset(QR_CODE_RECEIPT, 0x00, ARRAY_SIZE(QR_CODE_RECEIPT));

	if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
	{
		if((strcmp((char *)ShmOCPP16Data->Cost.FinalCost[gun_index].qrCodeText,"") != 0))
		{
			// QR CODE RECEIPT FOR CDFA 2.0 STRUCTURE
			memcpy((char*)QR_CODE_CONTENT, (char*)ShmOCPP16Data->Cost.FinalCost[gun_index].qrCodeText, ARRAY_SIZE(QR_CODE_CONTENT));
			sprintf((char *)QR_CODE_RECEIPT, "%s", QR_CODE_CONTENT);
			string2ByteArray(QR_CODE_RECEIPT, DISPLAY_DATA);
		}
		else
		{
			if((strcmp((char *)ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL,"") != 0))
			{
				// QR CODE RECEIPT FOR CDFA 1.0 STRUCTURE
				memcpy((char*)QR_CODE_CONTENT, (char*)ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL, ARRAY_SIZE(QR_CODE_CONTENT));
				TRANSACTION_ID = ShmOCPP16Data->StopTransaction[gun_index].TransactionId;
				sprintf((char *)QR_CODE_RECEIPT, "%s%d", QR_CODE_CONTENT,TRANSACTION_ID);
				string2ByteArray(QR_CODE_RECEIPT, DISPLAY_DATA);
			}
			else
			{}
		}
	}
	else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
	{
		// TO DO OCPP 2.0
	}
	else
	{}

	LENGTH = strlen((char *)DISPLAY_DATA);
	setQRCodeContent((char *)DISPLAY_DATA, LENGTH, QRCODE_FOR_COMPLETE);
}

//=======================================
// SETTING CONTENT [QR CODE ALARM]
//=======================================
void setQRCodeAlarm()
{
	int LENGTH = 0;
	uint8_t DISPLAY_DATA[512];
	uint8_t QR_CODE_ALARM[512];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(QR_CODE_ALARM, 0x00, ARRAY_SIZE(QR_CODE_ALARM));

	sprintf((char *)QR_CODE_ALARM, "%s", "https://evsc.phihong.com.tw/");
	string2ByteArray(QR_CODE_ALARM, DISPLAY_DATA);
	LENGTH = strlen((char *)DISPLAY_DATA);
	setQRCodeContent((char *)DISPLAY_DATA, LENGTH, QRCODE_FOR_ALARM);
}

//=======================================
// SETTING CONTENT [QR CODE]
//=======================================
void setQRCodeContent(char *input, int length, uint8_t mode)
{
	int loop = 0;
	uint8_t output[length];

	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 SWITCH [WARNING PAGE]
//=======================================
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) && (getDiffSecNow(startTime[gun_index][TMR_IDX_ALARM]) > (TIME_ANIMATION_ALARM)))
	{
		refreshStartTimer(&startTime[gun_index][TMR_IDX_ALARM]);
		if(ShmSysConfigAndInfo->SysWarningInfo.PageIndex == 0)
		{
			ShmSysConfigAndInfo->SysWarningInfo.PageIndex = 1;
		}
		else
		{
			ShmSysConfigAndInfo->SysWarningInfo.PageIndex = 0;
		}

		setAlarmCodeAndIcon();
	}
}

//=======================================
// SETTING ICON [ALARM CODE]
//=======================================
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 ANIMATION CONNECTION
//=======================================
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) && (getDiffSecNow(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) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
				{
					setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_2);
					CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
					refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
				}
			}
			else
			{
				if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
				{
					setDisplayValue(ICON_PREPARING_ANIMATION, CONNECTION_FLASHING_1);
					setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_1);
					CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_1;
				}
				else if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_1) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
				{
					setDisplayValue(ICON_PREPARING_ANIMATION, CONNECTION_FLASHING_2);
					setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_2);
					CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
					refreshStartTimer(&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) && (getDiffSecNow(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) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
				{
					setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_2);
					CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
					refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
				}
			}
			else
			{
				if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (getDiffSecNow(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) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
				{
					setDisplayValue(ICON_PREPARING_ANIMATION, CONNECTION_FLASHING_2);
					CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
					refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
				}
			}

			break;
		case SYS_MODE_CHARGING:
			if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (getDiffSecNow(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) && (getDiffSecNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
			{
				setDisplayValue(ICON_CHARGING_ANIMATION, CONNECTION_FLASHING_2);
				CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
				refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
			}
			break;
		case SYS_MODE_TERMINATING:
			break;
		default:
			break;
	}
}

//=======================================
// SETTING ANIMATION [CONNECTOR PLUG-IN]
//=======================================
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) && (getDiffSecNow(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) && (getDiffSecNow(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;
			refreshStartTimer(&startTime[gun_index][TMR_IDX_PLUGIN]);
		}
	}
}

//=======================================
// SETTING ANIMATION [PLUG & CHARGE]
//=======================================
void setPlugAndChargeAnimation(uint8_t gun_index)
{
	if((GUN_PLUGING_LEVEL_STATUS == GUN_PLUGING_LEVEL_0) && (getDiffSecNow(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) && (getDiffSecNow(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;
		refreshStartTimer(&startTime[gun_index][TMR_IDX_PLUGIN]);
	}
}

//=======================================
// SETTING ANIMATION [PRESS START BUTTON]
//=======================================
void setPressStartButtonAnimation(uint8_t gun_index)
{
	if((START_PRESS_LEVEL_STATIS == PRESS_START_LEVEL_0) && ((getDiffSecNow(startTime[gun_index][TMR_IDX_STARTBUTTON]))> (TIME_ANIMATION_START_PRESS)))
	{
		setDisplayValue(ICON_PRESS_START_BUTTON, PRESS_START_1);
		START_PRESS_LEVEL_STATIS = PRESS_START_LEVEL_1;
	}
	else if((START_PRESS_LEVEL_STATIS == PRESS_START_LEVEL_1) && ((getDiffSecNow(startTime[gun_index][TMR_IDX_STARTBUTTON]))> (TIME_ANIMATION_START_PRESS*2)))
	{
		setDisplayValue(ICON_PRESS_START_BUTTON, PRESS_START_2);
		START_PRESS_LEVEL_STATIS = PRESS_START_LEVEL_0;
		refreshStartTimer(&startTime[gun_index][TMR_IDX_STARTBUTTON]);
	}
}

//=======================================
// SETTING CONNECTION TIMEOUT
//=======================================
void setPresentConnectionTimeout(uint8_t gun_index)
{
	int TIME;
	uint8_t DISPLAY_DATA[16];
	uint8_t CONNECTION_TIMEOUT[16];
	unsigned char NOT_COUNTING[16];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(CONNECTION_TIMEOUT, 0x00, ARRAY_SIZE(CONNECTION_TIMEOUT));
	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, DISPLAY_DATA);
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_CONNECTION_TIMER, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	}
	else
	{
		if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == CP_STATE_A))
		{
			TIME = ShmCharger->timeoutSpec.Handshake_Timeout;
			if(TIME <= 0)
			{
				strcpy((char*)NOT_COUNTING, "000");
				string2ByteArray(NOT_COUNTING, DISPLAY_DATA);
				lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_CONNECTION_TIMER, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
			}
			else
			{
				sprintf((char *)CONNECTION_TIMEOUT, "%03d ", TIME);
				string2ByteArray(CONNECTION_TIMEOUT, DISPLAY_DATA);
				lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_CONNECTION_TIMER, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
			}
		}
		else
		{
			strcpy((char*)NOT_COUNTING, "-----");
			string2ByteArray(NOT_COUNTING, DISPLAY_DATA);
			lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_CONNECTION_TIMER, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
		}
	}
}

//=======================================
// SETTING PRESENT [POWER]
//=======================================
void setPresentChargedPower(uint8_t gun_index)
{
	uint8_t DISPLAY_DATA[16];
	uint8_t POWER[16];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(POWER, 0x00, ARRAY_SIZE(POWER));

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

//=======================================
// SETTING PRESENT [ENERGY]
//=======================================
void setPresentChargedEnergy(uint8_t gun_index, uint8_t system_mode)
{
	uint8_t DISPLAY_DATA[16];
	uint8_t ENERGY[16];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(ENERGY, 0x00, ARRAY_SIZE(ENERGY));

	switch(system_mode)
	{
		case SYS_MODE_PREPARING:
			sprintf((char *)ENERGY, "%s kWh", "0.0000");
			string2ByteArray(ENERGY, DISPLAY_DATA);
			lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_ENERGY, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
			break;
		case SYS_MODE_CHARGING:
		case SYS_MODE_TERMINATING:
		case SYS_MODE_COMPLETE:
		default:
			sprintf((char *)ENERGY, "%.4f kWh", ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargedEnergy);
			string2ByteArray(ENERGY, DISPLAY_DATA);
			lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_ENERGY, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
			break;
	}
}

//=======================================
// SETTING PRESENT [DURATION]
//=======================================
void setPresentChargedDuration(uint8_t gun_index)
{
	uint8_t DISPLAY_DATA[16];
	uint8_t TIME[16];
	uint16_t HOUR;
	uint16_t MINUTE;
	uint16_t SECOND;
	uint32_t PRESENT_CHARGED_DURATION = ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PresentChargedDuration;

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TIME, 0x00, ARRAY_SIZE(TIME));

	HOUR = (PRESENT_CHARGED_DURATION / 3600);
	MINUTE = (PRESENT_CHARGED_DURATION - (3600 * HOUR)) / 60;
	SECOND = (PRESENT_CHARGED_DURATION - (3600 * HOUR) - (MINUTE * 60));

	sprintf((char *)TIME, "%02d:%02d:%02d", HOUR, MINUTE, SECOND);
	string2ByteArray(TIME, DISPLAY_DATA);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TIMER, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
}

//=======================================
// SETTING PRESENT [POWER CONSUMPTION]
//=======================================
void setPresentPowerConsumption(uint8_t gun_index)
{
	uint8_t DISPLAY_DATA[32];
	uint8_t POWER_CONSUMPTION[32];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(POWER_CONSUMPTION, 0x00, ARRAY_SIZE(POWER_CONSUMPTION));

	sprintf((char *)POWER_CONSUMPTION, "%.4f kWh", ((float)ShmCharger->gun_info[gun_index].powerConsumptionTotal.power_consumption/10000.0));
	string2ByteArray(POWER_CONSUMPTION, DISPLAY_DATA);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_POWER_CONSUMPTION, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_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);
			}
			else
			{}
			break;
		case UNVALIDATED_RFID:
			if(getCurrentPage() != SYSTEM_SCREEN_AUTH_FAIL)
			{
				setCurrentPage(SYSTEM_SCREEN_AUTH_FAIL);
			}
			else
			{}
			break;
		case UNKNOW_RFID:
			if(getCurrentPage() != SYSTEM_SCREEN_AUTH_UNKNOWN)
			{
				setCurrentPage(SYSTEM_SCREEN_AUTH_UNKNOWN);
			}
			else
			{}
			break;
		case DEFAULT_RFID:
			break;
		default:
			break;
	}
}

//=======================================
// SETTING DEFAULT VALUE
//=======================================
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);
			setTimeTitle(ON);
			setEnergyTitle(ON);
			setSessionFeeTitle(ON);
			setParkingFeeTitle(ON);
			setFinalCostTitle(ON);

			if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
			{
				setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_1);
				CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
				refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
			}
			else
			{
				setDisplayValue(ICON_PREPARING_PLUG_ARROW, PLUGIN_ARROW_1);
				GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_0;
				refreshStartTimer(&startTime[gun_index][TMR_IDX_PLUGIN]);
			}

			// Clean all CDFA value before start a session
			CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_KWH_PRICE = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_HOUR_PRICE = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_HOUR_PRICE = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_KWH_PRICE = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_METER_VALUE = 0;
			memset(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP, 0x00, ARRAY_SIZE(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP));

			CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_IDLE_PRICE = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].GRACE_MINUTES_PERIOD_COUNTER = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_REAL_TIME_IN_SECONDS = 0;
			memset(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP_FOR_GRACE_MINUTES, 0x00, ARRAY_SIZE(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP_FOR_GRACE_MINUTES));

			break;
		case SYS_MODE_AUTHORIZING:

			setTimeTitle(ON);
			setEnergyTitle(ON);
			setSessionFeeTitle(ON);
			setParkingFeeTitle(ON);
			setFinalCostTitle(ON);

			break;
		case SYS_MODE_PREPARING:

			setTimeTitle(ON);
			setEnergyTitle(ON);
			setSessionFeeTitle(ON);
			setParkingFeeTitle(ON);
			setFinalCostTitle(ON);
			if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
			{
				setDisplayValue(ICON_PRECHARGING_ANIMATION, CONNECTION_FLASHING_1);
				CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
				refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
				refreshStartTimer(&startTime[gun_index][TMR_IDX_REFRESH_INFO]);
			}
			else
			{
				setDisplayValue(ICON_PREPARING_PLUG_ARROW, PLUGIN_ARROW_1);
				GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_0;
				refreshStartTimer(&startTime[gun_index][TMR_IDX_PLUGIN]);
				refreshStartTimer(&startTime[gun_index][TMR_IDX_REFRESH_INFO]);
			}

			// Clean all CDFA value before start a session
			CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_KWH_PRICE = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_HOUR_PRICE = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_HOUR_PRICE = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_KWH_PRICE = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_METER_VALUE = 0;
			memset(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP, 0x00, ARRAY_SIZE(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP));

			CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_IDLE_PRICE = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].GRACE_MINUTES_PERIOD_COUNTER = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_REAL_TIME_IN_SECONDS = 0;
			memset(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP_FOR_GRACE_MINUTES, 0x00, ARRAY_SIZE(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP_FOR_GRACE_MINUTES));

			break;
		case SYS_MODE_CHARGING:

			CaliforniaPricing.LcmRunningCost[gun_index].END_OF_SESSION_IDLE_PRICE = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_REAL_TIME_IN_SECONDS = 0;
			CaliforniaPricing.LcmRunningCost[gun_index].GRACE_MINUTES_PERIOD_COUNTER = 0;
			memset(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP_FOR_GRACE_MINUTES, 0x00, ARRAY_SIZE(CaliforniaPricing.LcmRunningCost[gun_index].PREVIOUS_TIMESTAMP_FOR_GRACE_MINUTES));

			break;
		case SYS_MODE_TERMINATING:

			setDisplayValue(ICON_CHARGING_ANIMATION, CONNECTION_FLASHING_1);
			refreshStartTimer(&startTime[gun_index][TMR_IDX_CONNECTION]);
			refreshStartTimer(&startTime[gun_index][TMR_IDX_REFRESH_INFO]);
			CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;

			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 CONTENT EMPTY
//=======================================
void setTextToEmpty(uint8_t gun_index)
{
	uint8_t DISPLAY_DATA[16];
	uint8_t TEXT_DATA[16];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	strcpy((char*)TEXT_DATA, "               ");
	string2ByteArray(TEXT_DATA, DISPLAY_DATA);

	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TOTAL_COST, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_SESSION_FEE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_PARKING_FEE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_USER_ACCOUNT_BALANCE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_REMAINING_ACCOUNT_BALANCE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
}

//=======================================
// SETTING MARQUEE CONTROL
//=======================================
void setMarqueeControl(uint16_t address, uint8_t gun_index, uint8_t type)
{
	uint8_t DISPLAY_DATA[250];
	uint8_t TEXT_DATA[250];
	uint8_t priceText[250];
	uint8_t priceTextOffline[250];
	json_object *jsonDescription;

	memset(DISPLAY_DATA, 0xFF, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0xFF, ARRAY_SIZE(TEXT_DATA));
	memset(priceText, 0xFF, ARRAY_SIZE(priceText));
	memset(priceTextOffline, 0xFF, ARRAY_SIZE(priceTextOffline));

	switch(type)
	{
		case DEFAULE_PRICE:
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				if((strstr((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData, "priceText") > 0) ||
				   (strstr((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData, "priceTextOffline") > 0))
				{
					// MARQUEE CONTROL CDFA 2.0 STRUCTURE
					double kWhPrice = 0.0;
					double hourPrice = 0.0;
					double flatFee = 0.0;
					jsonDescription = json_tokener_parse((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData);

					if(!is_error(jsonDescription))
					{
						if(json_object_object_get(jsonDescription, "priceText") != NULL)
						{
							sprintf((char*)priceText, "%s", json_object_get_string(json_object_object_get(jsonDescription, "priceText")));
						}

						if(json_object_object_get(jsonDescription, "priceTextOffline") != NULL)
						{
							sprintf((char*)priceTextOffline, "%s", json_object_get_string(json_object_object_get(jsonDescription, "priceTextOffline")));
						}

						if(json_object_object_get(jsonDescription, "chargingPrice") != NULL)
						{
							if(json_object_object_get(json_object_object_get(jsonDescription, "chargingPrice"), "kWhPrice") != NULL)
							{
								kWhPrice = json_object_get_double(json_object_object_get(json_object_object_get(jsonDescription, "chargingPrice"), "kWhPrice"));
							}

							if(json_object_object_get(json_object_object_get(jsonDescription, "chargingPrice"), "hourPrice") != NULL)
							{
								hourPrice = json_object_get_double(json_object_object_get(json_object_object_get(jsonDescription, "chargingPrice"), "hourPrice"));
							}

							if(json_object_object_get(json_object_object_get(jsonDescription, "chargingPrice"), "flatFee") != NULL)
							{
								flatFee = json_object_get_double(json_object_object_get(json_object_object_get(jsonDescription, "chargingPrice"), "flatFee"));
							}
						}
					}
					json_object_put(jsonDescription);

					if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
					{
						if((strcmp((char *)priceText,"") != 0))
						{
							sprintf((char *)TEXT_DATA, "%s", (char*)priceText);
							string2ByteArray(TEXT_DATA, DISPLAY_DATA);
							lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (address+3), DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
						}
					}
					else
					{
						if((strcmp((char *)priceTextOffline,"") != 0))
						{
							sprintf((char *)TEXT_DATA, "%s", (char*)priceTextOffline);
							string2ByteArray(TEXT_DATA, DISPLAY_DATA);
							lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (address+3), DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
						}

						if(kWhPrice != 0)
						{
							// Off-line (kWh price)
						}

						if(hourPrice != 0)
						{
							// Off-line (hour price)
						}

						if(flatFee !=0)
						{
							// Off-line (flat fee)
						}
					}
				}
				else
				{
					// MARQUEE CONTROL CDFA 1.0 STRUCTURE
					sprintf((char *)TEXT_DATA, "%s", (char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[DefaultPrice].ItemData);
					string2ByteArray(TEXT_DATA,DISPLAY_DATA);
					lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (address+3), DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
				}
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// OCPP 2.0.1
			}
			else
			{}
			break;
		case SET_USER_PRICE:
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				sprintf((char *)TEXT_DATA, "%s", (char *)ShmOCPP16Data->Cost.SetUserPrice.price);
				string2ByteArray(TEXT_DATA,DISPLAY_DATA);
				lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, (address+3), DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
			}
			else if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_20)
			{
				// OCPP 2.0.1
			}
			else
			{}
			break;
		case FINAL_COST:
			break;
		case RUNNING_COST:
			break;
		default:
			break;
	}
}

//=======================================
// SETTING TITLE [BY MODEL NAME]
//=======================================
int isAmericaType()
{
	int result = NO;

	if(ShmSysConfigAndInfo->SysConfig.ModelName[3] == 'U')
		result = YES;
	else
		result = NO;

	return result;
}

//=======================================
// SETTING TITLE [TIME]
//=======================================
void setTimeTitle(uint8_t isOn)
{
	uint8_t DISPLAY_DATA[32];
	uint8_t TEXT_DATA[32];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	if(isAmericaType() == YES)
	{
		if(isOn == ON)
		{
			strcpy((char*)TEXT_DATA, "(hrs: mins: secs)");
			string2ByteArray(TEXT_DATA, DISPLAY_DATA);
		}
		else
		{
			strcpy((char*)TEXT_DATA, "                               ");
			string2ByteArray(TEXT_DATA, DISPLAY_DATA);
		}

		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TITLE_TIME, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_TITLE_TIME, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TITLE_TIME, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	}
	else
	{
		setDisplayValue(TEXT_CHARGING_TITLE_TIME, DISAPPEAR);
		setDisplayValue(TEXT_PREPARING_TITLE_TIME, DISAPPEAR);
		setDisplayValue(TEXT_PRECHARGING_TITLE_TIME, DISAPPEAR);
	}
}

//=======================================
// SETTING TITLE [ENERGY]
//=======================================
void setEnergyTitle(uint8_t isOn)
{
	uint8_t DISPLAY_DATA[32];
	uint8_t TEXT_DATA[32];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	if(isAmericaType() == YES)
	{
		if(isOn == ON)
		{
			strcpy((char*)TEXT_DATA, "(Energy)");
			string2ByteArray(TEXT_DATA, DISPLAY_DATA);
		}
		else
		{
			strcpy((char*)TEXT_DATA, "                               ");
			string2ByteArray(TEXT_DATA, DISPLAY_DATA);
		}

		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TITLE_ENERGY, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_TITLE_ENERGY, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TITLE_ENERGY, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	}
	else
	{
		setDisplayValue(TEXT_CHARGING_TITLE_ENERGY, DISAPPEAR);
		setDisplayValue(TEXT_PREPARING_TITLE_ENERGY, DISAPPEAR);
		setDisplayValue(TEXT_PRECHARGING_TITLE_ENERGY, DISAPPEAR);
	}
}

//=======================================
// SETTING TITLE [SESSION FEE]
//=======================================
void setSessionFeeTitle(uint8_t isOn)
{
	uint8_t DISPLAY_DATA[32];
	uint8_t TEXT_DATA[32];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	if(isAmericaType() == YES)
	{
		if(isOn == ON)
		{
			strcpy((char*)TEXT_DATA, "(Energy Cost)");
			string2ByteArray(TEXT_DATA, DISPLAY_DATA);
		}
		else
		{
			strcpy((char*)TEXT_DATA, "                               ");
			string2ByteArray(TEXT_DATA, DISPLAY_DATA);
		}

		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TITLE_SESSION_FEE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_TITLE_SESSION_FEE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TITLE_SESSION_FEE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	}
	else
	{
		setDisplayValue(TEXT_CHARGING_TITLE_SESSION_FEE, DISAPPEAR);
		setDisplayValue(TEXT_PREPARING_TITLE_SESSION_FEE, DISAPPEAR);
		setDisplayValue(TEXT_PRECHARGING_TITLE_SESSION_FEE, DISAPPEAR);
	}
}

//=======================================
// SETTING TITLE [PARKING FEE]
//=======================================
void setParkingFeeTitle(uint8_t isOn)
{
	uint8_t DISPLAY_DATA[32];
	uint8_t TEXT_DATA[32];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	if(isAmericaType() == YES)
	{
		if(isOn == ON)
		{
			strcpy((char*)TEXT_DATA, "(Parking Fee)");
			string2ByteArray(TEXT_DATA, DISPLAY_DATA);
		}
		else
		{
			strcpy((char*)TEXT_DATA, "                               ");
			string2ByteArray(TEXT_DATA, DISPLAY_DATA);
		}

		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TITLE_PARKING_FEE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_TITLE_PARKING_FEE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TITLE_PARKING_FEE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	}
	else
	{
		setDisplayValue(TEXT_CHARGING_TITLE_PARKING_FEE, DISAPPEAR);
		setDisplayValue(TEXT_PREPARING_TITLE_PARKING_FEE, DISAPPEAR);
		setDisplayValue(TEXT_PRECHARGING_TITLE_PARKING_FEE, DISAPPEAR);
	}
}

//=======================================
// SETTING TITLE [FINAL COST]
//=======================================
void setFinalCostTitle(uint8_t isOn)
{
	uint8_t DISPLAY_DATA[32];
	uint8_t TEXT_DATA[32];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	if(isAmericaType() == YES)
	{
		if(isOn == ON)
		{
			strcpy((char*)TEXT_DATA, "(Total Cost)");
			string2ByteArray(TEXT_DATA, DISPLAY_DATA);
		}
		else
		{
			strcpy((char*)TEXT_DATA, "                               ");
			string2ByteArray(TEXT_DATA, DISPLAY_DATA);
		}

		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CHARGING_TITLE_FINAL_COST, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PREPARING_TITLE_FINAL_COST, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TITLE_FINAL_COST, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	}
	else
	{
		setDisplayValue(TEXT_CHARGING_TITLE_FINAL_COST, DISAPPEAR);
		setDisplayValue(TEXT_PREPARING_TITLE_FINAL_COST, DISAPPEAR);
		setDisplayValue(TEXT_PRECHARGING_TITLE_FINAL_COST, DISAPPEAR);
	}
}

//=======================================
// SETTING CSU FIRMWARE VERSION
//=======================================
void setCsuRootFsFwRev()
{
	uint8_t DISPLAY_DATA[64];
	uint8_t TEXT_DATA[64];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	sprintf((char *)TEXT_DATA, "%s%s", " CSU Software Version: ",(char*)ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev);
	string2ByteArray(TEXT_DATA, DISPLAY_DATA);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_CSU_ROOT_FS_FW_REV, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
}

//=======================================
// SETTING PRECHARGING VALUE EMPTY
//=======================================
void setClearPrechargingValueToEmpty()
{
	uint8_t DISPLAY_DATA[16];
	uint8_t TEXT_DATA[16];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	strcpy((char*)TEXT_DATA, "               ");
	string2ByteArray(TEXT_DATA, DISPLAY_DATA);

	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TIMER, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_ENERGY, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_SESSION_FEE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_PARKING_FEE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_COST, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_POWER, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
}

//=======================================
// SETTING PRECHARGING TIMER DEFAULT
//=======================================
void setPrechargingTimerToDefault()
{
	uint8_t DISPLAY_DATA[16];
	uint8_t TEXT_DATA[16];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	sprintf((char *)TEXT_DATA, "%s", "00:00:00");
	string2ByteArray(TEXT_DATA, DISPLAY_DATA);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_TIMER, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
}

//=======================================
// SETTING PRECHARGING ENERGY DEFAULT
//=======================================
void setPrechargingEnergyToDefault()
{
	uint8_t DISPLAY_DATA[16];
	uint8_t TEXT_DATA[16];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	sprintf((char *)TEXT_DATA, "%s kWh", "0000.0000");
	string2ByteArray(TEXT_DATA, DISPLAY_DATA);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_ENERGY, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
}

//=======================================
// SETTING PRECHARGING SESSION FEE DEFAULT
//=======================================
void setPrechargingSessionFeeToDefault()
{
	uint8_t DISPLAY_DATA[16];
	uint8_t TEXT_DATA[16];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	sprintf((char *)TEXT_DATA, "%s", "000.00");
	string2ByteArray(TEXT_DATA, DISPLAY_DATA);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_SESSION_FEE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
}

//=======================================
// SETTING PRECHARGING PARKING FEE DEFAULT
//=======================================
void setPrechargingParkingFeeToDefault()
{
	uint8_t DISPLAY_DATA[16];
	uint8_t TEXT_DATA[16];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	sprintf((char *)TEXT_DATA, "%s", "000.00");
	string2ByteArray(TEXT_DATA, DISPLAY_DATA);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_PARKING_FEE, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
}

//=======================================
// SETTING PRECHARGING COST DEFAULT
//=======================================
void setPrechargingCostToDefault()
{
	uint8_t DISPLAY_DATA[16];
	uint8_t TEXT_DATA[16];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	sprintf((char *)TEXT_DATA, "%s", "000.00");
	string2ByteArray(TEXT_DATA, DISPLAY_DATA);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_COST, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
}

//=======================================
// SETTING PRECHARGING POWER DEFUALT
//=======================================
void setPrechargingPowerToDefault()
{
	uint8_t DISPLAY_DATA[16];
	uint8_t TEXT_DATA[16];

	memset(DISPLAY_DATA, 0x00, ARRAY_SIZE(DISPLAY_DATA));
	memset(TEXT_DATA, 0x00, ARRAY_SIZE(TEXT_DATA));

	sprintf((char *)TEXT_DATA, "%s kW", "0.00");
	string2ByteArray(TEXT_DATA, DISPLAY_DATA);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PRECHARGING_POWER, DISPLAY_DATA, ARRAY_SIZE(DISPLAY_DATA));
}

//=======================================
// 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(getDiffSecNow(startTime[ShmCharger->gun_selectd][TMR_IDX_SHOW_AUTH_RESULT]) >= TIME_AUTH_RESULT_TIME)
					ShmCharger->isGetAuthResult = FALSE;

				if(getDiffSecNow(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))
				{
					if((ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus == SYS_MODE_RESERVATION) && (ocpp_compare_reserve_id_with_user(ShmCharger->gun_selectd) != YES))
					{
						page_idle(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
					}
					else
					{
						page_preparing(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
					}
					ShmCharger->gun_info[ShmCharger->gun_selectd].isHandshakeTimerRefresh = NO;
				}
			}
			else
			{
				refreshStartTimer(&startTime[ShmCharger->gun_selectd][TMR_IDX_SHOW_AUTH_RESULT]);
				ShmCharger->gun_info[ShmCharger->gun_selectd].isHandshakeTimerRefresh = NO;

				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:
						if(ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].StartMethod == START_METHOD_EVCCID)
							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;
}