#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/can.h>
#include    <linux/can/raw.h>
#include    <linux/wireless.h>
#include    <arpa/inet.h>
#include    <netinet/in.h>
#include <signal.h>
#include    <unistd.h>
#include    <stdarg.h>
#include    <stdio.h>      /*標準輸入輸出定義*/
#include    <stdlib.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    "../../define.h"
#include    "Config.h"

//#define Debug

#define DoIPAddress "192.168.100.1"
#define DoTcpPort       36000
#define TriggerMsgeNum      20

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

struct ApplicationPacket {
    unsigned char Se;
    unsigned char Id;
    unsigned char Op;
    unsigned char Len;
    unsigned char RegisterNum;
    unsigned char Data[250];
};

struct SysConfigAndInfo         *ShmSysConfigAndInfo;
struct StatusCodeData           *ShmStatusCodeData;
struct PsuData              *ShmPsuData;
struct OCPP16Data               *ShmOCPP16Data;
struct PrimaryMcuData           *ShmPrimaryMcuData;
int                             TcpSock = 0;
unsigned char                   PacketSe;
struct ChargingInfoData         *ChargingData[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];
struct timeb                    TriggerTimeUp[2][TriggerMsgeNum];
struct WARNING_CODE_INFO        PreSysWarningInfo;
int DisconnectFlag;

int StoreLogMsg(const char *fmt, ...)
{
    char Buf[4096 + 256];
    char buffer[4096];
    va_list args;
    struct timeb  SeqEndTime;
    struct tm *tm;

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

    memset(Buf, 0, sizeof(Buf));
    ftime(&SeqEndTime);
    SeqEndTime.time = time(NULL);
    tm = localtime(&SeqEndTime.time);

    if (ShmSysConfigAndInfo->SysConfig.SwitchDebugFlag == 1) {
        sprintf(Buf, "%02d:%02d:%02d:%03d - %s",
                tm->tm_hour, tm->tm_min, tm->tm_sec, SeqEndTime.millitm, buffer);
        printf("%s \n", Buf);
    } else {
        sprintf(Buf, "echo \"%04d-%02d-%02d %02d:%02d:%02d:%03d - %s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog",
                tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, SeqEndTime.millitm,
                buffer,
                tm->tm_year + 1900, tm->tm_mon + 1);
        system(Buf);
    }

    return rc;
}

int DiffTimeb(struct timeb ST, struct timeb ET)
{
    //return milli-second
    unsigned int StartTime, StopTime;

    StartTime = (unsigned int)ST.time;
    StopTime = (unsigned int)ET.time;
    return (StopTime - StartTime) * 1000 + ET.millitm - ST.millitm;
}

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

    if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo),  0777)) < 0) {
        DEBUG_ERROR("shmget ShmSysConfigAndInfo NG\n");
        result = 0;
    } else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        DEBUG_ERROR("[shmat ShmSysConfigAndInfo NG\n");
        result = 0;
    }

    if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  0777)) < 0) {
        DEBUG_ERROR("shmget ShmStatusCodeData NG\n");
        result = 0;
    } else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        DEBUG_ERROR("shmat ShmStatusCodeData NG\n");
        result = 0;
    }
    //creat ShmPsuData
    if ((MeterSMId = shmget(ShmPsuKey, sizeof(struct PsuData),  0777)) < 0) {
        DEBUG_ERROR("shmget ShmPsuData NG \n");
        result = 0;
    } else if ((ShmPsuData = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        DEBUG_ERROR("shmat ShmPsuData NG \n");
        result = 0;
    }
    //creat ShmOCPP16Data
    if ((MeterSMId = shmget(ShmOcppModuleKey, sizeof(struct OCPP16Data),  0777)) < 0) {
        DEBUG_ERROR("shmget ShmOCPP16Data NG \n");
        result = 0;
    } else if ((ShmOCPP16Data = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        DEBUG_ERROR("shmat ShmOCPP16Data NG \n");
        result = 0;
    }

    if ((MeterSMId = shmget(ShmPrimaryMcuKey, sizeof(struct PrimaryMcuData), 0777)) < 0) {
        DEBUG_ERROR("shmget ShmPrimaryMcuData NG\n");
        result = 0;
    } else if ((ShmPrimaryMcuData = shmat(MeterSMId, NULL, 0)) == (void *) - 1) {
        DEBUG_ERROR("shmat ShmPrimaryMcuData NG\n");
        result = 0;
    }
    return result;
}

int CheckNetworkStatus()
{
    //printf("ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress=%s\n",ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress);
    if (strstr(ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress, "192.168.100") != NULL) {
        return 1;
    } else {
        return 0;
    }
}

int TcpConnected()
{
    struct sockaddr_in dest;
    struct timeval tv;
    int flag;

    if (TcpSock > 0) {
        close(TcpSock);
    }

    if ((TcpSock = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        DEBUG_ERROR("Open TCP socket NG");
        return -1;
    }
    /*   flag=fcntl (TcpSock, F_GETFL, 0);
       if(flag>=0)
       {
           flag |= O_NONBLOCK;
           fcntl(TcpSock,F_SETFL, flag );
       }*/
    tv.tv_sec = 0;
    tv.tv_usec = 100000;
    setsockopt(TcpSock, SOL_SOCKET,  SO_RCVTIMEO, &tv, sizeof(struct timeval));
    setsockopt(TcpSock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(struct timeval));
    flag = 1;
    setsockopt(TcpSock, SOL_SOCKET, MSG_NOSIGNAL, &flag, sizeof(flag));

    memset(&dest, 0, sizeof(dest));
    dest.sin_family = AF_INET;
    dest.sin_port = htons(DoTcpPort);
    inet_aton(DoIPAddress, (struct in_addr *) &dest.sin_addr.s_addr);

    if (connect(TcpSock, (struct sockaddr *) &dest, sizeof(dest)) != 0) {
        close(TcpSock);
        return -1;
    }
    return TcpSock;
}
void AddFaultCodeToBuf(unsigned char *Code)
{
    if (ShmSysConfigAndInfo->SysWarningInfo.WarningCount < 10) {
        memcpy(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[ShmSysConfigAndInfo->SysWarningInfo.WarningCount][0], Code, strlen(Code));
        ShmSysConfigAndInfo->SysWarningInfo.WarningCount++;
    }
}

void RemoveFaultCodeToBuf(unsigned char *Code)
{
    unsigned char find = 0x01;
    char _code[7];
    sprintf(_code, "%s", Code);

    // 把相關的錯誤碼一次移除，避免重複顯示
    while (find) {
        find = 0x00;
        for (unsigned char i = 0; i < ShmSysConfigAndInfo->SysWarningInfo.WarningCount; i++) {
            if (find == 0x00) {
                if (memcmp(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][0], _code, 7) == 0) {
                    find = 0x01;
                }
            } else {
                memcpy(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i - 1][0],
                       &ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][0], 7);
            }
        }

        if (find) {
            ShmSysConfigAndInfo->SysWarningInfo.WarningCount--;
        }
    }
}

int StatusCodeProcessing(unsigned char *StatusCode)
{
    unsigned char Rtn = 0;
    int ByteCount, BitCount;
    unsigned char tmp, EventCodeTmp[7];

    if (strlen(StatusCode) != 6) {
        return 0;
    }
    memset(EventCodeTmp, 0, sizeof(EventCodeTmp));
    memcpy(EventCodeTmp, StatusCode, strlen(StatusCode));

    if (*(StatusCode + 1) == 0x34) { //alarm from power cabinet itself
        if (StatusCode[0] == 0x30) { //trigger
            for (unsigned char i = 0; i < ShmSysConfigAndInfo->SysWarningInfo.WarningCount; i++) {
                if (memcmp(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][0], EventCodeTmp, 7) == 0) {
                    Rtn = 1;
                    break;
                }
            }
            if (Rtn == 0) {
                AddFaultCodeToBuf(EventCodeTmp);
            }
            Rtn = 1;
        } else if (StatusCode[0] == 0x31) { //recovery
            RemoveFaultCodeToBuf(EventCodeTmp);
            Rtn = 1;
        }
    } else {
        switch (*(StatusCode + 2)) {
        case 0x31://Fault
            for (ByteCount = 0; ByteCount < (sizeof(FaultStatusCode) / 6); ByteCount++) {
                if (memcmp(FaultStatusCode[ByteCount] + 1, StatusCode + 1, 5) == 0) {
                    if (StatusCode[0] == 0x30) { //trigger
                        ShmStatusCodeData->FaultCode.FaultEvents.FaultVal[ByteCount / 8] |= 1 << (ByteCount % 8);
                    } else if (StatusCode[0] == 0x31) { //recovery
                        ShmStatusCodeData->FaultCode.FaultEvents.FaultVal[ByteCount / 8] &= 0 << (ByteCount % 8);
                    }
                    Rtn = 1;
                    break;
                }
            }
            break;
        case 0x32://Alarm
            for (ByteCount = 0; ByteCount < (sizeof(AlarmStatusCode) / 6); ByteCount++) {
                if (memcmp(AlarmStatusCode[ByteCount] + 1, StatusCode + 1, 5) == 0) {

                    if (StatusCode[0] == 0x30) { //trigger
                        ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[ByteCount / 8] |= 1 << (ByteCount % 8);
                    } else if (StatusCode[0] == 0x31) { //recovery
                        ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[ByteCount / 8] &= 0 << (ByteCount % 8);
                    }
                    Rtn = 1;
                    break;
                }
            }
            break;
        case 0x33://Information
            for (ByteCount = 0; ByteCount < (sizeof(InfoStatusCode) / 6); ByteCount++) {
                if (memcmp(InfoStatusCode[ByteCount] + 1, StatusCode + 1, 5) == 0) {
                    if (StatusCode[0] == 0x30) { //trigger
                        ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[ByteCount / 8] |= 1 << (ByteCount % 8);
                    } else if (StatusCode[0] == 0x31) { //recovery
                        ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[ByteCount / 8] &= 0 << (ByteCount % 8);
                    }
                    Rtn = 1;
                    break;
                }
            }
            break;
        default:
            break;
        }
    }

    return Rtn;
}

int SendPacket(unsigned char Id, unsigned char Op, unsigned char RegNum, unsigned char DataLen, unsigned char *Data)
{
    int Rtn = 0, PacketLen, Tmp;
    struct ApplicationPacket SendBuffer;
    struct timeb ST, ET;

    memset(&SendBuffer, 0, sizeof(struct ApplicationPacket));
    SendBuffer.Se = (PacketSe++);
    SendBuffer.Id = Id;
    SendBuffer.Op = Op;
    SendBuffer.Len = DataLen + 1;
    SendBuffer.RegisterNum = RegNum;
    if (DataLen > 0) {
        memcpy(SendBuffer.Data, Data, DataLen);
    }
    PacketLen = SendBuffer.Len + 4;
    ftime(&ST);
    while (Rtn < PacketLen) {
        Tmp = send(TcpSock, &SendBuffer + Rtn, PacketLen - Rtn, MSG_NOSIGNAL);
        if (Tmp > 0) {
            Rtn += Tmp;
        }
        ftime(&ET);
        if (DiffTimeb(ST, ET) > 500) {
            DisconnectFlag++;
            if (DisconnectFlag >= 10) {
                DisconnectFlag = 10;
            }
#ifdef Debug
            printf("Send Packet Timeout(%d/%d): SE=%d, ID=%d, OP=%d, Reg=%d",
                   Rtn, PacketLen, PacketSe, Id, Op, RegNum);
#endif
            return 0;
        }
    }
    return Rtn;
}

int RecvPacket(unsigned char *DataLen, struct ApplicationPacket *Packet)
{
    int Rtn = 0, Tmp;
    unsigned char TmpBuf[250];
    struct timeb ST, ET;

    memset(Packet, 0, sizeof(struct ApplicationPacket));
    memset(TmpBuf, 0, sizeof(TmpBuf));
    ftime(&ST);
    while (Rtn < 5) {
        Tmp = recv(TcpSock, TmpBuf + Rtn, 5 - Rtn, 0);
        if (Tmp > 0) {
            Rtn += Tmp;
        }
        ftime(&ET);
        if (DiffTimeb(ST, ET) > 500) {
            DisconnectFlag++;
            if (DisconnectFlag >= 10) {
                DisconnectFlag = 10;
            }
#ifdef Debug
            printf("Recv Packet header Timeout(%d/5)(disconnect count=%d): SE=%d, ID=%d, OP=%d, Len=%d, Reg=%d",
                   Rtn, DisconnectFlag, TmpBuf[0], TmpBuf[1], TmpBuf[2], TmpBuf[3], TmpBuf[4]);
#endif
            return 0;
        }
    }
    if ((TmpBuf[0] > 255)/*||(TmpBuf[1]>2)*/ || (TmpBuf[2] > 3) || (TmpBuf[3] > 250)) {
        DEBUG_INFO("Recv Wrong Packet header (%d/5): SE=%d, ID=%d, OP=%d, Len=%d, Reg=%d",
                   Rtn, TmpBuf[0], TmpBuf[1], TmpBuf[2], TmpBuf[3], TmpBuf[4]);
        return 0;
    }
    memcpy(Packet, TmpBuf, 5);
    *DataLen = Packet->Len - 1;
    memset(TmpBuf, 0, sizeof(TmpBuf));
    Rtn = 0;
    ftime(&ST);
    while (Rtn < *DataLen) {
        Tmp = recv(TcpSock, TmpBuf + Rtn, *DataLen - Rtn, 0);
        if (Tmp > 0) {
            Rtn += Tmp;
        }
        ftime(&ET);
        if (DiffTimeb(ST, ET) > 500) {
            DEBUG_INFO("Recv Packet Timeout(%d/%d): SE=%d, ID=%d, OP=%d, Reg=%d",
                       Rtn, *DataLen, Packet->Se, Packet->Id, Packet->Op, Packet->RegisterNum);
            return 0;
        }
    }
    memcpy(Packet->Data, TmpBuf, *DataLen);
    DisconnectFlag = 0;
    return Rtn;
}

int WriteModelName()
{
    unsigned char Tmp = 0;
    unsigned char TmpBuf[255];
    struct ApplicationPacket PacketData;

    memset(TmpBuf, 0, sizeof(TmpBuf));
    memset(&PacketData, 0, sizeof(struct ApplicationPacket));

    memcpy(TmpBuf, ShmSysConfigAndInfo->SysConfig.ModelName, strlen(ShmSysConfigAndInfo->SysConfig.ModelName));
    Tmp = (unsigned char)(ShmPrimaryMcuData->InputDet.bits.Key2 << 2 | ShmPrimaryMcuData->InputDet.bits.Key1 << 1 | ShmPrimaryMcuData->InputDet.bits.Key0);
    TmpBuf[strlen(ShmSysConfigAndInfo->SysConfig.ModelName)] = Tmp; //Dispenser switch value
#ifdef Debug
    printf("WriteModelName(%s)(%d) => ", ShmSysConfigAndInfo->SysConfig.ModelName, Tmp);
#endif
    if (SendPacket(0xFF, 0x02, 0x01, strlen(ShmSysConfigAndInfo->SysConfig.ModelName) + 1, TmpBuf) <= 0) {
#ifdef Debug
        printf("SendPacket Fail\n");
#endif
        return -1;
    }
    if (RecvPacket(&Tmp, &PacketData) <= 0) {
#ifdef Debug
        printf("RecvPacket Fail\n");
#endif
        return -1;
    }
    if (PacketData.Data[0] != 1) { //!=OK
#ifdef Debug
        printf("NG\n");
#endif
        return -1;
    }
#ifdef Debug
    printf("OK\n");
#endif
    return 1;
}

int ReadConnectorID()
{
    unsigned char Tmp = 0;
    struct ApplicationPacket PacketData;

    memset(&PacketData, 0, sizeof(struct ApplicationPacket));
#ifdef Debug
    printf("ReadConnectorID => ");
#endif
    if (SendPacket(0xFF, 0x01, 0x02, 0, PacketData.Data) <= 0) {
#ifdef Debug
        printf("SendPacket Fail\n");
#endif
        return -1;
    }
    if (RecvPacket(&Tmp, &PacketData) <= 0) {
#ifdef Debug
        printf("RecvPacket Fail\n");
#endif
        return -1;
    }
    if (PacketData.Data[0] != 1) { //!=OK
#ifdef Debug
        printf("NG\n");
#endif
        return -1;
    }
#ifdef Debug
    printf("OK (Left connector ID = %d, Right connector ID = %d)\n", PacketData.Data[1], PacketData.Data[2]);
#endif
    return 1;
}

int ReadDoStatus()
{
    unsigned char Tmp = 0, count, Rtn;
    struct ApplicationPacket PacketData;
    unsigned char StatusArray[20][6];
    unsigned char EventCodeTmp[7];

    memset(&PacketData, 0, sizeof(struct ApplicationPacket));
    memset(StatusArray, 0, sizeof(StatusArray));
#ifdef Debug
    printf("ReadDoStatus => ");
#endif
    if (SendPacket(0x01, 0x01, 0x03, 0, PacketData.Data) <= 0) {
#ifdef Debug
        printf("SendPacket Fail\n");
#endif
        return -1;
    }
    if (RecvPacket(&Tmp, &PacketData) <= 0) {
#ifdef Debug
        printf("RecvPacket Fail\n");
#endif
        return -1;
    }
    if (PacketData.Data[0] != 1) { //!=OK
#ifdef Debug
        printf("NG\n");
#endif
        return -1;
    }
    Tmp--;//decrase OK/NG byte
    if (Tmp < 6) {
        if (ShmSysConfigAndInfo->SysWarningInfo.WarningCount > 0) {
            for (unsigned char i = 0; i < ShmSysConfigAndInfo->SysWarningInfo.WarningCount; i++) {
                if (ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][1] >= 0x33) { //from backend or power cabinet
                    memset(EventCodeTmp, 0, sizeof(EventCodeTmp));
                    memcpy(EventCodeTmp, ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i], sizeof(EventCodeTmp));
                    RemoveFaultCodeToBuf(EventCodeTmp);
                }
            }
        }
#ifdef Debug
        printf("no alarm (%d)\n", Tmp);
#endif
        return -1;
    }
#ifdef Debug
    printf("OK, (%d) ", Tmp);
    //printf("PacketData.Se=%d\n",PacketData.Se);
    //printf("PacketData.Id=%d\n",PacketData.Id);
    //printf("PacketData.Op=%d\n",PacketData.Op);
    //printf("PacketData.Len=%d\n",PacketData.Len);
    //printf("PacketData.RegisterNum=%d\n",PacketData.RegisterNum);
    //for(Rtn=0;Rtn<=PacketData.Len-1;Rtn++)
    //printf("PacketData.Data[%d]=0x%x\n",Rtn,PacketData.Data[Rtn]);
#endif
    for (count = 0; count < Tmp; count += 6) {
        //if((Tmp-count)<6)
        strncpy(StatusArray[count / 6], (PacketData.Data + 1) + count, 6);
        Rtn = 0;
        for (unsigned char i = 0; i < ShmSysConfigAndInfo->SysWarningInfo.WarningCount; i++) {
            if (memcmp(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][0], StatusArray[count / 6], 6) == 0) {
                Rtn = 1;
                break;
            }
        }
        if (Rtn == 0) {
            AddFaultCodeToBuf(StatusArray[count / 6]);
        }
        //Rtn=StatusCodeProcessing(StatusArray[count/6]);
#ifdef Debug
        printf("(%d)(%s) = %s,  ", count / 6, Rtn == 1 ? "Process OK" : "Process NG", StatusArray[count / 6]);
#endif
    }
    for (unsigned char i = 0; i < ShmSysConfigAndInfo->SysWarningInfo.WarningCount; i++) {
        if (ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][1] >= 0x33) { //from backend or power cabinet
            Rtn = 0;
            for (count = 0; count < (Tmp / 6); count++) {
                if (memcmp(&ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i][0], StatusArray[count], 6) == 0) {
                    Rtn = 1;
                    break;
                }
            }
            if (Rtn == 0) {
                memset(EventCodeTmp, 0, sizeof(EventCodeTmp));
                memcpy(EventCodeTmp, ShmSysConfigAndInfo->SysWarningInfo.WarningCode[i], sizeof(EventCodeTmp));
                RemoveFaultCodeToBuf(EventCodeTmp);
            }
        }
    }
#ifdef Debug
    printf("\n");
#endif
    return 1;
}

int WriteDdStatus()
{
    unsigned char Tmp = 0, count;
    unsigned char TmpBuf[255], CurWarnCodeTmp[10][6], PreWarnCodeTmp[10][6];
    struct ApplicationPacket PacketData;

    if ((ShmSysConfigAndInfo->SysWarningInfo.WarningCount <= 0) && (PreSysWarningInfo.WarningCount <= 0)) {
        return -1;
    }
    memset(CurWarnCodeTmp, 0, sizeof(CurWarnCodeTmp));
    Tmp = ShmSysConfigAndInfo->SysWarningInfo.WarningCount;
    for (count = 0; count < Tmp; count++) {
        memcpy(CurWarnCodeTmp[count], ShmSysConfigAndInfo->SysWarningInfo.WarningCode[count], 6);
    }
    memset(PreWarnCodeTmp, 0, sizeof(PreWarnCodeTmp));
    Tmp = PreSysWarningInfo.WarningCount;
    for (count = 0; count < Tmp; count++) {
        memcpy(PreWarnCodeTmp[count], PreSysWarningInfo.WarningCode[count], 6);
    }
    if (strcmp(CurWarnCodeTmp, PreWarnCodeTmp) == 0) {
        return -1;
    }


    /*memset(TmpBuf,0,sizeof(TmpBuf));
    Tmp=ShmSysConfigAndInfo->SysWarningInfo.WarningCount;
    for(count=0;count<Tmp;count++)
    {
        memcpy(TmpBuf+(count*6),ShmSysConfigAndInfo->SysWarningInfo.WarningCode[count],6);
        #ifdef Debug
        printf("WriteDdStatus(%d) = %s", count, ShmSysConfigAndInfo->SysWarningInfo.WarningCode[count]);
        #endif
    }
    if(SendPacket(0x01, 0x02, 0x04,strlen(TmpBuf), TmpBuf)<=0)
        return -1;
    */
#ifdef Debug
    printf("WriteDdStatus => ");
#endif
    if (SendPacket(0x01, 0x02, 0x04, strlen(CurWarnCodeTmp), CurWarnCodeTmp) <= 0) {
#ifdef Debug
        printf("SendPacket Fail\n");
#endif
        return -1;
    }
    memset(&PacketData, 0, sizeof(struct ApplicationPacket));
    if (RecvPacket(&Tmp, &PacketData) <= 0) {
#ifdef Debug
        printf("RecvPacket Fail\n");
#endif
        return -1;
    }
    if (PacketData.Data[0] != 1) { //!=OK
#ifdef Debug
        printf("NG\n");
#endif
        return -1;
    }
    memset(&PreSysWarningInfo, 0, sizeof(struct WARNING_CODE_INFO));
    memcpy(&PreSysWarningInfo, &(ShmSysConfigAndInfo->SysWarningInfo), sizeof(struct WARNING_CODE_INFO));
#ifdef Debug
    printf("OK,  ");
    Tmp = ShmSysConfigAndInfo->SysWarningInfo.WarningCount;
    for (count = 0; count < Tmp; count++) {
        printf("(%d)%s,  ", count, ShmSysConfigAndInfo->SysWarningInfo.WarningCode[count]);
    }
    printf("\n");
#endif
    return 1;
}

int ReadChargingCapability(unsigned char PlugNum)
{
    unsigned char Tmp = 0;
    struct ApplicationPacket PacketData;
    float MaxVolt, MaxCurrent, MaxPower;

#ifdef Debug
    printf("Read Charging Capability => ");
#endif
    memset(&PacketData, 0, sizeof(struct ApplicationPacket));
    if (SendPacket(PlugNum, 0x01, 0x05, 0, PacketData.Data) <= 0) {
#ifdef Debug
        printf("SendPacket Fail\n");
#endif
        return -1;
    }
    if (RecvPacket(&Tmp, &PacketData) <= 0) {
#ifdef Debug
        printf("RecvPacket Fail\n");
#endif
        return -1;
    }
    if (PacketData.Data[0] != 1) { //!=OK
#ifdef Debug
        printf("NG\n");
#endif
        return -1;
    }
    MaxVolt = (float)(PacketData.Data[1] << 8 | PacketData.Data[2]);
    MaxCurrent = (float)(PacketData.Data[3] << 8 | PacketData.Data[4]);
    MaxPower = (float)(PacketData.Data[5] << 8 | PacketData.Data[6]);
    if ((MaxVolt >= 0) && (MaxVolt <= 10000)) {
        ChargingData[PlugNum - 1]->MaximumChargingVoltage = MaxVolt;
    }
    if ((MaxCurrent >= 0) && (MaxCurrent <= 5000)) {
        ChargingData[PlugNum - 1]->AvailableChargingCurrent = MaxCurrent;
    }
    if ((MaxPower >= 0) && (MaxPower <= 3600)) {
        ChargingData[PlugNum - 1]->AvailableChargingPower = MaxPower;
    }
#ifdef Debug
    printf(" MaxVolt=%f, MaxCurrent=%f, MaxPower=%f,\n", MaxVolt, MaxCurrent, MaxPower);
#endif
    return 1;
}

int WriteChargingTarget(unsigned char PlugNum)
{
    unsigned char Tmp = 0;
    unsigned char TmpBuf[255];
    struct ApplicationPacket PacketData;
    float ChargingVolt, ChargingAmp;

    memset(TmpBuf, 0, sizeof(TmpBuf));
    memset(&PacketData, 0, sizeof(struct ApplicationPacket));

    ChargingVolt = ChargingData[PlugNum - 1]->EvBatterytargetVoltage;
    ChargingAmp = ChargingData[PlugNum - 1]->EvBatterytargetCurrent;
    ChargingVolt *= 10;
    ChargingAmp *= 10;
    TmpBuf[0] = ((unsigned short)ChargingVolt >> 8) & 0xFF;
    TmpBuf[1] = ((unsigned short)ChargingVolt) & 0xFF;
    TmpBuf[2] = ((unsigned short)ChargingAmp >> 8) & 0xFF;
    TmpBuf[3] = ((unsigned short)ChargingAmp) & 0xFF;
#ifdef Debug
    printf("WriteChargingTarget(%d), EvBatterytargetVoltage=%f,EvBatteryMaxVoltage=%f => ",
           PlugNum, ChargingData[PlugNum - 1]->EvBatterytargetVoltage, ChargingData[PlugNum - 1]->EvBatteryMaxVoltage);
#endif
    if (SendPacket(PlugNum, 0x02, 0x06, 4, TmpBuf) <= 0) {
#ifdef Debug
        printf("SendPacket Fail\n");
#endif
        return -1;
    }
    if (RecvPacket(&Tmp, &PacketData) <= 0) {
#ifdef Debug
        printf("RecvPacket Fail\n");
#endif
        return -1;
    }
    if (PacketData.Data[0] != 1) { //!=OK
#ifdef Debug
        printf("NG\n");
#endif
        return -1;
    }
#ifdef Debug
    printf("ChargingVolt=%f, ChargingAmp=%f\n", ChargingVolt / 10, ChargingAmp / 10);
#endif

    return 1;
}
int ReadSoftwareUpdate()
{
    unsigned char Tmp = 0;
    struct ApplicationPacket PacketData;

    memset(&PacketData, 0, sizeof(struct ApplicationPacket));

    if (SendPacket(0x01, 0x01, 0x07, 0, PacketData.Data) <= 0) {
        return -1;
    }
    if (RecvPacket(&Tmp, &PacketData) <= 0) {
        return -1;
    }
    if (PacketData.Data[0] != 1) { //!=OK
        return -1;
    }
    if (PacketData.Data[1] != 0x01) { //not update
        return -1;
    }
    return PacketData.Data[1];
}
int WritePlugInStatus(unsigned char PlugNum)
{
    unsigned char Tmp = 0;
    unsigned char TmpBuf[255];
    struct ApplicationPacket PacketData;

    memset(TmpBuf, 0, sizeof(TmpBuf));
    memset(&PacketData, 0, sizeof(struct ApplicationPacket));
    TmpBuf[0] = ChargingData[PlugNum - 1]->ConnectorPlugIn;
#ifdef Debug
    printf("WritePlugInStatus(%d) =>", PlugNum);
#endif
    if (SendPacket(PlugNum, 0x02, 0x08, 1, TmpBuf) <= 0) {
#ifdef Debug
        printf("SendPacket Fail\n");
#endif
        return -1;
    }
    if (RecvPacket(&Tmp, &PacketData) <= 0) {
#ifdef Debug
        printf("RecvPacket Fail\n");
#endif
        return -1;
    }
    if (PacketData.Data[0] != 1) { //!=OK
#ifdef Debug
        printf("NG\n");
#endif
        return -1;
    }
#ifdef Debug
    printf(" %s\n", TmpBuf[0] == 1 ? "Plug-in" : "Un-plug");
#endif

    return 1;
}

int WriteConnectorState(unsigned char PlugNum)
{
    unsigned char Tmp = 0;
    unsigned char TmpBuf[255];
    struct ApplicationPacket PacketData;


    memset(TmpBuf, 0, sizeof(TmpBuf));
    memset(&PacketData, 0, sizeof(struct ApplicationPacket));

    if (ChargingData[PlugNum - 1]->SystemStatus <= 2) {
        TmpBuf[0] = 0;    //idle
    } else if ((ChargingData[PlugNum - 1]->SystemStatus <= 7) || (ChargingData[PlugNum - 1]->SystemStatus == 17) || (ChargingData[PlugNum - 1]->SystemStatus == 18)) {
        TmpBuf[0] = 1;    //preparing
    } else if (ChargingData[PlugNum - 1]->SystemStatus == 8) {
        TmpBuf[0] = 2;    //charging
    } else if (ChargingData[PlugNum - 1]->SystemStatus == 9) {
        TmpBuf[0] = 3;    //terminating
    }

#ifdef Debug
    printf("WriteConnectorState(%d) SystemStatus=%d,TmpBuf[0]=%d => ", PlugNum, ChargingData[PlugNum - 1]->SystemStatus, TmpBuf[0]);
#endif
    if (SendPacket(PlugNum, 0x02, 0x09, 1, TmpBuf) <= 0) {
#ifdef Debug
        printf("SendPacket Fail\n");
#endif
        return -1;
    }
    if (RecvPacket(&Tmp, &PacketData) <= 0) {
#ifdef Debug
        printf("RecvPacket Fail\n");
#endif
        return -1;
    }
    if (PacketData.Data[0] != 1) { //!=OK
#ifdef Debug
        printf("NG\n");
#endif
        return -1;
    }
#ifdef Debug
    printf(" %d\n", TmpBuf[0]);
#endif

    return 1;
}

int WriteUserID(unsigned char ConnectorID, unsigned char *UserID)
{
    unsigned char Tmp = 0;
    unsigned char TmpBuf[255];
    struct ApplicationPacket PacketData;

    if (strlen(UserID) <= 0) {
        return -1;
    }
    memset(TmpBuf, 0, sizeof(TmpBuf));
    memset(&PacketData, 0, sizeof(struct ApplicationPacket));
    strcpy(TmpBuf, UserID);
#ifdef Debug
    printf("WriteUserID(%d) => ", ConnectorID);
#endif
    if (SendPacket(ConnectorID, 0x02, 0x0A, strlen(TmpBuf), TmpBuf) <= 0) {
#ifdef Debug
        printf("SendPacket Fail\n");
#endif
        return -1;
    }
    if (RecvPacket(&Tmp, &PacketData) <= 0) {
#ifdef Debug
        printf("RecvPacket Fail\n");
#endif
        return -1;
    }
    if (PacketData.Data[0] != 1) { //!=OK
#ifdef Debug
        printf("NG\n");
#endif
        return -1;
    }
#ifdef Debug
    printf(" StartUserId=%s, PacketData.Data[1]=%d\n", TmpBuf, PacketData.Data[1]);
#endif
    return PacketData.Data[1];
}

int ReadChargePermission(unsigned char PlugNum)
{
    unsigned char Tmp = 0;
    struct ApplicationPacket PacketData;


    memset(&PacketData, 0, sizeof(struct ApplicationPacket));
#ifdef Debug
    printf("ReadChargePermission[%d] => ", PlugNum);
#endif
    if (SendPacket(PlugNum, 0x01, 0x0B, 0, PacketData.Data) <= 0) {
#ifdef Debug
        printf("SendPacket Fail\n");
#endif
        return -1;
    }
    if (RecvPacket(&Tmp, &PacketData) <= 0) {
#ifdef Debug
        printf("RecvPacket Fail\n");
#endif
        return -1;
    }
    if (PacketData.Data[0] != 1) { //!=OK
#ifdef Debug
        printf("NG\n");
#endif
        return -1;
    }
#ifdef Debug
    printf(" %s\n", PacketData.Data[1] == 1 ? "Permitted" : "NOT permitted" );
#endif

    return PacketData.Data[1];
}

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

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

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

    return 0;
}

int MessageTrigger(unsigned char connectorID)
{
    struct timeb  NowTime;
    unsigned char Reg;
    for (Reg = 0; Reg < TriggerMsgeNum; Reg++) {
        ftime(&NowTime);
        switch (Reg) {
        case 3://ReadDoStatus
            if (DiffTimeb(TriggerTimeUp[connectorID - 1][Reg], NowTime) > 1000) {
                if (ReadDoStatus()) {
                    ftime(&TriggerTimeUp[connectorID - 1][Reg]);
                }
            }
            break;
        case 4://WriteDdStatus
            if (DiffTimeb(TriggerTimeUp[connectorID - 1][Reg], NowTime) > 1000) {
                if (WriteDdStatus()) {
                    ftime(&TriggerTimeUp[connectorID - 1][Reg]);
                }
            }
            break;
        /*case 5://ReadChargingCapability
            if(DiffTimeb(TriggerTimeUp[connectorID-1][Reg],NowTime)>200)
            {
                if(ReadChargingCapability(connectorID))
                {
                    ftime(&TriggerTimeUp[connectorID-1][Reg]);
                }
            }
            break;
        case 6://WriteChargingTarget
            if(DiffTimeb(TriggerTimeUp[connectorID-1][Reg],NowTime)>100)
            {
                if(WriteChargingTarget(connectorID))
                {
                    ftime(&TriggerTimeUp[connectorID-1][Reg]);
                }
            }
            break;*/
        case 8://WritePlugInStatus
            if (DiffTimeb(TriggerTimeUp[connectorID - 1][Reg], NowTime) > 1000) {
                if (WritePlugInStatus(connectorID)) {
                    ftime(&TriggerTimeUp[connectorID - 1][Reg]);
                }
            }
            break;
        case 9://WriteConnectorState
            if (DiffTimeb(TriggerTimeUp[connectorID - 1][Reg], NowTime) > 1000) {
                if (WriteConnectorState(connectorID)) {
                    ftime(&TriggerTimeUp[connectorID - 1][Reg]);
                }
            }
            break;
        /*case 0x0B://ReadChargePermission
            if(DiffTimeb(TriggerTimeUp[connectorID-1][Reg],NowTime)>1000)
            {
                if(ReadChargePermission(connectorID))
                {
                    ftime(&TriggerTimeUp[connectorID-1][Reg]);
                }
            }
            break;*/
        default:
            break;
        }
    }
}

int main(int argc, char *argv[])
{
    unsigned char Tmp, PlugNum;
    int Rtn;
    struct timeb  AuthNowTime;

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

ReConnect:
    memset(&PreSysWarningInfo, 0, sizeof(struct WARNING_CODE_INFO));
    PacketSe = 0;
    DisconnectFlag = 0;
    for (byte _index = 0; _index < ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; _index++) {
        if (!FindChargingInfoData(_index, &ChargingData[0])) {
            DEBUG_ERROR("FindChargingInfoData false \n");
            break;
        }
    }

    /**************** Check Network **********/
    DEBUG_INFO("Check Dispenser Network Information");
    while (!CheckNetworkStatus()) {
        sleep(1);
        if (DisconnectFlag >= 10) {
            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DisconnectedFromDo = 1;
        } else {
            DisconnectFlag++;
        }
    }
    DEBUG_INFO("Dispenser Network Information checked: IP=%s Netmask=%s, Gateway=%s",
               ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress,
               ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthSubmaskAddress,
               ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthGatewayAddress);

    /**************** Power cabinet connection **********/
    DEBUG_INFO("Connect to Power Cabinet");
    while (TcpConnected() < 0) {
        sleep(1);
        if (DisconnectFlag >= 5) {
            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DisconnectedFromDo = 1;
        } else {
            DisconnectFlag++;
        }
    }
    DEBUG_INFO("Power cabinet connected(TcpSock=%d): IP=%s Netmask=%s, Gateway=%s",
               TcpSock,
               ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthIpAddress,
               ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthSubmaskAddress,
               ShmSysConfigAndInfo->SysConfig.Eth0Interface.EthGatewayAddress);

    /**************** Write Model Name**********/
    DEBUG_INFO("Write Model Name");
    while (WriteModelName() < 0) {
        sleep(1);
        if (DisconnectFlag >= 5) {
            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DisconnectedFromDo = 1;
        } else {
            DisconnectFlag++;
        }
    }
    DEBUG_INFO("Write Model Name OK: %s", ShmSysConfigAndInfo->SysConfig.ModelName);

    /**************** Get Connector ID**********/
    DEBUG_INFO("Get Connector ID");
    while (ReadConnectorID() < 0) {
        sleep(1);
        if (DisconnectFlag >= 5) {
            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DisconnectedFromDo = 1;
        } else {
            DisconnectFlag++;
        }
    }
    DEBUG_INFO("Get Connector ID OK");
    /*while(1)
    {
        //for self testin main.c
        if(ShmSysConfigAndInfo->SysInfo.SelfTestSeq >= _STEST_PSU_DETECT)
        {
            ShmSysConfigAndInfo->SysInfo.SelfTestSeq = _STEST_PSU_CAP;
            break;
        }
    }*/
    for (Tmp = 0; Tmp < TriggerMsgeNum; Tmp++) {
        ftime(&TriggerTimeUp[0][Tmp]);
        ftime(&TriggerTimeUp[1][Tmp]);
        usleep(50000);
    }
    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DisconnectedFromDo = 0;
    DEBUG_INFO("Start Communication");
    /**************** Data transmission**********/
    while (1) {
        if ((ShmOCPP16Data->SpMsg.bits.AuthorizeReq == 1) || (ShmSysConfigAndInfo->SysInfo.AuthorizeFlag == 1)) {
            ftime(&AuthNowTime);
            if (DiffTimeb(TriggerTimeUp[0][10], AuthNowTime) > 1000) {
                Rtn = WriteUserID(ShmSysConfigAndInfo->SysInfo.CurGunSelected, ShmSysConfigAndInfo->SysConfig.UserId);
                if (Rtn >= 0) {
                    memset(ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status, 0, sizeof(ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status));
                    if (Rtn == 0) {
                        strcpy(ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status, "Invalid");
                    } else {
                        strcpy(ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status, "Accepted");
                    }
                    ShmOCPP16Data->SpMsg.bits.AuthorizeConf = 1; //isAuthorizedComplete
                    ShmOCPP16Data->SpMsg.bits.AuthorizeReq = 0;
                    ShmSysConfigAndInfo->SysInfo.AuthorizeFlag = 0;
                    ShmPsuData->SystemAvailablePower = 0;
                    ShmPsuData->SystemPresentPsuQuantity = 0;
                }
                ftime(&TriggerTimeUp[0][10]);
            }
        }

        for (PlugNum = 1; PlugNum <= ShmSysConfigAndInfo->SysConfig.TotalConnectorCount; PlugNum++) {
            //printf("ChargingData[PlugNum-1]->SystemStatus=%d\n",ChargingData[PlugNum-1]->SystemStatus);
            //printf("ShmOCPP16Data->SpMsg.bits.AuthorizeReq=%d\n",ShmOCPP16Data->SpMsg.bits.AuthorizeReq);
            //printf("ShmSysConfigAndInfo->SysInfo.AuthorizeFlag=%d\n",ShmSysConfigAndInfo->SysInfo.AuthorizeFlag);
            //printf("ChargingData[%d]->FireChargingVoltage=%f\n",PlugNum,ChargingData[PlugNum-1]->FireChargingVoltage);
            //printf("ChargingData[%d]->PresentChargingCurrent=%f\n",PlugNum,ChargingData[PlugNum-1]->PresentChargingCurrent);
            switch (ChargingData[PlugNum - 1]->SystemStatus) {
            case S_IDLE:
            case S_RESERVATION:
            case S_MAINTAIN:
            case S_ALARM:
            case S_AUTHORIZING:
                if ((ShmOCPP16Data->SpMsg.bits.AuthorizeReq == 1) || (ShmSysConfigAndInfo->SysInfo.AuthorizeFlag == 1)) {
                    ftime(&AuthNowTime);
                    if (DiffTimeb(TriggerTimeUp[PlugNum - 1][10], AuthNowTime) > 1000) {
                        Rtn = WriteUserID(ShmSysConfigAndInfo->SysInfo.CurGunSelected, ShmSysConfigAndInfo->SysConfig.UserId);
                        if (Rtn >= 0) {
                            memset(ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status, 0, sizeof(ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status));
                            if (Rtn == 0) {
                                strcpy(ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status, "Invalid");
                            } else {
                                strcpy(ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status, "Accepted");
                            }
                            ShmOCPP16Data->SpMsg.bits.AuthorizeConf = 1; //isAuthorizedComplete
                            ShmOCPP16Data->SpMsg.bits.AuthorizeReq = 0;
                            ShmSysConfigAndInfo->SysInfo.AuthorizeFlag = 0;
                            ShmPsuData->SystemAvailablePower = 0;
                            ShmPsuData->SystemPresentPsuQuantity = 0;
                            ftime(&TriggerTimeUp[PlugNum - 1][10]);

                        }
                        ftime(&TriggerTimeUp[PlugNum - 1][10]);
                    }
                }
                /*if(ReadSoftwareUpdate())//0x07
                {
                    //firmware update
                }*/
                break;
            case S_PREPARNING: //get permission
                //printf("S_PREPARNING\n");
                ftime(&AuthNowTime);
                if (DiffTimeb(TriggerTimeUp[PlugNum - 1][11], AuthNowTime) > 1000) {
                    if ((ReadChargePermission(PlugNum)) && (ReadChargingCapability(PlugNum))) {
                        ShmPsuData->SystemAvailablePower = ChargingData[0]->AvailableChargingPower + ChargingData[1]->AvailableChargingPower;
                        ShmPsuData->SystemPresentPsuQuantity = ShmPsuData->SystemAvailablePower / 30;
                    }
                    ftime(&TriggerTimeUp[PlugNum - 1][11]);
                }
                break;
            case S_PREPARING_FOR_EV://wait connector lock
                //printf("S_PREPARING_FOR_EV\n");
                ftime(&AuthNowTime);
                if (DiffTimeb(TriggerTimeUp[PlugNum - 1][5], AuthNowTime) > 1000) {
                    ReadChargingCapability(PlugNum);
                    ftime(&TriggerTimeUp[PlugNum - 1][5]);
                }
                ftime(&AuthNowTime);
                if (DiffTimeb(TriggerTimeUp[PlugNum - 1][11], AuthNowTime) > 1000) {
                    if (ReadChargePermission(PlugNum) == 0) {
                        DEBUG_INFO("Stop charging by power cabinet's permission");
                        ChargingData[PlugNum - 1]->StopChargeFlag = 1;
                    }
                    ftime(&TriggerTimeUp[PlugNum - 1][11]);
                }
                break;
            case S_PREPARING_FOR_EVSE: //insaulation test
            case S_CCS_PRECHARGE_ST0:
            case S_CCS_PRECHARGE_ST1:
                //printf("S_PREPARING_FOR_EVSE\n");
                WriteChargingTarget(PlugNum);
                ftime(&AuthNowTime);
                if (DiffTimeb(TriggerTimeUp[PlugNum - 1][5], AuthNowTime) > 1000) {
                    ReadChargingCapability(PlugNum);
                    ftime(&TriggerTimeUp[PlugNum - 1][5]);
                }
                ftime(&AuthNowTime);
                if (DiffTimeb(TriggerTimeUp[PlugNum - 1][11], AuthNowTime) > 1000) {
                    if (ReadChargePermission(PlugNum) == 0) {
                        DEBUG_INFO("Stop charging by power cabinet's permission");
                        ChargingData[PlugNum - 1]->StopChargeFlag = 1;
                    }
                    ftime(&TriggerTimeUp[PlugNum - 1][11]);
                }
                break;
            case S_CHARGING: //charging
            case S_TERMINATING:
                //printf("S_CHARGING,S_TERMINATING\n");
                ftime(&AuthNowTime);
                if (DiffTimeb(TriggerTimeUp[PlugNum - 1][5], AuthNowTime) > 1000) {
                    ReadChargingCapability(PlugNum);
                    ftime(&TriggerTimeUp[PlugNum - 1][5]);
                }
                ftime(&AuthNowTime);
                if (DiffTimeb(TriggerTimeUp[PlugNum - 1][11], AuthNowTime) > 1000) {
                    if (ReadChargePermission(PlugNum) == 0) {
                        DEBUG_INFO("Stop charging by power cabinet's permission");
                        ChargingData[PlugNum - 1]->StopChargeFlag = 1;
                    }
                    ftime(&TriggerTimeUp[PlugNum - 1][11]);
                }
                WriteChargingTarget(PlugNum);
                //printf("ChargingData[%d]->FireChargingVoltage=%f\n",PlugNum,ChargingData[PlugNum-1]->FireChargingVoltage);
                //printf("ChargingData[%d]->PresentChargingCurrent=%f\n",PlugNum,ChargingData[PlugNum-1]->PresentChargingCurrent);
                break;
            default:
                break;
            }//switch   case
            MessageTrigger(PlugNum);
        }//for connector #
        if (DisconnectFlag >= 10) {
            if (ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DisconnectedFromDo == 0) {
                ShmStatusCodeData->AlarmCode.AlarmEvents.bits.DisconnectedFromDo = 1;
                DEBUG_INFO("Disconnected from power cabinet...re-connecting");
            }
            goto ReConnect;
        }
    }//while(1)
}