/*===========================================================================
                    Combined Charging System (CCS): SECC
                                 CsuComm.c

                        initiated by Vern, Joseph
                           (since 2019/07/19)
=============================================================================*/
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <linux/termios.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/mman.h>
#include <linux/sockios.h>
#include <linux/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <math.h>//for pow
#include <net/if.h>
#include <linux/can.h>
#include <linux/can/raw.h>
#include <unistd.h>
#include "define.h"
#include "CsuComm.h"

//#define Debug

//Protocol format : Dir
#define SendDirection               0x08000000
#define RecvDirection               0x00000000
//Protocol format : Message ID
#define MsgAddressRequest           0x00000100
#define MsgAddressAssign            0x00000200
#define MsgStatusNotification       0x00000300
#define MsgGetFwVersion             0x00000400
#define MsgGetHwVersion             0x00000500
#define MsgChargingPermission       0x00000600
#define MsgPresentOutputPower       0x00000700
#define MsgPresentOutputCapacity    0x00000800
#define MsgGetOutputRequirement     0x00000900
#define MsgGetEvBatteryInfo         0x00000A00
#define MsgEvStopEvent              0x00000B00
#define MsgEvseStopEvent            0x00000C00
#define MsgGetMiscInfo              0x00000D00
#define MsgDownloadRequest          0x00000E00
#define MsgStartBlockTransfer       0x00000F00
#define MsgDataTransfer             0x00001000
#define MsgDownloadFinish           0x00001100

struct SysConfigAndInfo     *ShmSysConfigAndInfo;
struct StatusCodeData       *ShmStatusCodeData;
struct CcsData              *ShmCcsData;
struct InternalComm         *ShmInternalComm;
pid_t CANReceiverPid;
int CanFd;

#ifdef SystemLogMessage
    int StoreLogMsg(unsigned char *DataString)
    {
        unsigned char Buf[256];
        time_t CurrentTime;
        struct tm *tm;

        memset(Buf, 0, sizeof(Buf));
        CurrentTime = time(NULL);
        tm = localtime(&CurrentTime);
        sprintf(Buf, "echo \"%04d.%02d.%02d %02d:%02d:%02d - %s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog",
                tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
                DataString,
                tm->tm_year + 1900, tm->tm_mon + 1);
        system(Buf);

        #ifdef Debug
            printf("%s \n", DataString);
        #endif
    }
#endif

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;
}

/**************************************************************************************/
/**************************Init all share memory *********************************/
/**************************************************************************************/
int InitShareMemory()
{
    int MeterSMId;

    //creat ShmSysConfigAndInfo
    if((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo),  0777)) < 0)
    {
        #ifdef SystemLogMessage
            StoreLogMsg("[CsuComm]InitShareMemory:shmget ShmSysConfigAndInfo NG");
        #endif
        return 0;
    }
    else if((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *)-1)
    {
        #ifdef SystemLogMessage
            StoreLogMsg("[CsuComm]InitShareMemory:shmat ShmSysConfigAndInfo NG");
        #endif
        return 0;
    }

    //creat ShmStatusCodeData
    if((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  0777)) < 0)
    {
        #ifdef SystemLogMessage
            StoreLogMsg("[CsuComm]InitShareMemory:shmget ShmStatusCodeData NG");
        #endif
        return 0;
    }
    else if((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *)-1)
    {
        #ifdef SystemLogMessage
            StoreLogMsg("[CsuComm]InitShareMemory:shmat ShmStatusCodeData NG");
        #endif
        return 0;
    }

    //creat ShmCcsData
    if((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData),  0777)) < 0)
    {
        #ifdef SystemLogMessage
            StoreLogMsg("[CsuComm]InitShareMemory:shmget ShmCcsData NG");
        #endif
        return 0;
    }
    else if((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *)-1)
    {
        #ifdef SystemLogMessage
            StoreLogMsg("[CsuComm]InitShareMemory:shmat ShmCcsData NG");
        #endif
        return 0;
    }

    //creat ShmInternalComm
    if((MeterSMId = shmget(ShmInternalCommKey, sizeof(struct InternalComm),  IPC_CREAT | 0777)) < 0)
    {
        #ifdef SystemLogMessage
            StoreLogMsg("[CsuComm]InitShareMemory:shmget ShmInternalComm NG");
        #endif
        return 0;
    }
    else if((ShmInternalComm = shmat(MeterSMId, NULL, 0)) == (void *)-1)
    {
        #ifdef SystemLogMessage
            StoreLogMsg("[CsuComm]InitShareMemory:shmat ShmInternalComm NG");
        #endif
        return 0;
    }

    memset(ShmInternalComm, 0, sizeof(struct InternalComm));
    return 1;
}

int InitCanBus()
{
    int s0, nbytes;
    struct timeval tv;
    struct ifreq ifr0;
    struct sockaddr_can addr0;

    system("/sbin/ip link set can0 type can bitrate 500000 restart-ms 100");
    system("/sbin/ip link set can0 up");

    s0 = socket(PF_CAN, SOCK_RAW, CAN_RAW);

    tv.tv_sec = 0;
    tv.tv_usec = 10000;

    if(setsockopt(s0, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct timeval)) < 0)
    {
        #ifdef SystemLogMessage
            StoreLogMsg("[CsuComm]InitCanBus:Set SO_RCVTIMEO NG");
        #endif
    }

    nbytes = 40960;

    if(setsockopt(s0, SOL_SOCKET,  SO_RCVBUF, &nbytes, sizeof(int)) < 0)
    {
        #ifdef SystemLogMessage
            StoreLogMsg("[CsuComm]InitCanBus:Set SO_RCVBUF NG");
        #endif
    }

    nbytes = 40960;

    if(setsockopt(s0, SOL_SOCKET, SO_SNDBUF, &nbytes, sizeof(int)) < 0)
    {
        #ifdef SystemLogMessage
            StoreLogMsg("[CsuComm]InitCanBus:Set SO_SNDBUF NG");
        #endif
    }

    strcpy(ifr0.ifr_name, "can0" );
    ioctl(s0, SIOCGIFINDEX, &ifr0); /* ifr.ifr_ifindex gets filled with that device's index */
    addr0.can_family = AF_CAN;
    addr0.can_ifindex = ifr0.ifr_ifindex;
    bind(s0, (struct sockaddr *)&addr0, sizeof(addr0));
    return s0;
}

int SendMsg(int Fd, unsigned int MsgId, unsigned char SlaveAddress, unsigned char DataLength, unsigned char *SendData)
{
    struct can_frame frame;
    struct timeb StartTime, EndTime;
    unsigned int tmp = 0;
    int nbytes;

    memset(&frame, 0, sizeof(struct can_frame));
    frame.can_id = 0x80000000 | SendDirection | MsgId | SlaveAddress;
    frame.can_dlc = DataLength;
    memcpy(frame.data, SendData, DataLength);
    nbytes = write(Fd, &frame, sizeof(struct can_frame));
    #ifdef Debug
        printf("[CsuComm]SendMsg => Send to ID=0x%x, nbytes=0x%x, DataLength=0x%x, Data=0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x,0x%x\n",
               frame.can_id, nbytes, frame.can_dlc,
               frame.data[0], frame.data[1], frame.data[2], frame.data[3], frame.data[4], frame.data[5], frame.data[6], frame.data[7]);
    #endif
    return nbytes;
}

int SendFwVersion(int Fd)
{
    int nbytes;
    unsigned char Buffer[4];

    memset(Buffer, 0, sizeof(Buffer));
    nbytes = FirmwareVersion;
    memcpy(Buffer, &nbytes, sizeof(int));
    nbytes = SendMsg(Fd, MsgGetFwVersion, ShmInternalComm->SlaveAddress, sizeof(int), Buffer);
    return nbytes;
}

int SendHwVersion(int Fd)
{
    int nbytes;
    unsigned char Buffer[4];

    memset(Buffer, 0, sizeof(Buffer));
    nbytes = FirmwareVersion;
    memcpy(Buffer, &nbytes, sizeof(int));
    nbytes = SendMsg(Fd, MsgGetFwVersion, ShmInternalComm->SlaveAddress, sizeof(int), Buffer);
    return nbytes;
}

int SendStatusNotification(int Fd)
{
    int nbytes;
    unsigned char Buffer[8];

    memset(Buffer, 0, sizeof(Buffer));
    Buffer[0] = ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].ConnectorPlugIn;
    Buffer[1] = ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState;

    if(strlen(ShmStatusCodeData->PresentStatusCode[0]) > 0)
    {
        memcpy(Buffer + 2, ShmStatusCodeData->PresentStatusCode[0], 6);
    }

    nbytes = SendMsg(Fd, MsgStatusNotification, ShmInternalComm->SlaveAddress, 8, Buffer);
    return nbytes;
}

float DIN70121PhyValDecode(struct PhysicalValueType_DIN70121 PhysicalData)
{
    short DataValue;
    int DataMultiplier;
    float Rtn;

    DataValue = PhysicalData.Value;
    DataMultiplier = PhysicalData.Multiplier;

    switch(PhysicalData.Unit)
    {
    case h_DIN70121:
        Rtn = (DataValue * (10 ^ DataMultiplier) * 60 * 60);
        return Rtn;

    case m_DIN70121:
        Rtn = (DataValue * (10 ^ DataMultiplier) * 60);
        return Rtn;

    case s_DIN70121:
    case A_DIN70121:
    case V_DIN70121:
        Rtn = (DataValue * (10 ^ DataMultiplier));
        return Rtn;

    case Ah_DIN70121:
        Rtn = (DataValue * (10 ^ DataMultiplier));
        return Rtn;

    case VA_DIN70121:
    case W_DIN70121:
        Rtn = (DataValue * (10 ^ DataMultiplier) / 1000);
        return Rtn;    //kW

    case Wh_DIN70121:
        Rtn = (DataValue * (10 ^ DataMultiplier) / 1000);
        return Rtn;    //kWh
    }
}

float ISO151182014PhyValDecode(struct PhysicalValueType_ISO15118_2014 PhysicalData)
{
    short DataValue;
    int DataMultiplier;
    float Rtn;

    DataValue = PhysicalData.Value;
    DataMultiplier = PhysicalData.Multiplier;

    switch(PhysicalData.Unit)
    {
    case h_ISO15118_2014:
        Rtn = (DataValue * (10 ^ DataMultiplier) * 60 * 60);
        return Rtn;

    case m_ISO15118_2014:
        Rtn = (DataValue * (10 ^ DataMultiplier) * 60);
        return Rtn;

    case s_ISO15118_2014:
    case A_ISO15118_2014:
    case V_ISO15118_2014:
        Rtn = (DataValue * (10 ^ DataMultiplier));
        return Rtn;

    case W_ISO15118_2014:
        Rtn = (DataValue * (10 ^ DataMultiplier) / 1000);
        return Rtn;    //kW

    case Wh_ISO15118_2014:
        Rtn = (DataValue * (10 ^ DataMultiplier) / 1000);
        return Rtn;    //kWh
    }
}

int SendOutputReq(int Fd)
{
    int nbytes;
    unsigned char Buffer[8];
    unsigned short TmpValue;

    memset(Buffer, 0, sizeof(Buffer));

    if(ShmCcsData->CommProtocol == 1)
    {
        //DIN70121
        Buffer[0] = ShmCcsData->V2GMessage_DIN70121.PresentMsgFlowStatus;
        Buffer[1] = ShmCcsData->V2GMessage_DIN70121.CurrentDemandRequest.DC_EVStatus.EVRESSSOC;

        TmpValue = DIN70121PhyValDecode(ShmCcsData->V2GMessage_DIN70121.CurrentDemandRequest.EVTargetVoltage) * 10;
        memcpy(Buffer + 2, &TmpValue, 2);
        TmpValue = DIN70121PhyValDecode(ShmCcsData->V2GMessage_DIN70121.CurrentDemandRequest.EVTargetCurrent) * 10;
        memcpy(Buffer + 4, &TmpValue, 2);
        TmpValue = DIN70121PhyValDecode(ShmCcsData->V2GMessage_DIN70121.CurrentDemandRequest.RemainingTimeToFullSoC);
        memcpy(Buffer + 6, &TmpValue, 2);
    }
    else if(ShmCcsData->CommProtocol == 2)
    {
        //ISO15118_2014
        Buffer[0] = ShmCcsData->V2GMessage_ISO15118_2014.PresentMsgFlowStatus;
        Buffer[1] = ShmCcsData->V2GMessage_ISO15118_2014.CurrentDemandRequest.DC_EVStatus.EVRESSSOC;

        TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.CurrentDemandRequest.EVTargetVoltage) * 10;
        memcpy(Buffer + 2, &TmpValue, 2);
        TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.CurrentDemandRequest.EVTargetCurrent) * 10;
        memcpy(Buffer + 4, &TmpValue, 2);
        TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.CurrentDemandRequest.RemainingTimeToFullSoC);
        memcpy(Buffer + 6, &TmpValue, 2);
    }

    nbytes = SendMsg(Fd, MsgStatusNotification, ShmInternalComm->SlaveAddress, 8, Buffer);
    return nbytes;
}

int SendBatteryInfo(int Fd)
{
    int nbytes;
    unsigned char Buffer[8];
    unsigned short TmpValue;

    memset(Buffer, 0, sizeof(Buffer));

    if((ShmCcsData->CommProtocol == 2) && (ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.RequestedEnergyTransferMode <= 1))
    {
        Buffer[0] = 1;//AC
    }
    else
    {
        Buffer[0] = 0;//DC
    }

    if(ShmCcsData->CommProtocol == 1)
    {
        //DIN70121
        TmpValue = DIN70121PhyValDecode(ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.EVEnergyCapacity) * 10;
        memcpy(Buffer + 1, &TmpValue, 2);
        TmpValue = DIN70121PhyValDecode(ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.EVMaximumVoltageLimit) * 10;
        memcpy(Buffer + 3, &TmpValue, 2);
        TmpValue = DIN70121PhyValDecode(ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.EVMaximumCurrentLimit) * 10;
        memcpy(Buffer + 5, &TmpValue, 2);
    }
    else if(ShmCcsData->CommProtocol == 2)
    {
        //ISO15118_2014
        if(Buffer[0] == 0)
        {
            //DC
            TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.EVEnergyCapacity) * 10;
            memcpy(Buffer + 1, &TmpValue, 2);
            TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.EVMaximumVoltageLimit) * 10;
            memcpy(Buffer + 3, &TmpValue, 2);
            TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.EVMaximumCurrentLimit) * 10;
            memcpy(Buffer + 5, &TmpValue, 2);
        }
        else
        {
            //AC
            TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.AC_EVChargeParameter.EAmount) * 10;
            memcpy(Buffer + 1, &TmpValue, 2);
            TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.AC_EVChargeParameter.EVMaxVoltage) * 10;
            memcpy(Buffer + 3, &TmpValue, 2);
            TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.AC_EVChargeParameter.EVMaxCurrent) * 10;
            memcpy(Buffer + 5, &TmpValue, 2);
        }
    }

    nbytes = SendMsg(Fd, MsgStatusNotification, ShmInternalComm->SlaveAddress, 7, Buffer);
    return nbytes;
}

int SendStopEvent(int Fd)
{
    int nbytes;
    unsigned char Buffer[8];

    memset(Buffer, 0, sizeof(Buffer));
    Buffer[0] = 0x01;

    if(strlen(ShmStatusCodeData->PresentStatusCode[0]) > 0)
    {
        memcpy(Buffer + 2, ShmStatusCodeData->PresentStatusCode[0], 6);
    }

    nbytes = SendMsg(Fd, MsgStatusNotification, ShmInternalComm->SlaveAddress, 7, Buffer);
    return nbytes;
}

int SendMiscInfo(int Fd)
{
    int nbytes;
    unsigned char Buffer[8];
    unsigned short TmpValue;

    memset(Buffer, 0, sizeof(Buffer));
    Buffer[0] = ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].ConnectorPlugIn;
    TmpValue = ShmSysConfigAndInfo->SysInfo.CcsConnectorTemp;
    memcpy(Buffer + 1, &TmpValue, 2);
    Buffer[3] = (unsigned char)(ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotVoltage * 10);
    Buffer[4] = ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState;
    nbytes = SendMsg(Fd, MsgStatusNotification, ShmInternalComm->SlaveAddress, 7, Buffer);
    return nbytes;
}

/**************************************************************/
/************** Receiving Task*******************************/
/*************************************************************/
void CANReceiver(int fd)
{
    pid_t tmp = 0;
    struct can_frame frame;
    int nbytes;
    unsigned char FanspeedGetTime = 0;

    if(CANReceiverPid == 0)
    {
        tmp = fork();

        if(tmp > 0)
        {
            CANReceiverPid = tmp;
            {
                unsigned char buf[64];
                memset(buf, 0, sizeof(buf));
                sprintf(buf, "renice -20 -p %d", tmp);
                system(buf);
            }
            return;
        }
    }

    while(1)
    {
        memset(&frame, 0, sizeof(struct can_frame));
        nbytes = read(fd, &frame, sizeof(struct can_frame));

        if((frame.can_id == 0) || (frame.can_id & 0x08000000) || (((frame.can_id & 0x000000FF) != ShmInternalComm->SlaveAddress) && ((frame.can_id & 0x000000FF) != 0)))
        {
            continue;
        }

        switch(frame.can_id & 0x0000FF00)//Message ID
        {
        case MsgGetFwVersion:
            ShmInternalComm->InternalCommUnion.bits.FwVersion = 1;
            break;

        case MsgGetHwVersion:
            ShmInternalComm->InternalCommUnion.bits.HwVersion = 1;
            break;

        case MsgChargingPermission:
            ShmInternalComm->ChargingPermission = frame.data[0];
            ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].AvailableChargingPower = (float)((unsigned int)frame.data[2] << 8 | frame.data[1]) / 10;
            ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].AvailableChargingCurrent = (float)((unsigned int)frame.data[4] << 8 | frame.data[3]) / 10;
            ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].MaximumChargingVoltage = (float)((unsigned int)frame.data[6] << 8 | frame.data[5]) / 10;
            break;

        case MsgPresentOutputPower:

            if(ShmInternalComm->SlaveAddress == 1)
            {
                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PresentChargingVoltage = (float)((unsigned int)frame.data[1] << 8 | frame.data[0]) / 10;
                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PresentChargingCurrent = (float)((unsigned int)frame.data[3] << 8 | frame.data[2]) / 10;
            }
            else
            {
                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PresentChargingVoltage = (float)((unsigned int)frame.data[5] << 8 | frame.data[4]) / 10;
                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PresentChargingCurrent = (float)((unsigned int)frame.data[7] << 8 | frame.data[6]) / 10;
            }

            break;

        case MsgPresentOutputCapacity:

            if(ShmInternalComm->SlaveAddress == 1)
            {
                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].AvailableChargingPower = (float)((unsigned int)frame.data[1] << 8 | frame.data[0]) / 10;
                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].AvailableChargingCurrent = (float)((unsigned int)frame.data[3] << 8 | frame.data[2]) / 10;
            }
            else
            {
                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].AvailableChargingPower = (float)((unsigned int)frame.data[5] << 8 | frame.data[4]) / 10;
                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].AvailableChargingCurrent = (float)((unsigned int)frame.data[7] << 8 | frame.data[6]) / 10;
            }

            break;

        case MsgGetOutputRequirement:
            ShmInternalComm->InternalCommUnion.bits.OutputRequirement = 1;
            break;

        case MsgGetEvBatteryInfo:
            ShmInternalComm->InternalCommUnion.bits.EvBatteryInfo = 1;
            break;

        case MsgEvseStopEvent:
            break;

        case MsgGetMiscInfo:
            ShmInternalComm->InternalCommUnion.bits.MiscInfo = 1;
            break;

        case MsgDownloadRequest:
            break;

        case MsgStartBlockTransfer:
            break;

        case MsgDataTransfer:
            break;

        case MsgDownloadFinish:
            break;
        }
    }
}

/**************************************************************/
/************** main function***********************************/
/*************************************************************/
int main(int argc, char *argv[])
{
    int CanFd;
    struct can_frame frame;
    struct timeb StartTime, EndTime;
    unsigned int TmpValue;
    unsigned char Buffer[8];

    //Initialization
    if(InitShareMemory() == 0)
    {
        #ifdef SystemLogMessage
            StoreLogMsg("[CsuComm]main:InitShareMemory NG");
        #endif

        if(ShmStatusCodeData != NULL)
        {
            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory = 1;
        }

        sleep(5);
        return 0;
    }

    CanFd = InitCanBus();
    CANReceiverPid = 0;

    ShmInternalComm->SlaveAddress = 0xFF;

    //Address Request
    while(ShmInternalComm->SlaveAddress == 0xFF)
    {
        ftime(&StartTime);
        ftime(&EndTime);
        srandom(StartTime.millitm);
        TmpValue = random();
        #ifdef Debug
            printf("[CsuComm]main => TmpValue=%d\n", TmpValue);
        #endif
        memset(Buffer, 0, sizeof(Buffer));
        memcpy(Buffer, &TmpValue, sizeof(int));
        SendMsg(CanFd, MsgAddressRequest, ShmInternalComm->SlaveAddress, 4, Buffer);

        while(DiffTimeb(StartTime, EndTime) < 100)//resend interval: 100ms
        {
            unsigned int TmpValue2 = 0;
            ftime(&EndTime);
            memset(&frame, 0, sizeof(struct can_frame));
            read(CanFd, &frame, sizeof(struct can_frame));

            if((frame.can_id == 0) || (frame.can_id & 0x08000000) || ((frame.can_id & 0x0000FF00) != MsgAddressAssign) || (frame.can_dlc != 4))
            {
                continue;
            }

            memcpy(&TmpValue2, frame.data, sizeof(int));

            if(TmpValue2 == TmpValue)
            {
                ShmInternalComm->SlaveAddress = frame.can_id & 0x000000FF;
                #ifdef SystemLogMessage
                    {
                        unsigned char Buffer[128];
                        memset(Buffer, 0, sizeof(Buffer));
                        sprintf(Buffer, "[CsuComm]main: ShmCcsData->SlaveAddres=%d", ShmInternalComm->SlaveAddress);
                        StoreLogMsg(Buffer);
                    }
                #endif
                #ifdef Debug
                    printf("[CsuComm]main => ShmCcsData->SlaveAddres=0x%x\n", ShmCcsData->SlaveAddres);
                #endif
                break;
            }
        }
    }

    CANReceiver(CanFd);
    //main loop
    ftime(&StartTime);

    while(1)
    {
        ftime(&EndTime);

        if(DiffTimeb(StartTime, EndTime) >= 1000)
        {
            SendStatusNotification(CanFd);
            ftime(&StartTime);
        }

        if(ShmInternalComm->InternalCommUnion.bits.FwVersion == 1)
        {
            SendFwVersion(CanFd);
            ShmInternalComm->InternalCommUnion.bits.FwVersion = 0;
        }

        if(ShmInternalComm->InternalCommUnion.bits.HwVersion == 1)
        {
            SendHwVersion(CanFd);
            ShmInternalComm->InternalCommUnion.bits.HwVersion = 0;
        }

        if(ShmInternalComm->InternalCommUnion.bits.OutputRequirement == 1)
        {
            SendOutputReq(CanFd);
            ShmInternalComm->InternalCommUnion.bits.OutputRequirement = 0;
        }

        if(ShmInternalComm->InternalCommUnion.bits.EvBatteryInfo == 1)
        {
            SendBatteryInfo(CanFd);
            ShmInternalComm->InternalCommUnion.bits.EvBatteryInfo = 0;
        }

        if(ShmInternalComm->InternalCommUnion.bits.MiscInfo == 1)
        {
            SendMiscInfo(CanFd);
            ShmInternalComm->InternalCommUnion.bits.MiscInfo = 0;
        }

    }

EndProcess:

    if(CANReceiverPid > 0)
    {
        char Buf[32];
        memset(Buf, 0, 32);
        sprintf(Buf, "kill %d", CANReceiverPid);
        system(Buf);
    }

    close(CanFd);
    system("/sbin/ip link set can0 down");
    system("/sbin/ip link set can0 type can bitrate 500000 restart-ms 100");
    system("/sbin/ip link set can0 up");
    system("/sbin/ip link set can0 down");
    system("killall CsuComm");
}