csu3_am335x/EVSE/Projects/DD360UCar/Apps/ModuleLcmCtrl/Module_LcmControl.c

#include <stdio.h>      /*標準輸入輸出定義*/
#include <stdlib.h>     /*標準函數庫定義*/
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <termios.h>
#include <fcntl.h>
#include <time.h>

#include <sys/ioctl.h>
#include <sys/timeb.h>

#include "Module_LcmControl.h"
#include "../Log/log.h"
#include "../ShareMemory/shmMem.h"
#include "../Define/define.h"
#include "../Config.h"
#include "../SelectGun/SelectGun.h"
#define uSEC_VAL                                (1000000)
//------------------------------------------------------------------------------
//struct SysConfigAndInfo         *ShmSysConfigAndInfo;
//struct StatusCodeData           *ShmStatusCodeData;
static struct SysConfigData *pSysConfig = NULL;
static struct SysInfoData *pSysInfo = NULL;
static struct WARNING_CODE_INFO *pSysWarning = NULL;

static struct FanModuleData *ShmFanModuleData;
static struct PrimaryMcuData *ShmPrimaryMcuData;
static SelectGunInfo *ShmSelectGunInfo = NULL;
static struct ChargingInfoData *pDcChargingInfo = NULL;
static DcCommonInfo *ShmDcCommonData            = NULL;

short _currentPage              = _LCM_NONE;
uint8_t _totalCount;
uint8_t _showInformIndex = 0;
float ChargeMaxPower_0 = 0;
float ChargeMaxPower_1 = 0;
int _port;
//char* pPortName         = "/dev/ttyO2";
char *pPortName           = "/dev/ttyS3";
char *moduleName          = "DMT80480T070_09WT";
bool is_show = false;
uint8_t _everyPageRollChange;
//==========================================
// Open and Close RS232 and R/W
//==========================================
unsigned long GetClockTimeoutValue(struct timespec _start_time)
{
    struct timespec ts_end;
    unsigned long ret = 0;

    clock_gettime(CLOCK_MONOTONIC, &ts_end);

    ret = ((unsigned long)(ts_end.tv_sec - _start_time.tv_sec) * 1000000) + ((unsigned long)((ts_end.tv_nsec / 1000) - (_start_time.tv_nsec/ 1000)));

    return ret;
}
int CreateCommunicationLcmPort()
{
    int fd;
    struct termios tios;

    fd = open(pPortName, O_RDWR);
    if (fd <= 0) {
        log_error("open /dev/ttyS3 NG ");
        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] = (uint8_t) 5;
    tios.c_lflag = 0;
    tcflush(fd, TCIFLUSH);
    ioctl(fd, TCSETS, &tios);

    return fd;
}

void CloseCommunicationLcmPort()
{
    close(_port);
}

void WriteCmdToLcm(uint8_t *cmd, uint8_t cmdLen)
{
    int len = write(_port, cmd, cmdLen);
    if (len < sizeof(cmd)) {
        log_error("Write cmd to LCM Failure. ");
    }
}

void ReadMsgFromLcm(uint8_t *msg, uint8_t 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 *)pSysInfo->LcmHwRev, moduleName);
                _currentPage = *(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;
//          }
        }
    }
}
void GetHrFormTimeString(char* time,char* hr)
{
    //char tm[] = "2021-12-06 17:29:08:084";
    int _temp_hr;
    for(int i = 0 ; i < 2 ; i++) {
        hr[i] = time[i+11];
    }
    if ((atoi(hr) + 8) > 23) {
        _temp_hr = atoi(hr) + 8 - 24;
        sprintf(hr, "%02d", _temp_hr);
    } else if( atoi(hr) == NULL ) {
        strcmp(hr,"");
    }
}
void GetMinFormTimeString(char* time,char* min)
{
    //char tm[] = "2021-12-06 17:29:08:084";
    for(int i = 0 ; i < 2 ; i++) {
        min[i] = time[i+14];
    }
    if( atoi(min) == NULL || atoi(min) > 60) {
        strcmp(min,"");
    }
}
//================================================
// Function
//================================================
void ChangeToOtherPage(short newPage)
{
    uint8_t 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)
{
    uint8_t value = 0x01;

    if (islight) {
        value = 0x20;
    }
    uint8_t 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()
{
    uint8_t cmd[6];
    memset(cmd, 0x00, sizeof(cmd));
    uint8_t 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(5000);
    ReadMsgFromLcm(msg, ARRAY_SIZE(msg));
}

void DisplayValueToLcm(short address, uint8_t *data, uint8_t len)
{
    uint8_t 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 (uint8_t count = 0; count < len; count++) {
        cmd[6 + count] = *(data + count);
    }

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

void ChangeDisplay2Value(short address, short value)
{
    uint8_t data[2];
    data[0] = value >> 8;
    data[1] = value & 0x00FF;
    //log_info("Addr:0x%x, value:%d",address,value);
    DisplayValueToLcm(address, data, sizeof(data));
}

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

    loop = 0;
    i = 0;

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

void RefreshProgressAnimation(uint8_t progress_index)
{
    if(_everyPageRollChange % 2) {
        progress_index+=1;
    }
    ChangeDisplay2Value(_ProgressBar_LEVEL,progress_index);
    _everyPageRollChange++;
}
//================================================
// Change current page
//================================================
void ChangeCurPage()
{
    //log_info("cur = %d ,system = %d, lcm = %d ",_currentPage, pSysInfo->SystemPage, pSysInfo->PageIndex);
    struct ChargingInfoData *pDcChargingInfo_0 = (struct ChargingInfoData *)GetDcChargingInfoData(LEFT_GUN_NUM);
    struct ChargingInfoData *pDcChargingInfo_1 = (struct ChargingInfoData *)GetDcChargingInfoData(RIGHT_GUN_NUM);

    
    switch (pSysInfo->SystemPage) {
        case _LCM_VIEW:
            if (pDcChargingInfo_0->SystemStatus == S_IDLE && pDcChargingInfo_1->SystemStatus == S_IDLE ) {
                pSysInfo->PageIndex = __VIEW_ALL_IDLE_;
            } else if(pDcChargingInfo_0->SystemStatus == S_CHARGING && pDcChargingInfo_1->SystemStatus != S_CHARGING) {
                pSysInfo->PageIndex = __VIEW_LEFT_CHARGE_;
            } else if(pDcChargingInfo_0->SystemStatus != S_CHARGING && pDcChargingInfo_1->SystemStatus == S_CHARGING) {
                pSysInfo->PageIndex = __VIEW_RIGHT_CHARGE_;
            } else if(pDcChargingInfo_0->SystemStatus == S_CHARGING && pDcChargingInfo_1->SystemStatus == S_CHARGING) {
                pSysInfo->PageIndex = __VIEW_ALL_CHARGE_;
            }
            break;
        case _LCM_START_SCAN:
            if (pSysInfo->CurGunSelected == LEFT_GUN_NUM)
                pSysInfo->PageIndex = __START_SCAN_LEFT;
            else
                pSysInfo->PageIndex = __START_SCAN_RIGHT;
            break;
        case _LCM_START_AUTHORIZING:
            pSysInfo->PageIndex = __START_AUTHORIZE_;
            break;
        case _LCM_START_AUTHORIZE_FAIL:
            if (pSysInfo->CurGunSelected == LEFT_GUN_NUM)
                pSysInfo->PageIndex = __START_AUTHORIZE_FAIL_LEFT;
            else
                pSysInfo->PageIndex = __START_AUTHORIZE_FAIL_RIGHT;
            break;
        case _LCM_WAIT_PLUGIN:
            if (pSysInfo->CurGunSelected == LEFT_GUN_NUM)
                pSysInfo->PageIndex = __WAIT_PLUGIN_;
            else
                pSysInfo->PageIndex = __WAIT_PLUGIN_RIGHT;
            break;
        case _LCM_PRECHARGE:
            pSysInfo->PageIndex =__PRE_CHARGE_;
            break;
        case _LCM_LINK_ERROR:
            if(pSysInfo->CurGunSelected == LEFT_GUN_NUM)
                pSysInfo->PageIndex = __LINKING_ERROR_LEFT;
            else
                pSysInfo->PageIndex = __LINKING_ERROR_RIGHT;
            break;
        case _LCM_DETAIL_VIEW:
            pSysInfo->PageIndex =__DETAIL_VIEW_;
            break;
        case _LCM_STOP_RFID:
            pSysInfo->PageIndex =__STOP_SCAN_RFID_;
            break;
        case _LCM_STOP_APP:
            pSysInfo->PageIndex =__STOP_SCAN_APP_;
            break;
        case _LCM_STOP_RFID_FAIL:
            pSysInfo->PageIndex =__STOP_RFID_FAIL_;
            break;
        case _LCM_STOPPING:
            pSysInfo->PageIndex =__STOP_AUTHORIZE_;
            break;
        case _LCM_WAIT_PLUGOUT:
            if (pSysInfo->CurGunSelected == LEFT_GUN_NUM)
                pSysInfo->PageIndex = __WAIT_PLUGOUT_LEFT;
            else
                pSysInfo->PageIndex = __WAIT_PLUGOUT_RIGHT;
            break;
        case _LCM_SUMMARY:
            if (pSysInfo->CurGunSelected == LEFT_GUN_NUM)
                pSysInfo->PageIndex = __SUMMARY_LEFT;
            else
                pSysInfo->PageIndex = __SUMMARY_RIGHT;
            break;
        case _LCM_MAINTAIN:
            pSysInfo->PageIndex =__MAINTAIN_PAGE_;
            break;
        case _LCM_ERROR:
            if (pSysInfo->CurGunSelected == LEFT_GUN_NUM)
                pSysInfo->PageIndex = __ERROR_PAGE_LEFT;
            else
                pSysInfo->PageIndex = __ERROR_PAGE_RIGHT;
            break;
        case _LCM_EMERGENCY:
            pSysInfo->PageIndex =__EMERGENCY_BUTTON_;
            break;
        case _LCM_CONFIRM_STOP:
            if (pSysInfo->CurGunSelected == LEFT_GUN_NUM) {
                pSysInfo->PageIndex = __CONFIRM_STOP_LEFT;
            } else 
                pSysInfo->PageIndex = __CONFIRM_STOP_RIGHT;
            break;
        case _LCM_COMMUNICATION:
            pSysInfo->PageIndex = __COMMUNICATION_PROCESS;
            break;
        case _LCM_CHARGING_DETECT:
            pSysInfo->PageIndex = __GFD_PROCESS;
            break;
        case _LCM_PREPARECHARE:
            pSysInfo->PageIndex = __PRECHARGE_PROCESS;
            break;
    }
    if (_currentPage != pSysInfo->PageIndex) {
        _currentPage = pSysInfo->PageIndex;
        ChangeToOtherPage(pSysInfo->PageIndex);
    }
}

/*
 * View Page
 *
 */

void ShowViewChargingSoc(uint8_t gunIndex,int soc)
{
    uint8_t digits = soc % 10;
    uint8_t tens = (soc / 10) %10;
    uint8_t hundreds = soc / 100;

    if (gunIndex == LEFT_GUN_NUM) {
        ChangeDisplay2Value(_LeftGun_Soc_Digits,(short)_ICON_Red_Num_0+digits);
        ChangeDisplay2Value(_LeftGun_Soc_Tens,(short)_ICON_Red_Num_0+tens);
        if (hundreds == 0 ) {
            ChangeDisplay2Value(_LeftGun_Soc_Hundreds,(short)_ICON_Empty);
            if (tens == 0 )
                ChangeDisplay2Value(_LeftGun_Soc_Tens,(short)_ICON_Empty);
        }
        else
            ChangeDisplay2Value(_LeftGun_Soc_Hundreds,(short)_ICON_Red_Num_1);

    } else {
        //log_info("%d %d %d",hundreds,tens,digits);
        ChangeDisplay2Value(_RightGun_Soc_Digits,(short)_ICON_Red_Num_0+digits);
        ChangeDisplay2Value(_RightGun_Soc_Tens,(short)_ICON_Red_Num_0+tens);
        if (hundreds == 0 ) {
            ChangeDisplay2Value(_RightGun_Soc_Hundreds,(short)_ICON_Empty);
            if (tens == 0)
                ChangeDisplay2Value(_RightGun_Soc_Tens,(short)_ICON_Empty);
        }
        else
            ChangeDisplay2Value(_RightGun_Soc_Hundreds,(short)_ICON_Red_Num_1);
    }
}
void ShowViewChargingTime(uint8_t gunIndex,int time)
{
    uint8_t value[10] = {0};
    int min,sec;
    min = time/60;
    sec = time % 60;
    sprintf((char *)value,"%d:%02d",min,sec);
    if (gunIndex == LEFT_GUN_NUM) {
        DisplayValueToLcm(_LeftGun_info_time, (uint8_t *)value, sizeof(value));
    } else
        DisplayValueToLcm(_RightGun_info_time, (uint8_t *)value, sizeof(value));
}
void ShowViewChargingEngery(uint8_t gunIndex, float energy)
{
    uint8_t value[10] = { 0 };

    if(energy < 100)
        sprintf((char*)value, "%.1f", energy);
    else
        sprintf((char*)value, "%d", (int)energy);
    //log_info("gun[%d] energy:%.1f", gunIndex, energy);
    if (gunIndex == LEFT_GUN_NUM) {
        DisplayValueToLcm(_LeftGun_info_cap, (uint8_t*)value, sizeof(value));
    }
    else
        DisplayValueToLcm(_RightGun_info_cap, (uint8_t*)value, sizeof(value));
}
void ShowViewCharingMoney(uint8_t gunIndex,float money)
{
    uint8_t value[10] = {0};
    sprintf((char *)value,"%d",(int)money);
    //log_info("gun[%d] money:%.1f", gunIndex, money);
    if (gunIndex == LEFT_GUN_NUM) {
        DisplayValueToLcm(_LeftGun_info_money, (uint8_t *)value, sizeof(value));
    } else
        DisplayValueToLcm(_RightGun_info_money, (uint8_t *)value, sizeof(value));
}
void ShowViewChargingPower(uint8_t gunIndex,float power)
{
    uint8_t value[10] = {0};
    float _data = power * 10;
    sprintf((char *)value,"%.1f",power);
    //log_info("gun[%d] power:%.1f",gunIndex,power);
    if (power >= 0 &&  power <= POWER_MAX_KW) {
        if (gunIndex == LEFT_GUN_NUM) {
            ChangeDisplay2Value(_LeftGun_info_power_number, _data);
            //DisplayValueToLcm(_LeftGun_info_power_number, (uint8_t *)value, sizeof(value));
        } else {
            //DisplayValueToLcm(_RightGun_info_power_number, (uint8_t*)value, sizeof(value));
            ChangeDisplay2Value(_RightGun_info_power_number, _data);
        }
    }
}
void ShowConnectId()
{
    if (ShmDcCommonData->ConnectorId[0] <= 2) {
        ChangeDisplay2Value(_LeftGun_ConnectorId, _ICON_CONNECTOR_1);
        ChangeDisplay2Value(_RightGun_ConnectorId, _ICON_CONNECTOR_1);
    } else {
        ChangeDisplay2Value(_LeftGun_ConnectorId, _ICON_CONNECTOR_2);
        ChangeDisplay2Value(_RightGun_ConnectorId, _ICON_CONNECTOR_2);
    }
    
}
void ShowViewLeftGunInfo()
{
    char value[5];
    pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(LEFT_GUN_NUM);
    if (pDcChargingInfo->SystemStatus == S_IDLE ) {
        switch (pDcChargingInfo->CCSGunType) {
            case _TYPE_CCS1_Liquid:
            case _TYPE_CCS1_Natural:
                ChangeDisplay2Value(_LeftGun_type_pic_U,_ICON_CCS1_GUN_U);
                ChangeDisplay2Value(_LeftGun_type_pic_L,_ICON_CCS1_GUN_L);
                ChangeDisplay2Value(_LeftGun_type_name,_ICON_CCS1_Name);
                if (pDcChargingInfo->CCSGunType == _TYPE_CCS1_Liquid) {
                    ChangeDisplay2Value(_LeftGun_type_speed,_ICON_High_Speed);
                } else {
                    ChangeDisplay2Value(_LeftGun_type_speed,_ICON_Speed);
                }
                break;
            case _TYPE_CCS2_Liquid:
            case _TYPE_CCS2_Natural:
                ChangeDisplay2Value(_LeftGun_type_pic_U,_ICON_CCS2_GUN_U);
                ChangeDisplay2Value(_LeftGun_type_pic_L,_ICON_CCS2_GUN_L);
                ChangeDisplay2Value(_LeftGun_type_name,_ICON_CCS2_Name);
                if (pDcChargingInfo->CCSGunType == _TYPE_CCS2_Liquid) {
                    ChangeDisplay2Value(_LeftGun_type_speed,_ICON_High_Speed);
                } else {
                    ChangeDisplay2Value(_LeftGun_type_speed,_ICON_Speed);
                }
                break;
            default:
                log_error("CCS Gun Type Error! Not Show in LCM!!");
        }
        memset(value, 0x00, sizeof(value));
        sprintf((char *)value,"1 A");
        DisplayValueToLcm(_LeftGun_location, (uint8_t *)value, sizeof(value));
    } else if (pDcChargingInfo->SystemStatus == S_CHARGING ) {
        ShowViewChargingSoc(LEFT_GUN_NUM,pDcChargingInfo->EvBatterySoc);
        ShowViewChargingTime(LEFT_GUN_NUM,pDcChargingInfo->PresentChargedDuration);
        ShowViewCharingMoney(LEFT_GUN_NUM,pDcChargingInfo->ChargingFee);
        ShowViewChargingPower(LEFT_GUN_NUM,pDcChargingInfo->PresentChargingPower);
        ShowViewChargingEngery(LEFT_GUN_NUM, pDcChargingInfo->PresentChargedEnergy);

        switch (pDcChargingInfo->CCSGunType) {
            case _TYPE_CCS1_Liquid:
            case _TYPE_CCS1_Natural:
                ChangeDisplay2Value(_LeftGun_type_name, _ICON_CCS1_Name);
                break;
            case _TYPE_CCS2_Liquid:
            case _TYPE_CCS2_Natural:
                ChangeDisplay2Value(_LeftGun_type_name, _ICON_CCS2_Name);
                break;
        }

    }
}

void ShowViewRightGunInfo()
{
    char value[5];
    pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(RIGHT_GUN_NUM);
    if (pDcChargingInfo->SystemStatus == S_IDLE ) {
        switch (pDcChargingInfo->CCSGunType) {
            case _TYPE_CCS1_Liquid:
            case _TYPE_CCS1_Natural:
                ChangeDisplay2Value(_RightGun_type_pic_U,_ICON_CCS1_GUN_U);
                ChangeDisplay2Value(_RightGun_type_pic_L,_ICON_CCS1_GUN_L);
                ChangeDisplay2Value(_RightGun_type_name,_ICON_CCS1_Name);
                if (pDcChargingInfo->CCSGunType == _TYPE_CCS1_Liquid) {
                    ChangeDisplay2Value(_RightGun_type_speed,_ICON_High_Speed);
                } else {
                    ChangeDisplay2Value(_RightGun_type_speed,_ICON_Speed);
                }
                break;
            case _TYPE_CCS2_Liquid:
            case _TYPE_CCS2_Natural:
                ChangeDisplay2Value(_RightGun_type_pic_U,_ICON_CCS2_GUN_U);
                ChangeDisplay2Value(_RightGun_type_pic_L,_ICON_CCS2_GUN_L);
                ChangeDisplay2Value(_RightGun_type_name,_ICON_CCS2_Name);
                if (pDcChargingInfo->CCSGunType == _TYPE_CCS2_Liquid) {
                    ChangeDisplay2Value(_RightGun_type_speed,_ICON_High_Speed);
                } else {
                    ChangeDisplay2Value(_RightGun_type_speed,_ICON_Speed);
                }
                break;
            default:
                log_error("CCS Gun Type Error! Not Show in LCM!!");
        }
        memset(value, 0x00, sizeof(value));
        sprintf((char *)value,"1 B");
        DisplayValueToLcm(_RightGun_location, (uint8_t *)value, sizeof(value));
    } else if (pDcChargingInfo->SystemStatus == S_CHARGING ) {
        ShowViewChargingSoc(RIGHT_GUN_NUM,pDcChargingInfo->EvBatterySoc);
        ShowViewChargingTime(RIGHT_GUN_NUM,pDcChargingInfo->PresentChargedDuration);
        ShowViewCharingMoney(RIGHT_GUN_NUM,pDcChargingInfo->ChargingFee);
        ShowViewChargingPower(RIGHT_GUN_NUM,pDcChargingInfo->PresentChargingPower);
        ShowViewChargingEngery(RIGHT_GUN_NUM, pDcChargingInfo->PresentChargedEnergy);
        switch (pDcChargingInfo->CCSGunType) {
        case _TYPE_CCS1_Liquid:
        case _TYPE_CCS1_Natural:
            ChangeDisplay2Value(_RightGun_type_name, _ICON_CCS1_Name);
            break;
        case _TYPE_CCS2_Liquid:
        case _TYPE_CCS2_Natural:
            ChangeDisplay2Value(_RightGun_type_name, _ICON_CCS2_Name);
            break;
        }
    }
}
void SetViewPage()
{
    // Set Background pic.
    if (pSysConfig->TotalConnectorCount == 1) {

    } else if (pSysConfig->TotalConnectorCount == 2) {
        ShowConnectId();
        ShowViewLeftGunInfo();
        ShowViewRightGunInfo();
    }
}
void ShowSelectGunIcon()
{
    uint8_t value[5] = {0};
    pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(pSysInfo->CurGunSelected);

    if (pSysInfo->CurGunSelected == LEFT_GUN_NUM) {
        if (pDcChargingInfo->CCSGunType == _TYPE_CCS1_Liquid ||
                pDcChargingInfo->CCSGunType == _TYPE_CCS1_Natural) {
            ChangeDisplay2Value(_Confirm_Gun_Left_symbol,_ICON_CCS1_Symbol);

        } else if (pDcChargingInfo->CCSGunType == _TYPE_CCS2_Liquid ||
                pDcChargingInfo->CCSGunType == _TYPE_CCS2_Natural) {
            ChangeDisplay2Value(_Confirm_Gun_Left_symbol,_ICON_CCS2_Symbol);
        }
        ChangeDisplay2Value(_Confirm_Gun_Right_symbol,_ICON_Empty);
        sprintf((char *)value,"%s",LEFT_GUN_LOCAL_NAME);
        DisplayValueToLcm(_Confirm_Gun_Left_name, (uint8_t *)value, sizeof(value));
        memset(value, 0x00, sizeof(value));
        DisplayValueToLcm(_Confirm_Gun_Right_name, (uint8_t *)value, sizeof(value));

    } else if (pSysInfo->CurGunSelected == RIGHT_GUN_NUM) {
        if (pDcChargingInfo->CCSGunType == _TYPE_CCS1_Liquid ||
                pDcChargingInfo->CCSGunType == _TYPE_CCS1_Natural) {
            ChangeDisplay2Value(_Confirm_Gun_Right_symbol,_ICON_CCS1_Symbol);

        } else if (pDcChargingInfo->CCSGunType == _TYPE_CCS2_Liquid ||
                pDcChargingInfo->CCSGunType == _TYPE_CCS2_Natural) {
            ChangeDisplay2Value(_Confirm_Gun_Right_symbol,_ICON_CCS2_Symbol);
        }
        ChangeDisplay2Value(_Confirm_Gun_Left_symbol,_ICON_Empty);

        sprintf((char *)value,"%s",RIGHT_GUN_LOCAL_NAME);
        DisplayValueToLcm(_Confirm_Gun_Right_name, (uint8_t *)value, sizeof(value));

        memset(value, 0x00, sizeof(value));
        DisplayValueToLcm(_Confirm_Gun_Left_name, (uint8_t *)value, sizeof(value));
    }
}
/*
 * Detail View Page
 */
void SetDetailViewPage()
{
    uint8_t data;
    float float_data;
    uint8_t value[10] = {0};
    ShowSelectGunIcon();
    pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(pSysInfo->CurGunSelected);
    if (pDcChargingInfo->SystemStatus != S_CHARGING) {
        SetViewPage();
        return;
    }
    log_info("PowerConsumption:%.1f",pDcChargingInfo->PowerConsumption);
    uint8_t digits = pDcChargingInfo->EvBatterySoc % 10;
    uint8_t tens = (pDcChargingInfo->EvBatterySoc / 10) %10;
    uint8_t hundreds = pDcChargingInfo->EvBatterySoc / 100;
    // Show Numbers.
    ChangeDisplay2Value(_Percent_Number_Digits,_ICON_White_Num_0+digits);
    ChangeDisplay2Value(_Percent_Number_Tens,_ICON_White_Num_0+tens);
    if (hundreds == 0 ) {
        ChangeDisplay2Value(_Percent_Number_Hundreds,_ICON_Empty);
        if (tens == 0)
            ChangeDisplay2Value(_Percent_Number_Tens,_ICON_Empty);
    } else {
        ChangeDisplay2Value(_Percent_Number_Hundreds,_ICON_White_Num_1);
    }

    // Show Progress Bar
    if (hundreds) {
    	ChangeDisplay2Value(_ProgressBar_LEVEL, _ICON_BTY_100);
    }
    else {
        // 0 ~ 19 % show in progress bar 10%
        if (pDcChargingInfo->EvBatterySoc < 10) {
            if (_everyPageRollChange % 3 == 0)
                ChangeDisplay2Value(_ProgressBar_LEVEL, _ICON_BTY_10);
            else if (_everyPageRollChange % 3 == 1)
                ChangeDisplay2Value(_ProgressBar_LEVEL, _ICON_BTY_12);
            else
                ChangeDisplay2Value(_ProgressBar_LEVEL, _ICON_BTY_14);
        }
        else {
            ChangeDisplay2Value(_ProgressBar_LEVEL, _ICON_BTY_10 + (tens * 10) + (_everyPageRollChange % 5) * 2);
        }
        /*
    	if (tens == 1)
    		tens = 0;
		if (_everyPageRollChange%2 == 0)
			ChangeDisplay2Value(_ProgressBar_LEVEL,_ICON_ProgressBar_10+tens*2);
		else
			ChangeDisplay2Value(_ProgressBar_LEVEL,_ICON_ProgressBar_10+tens*2+1);
            */
		_everyPageRollChange++;
    }

    // Show Power
    if (pDcChargingInfo->PresentChargingPower >= 0 &&
        pDcChargingInfo->PresentChargingPower <= POWER_MAX_KW) {
        float_data = pDcChargingInfo->PresentChargingPower;
    } else {
        float_data = 0;
    }
    sprintf((char *)value,"%.1f",float_data);
    DisplayValueToLcm(_Detail_Power_Num,value, sizeof(value));

    // Show Time
    data = (pDcChargingInfo->PresentChargedDuration)/60;
    sprintf((char *)value,"%d",data);
    DisplayValueToLcm(_Detail_Time_Num,value, sizeof(value));
    // Show Energy
    if (pDcChargingInfo->PresentChargedEnergy >= 0.1 &&
            pDcChargingInfo->PresentChargedEnergy <= ENERGY_MAX_KWH) {
    	float_data = pDcChargingInfo->PresentChargedEnergy;
    } else
    	float_data = 0;
    sprintf((char *)value,"%.1f",float_data);
    log_info("Energy:%s",value);
    DisplayValueToLcm(_Detail_Cap_Num,value, sizeof(value));

    // Show Money
    //data = pDcChargingInfo->ChargingFee;
    sprintf((char *)value,"%.1f",pDcChargingInfo->ChargingFee);
    DisplayValueToLcm(_Detail_Money_Num,value, sizeof(value));
}

void ShowCountDownTimer()
{
    int min,sec;
    uint8_t value[10] = {0};
    int tm = 120 - (GetClockTimeoutValue(pSysInfo->SystemTimeoutTimer) / uSEC_VAL);
    // GetClockTimeoutValue(pSysInfo->SystemTimeoutTimer) / uSEC_VAL
    min = tm/60;
    sec = tm%60;
    sprintf((char *)value,"%02d:%02d",min,sec);
    if (pSysInfo->SystemPage == _LCM_SUMMARY) {
        sprintf((char*)value, "");
        DisplayValueToLcm(_Count_Down_Time, (uint8_t*)value, sizeof(value));
    }
    else
        DisplayValueToLcm(_Count_Down_Time, (uint8_t *)value, sizeof(value));
}
unsigned long GetTimeoutValue(struct timeval _sour_time)
{
    struct timeval _end_time;
    gettimeofday(&_end_time, NULL);

    return 1000000 * (_end_time.tv_sec - _sour_time.tv_sec) + _end_time.tv_usec - _sour_time.tv_usec;
}
void ShowGunCountDownTimer()
{
    int min,sec;
    uint8_t value[10] = {0};
    pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(pSysInfo->CurGunSelected);
    int tm = 30 - (GetTimeoutValue(pDcChargingInfo->TimeoutTimer) / uSEC_VAL);
    // GetClockTimeoutValue(pSysInfo->SystemTimeoutTimer) / uSEC_VAL
    min = tm/60;
    sec = tm%60;
    sprintf((char *)value,"%02d:%02d",min,sec);
    DisplayValueToLcm(_Count_Down_Time, (uint8_t *)value, sizeof(value));
}
void ClearQrCode()
{
    char cmd[200];
    memset(cmd, 0, 200);
    DisplayValueToLcm(_QR_CODE_AUTHORIZE, cmd, 200);
}
void ChangeQrCode()
{
    char cmd[250];
    pDcChargingInfo = (struct ChargingInfoData*)GetDcChargingInfoData(pSysInfo->CurGunSelected);
    // https://nhoatcc.lineapid.tw/web/tologin?sn=ABC123&cid=2
    memset(cmd, '\0', 256);
    int len = sprintf(cmd, "https://nhoatcc.lineapid.tw/web/tologin?sn=%s&cid=%d", pSysConfig->SystemId, ShmDcCommonData->ConnectorId[pSysInfo->CurGunSelected]);
    DisplayValueToLcm(_QR_CODE_AUTHORIZE, cmd, len + 1);
}
void ShowProgressBar()
{
    /*
    for(int i = 0 ; i <= 19 ; i++) {
        ChangeDisplay2Value(_ProgressBar_LEVEL,_ICON_ProgressBar_10+i);
        usleep(100000);
    }*/
}
void ShowSummaryPage()
{
    float data;
    uint8_t value[10] = {0};
    char start_hr[3],start_min[3],end_hr[3],end_min[3];
    int t_hr;
    pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(pSysInfo->CurGunSelected);
    // Show Money
    data = pDcChargingInfo->ChargingFee;
    sprintf((char *)value,"%.1f",data);
    int discount,settlement = 0;
    //DisplayValueToLcm(_Summary_total_money, (uint8_t *)value, sizeof(value));
    //DisplayValueToLcm(_Summary_cal_Total_money, (uint8_t *)value, sizeof(value));
    ChangeDisplay2Value(_Summary_total_money, (int)pDcChargingInfo->ChargingFee);
    ChangeDisplay2Value(_Summary_cal_Total_money, (int)pDcChargingInfo->ChargingFee);
    /*
    log_info("start time:%s",pDcChargingInfo->StartDateTime);
    log_info("stop time:%s",pDcChargingInfo->StopDateTime);*/

    GetHrFormTimeString(pDcChargingInfo->StartDateTime,start_hr);
    GetMinFormTimeString(pDcChargingInfo->StartDateTime,start_min);
    GetHrFormTimeString(pDcChargingInfo->StopDateTime,end_hr);
    GetMinFormTimeString(pDcChargingInfo->StopDateTime,end_min);

    t_hr = atoi(start_hr) + (ShmDcCommonData->TzOffset / 60);
    if (t_hr >= 24)
        t_hr -= 24;
    ChangeDisplay2Value(_Summary_Start_time_hr, t_hr);
    ChangeDisplay2Value(_Summary_Start_time_min, atoi(start_min));
    t_hr = atoi(end_hr) + (ShmDcCommonData->TzOffset / 60);
    if (t_hr >= 24)
        t_hr -= 24;
    ChangeDisplay2Value(_Summary_end_time_hr, t_hr);
    ChangeDisplay2Value(_Summary_end_time_min, atoi(end_min));
    /*
    DisplayValueToLcm(_Summary_Start_time_hr, (uint8_t *)start_hr, sizeof(start_hr));
    DisplayValueToLcm(_Summary_Start_time_min, (uint8_t *)start_min, sizeof(start_min));
    DisplayValueToLcm(_Summary_end_time_hr, (uint8_t *)end_hr, sizeof(end_hr));
    DisplayValueToLcm(_Summary_end_time_min, (uint8_t *)end_min, sizeof(end_min));
    */

    uint8_t _min = (pDcChargingInfo->PresentChargedDuration)/60;
    uint8_t _sec = (pDcChargingInfo->PresentChargedDuration) % 60;
    /*
    sprintf((char *)value,"%d",min);
    DisplayValueToLcm(_Summary_duration_time, (uint8_t *)value, sizeof(value));
    */
    ChangeDisplay2Value(_Summary_duration_min, (int)_min);
    ChangeDisplay2Value(_Summary_duration_sec, (int)_sec);

    if (pDcChargingInfo->PresentChargedEnergy >= 0.1 &&
            pDcChargingInfo->PresentChargedEnergy <= ENERGY_MAX_KWH) {
        data = pDcChargingInfo->PresentChargedEnergy*10;
    } else
        data = 0;
    //sprintf((char *)value,"%.1f",data);
    ChangeDisplay2Value(_Summary_cap, data);
    //DisplayValueToLcm(_Summary_cap, (uint8_t *)value, sizeof(value));
    discount = ShmSelectGunInfo->PricesInfo[pSysInfo->CurGunSelected].Discount;
    sprintf((char *)value,"%.1f", discount);
    DisplayValueToLcm(_Summary_cal_discount, (uint8_t *)value, sizeof(value));
    settlement = pDcChargingInfo->ChargingFee - discount;
    sprintf((char *)value,"%.1f",settlement);
    DisplayValueToLcm(_Summary_cal_Settlement, (char *)value, sizeof(value));
    /*
    if(pSysInfo->CurGunSelected == LEFT_GUN_NUM) {
        sprintf((char *)value,"%.1f",ChargeMaxPower_0);
    } else if (pSysInfo->CurGunSelected == RIGHT_GUN_NUM) {
        sprintf((char *)value,"%.1f",ChargeMaxPower_1);
    }
    DisplayValueToLcm(_Summary_max_power, (uint8_t *)value, sizeof(value));
     */
    if (pSysInfo->CurGunSelected == LEFT_GUN_NUM) {
        ChangeDisplay2Value(_Summary_max_power, (int)ChargeMaxPower_0);
    }
    else if (pSysInfo->CurGunSelected == RIGHT_GUN_NUM) {
        ChangeDisplay2Value(_Summary_max_power, (int)ChargeMaxPower_1);

    }

    if (pDcChargingInfo->PowerConsumption >= 0.1 ) {
        data = pDcChargingInfo->PowerConsumption / pDcChargingInfo->PresentChargedDuration;
    } else
        data = 0;
    //sprintf((char *)value,"%.1f",data);
    ChangeDisplay2Value(_Summary_average_power, (int)data);
    //DisplayValueToLcm(_Summary_average_power, (uint8_t *)value, sizeof(value));
}
void ProcessPageInfo()
{
    if (pSysWarning->Level == WARN_LV_ER) {
    	pSysInfo->SystemPage = _LCM_MAINTAIN;
        if (ShmPrimaryMcuData->InputDet.bits.EmergencyButton)
            pSysInfo->SystemPage = _LCM_EMERGENCY;
        return;;
    }
    switch (pSysInfo->SystemPage) {
    case _LCM_VIEW:
        // Confirm Charging Gun Number.
        SetViewPage();
        break;
    case _LCM_DETAIL_VIEW:
        ShowGunCountDownTimer();
        SetDetailViewPage();
        break;
    case _LCM_START_SCAN:
        ChangeQrCode();
    case _LCM_STOP_RFID:
    case _LCM_STOP_APP:
        ShowSelectGunIcon();
        ShowCountDownTimer();
        break;
    case _LCM_START_AUTHORIZING:
    case _LCM_PRECHARGE:
    case _LCM_STOPPING:
        //ShowProgressBar();
        ChangeDisplay2Value(_Animation_Running, 1);
        break;
    case _LCM_START_AUTHORIZE_FAIL:
    case _LCM_STOP_RFID_FAIL:
    case _LCM_LINK_ERROR:
        ShowCountDownTimer();
        break;
    case _LCM_SUMMARY:
        ShowCountDownTimer();
        ShowSummaryPage();
        break;
    case _LCM_ERROR:
        break;
    case _LCM_MAINTAIN:
    	break;
    case _LCM_WAIT_PLUGIN:
    case _LCM_WAIT_PLUGOUT:
    	ShowSelectGunIcon();
        break;
    case _LCM_EMERGENCY:
        break;
    case _LCM_COMMUNICATION:
        ChangeDisplay2Value(_Animation_Communcation, 1);
        break;
    case _LCM_CHARGING_DETECT:
        ChangeDisplay2Value(_Animation_GFD, 1);
        break;
    case _LCM_PREPARECHARE:
        ChangeDisplay2Value(_Animation_Precharge, 1);
        break;
    }
}

void DemoFunction()
{
    int i;
    uint8_t value[10];
    struct timeb  SeqEndTime;
    struct tm *tm;
    switch (pSysInfo->PageIndex) {
        case __VIEW_ALL_IDLE_:
            memset(value, 0x00, sizeof(value));
            sprintf((char *)value,"1 A");
            DisplayValueToLcm(_LeftGun_location, (uint8_t *)value, sizeof(value));
            sprintf((char *)value,"1 B");
            DisplayValueToLcm(_RightGun_location, (uint8_t *)value, sizeof(value));
            sleep(1);

            ChangeDisplay2Value(_LeftGun_type_pic_U,_ICON_CCS2_GUN_U);
            ChangeDisplay2Value(_LeftGun_type_pic_L,_ICON_CCS2_GUN_L);
            ChangeDisplay2Value(_LeftGun_type_name,_ICON_CCS2_Name);
            ChangeDisplay2Value(_LeftGun_type_speed,_ICON_High_Speed);
            ChangeDisplay2Value(_RightGun_type_pic_U,_ICON_CCS2_GUN_U);
            ChangeDisplay2Value(_RightGun_type_pic_L,_ICON_CCS2_GUN_L);
            ChangeDisplay2Value(_RightGun_type_name,_ICON_CCS2_Name);
            ChangeDisplay2Value(_RightGun_type_speed,_ICON_High_Speed);
            sleep(1);
            ChangeDisplay2Value(_LeftGun_type_pic_U,_ICON_CCS1_GUN_U);
            ChangeDisplay2Value(_LeftGun_type_pic_L,_ICON_CCS1_GUN_L);
            ChangeDisplay2Value(_LeftGun_type_name,_ICON_CCS1_Name);
            ChangeDisplay2Value(_LeftGun_type_speed,_ICON_Speed);

            ChangeDisplay2Value(_RightGun_type_pic_U,_ICON_CCS1_GUN_U);
            ChangeDisplay2Value(_RightGun_type_pic_L,_ICON_CCS1_GUN_L);
            ChangeDisplay2Value(_RightGun_type_name,_ICON_CCS1_Name);
            ChangeDisplay2Value(_RightGun_type_speed,_ICON_Speed);
            break;
        case __VIEW_LEFT_CHARGE_:
            for(i=0;i<=100;i++) {
                ShowViewChargingSoc(LEFT_GUN_NUM,i);
                ShowViewChargingTime(LEFT_GUN_NUM,i);
                ShowViewCharingMoney(LEFT_GUN_NUM,i);
                ShowViewChargingPower(LEFT_GUN_NUM,i);
                ShowViewChargingEngery(LEFT_GUN_NUM,i);
                usleep(100000);
            }
            break;
        case __VIEW_RIGHT_CHARGE_:
            for(i=0;i<=100;i++) {
                ShowViewChargingSoc(RIGHT_GUN_NUM,i);
                ShowViewChargingTime(RIGHT_GUN_NUM,i);
                ShowViewCharingMoney(RIGHT_GUN_NUM,i);
                ShowViewChargingPower(RIGHT_GUN_NUM,i);
                ShowViewChargingEngery(RIGHT_GUN_NUM, i);
                usleep(100000);
            }
            break;
        case __VIEW_ALL_CHARGE_:
            for(i=0;i<=100;i++) {
                ShowViewChargingSoc(LEFT_GUN_NUM,i);
                ShowViewChargingTime(LEFT_GUN_NUM,i*60);
                ShowViewCharingMoney(LEFT_GUN_NUM,i);
                ShowViewChargingPower(LEFT_GUN_NUM,i);
                ShowViewChargingEngery(LEFT_GUN_NUM, i/10);

                ShowViewChargingSoc(RIGHT_GUN_NUM,i);
                ShowViewChargingTime(RIGHT_GUN_NUM,i);
                ShowViewCharingMoney(RIGHT_GUN_NUM,i);
                ShowViewChargingPower(RIGHT_GUN_NUM,i);
                ShowViewChargingEngery(RIGHT_GUN_NUM, i/10);
                usleep(100000);
            }
            break;
        case 7:
        case 9:
        case 23:
        case 24:
            break;
        case 11:
            for(i = 0 ; i <= 100 ; i++) {
               // RefreshProgressAnimation(_ICON_ProgressBar_10+((i/10)*2));
                uint8_t digits = i % 10;
                uint8_t tens = (i / 10) %10;
                uint8_t hundreds = i / 100;
                ChangeDisplay2Value(_Percent_Number_Digits,(short)_ICON_White_Num_0+digits);
                ChangeDisplay2Value(_Percent_Number_Tens,(short)_ICON_White_Num_0+tens);
                if (hundreds == 0 )
                    ChangeDisplay2Value(_Percent_Number_Hundreds,(short)_ICON_Empty);
                else
                    ChangeDisplay2Value(_Percent_Number_Hundreds,(short)_ICON_White_Num_1);
                sprintf((char *)value,"%03d",i);
                DisplayValueToLcm(_Detail_Power_Num, (uint8_t *)value, sizeof(value));
                DisplayValueToLcm(_Detail_Time_Num, (uint8_t *)value, sizeof(value));
                DisplayValueToLcm(_Detail_Cap_Num, (uint8_t *)value, sizeof(value));
                DisplayValueToLcm(_Detail_Money_Num, (uint8_t *)value, sizeof(value));
                if (i%2 == 0 ) {
                    ChangeDisplay2Value(_Confirm_Gun_Left_symbol,_ICON_CCS1_Symbol);
                    ChangeDisplay2Value(_Confirm_Gun_Right_symbol,_ICON_Empty);
                    memset(value, 0x00, sizeof(value));
                    DisplayValueToLcm(_Confirm_Gun_Right_name, (uint8_t *)value, sizeof(value));
                    sprintf((char *)value,"1 A");
                    DisplayValueToLcm(_Confirm_Gun_Left_name, (uint8_t *)value, sizeof(value));
                } else {
                    ChangeDisplay2Value(_Confirm_Gun_Left_symbol,_ICON_Empty);
                    ChangeDisplay2Value(_Confirm_Gun_Right_symbol,_ICON_CCS2_Symbol);
                    memset(value, 0x00, sizeof(value));
                    DisplayValueToLcm(_Confirm_Gun_Left_name, (uint8_t *)value, sizeof(value));
                    sprintf((char *)value,"1 B");
                    DisplayValueToLcm(_Confirm_Gun_Right_name, (uint8_t *)value, sizeof(value));
                }
                usleep(100000);
            }
            break;
        case 12:
        case 13:
        case 15:
        case 17:
        case 28:
            ftime(&SeqEndTime);
            SeqEndTime.time = time(NULL);
            tm = localtime(&SeqEndTime.time);

            memset(value, 0x00, sizeof(value));
            sprintf((char *)value,"%02d:%02d",tm->tm_hour,tm->tm_min);

            DisplayValueToLcm(_Count_Down_Time, (uint8_t *)value, sizeof(value));
            if (pSysInfo->PageIndex == 17 || pSysInfo->PageIndex == 28) {
                for (i = 0; i <= 100; i++) {
                    ChangeDisplay2Value(_Summary_total_money, i);
                    ChangeDisplay2Value(_Summary_cal_Total_money, i);
                    ChangeDisplay2Value(_Summary_Start_time_hr, i/60);
                    ChangeDisplay2Value(_Summary_Start_time_min, i%60);
                    ChangeDisplay2Value(_Summary_end_time_hr, i/60);
                    ChangeDisplay2Value(_Summary_end_time_min, i%60);
                    ChangeDisplay2Value(_Summary_duration_min, i);
                    ChangeDisplay2Value(_Summary_duration_sec, i%60);

                    ChangeDisplay2Value(_Summary_cap, i);
                    ChangeDisplay2Value(_Summary_cal_discount,i);
                    ChangeDisplay2Value(_Summary_cal_Settlement,i);
                    ChangeDisplay2Value(_Summary_max_power, i);
                    ChangeDisplay2Value(_Summary_average_power, i);
                    usleep(100000);
                }
            }
            break;
        case __START_AUTHORIZE_:
        case __PRE_CHARGE_:
        case __STOP_AUTHORIZE_:
            for( i = 0 ; i <= 20 ; i++) {
                //RefreshProgressAnimation(_ICON_ProgressBar_10);
                usleep(100000);
            }
            for( i = 0 ; i <= 20 ; i++) {
                //RefreshProgressAnimation(_ICON_ProgressBar_20);
                usleep(100000);
            }
            break;
        case 8:
        case 16:
        case 27:
        case 18:
        case 19:
        case 20:
        case 29:
        case 30:
            break;
        case 21:
            ShowCabientVersion();
            break;
        case 22:
            ShowDispenserVersion();
            break;
        case 25:
        case 26:
            break;
        case 5:
            pSysInfo->CurGunSelected = 0;
            ChangeQrCode();
            break;
        case 31:
            pSysInfo->CurGunSelected = 1;
            ChangeQrCode();
            break;
    }
}
void ShowCabientVersionDefaultText()
{
    char value[16];
    memset(value, 0x00, sizeof(value));
    sprintf((char *)value,"%s","Cabient:");
    DisplayValueToLcm(_Version_Cabient_Name_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","BootLoader:");
    DisplayValueToLcm(_Version_Cabient_BootLoader_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","Kernel Fw:");
    DisplayValueToLcm(_Version_Cabient_Kernel_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","CSU Fw:");
    DisplayValueToLcm(_Version_Cabient_CSU_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","Priamry Fw:");
    DisplayValueToLcm(_Version_Cabient_Priamry_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","Relay(0) Fw:");
    DisplayValueToLcm(_Version_Cabient_Relay0_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","Relay(1) Fw:");
    DisplayValueToLcm(_Version_Cabient_Relay1_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","Fan Fw:");
    DisplayValueToLcm(_Version_Cabient_Fan_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","IP Addr:");
    DisplayValueToLcm(_Version_Cabient_IPAddr_Text, (uint8_t *)value, sizeof(value));
    if (ShmDcCommonData->PSU_Number > 0 && ShmDcCommonData->PSU_Number <= 12) {
        sprintf((char *)value,"%s","Primary");
        DisplayValueToLcm(_Version_Cabient_Primary_Text, (uint8_t *)value, sizeof(value));
        sprintf((char *)value,"%s","Secondary");
        DisplayValueToLcm(_Version_Cabient_Secondary_Text, (uint8_t *)value, sizeof(value));
        for(uint8_t i = 0 ; i < ShmDcCommonData->PSU_Number ; i++) {
            sprintf((char *)value,"PSU(%d):",i+1);
            DisplayValueToLcm(_Version_Cabient_PSU1_Text+i*0x10, (uint8_t *)value, sizeof(value));
        }
    }
}
void ShowDispenserVersionDefautlText()
{
    char value[16];
    memset(value, 0x00, sizeof(value));
    sprintf((char *)value,"%s","Dispenser:");
    DisplayValueToLcm(_Version_Dispenser_Name_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","BootLoader:");
    DisplayValueToLcm(_Version_Dispenser_BootLoader_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","Kernel Fw:");
    DisplayValueToLcm(_Version_Dispenser_Kernel_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","CSU Fw:");
    DisplayValueToLcm(_Version_Dispenser_CSU_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","Relay Fw:");
    DisplayValueToLcm(_Version_Dispenser_Relay_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","Fan Fw:");
    DisplayValueToLcm(_Version_Dispenser_Fan_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","Prim Fw:");
    DisplayValueToLcm(_Version_Dispenser_Priamry_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","LCM Hw:");
    DisplayValueToLcm(_Version_Dispenser_LCM_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","LED Fw:");
    DisplayValueToLcm(_Version_Dispenser_LED_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","Connector(0):");
    DisplayValueToLcm(_Version_Dispenser_Connector0_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","Connector(1):");
    DisplayValueToLcm(_Version_Dispenser_Connector1_Text, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s","IP Addr:");
    DisplayValueToLcm(_Version_Dispenser_IPAddr_Text, (uint8_t *)value, sizeof(value));
}
void ShowCabientVersion()
{
    char value[16];
    memset(value, 0x00, sizeof(value));
    sprintf((char *)value,"%s",ShmDcCommonData->CabinetModelName);
    DisplayValueToLcm(_Version_Cabient_Model_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",ShmDcCommonData->CabinetBoolLoaderVersion);
    DisplayValueToLcm(_Version_Cabient_BootLoader_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",ShmDcCommonData->CabinetKernelVersion);
    DisplayValueToLcm(_Version_Cabient_Kernel_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",ShmDcCommonData->CabinetRFSystemVersion);
    DisplayValueToLcm(_Version_Cabient_CSU_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",ShmDcCommonData->CabinetPrimaryVersion);
    DisplayValueToLcm(_Version_Cabient_Priamry_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",ShmDcCommonData->CabinetRelay0Version);
    DisplayValueToLcm(_Version_Cabient_Relay0_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",ShmDcCommonData->CabinetRelay1Version);
    DisplayValueToLcm(_Version_Cabient_Relay1_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",ShmDcCommonData->CabinetFanVersion);
    DisplayValueToLcm(_Version_Cabient_Fan_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",ShmDcCommonData->CabinetIPAddr);
    DisplayValueToLcm(_Version_Cabient_IPAddr_value, (uint8_t *)value, sizeof(value));
    if (ShmDcCommonData->PSU_Number > 0 && ShmDcCommonData->PSU_Number < 12) {
        for(uint8_t i = 0 ; i < ShmDcCommonData->PSU_Number ; i++) {
            if (i>=6) {
                sprintf((char *)value,"%s",ShmDcCommonData->PsuVer[(i-6)].DCVersion);
                DisplayValueToLcm(_Version_Cabient_PSU_Prim7_value+(i-6)*0x10, (uint8_t *)value, sizeof(value));
                sprintf((char *)value,"%s",ShmDcCommonData->PsuVer[(i-6)].FPCVersion);
                DisplayValueToLcm(_Version_Cabient_PSU_Sec7_value+(i-6)*0x10, (uint8_t *)value, sizeof(value));
                continue;
            }
            sprintf((char *)value,"%s",ShmDcCommonData->PsuVer[i].DCVersion);
            DisplayValueToLcm(_Version_Cabient_PSU_Prim1_value+i*0x10, (uint8_t *)value, sizeof(value));
            sprintf((char *)value,"%s",ShmDcCommonData->PsuVer[i].FPCVersion);
            DisplayValueToLcm(_Version_Cabient_PSU_Sec1_value+i*0x10, (uint8_t *)value, sizeof(value));
        }
    }
}
void ShowDispenserVersion()
{
    char value[32];
    memset(value, 0x00, sizeof(value));
    sprintf((char *)value,"%s",pSysConfig->ModelName);
    DisplayValueToLcm(_Version_Dispenser_Model_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",pSysInfo->CsuBootLoadFwRev);
    DisplayValueToLcm(_Version_Dispenser_BootLoader_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",pSysInfo->CsuKernelFwRev);
    DisplayValueToLcm(_Version_Dispenser_Kernel_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",pSysInfo->CsuRootFsFwRev);
    DisplayValueToLcm(_Version_Dispenser_CSU_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",pSysInfo->RelayModuleFwRev);
    DisplayValueToLcm(_Version_Dispenser_Relay_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",pSysInfo->FanModuleFwRev);
    DisplayValueToLcm(_Version_Dispenser_Fan_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",pSysInfo->CsuPrimFwRev);
    DisplayValueToLcm(_Version_Dispenser_Priamry_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",pSysInfo->LcmHwRev);
    DisplayValueToLcm(_Version_Dispenser_LCM_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",pSysInfo->LedModuleFwRev);
    DisplayValueToLcm(_Version_Dispenser_LED_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",pSysInfo->Connector1FwRev);
    DisplayValueToLcm(_Version_Dispenser_Connector0_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",pSysInfo->Connector2FwRev);
    DisplayValueToLcm(_Version_Dispenser_Connector1_value, (uint8_t *)value, sizeof(value));
    sprintf((char *)value,"%s",pSysConfig->Eth0Interface.EthIpAddress);
    DisplayValueToLcm(_Version_Dispenser_IPAddr_value, (uint8_t *)value, sizeof(value));
}
void InformationShow()
{
    is_show = true;
    if (_showInformIndex == 0 ) {
        pSysInfo->PageIndex = __SHOW_CABIENT_VERSION;
    } else {
        pSysInfo->PageIndex = __SHOW_DISPENSER_VERASION;
        ShowDispenserVersion();
    }
}

int main(void)
{
    bool defaulttext = false;
    if (CreateAllCsuShareMemory() == FAIL) {
        log_error("create share memory error");
        return FAIL;
    }

    MappingGunChargingInfo("LCM Control Task");

    pSysConfig = (struct SysConfigData *)GetShmSysConfigData();
    pSysInfo = (struct SysInfoData *)GetShmSysInfoData();
    pSysWarning = (struct WARNING_CODE_INFO *)GetShmSysWarningInfo();
    ShmFanModuleData = (struct FanModuleData *)GetShmFanModuleData();;
    ShmPrimaryMcuData = (struct PrimaryMcuData *)GetShmPrimaryMcuData();
    ShmSelectGunInfo = (SelectGunInfo *)GetShmSelectGunInfo();
    ShmDcCommonData = (DcCommonInfo *)GetShmDcCommonData();
    struct StatusCodeData *ShmStatusCodeData = (struct StatusCodeData *)GetShmStatusCodeData();;
    struct ChargingInfoData *pDcChargingInfo_0 = (struct ChargingInfoData *)GetDcChargingInfoData(LEFT_GUN_NUM);
    struct ChargingInfoData *pDcChargingInfo_1 = (struct ChargingInfoData *)GetDcChargingInfoData(RIGHT_GUN_NUM);
    _port = CreateCommunicationLcmPort();
    ChangeBackLight(true);
    _totalCount = pSysConfig->TotalConnectorCount;
    _everyPageRollChange = 0;
    //Initialization();
    //printf("_LCM_COMPLETE ");
    //ChangeToOtherPage(_LCM_COMPLETE);
    //return 0;
    uint8_t index = 1;
    ShmDcCommonData->PSU_Number = 12;
    while (_port != -1) {
        if (strcmp((char *)pSysInfo->LcmHwRev, moduleName) != 0x00) {
            GetCurrentPage();
            sleep(1);

            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.LcmModuleCommFail = true;

        } else {
            // Show Default Text
            if (!defaulttext) {
                ShowCabientVersionDefaultText();
                ShowDispenserVersionDefautlText();
                defaulttext = true;
            }
            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.LcmModuleCommFail = false;


            if(pSysConfig->TotalConnectorCount>=2) {
                if (pDcChargingInfo_0->SystemStatus == S_IDLE) {
                    ChargeMaxPower_0 = 0;
                } else if (pDcChargingInfo_0->SystemStatus == S_CHARGING) {
                    if (pDcChargingInfo_0->PresentChargingPower > ChargeMaxPower_0 &&
                            pDcChargingInfo_0->PresentChargingPower >= 0 &&
                            pDcChargingInfo_0->PresentChargingPower <= POWER_MAX_KW)
                        ChargeMaxPower_0 = pDcChargingInfo_0->PresentChargingPower;
                }
                if (pDcChargingInfo_1->SystemStatus == S_IDLE) {
                    ChargeMaxPower_1 = 0;
                } else if (pDcChargingInfo_1->SystemStatus == S_CHARGING) {
                    if (pDcChargingInfo_1->PresentChargingPower > ChargeMaxPower_1 &&
                            pDcChargingInfo_1->PresentChargingPower >= 0 &&
                            pDcChargingInfo_1->PresentChargingPower <= POWER_MAX_KW)
                        ChargeMaxPower_1 = pDcChargingInfo_1->PresentChargingPower;
                }
            }

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

            // 換頁處理
            //GetCurrentPage(); //DS60-120 add
            /*
            if (pSysConfig->ShowInformation == YES && pSysInfo->SystemPage == _LCM_VIEW) {
                InformationShow();
                ChangeToOtherPage(pSysInfo->PageIndex);
                usleep(100000);
                continue;
            } else {
                if (is_show)
                    _showInformIndex >= 1 ? _showInformIndex = 0 : _showInformIndex++;
                is_show = false;
            }*/
            
            GetCurrentPage(); //DS60-120 add
            ChangeCurPage();
            
            /*
            pSysInfo->PageIndex = _LCM_WAIT_PLUGIN;
            GetCurrentPage();
            ChangeToOtherPage(_LCM_WAIT_PLUGIN);
            GetCurrentPage();
            DemoFunction();
            index >= 34 ? index = 1 : index++;
            */
            //usleep(100000);
            usleep(1000000);

        }
    } //while

    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.LcmModuleCommFail = true;

    log_info("Close LCM Uart Port");
    CloseCommunicationLcmPort();

    return FAIL;
}