csu3_am335x/EVSE/Projects/DD360ComBox/Apps/ReadCmdline.c

/*
 * Main.c
 *
 *  Created on: 2019年8月6日
 *      Author: 7564
 */


#include <sys/time.h>
#include <sys/timeb.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/shm.h>
#include <sys/mman.h>
#include <linux/wireless.h>
#include <arpa/inet.h>
#include <netinet/in.h>

#include <unistd.h>
#include <stdarg.h>
#include <stdio.h>      /*標準輸入輸出定義*/
#include <stdlib.h>     /*標準函數庫定義*/
#include <stdint.h>
#include <unistd.h>     /*Unix 標準函數定義*/
#include <fcntl.h>      /*檔控制定義*/
#include <termios.h>    /*PPSIX 終端控制定義*/
#include <errno.h>      /*錯誤號定義*/
#include <errno.h>
#include <string.h>
#include <time.h>
#include <ctype.h>
#include <ifaddrs.h>
#include <math.h>
#include <stdbool.h>
#include "./Define/define.h"
#include "Config.h"
#include "./SelectGun/SelectGun.h"

#define DEFAULT_AC_INDEX    2

#define AUTORUN_STEP1_TIME_START            140             // Minutes
#define AUTORUN_STEP1_TIME_END              150
#define AUTORUN_STEP2_TIME_START            210
#define AUTORUN_STEP2_TIME_END              410
#define AUTORUN_END_TIME                    480
#define AUTORUN_CYCLE_COUNT                 30

#define TTY_PATH            "/dev/tty"
#define STTY_US             "stty raw -echo -F "
#define STTY_DEF            "stty -raw echo -F "

uint8_t _curAutoRunCount = 0;
uint8_t _usingAutoRun = 0;
struct timeval _autoTime;

struct SysConfigAndInfo *ShmSysConfigAndInfo = NULL;
struct StatusCodeData *ShmStatusCodeData = NULL;
struct PrimaryMcuData *ShmPrimaryMcuData = NULL;
struct CHAdeMOData *ShmCHAdeMOData = NULL;
struct CcsData *ShmCcsData = NULL;
struct GBTData *ShmGBTData = NULL;
struct FanModuleData *ShmFanModuleData = NULL;
struct RelayModuleData *ShmRelayModuleData = NULL;
struct LedModuleData *ShmLedModuleData = NULL;
struct PsuData *ShmPsuData = NULL;
struct OCPP16Data *ShmOCPP16Data = NULL;
static SelectGunInfo *ShmSelectGunInfo = NULL; //Jerry add

struct ChargingInfoData *_chargingData[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];
struct ChargingInfoData *ac_chargingInfo[AC_QUANTITY];

char *msg = "state : get gun state (index) \n"
            "card : scanning card (x) : \n"
            "gun : get gun plugit state (index) \n"
            "lock : get gun locked state (index) \n"
            "self : self test state (x) \n"
            "ver : ver of board (407 or index or rb or fan) \n"
            "ac : get ac relay state (x) \n";

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

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

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

    return false;
}

bool FindAcChargingInfoData(uint8_t target, struct ChargingInfoData **acChargingData)
{
    if (target < AC_QUANTITY) {
        acChargingData[target] = &ShmSysConfigAndInfo->SysInfo.AcChargingData[target];
        return true;
    }

    return false;
}

int InitShareMemory()
{
    int result = PASS;
    int MeterSMId;

    //initial ShmSysConfigAndInfo
    if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo),  0777)) < 0) {
        result = FAIL;
    } else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        result = FAIL;
    }

    //initial ShmStatusCodeData
    if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  0777)) < 0) {
        result = FAIL;
    } else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        result = FAIL;
    }

    if (CHAdeMO_QUANTITY > 0) {
        if ((MeterSMId = shmget(ShmCHAdeMOCommKey, sizeof(struct CHAdeMOData),
                                IPC_CREAT | 0777)) < 0) {
            result = FAIL;
        } else if ((ShmCHAdeMOData = shmat(MeterSMId, NULL, 0))
                   == (void *) - 1) {
            result = FAIL;
        }
    }

    if (CCS_QUANTITY > 0) {
        if ((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData),
                                IPC_CREAT | 0777)) < 0) {
            result = FAIL;
        } else if ((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
            result = FAIL;
        }
    }

    if (GB_QUANTITY > 0) {
        if ((MeterSMId = shmget(ShmGBTCommKey, sizeof(struct GBTData),
                                IPC_CREAT | 0777)) < 0) {
            return 0;
        } else if ((ShmGBTData = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
            return 0;
        }
        memset(ShmGBTData, 0, sizeof(struct GBTData));
    }

    if ((MeterSMId = shmget(ShmPrimaryMcuKey, sizeof(struct PrimaryMcuData), IPC_CREAT | 0777)) < 0) {
        result = FAIL;
    } else if ((ShmPrimaryMcuData = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        result = FAIL;
    }

    if ((MeterSMId = shmget(ShmFanBdKey, sizeof(struct FanModuleData),  IPC_CREAT | 0777)) < 0) {
        result = FAIL;
    } else if ((ShmFanModuleData = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        result = FAIL;
    }

    if ((MeterSMId = shmget(ShmRelayBdKey, sizeof(struct RelayModuleData),  IPC_CREAT | 0777)) < 0) {
        result = FAIL;
    } else if ((ShmRelayModuleData = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        result = FAIL;
    }

    if ((MeterSMId = shmget(ShmLedBdKey, sizeof(struct LedModuleData),  0777)) < 0) {
        result = FAIL;
    } else if ((ShmLedModuleData = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        result = FAIL;
    }

    if ((MeterSMId = shmget(ShmPsuKey, sizeof(struct PsuData),  IPC_CREAT | 0777)) < 0) {
        result = FAIL;
    } else if ((ShmPsuData = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        result = FAIL;
    }

    //creat ShmOCPP16Data
    if ((MeterSMId = shmget(ShmOcppModuleKey, sizeof(struct OCPP16Data), IPC_CREAT | 0777)) < 0) {
        return FAIL;
    } else if ((ShmOCPP16Data = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        return FAIL;
    }

    if ((MeterSMId = shmget(ShmSelectGunInfoKey, sizeof(SelectGunInfo), IPC_CREAT | 0777)) < 0) {
        return FAIL;
    } else if ((ShmSelectGunInfo = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        return FAIL;
    }

    return result;
}

unsigned long GetTimeoutValue(struct timeval _sour_time)
{
    struct timeval _end_time;
    gettimeofday(&_end_time, NULL);

    return (_end_time.tv_sec - _sour_time.tv_sec);
}

void RunStatusProc(char *v1, char *v2)
{
    printf("OrderCharging = %d \n", ShmSysConfigAndInfo->SysInfo.OrderCharging);
    printf("WaitForPlugit = %d \n", ShmSysConfigAndInfo->SysInfo.WaitForPlugit);
    if (strcmp(v1, "ac") == 0) {
        if (!FindAcChargingInfoData(0, &ac_chargingInfo[0])) {
            printf("FindChargingInfoData (AC) false \n");
        }
        printf("AC Status = %d \n", ac_chargingInfo[0]->ConnectorPlugIn);
        return;
    }

    int _index = atoi(v1);
    if (_index <= 1) {
        if (!FindChargingInfoData(_index, &_chargingData[0])) {
            printf ("FindChargingInfoData error\n");
            return;
        }

        if (strcmp(v2, "-1") == 0 || strcmp(v2, "") == 0) {
            // get
            printf ("index = %x, status = %x (%d)\n", _index, _chargingData[_index]->SystemStatus, _chargingData[_index]->IsAvailable);
            printf ("SystemTimeoutFlag = %d, PageIndex = %d\n",
                    ShmSysConfigAndInfo->SysInfo.SystemTimeoutFlag, ShmSysConfigAndInfo->SysInfo.PageIndex);
        } else {
            // set
            _chargingData[_index]->SystemStatus = atoi(v2);
        }
    } else {
        if (!FindAcChargingInfoData(0, &ac_chargingInfo[0])) {
            printf("FindChargingInfoData (AC) false \n");
        }

        if (strcmp(v2, "-1") == 0 || strcmp(v2, "") == 0) {
            // get
            printf ("AC Type, status = %x (%d)\n", ac_chargingInfo[0]->SystemStatus, ac_chargingInfo[0]->IsAvailable);
        } else {
            // set
            ac_chargingInfo[0]->SystemStatus = atoi(v2);
        }
    }
}

void RunCardProc(char *v1, char *v2)
{
    if (strcmp(v1, "-1") == 0 || strcmp(v1, "") == 0) {
        if (ShmSysConfigAndInfo->SysInfo.WaitForPlugit) {
            ShmSysConfigAndInfo->SysInfo.WaitForPlugit = 0x00;
            printf ("SysInfo.WaitForPlugit = %x \n", ShmSysConfigAndInfo->SysInfo.WaitForPlugit);
        } else {
            ShmSysConfigAndInfo->SysInfo.WaitForPlugit = 0x01;
            printf ("SysInfo.WaitForPlugit = %x \n", ShmSysConfigAndInfo->SysInfo.WaitForPlugit);
        }
    } else {
        strcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, "");
        memcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, v1, strlen(v1));
        ShmSysConfigAndInfo->SysConfig.UserId[strlen(v1)] = '\0';
        printf("StartUserId = %s \n", ShmSysConfigAndInfo->SysConfig.UserId);
    }
}

void RunGunPlugitProc(char *v1, char *v2)
{
    if (strcmp(v1, "ac") == 0) {
        if (!FindAcChargingInfoData(0, &ac_chargingInfo[0])) {
            printf("FindChargingInfoData (AC) false \n");
        }

        if (strcmp(v2, "-1") == 0 || strcmp(v2, "") == 0) {
            // get
            printf("ConnectorPlugIn = %d \n", ac_chargingInfo[0]->ConnectorPlugIn);
        } else {
            // set
            ac_chargingInfo[0]->ConnectorPlugIn = atoi(v2);
        }
        return;
    }

    int _index = atoi(v1);
    if (!FindChargingInfoData(_index, &_chargingData[0])) {
        printf("FindChargingInfoData error\n");
        return;
    }

    if (strcmp(v2, "-1") == 0 || strcmp(v2, "") == 0) {
        // get
        printf("index = %x, plug it = %x\n", _index, _chargingData[_index]->ConnectorPlugIn);
    } else {
        // set
        _chargingData[_index]->ConnectorPlugIn = atoi(v2);
    }
}

void GetGunLockStatusProc(char *v1, char *v2)
{
    int _index = atoi(v1);
    if (!FindChargingInfoData(_index, &_chargingData[0])) {
        printf("FindChargingInfoData error\n");
        return;
    }
    if (strcmp(v2, "-1") != 0 && strcmp(v2, "") != 0) {
        _chargingData[_index]->GunLocked = atoi(v2);
    }

    printf("Gun Locked Status = %d \n", _chargingData[_index]->GunLocked);
}

void SetSystemIDProc()
{
    char *systemId = "Alston_Test";
    memcpy(&ShmSysConfigAndInfo->SysConfig.SystemId, systemId, strlen(systemId));
}

void RunSelfProc()
{
    printf("self test status = %x\n", ShmSysConfigAndInfo->SysInfo.SelfTestSeq);
}

void GetFwVerProc(char *v1)
{
    if (strcmp(v1, "407") == 0) {
        printf("407 FW Version = %s \n", ShmPrimaryMcuData->version);
    } else if (strcmp(v1, "0") == 0 || strcmp(v1, "1") == 0) {
        int _index = atoi(v1);

        if (_index == 0) {
            printf("Gun 0 FW Version = %s \n", ShmSysConfigAndInfo->SysInfo.Connector1FwRev);
        } else if (_index == 1) {
            printf("Gun 1 FW Version = %s \n", ShmSysConfigAndInfo->SysInfo.Connector2FwRev);
        }
    } else if (strcmp(v1, "rb") == 0) {
        printf("RB Version = %s \n", ShmSysConfigAndInfo->SysInfo.RelayModuleFwRev);
    } else if (strcmp(v1, "fan") == 0) {
        printf("FAN Version = %s \n", ShmSysConfigAndInfo->SysInfo.FanModuleFwRev);
    } else if (strcmp(v1, "dc") == 0) {
        printf("DC Main Version = %s \n", ShmSysConfigAndInfo->SysInfo.CsuRootFsFwRev);
    } else if (strcmp(v1, "led") == 0) {
        printf("LED Version = %s \n", ShmSysConfigAndInfo->SysInfo.LedModuleFwRev);
    } else if (strcmp(v1, "ac") == 0) {
        if (!FindAcChargingInfoData(0, &ac_chargingInfo[0])) {
            printf("FindChargingInfoData (AC) false \n");
        }
        printf("AC Version = %s \n", ac_chargingInfo[0]->version);
    }
}

void CreateOneError(char *v1)
{
    int value = atoi(v1);

    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputOVP = value;
    ShmSysConfigAndInfo->SysConfig.BillingData.isBilling = value;
}

void GetAuthorizeFlag(char *v1)
{
    if (strcmp(v1, "-1") == 0 || strcmp(v1, "") == 0) {
        printf("AuthorizeFlag = %d \n", ShmSysConfigAndInfo->SysInfo.AuthorizeFlag);
    } else {
        ShmSysConfigAndInfo->SysInfo.AuthorizeFlag = atoi(v1);
    }
}

void GetRelayStatus(char *v1)
{
    int _index = atoi(v1);
    if (!FindChargingInfoData(_index, &_chargingData[0])) {
        printf("FindChargingInfoData error\n");
        return;
    }

    printf("RelayK1K2Status = %d \n", _chargingData[_index]->RelayK1K2Status);
    printf("RelayKPK2Status = %d \n", _chargingData[_index]->RelayKPK2Status);
}

void FwUpdateFlagProc()
{
    ShmSysConfigAndInfo->SysInfo.FirmwareUpdate = 0x01;
}

void CheckAcStatus(char *v1)
{
    if (strcmp(v1, "-1") == 0 || strcmp(v1, "") == 0) {
        printf("AC Status = %d \n", ShmSysConfigAndInfo->SysInfo.AcContactorStatus);
    }
}

void SetCableChkStatus(char *v1, char *v2)
{
    int _index = atoi(v1);
    if (!FindChargingInfoData(_index, &_chargingData[0])) {
        printf ("FindChargingInfoData error\n");
        return;
    }

    _chargingData[_index]->GroundFaultStatus = atoi(v2);
}

void SetChargingInfoCCID(char *v1, char *v2)
{
    int _index = atoi(v1);
    if (!FindChargingInfoData(_index, &_chargingData[0])) {
        printf ("FindChargingInfoData error\n");
        return;
    }

    memcpy(_chargingData[_index]->EVCCID, v2, 8);
    _chargingData[_index]->EVCCID[8] = '\0';
}

void SetPowerValue(char *v1, char *v2)
{
    int _index = atoi(v1);
    float _Current = atof(v2);
    // 盲沖的時候才允許使用~
    if (_chargingData[_index]->Type != 9) {
        return;
    }

    if (!FindChargingInfoData(_index, &_chargingData[0])) {
        printf ("FindChargingInfoData error\n");
        return;
    }

    _chargingData[_index]->EvBatterytargetCurrent = _Current;
}

void GetSystemInfo()
{
    printf ("ModelName = %s \n", ShmSysConfigAndInfo->SysConfig.ModelName);
    printf ("SerialNumber = %s \n", ShmSysConfigAndInfo->SysConfig.SerialNumber);
    printf ("InternetConn = %d \n", ShmSysConfigAndInfo->SysInfo.InternetConn);

    printf ("MaxChargingPower = %d, MaxChargingCurrent = %d \n",
            ShmSysConfigAndInfo->SysConfig.MaxChargingPower,
            ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent);
}

void ChangeGunNum()
{
    if (ShmSysConfigAndInfo->SysInfo.CurGunSelected + 1 < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount) {
        ShmSysConfigAndInfo->SysInfo.CurGunSelected += 1;
        ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc = NO_DEFINE;
    } else if (ShmSysConfigAndInfo->SysConfig.AcConnectorCount > 0 &&
               ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc == NO_DEFINE) {
        ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc = DEFAULT_AC_INDEX;
    } else {
        ShmSysConfigAndInfo->SysInfo.CurGunSelected = 0;
        ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc = NO_DEFINE;
    }
}

void GetGunSelectedNum(char *v1)
{
    if (strcmp(v1, "-1") == 0 || strcmp(v1, "") == 0) {
        if (AC_QUANTITY > 0 &&
                ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc != NO_DEFINE) {
            printf("connector select changed = AC \n");
        } else {
            printf("connector selected = %d \n", ShmSysConfigAndInfo->SysInfo.CurGunSelected);
        }
    } else {
        int _index = atoi(v1);
        if (_index <= 1) {
            ShmSysConfigAndInfo->SysInfo.CurGunSelected = _index;
            ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc = NO_DEFINE;
            printf("connector select changed = %d \n", _index);
        } else if (AC_QUANTITY > 0) {
            ShmSysConfigAndInfo->SysInfo.CurGunSelectedByAc = DEFAULT_AC_INDEX;
            printf("connector select changed = AC \n");
        }
    }
}

void SetFanSpeed(char *v1)
{
    int speed = atoi(v1);

    ShmFanModuleData->TestFanSpeed = speed;
}

void GetFanSpeed()
{
    printf("ShmFanModuleData->PresentFan1Speed = %d \n", ShmFanModuleData->PresentFan1Speed);
    printf("ShmFanModuleData->PresentFan2Speed = %d \n", ShmFanModuleData->PresentFan2Speed);
    printf("ShmFanModuleData->PresentFan3Speed = %d \n", ShmFanModuleData->PresentFan3Speed);
    printf("ShmFanModuleData->PresentFan4Speed = %d \n", ShmFanModuleData->PresentFan4Speed);
}

void SetDebugMode(char *v1)
{
    int mode = atoi(v1);

    ShmSysConfigAndInfo->SysConfig.SwitchDebugFlag = mode;
}

void SetGFDMode(char *v1)
{
    int mode = atoi(v1);

    ShmSysConfigAndInfo->SysConfig.AlwaysGfdFlag = mode;
}

void GetPsuTemp()
{
    for (uint8_t index = 0; index < ShmPsuData->GroupCount; index++) {
        for (uint8_t count = 0; count < ShmPsuData->PsuGroup[index].GroupPresentPsuQuantity; count++) {
            printf("PSU Temp = %d \n", ShmPsuData->PsuGroup[index].PsuModule[count].ExletTemp);
        }
    }
}

void GetAcInputVol()
{
    printf("L1N_L12 = %f, L2N_L23 = %f, L3N_L31 = %f \n",
           ShmSysConfigAndInfo->SysInfo.InputVoltageR,
           ShmSysConfigAndInfo->SysInfo.InputVoltageS,
           ShmSysConfigAndInfo->SysInfo.InputVoltageT);
}

void GetPsuInformation(char *v1, char *v2, char *v3)
{
    printf("**********************AC Contact needed*************************\n");
    if (strcmp(v1, "count") == 0) {
        for (int i = 0; i < 4; i++) {
            printf("Group Index = %d, Module Count = %d \n", i, ShmPsuData->PsuGroup[i].GroupPresentPsuQuantity);
        }
    } else if (strcmp(v1, "ver") == 0) {
        for (int i = 0; i < ShmPsuData->SystemPresentPsuQuantity; i++) {
            printf("Psu Index = %d, PriVersion = %s, SecVersion = %s \n",
                   i, ShmPsuData->PsuVersion[i].FwPrimaryVersion, ShmPsuData->PsuVersion[i].FwSecondVersion);
        }

        for (int i = 0; i < ShmPsuData->GroupCount; i++) {
            for (int j = 0; j < ShmPsuData->PsuGroup[i].GroupPresentPsuQuantity; j++) {
                printf("Group Index = %d, Psu Index = %d, Version = %s \n",
                       i, j, ShmPsuData->PsuGroup[i].PsuModule[j].FwVersion);
            }
        }
    } else if (strcmp(v1, "cap") == 0) {
        for (int i = 0; i < ShmPsuData->GroupCount; i++) {
            printf("Group Index = %d, MaxCur = %d, Power = %d \n",
                   i, ShmPsuData->PsuGroup[i].GroupAvailableCurrent, ShmPsuData->PsuGroup[i].GroupAvailablePower);
        }
    } else if (strcmp(v1, "input") == 0) {
        for (int i = 0; i < ShmPsuData->GroupCount; i++) {
            for (uint8_t count = 0; count < ShmPsuData->PsuGroup[i].GroupPresentPsuQuantity; count++) {
                printf("gp = %d, Index = %d, volR = %d, volS = %d, volT = %d \n",
                       i, count,
                       ShmPsuData->PsuGroup[i].PsuModule[count].InputVoltageL1,
                       ShmPsuData->PsuGroup[i].PsuModule[count].InputVoltageL2,
                       ShmPsuData->PsuGroup[i].PsuModule[count].InputVoltageL3);
            }
        }
    } else if (strcmp(v1, "output") == 0) {
        for (int i = 0; i < ShmPsuData->GroupCount; i++) {
            printf("Group Index = %d, OutputV = %d, OutputC = %d \n",
                   i, ShmPsuData->PsuGroup[i].GroupPresentOutputVoltage, ShmPsuData->PsuGroup[i].GroupPresentOutputCurrent);
        }

        for (int i = 0; i < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; i++) {
            if (!FindChargingInfoData(i, &_chargingData[0])) {
                printf ("FindChargingInfoData error\n");
                continue;
            }

            printf("Form RB : Group Index = %d, OutputV = %f \n",
                   i, _chargingData[i]->FireChargingVoltage);
        }
    } else if (strcmp(v1, "test") == 0) {
        int mode = atoi(v2);

        if (mode >= _TEST_MODE && mode <= _TEST_MODE) {
            ShmPsuData->Work_Step = mode;
        }
    } else if (strcmp(v1, "out") == 0) {
        float vol = atof(v2);
        float cur = atof(v3);

        if (ShmPsuData->Work_Step >= _TEST_MODE && ShmPsuData->Work_Step <= _TEST_MODE) {
            if (!FindChargingInfoData(0, &_chargingData[0])) {
                printf ("FindChargingInfoData error\n");
                return;
            }
            _chargingData[0]->EvBatterytargetVoltage = vol;
            _chargingData[0]->EvBatterytargetCurrent = cur;
        }
    }
    printf("*************************************************\n");
}

void GetConnectorCapInfo(char *v1)
{
    int _GunIndex = atoi(v1);

    if (!FindChargingInfoData(_GunIndex, &_chargingData[0])) {
        printf ("FindChargingInfoData error\n");
        return;
    }

    printf ("Charger Max Current = %d, Max Power = %d \n",
            ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent * 10,
            ShmSysConfigAndInfo->SysConfig.MaxChargingPower * 10);

    printf ("Index = %d, MaxPow = %f, MaxVol = %f, MaxCur = %f\n",
            _GunIndex,
            _chargingData[_GunIndex]->RealMaxPower,
            _chargingData[_GunIndex]->RealMaxVoltage,
            _chargingData[_GunIndex]->RealMaxCurrent);
}

static void get_char(char *word)
{
    fd_set rfds;
    struct timeval tv;

    FD_ZERO(&rfds);
    FD_SET(0, &rfds);
    tv.tv_sec = 0;
    tv.tv_usec = 10; //wait input timout time

    //if input
    if (select(1, &rfds, NULL, NULL, &tv) > 0) {
        fgets(word, 128, stdin);
    }
}

static void setConfirmSelGun(uint8_t selGun)
{
    if (selGun == LEFT_GUN_NUM && ShmSelectGunInfo->SelGunInfo.LeftGun == SEL_GUN_RELEASE) {
        ShmSelectGunInfo->SelGunInfo.LeftGun = SEL_GUN_CONFIRM;
        //printf("confirmSelGun left\r\n");
    } else if (selGun == RIGHT_GUN_NUM && ShmSelectGunInfo->SelGunInfo.RightGun == SEL_GUN_RELEASE) {
        ShmSelectGunInfo->SelGunInfo.RightGun = SEL_GUN_CONFIRM;
        //printf("confirmSelGun right\r\n");
    }
}

void RunUnconditionalChargeIndex1(char *v1, char *v2, char *v3)
{
    int _GunIndex;
    uint8_t gunIndex = 0;
    uint8_t stopChg = 0;
    uint8_t curGun = 0;
    float _Voltage;
    float _Current;
    uint8_t PreviousSystemStatus[2] = {0xff};

    if (strcmp(v1, "auto") == EQUAL) {
        _usingAutoRun = 0x01;
        _GunIndex = 0;
        _Voltage = 500;
        _Current = (ShmSysConfigAndInfo->SysConfig.MaxChargingPower * 1000) / _Voltage;
    } else {
        _usingAutoRun = 0x00;
        _GunIndex = atoi(v1);
        _Voltage = atof(v2);
        _Current = atof(v3);
    }

    if (!FindChargingInfoData(_GunIndex, &_chargingData[0])) {
        printf ("FindChargingInfoData error\n");
        return;
    }

    printf("Power = %d, ReqVoltage = %f, ReqCurrent = %f\n",
           ShmSysConfigAndInfo->SysConfig.MaxChargingPower,
           _Voltage,
           _Current);

    if (_Voltage > 1000 || _Voltage < 50) {
        printf ("Input Voltage over range\n");
        return;
    }

//    if(_Current > 100 || _Current < 2){
//
//        printf ("Input Current over range\n");
//        return;
//    }

    //測試期間先跳過自我測試 _STEST_COMPLETE = 0xfe
    //ShmSysConfigAndInfo->SysInfo.SelfTestSeq = 0xfe;

    //kill ev task
    system("killall Module_EvComm");

    //_Voltage = (_Voltage * 10);
    //_Current = (_Current * 10);

    //system(STTY_US TTY_PATH);

    ShmSysConfigAndInfo->SysInfo.CurGunSelected = _GunIndex;

    while (true) {
        curGun = ShmSysConfigAndInfo->SysInfo.CurGunSelected;

        //fix gun 1
        switch (_chargingData[curGun]->SystemStatus) {
        case S_IDLE:
            if (PreviousSystemStatus[curGun] != _chargingData[curGun]->SystemStatus) {
                PreviousSystemStatus[curGun] = _chargingData[curGun]->SystemStatus;
#if defined DD360Audi
                setConfirmSelGun(curGun);
#endif //defined DD360Audi

                strcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, "AutoStartCharging");
                _chargingData[curGun]->ConnectorPlugIn = 1;
                printf ("[UnconditionalCharge - S_IDLE]\n");
                _chargingData[curGun]->Type = 9;

            }
            if (ShmOCPP16Data->SpMsg.bits.AuthorizeConf == 1) {
                ShmSysConfigAndInfo->SysInfo.StartToChargingFlag = 0x01;
                _chargingData[curGun]->SystemStatus = S_PREPARNING;
            }
            break;

        case S_PREPARNING:
            if (PreviousSystemStatus[curGun] != _chargingData[curGun]->SystemStatus) {
                PreviousSystemStatus[curGun] = _chargingData[curGun]->SystemStatus;

                printf ("[UnconditionalCharge - S_PREPARNIN]\n");

                //等待 AC Relay 搭上且找到模組 (main 在此 statue 其它 task 會去做完)
                printf ("wait find module\n");

            }
            //main 會在此階段判斷以下資料跳到下一個 state
            //用來得知 AC 是否有搭上 (搭上模組的資訊才會出來) 因為每次  AC_Contactor
            //ShmPsuData->SystemPresentPsuQuantity;
            //ShmPsuData->PsuGroup[gun_index].GroupPresentPsuQuantity;
            //ShmPsuData->PsuGroup[gun_index].GroupAvailablePower;
            //_chargingData[gun_index]->AvailableChargingPower;

            //等待 AC Relay 搭上且找到模組 (main 在此 statue 其它 task 會去做完)
            //sleep(10);

            //清除 main timeout 機制
            _chargingData[curGun]->TimeoutFlag = 0;
            //不論是什麼 type 的槍都固意設成 Chademo 不跑 Prechage step
            _chargingData[curGun]->Type = 9;
            break;

        case S_PREPARING_FOR_EV:
            if (PreviousSystemStatus[curGun] != _chargingData[curGun]->SystemStatus) {
                PreviousSystemStatus[curGun] = _chargingData[curGun]->SystemStatus;

                printf ("[UnconditionalCharge - S_PREPARING_FOR_EV]\n");
                printf ("ReqVoltage = %f, ReqCurrent = %f \n", _Voltage * 10, _Current * 10);

            }
            //清除 main timeout 機制
            _chargingData[curGun]->TimeoutFlag = 0;
            //不論是什麼 type 的槍都固意設成 Chademo 不跑 Prechage step
            _chargingData[curGun]->Type = 9;

            //充電電壓電流
            _chargingData[curGun]->EvBatterySoc             = 50;
            _chargingData[curGun]->EvBatterytargetVoltage   = 500;
            _chargingData[curGun]->EvBatterytargetCurrent   = 2;
            _chargingData[curGun]->AvailableChargingCurrent = 1000;

            //****** 注意~此行為是防止 K1K2 先開導到無法升壓 ( Relay Board 在此 state 還未搭上 K1K2 )
            //確定模組己升壓完成
            //if(_chargingData[curGun]->PresentChargingVoltage <=  (3000+500) &&
            //  _chargingData[curGun]->PresentChargingVoltage >=  (3000-500) )
            {
                printf ("Precharge Done = %f \n",
                        _chargingData[curGun]->PresentChargingVoltage);
                //EV done
                _chargingData[curGun]->SystemStatus = S_PREPARING_FOR_EVSE;
            }
            break;

        case S_PREPARING_FOR_EVSE:
            if (PreviousSystemStatus[curGun] != _chargingData[curGun]->SystemStatus) {
                PreviousSystemStatus[curGun] = _chargingData[curGun]->SystemStatus;

                printf ("[UnconditionalCharge - S_PREPARING_FOR_EVSE]\n");

            }
            //printf ("tar vol = %d \n", _Voltage);
            //printf ("tar cur = %d \n", _Current);

            //清除 main timeout 機制
            _chargingData[curGun]->TimeoutFlag = 0;
            //不論是什麼 type 的槍都固意設成 Chademo 不跑 Prechage step
            _chargingData[curGun]->Type = 9;

            //充電電壓電流
            _chargingData[curGun]->EvBatterySoc = 50;
            _chargingData[curGun]->EvBatterytargetVoltage = 500;
            _chargingData[curGun]->EvBatterytargetCurrent = 2;
            _chargingData[curGun]->AvailableChargingCurrent = 1000;

            //printf ("tar vol_ = %d \n", _chargingData[curGun]->EvBatterytargetVoltage);
            // printf ("tar cur_ = %d \n", _chargingData[curGun]->EvBatterytargetCurrent);

            //****** 注意~此行為是防止 K1K2 先開導到無法升壓 ( Relay Board 在此 state 還未搭上 K1K2 )
            //確定模組己升壓完成
            if (_chargingData[curGun]->GroundFaultStatus == 0x01 ||
                    _chargingData[curGun]->GroundFaultStatus == 0x03) {
                printf ("First Ground Fault State (%d)\n",
                        _chargingData[curGun]->GroundFaultStatus);
                printf ("Wait K1K2 = %f \n", _chargingData[curGun]->PresentChargingVoltage);
                sleep(5);
                //EV done
                _chargingData[curGun]->SystemStatus = S_CHARGING;
            } else if (_chargingData[curGun]->GroundFaultStatus > 0x02) {
                printf ("First Ground Fault check Fail (%d)\n",
                        _chargingData[curGun]->GroundFaultStatus);
                _chargingData[curGun]->SystemStatus = S_TERMINATING;
            }
            break;

        case S_CHARGING:
            if (PreviousSystemStatus[curGun] != _chargingData[curGun]->SystemStatus) {
                PreviousSystemStatus[curGun] = _chargingData[curGun]->SystemStatus;

                if (_usingAutoRun == 0x00) {
                    //充電電壓電流
                    _chargingData[curGun]->EvBatterytargetVoltage = _Voltage;
                    _chargingData[curGun]->EvBatterytargetCurrent = _Current;
                } else {
                    _curAutoRunCount = 0;
                    gettimeofday(&_autoTime, NULL);
                }

                _chargingData[curGun]->EvBatterySoc = 50;
                _chargingData[curGun]->AvailableChargingCurrent = 1000;

                printf ("[UnconditionalCharge - S_CHARGING]\n");
            }

            if (_usingAutoRun == 0x01) {
                if (((GetTimeoutValue(_autoTime)) >= AUTORUN_STEP1_TIME_START * 60 &&
                        (GetTimeoutValue(_autoTime)) <= AUTORUN_STEP1_TIME_END * 60) ||
                        ((GetTimeoutValue(_autoTime)) >= AUTORUN_STEP2_TIME_START * 60 &&
                         (GetTimeoutValue(_autoTime)) <= AUTORUN_STEP2_TIME_END * 60)
                   ) {
                    _chargingData[curGun]->EvBatterytargetVoltage = _Voltage;
                    _chargingData[curGun]->EvBatterytargetCurrent = _Current;
                } else if ((GetTimeoutValue(_autoTime)) >= AUTORUN_END_TIME * 60) {
                    _curAutoRunCount++;
                    if (_curAutoRunCount >= AUTORUN_CYCLE_COUNT) {
                        _chargingData[curGun]->SystemStatus = S_TERMINATING;
                    } else {
                        gettimeofday(&_autoTime, NULL);
                    }
                } else {
                    _chargingData[curGun]->EvBatterytargetVoltage = 0;
                    _chargingData[curGun]->EvBatterytargetCurrent = 0;
                }
            }

//              printf("out : vol = %f, cur = %f \n",
//                      _chargingData[curGun]->EvBatterytargetVoltage,
//                      _chargingData[curGun]->EvBatterytargetCurrent);
            //ev task do this
            _chargingData[curGun]->PresentChargingPower =
                ((float)((_chargingData[curGun]->PresentChargingVoltage) *
                         (_chargingData[curGun]->PresentChargingCurrent)) / 1000);

            if (_chargingData[curGun]->GroundFaultStatus == 0x02) {
                printf ("Charging Ground Fault check Fail (%d)\n",
                        _chargingData[curGun]->GroundFaultStatus);
                _chargingData[curGun]->SystemStatus = S_TERMINATING;
            }
            break;

        case S_TERMINATING:
            if (PreviousSystemStatus[curGun] != _chargingData[curGun]->SystemStatus) {
                PreviousSystemStatus[curGun] = _chargingData[curGun]->SystemStatus;

                printf ("[UnconditionalCharge - S_TERMINATING]\n");
                //無阻塞偵測 keybaord 結束
                system(STTY_DEF TTY_PATH);
            }

            _chargingData[curGun]->SystemStatus = S_COMPLETE;
            break;

        case S_COMPLETE:
            if (PreviousSystemStatus[curGun] != _chargingData[curGun]->SystemStatus) {
                PreviousSystemStatus[curGun] = _chargingData[curGun]->SystemStatus;

                printf ("[UnconditionalCharge - S_COMPLETE]\n");
            }

            PreviousSystemStatus[curGun] = 0xFF;
            stopChg = 0;
            for (gunIndex = 0; gunIndex < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; gunIndex++) {
                if (PreviousSystemStatus[gunIndex] == 0xFF) {
                    _chargingData[curGun]->SystemStatus = S_IDLE;
                }

                if (_chargingData[gunIndex]->SystemStatus == S_IDLE) {
                    stopChg++;
                }
            }

            _chargingData[curGun]->PresentChargingPower = 0;

            if (stopChg == ShmSysConfigAndInfo->SysConfig.TotalConnectorCount) {
                system("/root/Module_EvComm &");
                sleep(3);
                return;
            }
            break;
        }

        char word[128];
        char newString[7][10];
        int i, j, ctr;

        memset(word, 0x00, sizeof(word));
        get_char(word);

        if (strlen(word) == 0) {
            continue;
        }

        j = 0; ctr = 0;
        strcpy(newString[1], "-1");
        strcpy(newString[2], "-1");
        for (i = 0; i <= (strlen(word)); i++) {
            if (word[i] == ' ' || word[i] == '\0' || word[i] == 10) {
                newString[ctr][j] = '\0';
                ctr++;
                j = 0;
            } else {
                newString[ctr][j] = word[i];
                j++;
            }
        }

        if (strcmp(newString[0], "strchg") == 0) {
            if (strcmp(newString[1], "-1") == 0 ||
                    strcmp(newString[1], "") == 0 ||
                    strcmp(newString[2], "-1") == 0 ||
                    strcmp(newString[2], "") == 0
               ) {
                printf ("Input cmd fail ------  strchg [vol 150-1000] [cru 2-100]\n");
                continue;
            }

            if (atoi(newString[1]) == ShmSysConfigAndInfo->SysInfo.CurGunSelected) {
                continue;
            }

            _GunIndex = atoi((char *)newString[1]);
            _Voltage = atof((char *)newString[2]);
            _Current = atof((char *)newString[3]);

            if (!FindChargingInfoData(_GunIndex, &_chargingData[0])) {
                printf ("FindChargingInfoData error\n");
                continue;
            }

            printf ("Power = %d, ReqVoltage = %f, ReqCurrent = %f\n",
                    ShmSysConfigAndInfo->SysConfig.MaxChargingPower,
                    _Voltage,
                    _Current);

            if (_Voltage > 1000 || _Voltage < 50) {
                _Voltage = 200;
                printf ("Input Voltage over range\n");
                continue;
            }

            ShmSysConfigAndInfo->SysInfo.CurGunSelected = _GunIndex;
            strcpy((char *)ShmSysConfigAndInfo->SysConfig.UserId, "");
        } else if (strcmp(newString[0], "chg") == 0) {
            if (strcmp(newString[1], "-1") == 0) {
                continue;
            }

            if (strcmp(newString[2], "-1") == 0 ||
                    strcmp(newString[2], "") == 0) {
                continue;
            }

            if (strcmp(newString[3], "-1") == 0 ||
                    strcmp(newString[3], "") == 0) {
                continue;
            }

            _GunIndex = atoi((char *)newString[1]);
            float _vol = atof(newString[2]);
            float _cur = atof(newString[3]);

            if (_cur <= 0 || _cur <= 0) {
                continue;
            }

            printf("vol = %f, cur = %f \n", _vol, _cur);
            _chargingData[_GunIndex]->EvBatterytargetVoltage = _vol;
            _chargingData[_GunIndex]->EvBatterytargetCurrent = _cur;
        } else if (strcmp(newString[0], "c") == 0) {
            if (atoi((char *)newString[1]) != -1) {
                ShmSysConfigAndInfo->SysInfo.CurGunSelected = atoi((char *)newString[1]);
            }
            printf("stop \n\r");

            ShmSysConfigAndInfo->SysInfo.StartToChargingFlag = 0x00;
            _chargingData[ShmSysConfigAndInfo->SysInfo.CurGunSelected]->SystemStatus = S_TERMINATING;
        }

        usleep(100000);
    }
}

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

    for (;;) {
        char word[128];
        char newString[7][10];
        int i, j, ctr;

        fgets(word, sizeof(word), stdin);

        j = 0; ctr = 0;
        strcpy(newString[1], "-1");
        strcpy(newString[2], "-1");
        for (i = 0; i <= (strlen(word)); i++) {
            if (word[i] == ' ' || word[i] == '\0' || word[i] == 10) {
                newString[ctr][j] = '\0';
                ctr++;
                j = 0;
            } else {
                newString[ctr][j] = word[i];
                j++;
            }
        }

        if (strcmp(newString[0], "state") == 0) {
            if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0) {
                continue;
            }

            // 槍狀態
            RunStatusProc(newString[1], newString[2]);
        } else if (strcmp(newString[0], "card") == 0) {
            // 刷卡狀態
            RunCardProc(newString[1], newString[2]);
        } else if (strcmp(newString[0], "gun") == 0) {
            if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0) {
                continue;
            }

            // 插槍狀態
            RunGunPlugitProc(newString[1], newString[2]);
        } else if (strcmp(newString[0], "lock") == 0) {
            if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0) {
                continue;
            }

            // 插槍狀態
            GetGunLockStatusProc(newString[1], newString[2]);
        } else if (strcmp(newString[0], "sysid") == 0) {
            // 測試 sys id
            SetSystemIDProc();
        } else if (strcmp(newString[0], "self") == 0) {
            // CSU 自我檢測狀態
            RunSelfProc(newString[1]);
        } else if (strcmp(newString[0], "ver") == 0) {
            if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0) {
                continue;
            }
            // 取 FW 版號
            GetFwVerProc(newString[1]);
        } else if (strcmp(newString[0], "update") == 0) {
            // 更新
            FwUpdateFlagProc(newString[1]);
        } else if (strcmp(newString[0], "ac") == 0) {
            // AC contactor 狀態
            CheckAcStatus(newString[1]);
        } else if (strcmp(newString[0], "cable") == 0) {
            if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0) {
                continue;
            }
            // cable check pass
            SetCableChkStatus(newString[1], newString[2]);
        } else if (strcmp(newString[0], "pow") == 0) {
            if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0) {
                continue;
            }
            // cable check pass
            SetPowerValue(newString[1], newString[2]);
        } else if (strcmp(newString[0], "model") == 0) {
            GetSystemInfo();
        } else if (strcmp(newString[0], "select") == 0) {
            // 取得 / 設定 當前選的槍號
            GetGunSelectedNum(newString[1]);
        } else if (strcmp(newString[0], "change") == 0) {
            // 模擬按鈕改變選槍
            ChangeGunNum();
        } else if (strcmp(newString[0], "fan") == 0) {
            // 設定風扇速度
            SetFanSpeed(newString[1]);
        } else if (strcmp(newString[0], "speed") == 0) {
            // 取得風扇速度
            GetFanSpeed();
        } else if (strcmp(newString[0], "debug") == 0) {
            // 設定 debug mode
            SetDebugMode(newString[1]);
        } else if (strcmp(newString[0], "gfd") == 0) {
            // 設定盲沖使用 GFD 功能
            SetGFDMode(newString[1]);
        } else if (strcmp(newString[0], "temp") == 0) {
            // 取得 PSU 溫度
            GetPsuTemp();
        } else if (strcmp(newString[0], "acin") == 0) {
            // 取得三向輸入電壓
            GetAcInputVol();
        } else if (strcmp(newString[0], "psu") == 0) {
            //如果連一個參數都沒有 (此命令不理會) 加上判斷第二參數
            if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0) {
                printf ("PSU : Param fail..Please retry again......\n");
                continue;
            }

            // 取得 PSU 資訊
            GetPsuInformation(newString[1], newString[2], newString[3]);
        } else if (strcmp(newString[0], "cap") == 0) {
            GetConnectorCapInfo(newString[1]);
        } else if (strcmp(newString[0], "error") == 0) {
            CreateOneError(newString[1]);
        } else if (strcmp(newString[0], "auth") == 0) {
            GetAuthorizeFlag(newString[1]);
        } else if (strcmp(newString[0], "relay") == 0) {
            GetRelayStatus(newString[1]);
        } else if (strcmp(newString[0], "ccid") == 0) {
            if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0 ||
                    strcmp(newString[2], "-1") == 0 || strcmp(newString[2], "") == 0) {
                printf ("Input ccid fail.\n");
                continue;
            }
            SetChargingInfoCCID(newString[1], newString[2]);
        } else if (strcmp(newString[0], "strchg") == 0) {
            //如果連一個參數都沒有 (此命令不理會) 加上判斷第二參數
            if (strcmp(newString[1], "auto") == 0) {
                newString[2][0] = 0;
                newString[3][0] = 0;
            } else if (strcmp(newString[1], "-1") == 0 || strcmp(newString[1], "") == 0 ||
                       strcmp(newString[2], "-1") == 0 || strcmp(newString[2], "") == 0) {
                printf ("Input cmd fail ------  strchg [vol 150-1000] [cru 2-100]\n");
                continue;
            }

            // 槍狀態
            RunUnconditionalChargeIndex1(newString[1], newString[2], newString[3]);
        } else if (strcmp(newString[0], "tempT") == 0) {

            if (strcmp(newString[1], "0") == 0) {
                uint8_t _GunIndex = 0;
                if (!FindChargingInfoData(_GunIndex, &_chargingData[0])) {
                    printf ("FindChargingInfoData error\n");
                    return 0;
                }

                _chargingData[0]->ConnectorTemp = atoi(newString[2]);
                printf("ReadCmdline temp 0 = %d\r\n", _chargingData[0]->ConnectorTemp);
            } else if (strcmp(newString[1], "1") == 0) {
                uint8_t _GunIndex = 1;
                if (!FindChargingInfoData(_GunIndex, &_chargingData[0])) {
                    printf ("FindChargingInfoData error\n");
                    return 0;
                }

                _chargingData[1]->ConnectorTemp = atoi(newString[2]);
                printf("ReadCmdline temp 1 = %d\r\n", _chargingData[1]->ConnectorTemp);
            }
        } else if (strcmp(newString[0], "tempC") == 0) {
            if (strcmp(newString[1], "0") == 0) {
                uint8_t _GunIndex = 0;
                if (!FindChargingInfoData(_GunIndex, &_chargingData[0])) {
                    printf ("FindChargingInfoData error\n");
                    return 0;
                }

                _chargingData[0]->ChillerTemp = atoi(newString[2]);
                printf("ReadCmdline temp 0 = %d\r\n", _chargingData[0]->ChillerTemp);
            } else if (strcmp(newString[1], "1") == 0) {
                uint8_t _GunIndex = 1;
                if (!FindChargingInfoData(_GunIndex, &_chargingData[0])) {
                    printf ("FindChargingInfoData error\n");
                    return 0;
                }

                _chargingData[1]->ChillerTemp = atoi(newString[2]);
                printf("ReadCmdline temp 1 = %d\r\n", _chargingData[1]->ChillerTemp);
            }
        } else if (strcmp(newString[0], "TempCR") == 0) {
            if (strcmp(newString[1], "0") == 0) {
                uint8_t _GunIndex = 0;
                if (!FindChargingInfoData(_GunIndex, &_chargingData[0])) {
                    printf ("FindChargingInfoData error\n");
                    return 0;
                }
                printf("ReadCmdline temp 0 = %d\r\n", _chargingData[0]->ChillerTemp);
            } else if (strcmp(newString[1], "1") == 0) {
                uint8_t _GunIndex = 1;
                if (!FindChargingInfoData(_GunIndex, &_chargingData[0])) {
                    printf ("FindChargingInfoData error\n");
                    return 0;
                }

                printf("ReadCmdline temp 1 = %d\r\n", _chargingData[1]->ChillerTemp);
            }
        } else {
            printf ("%s\n", msg);
        }
        usleep(100000);
    }

    return 0;
}