csu3_am335x/EVSE/Projects/DD360ComBox/Apps/ModuleEvComm/Module_EvRxComm.c

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>

#include <sys/stat.h>

#include <linux/can.h>
#include <linux/can/raw.h>

#include "../Config.h"
#include "../Log/log.h"
#include "../Define/define.h"
#include "../ShareMemory/shmMem.h"
#include "Ev_Comm.h"
#include "Module_EvComm.h"

//------------------------------------------------------------------------------
static struct SysConfigData *pSysConfig = NULL;
static struct SysInfoData *pSysInfo = NULL;
static struct WARNING_CODE_INFO *pSysWarning = NULL;
static struct AlarmCodeData *pAlarmCode = NULL;
static struct CHAdeMOData *ShmCHAdeMOData = NULL;
static struct GBTData *ShmGBTData = NULL;
static struct CcsData *ShmCcsData = NULL;
static DcCommonInfo *ShmDcCommonData = NULL;

//------------------------------------------------------------------------------
extern bool AbnormalStopAnalysis(uint8_t gun_index, uint8_t *errCode);

//------------------------------------------------------------------------------
static uint8_t getMaxConnectTempAndChiller(uint8_t headTemp1, uint8_t headTemp2,
        uint8_t chillerTemp1, uint8_t chillerTemp2)
{
    uint8_t i = 0;
    uint8_t tempSource[4] = {headTemp1, headTemp2, chillerTemp1, chillerTemp2};
    uint8_t maxTemp = 0;

    if (headTemp1 == UNDEFINED_TEMP &&
            headTemp2 == UNDEFINED_TEMP &&
            chillerTemp1 == UNDEFINED_TEMP &&
            chillerTemp2 == UNDEFINED_TEMP) {
        return UNDEFINED_TEMP;
    }

    //先取得第一個非UNDEFINED_TEMP的值
    for (i = 0; i < (sizeof(tempSource) / sizeof(uint8_t)); i++) {
        if (tempSource[i] != UNDEFINED_TEMP) {
            maxTemp = tempSource[i];
            break;
        }
    }

    //找最大的溫度值
    for (i = 0; i < (sizeof(tempSource) / sizeof(uint8_t)); i++) {
        if (tempSource[i] != UNDEFINED_TEMP) {
            if (maxTemp < tempSource[i]) {
                maxTemp = tempSource[i];
            }
        }
    }

    return maxTemp;
}

static uint8_t getMaxConnectTemp(uint8_t headTemp1, uint8_t headTemp2)
{
    uint8_t maxTemp = 0;

    if (headTemp1 == UNDEFINED_TEMP &&
            headTemp2 == UNDEFINED_TEMP) {
        return UNDEFINED_TEMP;
    }

    if (headTemp1 != UNDEFINED_TEMP) {
        maxTemp = headTemp1;
    } else {
        headTemp1 = 0;
    }

    if (headTemp2 != UNDEFINED_TEMP) {
        if (headTemp2 > headTemp1) {
            maxTemp = headTemp2;
        }
    }

    return maxTemp;
}

static float ReadAdcVolt(uint8_t AdcChannel)
{
    //AIN0=CCS GUN Temp 1
    //AIN1=CCS GUN Temp 2
    //AIN2=CCS_Proximity/2
    //AIN3=pilot voltage
    int fd = -1;
    uint8_t str[64] = {0};
    uint8_t AdcValue[8] = {'\0'};
    //uint32_t AdcValue = 0;

    if (AdcChannel > 7) {
        return -1;
    }

    sprintf((char *)str, "/sys/bus/iio/devices/iio\:device0/in_voltage%d_raw", AdcChannel);
    fd = open((char *)str, O_RDONLY);
    read(fd, AdcValue, 4);

    close(fd);

    return (1.8 * atoi((char *)&AdcValue[0])) / 4095;
    //return (1.8 * atoi((char *)&AdcValue)) / 4095;
}

static void getChillerTemperature(ChillerTemp *chillerTemp)
{
    uint8_t i = 0;
    float adcVoltage = 0.0;
    ChillerTemp *pChillerTemp = (ChillerTemp *)chillerTemp;

    for (i = 0; i < 2; i++) {
        adcVoltage = 0.0;
        adcVoltage =  ReadAdcVolt(i);
        if ((adcVoltage <= 0.9) && (adcVoltage >= 0.8)) { //0 ~ -40
            pChillerTemp->Temp[i] = ((adcVoltage - 0.908) * 500) + 60;
            //log_info("1 adcVoltage = %f", (adcVoltage - 0.9) * 500);
        } else if ((adcVoltage <= 1.07) && (adcVoltage > 0.9)) {
            pChillerTemp->Temp[i] = ((adcVoltage - 0.91) * 705.88) + 60;
            //log_info("2 adcVoltage = %f", (adcVoltage - 0.9) * 500);
        } else {
            pChillerTemp->Temp[i] = 195;
        }

        //CcsConnectorTemp1 = ReadAdcVolt(i);
        //if ((CcsConnectorTemp1 <= 0.9) && (CcsConnectorTemp1 >= 0.8)) { //0 ~ -40
        //    CcsConnectorTemp1 = (CcsConnectorTemp1 - 0.9) * 500;
        //} else if ((CcsConnectorTemp1 <= 1.07) && (CcsConnectorTemp1 > 0.9)) {
        //    CcsConnectorTemp1 = (CcsConnectorTemp1 - 0.9) * 705.88;
        //} else {
        //    CcsConnectorTemp1 = 195;    //not available
        //}
        //CcsConnectorTemp |= ((unsigned int)(CcsConnectorTemp1 + 60) & 0xFF) << (i * 8); //0x00(-60)~0xFE(194)
    }
}


static void AddrAssignment(uint8_t *data)
{
    uint8_t target_number[8];
    uint8_t index = 0x00;
    struct ChargingInfoData *pDcChargingInfo = NULL;

    memcpy(target_number, data, sizeof(target_number));
    index = *(data + 4);

    if (pSysConfig->TotalConnectorCount == 1) {
        index = 0x01;
    }

    //if (CheckUniqNumber(index)) {
    pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(index - 1);
    //DS60-120 add
    if (pDcChargingInfo->Type == _Type_Chademo) {
        log_info("Set EV board info : (Chademo) TargetAddr = %d \n", index);
    } else if (pDcChargingInfo->Type == _Type_CCS_2) {
        log_info("Set EV board info : (CCS) TargetAddr = %d \n", index);
    } else if (pDcChargingInfo->Type == _Type_GB) {
        log_info("Set EV board info : (GB) TargetAddr = %d \n", index);
    }
    //log_info("EV board id = %x \n", index); //DS60-120 remove

    //log_info("target_number[0] = %x \n", target_number[0]);
    //log_info("target_number[1] = %x \n", target_number[1]);
    //log_info("target_number[2] = %x \n", target_number[2]);
    //log_info("target_number[3] = %x \n", target_number[3]);
    //log_info("target_number[4] = %x \n", target_number[4]);

    log_info("SetTargetAddr = %d, type = %d \n", index, pDcChargingInfo->Type);
    SetTargetAddr(target_number, index);
    //}
}

void CANReceiver(int fd)
{
    pid_t canRecPid;

    canRecPid = fork();

    if (canRecPid == 0) {
        int isContinue = 1;
        int nbytes;
        int intCmd;
        uint8_t _index = 0;
        uint8_t recvID = 0;
        uint8_t targetGun = 0x00;
        uint8_t gunTypeIndex = 0;
        uint8_t ver[16] = {0};
        struct can_frame frame;
        ChillerTemp chiilerTemp = {0};
        struct ChargingInfoData *pDcChargingInfo = NULL;

        pSysConfig = (struct SysConfigData *)GetShmSysConfigData();
        pSysInfo = (struct SysInfoData *)GetShmSysInfoData();
        pSysWarning = (struct WARNING_CODE_INFO *)GetShmSysWarningInfo();

        pAlarmCode = (struct AlarmCodeData *)GetShmAlarmCodeData();

        ShmCHAdeMOData = (struct CHAdeMOData *)GetShmCHAdeMOData();
        ShmGBTData = (struct GBTData *)GetShmGBTData();
        ShmCcsData = (struct CcsData *)GetShmCcsData();
        ShmDcCommonData = (DcCommonInfo *)GetShmDcCommonData();

        while (isContinue) {
            memset(&frame, 0, sizeof(struct can_frame));
            nbytes = read(fd, &frame, sizeof(struct can_frame));
            if (nbytes <= 0) {
                usleep(10000);
                continue;
            }

            recvID = 0;
            targetGun = 0x00;
            intCmd = (int) (frame.can_id & CAN_EFF_MASK);

            if (intCmd == ADDRESS_REQ) {
                //ShmDcCommonData->CcsVersion = _CCS_VERSION_CHECK_TAG_V013S0;
                AddrAssignment(frame.data);
                continue;
            }

            intCmd = (int) (frame.can_id & CAN_EFF_MASK & 0xFFFFFF00);

            recvID = ((uint8_t) (frame.can_id & 0x000000FF)); // 0x01 or 0x02

            for (_index = 0; _index < pSysConfig->TotalConnectorCount; _index++) {                    // 假設有找到回應的 Index
                pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(_index);

                //if (gun_count == 1 &&
                //        _chargingData[_index]->Type == _Type_CCS_2 &&
                //        ShmDcCommonData->CcsVersion == _CCS_VERSION_CHECK_TAG_V015S0) {
                //    target -= 1;
                //}

                if (pDcChargingInfo->Evboard_id == recvID) {
                    targetGun = _index;
                    break;
                }
            }

            if (targetGun < 0 || targetGun >= CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY) {
                log_info("EvComm (CANReceiver) : Target index = %x is < 0 or > QUANTITY \n", targetGun);
                usleep(10000);
                continue;
            }
            //else if (gun_count == 1 && targetGun == 0 && findIndex == 1 &&
            //           ShmDcCommonData->CcsVersion == _CCS_VERSION_CHECK_TAG_V015S0) {
            //    // 這樣的條件下~ 也是單槍 CCS 舊版本的狀況 : 因為舊版 CCS 不會 timeout, then send request id
            //    ShmDcCommonData->CcsVersion = _CCS_VERSION_CHECK_TAG_V013S0;
            //}

            if (intCmd == 256) {
                log_info("EvComm command = 256");
                usleep(10000);
                continue;
            }

            pDcChargingInfo = (struct ChargingInfoData *)GetDcChargingInfoData(targetGun);
            gunTypeIndex = pDcChargingInfo->type_index;
            //log_info("intCmd = %x\r\n", intCmd);
            switch (intCmd) {
            case NOTIFICATION_EV_STATUS:
                if (pDcChargingInfo->ConnectorPlugIn != frame.data[0]) {
                    if (frame.data[0] == PLUG) {
                        log_info("Conn %d, Plugin. \n", targetGun);
                    } else if (frame.data[0] == UNPLUG) {
                        log_info("Conn %d, Unplug. \n", targetGun);
                    } else {
                        log_info("Conn %d, None Check. (%d) \n", targetGun, frame.data[0]);
                    }
                }

                pDcChargingInfo->ConnectorPlugIn = frame.data[0];
                pDcChargingInfo->PilotVoltage = frame.data[1];

                //log_info("index = %d, ConnectorPlugIn = %x, data[0] = %x \n",
                //         targetGun,
                //         pDcChargingInfo->ConnectorPlugIn,
                //         frame.data[0]);

                //log_info("ConnectorPlugIn = %x \n", (-120 + frame.data[1]) / 10);
                break;

            case ACK_EV_FW_VERSION:
                memset(ver, 0, sizeof(ver));
                if (pDcChargingInfo->Type == _Type_Chademo) {
                    memcpy(ver, frame.data, frame.can_dlc);
                    memcpy(ShmCHAdeMOData->evse[gunTypeIndex].version, ver, ARRAY_SIZE(ver));
                    ShmCHAdeMOData->evse[gunTypeIndex].SelfTest_Comp = PASS;
                    //log_info("chademo ver. : %s\n", ShmCHAdeMOData->evse[gunTypeIndex].version);
                } else if (pDcChargingInfo->Type == _Type_GB) {
                    memcpy(ver, frame.data, frame.can_dlc);
                    memcpy(ShmGBTData->evse[gunTypeIndex].version, ver, ARRAY_SIZE(ver));
                    ShmGBTData->evse[gunTypeIndex].SelfTest_Comp = PASS;
                    //log_info("gbt ver. : %s\n", ShmGBTData->evse[gunTypeIndex].version);
                } else if (pDcChargingInfo->Type == _Type_CCS_2) {
                    if (ShmCcsData->CommProtocol == _CCS_COMM_V2GMessage_DIN70121) {
                        memcpy(ver, frame.data, frame.can_dlc); //DS60-120 add

                        //for (uint8_t _vCount = 0, _vPoint = 0; _vCount < frame.can_dlc; _vCount++) {//DS60-120 remove
                        /*if (_vCount % 2 == 0 && _vCount != 0)
                        {
                            ver[_vCount + _vPoint] = 0x2E;
                            _vPoint++;
                        }*/

                        //ver[_vCount + _vPoint] = frame.data[_vCount];
                        //}

                        memcpy(&ShmCcsData->V2GMessage_DIN70121[gunTypeIndex].version, ver, ARRAY_SIZE(ver));
                        ShmCcsData->V2GMessage_DIN70121[gunTypeIndex].SelfTest_Comp = PASS;
                        //log_info("CCS FW = %s \n", ShmCcsData->V2GMessage_DIN70121[gunTypeIndex].version);
                    }
                }

                if (targetGun == 0) {
                    memset(pSysInfo->Connector1FwRev,
                           0,
                           sizeof(pSysInfo->Connector1FwRev));
                    memcpy(pSysInfo->Connector1FwRev, ver, ARRAY_SIZE(ver));
                } else if (targetGun == 1) {
                    memset(pSysInfo->Connector2FwRev,
                           0,
                           sizeof(pSysInfo->Connector2FwRev));
                    memcpy(pSysInfo->Connector2FwRev, ver, ARRAY_SIZE(ver));
                }
                break;

            case ACK_EV_HW_VERSION:
                //log_info("Get EV HW = %s \n", frame.data);
                break;

            case ACK_GET_OUTPUT_REQ:
                //DS60-120 add
                if ((pDcChargingInfo->SystemStatus >= S_PREPARING_FOR_EV &&
                        pDcChargingInfo->SystemStatus <= S_CHARGING) ||
                        (pDcChargingInfo->SystemStatus >= S_CCS_PRECHARGE_ST0 &&
                         pDcChargingInfo->SystemStatus <= S_CCS_PRECHARGE_ST1)) {
                    if (pDcChargingInfo->EvBatteryStartSoc <= 0) {
                        pDcChargingInfo->EvBatteryStartSoc = frame.data[1];
                    }

                    if (frame.data[1] > pDcChargingInfo->EvBatterySoc) {
                        pDcChargingInfo->EvBatterySoc = frame.data[1];
                    }
                }
                //pDcChargingInfo->EvBatterySoc = frame.data[1]; //DS60-120 remove

                //Jerry add set voltage limit
                pDcChargingInfo->EvBatterytargetVoltage = (float)((frame.data[3] << 8) + frame.data[2]) / 10;
                if (pDcChargingInfo->EvBatterytargetVoltage > (GetMaxChargingVol(targetGun) * 0.1)) {
                    pDcChargingInfo->EvBatterytargetVoltage = (GetMaxChargingVol(targetGun) * 0.1);
                }
                //printf("id = %d, EvBatterytargetVoltage = %.2f\r\n", targetGun, pDcChargingInfo->EvBatterytargetVoltage);

                //Jerry add set currency limit
                pDcChargingInfo->EvBatterytargetCurrent = (float)((frame.data[5] << 8) + frame.data[4]) / 10;
                if (pDcChargingInfo->EvBatterytargetCurrent > (GetMaxCharginigCur(targetGun) * 0.1)) {
                    pDcChargingInfo->EvBatterytargetCurrent = (GetMaxCharginigCur(targetGun) * 0.1);
                }
                //printf("id = %d, EvBatterytargetCurrent = %.2f\r\n", targetGun, pDcChargingInfo->EvBatterytargetCurrent);

                pDcChargingInfo->RemainChargingDuration = ((short) frame.data[7] << 8) + (short) frame.data[6];
                //printf("RemainChargingDuration = %d\r\n",  pDcChargingInfo->RemainChargingDuration);

                if (pDcChargingInfo->Type == _Type_Chademo) {
                    //if (ShmCHAdeMOData->ev[gunTypeIndex].EvDetection != frame.data[0])
                    {
                        ShmCHAdeMOData->ev[gunTypeIndex].PresentMsgFlowStatus = frame.data[0];
                    }

                    ShmCHAdeMOData->ev[gunTypeIndex].EvDetection = frame.data[0];
                    ShmCHAdeMOData->ev[gunTypeIndex].SOC = pDcChargingInfo->EvBatterySoc;
                    ShmCHAdeMOData->ev[gunTypeIndex].TargetBatteryVoltage = (pDcChargingInfo->EvBatterytargetVoltage * 10);
                    ShmCHAdeMOData->ev[gunTypeIndex].ChargingCurrentRequest = (pDcChargingInfo->EvBatterytargetCurrent * 10);
                } else if (pDcChargingInfo->Type == _Type_GB) {
                    //if (ShmGBTData->ev[gunTypeIndex].EvDetection != frame.data[0])
                    {
                        ShmGBTData->ev[gunTypeIndex].PresentMsgFlowStatus = frame.data[0];
                    }

                    ShmGBTData->ev[gunTypeIndex].EvDetection = frame.data[0];
                    ShmGBTData->ev[gunTypeIndex].SOC = pDcChargingInfo->EvBatterySoc;
                    ShmGBTData->ev[gunTypeIndex].TargetBatteryVoltage = (pDcChargingInfo->EvBatterytargetVoltage * 10);
                    ShmGBTData->ev[gunTypeIndex].ChargingCurrentRequest = (pDcChargingInfo->EvBatterytargetCurrent * 10);
                } else if (pDcChargingInfo->Type == _Type_CCS_2) {
                    if (ShmCcsData->CommProtocol == _CCS_COMM_V2GMessage_DIN70121) {
                        ShmCcsData->V2GMessage_DIN70121[gunTypeIndex].PresentMsgFlowStatus = frame.data[0];
                    }
                }

                //log_info("EvBatterytargetVoltage = %f \n", pDcChargingInfo->EvBatterytargetVoltage);
                //log_info("EvBatterytargetCurrent = %f \n", pDcChargingInfo->EvBatterytargetCurrent);
                //log_info("BatteryVoltage = %d \n",
                //         ShmCHAdeMOData->ev[_chargingData[target]->type_index].TargetBatteryVoltage);
                //log_info("CurrentRequest = %d \n",
                //         ShmCHAdeMOData->ev[_chargingData[target]->type_index].ChargingCurrentRequest);
                break;

            case ACK_GET_EV_BATTERY_INFO:
                //_chargingData[target].EvACorDCcharging = frame.data[0];
                //_chargingData[target]->TotalBatteryCap = ((float) frame.data[4] << 8) + (short) frame.data[3];
                pDcChargingInfo->EvBatteryMaxVoltage = (((short) frame.data[4] << 8) + (short) frame.data[3]) / 10;
                //_chargingData[target]->EvBatteryMaxCurrent = ((float) frame.data[4] << 8) + (short) frame.data[3];
                //_chargingData[target].MaxiBatteryCurrent = ((short) frame.data[6] << 8) + (short) frame.data[5];
                if (pDcChargingInfo->Type == _Type_Chademo) {
                    ShmCHAdeMOData->ev[gunTypeIndex].TotalBatteryCapacity = ((short) frame.data[2] << 8) + (short) frame.data[1];
                    ShmCHAdeMOData->ev[gunTypeIndex].MaxiBatteryVoltage = pDcChargingInfo->EvBatteryMaxVoltage;

                    //log_info("EvBatteryMaxVoltage = %f \n", _chargingData[target]->EvBatteryMaxVoltage);
                    //log_info("TotalBatteryCapacity = %d \n", ShmCHAdeMOData->ev[_chargingData[target]->type_index].TotalBatteryCapacity);
                    //log_info("MaxiBatteryVoltage = %d \n", ShmCHAdeMOData->ev[_chargingData[target]->type_index].MaxiBatteryVoltage);
                } else if (pDcChargingInfo->Type == _Type_GB) {
                    ShmGBTData->ev[gunTypeIndex].TotalBatteryCapacity = ((short) frame.data[2] << 8) + (short) frame.data[1];
                    ShmGBTData->ev[gunTypeIndex].MaxiBatteryVoltage = pDcChargingInfo->EvBatteryMaxVoltage;
                }
                //else if (pDcChargingInfo->Type == _Type_CCS_2) {
                //}
                break;

            case ACK_GET_MISCELLANEOUS_INFO:
                pDcChargingInfo->GunLocked = frame.data[0];
                pDcChargingInfo->PilotVoltage = (float)(-120 + frame.data[3]) / 10;

                if (pDcChargingInfo->Type == _Type_Chademo) {
                    ShmCHAdeMOData->evse[gunTypeIndex].ConnectorTemperatureP = frame.data[1];
                    ShmCHAdeMOData->evse[gunTypeIndex].ConnectorTemperatureN = frame.data[2];
                    ShmCHAdeMOData->evse[gunTypeIndex].EvboardStatus = frame.data[7];
                } else if (pDcChargingInfo->Type == _Type_GB) {
                    ShmGBTData->evse[gunTypeIndex].ConnectorTemperatureP = frame.data[1];
                    ShmGBTData->evse[gunTypeIndex].ConnectorTemperatureN = frame.data[2];
                    ShmGBTData->evse[gunTypeIndex].EvboardStatus = frame.data[7];
                }
                /*else if (pDcChargingInfo->Type == _Type_CCS_2) {
                if (ShmCcsData->CommProtocol == _CCS_COMM_V2GMessage_DIN70121) {
                    //ShmCcsData->V2GMessage_DIN70121[gunTypeIndex]. .ConnectorTemperatureP = frame.data[1];
                    //ShmCcsData->V2GMessage_DIN70121[gunTypeIndex]. .ConnectorTemperatureN = frame.data[2];
                }
                }*/
#if 1
                //memset((uint8_t)&chiilerTemp, 0, sizeof(ChillerTemp));
                if (targetGun == 0 &&
                        ((strncmp((char *)&pSysConfig->ModelName[7], "V", 1) == 0) ||
                         (strncmp((char *)&pSysConfig->ModelName[7], "F", 1) == 0))
                   ) {
                    getChillerTemperature(&chiilerTemp);

                    pDcChargingInfo->ConnectorTemp = getMaxConnectTempAndChiller(
                                                         frame.data[1],
                                                         frame.data[2],
                                                         chiilerTemp.Temp[0],
                                                         chiilerTemp.Temp[1]);

                    //log_info("%d chiller Temp1 = %d, temp2 = %d, head Temp1 = %d, Temp2 = %d\r\n",
                    //         targetGun,
                    //         chiilerTemp.Temp[0],
                    //         chiilerTemp.Temp[1],
                    //         frame.data[1],
                    //         frame.data[2]);
                } else if (targetGun == 1 &&
                           ((strncmp((char *)&pSysConfig->ModelName[9], "V", 1) == 0) ||
                            (strncmp((char *)&pSysConfig->ModelName[9], "F", 1) == 0))
                          ) {
                    getChillerTemperature(&chiilerTemp);

                    pDcChargingInfo->ConnectorTemp = getMaxConnectTempAndChiller(
                                                         frame.data[1],
                                                         frame.data[2],
                                                         chiilerTemp.Temp[0],
                                                         chiilerTemp.Temp[1]);

                    //log_info("%d chillerTemp1 = %d, temp2 = %d, head Temp1 = %d, Temp2 = %d\r\n",
                    //         targetGun,
                    //         chiilerTemp.Temp[0],
                    //         chiilerTemp.Temp[1],
                    //         frame.data[1],
                    //         frame.data[2]);
                } else {
                    pDcChargingInfo->ConnectorTemp = getMaxConnectTemp(frame.data[1], frame.data[2]);
                    //log_info("connector temperature = %d\r\n",
                    //         pDcChargingInfo->ConnectorTemp);
                }
#endif //0
                if (ShmDcCommonData->SystemModeChange == YES) {
                    ShmDcCommonData->SystemModeChange = NO;
                    //log_info("EvboardStatus = %x \n",
                    //         ShmCHAdeMOData->evse[gunTypeIndex].EvboardStatus);
                    //log_info("ConnectorPlug locked = %x \n",
                    //         frame.data[0]);

                    //if (frame.data[1] >= GUN_OTP_VALUE ||
                    //        frame.data[2] >= GUN_OTP_VALUE ||
                    //        chiilerTemp.Temp[0] >= GUN_OTP_VALUE ||
                    //        chiilerTemp.Temp[1] >= GUN_OTP_VALUE) {
                    log_info("Conn %d Temp 0= %d, Temp 1 = %d, chillerTemp1 = %d, chillerTemp2 = %d\r\n",
                             targetGun,
                             frame.data[1],
                             frame.data[2],
                             chiilerTemp.Temp[0],
                             chiilerTemp.Temp[1]);
                    //}
                    //log_info("PilotVoltage = %x \n", (-120 + frame.data[3]) / 10);
                }
                break;

            case ACK_EVSE_ISOLATION_STATUS:
                break;

            case ACK_EVSE_PRECHAGE_INFO:
                pDcChargingInfo->PrechargeStatus = frame.data[0];
                break;

            case NOTIFICATION_EV_STOP:
                // 車端要求停止
                if ((pDcChargingInfo->SystemStatus >= S_REASSIGN_CHECK && //DS60-120 add
                        pDcChargingInfo->SystemStatus <= S_TERMINATING) ||
                        (pDcChargingInfo->SystemStatus >= S_CCS_PRECHARGE_ST0 &&
                         pDcChargingInfo->SystemStatus <= S_CCS_PRECHARGE_ST1)) {
                    // frame.data[0] : 0x01 => normal stop, 0x02 => ev emergency stop
                    log_info("(%d) NOTIFICATION_EV_STOP err level = %d-----------------------------\n",
                             targetGun,
                             frame.data[0]);
                    if (frame.data[0] == 0x02) {
                        if (AbnormalStopAnalysis(targetGun, frame.data + 1) == true) {
                            pDcChargingInfo->StopChargeFlag = YES;
                        } else {
                            pDcChargingInfo->NormalStopChargeFlag = YES;
                        }
                    } else {
                        AbnormalStopAnalysis(targetGun, frame.data + 1);
                        pDcChargingInfo->NormalStopChargeFlag = YES;
                    }
                }
                break;

            default:
                log_info("EV board = %d, Ack none defined. intCmd = %d  \n", targetGun, intCmd);
                break;
            }//switch

            usleep(10000);
        }//while
    }
}