#include "Module_LcmContro.h"

bool needReloadQr = true;

bool needReloadQrCtep = true;

bool _isInforShow = false;
bool _isCtepInforShow = false;
byte _showInformIndex = 0;

byte _btn_pressed = 0xF0;

byte _defaultPriceBuf[501];

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_%s_Log",
			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,
			ShmSysConfigAndInfo->SysConfig.SerialNumber);
		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 ", 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;
   	}

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

 	if ((MeterSMId = shmget(ShmCommonKey, sizeof(struct DcCommonInformation), IPC_CREAT | 0777)) < 0)
    {
    	#ifdef SystemLogMessage
    	DEBUG_ERROR("shmget ShmCommonKey NG \n");
    	#endif
    	return 0;
    }
    else if ((ShmDcCommonData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
    	#ifdef SystemLogMessage
    	DEBUG_ERROR("shmat ShmCommonKey NG \n");
    	#endif
    	return 0;
    }

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

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

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

//	5a : CMD_TITLE_1
//	a5 : CMD_TITLE_2
//	5
//	81 : CMD_WRITE
//	3  : CMD_REGISTER
//	2  : Data length
//	0  : High byte
//	1  : Low byte

//	printf("-------------------------------------------- \n");
//	printf("msg = %x \n", *msg);			// A5
//	printf("msg = %x \n", *(msg + 1));		// 5A
//	printf("msg = %x \n", *(msg + 2));		// Len : [3] ~ [6] + Data Len
//	printf("msg = %x \n", *(msg + 3));		// cmd : 0x83
//	printf("msg = %x \n", *(msg + 4));		// addr : H
//	printf("msg = %x \n", *(msg + 5));		// addr : L
//	printf("msg = %x \n", *(msg + 6));		// Data Len
//
//	printf("msg = %x \n", *(msg + 7));
//	printf("msg = %x \n", *(msg + 8));
//	printf("msg = %x \n", *(msg + 9));
//	printf("msg = %x \n", *(msg + 10));
//	printf("msg = %x \n", *(msg + 11));
//	printf("msg = %x \n", *(msg + 12));
//	printf("msg = %x \n", *(msg + 13));
//	printf("msg = %x \n", *(msg + 14));

	if(*msg == CMD_HEADER_1 && *(msg + 1) == CMD_HEADER_2)
	{
		if(*(msg + 3) == CMD_REG_READ)
		{
			switch (*(msg + 4))
			{
				case CMD_REGISTER:
				{
					// 頁面
					if(strcmp((char *)ShmSysConfigAndInfo->SysInfo.LcmHwRev, "") != EQUAL)
						strcpy((char *)ShmSysConfigAndInfo->SysInfo.LcmHwRev, moduleName);

					_currentPage = *(msg + 7);
//					if (_currentPage != 1 && _currentPage != 5 && _currentPage != 6 && _currentPage != 7 && _currentPage != 8)
//						printf("_currentPage = %d \n", _currentPage);
				}
				break;
			}
		}
		else if (*(msg + 3) == CMD_REG_READ_DATA)
		{
			short key = ((short)(*(msg + 4) << 8) + *(msg + 5));
			if (key == __lcm_version)
			{
				ShmDcCommonData->LcmFwVersion = atoi((char *)(msg + 7));
				//printf("msg = %d \n", atoi((char *)(msg + 7)));
//				printf("msg = %x \n", *(msg + 7));
//				printf("msg = %x \n", *(msg + 8));
//				printf("msg = %x \n", *(msg + 9));
			}
		}
	}
}

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

	cmd[0] = CMD_HEADER_1;
	cmd[1] = CMD_HEADER_2;
	cmd[2] = 0x02 + sizeof(newPage);
	cmd[3] = CMD_REG_WRITE;
	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;

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

	cmd[0] = CMD_HEADER_1;
	cmd[1] = CMD_HEADER_2;
	cmd[2] = 0x03;
	cmd[3] = CMD_REG_WRITE;
	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_HEADER_1;
	cmd[1] = CMD_HEADER_2;
	cmd[2] = 0x03;				// 底下總長度
	cmd[3] = CMD_REG_READ;
	cmd[4] = CMD_REGISTER;
	cmd[5] = 0x02;

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

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

	cmd[0] = CMD_HEADER_1;
	cmd[1] = CMD_HEADER_2;
	cmd[2] = 0x03 + len;
	cmd[3] = CMD_REG_WRITE_DATA;
	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 DisplayFeeValueToLcm(short address, byte *data, byte len)
{
	byte cmd[256];
	memset(cmd, 0x00, sizeof(cmd));

	cmd[0] = CMD_HEADER_1;
	cmd[1] = CMD_HEADER_2;
	cmd[2] = 0x03 + len;
	cmd[3] = CMD_REG_WRITE_DATA;
	cmd[4] = address >> 8;
	cmd[5] = address & 0x00FF;

	for(byte count = 0; count < len; count++)
	{
		cmd[12 + 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 GetDeviceInfoStatus(short address, byte len)
{
	byte cmd[8];
	memset(cmd, 0x00, sizeof(cmd));
	byte msg[40];
	memset(msg, 0x00, sizeof(msg));

	cmd[0] = CMD_HEADER_1;
	cmd[1] = CMD_HEADER_2;
	cmd[2] = 0x04;
	cmd[3] = CMD_REG_READ_DATA;
	cmd[4] = (address >> 8) & 0xff;
	cmd[5] = (address >> 0) & 0xff;
	cmd[6] = len;

	WriteCmdToLcm(cmd, ARRAY_SIZE(cmd));
	usleep(10000);
	ReadMsgFromLcm(msg, ARRAY_SIZE(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, byte len)
{
	byte cmd[len];
	int loop = 0;

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

	//printf("cmd = %s, len = %d \n", cmd, len + 1);
	DisplayValueToLcm(__qr_code, cmd, len + 1);
}

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

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

	//printf("2 - cmd = %s, len = %d \n", cmd, len + 1);
	DisplayValueToLcm(__qr_code_pre, cmd, len + 1);
}

void ChangeQrCode_Comp(char *input, byte len)
{
	byte cmd [len];
	int loop = 0;

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

	DisplayValueToLcm ( __receipt_qrcode, cmd, len + 1 );
}

//================================================
// 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(ShmSysConfigAndInfo->SysInfo.PageIndex);
		_everyPageRollChange = 0;
	}
}

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

//=======================================
// Download File
//=======================================
void ResetLCM()
{
	uint8_t cmd_reset[] = {0x5a, 0xa5};
	lcdRegisterWrite(Uart1Fd,  0xee, cmd_reset, ARRAY_SIZE(cmd_reset));
	sleep(1);
	ChangeToOtherPage(_LCM_FIX);
}

int downloadBIN(uint8_t targetAddr, char *filename)
{
	int result = PASS;
	int fd;
	struct stat fileSt;
	uint32_t blocklSize = 1024 * 256;
	uint32_t pageSize = 128;

	// Get image file size
	stat(filename, &fileSt);
	uint8_t buf[fileSt.st_size];

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

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

		for(uint16_t idxBlock = 0;
				idxBlock < (fileSt.st_size % blocklSize == 0?fileSt.st_size / blocklSize : (fileSt.st_size / blocklSize) +1);
				idxBlock++)
		{
			// Download bin file command
			uint8_t cmd_download[] = {0x5a, targetAddr + idxBlock};
			while(lcdRegisterWrite(Uart1Fd, 0xf3, cmd_download, ARRAY_SIZE(cmd_download)) != PASS)
			{
				PRINTF_FUNC("Download start fail.\n");
			}

			// Transfer bin file data content
			for(uint16_t idxPage=0; idxPage < (((blocklSize % pageSize) == 0)?(blocklSize / pageSize) : (blocklSize / pageSize) + 1); idxPage++)
			{
				if((idxBlock * blocklSize) + (idxPage * pageSize) <= ARRAY_SIZE(buf))
				{
					if(write(Uart1Fd, &buf[(idxBlock * blocklSize)+(idxPage*pageSize)], pageSize) >= pageSize)
					{
						if (idxPage % 1000 == 0 || pageSize < 128)
							PRINTF_FUNC("idxBlock: %d, idxPage: %d, dataLength: %d\n", idxBlock, idxPage, pageSize);
					}
				}
				else
				{
					if(write(Uart1Fd, &buf[(idxBlock * blocklSize) + (idxPage * pageSize)], (ARRAY_SIZE(buf)-((idxBlock * blocklSize) + ((idxPage -1) * pageSize)))) >= (ARRAY_SIZE(buf)-((idxBlock * blocklSize) + ((idxPage -1) * pageSize))))
					{
						PRINTF_FUNC("idxBlock: %d, idxPage: %d, dataLength: %d\n", idxBlock, idxPage, (ARRAY_SIZE(buf) - ((idxBlock * blocklSize) + ((idxPage -1) * pageSize))));
					}
					break;
				}
			}
			sleep(1);

			PRINTF_FUNC("Save bin file on 0x%04X success.\n", (targetAddr + idxBlock));
		}
	}

	return result;
}

//=======================================
// Download image
//=======================================
int downloadBMP(uint8_t picIdx, char *filename)
{
	int result = PASS;
	BMP *bmp;
	struct stat fileSt;
	uint32_t blocklSize = 1024 * 256;
	uint32_t pageSize = 128;

	// Get image file size
	stat(filename, &fileSt);
	bmp = bopen(filename);
	uint8_t buf[fileSt.st_size];

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

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

	uint8_t cmd_download[] = {0x5a, 0x00, (picIdx>>8)&0xff, picIdx&0xff};
	while (lcdRegisterWrite ( Uart1Fd, 0xf5, cmd_download, ARRAY_SIZE( cmd_download ) ) != PASS)
	{
		PRINTF_FUNC ( "Download start fail.\n" );
	}

	for(uint16_t idxBlock = 0;
					idxBlock < (fileSt.st_size % blocklSize == 0?fileSt.st_size / blocklSize : (fileSt.st_size / blocklSize) +1);
					idxBlock++)
	{
		// Transfer bin file data content
		for(uint16_t idxPage=0; idxPage < (((blocklSize % pageSize) == 0)?(blocklSize / pageSize) : (blocklSize / pageSize) + 1); idxPage++)
		{
			if((idxBlock * blocklSize) + (idxPage * pageSize) <= ARRAY_SIZE(buf))
			{
				if(write(Uart1Fd, &buf[(idxBlock * blocklSize)+(idxPage*pageSize)], pageSize) >= pageSize)
				{
					if (idxPage % 1000 == 0 || pageSize < 128)
						PRINTF_FUNC("idxBlock: %d, idxPage: %d, dataLength: %d\n", idxBlock, idxPage, pageSize);
				}
			}
			else
			{
				if(write(Uart1Fd, &buf[(idxBlock * blocklSize) + (idxPage * pageSize)], (ARRAY_SIZE(buf)-((idxBlock * blocklSize) + ((idxPage -1) * pageSize)))) >= (ARRAY_SIZE(buf)-((idxBlock * blocklSize) + ((idxPage -1) * pageSize))))
				{
					PRINTF_FUNC("idxBlock: %d, idxPage: %d, dataLength: %d\n", idxBlock, idxPage, (ARRAY_SIZE(buf) - ((idxBlock * blocklSize) + ((idxPage -1) * pageSize))));
				}
				break;
			}
		}
	}
	PRINTF_FUNC("Save bmp file on 0x%04X success.\n", picIdx);

	return result;
}

//================================================
// Update Lcm process
//================================================
int UpdateBMP(char *forlder)
{
	int result = PASS;
	DIR *dir;
	struct dirent *file;
	struct stat fileSt;

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

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

					sprintf(targetFile, "/mnt/lcd/DWIN_SET/%s", file->d_name);
					PRINTF_FUNC("file->d_name = %s \n", file->d_name);
					if(strstr(file->d_name, ".bmp") != NULL)
					{
						PRINTF_FUNC("downloadBMP : targetAddr = %d,targetFile = %s \n", targetAddr, targetFile);
						downloadBMP(targetAddr, targetFile);
					}
				}
				else
				{
					PRINTF_FUNC("%s can not parse target address.\n", file->d_name);
				}
			}
			else
			{
				if(strlen(file->d_name) >= 3)
				{
					PRINTF_FUNC("File name error.\n");
					result = FAIL;
				}
				else
				{
					PRINTF_FUNC("Searching file.\n");
				}
			}

			sleep(1);
		}
		closedir (dir);
	}
	else
	{
		PRINTF_FUNC("%s does not valid (UpdateBMP).\n", forlder);
		result = FAIL;
	}

	return result;
}

int UpdateBin(char *forlder)
{
	int result = PASS;
	DIR *dir;
	struct dirent *file;
	struct stat fileSt;

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

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

					sprintf(targetFile, "/mnt/lcd/DWIN_SET/%s", file->d_name);
					PRINTF_FUNC("file->d_name = %s \n", file->d_name);
					if(strstr(file->d_name, ".bmp") == NULL)
					{
						PRINTF_FUNC("downloadBIN : targetAddr = %d,targetFile = %s \n", targetAddr, targetFile);
						downloadBIN(targetAddr, targetFile);
					}
				}
				else
				{
					PRINTF_FUNC("%s can not parse target address.\n", file->d_name);
				}
			}
			else
			{
				if(strlen(file->d_name) >= 3)
				{
					PRINTF_FUNC("File name error.\n");
					result = FAIL;
				}
				else
				{
					PRINTF_FUNC("Searching file.\n");
				}
			}

			sleep(1);
		}
		closedir (dir);
	}
	else
	{
		PRINTF_FUNC("%s does not valid (UpdateBin).\n", forlder);
		result = FAIL;
	}

	return result;
}

int lcdUpgrade(char *forlder)
{
	int result = PASS;

	result = UpdateBMP(forlder);

	if (result)
		result = UpdateBin(forlder);

	return result;
}

void UpdateLcmFunction()
{
	if(ShmDcCommonData->_upgrade_lcm_flag)
	{
		// 固定路徑 /mnt/lcd/DWIN_SET
		ChangeDisplay2Value(__qr_code, _disappear);
		ChangeDisplay2Value(__receipt_qrcode, _disappear);

		ShmDcCommonData->_upgrade_lcm_result = lcdUpgrade("/mnt/lcd/DWIN_SET");
		ResetLCM();
		ShmDcCommonData->_upgrade_lcm_flag = NO;
	}
}

//================================================
// 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 < 80)
		{
			if (_battery_display_ani)
				ChangeDisplay2Value(__batt_map, _battery_cap_60);
			else
				ChangeDisplay2Value(__batt_map, _battery_cap_80);
		}
		else if (soc >= 80 && soc < 100)
		{
			if (_battery_display_ani)
				ChangeDisplay2Value(__batt_map, _battery_cap_80);
			else
				ChangeDisplay2Value(__batt_map, _battery_cap_100);
		}
		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[16];
	byte value[16];

	memset(cmd, 0x00, sizeof(cmd));
	if (energy >= 0.00005)
		energy -= 0.00005;
	sprintf((char *) value, "%.4f 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 ChangeChargingInforForCTEP(short target, double cost)
{
	byte cmd[10];
	byte value[10];

	memset(cmd, 0x00, sizeof(cmd));
	sprintf((char *) value, "$%.2f", cost);
	string2ByteArray(value, cmd);
	DisplayValueToLcm(target, 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[8];
	byte buf[8];

	memset(cmd, 0x00, sizeof(cmd));
	memcpy((char *) buf, cur, 3);
	memcpy((char *) buf + 3, "/kWh", 4);
	buf[7] = '\0';
	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
	{
		ShmSysConfigAndInfo->SysConfig.AthInterface.WifiRssi = 0;
		ChangeDisplay2Value(__wifi_status, _disappear);
	}

	if((ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'T' || ShmSysConfigAndInfo->SysConfig.ModelName[10] == 'D') &&
			ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled != _SYS_4G_MODE_DISABLE)
	{
		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_connect); }
			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_connect); }
			else
			{ ChangeDisplay2Value(__3G4G_status, _3G4G_disconnect); }
		}
	}
	else
	{
		ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomRssi = 0;
		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;
}

bool IsConfigReloadChk()
{
	bool result = false;

	if (ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode == NO)
	{
		if (strcmp((char *)QRCodeBuf, (char *)ShmSysConfigAndInfo->SysConfig.SystemId) != EQUAL)
			result = true;
	}
	else
	{
		if (strcmp((char *)QRCodeBuf, (char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent) != EQUAL)
			result = true;
	}

	return result;
}

void SaveQrcodeToBuf(byte *qrcode)
{
	strncpy((char *)QRCodeBuf, (char *)qrcode, sizeof(QRCodeBuf));
}

void ClearDisplayInfo()
{
	ChangeDisplay2Value(__csu_ver_string, _disappear);
	ChangeDisplay2Value(__csu_ver_value, _disappear);

	ChangeDisplay2Value(__eth0_ip_string, _disappear);
	ChangeDisplay2Value(__eth0_ip_value, _disappear);

	ChangeDisplay2Value(__sn_string, _disappear);
	ChangeDisplay2Value(__sn_value, _disappear);

	ChangeDisplay2Value(__dc1_ver_string, _disappear);
	ChangeDisplay2Value(__dc1_ver_value, _disappear);

	ChangeDisplay2Value(__dc2_ver_string, _disappear);
	ChangeDisplay2Value(__dc2_ver_value, _disappear);

	ChangeDisplay2Value(__fan_speed_string, _disappear);
	ChangeDisplay2Value(__fan_speed_value, _disappear);
}

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 ShowWifiMode(bool isShow, unsigned char mode)
{
	if (isShow)
	{
		byte value[20];

		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, "Wifi Mo. >");
		DisplayValueToLcm(__csu_ver_string, value, sizeof(value));
		memset(value, 0x00, sizeof(value));
		if (mode == 0)
			sprintf((char *)value, "disable");
		else if (mode == 1)
			sprintf((char *)value, "station");
		else if (mode == 2)
			sprintf((char *)value, "AP");

		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 Show4GRssi(bool isShow, int dbValue)
{
	if (isShow)
	{
		byte value[20];

		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, "RSSI >");
		DisplayValueToLcm(__dc2_ver_string, value, sizeof(value));
		memset(value, 0x00, sizeof(value));
		sprintf((char *)value, "%d dBm", dbValue);
		DisplayValueToLcm(__dc2_ver_value, value, sizeof(value));
	}
	else
	{
		ChangeDisplay2Value(__dc2_ver_string, _disappear);
		ChangeDisplay2Value(__dc2_ver_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 ShowWifiRssi(bool isShow, int dbValue)
{
	if (isShow)
	{
		byte value[20];

		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, "RSSI >");
		DisplayValueToLcm(__fan_speed_string, value, sizeof(value));
		memset(value, 0x00, sizeof(value));
		sprintf((char *)value, "%d dBm", dbValue);
		DisplayValueToLcm(__fan_speed_value, value, sizeof(value));
	}
	else
	{
		ChangeDisplay2Value(__fan_speed_string, _disappear);
		ChangeDisplay2Value(__fan_speed_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 Show4GMode(bool isShow, unsigned char mode)
{
	if (isShow)
	{
		byte value[20];

		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, "3/4G Mo. >");
		DisplayValueToLcm(__dc1_ver_string, value, sizeof(value));
		memset(value, 0x00, sizeof(value));
		if (mode == 0)
			sprintf((char *)value, "disable");
		else if (mode == 1)
			sprintf((char *)value, "enable");

		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 Show4GIP(bool isShow, unsigned char *ip)
{
	if (isShow)
	{
		byte value[20];

		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, "3/4G 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 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 ShowWifiIP(bool isShow, unsigned char *ip)
{
	if (isShow)
	{
		byte value[20];

		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, "Wifi IP ");
		DisplayValueToLcm(__sn_string, value, sizeof(value));
		memset(value, 0x00, sizeof(value));
		strcpy((char *) value, (char *) ip);
		DisplayValueToLcm(__sn_value, value, sizeof(value));
	}
	else
	{
		ChangeDisplay2Value(__sn_string, _disappear);
		ChangeDisplay2Value(__sn_value, _disappear);
	}
}

void InformationShow()
{
	if(ShmSysConfigAndInfo->SysConfig.ShowInformation == YES)
	{
		bool show = _isInforShow = true;
		if (_showInformIndex == 0)
		{
			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 if (_showInformIndex == 1)
		{
			ShowWifiMode(show, ShmSysConfigAndInfo->SysConfig.AthInterface.WifiMode);
			ShowWifiRssi(show, ShmSysConfigAndInfo->SysConfig.AthInterface.WifiRssi);
			ShowWifiIP(show, ShmSysConfigAndInfo->SysConfig.AthInterface.WifiIpAddress);

			Show4GMode(show, ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomEnabled);
			Show4GRssi(show, ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomRssi);
			Show4GIP(show, ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomIpAddress);
		}
	}
	else
	{
		ClearDisplayInfo();

		if (_isInforShow)
		{
			_isInforShow = false;
			_showInformIndex++;
			if (_showInformIndex >= 2)
				_showInformIndex = 0;
		}
	}
}

void ProcessPageInfo()
{
	_page_reload = IsPageReloadChk();

	if (!_page_reload)
		_page_reload = IsConfigReloadChk();

	bool isStatusChanged = (_lcmGunSelect != ShmSysConfigAndInfo->SysInfo.CurGunSelected) ? true : false;

	if (isStatusChanged)
		_lcmGunSelect = ShmSysConfigAndInfo->SysInfo.CurGunSelected;
	else
		isStatusChanged = (_lcmGunStatus != _chargingInfoData [ShmSysConfigAndInfo->SysInfo.CurGunSelected]->SystemStatus) ? true : false;

	if (isStatusChanged)
		_lcmGunStatus = _chargingInfoData [ShmSysConfigAndInfo->SysInfo.CurGunSelected]->SystemStatus;

	// 隨插即充 - 可省略該按鈕
//	if (ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_ENABLE)
//	{
//		ChangeDisplay2Value(__ret_home_btn, _back_home_btn);
//		if (_totalCount >= 2 && ShmSysConfigAndInfo->SysInfo.IsAlternatvieConf == NO)
//			ChangeDisplay2Value(__sel_gun_btn, _sel_gun_btn);
//		else
//			ChangeDisplay2Value(__sel_gun_btn, _disappear);
//	}
	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;
					if (ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode == NO)
					{
						byte len = strlen((char *)ShmSysConfigAndInfo->SysConfig.SystemId);
						SaveQrcodeToBuf(ShmSysConfigAndInfo->SysConfig.SystemId);
						ChangeQrCode_Idle((char *)ShmSysConfigAndInfo->SysConfig.SystemId, len);
					}
					else
					{
						byte len = strlen((char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent);
						SaveQrcodeToBuf(ShmSysConfigAndInfo->SysConfig.QRCodeContent);
						ChangeQrCode_Idle((char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent, len);
					}
				}
			}

			bool isCharging = false;
			for(byte i = 0; i < _totalCount; i++)
			{
				if (_chargingInfoData[i]->SystemStatus == SYS_MODE_IDLE ||
						_chargingInfoData[i]->SystemStatus == SYS_MODE_RESERVATION)
					continue;

				isCharging = true;
				break;
			}

			if (isCharging && ShmSysConfigAndInfo->SysInfo.IsAlternatvieConf == NO)
			{
				ChangeDisplay2Value(__sel_gun_btn, _sel_gun_btn);
			}
			else
			{
				ChangeDisplay2Value(__sel_gun_btn, _disappear);
			}

			//LW_tpc plug detect
			if (ShmDcCommonData->TpcDetectFunction == YES)
			{
				if (ShmDcCommonData->_tpcPlugDetectState == _TPC_PLUG_DETECT_STATUS_NONE)
					ChangeDisplay2Value ( __tpc_detect_map, _tpc_start_detect_btn );
				else if (ShmDcCommonData->_tpcPlugDetectState == _TPC_PLUG_DETECT_STATUS_WAIT)
					ChangeDisplay2Value ( __tpc_detect_map, _tpc_wait_plugin_btn );
			}
			else
				ChangeDisplay2Value ( __tpc_detect_map, _disappear );
		}
			break;
		case _LCM_AUTHORIZING:
		case _LCM_AUTHORIZ_COMP:
		case _LCM_AUTHORIZ_FAIL:
		{
		}
			break;
		case _LCM_WAIT_FOR_PLUG:
		{
			bool isCharging = false;
			for (byte i = 0; i < _totalCount; i ++)
			{
				if (_chargingInfoData [i]->SystemStatus == SYS_MODE_IDLE ||
						_chargingInfoData [i]->SystemStatus == SYS_MODE_RESERVATION)
					continue;

				isCharging = true;
				break;
			}

			if (ShmSysConfigAndInfo->SysInfo.IsAlternatvieConf == YES)
			{
				ChangeDisplay2Value ( __sel_gun_btn, _disappear );
			}
			else
			{
				if (ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_DISABLE ||
						isCharging)
				{
					if (isCharging)
						ChangeDisplay2Value ( __sel_gun_btn, _sel_gun_btn );
					else
						ChangeDisplay2Value ( __sel_gun_btn, _disappear );
				}
			}

			if (ShmSysConfigAndInfo->SysConfig.AuthorisationMode == AUTH_MODE_DISABLE)
			{
				// 新增隨插即充功能預設在等待插槍頁面在開啟
				ChangeDisplay2Value(__ret_home_btn, _disappear);
			}
			else
				ChangeDisplay2Value(__ret_home_btn, _back_home_btn);
		}
			break;
		case _LCM_PRE_CHARGE:
		case _LCM_CHARGING:
		case _LCM_COMPLETE:
		{
			bool isShowAc = false;
			byte gunTargetIndex = 0;

			ChangeDisplay2Value(__ret_home_btn, _back_home_btn);

			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 (ShmSysConfigAndInfo->SysConfig.StopChargingByButton == YES)
							ChangeDisplay2Value(__stop_method_btn, _stop_charging_btn);
						else if (strcmp((char *)ac_chargingInfo[0]->StartUserId, "") != EQUAL)
							ChangeDisplay2Value(__stop_method_btn, _stop_charging_btn_scan);
						else
							ChangeDisplay2Value(__stop_method_btn, _disappear);
					}
					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) ||
								(strcmp((char *)ShmSysConfigAndInfo->SysConfig.OcppServerURL, "") != EQUAL &&
										strcmp((char *)ShmSysConfigAndInfo->SysConfig.ChargeBoxId, "") != EQUAL))
						{
							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);
				}
			}
			else
			{
				// 超過一把槍, 把中間圖隱藏
				if (_totalCount > 1)
				{
					gunTargetIndex = 2;
					ChangeDisplay2Value(__cmp_gun_type_index + (gunTargetIndex * 2), _disappear);
					ChangeDisplay2Value(__gun_type_index + (gunTargetIndex * 2), _disappear);
				}
			}

			gunTargetIndex = 0;
			for(byte i = 0; i < _totalCount; i++)
			{
				if (_totalCount == 1 && acgunCount <= 0)
				{
					if (ShmSysConfigAndInfo->SysInfo.ChargerType != _CHARGER_TYPE_JARI)
					{
						gunTargetIndex = 2;
					}
//
//					if (ShmSysConfigAndInfo->SysInfo.ChargerType == _CHARGER_TYPE_JARI)
//						gunTargetIndex = 1;
//					else
//						gunTargetIndex = 2;
				}
				else
					gunTargetIndex = i;

				switch(_chargingInfoData[i]->Type)
				{
					case _Type_Chademo:
					{
						if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == i && !isShowAc)
						{
							if (_totalCount >= 2 && ShmSysConfigAndInfo->SysInfo.ChargerType == _CHARGER_TYPE_JARI)
							{
								if (_currentPage == _LCM_COMPLETE)
								{
									if (i == 0)
										ChangeDisplay2Value(__cmp_gun_type_index_jp + (gunTargetIndex * 2), _n1_jp_cha_light_cmp);
									else
										ChangeDisplay2Value(__cmp_gun_type_index_jp + (gunTargetIndex * 2), _n2_jp_cha_light_cmp);
								}
								else
								{
									if (i == 0)
										ChangeDisplay2Value(__gun_type_index_jp + (gunTargetIndex * 2), _n1_jp_cha_light);
									else
										ChangeDisplay2Value(__gun_type_index_jp + (gunTargetIndex * 2), _n2_jp_cha_light);
								}
							}
							else
							{
								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 (_totalCount >= 2 && ShmSysConfigAndInfo->SysInfo.ChargerType == _CHARGER_TYPE_JARI)
							{
								if (_currentPage == _LCM_COMPLETE)
								{
									if (i == 0)
										ChangeDisplay2Value(__cmp_gun_type_index_jp + (gunTargetIndex * 2), _n1_jp_cha_dark_cmp);
									else
										ChangeDisplay2Value(__cmp_gun_type_index_jp + (gunTargetIndex * 2), _n2_jp_cha_dark_cmp);
								}
								else
								{
									if (i == 0)
										ChangeDisplay2Value(__gun_type_index_jp + (gunTargetIndex * 2), _n1_jp_cha_dark);
									else
										ChangeDisplay2Value(__gun_type_index_jp + (gunTargetIndex * 2), _n2_jp_cha_dark);
								}
							}
							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:
					{
						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 <= ENERGY_MAX_KWH)
							ChangeChargingEnergyValue(_chargingInfoData[i]->PresentChargedEnergy);
						else
							ChangeChargingEnergyValue(0);

						if (ShmSysConfigAndInfo->SysConfig.StopChargingByButton == YES)
							ChangeDisplay2Value ( __stop_method_btn, _stop_charging_btn );
						else if (strcmp((char *)_chargingInfoData[i]->StartUserId, "") != EQUAL)
							ChangeDisplay2Value ( __stop_method_btn, _stop_charging_btn_scan );
						else
							ChangeDisplay2Value ( __stop_method_btn, _disappear );

						// CTEP
						if (ShmSysConfigAndInfo->SysInfo.OcppConnStatus == YES &&
								strlen ( (char *) ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL ) > 0 &&
								ShmSysConfigAndInfo->SysConfig.BillingData.isBilling)
						{
							if (ShmDcCommonData->cdfaInfor[i]._ctepEnergyCost > 0)
								ChangeChargingInforForCTEP (__Energy_Cost_charging, ShmDcCommonData->cdfaInfor[i]._ctepEnergyCost);
							else
								ChangeChargingInforForCTEP (__Energy_Cost_charging, 0 );

							if (ShmDcCommonData->cdfaInfor[i]._ctepParkingFee > 0)
								ChangeChargingInforForCTEP (__Parking_Fee_charging, ShmDcCommonData->cdfaInfor[i]._ctepParkingFee);
							else
								ChangeChargingInforForCTEP (__Parking_Fee_charging, 0 );

							if (ShmDcCommonData->cdfaInfor[i]._ctepTotalCost > 0)
								ChangeChargingInforForCTEP (__Total_Cost_charging, ShmDcCommonData->cdfaInfor[i]._ctepTotalCost);
							else
								ChangeChargingInforForCTEP (__Total_Cost_charging, 0 );
						}
					}
				}
				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 <= ENERGY_MAX_KWH) ||
								(strcmp((char *)ShmSysConfigAndInfo->SysConfig.OcppServerURL, "") != EQUAL &&
									strcmp((char *)ShmSysConfigAndInfo->SysConfig.ChargeBoxId, "") != EQUAL))
						{
							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);
						}

						// CTEP
						if (ShmSysConfigAndInfo->SysInfo.OcppConnStatus == YES &&
								strlen ( (char *) ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL ) > 0 &&
								ShmSysConfigAndInfo->SysConfig.BillingData.isBilling)
						{
							if (ShmDcCommonData->cdfaInfor[i]._ctepEnergyCost > 0)
								ChangeChargingInforForCTEP (__Energy_Cost_comp, ShmDcCommonData->cdfaInfor[i]._ctepEnergyCost);
							else
								ChangeChargingInforForCTEP (__Energy_Cost_comp, 0 );

							if (ShmDcCommonData->cdfaInfor[i]._ctepParkingFee > 0)
								ChangeChargingInforForCTEP (__Parking_Fee_comp, ShmDcCommonData->cdfaInfor[i]._ctepParkingFee);
							else
								ChangeChargingInforForCTEP (__Parking_Fee_comp, 0 );

							if (ShmDcCommonData->cdfaInfor[i]._ctepTotalCost > 0)
								ChangeChargingInforForCTEP (__Total_Cost_comp, ShmDcCommonData->cdfaInfor[i]._ctepTotalCost);
							else
								ChangeChargingInforForCTEP (__Total_Cost_comp, 0 );
						}
					}
				}
			}

			if (_totalCount > 1 &&
					ShmSysConfigAndInfo->SysInfo.IsAlternatvieConf == NO)
			{
				ChangeDisplay2Value(__sel_gun_btn, _sel_gun_btn);
			}
			else
			{
				ChangeDisplay2Value(__sel_gun_btn, _disappear);
			}

			// 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 == SYS_MODE_IDLE ||
						_chargingInfoData[index]->SystemStatus == SYS_MODE_RESERVATION ||
						_chargingInfoData[index]->SystemStatus == SYS_MODE_BOOTING)
				{
					if (FirstPageChanged() == YES || needReloadQr || _page_reload)
					{
						if (ShmSysConfigAndInfo->SysConfig.isQRCode)
						{
							needReloadQr = false;
							if (ShmSysConfigAndInfo->SysConfig.QRCodeMadeMode == NO)
							{
								byte len = strlen((char *)ShmSysConfigAndInfo->SysConfig.SystemId);
								ChangeQrCode_Charge((char *)ShmSysConfigAndInfo->SysConfig.SystemId, len);
							}
							else
							{
								byte len = strlen((char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent);
								ChangeQrCode_Charge((char *)ShmSysConfigAndInfo->SysConfig.QRCodeContent, len);
							}
						}
					}
				}
			}
		}
			break;
	}

	if (_page_reload || isStatusChanged)
	{
		if (_chargingInfoData [ShmSysConfigAndInfo->SysInfo.CurGunSelected]->SystemStatus == SYS_MODE_COMPLETE ||
				_chargingInfoData [ShmSysConfigAndInfo->SysInfo.CurGunSelected]->SystemStatus == SYS_MODE_ALARM)
		{
			if (isStatusChanged)
			{
				char showStr [525];

				if (ShmSysConfigAndInfo->SysInfo.OcppConnStatus == YES &&
						ShmSysConfigAndInfo->SysConfig.BillingData.isBilling &&
						ShmDcCommonData->startTransactionID[ShmSysConfigAndInfo->SysInfo.CurGunSelected] != 0)
				{
					if (ShmDcCommonData->_useVersion == _CDFA_VERSION_10 &&
							strlen ((char *) ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL) > 0)
					{
						sprintf ( showStr, "%s%d",
								ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL,
								ShmDcCommonData->startTransactionID [ShmSysConfigAndInfo->SysInfo.CurGunSelected]);
						byte len = strlen ( (char *) showStr );
						ChangeQrCode_Comp ( (char *) showStr, len );
						ChangeDisplay2Value ( __receipt_qrcode_bg, _ctep_qr_background );
					}
					else if (ShmDcCommonData->_useVersion == _CDFA_VERSION_20 &&
							strcmp((char*)ShmDcCommonData->cdfaInfor[ShmSysConfigAndInfo->SysInfo.CurGunSelected]._preQrCodeText, "") != EQUAL)
					{
						byte len = strlen ( (char *) ShmDcCommonData->cdfaInfor[ShmSysConfigAndInfo->SysInfo.CurGunSelected]._preQrCodeText );
						ChangeQrCode_Comp ( (char *) ShmDcCommonData->cdfaInfor[ShmSysConfigAndInfo->SysInfo.CurGunSelected]._preQrCodeText, len );
						ChangeDisplay2Value ( __receipt_qrcode_bg, _ctep_qr_background );
					}
					else
					{
						ChangeDisplay2Value ( __receipt_qrcode, _disappear );
						ChangeDisplay2Value ( __receipt_qrcode_bg, _disappear );
					}
				}
				else
				{
					ChangeDisplay2Value ( __receipt_qrcode, _disappear );
					ChangeDisplay2Value ( __receipt_qrcode_bg, _disappear );
				}
			}
		}
	}
}

void ChangeDisplayMoneyInfoWithoutBackend()
{
	struct timeb csuTime;
	struct tm *tmCSU;

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

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

void ChangeDisplayMoneyInfo()
{
	struct timeb csuTime;
	struct tm *tmCSU;

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

	ChangeDisplay2Value(__money_rate_map, _charging_money);
	ShmDcCommonData->_hour_index = tmCSU->tm_hour;
	if (ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc == DEFAULT_AC_INDEX)
	{
		if (ac_chargingInfo[0]->SystemStatus == SYS_MODE_IDLE ||
				ac_chargingInfo[0]->SystemStatus == SYS_MODE_MAINTAIN ||
				ac_chargingInfo[0]->SystemStatus == SYS_MODE_RESERVATION)
		{
			ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee = (float)ShmDcCommonData->balanceInfo.defaultPrice_Noodoe / 100;
		}
		else
		{
			if (ShmSysConfigAndInfo->SysConfig.TotalConnectorCount > 0)
			{
				if (ShmDcCommonData->balanceInfo.connectorBalanceInfo[1].UserPrice == 0)
					ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee = (float)ShmDcCommonData->balanceInfo.defaultPrice_Noodoe / 100;
				else
				{
					ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee =
							(float)ShmDcCommonData->balanceInfo.connectorBalanceInfo[1].UserPrice / 100;
				}

				if (ShmDcCommonData->balanceInfo.connectorBalanceInfo[1].AccountBalance > 0)
					ac_chargingInfo[0]->ChargingFee = (float)ShmDcCommonData->balanceInfo.connectorBalanceInfo[1].AccountBalance / 100;
				else
					ac_chargingInfo[0]->ChargingFee = 0;
			}
			else
			{
				if (ShmDcCommonData->balanceInfo.connectorBalanceInfo[0].UserPrice == 0)
					ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee = (float)ShmDcCommonData->balanceInfo.defaultPrice_Noodoe / 100;
				else
					ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee = ShmDcCommonData->balanceInfo.connectorBalanceInfo[0].UserPrice;

				if (ShmDcCommonData->balanceInfo.connectorBalanceInfo[0].AccountBalance > 0)
					ac_chargingInfo[0]->ChargingFee = (float)ShmDcCommonData->balanceInfo.connectorBalanceInfo[0].AccountBalance / 100;
				else
					ac_chargingInfo[0]->ChargingFee = 0;
			}
		}
		DisplayMoneyRate(ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee);
	}
	else
	{
		if (_chargingInfoData[ShmSysConfigAndInfo->SysInfo.CurGunSelected]->SystemStatus == SYS_MODE_IDLE ||
				_chargingInfoData[ShmSysConfigAndInfo->SysInfo.CurGunSelected]->SystemStatus == SYS_MODE_MAINTAIN ||
				_chargingInfoData[ShmSysConfigAndInfo->SysInfo.CurGunSelected]->SystemStatus == SYS_MODE_RESERVATION)
		{
			ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee = (float)ShmDcCommonData->balanceInfo.defaultPrice_Noodoe / 100;
		}
		else
		{
			byte acGunIndex = 0;

			if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == 1)
				acGunIndex = ShmSysConfigAndInfo->SysConfig.AcConnectorCount;

			if (ShmDcCommonData->balanceInfo.connectorBalanceInfo[ShmSysConfigAndInfo->SysInfo.CurGunSelected + acGunIndex].UserPrice == 0)
			{
				ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee = (float)ShmDcCommonData->balanceInfo.defaultPrice_Noodoe / 100;
			}
			else
			{
				ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee =
					(float)ShmDcCommonData->balanceInfo.connectorBalanceInfo[ShmSysConfigAndInfo->SysInfo.CurGunSelected + acGunIndex].UserPrice / 100;
			}

			if (ShmDcCommonData->balanceInfo.connectorBalanceInfo[ShmSysConfigAndInfo->SysInfo.CurGunSelected + acGunIndex].AccountBalance > 0)
			{
				_chargingInfoData[ShmSysConfigAndInfo->SysInfo.CurGunSelected]->ChargingFee =
						(float)ShmDcCommonData->balanceInfo.connectorBalanceInfo[ShmSysConfigAndInfo->SysInfo.CurGunSelected + acGunIndex].AccountBalance / 100;
			}
			else
			{
				_chargingInfoData[ShmSysConfigAndInfo->SysInfo.CurGunSelected]->ChargingFee = 0;
			}
		}

		DisplayMoneyRate(ShmSysConfigAndInfo->SysConfig.BillingData.Cur_fee);
	}
}

void ChangeDisplayCtepMoneyInfo()
{
	byte cmd [230];

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

	string2ByteArray((byte *) _defaultPriceBuf, cmd);
	DisplayFeeValueToLcm(__scroll_display_value, cmd, sizeof(cmd));
}

void Initialization()
{
	bool isPass = false;
	byte count = 5;
	while(!isPass && count > 0)
	{
		isPass = true;
		for (byte _index = 0; _index < _totalCount; _index++)
		{
			_lcmGunSelect = GUN_LEFT;
			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");
}

void DefaultIconStatus()
{
	for(byte i = 0; i < 3; i++)
		ChangeDisplay2Value(__gun_type_index + (i * 2), _disappear);

	for(byte i = 0; i < 3; i++)
		ChangeDisplay2Value(__cmp_gun_type_index + (i * 2), _disappear);

	for(byte i = 0; i < 2; i++)
		ChangeDisplay2Value(__gun_type_index_jp + (i * 2), _disappear);

	for(byte i = 0; i < 2; i++)
		ChangeDisplay2Value(__cmp_gun_type_index_jp + (i * 2), _disappear);

	if (ShmSysConfigAndInfo->SysInfo.IsAlternatvieConf == YES || _totalCount == 1)
		ChangeDisplay2Value(__sel_gun_btn, _disappear);
	else
		ChangeDisplay2Value(__sel_gun_btn, _sel_gun_btn);

	if (ShmDcCommonData->ShowLogoFlag)
	{
		ChangeDisplay2Value(__logo, _logo);
		ChangeDisplay2Value(__logo_cmp, _logo_cmp);
	}
	else
	{
		ChangeDisplay2Value(__logo, _disappear);
		ChangeDisplay2Value(__logo_cmp, _disappear);
	}

	//LW_tpc plug detects
	if (ShmDcCommonData->TpcDetectFunction == YES)
		ChangeDisplay2Value(__tpc_detect_map, _tpc_start_detect_btn);
	else
		ChangeDisplay2Value(__tpc_detect_map, _disappear);

	char _buf[3] = {0};
	memcpy(_buf, &ShmSysConfigAndInfo->SysConfig.ModelName[12], 2);

	// N0 : 拓連
//	if (ShmDcCommonData->ShowLogoFlag &&
//			strcmp(_buf, "N0") != EQUAL)
	if (strcmp(_buf, "N0") != EQUAL)
	{
		ChangeDisplay2Value(__phihong_string, _phihong_string_map);
	}
	else
	{
		ChangeDisplay2Value(__phihong_string, _disappear);
	}
}

void DisplaySystemDate()
{
	byte cmd [16];

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

	string2ByteArray(ShmDcCommonData->_sys_date, cmd);
	DisplayValueToLcm(__sys_date_value, cmd, sizeof(cmd));

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

	string2ByteArray ( ShmDcCommonData->_sys_time, cmd );
	DisplayValueToLcm ( __sys_time_value, cmd, sizeof(cmd) );

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

	string2ByteArray ( ShmDcCommonData->_sys_period, cmd );
	DisplayValueToLcm ( __sys_period_value, cmd, sizeof(cmd) );
}

void SetCtepString(bool isShow)
{
	if(isShow)
	{
		byte cmd [16];

		memset ( cmd, 0x00, sizeof(cmd) );
		sprintf ( (char *) cmd, "hrs:mins:secs");
		DisplayValueToLcm ( __ctep_time_string, cmd, sizeof(cmd) );

		memset ( cmd, 0x00, sizeof(cmd) );
		sprintf ( (char *) cmd, "Energy" );
		DisplayValueToLcm ( __ctep_energy_string, cmd, sizeof(cmd) );

		memset ( cmd, 0x00, sizeof(cmd) );
		sprintf ( (char *) cmd, "Energy Cost" );
		DisplayValueToLcm ( __ctep_energy_mon_string, cmd, sizeof(cmd) );

		memset ( cmd, 0x00, sizeof(cmd) );
		sprintf ( (char *) cmd, "Packing Fee" );
		DisplayValueToLcm ( __ctep_packing_mon_string, cmd, sizeof(cmd) );

		memset ( cmd, 0x00, sizeof(cmd) );
		sprintf ( (char *) cmd, "Total Cost" );
		DisplayValueToLcm ( __ctep_total_mon_string, cmd, sizeof(cmd) );

		ChangeDisplay2Value ( _ctep_energy_mon_comm, _ctep_energy_mon_comm_map );
		ChangeDisplay2Value ( _ctep_packing_mon_comm, _ctep_packing_mon_comm_map );
		ChangeDisplay2Value ( _ctep_total_mon_comm, _ctep_total_mon_comm_map );

		ChangeDisplay2Value ( _ctep_energy_mon_chg, _ctep_energy_mon_chg_map );
		ChangeDisplay2Value ( _ctep_packing_mon_chg, _ctep_packing_mon_chg_map );
		ChangeDisplay2Value ( _ctep_total_mon_chg, _ctep_total_mon_chg_map );

		ChangeDisplay2Value ( _ctep_energy_mon_comp, _ctep_energy_mon_comp_map );
		ChangeDisplay2Value ( _ctep_packing_mon_comp, _ctep_packing_mon_comp_map );
		ChangeDisplay2Value ( _ctep_total_mon_comp, _ctep_total_mon_comp_map );

		memset ( cmd, 0x00, sizeof(cmd) );
		sprintf ( (char *) cmd, "$0.00" );
		DisplayValueToLcm ( __Energy_Cost_complete, cmd, sizeof(cmd) );
		DisplayValueToLcm ( __Parking_Fee_complete, cmd, sizeof(cmd) );
		DisplayValueToLcm ( __Total_Cost_complete, cmd, sizeof(cmd) );
		DisplayValueToLcm ( __Energy_Cost_charging, cmd, sizeof(cmd) );
		DisplayValueToLcm ( __Parking_Fee_charging, cmd, sizeof(cmd) );
		DisplayValueToLcm ( __Total_Cost_charging, cmd, sizeof(cmd) );
		DisplayValueToLcm ( __Energy_Cost_comp, cmd, sizeof(cmd) );
		DisplayValueToLcm ( __Parking_Fee_comp, cmd, sizeof(cmd) );
		DisplayValueToLcm ( __Total_Cost_comp, cmd, sizeof(cmd) );
	}
	else
	{
		ChangeDisplay2Value ( __ctep_time_string, _disappear);
		ChangeDisplay2Value ( __ctep_energy_string, _disappear);
		ChangeDisplay2Value ( __ctep_energy_mon_string, _disappear);
		ChangeDisplay2Value ( __ctep_packing_mon_string, _disappear);
		ChangeDisplay2Value ( __ctep_total_mon_string, _disappear);

		ChangeDisplay2Value ( _ctep_energy_mon_comm, _disappear );
		ChangeDisplay2Value ( _ctep_packing_mon_comm, _disappear );
		ChangeDisplay2Value ( _ctep_total_mon_comm, _disappear );
		ChangeDisplay2Value ( _ctep_energy_mon_chg, _disappear );
		ChangeDisplay2Value ( _ctep_packing_mon_chg, _disappear );
		ChangeDisplay2Value ( _ctep_total_mon_chg, _disappear );
		ChangeDisplay2Value ( _ctep_energy_mon_comp, _disappear );
		ChangeDisplay2Value ( _ctep_packing_mon_comp, _disappear );
		ChangeDisplay2Value ( _ctep_total_mon_comp, _disappear );

		ChangeDisplay2Value ( __Energy_Cost_complete, _disappear );
		ChangeDisplay2Value ( __Parking_Fee_complete, _disappear );
		ChangeDisplay2Value ( __Total_Cost_complete, _disappear );
		ChangeDisplay2Value ( __Energy_Cost_charging, _disappear );
		ChangeDisplay2Value ( __Parking_Fee_charging, _disappear );
		ChangeDisplay2Value ( __Total_Cost_charging, _disappear );
		ChangeDisplay2Value ( __Energy_Cost_comp, _disappear );
		ChangeDisplay2Value ( __Parking_Fee_comp, _disappear );
		ChangeDisplay2Value ( __Total_Cost_comp, _disappear );
	}
}

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

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

	Initialization();
	//ChangeToOtherPage(_LCM_CHARGING);

//	char SystemId[128] = "https://www.google.com.tw/";
//	ChangeDisplay2Value(__qr_code, _disappear);
//	sleep(1);
//	byte len = strlen(SystemId);
//	ChangeQrCode_Idle(SystemId, len);
	//return -1;

//	ChangeToOtherPage(_LCM_CHARGING);
	//ChangeChargingPowerValue(1.1);
	//ChangeChargingEnergyValue(3.225);
//	ChangeDisplay2Value(__phihong_string, _disappear);

	///ChangeDisplayMoneyInfo();
//	ChangeToOtherPage(_LCM_INIT);

	DefaultIconStatus();

//	int xxx = 3;
//	while(xxx > 0 && Uart1Fd != -1)
//	{
//		if (xxx == 1)
//		{
//			printf("---------------------------- \n");
//			downloadBMP(1, "/tmp/1_idle.bmp");
//			printf("---------------------------- end \n");
//			return -1;
//		}
//		sleep(1);
//		xxx--;
//	}
//	return -1;

	byte _verShowCount = 3;
	while(Uart1Fd != -1)
	{
		UpdateLcmFunction();

		if (strcmp((char *)ShmSysConfigAndInfo->SysInfo.LcmHwRev, moduleName) != EQUAL ||
				_verShowCount > 0)
		{
			GetDeviceInfoStatus(__lcm_version, 3);
			GetCurrentPage();
			sleep(1);

			if (_verShowCount > 0)
			{
				//PRINTF_FUNC("LCM Version = V.%03d \n", ShmDcCommonData->LcmFwVersion);
				_verShowCount--;
			}

			if (ShmDcCommonData->LcmFwVersion >= 2)
			{
				ChangeDisplay2Value ( __logo, _logo );
				ChangeDisplay2Value ( __logo_cmp, _logo_cmp );
			}

			if (ShmDcCommonData->LcmFwVersion >= 5)
			{
				if (_totalCount >= 2 || ShmSysConfigAndInfo->SysInfo.ChargerType != _CHARGER_TYPE_JARI)
				{
					ChangeDisplay2Value(__conn1_cabinet_charging, _conn1_cabinet_double_chg_map);
					ChangeDisplay2Value(__conn1_cabinet_complete, _conn1_cabinet_double_cop_map);
				}
				else
				{
					ChangeDisplay2Value(__conn1_cabinet_charging, _conn2_cabinet_single_chg_map);
					ChangeDisplay2Value(__conn1_cabinet_complete, _conn2_cabinet_single_cop_map);
				}
			}
		}
		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();

			// 換頁處理
			GetCurrentPage();
			ChangeCurPage();

			RefreshPageAnimation(_everyPageRollChange);

			if (changeWarningPriority == 0)
			{
				if (ShmSysConfigAndInfo->SysInfo.OcppConnStatus == YES &&
						strlen ((char *) ShmSysConfigAndInfo->SysConfig.OcppReceiptrURL) > 0 &&
						ShmSysConfigAndInfo->SysConfig.BillingData.isBilling)
				{
					if (!_isCtepInforShow)
					{
						_isCtepInforShow = true;
						SetCtepString(true);
					}
				}
				else
				{
					_isCtepInforShow = false;
					SetCtepString(false);
				}

				if (ShmSysConfigAndInfo->SysConfig.BillingData.isBilling)
				{
					ChangeDisplay2Value(__money_rate_map, _charging_money);

					if(ShmDcCommonData->_useVersion != _CDFA_VERSION_NONE ||
							(strcmp((char *)ShmSysConfigAndInfo->SysConfig.OcppServerURL, "") != EQUAL &&
							strcmp((char *)ShmSysConfigAndInfo->SysConfig.ChargeBoxId, "") != EQUAL &&
							ShmSysConfigAndInfo->SysInfo.OcppConnStatus == YES))
					{
						if (ShmDcCommonData->_useVersion == _CDFA_VERSION_NOODOE)
						{
							ChangeDisplayMoneyInfo();
							memset(_defaultPriceBuf, 0, sizeof(_defaultPriceBuf));
							ChangeDisplayCtepMoneyInfo();

						}
						else if (ShmDcCommonData->_useVersion == _CDFA_VERSION_10 ||
									ShmDcCommonData->_useVersion == _CDFA_VERSION_20)
						{
							if (strcmp((char *)_defaultPriceBuf, ShmDcCommonData->balanceInfo.defaultPrice) != EQUAL)
							{
								memset(_defaultPriceBuf, 0, sizeof(_defaultPriceBuf));
								strcpy((char *)_defaultPriceBuf, ShmDcCommonData->balanceInfo.defaultPrice);
								ChangeDisplayCtepMoneyInfo();
							}
							ChangeDisplay2Value(__money_by_rate, _disappear);
						}
					}
					else
					{
						ChangeDisplayMoneyInfoWithoutBackend();
						memset(_defaultPriceBuf, 0, sizeof(_defaultPriceBuf));
						ChangeDisplayCtepMoneyInfo();
					}

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

					ChangeDisplay2Value(__money_by_rate, _disappear);
					memset(_defaultPriceBuf, 0, sizeof(_defaultPriceBuf));
					ChangeDisplayCtepMoneyInfo();
				}

				InformationShow();

				// CTEP Date
				DisplaySystemDate();
			}

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

	CloseCommunicationLcmPort();
	return FAIL;
}