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

#include "Module_LcmContro.h"

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];
	time_t CurrentTime;
	struct tm *tm;
	va_list args;

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

	memset(Buf,0,sizeof(Buf));
	CurrentTime = time(NULL);
	tm=localtime(&CurrentTime);
	sprintf(Buf,"echo \"%04d-%02d-%02d %02d:%02d:%02d - %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,
			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;
}

//==========================================
// 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("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:
				{
					// 頁面
					_currentPage = (unsigned short) (*(msg + 6) << 8) + (unsigned short) *(msg + 7);
				}
				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;
//			}
		}
	}

//	for (byte idx = 0; idx < len; idx++)
//		printf("[system_command]-RX: %X\n", *(msg + idx));
}

//================================================
// 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("ChangeWarningFunc \n");
	// 最多一次五筆
	//printf("LCM PageIndex = %d \n", ShmSysConfigAndInfo->SysWarningInfo.PageIndex);
	//printf("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("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;
}

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

	if (page == _LCM_CHARGING)
	{
		if (soc < 20)
			ChangeDisplay2Value(__batt_map, _battery_cap_20);
		else if (soc >= 20 && soc < 40)
			ChangeDisplay2Value(__batt_map, _battery_cap_40);
		else if (soc >= 40 && soc < 60)
			ChangeDisplay2Value(__batt_map, _battery_cap_60);
		else if (soc >= 60 && soc < 80)
			ChangeDisplay2Value(__batt_map, _battery_cap_80);
		else if (soc >= 80 && 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[4];
	byte value[4];

	memset(cmd, 0x00, sizeof(cmd));
	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 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 RefreshPageAnimation(byte value)
{
	switch(_currentPage)
	{
		case _LCM_IDLE:
		{
			if (value == 0)
			{
				ChangeToOtherPage(_currentPage);
			}
			else if (value == 15)
			{
				ChangeToOtherPage(_currentPage + 1);
			}
			else if (value == 30)
			{
				ChangeToOtherPage(_currentPage + 2);
			}

			_everyPageRollChange > 45 ? _everyPageRollChange = 0 : _everyPageRollChange++;
		}
			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);
			}

			if (_totalCount == 2 && _currentPage != _LCM_PRE_CHARGE)
			{
				byte index = 0;
				for (index = 0; index < _totalCount; index++) {
					if (ShmSysConfigAndInfo->SysInfo.CurGunSelected != index)
					{
						break;
					}
				}

				if (_chargingInfoData[index]->SystemStatus == S_IDLE)
				{
					ChangeDisplay2Value(__sel_gun_btn, _disappear);
					if(value == 0)
					{
						ChangeDisplay2Value(__side_top, _side_rfid_1);
						ChangeDisplay2Value(__side_down, _side_rfid_2);
					}
					else if (value == 15)
					{
						ChangeDisplay2Value(__side_top, _side_qr_1);
						ChangeDisplay2Value(__side_down, _side_qr_2);
					}
					else if (value == 30)
					{
						ChangeDisplay2Value(__side_top, _side_app_1);
						ChangeDisplay2Value(__side_down, _side_app_2);
					}
				}
				else
				{
					ChangeDisplay2Value(__sel_gun_btn, _sel_gun_btn);
					ChangeDisplay2Value(__side_top, _disappear);
					ChangeDisplay2Value(__side_down, _disappear);
					ChangeDisplay2Value(__qr_code_pre, _disappear);
				}
			}
			else
			{
				ChangeDisplay2Value(__sel_gun_btn, _disappear);
				ChangeDisplay2Value(__side_top, _disappear);
				ChangeDisplay2Value(__side_down, _disappear);
				ChangeDisplay2Value(__qr_code_pre, _disappear);
			}

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

void RefreshConnStatus()
{
	// Wifi priority is higher than Ethernet
	if (ShmSysConfigAndInfo->SysConfig.AthInterface.WifiNetworkConn == 0x01)
	{
		if (!_wifi_conn_status)
		{
			_wifi_conn_status = true;
			ChangeDisplay2Value(__wifi_status, _wifi_connect);
			ChangeDisplay2Value(__ethernet_status, _disappear);
		}
	}
	else
	{
		if(_wifi_conn_status)
		{
			_wifi_conn_status = false;
			ChangeDisplay2Value(__wifi_status, _disappear);
		}
	}

	if (!_wifi_conn_status)
	{
		if (ShmSysConfigAndInfo->SysConfig.TelecomInterface.TelcomNetworkConn == PASS)
		{
			if(!_net_conn_status)
			{
				_net_conn_status = true;
				ChangeDisplay2Value(__ethernet_status, _ethernet_connect);
			}
		}
		else
		{
			if(_net_conn_status)
			{
				_net_conn_status = false;
				ChangeDisplay2Value(__ethernet_status, _ethernet_disconnect);
			}
		}
	}

	// 連線到後台

}

void ProcessPageInfo()
{
	switch(_currentPage)
	{
		case _LCM_IDLE:
		{
			// QR Code 處理
			ChangeQrCode_Idle("http://google.com.tw");
		}
			break;
		case _LCM_PRE_CHARGE:
		case _LCM_CHARGING:
		case _LCM_COMPLETE:
		{
			// gun type and charging info
			for(byte i = 0; i < _totalCount; i++)
			{
				switch(_chargingInfoData[i]->Type)
				{
					case _Type_Chademo:
					{
						if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == i)
						{
							ChangeDisplay2Value(__gun_type_index + (i * 2), _chademo_light);
						}
						else
						{
							ChangeDisplay2Value(__gun_type_index + (i * 2), _chademo_dark);
						}
					}
						break;
					case _Type_CCS:
					{
						if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == i)
						{
							ChangeDisplay2Value(__gun_type_index + (i * 2), _ccs_light);
						}
						else
						{
							ChangeDisplay2Value(__gun_type_index + (i * 2), _ccs_dark);
						}
					}
						break;
				}

				if (_currentPage == _LCM_CHARGING)
				{
					if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == i)
					{
						ChangeBattMapAndValue(_LCM_CHARGING, _chargingInfoData[i]->EvBatterySoc);
						if (_chargingInfoData[i]->RemainChargingDuration < 0)
							ChangeRemainTime(_chargingInfoData[i]->RemainChargingDuration);
						ChangeChargingPowerValue(_chargingInfoData[i]->PresentChargingPower);
					}
				}
				else if (_currentPage == _LCM_COMPLETE)
				{
					if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == i)
					{
						ChangeBattMapAndValue(_LCM_COMPLETE, _chargingInfoData[i]->EvBatterySoc);
						if (_chargingInfoData[i]->RemainChargingDuration < 0)
							ChangeRemainTime(_chargingInfoData[i]->RemainChargingDuration);
						ChangeChargingPowerValue(_chargingInfoData[i]->PresentChargingPower);
					}
				}
			}

			// gun btn and QR code
			if (_totalCount == 2 && _currentPage != _LCM_PRE_CHARGE)
			{
				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_BOOTING)
				{
					// QR Code 處理
					ChangeQrCode_Charge("http://google.com.tw");
				}
				else
				{
					ChangeDisplay2Value(__sel_gun_btn, _disappear);
				}
			}
		}
			break;
	}
}

void Initialization()
{
	strcpy((char *)ShmSysConfigAndInfo->SysInfo.LcmHwRev, moduleName);

	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("EvComm (main) : FindChargingInfoData false \n");
				isPass = false;
				count--;
				break;
			}
		}
	}

	if (count == 0)
		printf("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);
	Initialization();

	while(_port != -1)
	{
		//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);

		changeWarningPriority >= 30 ? changeWarningPriority = 0 : changeWarningPriority++;
		usleep(100000);
	}

	CloseCommunicationLcmPort();
	return FAIL;
}