csu3_am335x/EVSE/Projects/DS60-120/Apps/Module_LcmControl.c

#include "Module_LcmContro.h"

bool needReloadQr = true;

void PRINTF_FUNC(char *string, ...);

int StoreLogMsg(const char *fmt, ...);
#define DEBUG_INFO(format, args...) StoreLogMsg("[%s:%d][%s][Info] "format, __FILE__, __LINE__, __FUNCTION__, ##args)
#define DEBUG_WARN(format, args...) StoreLogMsg("[%s:%d][%s][Warn] "format, __FILE__, __LINE__, __FUNCTION__, ##args)
#define DEBUG_ERROR(format, args...) StoreLogMsg("[%s:%d][%s][Error] "format, __FILE__, __LINE__, __FUNCTION__, ##args)

char* getTimeString(void);

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

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

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

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

	return rc;
}

char* getTimeString(void)
{
	char *result=malloc(21);
	time_t timep;
	struct tm *p;
	time(&timep);
	p=gmtime(&timep);

	sprintf(result, "[%04d-%02d-%02d %02d:%02d:%02d]", (1900+p->tm_year), (1+p->tm_mon), p->tm_mday, p->tm_hour, p->tm_hour, p->tm_sec);

	return result;
}

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

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

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

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

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

    return result;
}

//==========================================
// Open and Close RS232 and R/W
//==========================================
int CreateCommunicationLcmPort()
{
	int fd;
	struct termios tios;

	fd = open(pPortName, O_RDWR);
	if (fd <= 0) {
		#ifdef SystemLogMessage
		DEBUG_ERROR("open /dev/ttyS3 NG \n");
		#endif
		return -1;
	}
	ioctl(fd, TCGETS, &tios);
	tios.c_cflag = B115200 | CS8 | CLOCAL | CREAD;
	tios.c_lflag = 0;
	tios.c_iflag = 0;
	tios.c_oflag = 0;
	tios.c_cc[VMIN] = 0;
	tios.c_cc[VTIME] = (unsigned char) 5;
	tios.c_lflag = 0;
	tcflush(fd, TCIFLUSH);
	ioctl(fd, TCSETS, &tios);

	return fd;
}

void CloseCommunicationLcmPort()
{
	close(_port);
}

void WriteCmdToLcm(byte *cmd, byte cmdLen)
{
	int len = write(_port, cmd, cmdLen);
	if(len >= sizeof(cmd))
	{
		//PRINTF_FUNC("Write cmd to LCM successfully. \n");
	}
}

void ReadMsgFromLcm(byte *msg, byte readLen)
{
	read(_port, msg, readLen);

	if(*msg == CMD_TITLE_1 && *(msg + 1) == CMD_TITLE_2)
	{
		if(*(msg + 3) == CMD_WRITE)
		{
			switch (*(msg + 4))
			{
				case CMD_REGISTER:
				{
					// 頁面
					strcpy((char *)ShmSysConfigAndInfo->SysInfo.LcmHwRev, moduleName);
				}
				break;
			}
		}
		else if (*(msg + 3) == CMD_MULTI_READ)
		{
//			switch ((unsigned short) (*(msg + 4) << 8) + (unsigned short) *(msg + 5))
//			{
//				case BUTTON_GUN_INDEX:
//				{
//					// 當前選的槍號
//					_curGunIndex = (*(msg + 8));
//				}
//				break;
//			}
		}
	}
}

//================================================
// Function
//================================================
void ChangeToOtherPage(short newPage)
{
	byte cmd[7];
	memset(cmd, 0x00, sizeof(cmd));

	cmd[0] = CMD_TITLE_1;
	cmd[1] = CMD_TITLE_2;
	cmd[2] = 0x02 + sizeof(newPage);
	cmd[3] = CMD_READ;
	cmd[4] = CMD_REGISTER;
	cmd[5] = newPage >> 8;
	cmd[6] = newPage & 0x00FF;

	WriteCmdToLcm(cmd, ARRAY_SIZE(cmd));
	usleep(100000);
}

void ChangeBackLight(bool islight)
{
	byte value = 0x01;

	if (islight)
	{
		value = 0x20;
	}
	byte cmd[7];
	memset(cmd, 0x00, sizeof(cmd));

	cmd[0] = CMD_TITLE_1;
	cmd[1] = CMD_TITLE_2;
	cmd[2] = 0x03;
	cmd[3] = CMD_READ;
	cmd[4] = CMD_BACKLIGHT;
	cmd[5] = value;

	WriteCmdToLcm(cmd, ARRAY_SIZE(cmd));
	usleep(100000);
}

void GetCurrentPage()
{
	byte cmd[6];
	memset(cmd, 0x00, sizeof(cmd));
	byte msg[8];
	memset(msg, 0x00, sizeof(msg));

	cmd[0] = CMD_TITLE_1;
	cmd[1] = CMD_TITLE_2;
	cmd[2] = 0x03;				// 底下總長度
	cmd[3] = CMD_WRITE;
	cmd[4] = CMD_REGISTER;
	cmd[5] = 0x02;

	WriteCmdToLcm(cmd, ARRAY_SIZE(cmd));
	usleep(100000);
	ReadMsgFromLcm(msg, ARRAY_SIZE(msg));
}

void DisplayValueToLcm(short address, byte *data, byte len)
{
	byte cmd[256];
	memset(cmd, 0x00, sizeof(cmd));

	cmd[0] = CMD_TITLE_1;
	cmd[1] = CMD_TITLE_2;
	cmd[2] = 0x03 + len;
	cmd[3] = CMD_MULTI_WRITE;
	cmd[4] = address >> 8;
	cmd[5] = address & 0x00FF;

	for(byte count = 0; count < len; count++)
	{
		cmd[6 + count] = *(data + count);
	}

	WriteCmdToLcm(cmd, cmd[2] + 3);
}

void ChangeDisplay2Value(short address, short value)
{
	byte data[2];
	data[0] = value >> 8;
	data[1] = value & 0x00FF;

	DisplayValueToLcm(address, data, sizeof(data));
}

void GetBtnStatus(short address, byte len)
{
	byte cmd[8];
	memset(cmd, 0x00, sizeof(cmd));
	byte msg[8];
	memset(msg, 0x00, sizeof(msg));

	cmd[0] = CMD_TITLE_1;
	cmd[1] = CMD_TITLE_2;
	cmd[2] = 0x03 + len;
	cmd[3] = CMD_MULTI_READ;
	cmd[4] = address >> 8;
	cmd[5] = address & 0x00FF;
	cmd[6] = 0x00 + len;

	WriteCmdToLcm(cmd, cmd[2] + 3);
	usleep(100000);
	ReadMsgFromLcm(msg, (len * 2) + sizeof(msg));
}

//================================================
// Warning process
//================================================
void string2ByteArray(unsigned char *input, byte *output)
{
    int loop;
    int i;

    loop = 0;
    i = 0;

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

void ChangeWarningFunc()
{
	byte cmd[7];
	byte i = 0;
	//PRINTF_FUNC("ChangeWarningFunc \n");
	// 最多一次五筆
	//PRINTF_FUNC("LCM PageIndex = %d \n", ShmSysConfigAndInfo->SysWarningInfo.PageIndex);
	//PRINTF_FUNC("WarningCount = %d \n", ShmSysConfigAndInfo->SysWarningInfo.WarningCount);
	for(i = 0; (i + ShmSysConfigAndInfo->SysWarningInfo.PageIndex * 5) < ShmSysConfigAndInfo->SysWarningInfo.WarningCount; i++)
	{
		memset(cmd, 0x00, sizeof(cmd));
		if(i >= 5)
		{
			break;
		}
		//error code
		string2ByteArray(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i + ShmSysConfigAndInfo->SysWarningInfo.PageIndex * 5][0], cmd);
		DisplayValueToLcm(0x0010 + (i * 6), cmd, sizeof(cmd));
		//警告標示
		memset(cmd, 0x00, sizeof(cmd));

		cmd[0] = 0x00;
		cmd[1] = 0x01;
		DisplayValueToLcm(0x0002 + (i * 2), cmd, 2);
	}

	memset(cmd, 0x00, sizeof(cmd));
	for(; i < 5; i++)
	{
		DisplayValueToLcm(0x0010 + (i * 6), cmd, sizeof(cmd));
		DisplayValueToLcm(0x0002 + (i * 2), cmd, 2);
	}
}

//================================================
// QR Code process
//================================================
void ChangeQrCode_Idle(char *input)
{
	int len = strlen(input);
	byte cmd[len];

	int loop = 0;
	int i = 0;

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

	DisplayValueToLcm(__qr_code, cmd, len);
}

void ChangeQrCode_Charge(char *input)
{
	int len = strlen(input);
	byte cmd[len];

	int loop = 0;
	int i = 0;

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

	DisplayValueToLcm(__qr_code_pre, cmd, len);
}

//================================================
// Change current page
//================================================
void ChangeCurPage()
{
	//PRINTF_FUNC("cur = %d, new = %d \n", _currentPage, ShmSysConfigAndInfo->SysInfo.PageIndex);
	if (_currentPage != ShmSysConfigAndInfo->SysInfo.PageIndex)
	{
		_currentPage = ShmSysConfigAndInfo->SysInfo.PageIndex;
		ChangeToOtherPage(_currentPage);
		_everyPageRollChange = 0;
	}
}

//================================================
// Main process
//================================================
byte demoCount = 0;
void DemoFunction()
{
	if (demoCount == 0)
	{
		ShmSysConfigAndInfo->SysWarningInfo.WarningCount = 6;
		memcpy(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[0][0], "000001", 7);
		memcpy(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[1][0], "000002", 7);
		memcpy(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[2][0], "000003", 7);
		memcpy(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[3][0], "000004", 7);
		memcpy(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[4][0], "000005", 7);
		memcpy(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[5][0], "000006", 7);
	}
	else
	{
		if (demoCount == 20) {
			ShmSysConfigAndInfo->SysInfo.PageIndex = _LCM_IDLE;
		} else if (demoCount == 80) {
			ShmSysConfigAndInfo->SysInfo.PageIndex = _LCM_AUTHORIZING;
		} else if (demoCount == 100) {
			ShmSysConfigAndInfo->SysInfo.PageIndex = _LCM_AUTHORIZ_COMP;
		} else if (demoCount == 120) {
			ShmSysConfigAndInfo->SysInfo.PageIndex = _LCM_AUTHORIZ_FAIL;
		} else if (demoCount == 140) {
			ShmSysConfigAndInfo->SysInfo.PageIndex = _LCM_PRE_CHARGE;
		} else if (demoCount == 180) {
			ShmSysConfigAndInfo->SysInfo.PageIndex = _LCM_CHARGING;
		}
	}

	if (demoCount < 180)
		demoCount++;
}

//================================================
// Main process
//================================================
bool FindChargingInfoData(byte target, struct ChargingInfoData **_chargingData)
{
	for (byte index = 0; index < CHAdeMO_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == target)
		{
			_chargingData[target] = &ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index];
			return true;
		}
	}

	for (byte index = 0; index < CCS_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == target)
		{
			_chargingData[target] = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[index];
			return true;
		}
	}

	for (byte index = 0; index < GB_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == target)
		{
			_chargingData[target] = &ShmSysConfigAndInfo->SysInfo.GbChargingData[index];
			return true;
		}
	}

	return false;
}

bool FindAcChargingInfoData(byte target, struct ChargingInfoData **acChargingData)
{
	if (target < AC_QUANTITY)
	{
		acChargingData[target] = &ShmSysConfigAndInfo->SysInfo.AcChargingData[target];
		return true;
	}

	return false;
}

void ChangeAcBattMapAndValue(short page)
{
	if (page == _LCM_CHARGING)
	{
		if (isDiffStatus != _battery_display_ani)
		{
			isChangeBattMap = false;
			isDiffStatus = _battery_display_ani;
		}

		if (ac_chargingInfo[0]->IsCharging && !isChangeBattMap)
		{
			isChangeBattMap = true;
			if (ac_ani_battery_level == _BATTERY_LEVEL_FOR_MAP_LV5)
			{
				ChangeDisplay2Value(__batt_map, _battery_empty);
				ac_ani_battery_level = _BATTERY_LEVEL_FOR_MAP_EMP;
			}
			else if (ac_ani_battery_level == _BATTERY_LEVEL_FOR_MAP_EMP)
			{
				ChangeDisplay2Value(__batt_map, _battery_cap_20);
				ac_ani_battery_level = _BATTERY_LEVEL_FOR_MAP_LV1;
			}
			else if (ac_ani_battery_level == _BATTERY_LEVEL_FOR_MAP_LV1)
			{
				ChangeDisplay2Value(__batt_map, _battery_cap_40);
				ac_ani_battery_level = _BATTERY_LEVEL_FOR_MAP_LV2;
			}
			else if (ac_ani_battery_level == _BATTERY_LEVEL_FOR_MAP_LV2)
			{
				ChangeDisplay2Value(__batt_map, _battery_cap_60);
				ac_ani_battery_level = _BATTERY_LEVEL_FOR_MAP_LV3;
			}
			else if (ac_ani_battery_level == _BATTERY_LEVEL_FOR_MAP_LV3)
			{
				ChangeDisplay2Value(__batt_map, _battery_cap_80);
				ac_ani_battery_level = _BATTERY_LEVEL_FOR_MAP_LV4;
			}
			else if (ac_ani_battery_level == _BATTERY_LEVEL_FOR_MAP_LV4)
			{
				ChangeDisplay2Value(__batt_map, _battery_cap_100);
				ac_ani_battery_level = _BATTERY_LEVEL_FOR_MAP_LV5;
			}
		}
	}
	else if (page == _LCM_COMPLETE)
	{
		if (ac_ani_battery_level == _BATTERY_LEVEL_FOR_MAP_LV5)
			ChangeDisplay2Value(__batt_map, _battery_soc_20);
		else if (ac_ani_battery_level == _BATTERY_LEVEL_FOR_MAP_EMP)
			ChangeDisplay2Value(__batt_map, _battery_soc_20);
		else if (ac_ani_battery_level == _BATTERY_LEVEL_FOR_MAP_LV1)
			ChangeDisplay2Value(__batt_map, _battery_soc_40);
		else if (ac_ani_battery_level == _BATTERY_LEVEL_FOR_MAP_LV2)
			ChangeDisplay2Value(__batt_map, _battery_soc_60);
		else if (ac_ani_battery_level == _BATTERY_LEVEL_FOR_MAP_LV3)
			ChangeDisplay2Value(__batt_map, _battery_soc_80);
		else if (ac_ani_battery_level == _BATTERY_LEVEL_FOR_MAP_LV4)
			ChangeDisplay2Value(__batt_map, _battery_soc_100);
	}

	ChangeDisplay2Value(__soc_value_charging, _disappear);
}

void ChangeBattMapAndValue(short page, int soc)
{
//	srand(time(NULL));
//	int min = 10;
//	int max = 90;
//	soc = rand() % (max - min + 1) + min;

	if (page == _LCM_PRE_CHARGE)
	{
		ChangeDisplay2Value(__batt_map_empty, _battery_empty);
	}
	else if (page == _LCM_CHARGING)
	{
		if (soc < 20)
		{
			if (_battery_display_ani)
				ChangeDisplay2Value(__batt_map, _battery_empty);
			else
				ChangeDisplay2Value(__batt_map, _battery_cap_20);
		}
		else if (soc >= 20 && soc < 40)
		{
			if (_battery_display_ani)
				ChangeDisplay2Value(__batt_map, _battery_cap_20);
			else
				ChangeDisplay2Value(__batt_map, _battery_cap_40);
		}
		else if (soc >= 40 && soc < 60)
		{
			if (_battery_display_ani)
				ChangeDisplay2Value(__batt_map, _battery_cap_40);
			else
				ChangeDisplay2Value(__batt_map, _battery_cap_60);
		}
		else if (soc >= 60 && soc < 100)
		{
			if (_battery_display_ani)
				ChangeDisplay2Value(__batt_map, _battery_cap_60);
			else
				ChangeDisplay2Value(__batt_map, _battery_cap_80);
		}
		else if (soc == 100)
			ChangeDisplay2Value(__batt_map, _battery_cap_100);
	}
	else if (page == _LCM_COMPLETE)
	{
		if (soc < 20)
			ChangeDisplay2Value(__batt_map, _battery_soc_20);
		else if (soc >= 20 && soc < 40)
			ChangeDisplay2Value(__batt_map, _battery_soc_40);
		else if (soc >= 40 && soc < 60)
			ChangeDisplay2Value(__batt_map, _battery_soc_60);
		else if (soc >= 60 && soc < 80)
			ChangeDisplay2Value(__batt_map, _battery_soc_80);
		else if (soc >= 80 && soc <= 100)
			ChangeDisplay2Value(__batt_map, _battery_soc_100);
	}

	byte cmd[5];
	byte value[5];

	memset(cmd, 0x00, sizeof(cmd));
	memset(value, 0x00, sizeof(value));
	sprintf((char *)value, "%d%%", soc);
	string2ByteArray(value, cmd);
	DisplayValueToLcm(__soc_value_charging, cmd, sizeof(cmd));
}

void ChangeRemainTime(int sec)
{
	int h, m, s;
	byte cmd[10];
	byte value[10];

	memset(cmd, 0x00, sizeof(cmd));

//	srand(time(NULL));
//	int min = 0;
//	int max = 65536;
//	sec = rand() % (max - min + 1) + min;

	h = (sec / 3600);
	m = (sec - (3600 * h)) / 60;
	s = (sec - (3600 * h) - (m * 60));
	sprintf((char *)value, "%02d:%02d:%02d", h, m, s);
	string2ByteArray(value, cmd);
	DisplayValueToLcm(__remain_time_tx, cmd, sizeof(cmd));
}

void ChangeChargingEnergyValue(float energy)
{
	byte cmd[10];
	byte value[10];

	memset(cmd, 0x00, sizeof(cmd));
	if (energy >= 0.05)
		energy -= 0.05;
	sprintf((char *) value, "%.1f kWh", energy);
	string2ByteArray(value, cmd);
	DisplayValueToLcm(__total_out_eng_tx, cmd, sizeof(cmd));
}

void ChangeChargingPowerValue(float pow)
{
	byte cmd[10];
	byte value[10];

	memset(cmd, 0x00, sizeof(cmd));

//	float min = 0.0;
//	float max = 50;
//	pow = (max - min) * rand() / (RAND_MAX + 1.0) + min;
	sprintf((char *) value, "%.1f kW", pow);
	string2ByteArray(value, cmd);
	DisplayValueToLcm(__output_eng_tx, cmd, sizeof(cmd));
}

void ChangeChargingFeeValue(float fee)
{
	byte cmd[10];
	byte value[10];

	memset(cmd, 0x00, sizeof(cmd));

	sprintf((char *) value, "%.2f", fee);
	string2ByteArray(value, cmd);
	DisplayValueToLcm(__charging_fee_tx, cmd, sizeof(cmd));
}

void DisplayMoneyRate(float money)
{
	byte cmd[8];
	byte value[8];

	memset(cmd, 0x00, sizeof(cmd));

	sprintf((char *) value, "%.2f", money);
	string2ByteArray(value, cmd);
	DisplayValueToLcm(__money_by_rate, cmd, sizeof(cmd));
}

void DisplayMoneyCur(byte *cur)
{
	byte cmd[5];
	byte buf[5];

	*(cur + 3) = '\0';
	memset(cmd, 0x00, sizeof(cmd));
	sprintf((char *) buf, "%s", cur);
	string2ByteArray(buf, cmd);
	DisplayValueToLcm(__money_rate, cmd, sizeof(cmd));
}

void RefreshPageAnimation(byte value)
{
	switch(_currentPage)
	{
		case _LCM_IDLE:
		{

		}
			break;
		case _LCM_WAIT_FOR_PLUG:
		{
			if(_everyPageRollChange == 0)
				ChangeDisplay2Value(__plug_in_arrow, _arrow_dark);
			else if(_everyPageRollChange == 15)
				ChangeDisplay2Value(__plug_in_arrow, _arrow_light);

			_everyPageRollChange > 30 ? _everyPageRollChange = 0 : _everyPageRollChange++;
		}
			break;
		case _LCM_PRE_CHARGE:
		case _LCM_CHARGING:
		case _LCM_COMPLETE:
		{
			if (_currentPage == _LCM_PRE_CHARGE)
			{
				if (_everyPageRollChange == 0 || _everyPageRollChange == 22)
					ChangeDisplay2Value(__conn_line, _conn_map1);
				else if (_everyPageRollChange == 11 || _everyPageRollChange == 33)
					ChangeDisplay2Value(__conn_line, _conn_map2);
			}
			else if (_currentPage == _LCM_CHARGING)
			{
				if (_everyPageRollChange == 0 || _everyPageRollChange == 22)
					ChangeDisplay2Value(__conn_line_chag, _charging_map1);
				else if (_everyPageRollChange == 11 || _everyPageRollChange == 33)
					ChangeDisplay2Value(__conn_line_chag, _charging_map2);
			}
			else if (_currentPage == _LCM_COMPLETE)
			{
				if (_everyPageRollChange == 0)
					ChangeDisplay2Value(__conn_line_comp, _complete_map);
			}

			_everyPageRollChange >= 45 ? _everyPageRollChange = 0 : _everyPageRollChange++;
		}
			break;
	}
}

void RefreshConnStatus()
{
	// eth
	if (ShmSysConfigAndInfo->SysInfo.ethInternetConn == YES)
	{ ChangeDisplay2Value(__ethernet_status, _ethernet_connect); }
	else
	{ ChangeDisplay2Value(__ethernet_status, _ethernet_disconnect); }

	// Wifi
	if((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'W' || ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D') &&
			ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode != _SYS_WIFI_MODE_DISABLE)
	{
		if (ShmSysConfigAndInfo->SysConfig.AthInterface.WifiNetworkConn == YES ||
				ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode == _SYS_WIFI_MODE_AP)
		{ ChangeDisplay2Value(__wifi_status, _wifi_connect); }
		else
		{ ChangeDisplay2Value(__wifi_status, _wifi_disconnect); }
	}
	else
	{ ChangeDisplay2Value(__wifi_status, _disappear); }

	if((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T' || ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D') &&
			ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled != NO)
	{
		if (ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode == _SYS_WIFI_MODE_DISABLE)
		{
			ChangeDisplay2Value(__3G4G_status, _disappear);
			// 3G/4G
			if (ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomNetworkConn == YES)
			{ ChangeDisplay2Value(__3G4G_move_status, _3G4G_disconnect); }
			else
			{ ChangeDisplay2Value(__3G4G_move_status, _3G4G_disconnect); }
		}
		else
		{
			ChangeDisplay2Value(__3G4G_move_status, _disappear);
			// 3G/4G
			if (ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomNetworkConn == YES)
			{ ChangeDisplay2Value(__3G4G_status, _3G4G_disconnect); }
			else
			{ ChangeDisplay2Value(__3G4G_status, _3G4G_disconnect); }
		}
	}
	else
	{
		ChangeDisplay2Value(__3G4G_status, _disappear);
		ChangeDisplay2Value(__3G4G_move_status, _disappear);
	}

	// 連線到後台
	if (ShmSysConfigAndInfo->SysInfo.OcppConnStatus == YES)
		ChangeDisplay2Value(__conn_status, _connect);
	else
		ChangeDisplay2Value(__conn_status, _disconnect);
}

byte FirstPageChanged()
{
	byte result = NO;

	if (_currentPage != _oldPage)
	{
		result = YES;
		_oldPage = _currentPage;
	}

	return result;
}

bool IsPageReloadChk()
{
	bool result = false;

	if (ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc == NO_DEFINE)
	{
		if (_curPage_index != ShmSysConfigAndInfo->SysInfo.CurGunSelected)
		{
			_curPage_index = ShmSysConfigAndInfo->SysInfo.CurGunSelected;
			result = true;
		}
	}
	else
	{
		if (_curPage_index != ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc)
		{
			_curPage_index = ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc;
			result = true;
		}
	}

	return result;
}

void DisplayInfoCsuVer(bool isShow, unsigned char *modelName)
{
	if (isShow)
	{
		byte value[10];

		memset(value, 0x00, sizeof(value));
		strcpy((char *)value, "CSU Ver >");
		DisplayValueToLcm(__csu_ver_string, value, sizeof(value));
		memset(value, 0x00, sizeof(value));
		strncpy((char *)value, (char *)modelName, 5);
		DisplayValueToLcm(__csu_ver_value, value, sizeof(value));
	}
	else
	{
		ChangeDisplay2Value(__csu_ver_string, _disappear);
		ChangeDisplay2Value(__csu_ver_value, _disappear);
	}
}

void DisplayInfoEthIp(bool isShow, unsigned char *ip)
{
	if (isShow)
	{
		byte value[20];

		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, "Eth IP >");
		DisplayValueToLcm(__eth0_ip_string, value, sizeof(value));
		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, (char *) ip);
		DisplayValueToLcm(__eth0_ip_value, value, sizeof(value));
	}
	else
	{
		ChangeDisplay2Value(__eth0_ip_string, _disappear);
		ChangeDisplay2Value(__eth0_ip_value, _disappear);
	}
}

void DisplayInfoSN(bool isShow, unsigned char *sn)
{
	if (isShow)
	{
		byte value[30];

		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, "SN >");
		DisplayValueToLcm(__sn_string, value, sizeof(value));
		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, (char *) sn);
		DisplayValueToLcm(__sn_value, value, sizeof(value));
	}
	else
	{
		ChangeDisplay2Value(__sn_string, _disappear);
		ChangeDisplay2Value(__sn_value, _disappear);
	}
}

void DisplayInfoGun1Ver(bool isShow, unsigned char *version)
{
	if (isShow)
	{
		byte value[10];

		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, "Ct1 Ver >");
		DisplayValueToLcm(__dc1_ver_string, value, sizeof(value));
		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, (char *) version);
		DisplayValueToLcm(__dc1_ver_value, value, sizeof(value));
	}
	else
	{
		ChangeDisplay2Value(__dc1_ver_string, _disappear);
		ChangeDisplay2Value(__dc1_ver_value, _disappear);
	}
}

void DisplayInfoGun2Ver(bool isShow, unsigned char *version)
{
	if (isShow)
	{
		byte value[10];

		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, "Ct2 Ver >");
		DisplayValueToLcm(__dc2_ver_string, value, sizeof(value));
		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, (char *) version);
		DisplayValueToLcm(__dc2_ver_value, value, sizeof(value));
	}
	else
	{
		ChangeDisplay2Value(__dc2_ver_string, _disappear);
		ChangeDisplay2Value(__dc2_ver_value, _disappear);
	}
}

void DisplayInfoSpeed(bool isShow, unsigned int fan)
{
	if (isShow)
	{
		byte value[10];

		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, "Fan Spd >");
		DisplayValueToLcm(__fan_speed_string, value, sizeof(value));
		memset(value, 0x00, sizeof(value));
		sprintf((char *)value, "%d", fan);
		DisplayValueToLcm(__fan_speed_value, value, sizeof(value));
	}
	else
	{
		ChangeDisplay2Value(__fan_speed_string, _disappear);
		ChangeDisplay2Value(__fan_speed_value, _disappear);
	}
}

void InformationShow()
{
	bool show = false;

	if(ShmSysConfigAndInfo->SysConfig.ShowInformation == YES)
	{
		show = true;
		DisplayInfoCsuVer(show, ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev);
		DisplayInfoSpeed(show, ShmSysConfigAndInfo->SysInfo.SystemFanRotaSpeed);
		DisplayInfoSN(show, ShmSysConfigAndInfo->SysConfig.SerialNumber);

		DisplayInfoEthIp(show, ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress);
		DisplayInfoGun1Ver(show, ShmSysConfigAndInfo->SysInfo.Connector1FwRev);
		if (_totalCount > 1)
			DisplayInfoGun2Ver(show, ShmSysConfigAndInfo->SysInfo.Connector2FwRev);
		else
		{
			DisplayInfoGun2Ver(false, ShmSysConfigAndInfo->SysInfo.Connector2FwRev);
		}
	}
	else
	{
		DisplayInfoCsuVer(show, ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev);
		DisplayInfoSpeed(show, ShmSysConfigAndInfo->SysInfo.SystemFanRotaSpeed);
		DisplayInfoSN(show, ShmSysConfigAndInfo->SysConfig.SerialNumber);

		DisplayInfoGun1Ver(show, ShmSysConfigAndInfo->SysInfo.Connector1FwRev);
		DisplayInfoGun2Ver(show, ShmSysConfigAndInfo->SysInfo.Connector2FwRev);
		DisplayInfoEthIp(show, ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress);
	}
}

void ProcessPageInfo()
{
	_page_reload = IsPageReloadChk();
	switch(_currentPage)
	{
		case _LCM_IDLE:
		{
			if (ShmSysConfigAndInfo->SysConfig.isRFID)
				ChangeDisplay2Value(__main_rfid, _main_rfid);
			else
				ChangeDisplay2Value(__main_rfid, _main_none_rfid);

			if (ShmSysConfigAndInfo->SysConfig.isQRCode)
				ChangeDisplay2Value(__main_qr, _main_qr);
			else
			{
				ChangeDisplay2Value(__qr_code, _disappear);
				ChangeDisplay2Value(__main_qr, _main_none_qr);
				needReloadQr = true;
			}

			if (ShmSysConfigAndInfo->SysConfig.isAPP)
				ChangeDisplay2Value(__main_app, _main_app);
			else
				ChangeDisplay2Value(__main_app, _main_none_app);

			if (FirstPageChanged() == YES || needReloadQr || _page_reload)
			{
				if (ShmSysConfigAndInfo->SysConfig.isQRCode)
				{
					needReloadQr = false;
					ChangeQrCode_Idle((char *)ShmSysConfigAndInfo->SysConfig.SystemId);
				}
			}
		}
			break;
		case _LCM_AUTHORIZING:
		case _LCM_AUTHORIZ_COMP:
		case _LCM_AUTHORIZ_FAIL:
		{
			FirstPageChanged();
		}
			break;
		case _LCM_WAIT_FOR_PLUG:
		{
			FirstPageChanged();
		}
			break;
		case _LCM_PRE_CHARGE:
		case _LCM_CHARGING:
		case _LCM_COMPLETE:
		{
			bool isShowAc = false;
			byte gunTargetIndex = 0;

			if (acgunCount > 0)
			{
				gunTargetIndex = 2;
				if (ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc != NO_DEFINE)
				{
					isShowAc = true;
					if (_currentPage == _LCM_COMPLETE)
						ChangeDisplay2Value(__cmp_gun_type_index + (gunTargetIndex * 2), _actype_light_cmp);
					else
						ChangeDisplay2Value(__gun_type_index + (gunTargetIndex * 2), _actype_light);

					if (_currentPage == _LCM_CHARGING)
					{
						ChangeAcBattMapAndValue(_LCM_CHARGING);
						if (ac_chargingInfo[0]->PresentChargedDuration >= 0 &&
								ac_chargingInfo[0]->PresentChargedDuration <= TIME_MAX_SEC)
							ChangeRemainTime(ac_chargingInfo[0]->PresentChargedDuration);
						else
							ChangeRemainTime(0);

						if (ac_chargingInfo[0]->PresentChargingPower >= 0.1 &&
								ac_chargingInfo[0]->PresentChargingPower <= POWER_MAX_KW)
							ChangeChargingPowerValue(ac_chargingInfo[0]->PresentChargingPower);
						else
							ChangeChargingPowerValue(0);

						if (ac_chargingInfo[0]->PresentChargedEnergy >= 0.1 &&
								ac_chargingInfo[0]->PresentChargedEnergy <= ENERGY_MAX_KWH)
							ChangeChargingEnergyValue(ac_chargingInfo[0]->PresentChargedEnergy);
						else
							ChangeChargingEnergyValue(0);

						if (strcmp((char *)ac_chargingInfo[0]->StartUserId, "") == 0)
							ChangeDisplay2Value(__stop_method_btn, _stop_charging_btn);
						else
							ChangeDisplay2Value(__stop_method_btn, _stop_charging_btn_scan);
					}
					else if (_currentPage == _LCM_COMPLETE)
					{
						ChangeAcBattMapAndValue(_LCM_COMPLETE);
						if (ac_chargingInfo[0]->PresentChargedDuration >= 0 &&
								ac_chargingInfo[0]->PresentChargedDuration <= TIME_MAX_SEC)
							ChangeRemainTime(ac_chargingInfo[0]->PresentChargedDuration);
						else
							ChangeRemainTime(0);

						if (ac_chargingInfo[0]->PresentChargingPower >= 0.1 &&
								ac_chargingInfo[0]->PresentChargingPower <= POWER_MAX_KW)
							ChangeChargingPowerValue(ac_chargingInfo[0]->PresentChargingPower);
						else
							ChangeChargingPowerValue(0);

						if (ac_chargingInfo[0]->PresentChargedEnergy >= 0.1 &&
								ac_chargingInfo[0]->PresentChargedEnergy <= ENERGY_MAX_KWH)
						{
							ChangeChargingEnergyValue(ac_chargingInfo[0]->PresentChargedEnergy);

							if (ShmSysConfigAndInfo->SysConfig.BillingData.isBilling &&
									ac_chargingInfo[0]->ChargingFee >= 0)
							{
								ChangeChargingFeeValue(ac_chargingInfo[0]->ChargingFee);
							}
						}
						else
						{
							ChangeChargingEnergyValue(0);
							if (ShmSysConfigAndInfo->SysConfig.BillingData.isBilling)
								ChangeChargingFeeValue(0);
						}

						if(!ShmSysConfigAndInfo->SysConfig.BillingData.isBilling)
						{
							ChangeDisplay2Value(__charging_fee_map, _disappear);
							ChangeDisplay2Value(__charging_fee_tx, _disappear);
						}
						else
						{
							ChangeDisplay2Value(__charging_fee_map, _money_map);
						}
					}
				}
				else
				{
					if (_currentPage == _LCM_COMPLETE)
						ChangeDisplay2Value(__cmp_gun_type_index + (gunTargetIndex * 2), _actype_dark_cmp);
					else
						ChangeDisplay2Value(__gun_type_index + (gunTargetIndex * 2), _actype_dark);
				}
			}

			gunTargetIndex = 0;
			for(byte i = 0; i < _totalCount; i++)
			{
				if (_totalCount == 1 && acgunCount <= 0)
					gunTargetIndex = 2;
				else
					gunTargetIndex = i;

				switch(_chargingInfoData[i]->Type)
				{
					case _Type_Chademo:
					{
						if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == i && !isShowAc)
						{
							if (_currentPage == _LCM_COMPLETE)
								ChangeDisplay2Value(__cmp_gun_type_index + (gunTargetIndex * 2), _chademo_light_cmp);
							else
								ChangeDisplay2Value(__gun_type_index + (gunTargetIndex * 2), _chademo_light);
						}
						else
						{
							if (_currentPage == _LCM_COMPLETE)
								ChangeDisplay2Value(__cmp_gun_type_index + (gunTargetIndex * 2), _chademo_dark_cmp);
							else
								ChangeDisplay2Value(__gun_type_index + (gunTargetIndex * 2), _chademo_dark);
						}
					}
						break;
					case _Type_GB:
					{
						if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == i && !isShowAc)
						{
							if (_currentPage == _LCM_COMPLETE)
								ChangeDisplay2Value(__cmp_gun_type_index + (gunTargetIndex * 2), _gbt_light_cmp);
							else
								ChangeDisplay2Value(__gun_type_index + (gunTargetIndex * 2), _gbt_light);
						}
						else
						{
							if (_currentPage == _LCM_COMPLETE)
								ChangeDisplay2Value(__cmp_gun_type_index + (gunTargetIndex * 2), _gbt_dark_cmp);
							else
								ChangeDisplay2Value(__gun_type_index + (gunTargetIndex * 2), _gbt_dark);
						}
					}
						break;
					case _Type_CCS_2:
					{
						if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == i && !isShowAc)
						{
							if (_currentPage == _LCM_COMPLETE)
								ChangeDisplay2Value(__cmp_gun_type_index + (gunTargetIndex * 2), _ccs_light_cmp);
							else
								ChangeDisplay2Value(__gun_type_index + (gunTargetIndex * 2), _ccs_light);
						}
						else
						{
							if (_currentPage == _LCM_COMPLETE)
								ChangeDisplay2Value(__cmp_gun_type_index + (gunTargetIndex * 2), _ccs_dark_cmp);
							else
								ChangeDisplay2Value(__gun_type_index + (gunTargetIndex * 2), _ccs_dark);
						}
					}
						break;
				}

				if (_currentPage == _LCM_PRE_CHARGE && !isShowAc)
				{
					if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == i)
					{
						ChangeBattMapAndValue(_currentPage, _chargingInfoData[i]->EvBatterySoc);
					}
				}
				else if (_currentPage == _LCM_CHARGING && !isShowAc)
				{
					if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == i)
					{
						ChangeBattMapAndValue(_currentPage, _chargingInfoData[i]->EvBatterySoc);
						if (_chargingInfoData[i]->PresentChargedDuration >= 0 &&
								_chargingInfoData[i]->PresentChargedDuration <= TIME_MAX_SEC)
							ChangeRemainTime(_chargingInfoData[i]->PresentChargedDuration);
						else
							ChangeRemainTime(0);

						if (_chargingInfoData[i]->PresentChargingPower >= 0 &&
								_chargingInfoData[i]->PresentChargingPower <= POWER_MAX_KW)
							ChangeChargingPowerValue(_chargingInfoData[i]->PresentChargingPower);
						else
							ChangeChargingPowerValue(0);

						if (_chargingInfoData[i]->PresentChargedEnergy >= 0.1 &&
								_chargingInfoData[i]->PresentChargedEnergy <= ENERGY_MAX_KWH)
							ChangeChargingEnergyValue(_chargingInfoData[i]->PresentChargedEnergy);
						else
							ChangeChargingEnergyValue(0);

						if (strcmp((char *)_chargingInfoData[i]->StartUserId, "") == 0)
							ChangeDisplay2Value(__stop_method_btn, _stop_charging_btn);
						else
							ChangeDisplay2Value(__stop_method_btn, _stop_charging_btn_scan);
					}
				}
				else if (_currentPage == _LCM_COMPLETE && !isShowAc)
				{
					if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == i)
					{
						ChangeBattMapAndValue(_currentPage, _chargingInfoData[i]->EvBatterySoc);
						if (_chargingInfoData[i]->PresentChargedDuration >= 0 &&
								_chargingInfoData[i]->PresentChargedDuration <= TIME_MAX_SEC)
							ChangeRemainTime(_chargingInfoData[i]->PresentChargedDuration);
						else
							ChangeRemainTime(0);

						if (_chargingInfoData[i]->PresentChargingPower >= 0 &&
								_chargingInfoData[i]->PresentChargingPower <= POWER_MAX_KW)
							ChangeChargingPowerValue(_chargingInfoData[i]->PresentChargingPower);
						else
							ChangeChargingPowerValue(0);

						if (_chargingInfoData[i]->PresentChargedEnergy >= 0.1 &&
								_chargingInfoData[i]->PresentChargedEnergy <= ENERGY_MAX_KWH)
						{
							ChangeChargingEnergyValue(_chargingInfoData[i]->PresentChargedEnergy);

							if (ShmSysConfigAndInfo->SysConfig.BillingData.isBilling &&
								_chargingInfoData[i]->ChargingFee >= 0)
							{
								ChangeChargingFeeValue(_chargingInfoData[i]->ChargingFee);
							}
						}
						else
						{
							ChangeChargingEnergyValue(0);
							if (ShmSysConfigAndInfo->SysConfig.BillingData.isBilling)
								ChangeChargingFeeValue(0);
						}

						if(!ShmSysConfigAndInfo->SysConfig.BillingData.isBilling)
						{
							ChangeDisplay2Value(__charging_fee_map, _disappear);
							ChangeDisplay2Value(__charging_fee_tx, _disappear);
						}
						else
						{
							ChangeDisplay2Value(__charging_fee_map, _money_map);
						}
					}
				}
			}

			// gun btn and QR code
			if (_totalCount + acgunCount >= 2 && _currentPage)
			{
				byte index = 0;
				for(index = 0; index < _totalCount; index++)
				{
					if(ShmSysConfigAndInfo->SysInfo.CurGunSelected != index)
					{
						break;
					}
				}

				if (_chargingInfoData[index]->SystemStatus == S_IDLE ||
						_chargingInfoData[index]->SystemStatus == S_RESERVATION ||
						_chargingInfoData[index]->SystemStatus == S_BOOTING)
				{
					if (FirstPageChanged() == YES || needReloadQr || _page_reload)
					{
						if (ShmSysConfigAndInfo->SysConfig.isQRCode)
						{
							needReloadQr = false;
							ChangeQrCode_Charge((char *)ShmSysConfigAndInfo->SysConfig.SystemId);
						}
					}
				}
			}
		}
			break;
	}
}

void ChangeDisplayMoneyInfo()
{
	if (ShmSysConfigAndInfo->SysConfig.BillingData.isBilling)
	{
		struct timeb csuTime;
		struct tm *tmCSU;

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

		ChangeDisplay2Value(__money_rate_map, _charging_money);

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

		if (ShmSysConfigAndInfo->SysConfig.BillingData.Currency <= 53)
			DisplayMoneyCur((byte *)Currency[ShmSysConfigAndInfo->SysConfig.BillingData.Currency]);
	}
	else
	{
		ChangeDisplay2Value(__money_rate_map, _disappear);
		ChangeDisplay2Value(__money_by_rate, _disappear);
		ChangeDisplay2Value(__money_rate, _disappear);
	}
}

void Initialization()
{
	bool isPass = false;
	byte count = 5;
	while(!isPass && count > 0)
	{
		isPass = true;
		for (byte _index = 0; _index < _totalCount; _index++)
		{
			if (!FindChargingInfoData(_index, &_chargingInfoData[0]))
			{
				DEBUG_ERROR("LcmComm (main) : FindChargingInfoData false \n");
				isPass = false;
				count--;
				break;
			}
		}

		sleep(1);
	}

	isPass = false;

	if (acgunCount > 0)
	{
		while(!isPass)
		{
			isPass = true;
			for (byte _index = 0; _index < acgunCount; _index++)
			{
				if (!FindAcChargingInfoData(_index, &ac_chargingInfo[0]))
				{
					DEBUG_ERROR("LcmComm : FindAcChargingInfoData false \n");
					isPass = false;
					break;
				}
			}

			sleep(1);
		}
	}

	if (count == 0)
		PRINTF_FUNC("LCM Initialization Gun Fail.............\n");
}

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

	_port = CreateCommunicationLcmPort();
	byte changeWarningPriority = 0;
	byte curWarningCount = 255;
	ChangeBackLight(true);
	_totalCount = ShmSysConfigAndInfo->SysConfig.TotalConnectorCount;
	acgunCount = ShmSysConfigAndInfo->SysConfig.AcConnectorCount;
	Initialization();

	//ChangeToOtherPage(_LCM_COMPLETE);
	//return 0;
	for(byte i = 0; i < 3; i++)
		ChangeDisplay2Value(__gun_type_index + (i * 2), _disappear);

	while(_port != -1)
	{
		if (strcmp((char *)ShmSysConfigAndInfo->SysInfo.LcmHwRev, moduleName) != 0x00)
		{
			GetCurrentPage();
			sleep(1);
		}
		else
		{
			//DemoFunction();

			// Warning 處理
			if(curWarningCount != ShmSysConfigAndInfo->SysWarningInfo.WarningCount)
			{
				changeWarningPriority = 0;
				ShmSysConfigAndInfo->SysWarningInfo.PageIndex = 0;
				curWarningCount = ShmSysConfigAndInfo->SysWarningInfo.WarningCount;
				ChangeWarningFunc();
			}
			else if (ShmSysConfigAndInfo->SysWarningInfo.WarningCount > 5 && changeWarningPriority == 0)
			{
				// 當有兩頁 Warning 則每隔三秒改變一次
				if(ShmSysConfigAndInfo->SysWarningInfo.PageIndex == 0)
					ShmSysConfigAndInfo->SysWarningInfo.PageIndex = 1;
				else
					ShmSysConfigAndInfo->SysWarningInfo.PageIndex = 0;

				ChangeWarningFunc();
			}

			// 頁面資訊處理
			ProcessPageInfo();

			// 網路 - wifi - 連線訊號處理
			RefreshConnStatus();

			// 換頁處理
			ChangeCurPage();

			RefreshPageAnimation(_everyPageRollChange);

			if (changeWarningPriority == 0)
			{
				ChangeDisplayMoneyInfo();
				InformationShow();
			}

			changeWarningPriority >= 15 ? (_battery_display_ani = true) : (_battery_display_ani = false);
			changeWarningPriority >= 30 ? changeWarningPriority = 0 : changeWarningPriority++;
			usleep(100000);
		}
	}

	CloseCommunicationLcmPort();
	return FAIL;
}