csu3_am335x/EVSE/Projects/DM30/Apps/Module_LcmControl.c

#include "Module_LcmControl.h"

bool needReloadQr = true;

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

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

char* getTimeString(void);

//=================================
// Common routine
//=================================
int StoreLogMsg(const char *fmt, ...)
{
    char Buf[4096+256];
    char buffer[4096];
    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;
}

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

    if (ShmSysConfigAndInfo->SysConfig.SwitchDebugFlag == YES)
        printf("%s \n", buffer);
    else
        DEBUG_INFO("%s \n", buffer);
}

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

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

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

    return result;
}

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

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

    return fd;
}

void CloseCommunicationLcmPort()
{
    close(_port);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    loop = 0;
    i = 0;

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

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

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

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

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

    int loop = 0;
    int i = 0;

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

    DisplayValueToLcm(__qr_code, cmd, len);
}

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

    int loop = 0;
    int i = 0;

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

    DisplayValueToLcm(__qr_code_pre, cmd, len);
}

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

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

    if (demoCount < 180)
        demoCount++;
}

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

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

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

    return false;
}

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)
        {
            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)
            ChangeDisplay2Value(__batt_map, _battery_cap_100);
    }
    else if (page == _LCM_COMPLETE)
    {
        if (soc < 20)
            ChangeDisplay2Value(__batt_map, _battery_soc_20);
        else if (soc >= 20 && soc < 40)
            ChangeDisplay2Value(__batt_map, _battery_soc_40);
        else if (soc >= 40 && soc < 60)
            ChangeDisplay2Value(__batt_map, _battery_soc_60);
        else if (soc >= 60 && soc < 80)
            ChangeDisplay2Value(__batt_map, _battery_soc_80);
        else if (soc >= 80 && soc <= 100)
            ChangeDisplay2Value(__batt_map, _battery_soc_100);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    // 連線到後台
    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;
}

void ProcessPageInfo()
{
    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)
            {
                if (ShmSysConfigAndInfo->SysConfig.isQRCode)
                {
                    needReloadQr = false;
                    ChangeQrCode_Idle("http://google.com.tw");
                }
            }
        }
            break;
        case _LCM_AUTHORIZING:
        case _LCM_AUTHORIZ_COMP:
        case _LCM_AUTHORIZ_FAIL:
        case _LCM_WAIT_FOR_PLUG:
        {
            FirstPageChanged();
        }
            break;
        case _LCM_PRE_CHARGE:
        case _LCM_CHARGING:
        case _LCM_COMPLETE:
        {
            if (_totalCount == 2)
            {
                ChangeDisplay2Value(__sel_gun_btn, _sel_gun_btn);

                if (ShmSysConfigAndInfo->SysConfig.isRFID)
                    ChangeDisplay2Value(__side_top, _side_rfid);
                else
                    ChangeDisplay2Value(__side_top, _side_none_rfid);

                if (ShmSysConfigAndInfo->SysConfig.isQRCode)
                    ChangeDisplay2Value(__side_mid, _side_qr);
                else
                {
                    ChangeDisplay2Value(__qr_code_pre, _disappear);
                    ChangeDisplay2Value(__side_mid, _side_none_qr);
                    needReloadQr = true;
                }

                if (ShmSysConfigAndInfo->SysConfig.isAPP)
                    ChangeDisplay2Value(__side_down, _side_app);
                else
                    ChangeDisplay2Value(__side_down, _side_none_app);
            }
            else
            {
                ChangeDisplay2Value(__side_top, _disappear);
                ChangeDisplay2Value(__side_mid, _disappear);
                ChangeDisplay2Value(__side_down, _disappear);
                ChangeDisplay2Value(__sel_gun_btn, _disappear);
            }

            // 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_GB:
                    {
                        if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == i)
                        {
                            ChangeDisplay2Value(__gun_type_index + (i * 2), _gbt_light);
                        }
                        else
                        {
                            ChangeDisplay2Value(__gun_type_index + (i * 2), _gbt_dark);
                        }
                    }
                        break;
                    case _Type_CCS_2:
                    {
                        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);
                        else
                            ChangeRemainTime(0);
                        if (_chargingInfoData[i]->PresentChargingPower >= 0)
                            ChangeChargingPowerValue(_chargingInfoData[i]->PresentChargingPower);
                        else
                            ChangeChargingPowerValue(0);
                        if (_chargingInfoData[i]->PresentChargedEnergy >= 0.1)
                            ChangeChargingEnergyValue(_chargingInfoData[i]->PresentChargedEnergy);
                        else
                            ChangeChargingEnergyValue(0);

                        if (strcmp((char *)_chargingInfoData[i]->StartUserId, "") == 0)
                            ChangeDisplay2Value(__stop_method_btn, _stop_charging_btn);
                        else
                            ChangeDisplay2Value(__stop_method_btn, _stop_charging_btn_scan);
                    }
                }
                else if (_currentPage == _LCM_COMPLETE)
                {
                    if (ShmSysConfigAndInfo->SysInfo.CurGunSelected == i)
                    {
                        ChangeBattMapAndValue(_LCM_COMPLETE, _chargingInfoData[i]->EvBatterySoc);
                        if (_chargingInfoData[i]->RemainChargingDuration >= 0)
                            ChangeRemainTime(_chargingInfoData[i]->RemainChargingDuration);
                        else
                            ChangeRemainTime(0);
                        if (_chargingInfoData[i]->PresentChargingPower >= 0)
                            ChangeChargingPowerValue(_chargingInfoData[i]->PresentChargingPower);
                        else
                            ChangeChargingPowerValue(0);

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

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

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

                if (_chargingInfoData[index]->SystemStatus == S_IDLE ||
                        _chargingInfoData[index]->SystemStatus == S_RESERVATION ||
                        _chargingInfoData[index]->SystemStatus == S_BOOTING)
                {
                    if (FirstPageChanged() == YES || needReloadQr)
                    {
                        if (ShmSysConfigAndInfo->SysConfig.isQRCode)
                        {
                            needReloadQr = false;
                            ChangeQrCode_Charge("http://google.com.tw");
                        }
                    }
                }
            }
        }
            break;
    }
}

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

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

        ChangeDisplay2Value(__money_rate_map, _charging_money);

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

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

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

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

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

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

    //ChangeToOtherPage(_LCM_INIT);
    //return 0;

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

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

                ChangeWarningFunc();
            }

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

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

            // 換頁處理
            ChangeCurPage();

            RefreshPageAnimation(_everyPageRollChange);

            if (changeWarningPriority == 0)
                ChangeDisplayMoneyInfo();

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

    CloseCommunicationLcmPort();
    return FAIL;
}