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

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

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

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

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

//=======================================
// Declare Control panel function
//=======================================
uint8_t getCurrentPage();
void setCurrentPage(uint8_t page);
void setCurrencyFromWebsite(char *unit);
void setWarningStatus(uint8_t gun_index);
void setAuthorizationPage(uint8_t gun_index);
void setPriceFromWebsite(float monry_rate);
void setBillingFromBackend(uint8_t gun_index, uint8_t system_mode);
void setPresentChargedEnergy(uint8_t gun_index);
void setPresentChargingPower(uint8_t gun_index);
void setBatteryPercentageValue(uint8_t gun_index);
void setPresentChargedDuration(uint8_t gun_index);
void setQRcodeContent(char *input, uint8_t length);
void setDisplayValue(uint16_t address, uint8_t value);
void setGunPluginAnimation(uint8_t gun_index);
void setBatteryAnimation(uint8_t gun_index, uint8_t system_mode);
void setConnectionAnimation(uint8_t gun_index, uint8_t system_mode);
void setPresentFinalCost(float cost);
float getPresentFinalCost(uint8_t gun_index);
void setDefaultValue(uint8_t gun_index, uint8_t system_mode);

void setUserPrice(uint8_t type);
void setDefaultPrice(uint8_t type);
void setFinalCost(uint8_t gun_index, uint8_t type);
void setCurrencyAndUnitFromBackend(uint8_t type_price,uint8_t type_currency_unit, uint8_t gun_index);

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


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

struct timeb					startTime[AC_QUANTITY][10];

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

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

int Uart1Fd;

//=======================================
// Emulator
//=======================================
int PERCENTAGE;
uint8_t isChange;
uint8_t isEmulator	= NO;
uint8_t isCharging	= YES;

//=======================================
// Record version and date
//=======================================
char *FIRMWARE_UPDATE_IMAGE[3] = {"V0.17", "2021-04-28", "REV.01.00"};


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

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

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

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

#ifdef SystemLogMessage
	system(Buf);
#endif

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

	return rc;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

	return result;
}

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

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

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

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

void page_idle(uint8_t gun_index, uint8_t system_mode)
{
	if(getCurrentPage() != SYSTEM_SCREEN_IDLE)
	{
		setCurrentPage(SYSTEM_SCREEN_IDLE);
		setDefaultValue(gun_index, system_mode);
		DEBUG_INFO("Setting page to idle.\n");
	}
	else
	{
		setRfidIcon();
		setQRCodeIcon();

		if(isEmulator == YES)
		{
			//if(isCharging == YES)
				//PERCENTAGE = 0;
			//else
				//PERCENTAGE = 100;
		}
	}
}

void page_authorizing(uint8_t gun_index)
{
	// CHANGE DISPLAY TO AUTHORIZATION
	setAuthorizationPage(gun_index);

	// SHOW USER ACCOUNT BALANCE WHEN THE SYSTEM IS ONLINE
	if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
	{
		if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
		{
			if((strcmp((char*)ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartUserId, (char *)ShmOCPP16Data->Cost.SetUserPrice.idToken) == 0) &&
			   ((strcmp((char *)ShmOCPP16Data->Cost.SetUserPrice.idToken,"") != 0)))
			{
				// SEARCHING USER PRICE FOR ACCOUNT BALANCE
				setUserPrice(ACCOUNT_BALANCE);
			}
			else
			{
				// DISAPPEAR ACCOUNT BALANCE AND ICON
				setDisplayValue(ICON_BALANCE_WALLET, DISAPPEAR);
				setDisplayValue(TEXT_BALANCE, DISAPPEAR);
			}
		}
		else
		{
			// DISPLAY BY OCPP 2.0.1
		}
	}
	else
	{
		// DISAPPEAR ACCOUNT BALANCE AND ICON
		setDisplayValue(ICON_BALANCE_WALLET, DISAPPEAR);
		setDisplayValue(TEXT_BALANCE, DISAPPEAR);
	}
}

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

void page_charging(uint8_t gun_index, uint8_t system_mode)
{
	if((getCurrentPage() != SYSTEM_SCREEN_CHARGING) && (ShmCharger->gun_info[gun_index].resultAuthorization == DEFAULT_RFID))
	{
		setCurrentPage(SYSTEM_SCREEN_CHARGING);
		setDefaultValue(gun_index, system_mode);
		DEBUG_INFO("Setting page to charging.\n");

		//isChange = 0;
		//ftime(&startTime[gun_index][TMR_IDX_EMULATOR]);
	}
	else
	{
		setAuthorizationPage(gun_index);
		setConnectionAnimation(gun_index, system_mode);
		setBatteryAnimation(gun_index, system_mode);
		setPresentChargedDuration(gun_index);
		setPresentChargedEnergy(gun_index);
		setPresentChargingPower(gun_index);
	}
}

void page_complete(uint8_t gun_index, uint8_t system_mode)
{
	if(getCurrentPage() != SYSTEM_SCREEN_COMPLETE)
	{
		setCurrentPage(SYSTEM_SCREEN_COMPLETE);
		DEBUG_INFO("Setting page to complete.\n");
	}
	else
	{
		setPresentChargedDuration(gun_index);
		setPresentChargedEnergy(gun_index);
		setBatteryAnimation(gun_index, system_mode);

		// SHOW FINAL COST AND ACCOUNT BALANCE AFTER THE END OF TRANSACTION
		if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
		{
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				setFinalCost(gun_index, TOTAL_COST);
				setFinalCost(gun_index, ACCOUNT_BALANCE);
				setCurrencyAndUnitFromBackend(FINAL_COST, ACCOUNT_BALANCE, gun_index);
			}
			else
			{
				// DISPLAY BY OCPP 2.0.1
			}
		}
		else
		{
			if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
			{
				// APPEAR COST AND ICON
				setDisplayValue(ICON_COST_COMPLETE, APPEAR);
				setPresentFinalCost(getPresentFinalCost(gun_index));
			}
			else
			{
				// DISAPPEAR ACCOUNT BALANCE AND ICON
				setDisplayValue(ICON_WALLER_COMPLETE, DISAPPEAR);
				setDisplayValue(TEXT_ACCOUNT_COMPLETE, DISAPPEAR);

				// DISAPPEAR COST AND ICON
				setDisplayValue(ICON_COST_COMPLETE, DISAPPEAR);
				setDisplayValue(TEXT_COST_COMPLETE, DISAPPEAR);

				// DISAPPEAR BALANCE CURRENCY UNIT
				setDisplayValue(TEXT_CURRENCY_COMPLETE, DISAPPEAR);
			}
		}
	}
}

void page_terminating(uint8_t gun_index, uint8_t system_mode)
{
	if((getCurrentPage() != SYSTEM_SCREEN_TERMINATING) && (ShmCharger->gun_info[gun_index].resultAuthorization == DEFAULT_RFID))
	{
		setCurrentPage(SYSTEM_SCREEN_TERMINATING);
		setDefaultValue(gun_index, system_mode);
		DEBUG_INFO("Setting page to terminating.\n");
	}
	else
	{
		setAuthorizationPage(gun_index);
		setConnectionAnimation(gun_index, system_mode);
		setBatteryAnimation(gun_index, system_mode);
		setPresentChargedDuration(gun_index);
		setPresentChargedEnergy(gun_index);
		setPresentChargingPower(gun_index);

		if((ShmSysConfigAndInfo->SysInfo.OcppConnStatus == ON))
		{
			if(ShmSysConfigAndInfo->SysInfo.OcppRunningVer == OCPP_RUNNING_VERSION_16)
			{
				setFinalCost(gun_index, TOTAL_COST);
				setFinalCost(gun_index, ACCOUNT_BALANCE);
				setCurrencyAndUnitFromBackend(FINAL_COST, ACCOUNT_BALANCE, gun_index);
			}
			else
			{
				// DISPLAY BY OCPP 2.0.1
			}
		}
		else
		{
			// DISAPPEAR ACCOUNT BALANCE AND ICON
			setDisplayValue(ICON_WALLER_COMPLETE, DISAPPEAR);
			setDisplayValue(TEXT_ACCOUNT_COMPLETE, DISAPPEAR);

			// DISAPPEAR COST ADN ICON
			setDisplayValue(ICON_COST_COMPLETE, DISAPPEAR);
			setDisplayValue(TEXT_COST_COMPLETE, DISAPPEAR);

			// DISAPPEAR BALANCE CURRENCY UNIT
			setDisplayValue(TEXT_CURRENCY_COMPLETE, DISAPPEAR);
		}
	}
}

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

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

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

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

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

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

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

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

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

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

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

void page_footer()
{
	setRTC();
}

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

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

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

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

	if(lcdRegisterRead(Uart1Fd, REG_TYPE_CONTROL, REG_ADDRESS_READ_PAGE_ID, currentPage, ARRAY_SIZE(currentPage)))
	{
		result = currentPage[1];

		// DEBUG_INFO("currentPage[0] : %X\n", currentPage[0]);
		// DEBUG_INFO("currentPage[1] : %X\n", currentPage[1]);
		// DEBUG_INFO("Getting current page : [%d] \n", result);
	}
	else
	{
		DEBUG_INFO("Getting current page fail! \n");
	}

	return result;
}

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

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

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

    loop = 0;
    i = 0;

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

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

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

//=======================================
// Setting WIFI / 4G icon status
//=======================================
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);
				if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == ON)
					setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_OFFLINE);
				else
					setDisplayValue(ICON_WIFI_CONNECTION, TELECOM_ONLINE);
			}
		}
		else
		{
			if(ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode == WIFI_STATION)
			{
				if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi == ON)
					setDisplayValue(ICON_WIFI_CONNECTION, WIFI_OFFLINE);
				else
					setDisplayValue(ICON_WIFI_CONNECTION, WIFI_ONLINE);
			}
			else
				setDisplayValue(ICON_WIFI_CONNECTION, WIFI_OFFLINE);

			if(ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled == DISABLE_4G)
			{
				setDisplayValue(ICON_4G_CONNECTION, DISAPPEAR);
			}
			else
			{
				if(ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi == ON)
					setDisplayValue(ICON_4G_CONNECTION, TELECOM_OFFLINE);
				else
					setDisplayValue(ICON_4G_CONNECTION, TELECOM_ONLINE);
			}
		}
	}
	else
	{
		// 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:

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

					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:

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

					break;
				case WIFI_ACCESS_POINT:

					setDisplayValue(ICON_WIFI_CONNECTION, WIFI_OFFLINE);

					break;
				default:
					break;
			}
		}
	}
}

//=======================================
// Setting billing ( WEB PAGE )
//=======================================
void setBillingFromWebsite()
{
	if(ShmSysConfigAndInfo->SysConfig.BillingData.isBilling == ON)
	{
		setDisplayValue(ICON_PRICE, APPEAR);

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

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

		// CURRENCY UNIT ( 53 COUNTRIES )
		if(ShmSysConfigAndInfo->SysConfig.BillingData.Currency <= 53)
		{
			setCurrencyFromWebsite((char *)Currency[ShmSysConfigAndInfo->SysConfig.BillingData.Currency]);
		}
	}
	else
	{
		setDisplayValue(ICON_PRICE, DISAPPEAR);
		setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
		setDisplayValue(TEXT_PRICE, DISAPPEAR);
	}
}

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

	memset(data, 0x00, ARRAY_SIZE(data));
	memset(currency, 0x00, ARRAY_SIZE(currency));
	strcpy((char*)kWh, "/kWh");

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

//=======================================
// Setting price ( WEB PAGE )
//=======================================
void setPriceFromWebsite(float monry_rate)
{
	uint8_t data[16];
	uint8_t price[16];

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

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

//=======================================
// Setting final cost
//=======================================
void setPresentFinalCost(float cost)
{
	uint8_t data[16];
	uint8_t finalCost[16];

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

//=======================================
// Getting final cost
//=======================================
float getPresentFinalCost(uint8_t gun_index)
{
	float result = 0.0f;

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

	return result;
}

//=======================================
// Setting billing ( BACKEND )
//=======================================
void setBillingFromBackend(uint8_t gun_index, uint8_t system_mode)
{
	if((system("pidof -s OcppBackend > /dev/null") != 0))
	{
		// DISAPPEAR PRICE ICON, PRICE TEXT AND CURRENCY TEXT
		setDisplayValue(ICON_PRICE, DISAPPEAR);
		setDisplayValue(TEXT_PRICE, DISAPPEAR);
		setDisplayValue(TEXT_CURRENCY_UNIT, 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)
					{
						/*
						 * 1. SEARCHING DEFAULT PRICE FOR PRICE TEXT
						 * 2. SEARCHING DEFAULT PRICE FOR CURRENCY AND UNIT TO APPEAR
						 */
						setDefaultPrice(CURRENT_RATE);
						setCurrencyAndUnitFromBackend(DEFAULE_PRICE, CURRENT_RATE, gun_index);
					}
					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->SysInfo.AcChargingData[gun_index].StartUserId, (char *)ShmOCPP16Data->Cost.SetUserPrice.idToken) == 0) &&
							((strcmp((char *)ShmOCPP16Data->Cost.SetUserPrice.idToken,"") != 0)))
						{
							/*
							 * 1. SEARCHING USER PRICE FOR PRICE TEXT
							 * 2. SEARCHING USER PRICE FOR URRENCY AND UNIT TO APPEAR
							 */
							setUserPrice(CURRENT_RATE);
							setCurrencyAndUnitFromBackend(SET_USER_PRICE, CURRENT_RATE,gun_index);
						}
						else
						{
							/*
							 * 1. SEARCHING DEFAULT PRICE FOR PRICE TEXT
							 * 2. SEARCHING DEFAULT PRICE FOR CURRENCY AND UNIT TO APPEAR
							 */
							setDefaultPrice(CURRENT_RATE);
							setCurrencyAndUnitFromBackend(DEFAULE_PRICE, CURRENT_RATE, gun_index);
						}
					}
				}
				else
				{
					// DISAPPEAR PRICE ICON, PRICE TEXT AND CURRENCY TEXT
					setDisplayValue(ICON_PRICE, DISAPPEAR);
					setDisplayValue(TEXT_PRICE, DISAPPEAR);
					setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
				}
			}
			else
			{
				// DISPLAY BY OCPP 2.0.1
			}
		}
		else
		{
			// DISAPPEAR PRICE ICON, PRICE TEXT AND CURRENCY TEXT
			setDisplayValue(ICON_PRICE, DISAPPEAR);
			setDisplayValue(TEXT_PRICE, DISAPPEAR);
			setDisplayValue(TEXT_CURRENCY_UNIT, DISAPPEAR);
		}
	}
}

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

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

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

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

				// APPEAR ACCOUNT BALANCE TEXT
				strcpy((char*)tmp,(char *)ShmOCPP16Data->Cost.SetUserPrice.price);
				Split_String_Count = 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_BALANCE, output_data, ARRAY_SIZE(output_data));
			}
			else
			{
				// DISAPPEAR BALANCE ICON AND BALANCE TEXT
				setDisplayValue(ICON_BALANCE_WALLET, DISAPPEAR);
				setDisplayValue(TEXT_BALANCE, DISAPPEAR);
			}
			break;
		default:
			break;
	}
}

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

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

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

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

//=======================================
// Setting FinalCost ( BACKEND )
//=======================================
void setFinalCost(uint8_t gun_index, uint8_t type)
{
	uint8_t length;
	uint8_t Split_String_Count;
	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(output_data, 0x00, ARRAY_SIZE(output_data));
	memset(input_data, 0x00, ARRAY_SIZE(input_data));

	switch(type)
	{
		case CONNECTION_FEE:
			break;
		case SESSION_FEE:
			break;
		case OCCUPANCY_FEE:
			break;
		case TOTAL_COST:
			if((strstr((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description, "Total Cost:") > 0))
			{
				// APPEAR COST ICON
				setDisplayValue(ICON_COST_COMPLETE, APPEAR);

				// APPEAR COST TEXT
				strcpy((char*)tmp,(char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description);
				Split_String_Count = 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_COST_COMPLETE, output_data, ARRAY_SIZE(output_data));
			}
			else
			{
				// DISAPPEAR COST ICON AND COST TEXT
				setDisplayValue(ICON_COST_COMPLETE, DISAPPEAR);
				setDisplayValue(TEXT_COST_COMPLETE, DISAPPEAR);
			}
			break;
		case ACCOUNT_BALANCE:
			if((strstr((char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description, "Account Balance:") > 0))
			{
				// APPEAR BALANCE ICON
				setDisplayValue(ICON_WALLER_COMPLETE, APPEAR);
				setDisplayValue(ICON_BALANCE_WALLET, APPEAR);

				// APPEAR BALANCE TEXT
				strcpy((char*)tmp,(char*)ShmOCPP16Data->Cost.FinalCost[gun_index].description);
				Split_String_Count = split((char**)splitString, tmp, Symbol);
				memcpy(input_data, splitString[4], strlen(splitString[4]));
				length = strlen(input_data);
				trim_string(input_data,length);
				memcpy(output_data ,input_data, strlen(input_data));
				lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_ACCOUNT_COMPLETE, output_data, ARRAY_SIZE(output_data));
				lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_BALANCE, output_data, ARRAY_SIZE(output_data));
			}
			else
			{
				/*
				 * 1. DISAPPEAR ACCOUNT BALANCE WHEN THE SYSTEM IS COMPLETE MODE
				 * 2. DISAPPEAR ACCOUNT ICON WHEN THE SYSTEM IS COMPLETE MODE
				 */
				setDisplayValue(ICON_WALLER_COMPLETE, DISAPPEAR);
				setDisplayValue(TEXT_ACCOUNT_COMPLETE, DISAPPEAR);

				setDisplayValue(ICON_BALANCE_WALLET, DISAPPEAR);
				setDisplayValue(TEXT_BALANCE, DISAPPEAR);
			}
			break;
		default:
			break;
	}
}

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

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

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

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

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

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

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

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

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

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

	// QR CODE ( ENABLE / DISABLE )
	if(ShmSysConfigAndInfo->SysConfig.isQRCode == ON)
	{
		setDisplayValue(ICON_QRCODE,QRCODE_ENABLE);
		if(ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode == NO)
		{
			length = strlen((char *)ShmSysConfigAndInfo->SysConfig.SystemId);
			setQRcodeContent((char *)ShmSysConfigAndInfo->SysConfig.SystemId, length);
		}
		else
		{
			length = strlen((char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent);
			setQRcodeContent((char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent, length);
		}
	}
	else
	{
		setDisplayValue(TEXT_QRCODE_CONTENT, DISAPPEAR);
		setDisplayValue(ICON_QRCODE,QRCODE_DISABLE);
	}
}

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

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

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

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

//=======================================
// Setting warning page switch
//=======================================
void setWarningStatus(uint8_t gun_index)
{
	/*
	 * 1. WARNING COUNT IS DIFFERENT BETWEEN BEGINNING CHANGE DISPLAY
	 * 2. WARNING COUNT BIGGER THAN 4 AND EVERY 5 SECONDS CHANGE NEXT PAGE
	 */
	if(WarningCount != ShmSysConfigAndInfo->SysWarningInfo.WarningCount)
	{
		WarningCount = ShmSysConfigAndInfo->SysWarningInfo.WarningCount;
		ShmSysConfigAndInfo->SysWarningInfo.PageIndex = 0;

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

		setAlarmCodeAndIcon();
	}
}

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

	for(index = 0; (index + ShmSysConfigAndInfo->SysWarningInfo.PageIndex * 4) < ShmSysConfigAndInfo->SysWarningInfo.WarningCount; index++)
	{
		memset(cmd, 0x00, sizeof(cmd));
		if(index >= 4)
		{
			break;
		}

		// ALARM CODE TEXT (XXXXXX)
		string2ByteArray(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[index + ShmSysConfigAndInfo->SysWarningInfo.PageIndex * 4][0], cmd);
		lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_ALARM_CODE_1 + (index * 6), cmd, ARRAY_SIZE(cmd));

		// ALARM CODE ICON STATUS (!)
		memset(cmd, 0x00, sizeof(cmd));

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

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

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

			// INITIALIZATION BATTERY ICON AND PERCENTAGE TEXT
			setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_EMPTY);
			setDisplayValue(ICON_BATTERY_COMPLETE, BATTERY_SOC_EMPTY);
			setDisplayValue(TEXT_PERCENTAGE, DISAPPEAR);

			break;
		case SYS_MODE_CHARGING:
			if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
			{
				if(isEmulator == YES)
				{
					if((DiffTimebWithNow(startTime[gun_index][TMR_IDX_EMULATOR]) > 3000))
					{
						if(isCharging == YES)
							PERCENTAGE++;
						else
							PERCENTAGE--;

						ftime(&startTime[gun_index][TMR_IDX_EMULATOR]);
					}

					if(isCharging == YES)
					{
						if(PERCENTAGE > 100)
							PERCENTAGE = 0;
					}
					else
					{
						if(PERCENTAGE <= 0)
							PERCENTAGE = 100;
					}

					ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc = PERCENTAGE;
					if((isChange == 0) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_BATTERY]) > (TIME_ANIMATION_BATTERY)))
					{
						isChange = 1;
					}
					else if((isChange == 1) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_BATTERY]) > (TIME_ANIMATION_BATTERY*2)))
					{
						isChange = 0;
						ftime(&startTime[gun_index][TMR_IDX_BATTERY]);
					}
				}
				else
				{}

				// SET BATTERY ANIMATION
				if(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc < 20)
				{
					if(isChange == 0)
						setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_EMPTY);
					else
						setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_20);
				}
				else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc >= 20) && (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc < 40))
				{
					if(isChange == 0)
						setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_20);
					else
						setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_40);
				}
				else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc >= 40) && (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc < 60))
				{
					if(isChange == 0)
						setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_40);
					else
						setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_60);
				}
				else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc >= 60) && (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc < 80))
				{
					if(isChange == 0)
						setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_60);
					else
						setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_80);
				}
				else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc >= 80) && (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc < 100))
				{
					if(isChange == 0)
						setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_80);
					else
						setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_100);
				}
				else if(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc == 100)
				{
					setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_100);
				}

				// SET BATTERY SOC VALUE
				setBatteryPercentageValue(gun_index);

				// SET ICON TO CHARGE OR DISCHARGE
				if(isCharging == YES)
					setDisplayValue(ICON_ELECTRICITY_DIRECTION, ELECTRICITY_DIRECTION_LEFT);
				else
					setDisplayValue(ICON_ELECTRICITY_DIRECTION, ELECTRICITY_DIRECTION_RIGHT);
			}
			else
			{
				// SET BATTERY PERCENTAGE TEXT TO DISAPPEAR
				setDisplayValue(TEXT_PERCENTAGE, DISAPPEAR);

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

			break;
		case SYS_MODE_TERMINATING:
			if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
			{
				// SET BATTERY ANIMATION
				if(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc < 20)
					setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_20);
				else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc >= 20) && (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc < 40))
					setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_40);
				else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc >= 40) && (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc < 60))
					setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_60);
				else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc >= 60) && (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc < 80))
					setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_80);
				else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc >= 80) && (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc <= 100))
					setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_100);

				// SET BATTERY SOC VALUE
				setBatteryPercentageValue(gun_index);

				// SET ELECTRIC ARROW DIRECTION ICON DISAPPEAR
				setDisplayValue(ICON_ELECTRICITY_DIRECTION, DISAPPEAR);
			}
			else
			{
				// SET BATTERY ICON TO EMPTY ICON
				setDisplayValue(ICON_BATTERY_CHARGING, BATTERY_CAPACITY_EMPTY);

				// SET BATTERY PERCENTAGE TO DISAPPEAR
				setDisplayValue(TEXT_PERCENTAGE, DISAPPEAR);
			}

			break;
		case SYS_MODE_COMPLETE:
			if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
			{
				// SET BATTERY ANIMATION
				if(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc < 20)
					setDisplayValue(ICON_BATTERY_COMPLETE, BATTERY_SOC_20);
				else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc >= 20) && (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc < 40))
					setDisplayValue(ICON_BATTERY_COMPLETE, BATTERY_SOC_40);
				else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc >= 40) && (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc < 60))
					setDisplayValue(ICON_BATTERY_COMPLETE, BATTERY_SOC_60);
				else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc >= 60) && (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc < 80))
					setDisplayValue(ICON_BATTERY_COMPLETE, BATTERY_SOC_80);
				else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc >= 80) && (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc <= 100))
					setDisplayValue(ICON_BATTERY_COMPLETE, BATTERY_SOC_100);

				// SET BATTERY SOC VALUE
				setBatteryPercentageValue(gun_index);

				// SET ELECTRIC ARROW DIRECTION ICON DISAPPEAR
				setDisplayValue(ICON_ELECTRICITY_DIRECTION, DISAPPEAR);
			}
			else
			{
				// SET BATTERY ICON TO FULL BATTERY ICON
				setDisplayValue(ICON_BATTERY_COMPLETE, BATTERY_SOC_100);

				// SET BATTERY PERCENTAGE TO DISAPPEAR
				setDisplayValue(TEXT_PERCENTAGE, DISAPPEAR);
			}

			break;
		default:
			break;
	}
}

//=======================================
// Setting connection icon animation
//=======================================
void setConnectionAnimation(uint8_t gun_index, uint8_t system_mode)
{
	switch(system_mode)
	{
		case SYS_MODE_PREPARING:
			if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_0) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION)))
			{
				setDisplayValue(ICON_CONNECTION_PRECHARGING, CONNECTION_QUESTION_MARK_1);
				CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_1;
			}
			else if((CONNECTION_LEVEL_STATUS == CONNECTION_LEVEL_1) && (DiffTimebWithNow(startTime[gun_index][TMR_IDX_CONNECTION]) > (TIME_ANIMATION_CONNECTION*2)))
			{
				setDisplayValue(ICON_CONNECTION_PRECHARGING, CONNECTION_QUESTION_MARK_2);
				CONNECTION_LEVEL_STATUS =  CONNECTION_LEVEL_0;
				ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
			}

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

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

			break;
		default:
			break;
	}
}

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

//=======================================
// Setting battery SOC value
//=======================================
void setBatteryPercentageValue(uint8_t gun_index)
{
	uint8_t data[16];
	uint8_t soc[16];

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

	sprintf((char *)soc, "%d%%", ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].EvBatterySoc);
	string2ByteArray(soc, data);
	lcdRegisterWrite(Uart1Fd, REG_TYPE_RAM, TEXT_PERCENTAGE, data, ARRAY_SIZE(data));
}

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

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

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

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

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

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

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

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

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

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

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

//=======================================
// Setting default values
//=======================================
void setDefaultValue(uint8_t gun_index, uint8_t system_mode)
{
	switch(system_mode)
	{
		case SYS_MODE_BOOTING:
			break;
		case SYS_MODE_IDLE:
			setBatteryAnimation(gun_index, system_mode);
			break;
		case SYS_MODE_AUTHORIZING:
			break;
		case SYS_MODE_PREPARING:
			// DEFAULT TIMER, ICON AND STATUS OF ANIMATION. ( BS / HLC ) MODE
			if(ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC)
			{
				setDisplayValue(ICON_CONNECTION_PRECHARGING, CONNECTION_QUESTION_MARK_1);
				setDisplayValue(ICON_BATTERY_PRECHARGING, BATTERY_CAPACITY_EMPTY);
				ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
				CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
			}
			else
			{
				setDisplayValue(ICON_PLUGIN_ARROW, PLUGIN_ARROW_1);
				GUN_PLUGING_LEVEL_STATUS = GUN_PLUGING_LEVEL_0;
				ftime(&startTime[gun_index][TMR_IDX_PLUGIN]);
			}
			break;
		case SYS_MODE_CHARGING:
			// DEFAULT TIMER, ICON AND STATUS OF ANIMATION
			setDisplayValue(ICON_CONNECTION_CHARGING, CONNECTION_ELECTRIC_MARK_1);
			ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
			ftime(&startTime[gun_index][TMR_IDX_BATTERY]);
			CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
			BATTERY_LEVEL_STATUS = BATTERY_LEVEL_5;
			break;
		case SYS_MODE_TERMINATING:
			// DEFAULT TIMER, ICON AND STATUS OF ANIMATION
			setDisplayValue(ICON_CONNECTION_CHARGING, CONNECTION_QUESTION_MARK_1);
			ftime(&startTime[gun_index][TMR_IDX_CONNECTION]);
			CONNECTION_LEVEL_STATUS = CONNECTION_LEVEL_0;
			BATTERY_LEVEL_STATUS = BATTERY_LEVEL_5;
			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;
	}
}

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

//=======================================
// 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(previousMode != ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus)
		{
			previousMode = ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus;
		}

		switch(ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus)
		{
			case SYS_MODE_BOOTING:
				page_booting();
				break;
			case SYS_MODE_IDLE:
				page_idle(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
				break;
			case SYS_MODE_AUTHORIZING:
				page_authorizing(ShmCharger->gun_selectd);
				break;
			case SYS_MODE_PREPARING:
				page_preparing(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
				break;
			case SYS_MODE_CHARGING:
				page_charging(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
				break;
			case SYS_MODE_TERMINATING:
				page_terminating(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
				break;
			case SYS_MODE_COMPLETE:
				page_complete(ShmCharger->gun_selectd, ShmSysConfigAndInfo->SysInfo.AcChargingData[ShmCharger->gun_selectd].SystemStatus);
				break;
			case SYS_MODE_ALARM:
				page_alarm();
				break;
			case SYS_MODE_FAULT:
				page_fault();
				break;
			case SYS_MODE_MAINTAIN:
				page_maintain();
				break;
			case SYS_MODE_UPDATE:
				page_update();
				break;
			case SYS_MODE_RESERVATION:
				page_reservation();
				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;
}