csu3_am335x/EVSE/Projects/ATE/Apps/Module_EvComm.c

#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 	<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"
#include 	"Module_EvComm.h"
#include 	"VCCU.h"

#define Debug
#define ARRAY_SIZE(A)		(sizeof(A) / sizeof(A[0]))
#define PASS				1
#define FAIL				-1
#define START				1
#define STOP				0
#define YES					1
#define NO					0
#define DEMO 				0

struct SysConfigAndInfo         *ShmSysConfigAndInfo;
struct StatusCodeData           *ShmStatusCodeData;
struct FanModuleData            *ShmFanModuleData;
struct RelayModuleData          *ShmRelayModuleData;
struct LedModuleData            *ShmLedModuleData;
struct PsuData                  *ShmPsuData;
struct OCPP16Data               *ShmOCPP16Data;
byte gunCount;
byte gun_count = CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY;
int chargingTime[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];

float maxChargingVol = 5000;			// 限制最大充電電壓，如依照模塊則填上 0
float maxChargingCur = 100;				// 限制最大充電電流，如依照模塊則填上 0
int maxValue = 950;

int gbmaxValue = 7500;
int whileLoopTime = 500000;//45000;//500ms//10000; // 10 ms

int soc = 70;
// 槍資訊
struct ChargingInfoData *_chargingData[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];

byte normalStop = 0x01;
byte stopReason[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
byte evstaus[5] = { 0x01, 0x02, 0x03, 0x04, 0x05 };

struct Ev_Board_Cmd Ev_Cmd={
		0,
		0x00000200,
		0x00000400,
		0x00000500,
		0x00000600,
		0x00000700,
		0x00000800,
		0x00000900,
		0x00000A00,
		0x00000C00,
		0x00000D00,

		0x00000E00,
		0x00000F00,
		0x00001000,
		0x00001100,

		0x00001200,
		0x00001500,
};

//==========================================
// Init all share memory
//==========================================
int InitShareMemory()
{
    int result = PASS;
    int MeterSMId;

    if ((MeterSMId = shmget(ShmSysConfigAndInfoKey,	sizeof(struct SysConfigAndInfo), IPC_CREAT | 0777)) < 0)
    {
        #ifdef SystemLogMessage
    	printf("EV shmget ShmSysConfigAndInfo NG\n");
        #endif
        result = FAIL;
    }
    else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
        #ifdef SystemLogMessage
    	printf("[shmat ShmSysConfigAndInfo NG\n");
        #endif
        result = FAIL;
     }

    if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),   IPC_CREAT | 0777)) < 0)
    {
        #ifdef SystemLogMessage
    	printf("shmget ShmStatusCodeData NG\n");
        #endif
        result = FAIL;
    }
    else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
        #ifdef SystemLogMessage
    	printf("shmat ShmStatusCodeData NG\n");
        #endif
        result = FAIL;
    }

    if ((MeterSMId = shmget(ShmFanBdKey, sizeof(struct FanModuleData),   IPC_CREAT | 0777)) < 0)
    {
        #ifdef SystemLogMessage
    	printf("shmget ShmFanModuleData NG\n");
        #endif
        result = FAIL;
    }
    else if ((ShmFanModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
        #ifdef SystemLogMessage
    	printf("shmat ShmFanModuleData NG\n");
        #endif
        result = FAIL;
     }
     memset(ShmFanModuleData,0,sizeof(struct FanModuleData));

    if ((MeterSMId = shmget(ShmRelayBdKey, sizeof(struct RelayModuleData),   IPC_CREAT | 0777)) < 0)
    {
        #ifdef SystemLogMessage
    	printf("shmget ShmRelayModuleData NG\n");
        #endif
        result = FAIL;
    }
    else if ((ShmRelayModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
        #ifdef SystemLogMessage
    	printf("shmat ShmRelayModuleData NG\n");
        #endif
        result = FAIL;
    }
    memset(ShmRelayModuleData,0,sizeof(struct RelayModuleData));

    if ((MeterSMId = shmget(ShmLedBdKey, sizeof(struct LedModuleData),  IPC_CREAT |  0777)) < 0)
    {
        #ifdef SystemLogMessage
    	printf("shmget ShmLedModuleData NG\n");
        #endif
        result = FAIL;
    }
    else if ((ShmLedModuleData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
        #ifdef SystemLogMessage
    	printf("shmat ShmLedModuleData NG\n");
        #endif
        result = FAIL;
    }
    memset(ShmLedModuleData,0,sizeof(struct LedModuleData));

    if ((MeterSMId = shmget(ShmPsuKey, sizeof(struct PsuData),   IPC_CREAT | 0777)) < 0)
    {
        #ifdef SystemLogMessage
    	printf("shmget ShmPsuData NG \n");
        #endif
        result = FAIL;
    }
    else if ((ShmPsuData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
    {
        #ifdef SystemLogMessage
    	printf("shmat ShmPsuData NG \n");
        #endif
        result = FAIL;
    }


    return result;
}

int InitCanBus()
{
    int s0, nbytes;
    struct timeval tv;
    struct ifreq ifr0;
    struct sockaddr_can addr0;
    /*
    //can0
    system("/sbin/ip link set can0 down");//先將interface disable
    system("/sbin/ip link set can0 type can bitrate 500000 restart-ms 100");
    system("/sbin/ip link set can0 up");
    */

    //can1
    system("/sbin/ip link set can0 down");//先將interface disable
    system("/sbin/ip link set can0 type can bitrate 250000 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" );
    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 CHROMAInitCanBus()
{
	int 					s0,nbytes;
		struct timeval			tv;
		struct ifreq 			ifr0;
		struct sockaddr_can		addr0;

		system("/sbin/ip link set can1 down");
		system("/sbin/ip link set can1 type can bitrate 500000 restart-ms 100");
		system("/sbin/ip link set can1 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
			//DEBUG_ERROR("Set SO_RCVTIMEO NG");
			#endif
		}
		nbytes=40960;
		if (setsockopt(s0, SOL_SOCKET,  SO_RCVBUF, &nbytes, sizeof(int)) < 0)
		{
			#ifdef SystemLogMessage
			//DEBUG_ERROR("Set SO_RCVBUF NG");
			#endif
		}
		nbytes=40960;
		if (setsockopt(s0, SOL_SOCKET, SO_SNDBUF, &nbytes, sizeof(int)) < 0)
		{
			#ifdef SystemLogMessage
			//DEBUG_ERROR("Set SO_SNDBUF NG");
			#endif
		}

	   	strcpy(ifr0.ifr_name, "can1" );
		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;
}


bool CheckUniqNumber(byte value)
{
	for (byte index = 0; index < gun_count; index++)
	{
		if (_chargingData[index]->Evboard_id == value)
		{
			struct timeval _end_time;
			gettimeofday(&_end_time, NULL);
			unsigned long diff = 1000000 *	(_end_time.tv_sec - _id_assign_time.tv_sec) + _end_time.tv_usec - _id_assign_time.tv_usec;
			if (diff >= 3000000)
			{
				gettimeofday(&_id_assign_time, NULL);
				return true;
			}
			else
			{
				return false;
			}
		}
	}

	gettimeofday(&_id_assign_time, NULL);
	return true;
}

void AddrAssignment(byte *data)
{
	byte target_number[8];
	byte index = 0x00;

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

	if (CheckUniqNumber(index))
	{
		//printf("EV board id = %x \n", index);
		if (index < 1)
			return;

		printf("SetTargetAddr \n");
		SetTargetAddr(target_number, index);
	}
}

void setATEMode(byte gun_index, byte mode)
{
	_chargingData[gun_index]->ATEStatus = mode;
}

void setStatusMode(byte gun_index, byte mode)
{
	_chargingData[gun_index]->ATEStatus = mode;
}

unsigned char isStatusChange(unsigned char gun_index)
{
	unsigned char result = NO;
	if(_chargingData[gun_index]->ATEStatus != _chargingData[gun_index]->PreviousATEStatus)
	{
		result = YES;
		_chargingData[gun_index]->PreviousATEStatus = _chargingData[gun_index]->ATEStatus;

	}
	return result;
}

int bitExtracted(byte number, int k, int p)
{
    return (((1 << k) - 1) & (number >> (p - 1)));
}

unsigned short bitextract(unsigned short value, int begin, int end)
{
	unsigned short mask = (1 << (end - begin)) - 1;
    return (value >> begin) & mask;
}

//接收can
void CANReceiver()
{
	pid_t canRecPid;
	canRecPid = fork();
	if(canRecPid > 0){
		int nbytes;
		struct can_frame frame;
		int intCmd;
		while (1){
			if(ShmSysConfigAndInfo->ate.ATEState  == 1){
				//清空 canbus recever buf
				memset(&frame, 0, sizeof(struct can_frame));
				//讀取 canbus 是否有接收到封包
				nbytes = read(CanFd, &frame, sizeof(struct can_frame));
				//如果有收到 canbus 封包
				if (nbytes > 0){
					intCmd = (int) (frame.can_id & CAN_EFF_MASK);//extended frame format
					#ifdef Debug
						//printf("hsout0StatusChange Get-INFYPWR-Msg : %08x - %02x %02x %02x %02x %02x %02x %02x %02x\n ", intCmd, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7] );
						//printf(" Get-Msg : %08X - %02x %02x %02x %02x %02x %02x %02x %02x\n ", frame.can_id, 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
					switch (intCmd){
						case VCCU_ChargeFromVehicleId:{
							//memcpy(&ShmSysConfigAndInfo->ate.vccu.chargeFromVehicle, &frame.data, frame.can_dlc);

							ShmSysConfigAndInfo->ate.vccu.chargeFromVehicle.VCCU_Vehicle_ContactorVoltage = ((short) frame.data[1] << 8) + (short) frame.data[0];
							ShmSysConfigAndInfo->ate.vccu.chargeFromVehicle.VCCU_Vehicle_LinkVoltage = ((short) frame.data[3] << 8) + (short) frame.data[2];
							ShmSysConfigAndInfo->ate.vccu.chargeFromVehicle.DATA.bits.VCCU_Vehicle_IsolationMeasurem = bitextract(frame.data[4],0, 2);//((short) frame.data[4] >> 0)+((short) frame.data[4] >> 1);//((short) frame.data[4] << 2);
							ShmSysConfigAndInfo->ate.vccu.chargeFromVehicle.DATA.bits.VCCU_Vehicle_PlugLockPermissio = bitextract(frame.data[4],2, 4);//((short) frame.data[4] >> 2)+((short) frame.data[4] >> 3);
							ShmSysConfigAndInfo->ate.vccu.chargeFromVehicle.DATA.bits.VCCU_Vehicle_PlugUnlockPermiss = bitextract(frame.data[4],4, 6);//((short) frame.data[4] >> 4)+((short) frame.data[4] >> 5);
							ShmSysConfigAndInfo->ate.vccu.chargeFromVehicle.DATA.bits.VCCU_Vehicle_ChargePermission  = bitextract(frame.data[4],6, 8);//((short) frame.data[4] >> 6)+((short) frame.data[4] >> 7);
							ShmSysConfigAndInfo->ate.vccu.chargeFromVehicle.bits.VCCU_Vehicle_ContactorStatus  = bitextract(frame.data[5],0, 2);

							//memset(&ShmSysConfigAndInfo->ate.vccu.chargeFromVehicle,*frame.data, frame.can_dlc);
							break;
						}
						case VCCU_ControlPilotStatusId:{
							//memcpy(&ShmSysConfigAndInfo->ate.vccu.controlPilotStatus, &frame.data, frame.can_dlc);
							ShmSysConfigAndInfo->ate.vccu.controlPilotStatus.ControlPilot_Frequency.bits.VCCU_ControlPilot_Frequency = ((short) frame.data[1] << 8) + (short) frame.data[0];
							ShmSysConfigAndInfo->ate.vccu.controlPilotStatus.ControlPilot_DutyCycle.bits.value = ((short) frame.data[2] ) ;
							ShmSysConfigAndInfo->ate.vccu.controlPilotStatus.ControlPilot_Voltage.bits.value = ((short) frame.data[4] << 8) + (short) frame.data[3];
							ShmSysConfigAndInfo->ate.vccu.controlPilotStatus.DATA.bits.VCCU_ControlPilot_Wakeup = bitextract(((short) (frame.data[5])), 0, 2);
							ShmSysConfigAndInfo->ate.vccu.controlPilotStatus.DATA.bits.VCCU_ChargeUnit_Mode = bitextract(frame.data[5],2, 5);
							ShmSysConfigAndInfo->ate.vccu.controlPilotStatus.DATA.bits.VCCU_ChargeUnit_State = bitextract(((short) (frame.data[5])), 5, 8);
							ShmSysConfigAndInfo->ate.vccu.controlPilotStatus.ChargeUnit_MaxCurrent = ((short) frame.data[6] );
							//printf("ControlPilot_Voltage===== %d %02x %02x\n", (32000-ShmSysConfigAndInfo->ate.vccu.controlPilotStatus.ControlPilot_Voltage.bits.value), frame.data[4], frame.data[3]);
							//memset(&ShmSysConfigAndInfo->ate.vccu.controlPilotStatus.ControlPilot_Voltage,frame.data[5], frame.can_dlc);
							break;
						}
						case VCCU_V2G_StateMId:{
							//memcpy(&ShmSysConfigAndInfo->ate.vccu.v2g_StateM, &frame.data, frame.can_dlc);
							ShmSysConfigAndInfo->ate.vccu.v2g_StateM.VCCU_V2G_StateM_EnergyTransfer = (short) frame.data[0];
							ShmSysConfigAndInfo->ate.vccu.v2g_StateM.VCCU_V2G_StateM_StateMachineEr = (short) frame.data[1];
							ShmSysConfigAndInfo->ate.vccu.v2g_StateM.VCCU_V2G_StateM_StateMachineMe = (short) frame.data[2];
							ShmSysConfigAndInfo->ate.vccu.v2g_StateM.VCCU_V2G_StateM_StateMachineSt = (short) frame.data[3];
							ShmSysConfigAndInfo->ate.vccu.v2g_StateM.DATA.bits.VCCU_V2G_StateM_InternetAvaila = bitextract(frame.data[4],0, 1);
							ShmSysConfigAndInfo->ate.vccu.v2g_StateM.DATA.bits.VCCU_V2G_Appl_SccChargeModeReq = bitextract(frame.data[4],1, 4);
							ShmSysConfigAndInfo->ate.vccu.v2g_StateM.DATA.bits.VCCU_V2G_Appl_SccFuncModeReq = bitextract(frame.data[4],4, 6);
							//memset(&ShmSysConfigAndInfo->ate.vccu.v2g_StateM.VCCU_V2G_StateM_StateMachineSt,*frame.data, frame.can_dlc);
							break;
						}
						case VCCU_InletStatusId:{
							//memcpy(&ShmSysConfigAndInfo->ate.vccu.inletStatus, &frame.data, frame.can_dlc);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.VCCU_POSFeedback_Voltage = ((short) frame.data[1] << 8) + (short) frame.data[0];
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA2.VCCU_PlugPresent_SelfDiagnosti = bitextract(frame.data[2],0, 3);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA2.VCCU_PlugPresent_Resistance = bitextract(frame.data[2],3, 6);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA2.VCCU_PlugPresent_Status = bitextract(frame.data[2],6, 8);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA3.VCCU_PlugPresent_Wakeup = bitextract(frame.data[3],0, 2);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA3.VCCU_POSFeedback_SelfDiagnosti = bitextract(frame.data[3],2, 5);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA3.VCCU_PlugLock_MotorStatus = bitextract(frame.data[3],5, 8);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA4.VCCU_PlugLock_Output0_SelfDiag = bitextract(frame.data[4],0, 3);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA4.VCCU_PlugLock_Output1_SelfDiag = bitextract(frame.data[4],3, 6);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA4.VCCU_Inlet_HWVariant = bitextract(frame.data[4],6, 8);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA5.bits.VCCU_DigitalInput_Status = bitextract(frame.data[5],0, 2);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA5.bits.VCCU_DigitalInput_Wakeup = bitextract(frame.data[5],2, 4);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA5.bits.VCCU_Inlet_MotorStatus = bitextract(frame.data[5],4, 7);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.VCCU_Inlet_MaxCurrent = (short) frame.data[6];
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA7.bits.VCCU_DigitalInput_DebouncedSta = bitextract(frame.data[7],0, 2);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA7.bits.VCCU_Inlet_ConnectionStatus = bitextract(frame.data[7],2, 4);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA7.bits.VCCU_S3Switch_Status = bitextract(frame.data[7],4, 6);
							ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA7.bits.VCCU_S3Switch_DebouncedStatus = bitextract(frame.data[7],6, 8);
							//memset(&ShmSysConfigAndInfo->ate.vccu.inletStatus,*frame.data, frame.can_dlc);
							//printf("VCCU_ControlPilotStatus Get-INFYPWR-Msg : %08x - %02x %02x %02x %02x %02x %02x %02x %02x\n ", intCmd, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7] );
							break;
						}
						case VCCU_ChargeToVehicleId:{
							//memcpy(&ShmSysConfigAndInfo->ate.vccu.chargeToVehicle, &frame.data, frame.can_dlc);
							//ShmSysConfigAndInfo->ate.vccu.chargeToVehicle.Data.bits.VCCU_Vehicle_IsolationMea_0000 = bitextract(frame.data[0],0, 2);
							ShmSysConfigAndInfo->ate.vccu.chargeToVehicle.bits.VCCU_Vehicle_IsolationMea_0000 = bitextract(frame.data[0],0, 2);
							ShmSysConfigAndInfo->ate.vccu.chargeToVehicle.bits.VCCU_Vehicle_ContactorRequest = bitextract(frame.data[0],2, 4);
							//memset(&ShmSysConfigAndInfo->ate.vccu.chargeToVehicle,*frame.data, frame.can_dlc);
							//printf("VCCU_ControlPilotStatus Get-INFYPWR-Msg : %08x - %02x %02x %02x %02x %02x %02x %02x %02x\n ", intCmd, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7] );
							break;
						}
						case VCCU_V2G_EVMaximumVoltageLimitId:{
							//memcpy(&ShmSysConfigAndInfo->ate.vccu.v2g_EVMaximumVoltageLimit, &frame.data, frame.can_dlc);
							//memset(&ShmSysConfigAndInfo->ate.vccu.v2g_EVMaximumVoltageLimit,*frame.data, frame.can_dlc);
							break;
						}
						case VCCU_V2G_EVSEMaximumCurrentLimId:{
							ShmSysConfigAndInfo->ate.vccu.v2g_EVSEMaximumCurrentLim.DATA.VCCU_V2G_EVSEMaximumCurre_0002 = bitextract(frame.data[0],0, 4);
							ShmSysConfigAndInfo->ate.vccu.v2g_EVSEMaximumCurrentLim.DATA.VCCU_V2G_EVSEMaximumCurrentLim = bitextract(frame.data[0],4, 6);
							ShmSysConfigAndInfo->ate.vccu.v2g_EVSEMaximumCurrentLim.VCCU_V2G_EVSEMaximumCurre_0003 = (short) frame.data[1];
							ShmSysConfigAndInfo->ate.vccu.v2g_EVSEMaximumCurrentLim.VCCU_V2G_EVSEMaximumCurre_0000 = ((short) frame.data[3] << 8) + (short) frame.data[2];
							ShmSysConfigAndInfo->ate.vccu.v2g_EVSEMaximumCurrentLim.VCCU_V2G_EVSEMaximumCurre_0001 = (short) frame.data[4];//樁的電流

							//printf("VCCU_V2G_EVSEMaximumCurrentLimId Get-INFYPWR-Msg :  VCCU_V2G_EVSEMaximumCurre_0000 = %d \n ", ShmSysConfigAndInfo->ate.vccu.v2g_EVSEMaximumCurrentLim.VCCU_V2G_EVSEMaximumCurre_0000);

							//memcpy(&ShmSysConfigAndInfo->ate.vccu.v2g_EVMaximumCurrentLimit, &frame.data, frame.can_dlc);
							//memset(&ShmSysConfigAndInfo->ate.vccu.v2g_EVMaximumCurrentLimit,*frame.data, frame.can_dlc);
							break;
						}
						case VCCU_V2G_EVTargetCurrentId:{
							//memcpy(&ShmSysConfigAndInfo->ate.vccu.v2g_EVTargetCurrent, &frame.data, frame.can_dlc);
							//memset(&ShmSysConfigAndInfo->ate.vccu.v2g_EVTargetCurrent,*frame.data, frame.can_dlc);
							break;
						}
						case VCCU_V2G_EVTargetVoltageId:{
							//memcpy(&ShmSysConfigAndInfo->ate.vccu.v2g_EVTargetVoltage, &frame.data, frame.can_dlc);
							//memset(&ShmSysConfigAndInfo->ate.vccu.v2g_EVTargetVoltage,*frame.data, frame.can_dlc);
							break;
						}
						case VCCU_V2G_EVSEPresentVoltageId:{

							ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va = ((short) frame.data[3] << 8) + (short) frame.data[2];
							//printf("EVSEPresentVoltage = %d\n ", ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va );
							ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va = ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va / 10;
							//printf("EVSEPresentVoltage = %d\n ", ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va );
							/*
							if(ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va != 0){
								ShmSysConfigAndInfo->ate.targetVoltage_Value = ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va;

							}
							*/
							break;
						}


						default:
							break;
					}
				}
				usleep(2000);

			}else if(ShmSysConfigAndInfo->ate.ATEState  == 2){
				memset(&frame, 0, sizeof(struct can_frame));
				nbytes = read(CanFd, &frame, sizeof(struct can_frame));
				if (nbytes > 0)
				{
					intCmd = (int) (frame.can_id & CAN_EFF_MASK);
					#ifdef Debug
						//printf("hsout0StatusChange Get-INFYPWR-Msg : %08x - %02x %02x %02x %02x %02x %02x %02x %02x\n ", intCmd, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7] );
						//printf(" Get-Msg2 : %08X - %02x %02x %02x %02x %02x %02x %02x %02x\n ", frame.can_id, 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
					if (intCmd == ADDRESS_REQ)
					{
						AddrAssignment(frame.data);
						continue;
					}

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


					if(intCmd == 256)
					{
						continue;
					}

					//gettimeofday(&_cmd_ack_timeout[targetGun], NULL);
					//printf ("intCmd = %x \n", intCmd);
					switch (intCmd)
					{
					case EV_BOARD_STATUS_NOTIFICATION:
						{
							//printf(" EV_BOARD_STATUS_NOTIFICATION\n ");

							ShmSysConfigAndInfo->ate.chademo.id03.ProximitySignal = frame.data[2];
							ShmSysConfigAndInfo->ate.chademo.id03.state = frame.data[3];
							//printf(" EV_BOARD_STATUS_NOTIFICATION %d \n ", ShmSysConfigAndInfo->ate.chademo.id03.state);
							//printf(" EV_BOARD_STATUS_NOTIFICATION Get-Msg : %08X - %02x %02x %02x %02x %02x %02x %02x %02x\n ", frame.can_id, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7] );

							//printf("EVBoardStatusNotification Get-Msg : %08X - %02x %02x %02x %02x %02x %02x %02x %02x\n ", frame.can_id, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7] );

							//printf("ConnectorPlugIn = %x, data[0] = %x \n", _chargingData[target]->ConnectorPlugIn, frame.data[0]);
							//printf("ConnectorPlugIn = %x \n", (-120 + frame.data[1]) / 10);
						}
							break;
						case ACK_EV_FW_VERSION:
						{
							printf(" ACK_EV_FW_VERSION\n ");
							/*
							if (_chargingData[targetGun]->Type == _Type_Chademo)
							{
								memcpy(ShmCHAdeMOData->evse[_chargingData[targetGun]->type_index].version, frame.data, ARRAY_SIZE(frame.data));
								ShmCHAdeMOData->evse[_chargingData[targetGun]->type_index].SelfTest_Comp = PASS;
							}
							else if (_chargingData[targetGun]->Type == _Type_CCS)
							{
								if (ShmCcsData->CommProtocol == 0x01)
								{
									memcpy(&ShmCcsData->V2GMessage_DIN70121[_chargingData[targetGun]->type_index].version, frame.data, ARRAY_SIZE(frame.data));
									ShmCcsData->V2GMessage_DIN70121[_chargingData[targetGun]->type_index].SelfTest_Comp = PASS;
								}
							}
							*/
						}
							break;
						case ACK_EV_HW_VERSION:
						{
							printf("Get EV HW = %s \n", frame.data);
						}
							break;

						case ACK__GET_EVSE_OUTPUT_STATUS:
						{
							//printf(" ACK__GET_EVSE_OUTPUT_STATUS\n ");
							//printf(" ACK__GET_EVSE_OUTPUT_STATUS\n ");

							//printf(" Get EVSE output status Get-Msg : %08X - %02x %02x %02x %02x %02x %02x %02x %02x\n ", frame.can_id, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7] );
							ShmSysConfigAndInfo->ate.chademo.id09_ack.DcEvState = frame.data[0];//EV模擬器
							ShmSysConfigAndInfo->ate.chademo.id09_ack.ChargingMode = frame.data[1];
							ShmSysConfigAndInfo->ate.chademo.id09_ack.EvsePresentOutputVoltage = ((short) frame.data[3] << 8) + (short) frame.data[2];//充電樁輸出電壓
							ShmSysConfigAndInfo->ate.chademo.id09_ack.EvsePresentOutputCurrent = ((short) frame.data[5] << 8) + (short) frame.data[4];//充電樁輸出電流
							ShmSysConfigAndInfo->ate.chademo.id09_ack.RemainingTimeSec = ((short) frame.data[7] << 8) + (short) frame.data[6];//剩餘時間

							/*
							_chargingData[targetGun]->EvBatterySoc = frame.data[1];
							_chargingData[targetGun]->EvBatterytargetVoltage = ((short) frame.data[3] << 8) + (short) frame.data[2];
							_chargingData[targetGun]->EvBatterytargetCurrent = ((short) frame.data[5] << 8) + (short) frame.data[4];
							_chargingData[targetGun]->PresentChargedDuration = ((short) frame.data[7] << 8) + (short) frame.data[6];

							if (_chargingData[targetGun]->Type == _Type_Chademo)
							{
								if (ShmCHAdeMOData->ev[_chargingData[targetGun]->type_index].EvDetection != frame.data[0])
								{
									// log
								}

								ShmCHAdeMOData->ev[_chargingData[targetGun]->type_index].EvDetection = frame.data[0];
								ShmCHAdeMOData->ev[_chargingData[targetGun]->type_index].SOC = _chargingData[targetGun]->EvBatterySoc;
								ShmCHAdeMOData->ev[_chargingData[targetGun]->type_index].TargetBatteryVoltage = _chargingData[targetGun]->EvBatterytargetVoltage;
								ShmCHAdeMOData->ev[_chargingData[targetGun]->type_index].ChargingCurrentRequest = _chargingData[targetGun]->EvBatterytargetCurrent;
							}
							else if (_chargingData[targetGun]->Type == _Type_CCS)
							{
								if(ShmCcsData->CommProtocol == 0x01)
								{
									ShmCcsData->V2GMessage_DIN70121[_chargingData[targetGun]->type_index].PresentMsgFlowStatus = frame.data[0];
								}
							}
							*/
							//printf("frame.data_2 = %x, frame.data_3 = %x \n", frame.data[2], frame.data[3]);
							//printf("EvBatterytargetVoltage = %f \n", _chargingData[targetGun]->EvBatterytargetVoltage);
							//printf("EvBatterytargetCurrent = %f \n", _chargingData[targetGun]->EvBatterytargetCurrent);
							//printf("BatteryVoltage = %d \n", ShmCHAdeMOData->ev[_chargingData[target]->type_index].TargetBatteryVoltage);
							//printf("CurrentRequest = %d \n", ShmCHAdeMOData->ev[_chargingData[target]->type_index].ChargingCurrentRequest);
						}
							break;
						case ACK_GET_EVSE_Capacity_INFO:
						{
							ShmSysConfigAndInfo->ate.chademo.id0A_ack.EvseMaxChargeVoltage = ((short) frame.data[1] << 8) + (short) frame.data[0];//樁的最大電壓
							ShmSysConfigAndInfo->ate.chademo.id0A_ack.EvseMaxChargeCurrent = ((short) frame.data[3] << 8) + (short) frame.data[2];//樁的最大電流
							ShmSysConfigAndInfo->ate.chademo.id0A_ack.EvseMinChargeVoltage = ((short) frame.data[5] << 8) + (short) frame.data[4];
							ShmSysConfigAndInfo->ate.chademo.id0A_ack.EvseMinChargeCurrent = ((short) frame.data[7] << 8) + (short) frame.data[6];

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

								//printf("EvBatteryMaxVoltage = %f \n", _chargingData[target]->EvBatteryMaxVoltage);
								//printf("TotalBatteryCapacity = %d \n", ShmCHAdeMOData->ev[_chargingData[target]->type_index].TotalBatteryCapacity);
								//printf("MaxiBatteryVoltage = %d \n", ShmCHAdeMOData->ev[_chargingData[target]->type_index].MaxiBatteryVoltage);
							}
							else if (_chargingData[targetGun]->Type == _Type_CCS)
							{
								if(ShmCcsData->CommProtocol == 0x01)
								{

								}
							}
							*/
						}
							break;
						case ACK_GET_MISCELLANEOUS_INFO:
						{
							//printf(" ACK_GET_MISCELLANEOUS_INFO\n ");
							//printf(" ACK_GET_MISCELLANEOUS_INFO\n ");
							ShmSysConfigAndInfo->ate.chademo.id0D_ack.K1K2OnOff = frame.data[5];
							if(ShmSysConfigAndInfo->ate.chademo.relaystatus == 0){
								ShmSysConfigAndInfo->ate.chademo.id0D_req.K1K2Status = ShmSysConfigAndInfo->ate.chademo.id0D_ack.K1K2OnOff;
								setStatusMode(CCS_QUANTITY, ShmSysConfigAndInfo->ate.chademo.id0D_req.K1K2Status);

								int status = isStatusChange(CCS_QUANTITY);
								if(status){
									/*
									if(ShmSysConfigAndInfo->ate.chademo.id0D_req.K1K2Status == 1){
										if(ShmSysConfigAndInfo->ate.ATEState  == 1){


											//usleep(whileLoopTime);

											//outputRelay.relay_event.bits.Gun1_Parallel_N = 0x00;
											//outputRelay.relay_event.bits.Gun1_Parallel_P = 0x00;
											//Config_Relay_Output(Uart5Fd, Addr.Relay, &outputRelay);
										}else if(ShmSysConfigAndInfo->ate.ATEState  == 2){
											//outputRelay.relay_event.bits.Gun1_Parallel_N = 0x01;
											//outputRelay.relay_event.bits.Gun1_Parallel_P = 0x01;
											//Config_Relay_Output(Uart5Fd, Addr.Relay, &outputRelay);
										}
									}else{

									}
									*/
								}
							}
							//memcpy(&ShmSysConfigAndInfo->ate.chademo.id0D_ack, &frame.data, frame.can_dlc);
							//printf("%d %d\n", ShmSysConfigAndInfo->ate.chademo.id0D_ack.K1K2OnOff, ShmSysConfigAndInfo->ate.chademo.id0D_ack.EvBoardState);
							//printf(" Get-Msg : %08X - %02x %02x %02x %02x %02x %02x %02x %02x\n ", frame.can_id, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7] );
	/*
							float pilotVol = (float)(-120 + frame.data[3]) / 10;

	//						if (pilotVol != _chargingData[targetGun]->PilotVoltage)
	//							DEBUG_INFO("PilotVoltage = %f \n", _chargingData[targetGun]->PilotVoltage);

							if (_chargingData[targetGun]->Type == _Type_Chademo)
							{
								_chargingData[targetGun]->GunLocked = frame.data[0];
								ShmCHAdeMOData->evse[_chargingData[targetGun]->type_index].ConnectorTemperatureP = frame.data[1];
								ShmCHAdeMOData->evse[_chargingData[targetGun]->type_index].ConnectorTemperatureN = frame.data[2];
								_chargingData[targetGun]->PilotVoltage = pilotVol;
								ShmCHAdeMOData->evse[_chargingData[targetGun]->type_index].EvboardStatus = frame.data[7];
							}
							else if (_chargingData[targetGun]->Type == _Type_CCS)
							{
								if (ShmCcsData->CommProtocol == 0x01)
								{
									_chargingData[targetGun]->GunLocked = frame.data[0];
									//ShmCcsData->V2GMessage_DIN70121[_chargingData[targetGun]->type_index]. .ConnectorTemperatureP = frame.data[1];
									//ShmCcsData->V2GMessage_DIN70121[_chargingData[targetGun]->type_index]. .ConnectorTemperatureN = frame.data[2];
									_chargingData[targetGun]->PilotVoltage = pilotVol;
								}
							}
							*/

							//printf("ConnectorPlug locked = %x \n", frame.data[0]);
							//printf("ConnectorTemp 0= %d \n", ShmCHAdeMOData->evse[_chargingData[target]->type_index].ConnectorTemperatureP);
							//printf("ConnectorTemp 1= %d \n", ShmCHAdeMOData->evse[_chargingData[target]->type_index].ConnectorTemperatureN);
						}
							break;
						case ACK_EVSE_ISOLATION_STATUS: { }	break;
						case ACK_EVSE_PRECHAGE_INFO:
						{
							//_chargingData[targetGun]->PrechargeStatus = frame.data[0];
						}
							break;
						case NOTIFICATION_EV_STOP:
						{
							printf(" ACK_GET_MISCELLANEOUS_INFO\n ");

							ShmSysConfigAndInfo->ate.chademo.id0B.EvStopReason = frame.data[0];
							ShmSysConfigAndInfo->ate.chademo.id0B.AlarmCode1 = frame.data[1];
							ShmSysConfigAndInfo->ate.chademo.id0B.AlarmCode2 = frame.data[2];
							ShmSysConfigAndInfo->ate.chademo.id0B.AlarmCode3 = frame.data[3];
							ShmSysConfigAndInfo->ate.chademo.id0B.AlarmCode4 = frame.data[4];
							ShmSysConfigAndInfo->ate.chademo.id0B.AlarmCode5 = frame.data[5];
							ShmSysConfigAndInfo->ate.chademo.id0B.AlarmCode6 = frame.data[6];
							printf("EvStopReason = %d %d %d %d %d %d %d \n", ShmSysConfigAndInfo->ate.chademo.id0B.EvStopReason, ShmSysConfigAndInfo->ate.chademo.id0B.AlarmCode1, ShmSysConfigAndInfo->ate.chademo.id0B.AlarmCode2, ShmSysConfigAndInfo->ate.chademo.id0B.AlarmCode3, ShmSysConfigAndInfo->ate.chademo.id0B.AlarmCode4, ShmSysConfigAndInfo->ate.chademo.id0B.AlarmCode5, ShmSysConfigAndInfo->ate.chademo.id0B.AlarmCode6);
							//byte normalStop = 0x01;
							//byte stopReason[6] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
							//byte evstaus[5] = { 0x01, 0x02, 0x03, 0x04, 0x05 };

							//ShmSysConfigAndInfo->ate.Permission = STOP;
							//setChargerMode(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission);
							//ShmSysConfigAndInfo->ate.ATEStatus = 0x00;
							//SetChargingPermission(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission, ShmSysConfigAndInfo->ate.TotalBatteryCap, ShmSysConfigAndInfo->ate.MaxBatteryCurrent, ShmSysConfigAndInfo->ate.MaxBatteryVoltage, 1);
							//EvseStopChargingEvent(normalStop, stopReason, 1);
							setEVStatus1(evstaus[4]);
							ShmSysConfigAndInfo->ate.Permission = STOP;
							setStatusMode(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission);
							ShmSysConfigAndInfo->ate.ATEStatus = 0x00;
							SetChargingPermission(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission, ShmSysConfigAndInfo->ate.TotalBatteryCap, ShmSysConfigAndInfo->ate.MaxBatteryCurrent, ShmSysConfigAndInfo->ate.MaxBatteryVoltage, 1);
							EvseStopChargingEvent(normalStop, stopReason, 1);
							/*
							ShmSysConfigAndInfo->ate.Permission = STOP;
							setChargerMode(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission);
							ShmSysConfigAndInfo->ate.ATEStatus = 0x00;
							SetChargingPermission(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission, ShmSysConfigAndInfo->ate.TotalBatteryCap, ShmSysConfigAndInfo->ate.MaxBatteryCurrent, ShmSysConfigAndInfo->ate.MaxBatteryVoltage, 1);
*/
							/*
							time_t CurrentTime;
							struct tm *tm;
							CurrentTime = time(NULL);
							tm = localtime(&	CurrentTime);
							printf(" Get-Msg : %08X - %02x %02x %02x %02x %02x %02x %02x %02x\n ", frame.can_id, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7] );

							printf("NOTIFICATION_EV_STOP : %04d-%02d-%02d %02d:%02d:%02d \n",
									tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec);
							// 車端要求停止
							// frame.data[0] : 0x01 => normal stop, 0x02 => ev emergency stop
							if (frame.data[0] == 0x02)
							{
								//printf("NOTIFICATION_EV_STOP -----------------------------\n");
								AbnormalStopAnalysis(targetGun, frame.data + 1);
							}
							_chargingData[targetGun]->StopChargeFlag = YES;
							*/
						}
							break;
						default:
							//printf("Ack none defined. intCmd = %d  \n", intCmd);
							break;
					}
				}
				usleep(10000);
			}
		}
	}
}

//接收can
void CHROMACANReceiver()
{
	pid_t canRecPid;
	canRecPid = fork();
	if(canRecPid > 0){
		int nbytes;
		struct can_frame frame;
		int intCmd;
		while (1){
			//清空 canbus recever buf
			memset(&frame, 0, sizeof(struct can_frame));
			//讀取 canbus 是否有接收到封包
			nbytes = read(CanFd2, &frame, sizeof(struct can_frame));
			//如果有收到 canbus 封包
			if (nbytes > 0){
				intCmd = (int) (frame.can_id & CAN_EFF_MASK);//extended frame format
						#ifdef Debug
							//printf("hsout0StatusChange Get-INFYPWR-Msg : %08x - %02x %02x %02x %02x %02x %02x %02x %02x\n ", intCmd, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7] );
							//printf(" Get-Msg : %08X - %02x %02x %02x %02x %02x %02x %02x %02x\n ", frame.can_id, 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
				//printf("hsout0StatusChange Get-INFYPWR-Msg : %08x - %02x %02x %02x %02x %02x %02x %02x %02x\n ", frame.can_id, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7] );
				//printf("Ack none defined. intCmd = %08x  \n", intCmd);
				switch (intCmd){
					case bn_res1:{
						/*
						ShmSysConfigAndInfo->ate.ATEState = (short) frame.data[0];
						setATEMode(CCS_QUANTITY, ShmSysConfigAndInfo->ate.ATEState);
						printf("00010102 Get-Msg : %d %08X - %02x %02x %02x %02x %02x %02x %02x %02x\n ", ShmSysConfigAndInfo->ate.ATEState, frame.can_id, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7] );
						*/

						break;
					}
					case bn_res2:{
						//printf(" Get-Msg : %08X - %02x %02x %02x %02x %02x %02x %02x %02x\n ", frame.can_id, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7] );
						break;
					}
					case ATE_Connector2:{

						/*
						ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.TargetVoltage =  ((short) frame.data[1] << 8) + (short) frame.data[0];//
						ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.TargetCurrent =  ((short) frame.data[3] << 8) + (short) frame.data[2];//
						ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.PresentVoltage  = ((short) frame.data[5] << 8) + (short) frame.data[4];
						ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.PresentCurrent = ((short) frame.data[7] << 8) + (short) frame.data[6];
						//ShmSysConfigAndInfo->ate.linkVoltage = ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.PresentVoltage;
						ShmSysConfigAndInfo->ate.targetVoltage_Value = ((short) frame.data[1] << 8) + (short) frame.data[0];
						ShmSysConfigAndInfo->ate.targetCurrent_Value = ((short) frame.data[3] << 8) + (short) frame.data[2];
						//ShmSysConfigAndInfo->ate.maximumVoltage_value = ShmSysConfigAndInfo->ate.targetVoltage_Value+(ShmSysConfigAndInfo->ate.targetVoltage_Value*0.1);
						ShmSysConfigAndInfo->ate.maximumVoltage_value = ShmSysConfigAndInfo->ate.targetVoltage_Value+10;
						ShmSysConfigAndInfo->ate.linkVoltage = ShmSysConfigAndInfo->ate.targetVoltage_Value;
						*/
						//printf("targetVoltage_Value= %d targetCurrent_Value =%d maximumVoltage_value = %d linkVoltage = %d \n",ShmSysConfigAndInfo->ate.targetVoltage_Value, ShmSysConfigAndInfo->ate.targetCurrent_Value, ShmSysConfigAndInfo->ate.maximumVoltage_value, ShmSysConfigAndInfo->ate.linkVoltage);
						//printf("ATE_Connector2 Get-Msg : %08X - %02x %02x %02x %02x %02x %02x %02x %02x %d %d %d %d %d %d  \n ", frame.can_id, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7], ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.TargetVoltage, ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.TargetCurrent, ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.PresentVoltage, ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.PresentCurrent, ShmSysConfigAndInfo->ate.targetVoltage_Value, ShmSysConfigAndInfo->ate.targetCurrent_Value);
						break;
					}
					case ATE_Connector1:{

						if(ShmSysConfigAndInfo->ate.ATEState == 1){//ccs
							ShmSysConfigAndInfo->ate.chroma.ate_Connector_1.TargetVoltage =  ((short) frame.data[1] << 8) + (short) frame.data[0];//
							ShmSysConfigAndInfo->ate.chroma.ate_Connector_1.TargetCurrent =  ((short) frame.data[3] << 8) + (short) frame.data[2];//
							ShmSysConfigAndInfo->ate.chroma.ate_Connector_1.PresentVoltage  = ((short) frame.data[5] << 8) + (short) frame.data[4];
							ShmSysConfigAndInfo->ate.chroma.ate_Connector_1.PresentCurrent = ((short) frame.data[7] << 8) + (short) frame.data[6];
							//ShmSysConfigAndInfo->ate.linkVoltage = ShmSysConfigAndInfo->ate.chroma.ate_Connector_1.PresentVoltage;
							//ShmSysConfigAndInfo->ate.targetVoltage_Value = ((short) frame.data[1] << 8) + (short) frame.data[0];
							int voltage = ((short) frame.data[1] << 8) + (short) frame.data[0];
							int evseMaxCurrent = ShmSysConfigAndInfo->ate.vccu.v2g_EVSEMaximumCurrentLim.VCCU_V2G_EVSEMaximumCurre_0000 / 10;
							//int evseMaxvoltage = ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va / 10;
							ShmSysConfigAndInfo->ate.targetCurrent_Value = ((short) frame.data[3] << 8) + (short) frame.data[2];
							//ShmSysConfigAndInfo->ate.maximumVoltage_value = ShmSysConfigAndInfo->ate.targetVoltage_Value+(ShmSysConfigAndInfo->ate.targetVoltage_Value*0.1);
							//ShmSysConfigAndInfo->ate.maximumVoltage_value = ShmSysConfigAndInfo->ate.targetVoltage_Value+10;
							//ShmSysConfigAndInfo->ate.maximumVoltage_value = 0;
							//ShmSysConfigAndInfo->ate.targetVoltage_Value = 0;


							if(voltage > (maxValue - 10)){
								ShmSysConfigAndInfo->ate.maximumVoltage_value = maxValue;
								ShmSysConfigAndInfo->ate.targetVoltage_Value = maxValue - 20;
								ShmSysConfigAndInfo->ate.linkVoltage = maxValue - 20;
							}else{
								ShmSysConfigAndInfo->ate.maximumVoltage_value = voltage + 10;
								ShmSysConfigAndInfo->ate.targetVoltage_Value = voltage - 10;
								ShmSysConfigAndInfo->ate.linkVoltage = voltage - 10;
							}

							if((ShmSysConfigAndInfo->ate.targetCurrent_Value > evseMaxCurrent)  && (evseMaxCurrent > 0)){
								ShmSysConfigAndInfo->ate.targetCurrent_Value = evseMaxCurrent;
							}
						}else if (ShmSysConfigAndInfo->ate.ATEState == 2){//gb
							ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.TargetVoltage =  ((short) frame.data[1] << 8) + (short) frame.data[0];//
							ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.TargetCurrent =  ((short) frame.data[3] << 8) + (short) frame.data[2];//
							ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.PresentVoltage  = ((short) frame.data[5] << 8) + (short) frame.data[4];
							ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.PresentCurrent = ((short) frame.data[7] << 8) + (short) frame.data[6];
							int voltage = ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.TargetVoltage * 10;
							int current = ShmSysConfigAndInfo->ate.chroma.ate_Connector_2.TargetCurrent * 10;

							if(voltage > (gbmaxValue - 100)){
								//ShmSysConfigAndInfo->ate.targetVoltage_Value = maxValue - 100;
								ShmSysConfigAndInfo->ate.chademoTargetVoltage_Value = gbmaxValue - 100;
								ShmSysConfigAndInfo->ate.RequireVoltage = gbmaxValue -100;
								ShmSysConfigAndInfo->ate.MaxBatteryVoltage = gbmaxValue;

							}else{
								ShmSysConfigAndInfo->ate.chademoTargetVoltage_Value = voltage;
								ShmSysConfigAndInfo->ate.RequireVoltage = voltage;
								ShmSysConfigAndInfo->ate.MaxBatteryVoltage = gbmaxValue;
							}
							//ShmSysConfigAndInfo->ate.targetVoltage_Value = voltage;
							ShmSysConfigAndInfo->ate.chademoTargetCurrent_Value = current;
							ShmSysConfigAndInfo->ate.RequireCurrent = current;
							//printf("voltage= %d cstatus = %d current= %d voltage =%d %02x %02x \n", ShmSysConfigAndInfo->ate.targetVoltage_Value, ShmSysConfigAndInfo->ate.chademo.id03.state , current, voltage, frame.data[1], frame.data[0]);


						}else if (ShmSysConfigAndInfo->ate.ATEState == 3){//chademo

						}
						//printf("targetVoltage_Value= %d targetCurrent_Value =%d maximumVoltage_value = %d linkVoltage = %d \n",ShmSysConfigAndInfo->ate.targetVoltage_Value, ShmSysConfigAndInfo->ate.targetCurrent_Value, ShmSysConfigAndInfo->ate.maximumVoltage_value, ShmSysConfigAndInfo->ate.linkVoltage);
						//printf("ATE_Connector1 Get-Msg : %08X - %02x %02x %02x %02x %02x %02x %02x %02x %d %d %d %d %d %d  \n ", frame.can_id, frame.data[0], frame.data[1], frame.data[2], frame.data[3],frame.data[4], frame.data[5], frame.data[6], frame.data[7], ShmSysConfigAndInfo->ate.chroma.ate_Connector_1.TargetVoltage, ShmSysConfigAndInfo->ate.chroma.ate_Connector_1.TargetCurrent, ShmSysConfigAndInfo->ate.chroma.ate_Connector_1.PresentVoltage, ShmSysConfigAndInfo->ate.chroma.ate_Connector_1.PresentCurrent, ShmSysConfigAndInfo->ate.targetVoltage_Value, ShmSysConfigAndInfo->ate.targetCurrent_Value );
						break;
					}

					default:

					break;
				}
			}
			usleep(2000);
			//usleep(100000);
		}
	}
}

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;
	return (StopTime-StartTime);
}

unsigned short MaxValue(unsigned short value1, unsigned short value2)
{
	return value1 >= value2 ? value1 : value2;
}

void Initialization()
{
    _chargingData[CCS_QUANTITY] = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[CCS_QUANTITY];
}

void VCCU_Requests(int LED0, int LED1, int LED2,
		int HighSideOut0, int HighSideOut1, int HighSideOut2, int HighSideOut3,
		int HighSideOut4, int RTC_TimerRequest, int PlugLock,
		int RTC_TimerValue,
		int ControlPilot, int ChargeUnit, int Inlet){
	struct VCCU_Requests obj;
	obj.VCCU_LED0_Request = LED0;//0.0
	obj.VCCU_LED1_Request = LED1;//0.0
	obj.VCCU_LED2_Request = LED2;//0.0
	obj.byte3.VCCU_HighSideOut0_Request = HighSideOut0;//3
	obj.byte3.VCCU_HighSideOut1_Request = HighSideOut1;//3
	obj.byte3.VCCU_HighSideOut2_Request = HighSideOut2;//3
	obj.byte3.VCCU_HighSideOut3_Request = HighSideOut3;//3
	obj.byte4.VCCU_HighSideOut4_Request = HighSideOut4;//3
	obj.byte4.VCCU_RTC_TimerRequest = RTC_TimerRequest;//3
	obj.byte4.VCCU_PlugLock_MotorRequest = PlugLock;//7
	obj.VCCU_RTC_TimerValue= RTC_TimerValue;//0
	obj.byte6.VCCU_ControlPilot_ChargeModeRe = ControlPilot;//7
	obj.byte6.VCCU_ChargeUnit_Request = ChargeUnit;//3
	obj.byte6.VCCU_Inlet_MotorRequest = Inlet;//3


	byte data[7];
	data[0] = *((UBYTE *) &obj.VCCU_LED0_Request);
	data[1] = *((UBYTE *) &obj.VCCU_LED1_Request);
	data[2] = *((UBYTE *) &obj.VCCU_LED2_Request);
	data[3] = *((UBYTE *) &obj.byte3);
	data[4] = *((UBYTE *) &obj.byte4);
	data[5] = *((UBYTE *) &obj.VCCU_RTC_TimerValue);
	data[6] = *((UBYTE *) &obj.byte6);
	//printf("%02x %02x %02x %02x %02x %02x %02x  \n", data[0], data[1], data[2], data[3], data[4], data[5] , data[6]);
	setVCCU_Requests(data, sizeof(data));
}


void VCCU_ChargeFromVehicle(int canfd, int linkVoltage, int contactorVoltage,
		int chargePermission, int isolationMeasurem,
		int plugLockPermissio, int plugUnlockPermiss, int contactorStatus){

	struct VCCU_ChargeFromVehicle obj;
	obj.VCCU_Vehicle_LinkVoltage= linkVoltage;//500
	obj.VCCU_Vehicle_ContactorVoltage = contactorVoltage;//0
	obj.DATA.bits.VCCU_Vehicle_ChargePermission = chargePermission;//Not_allowed
	obj.DATA.bits.VCCU_Vehicle_IsolationMeasurem = isolationMeasurem;//Active
	obj.DATA.bits.VCCU_Vehicle_PlugLockPermissio = plugLockPermissio;//Allowed//Not_allowed;
	obj.DATA.bits.VCCU_Vehicle_PlugUnlockPermiss = plugUnlockPermiss;//Not_allowed
	obj.bits.VCCU_Vehicle_ContactorStatus = contactorStatus;//Open
	obj.bits.VCCU_Vehicle_StopCharge = 3;//Open
	obj.bits.VCCU_Vehicle_ChargeSelection = 3;//Open
	byte* data1;
	data1 = (byte*) &(*((UWORD *) &obj.VCCU_Vehicle_ContactorVoltage));
	byte* data2;
	data2 = (byte*) &(*((UWORD *) &obj.VCCU_Vehicle_LinkVoltage));
	byte data[6];
	data[0] = data1[0];
	data[1] = data1[1];
	data[2] = data2[0];
	data[3] = data2[1];
	data[4] = *((UBYTE *) &obj.DATA);
	data[5] = *((UBYTE *) &obj.bits);
	setVCCU_ChargeFromVehicle(data, sizeof(data));
}

void VCVCCU_V2G_RemainingTimeToFullSO(int remainingTime){
	struct VCCU_V2G_RemainingTimeToFullSO obj;
	obj.VCCU_V2G_RemainingTimeToB_0000.value = remainingTime;
	obj.DATA.VCCU_V2G_RemainingTimeToFullSO = 1;
	obj.DATA.VCCU_V2G_RemainingTimeToF_0002 = 0;//520
	obj.VCCU_V2G_RemainingTimeToB_0001.value = 0;//1
	obj.VCCU_V2G_RemainingTimeToB_0003.value = 0;//0
	byte* data1;
	data1 = (byte*) &(*((UWORD *) &obj.VCCU_V2G_RemainingTimeToB_0000));
	byte data[5];
	data[0] = data1[0];
	data[1] = data1[1];
	data[2] = *((UBYTE *) &obj.VCCU_V2G_RemainingTimeToB_0003);
	data[3] = *((UBYTE *) &obj.VCCU_V2G_RemainingTimeToB_0001);
	data[4] = *((UBYTE *) &obj.DATA);
	setVCCU_V2G_RemainingTimeToFullSO(data, sizeof(data));
}

void VCCU_V2G_EVMaximumVoltageLimit(int VMaximumVoltageLimit,
		int EVMaximumVoltage_0002,
		int EVMaximumVoltage_0000,
		int EVMaximumVoltage_0001,
		int EVMaximumVoltage_0003){

	struct VCCU_V2G_EVMaximumVoltageLimit obj;
	obj.DATA1.VCCU_V2G_EVMaximumVoltageLimit = VMaximumVoltageLimit;//1
	obj.DATA1.VCCU_V2G_EVMaximumVoltage_0002 = EVMaximumVoltage_0002;//5
	obj.VCCU_V2G_EVMaximumVoltage_0000.value = EVMaximumVoltage_0000;//520
	obj.VCCU_V2G_EVMaximumVoltage_0001.value = EVMaximumVoltage_0001;//1
	obj.VCCU_V2G_EVMaximumVoltage_0003.value = EVMaximumVoltage_0003;//0
	byte* data1;
	data1 = (byte*) &(*((UWORD *) &obj.VCCU_V2G_EVMaximumVoltage_0000));
	byte data[5];
	data[0] = *((UBYTE *) &obj.DATA1);
	data[1] = *((UBYTE *) &obj.VCCU_V2G_EVMaximumVoltage_0003);
	data[2] = data1[0];
	data[3] = data1[1];
	data[4] = *((UBYTE *) &obj.VCCU_V2G_EVMaximumVoltage_0001);
	//printf("%02x %02x %02x %02x %02x \n", data[0], data[1], data[2], data[3], data[4]);
	setVCCU_V2G_EVMaximumVoltageLimit(data, sizeof(data));
}

void VCCU_V2G_EVMaximumCurrentLimit(int EVMaximumCurrentLimit,
		int EVMaximumCurrent_0000,
		int EVMaximumCurrent_0001,
		int EVMaximumCurrent_0002,
		int EVMaximumCurrent_0003){

	struct VCCU_V2G_EVMaximumCurrentLimit obj;
	obj.DATA1.VCCU_V2G_EVMaximumCurrentLimit = EVMaximumCurrentLimit;//1
	obj.DATA1.VCCU_V2G_EVMaximumCurrent_0000 = EVMaximumCurrent_0000;//3
	obj.VCCU_V2G_EVMaximumCurrent_0001.value = EVMaximumCurrent_0001;//1
	obj.VCCU_V2G_EVMaximumCurrent_0002.value = EVMaximumCurrent_0002;//0
	obj.VCCU_V2G_EVMaximumCurrent_0003.value = EVMaximumCurrent_0003;//10
	byte* data1;
	data1 = (byte*) &(*((UWORD *) &obj.VCCU_V2G_EVMaximumCurrent_0003));
	byte data[5];
	data[0] = *((UBYTE *) &obj.DATA1);
	data[1] = *((UBYTE *) &obj.VCCU_V2G_EVMaximumCurrent_0002);
	data[2] = data1[0];
	data[3] = data1[1];
	data[4] = *((UBYTE *) &obj.VCCU_V2G_EVMaximumCurrent_0001);
	//printf("%02x %02x %02x %02x %02x \n", data[0], data[1], data[2], data[3], data[4]);
	setVCCU_V2G_EVMaximumCurrentLimit(data, sizeof(data));
}

void VCCU_V2G_EVTargetVoltage(int EVTargetVoltage_Value,
		int EVTargetVoltage_Unit,
		int EVTargetVoltage_UnitF,
		int EVTargetVoltage_Multi){//C2 01 00 01 05

	struct VCCU_V2G_EVTargetVoltage obj;
	obj.VCCU_V2G_EVTargetVoltage_Value.value = EVTargetVoltage_Value;//450
	obj.VCCU_V2G_EVTargetVoltage_Unit.value = EVTargetVoltage_Unit;//5
	obj.VCCU_V2G_EVTargetVoltage_UnitF.value = EVTargetVoltage_UnitF;//1
	obj.VCCU_V2G_EVTargetVoltage_Multi.value = EVTargetVoltage_Multi;//0

	byte* data1;
	data1 = (byte*) &(*((UWORD *) &obj.VCCU_V2G_EVTargetVoltage_Value));
	byte data[5];
	data[0] = data1[0];
	data[1] = data1[1];
	data[2] = *((UBYTE *) &obj.VCCU_V2G_EVTargetVoltage_Multi);
	data[3] = *((UBYTE *) &obj.VCCU_V2G_EVTargetVoltage_UnitF);
	data[4] = *((UBYTE *) &obj.VCCU_V2G_EVTargetVoltage_Unit);
	//printf("%d %02x %02x \n",obj.VCCU_V2G_EVTargetVoltage_Value.value, data[0], data[1]);
	//printf("%02x %02x %02x %02x %02x \n", data[0], data[1], data[2], data[3], data[4]);
	setVCCU_V2G_EVTargetVoltage(data, sizeof(data));
}

void VCCU_V2G_EVTargetCurrent(int EVTargetCurrent_Unit,
		int EVTargetCurrent_Value,
		int EVTargetCurrent_UnitF,
		int EVTargetCurrent_Multi){//05 00 00 01 03

	struct VCCU_V2G_EVTargetCurrent obj;
	obj.VCCU_V2G_EVTargetCurrent_Unit.value = EVTargetCurrent_Unit;//3
	obj.VCCU_V2G_EVTargetCurrent_Value.value = EVTargetCurrent_Value;//5
	obj.VCCU_V2G_EVTargetCurrent_UnitF.value = EVTargetCurrent_UnitF;//1
	obj.VCCU_V2G_EVTargetCurrent_Multi.value = EVTargetCurrent_Multi;//0
	byte* data1;
	data1 = (byte*) &(*((UWORD *) &obj.VCCU_V2G_EVTargetCurrent_Value));
	byte data[5];
	data[0] = data1[0];
	data[1] = data1[1];
	data[2] = *((UBYTE *) &obj.VCCU_V2G_EVTargetCurrent_Multi);
	data[3] = *((UBYTE *) &obj.VCCU_V2G_EVTargetCurrent_UnitF);
	data[4] = *((UBYTE *) &obj.VCCU_V2G_EVTargetCurrent_Unit);
	//printf("%02x %02x %02x %02x %02x \n", data[0], data[1], data[2], data[3], data[4]);
	setVCCU_V2G_EVTargetCurrent(data, sizeof(data));
}

void VCCU_V2G_VehicleStatus(int canfd, int EnergyTra, int EVErrorCode,
		int EVPowerDeliveryParame, int EVRESSSOC,
		int EVRESSConditioningFla, int EVRESSConditionin, int EVReady,
		int BulkChargingCompleteF, int EVCabinConditioningFl, int EVCabinConditioning,
		int ChargingComplete, int FullSOCFlag, int FullSOC,
		int BulkSOCFlag, int BulkSOC, int BulkChargingComplete,
		int BulkChargingCompleteFValue){
	struct VCCU_V2G_VehicleStatus obj;
	obj.DATA4.VCCU_V2G_StateM_EnergyTra_0000 = EnergyTra;//VCCU_V2G_StateM_EnergyTra_0000_DC_DC_extended;
	obj.DATA1.VCCU_V2G_EVErrorCode = EVErrorCode;//0;
	obj.DATA4.VCCU_V2G_EVPowerDeliveryParame = EVPowerDeliveryParame;//3;
	obj.VCCU_V2G_EVRESSSOC.value = EVRESSSOC;//0;
	obj.DATA3.VCCU_V2G_EVRESSConditioningFla = EVRESSConditioningFla;//3;
	obj.DATA3.VCCU_V2G_EVRESSConditioning = EVRESSConditionin;//3;
	obj.DATA3.VCCU_V2G_EVReady = EVReady;//3;
	obj.DATA1.VCCU_V2G_BulkChargingCompleteF = BulkChargingCompleteF;//3;
	obj.DATA3.VCCU_V2G_EVCabinConditioningFl = EVCabinConditioningFl;//3;
	obj.DATA2.VCCU_V2G_EVCabinConditioning = EVCabinConditioning;//3;
	obj.DATA2.VCCU_V2G_ChargingComplete = ChargingComplete;//3;
	obj.DATA2.VCCU_V2G_FullSOCFlag = FullSOCFlag;//0;
	obj.VCCU_V2G_FullSOC.value = FullSOC;//3;
	obj.DATA2.VCCU_V2G_BulkSOCFlag = BulkSOCFlag;//3;
	obj.VCCU_V2G_BulkSOC.value = BulkSOC;//0;
	obj.DATA1.VCCU_V2G_BulkChargingComplete = BulkChargingComplete;//3;
	obj.DATA1.VCCU_V2G_BulkChargingCompleteF = BulkChargingCompleteFValue;//3;
	byte data[7];
	data[0] = *((UBYTE *) &obj.DATA1);
	data[1] = *((UBYTE *) &obj.DATA2);
	data[2] = *((UBYTE *) &obj.DATA3);
	data[3] = *((UBYTE *) &obj.DATA4);
	data[4] = *((UBYTE *) &obj.VCCU_V2G_BulkSOC);
	data[5] = *((UBYTE *) &obj.VCCU_V2G_FullSOC);
	data[6] = *((UBYTE *) &obj.VCCU_V2G_EVRESSSOC);
	setVCCU_V2G_VehicleStatus(data, sizeof(data));
}

unsigned char isModeChange(unsigned char gun_index)
{
	unsigned char result = NO;
	if(_chargingData[gun_index]->SystemStatus != _chargingData[gun_index]->PreviousSystemStatus)
	{
		result = YES;
		_chargingData[gun_index]->PreviousSystemStatus = _chargingData[gun_index]->SystemStatus;

	}
	return result;
}

void setChargerMode(byte gun_index, byte mode)
{
	_chargingData[gun_index]->SystemStatus = mode;
}

void handleEmulatorFaultStatus(){
	setEVStatus1(evstaus[4]);
	ShmSysConfigAndInfo->ate.Permission = STOP;
	setStatusMode(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission);
	ShmSysConfigAndInfo->ate.ATEStatus = 0x00;
	SetChargingPermission(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission, ShmSysConfigAndInfo->ate.TotalBatteryCap,
				ShmSysConfigAndInfo->ate.MaxBatteryCurrent, ShmSysConfigAndInfo->ate.MaxBatteryVoltage, 1);
	EvseStopChargingEvent(normalStop, stopReason, 1);

}

int main(int argc, char *argv[])
{
	if(InitShareMemory() == FAIL)
	{
		#ifdef SystemLogMessage
		printf("InitShareMemory NG\n");
		#endif
		if(ShmStatusCodeData != NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory=1;
		}
		sleep(5);
		return 0;
	}

	Initialization();
	CanFd = InitCanBus();
	CanFd2 = CHROMAInitCanBus();
	CANReceiver();
	CHROMACANReceiver();

	//printf("%08X %08X  %d %d %d ....................\n" , bn1, (bn1 | 0x80000000), CanFd, CanFd2, ShmSysConfigAndInfo->ate.ATEState);

/*
	sleep(2);
	system("killall Module_InternalComm");
	system("killall Module_EvComm");
	return 0;
	*/

	printf("EvComm %d....................\n" , ShmSysConfigAndInfo->ate.ATEState);
	while(true){

		if(ShmSysConfigAndInfo->ate.ATEState  == 1){//VCCU

			setBootNotification1();
			VCCU_TD();
			VCCU_Requests(0, 0, 0,
									3, 3, 3, 3,
									3, 3, 7,
									0,
									7, 3, 3);

			int status = isModeChange(CCS_QUANTITY);
			VCVCCU_V2G_RemainingTimeToFullSO(8000);
			switch(_chargingData[CCS_QUANTITY]->SystemStatus){
				case V_IDLE:{
					if (status){
						printf("CCS IDLE Processing 1....................\n");
					}
					setEVStatus1(evstaus[0]);
					break;
				}
				case V_UNMATEDPLUG:{
					if (status){
						printf("CCS UNMATEDPLUG Processing 2....................\n");
					}
					setEVStatus1(evstaus[0]);
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, 0, Not_allowed, Active, Not_allowed, Not_allowed, Opened);

					break;
				}
				case V_MATED_PLUG_INLET_UNLOCKED:{
					if (status){
						if(ShmSysConfigAndInfo->ate.vccu.inletStatus.DATA2.VCCU_PlugPresent_Status == VCCU_InletStatus_Connected){

						}
						printf("CCS MATED_PLUG_INLET_UNLOCKED Processing 3....................\n");
					}
					setEVStatus1(evstaus[0]);
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, 0, Not_allowed, Active, Allowed, Not_allowed, Opened);
					//VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, 0, Not_allowed, Active, Allowed, Not_allowed, Opened);
					break;
				}
				case V_INLETLOCKING:{
					if (status){
						printf("CCS INLETLOCKING Processing 4....................\n");
					}
					setEVStatus1(evstaus[0]);
					break;
				}
				case V_INLETLOCKED:{
					if (status){
						printf("CCS INLETLOCKED Processing 5....................\n");
					}
					setEVStatus1(evstaus[1]);
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, 0, Not_allowed, Active, Allowed, Not_allowed, Opened);

					VCCU_V2G_EVMaximumVoltageLimit(TRUE, U_V, ShmSysConfigAndInfo->ate.maximumVoltage_value, TRUE, 0);
					VCCU_V2G_EVMaximumCurrentLimit(TRUE, U_A, TRUE, 0, ShmSysConfigAndInfo->ate.maximumCurrent_value);
					VCCU_V2G_EVTargetVoltage(ShmSysConfigAndInfo->ate.targetVoltage_Value, U_V, TRUE, 0);
					VCCU_V2G_EVTargetCurrent(U_A, ShmSysConfigAndInfo->ate.targetCurrent_Value, TRUE, 0);
					VCCU_V2G_VehicleStatus(CanFd, VCCU_V2G_StateM_EnergyTra_0000_DC_DC_extended, 0,
							3, soc,
							3, 3, TRUE,
							3, 3, 3,
							3, 3, 0,
							3, 0, 3,
							3);
					/*
					VCCU_V2G_EVMaximumVoltageLimit(TRUE, U_V, ShmSysConfigAndInfo->ate.maximumVoltage_value, TRUE, 0);
					VCCU_V2G_EVMaximumCurrentLimit(TRUE, U_A, TRUE, 0, ShmSysConfigAndInfo->ate.maximumCurrent_value);
					*/
					break;
				}
				case V_SLAC:{
					if (status){
						printf("CCS SLAC Processing 6....................\n");
					}
					setEVStatus1(evstaus[1]);
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, 0, Not_allowed, Active, Allowed, Not_allowed, Opened);
					/*
					 VCCU_V2G_EVMaximumVoltageLimit(TRUE, U_V, ShmSysConfigAndInfo->ate.maximumVoltage_value, TRUE, 0);
					 VCCU_V2G_EVMaximumCurrentLimit(TRUE, U_A, TRUE, 0, ShmSysConfigAndInfo->ate.maximumCurrent_value);
					 */
					VCCU_V2G_VehicleStatus(CanFd, VCCU_V2G_StateM_EnergyTra_0000_DC_DC_extended, 0,
										3, soc,
										3, 3, TRUE,
										3, 3, 3,
										3, 3, 0,
										3, 0, 3,
										3);
					VCCU_V2G_EVMaximumVoltageLimit(TRUE, U_V, ShmSysConfigAndInfo->ate.maximumVoltage_value, TRUE, 0);
					VCCU_V2G_EVMaximumCurrentLimit(TRUE, U_A, TRUE, 0, ShmSysConfigAndInfo->ate.maximumCurrent_value);
					VCCU_V2G_EVTargetVoltage(ShmSysConfigAndInfo->ate.targetVoltage_Value, U_V, TRUE, 0);
					VCCU_V2G_EVTargetCurrent(U_A, ShmSysConfigAndInfo->ate.targetCurrent_Value, TRUE, 0);
					break;
				}
				case V_DEFINITION:{
					if (status){
						printf("CCS DEFINITION Processing 7....................\n");
					}
					setEVStatus1(evstaus[1]);
					/*
					VCCU_V2G_VehicleStatus(CanFd, VCCU_V2G_StateM_EnergyTra_0000_DC_DC_extended, 0, 3, 0,
											3, 3, TRUE, 3, 3, 3, 3, 3, 0, 3, 0, 3, 3);
					*/
					/*
					VCCU_V2G_EVMaximumVoltageLimit(TRUE, U_V, 500, TRUE, 0);
					VCCU_V2G_EVMaximumCurrentLimit(TRUE, U_A, TRUE, 0, 10);

					VCCU_V2G_EVMaximumVoltageLimit(TRUE, U_V, ShmSysConfigAndInfo->ate.maximumVoltage_value, TRUE, 0);
					VCCU_V2G_EVMaximumCurrentLimit(TRUE, U_A, TRUE, 0, ShmSysConfigAndInfo->ate.maximumCurrent_value);
					*/
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, 0, Not_allowed, Active, Allowed, Not_allowed, Opened);
					VCCU_V2G_VehicleStatus(CanFd, VCCU_V2G_StateM_EnergyTra_0000_DC_DC_extended, 0,
										3, soc,
										3, 3, TRUE,
										3, 3, 3,
										3, 3, 0,
										3, 0, 3,
										3);
					VCCU_V2G_EVMaximumVoltageLimit(TRUE, U_V, ShmSysConfigAndInfo->ate.maximumVoltage_value, TRUE, 0);
					VCCU_V2G_EVMaximumCurrentLimit(TRUE, U_A, TRUE, 0, ShmSysConfigAndInfo->ate.maximumCurrent_value);
					VCCU_V2G_EVTargetVoltage(ShmSysConfigAndInfo->ate.targetVoltage_Value, U_V, TRUE, 0);
					VCCU_V2G_EVTargetCurrent(U_A, ShmSysConfigAndInfo->ate.targetCurrent_Value, TRUE, 0);
					break;
				}
				case V_CABLECHECK:{
					if (status){
						printf("CCS CABLECHECK Processing 8....................\n");
					}
					setEVStatus1(evstaus[1]);
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, 0, Allowed, Active, Allowed, Not_allowed, Opened);
					VCCU_V2G_VehicleStatus(CanFd, VCCU_V2G_StateM_EnergyTra_0000_DC_DC_extended, 0,
															3, soc,
															3, 3, TRUE,
															3, 3, 3,
															3, 3, 0,
															3, 0, 3,
															3);

					VCCU_V2G_EVMaximumVoltageLimit(TRUE, U_V, ShmSysConfigAndInfo->ate.maximumVoltage_value, TRUE, 0);
					VCCU_V2G_EVMaximumCurrentLimit(TRUE, U_A, TRUE, 0, ShmSysConfigAndInfo->ate.maximumCurrent_value);
					VCCU_V2G_EVTargetVoltage(ShmSysConfigAndInfo->ate.targetVoltage_Value, U_V, TRUE, 0);
					VCCU_V2G_EVTargetCurrent(U_A, ShmSysConfigAndInfo->ate.targetCurrent_Value, TRUE, 0);

					break;
				}
				case V_ISOLATION:{
					if (status){
						printf("CCS ISOLATION Processing 9....................\n");
					}
					setEVStatus1(evstaus[1]);
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, 0, Allowed, Not_Active, Allowed, Not_allowed, Opened);
					VCCU_V2G_VehicleStatus(CanFd, VCCU_V2G_StateM_EnergyTra_0000_DC_DC_extended, 0,
							3, soc,
							3, 3, TRUE,
							3, 3, 3,
							3, 3, 0,
							3, 0, 3,
							3);
					VCCU_V2G_EVMaximumVoltageLimit(TRUE, U_V, ShmSysConfigAndInfo->ate.maximumVoltage_value, TRUE, 0);
					VCCU_V2G_EVMaximumCurrentLimit(TRUE, U_A, TRUE, 0, ShmSysConfigAndInfo->ate.maximumCurrent_value);
					VCCU_V2G_EVTargetVoltage(ShmSysConfigAndInfo->ate.targetVoltage_Value, U_V, TRUE, 0);
					VCCU_V2G_EVTargetCurrent(U_A, ShmSysConfigAndInfo->ate.targetCurrent_Value, TRUE, 0);
					break;
				}
				case V_VOLTAGEDIFFERENCE:{
					if (status){
						printf("CCS VOLTAGEDIFFERENCE Processing 10 VCCU_V2G_EVSEPresentVoltage_Va = %d ....................\n", ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va);
					}
					setEVStatus1(evstaus[1]);
					/*
					int val = (ShmSysConfigAndInfo->ate.linkVoltage - ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va);

					printf("linkVoltage = %d v2g_EVSEPresentVoltage = %d val = %d RemainChargingDuration = %d....................\n", ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va, val, _chargingData[CCS_QUANTITY]->RemainChargingDuration);
*/
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va, Allowed, Not_Active, Allowed, Not_allowed, Opened);
					//VCCU_V2G_EVTargetCurrent(U_A, ShmSysConfigAndInfo->ate.targetCurrent_Value, TRUE, 0);
					VCCU_V2G_VehicleStatus(CanFd, VCCU_V2G_StateM_EnergyTra_0000_DC_DC_extended, 0,
							3, soc,
							3, 3, TRUE,
							3, 3, 3,
							3, 3, 0,
							3, 0, 3,
							3);

					VCCU_V2G_EVMaximumVoltageLimit(TRUE, U_V, ShmSysConfigAndInfo->ate.maximumVoltage_value, TRUE, 0);
					VCCU_V2G_EVMaximumCurrentLimit(TRUE, U_A, TRUE, 0, ShmSysConfigAndInfo->ate.maximumCurrent_value);
					VCCU_V2G_EVTargetVoltage(ShmSysConfigAndInfo->ate.targetVoltage_Value, U_V, TRUE, 0);
					VCCU_V2G_EVTargetCurrent(U_A, ShmSysConfigAndInfo->ate.targetCurrent_Value, TRUE, 0);



					break;
				}
				case V_CONTACTORSCLOSED:{
					if (status){
						printf("CCS CONTACTORSCLOSED Processing 11....................\n");
						//printf("EVSEPresentVoltage = %d\n ", ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va );


					}
					//
					setEVStatus1(evstaus[1]);
					if(ShmSysConfigAndInfo->ate.vccu.chargeToVehicle.bits.VCCU_Vehicle_ContactorRequest == Closed){
						VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va, Allowed, Not_Active, Allowed, Not_allowed, Closed);
					}else{
						VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va, Allowed, Not_Active, Allowed, Not_allowed, Opened);

					}
					VCCU_V2G_VehicleStatus(CanFd, VCCU_V2G_StateM_EnergyTra_0000_DC_DC_extended, 0,
							3, soc,
							3, 3, TRUE,
							3, 3, 3,
							3, 3, 0,
							3, 0, 3,
							3);
					VCCU_V2G_EVMaximumVoltageLimit(TRUE, U_V, ShmSysConfigAndInfo->ate.maximumVoltage_value, TRUE, 0);
					VCCU_V2G_EVMaximumCurrentLimit(TRUE, U_A, TRUE, 0, ShmSysConfigAndInfo->ate.maximumCurrent_value);
					VCCU_V2G_EVTargetVoltage(ShmSysConfigAndInfo->ate.targetVoltage_Value, U_V, TRUE, 0);
					VCCU_V2G_EVTargetCurrent(U_A, ShmSysConfigAndInfo->ate.targetCurrent_Value, TRUE, 0);
					break;
				}
				case V_POWERDELIVERY:{
					if (status){
						printf("CCS POWERDELIVERY Processing 12....................\n");
						//usleep(50000);
					}
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va, Allowed, Not_Active, Allowed, Not_allowed, Closed);
					/*
					if(ShmSysConfigAndInfo->ate.ATEStatus == 0){
						VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va, Allowed, Not_Active, Allowed, Not_allowed, Closed);
					}else{
						VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va, Not_allowed, Not_Active, Allowed, Not_allowed, Opened);
					}
					*/
					//VCCU_V2G_EVTargetVoltage(400, U_V, TRUE, 0);
					VCCU_V2G_VehicleStatus(CanFd, VCCU_V2G_StateM_EnergyTra_0000_DC_DC_extended, 0,
							3, soc,
							3, 3, TRUE,
							3, 3, 3,
							3, 3, 0,
							3, 0, 3,
							3);
					VCCU_V2G_EVMaximumVoltageLimit(TRUE, U_V, ShmSysConfigAndInfo->ate.maximumVoltage_value, TRUE, 0);
					VCCU_V2G_EVMaximumCurrentLimit(TRUE, U_A, TRUE, 0, ShmSysConfigAndInfo->ate.maximumCurrent_value);
					VCCU_V2G_EVTargetVoltage(ShmSysConfigAndInfo->ate.targetVoltage_Value, U_V, TRUE, 0);
					VCCU_V2G_EVTargetCurrent(U_A, ShmSysConfigAndInfo->ate.targetCurrent_Value, TRUE, 0);

					setEVStatus1(evstaus[1]);
					break;
				}
				case V_CURRENTDEMAND:{
					if (status){
						printf("CCS CURRENTDEMAND Processing 13 %d %d %d %d....................\n", ShmSysConfigAndInfo->ate.targetCurrent_Value, ShmSysConfigAndInfo->ate.targetVoltage_Value, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va);
						//ShmSysConfigAndInfo->ate.linkVoltage = ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va;
						//printf("maximumVoltage_value = %d  Voltage = %d  maximumCurrent_value = %d  Current = %d....................\n", ShmSysConfigAndInfo->ate.maximumVoltage_value, ShmSysConfigAndInfo->ate.targetVoltage_Value, ShmSysConfigAndInfo->ate.maximumCurrent_value, ShmSysConfigAndInfo->ate.targetCurrent_Value);
						//usleep(50000);
					}

					setEVStatus1(evstaus[2]);
					if(ShmSysConfigAndInfo->ate.vccu.chargeToVehicle.bits.VCCU_Vehicle_ContactorRequest == Opened){
						printf("CCS CURRENTDEMAND Processing  %d %d %d %d....................\n", ShmSysConfigAndInfo->ate.targetCurrent_Value, ShmSysConfigAndInfo->ate.targetVoltage_Value, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va);

						//VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va, Not_allowed, Not_Active, Allowed, Not_allowed, Opened);
					}else{
						//VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va, Allowed, Not_Active, Allowed, Not_allowed, Closed);
					}
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va, Allowed, Not_Active, Allowed, Not_allowed, Closed);
					/*
					if(ShmSysConfigAndInfo->ate.ATEStatus == 0){
						//VCCU_ChargeFromVehicle(CanFd, 500, 500, Allowed, Not_Active, Allowed, Not_allowed, Closed);
						VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va, Allowed, Not_Active, Allowed, Not_allowed, Closed);
					}else{
						//VCCU_ChargeFromVehicle(CanFd, 500, 500, Not_allowed, Not_Active, Allowed, Not_allowed, Closed);
						VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.vccu.v2g_EVSEPresentVoltage.VCCU_V2G_EVSEPresentVoltage_Va, Not_allowed, Not_Active, Allowed, Not_allowed, Closed);
					}
					*/
					VCCU_V2G_VehicleStatus(CanFd, VCCU_V2G_StateM_EnergyTra_0000_DC_DC_extended, 0,
							3, soc,
							3, 3, TRUE,
							3, 3, 3,
							3, 3, 0,
							3, 0, 3,
							3);
					VCCU_V2G_EVMaximumVoltageLimit(TRUE, U_V, ShmSysConfigAndInfo->ate.maximumVoltage_value, TRUE, 0);
					VCCU_V2G_EVMaximumCurrentLimit(TRUE, U_A, TRUE, 0, ShmSysConfigAndInfo->ate.maximumCurrent_value);
					VCCU_V2G_EVTargetVoltage(ShmSysConfigAndInfo->ate.targetVoltage_Value, U_V, TRUE, 0);
					VCCU_V2G_EVTargetCurrent(U_A, ShmSysConfigAndInfo->ate.targetCurrent_Value, TRUE, 0);
					break;
				}
				case V_POWERDELIVERYFALSE:{
					if (status){
						printf("CCS POWERDELIVERYFALSE Processing 14....................\n");
					}
					setEVStatus1(evstaus[3]);
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, ShmSysConfigAndInfo->ate.linkVoltage, Not_allowed, Not_Active, Allowed, Not_allowed, Opened);
					break;
				}
				case V_DETECTION:{
					if (status){
						printf("CCS DETECTION Processing 15....................\n");
					}
					setEVStatus1(evstaus[3]);
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, 0, Not_allowed, Active, Allowed, Not_allowed, Opened);
					break;
				}
				case V_SESSION_STOP:{
					if (status){
						printf("CCS SESSION_STOP Processing 16....................\n");
					}
					setEVStatus1(evstaus[3]);
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, 0, Not_allowed, Active, Allowed, Not_allowed, Opened);
					break;
				}
				case V_STOP_COMMUNICATION_SESSION:{
					if (status){
						printf("CCS STOP_COMMUNICATION_SESSION Processing 17....................\n");
					}
					setEVStatus1(evstaus[3]);
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, 0, Not_allowed, Active, Allowed, Not_allowed, Opened);
					break;
				}
				case V_FINISHED:{
					if (status){
						printf("CCS FINISHED Processing 18....................\n");
					}
					setEVStatus1(evstaus[3]);
					VCCU_ChargeFromVehicle(CanFd, ShmSysConfigAndInfo->ate.linkVoltage, 0, Not_allowed, Active, Allowed, Not_allowed, Opened);
					break;
				}
				default:{
					break;
				}
			}
			//usleep(25000);
			usleep(40000);

			//setBootNotification1();
		}else if(ShmSysConfigAndInfo->ate.ATEState  == 2){//GB
			if(ShmSysConfigAndInfo->ate.status == 0){
				int status = isModeChange(CCS_QUANTITY);
				setBootNotification1();
				usleep(1000);

				setMisc(1, ShmSysConfigAndInfo->ate.chademo.id0D_req.K1K2Status, ShmSysConfigAndInfo->ate.chademo.id0D_req.Soc);

				if(ShmSysConfigAndInfo->ate.ATEStatus == 1){
					ShmSysConfigAndInfo->ate.Permission = START;
					setChargerMode(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission);
					//ShmSysConfigAndInfo->ate.Permission = START;
					//setChargerMode(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission);
					//printf("ATEStatus == 1 %d \n",ShmSysConfigAndInfo->ate.ATEStatus);
				}else if(ShmSysConfigAndInfo->ate.ATEStatus == 2){
					ShmSysConfigAndInfo->ate.Permission = STOP;
					setChargerMode(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission);
					//printf("ATEStatus == 2 %d \n",ShmSysConfigAndInfo->ate.ATEStatus);
					ShmSysConfigAndInfo->ate.ATEStatus = 0;
				}else if(ShmSysConfigAndInfo->ate.ATEStatus == 3){
					//setEVStatus1(evstaus[4]);
					ShmSysConfigAndInfo->ate.Permission = STOP;
					setChargerMode(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission);
					ShmSysConfigAndInfo->ate.ATEStatus = 0x00;
					SetChargingPermission(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission, ShmSysConfigAndInfo->ate.TotalBatteryCap, ShmSysConfigAndInfo->ate.MaxBatteryCurrent, ShmSysConfigAndInfo->ate.MaxBatteryVoltage, 1);
					EvseStopChargingEvent(normalStop, stopReason, 1);
				}else{

				}
				//printf("state ==  %d  permission = %d \n",ShmSysConfigAndInfo->ate.chademo.id03.state, ShmSysConfigAndInfo->ate.Permission);
				if(ShmSysConfigAndInfo->ate.chademo.id03.state == 0 && ShmSysConfigAndInfo->ate.Permission == 0){
					//SetChargingPermission(CCS_QUANTITY, START, 1000, 1200, 6000, 1);
					//setChargerMode(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission);
					ShmSysConfigAndInfo->ate.Permission = START;
					setChargerMode(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission);
					SetChargingPermission(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission, ShmSysConfigAndInfo->ate.TotalBatteryCap, ShmSysConfigAndInfo->ate.MaxBatteryCurrent, ShmSysConfigAndInfo->ate.MaxBatteryVoltage, 1);

					setEVStatus1(evstaus[0]);
				}else  if(ShmSysConfigAndInfo->ate.chademo.id03.state ==1){
					ShmSysConfigAndInfo->ate.Permission = STOP;
					setEVStatus1(evstaus[0]);
				}else  if(ShmSysConfigAndInfo->ate.chademo.id03.state ==2){
					ShmSysConfigAndInfo->ate.Permission = STOP;
					setEVStatus1(evstaus[1]);
				}else  if(ShmSysConfigAndInfo->ate.chademo.id03.state ==3){
					ShmSysConfigAndInfo->ate.Permission = STOP;
					//setEVStatus1(evstaus[1]);
					setEVStatus1(evstaus[1]);
				}else  if(ShmSysConfigAndInfo->ate.chademo.id03.state ==4){
					ShmSysConfigAndInfo->ate.Permission = STOP;
					//setEVStatus1(evstaus[1]);
					setEVStatus1(evstaus[1]);
				}else  if(ShmSysConfigAndInfo->ate.chademo.id03.state == 5){
					ShmSysConfigAndInfo->ate.Permission = STOP;
					setEVStatus1(evstaus[1]);
				}else  if(ShmSysConfigAndInfo->ate.chademo.id03.state == 6){
					ShmSysConfigAndInfo->ate.Permission = STOP;
					setEVStatus1(evstaus[1]);
				}else  if(ShmSysConfigAndInfo->ate.chademo.id03.state == 7){
					ShmSysConfigAndInfo->ate.Permission = STOP;
					setEVStatus1(evstaus[2]);
					//setEVStatus2(evstaus[2]);
				}else  if(ShmSysConfigAndInfo->ate.chademo.id03.state == 8){
					ShmSysConfigAndInfo->ate.Permission = STOP;
					//outputRelay.relay_event.bits.Gun1_Parallel_N = 0x00;
					//outputRelay.relay_event.bits.Gun1_Parallel_P = 0x00;
					setEVStatus1(evstaus[2]);
					//setEVStatus2(evstaus[2]);
				}//else if(ShmSysConfigAndInfo->ate.chademo.id03.state == 16 ){
				else if(ShmSysConfigAndInfo->ate.chademo.id03.state >= 13 ){
					handleEmulatorFaultStatus();
					//setEVStatus1(evstaus[3]);
				}else if(ShmSysConfigAndInfo->ate.chademo.id03.state == 14 ){
					handleEmulatorFaultStatus();
					//setEVStatus1(evstaus[3]);
				}else if(ShmSysConfigAndInfo->ate.chademo.id03.state == 9 || ShmSysConfigAndInfo->ate.chademo.id03.state == 10
						|| ShmSysConfigAndInfo->ate.chademo.id03.state == 11 || ShmSysConfigAndInfo->ate.chademo.id03.state == 12
						//|| ShmSysConfigAndInfo->ate.chademo.id03.state == 13
						//|| ShmSysConfigAndInfo->ate.chademo.id03.state == 15
						){
					ShmSysConfigAndInfo->ate.Permission = STOP;
					setEVStatus1(evstaus[3]);
					//setEVStatus1(evstaus[3]);
					handleEmulatorFaultStatus();
				}else{
					setEVStatus1(evstaus[0]);
					//printf("4 %d %d\n",ShmSysConfigAndInfo->ate.chademo.id03.state,ShmSysConfigAndInfo->ate.chademo.id0D_req.K1K2Status);
				}

				if(ShmSysConfigAndInfo->ate.chademo.id03.ProximitySignal == 0){
					//printf("1 %d ===== \n", ShmSysConfigAndInfo->ate.chademo.id03.ProximitySignal);

					//printf("ProximitySignal=====%d  \n", ShmSysConfigAndInfo->ate.chademo.id03.ProximitySignal);
					setEVStatus1(evstaus[3]);
				}else if(ShmSysConfigAndInfo->ate.chademo.id03.ProximitySignal == 1 && ShmSysConfigAndInfo->ate.chademo.id03.state != 7 &&
						ShmSysConfigAndInfo->ate.chademo.id03.state != 9 && ShmSysConfigAndInfo->ate.chademo.id03.state != 10
						&& ShmSysConfigAndInfo->ate.chademo.id03.state != 11 && ShmSysConfigAndInfo->ate.chademo.id03.state != 12
						&& ShmSysConfigAndInfo->ate.chademo.id03.state != 13
						&& ShmSysConfigAndInfo->ate.chademo.id03.state != 15){
					//printf("2 %d ===== \n", ShmSysConfigAndInfo->ate.chademo.id03.ProximitySignal);
					setEVStatus1(evstaus[1]);
				}
				if(status){
					//printf("status change1 %d ===== \n", status);
					SetChargingPermission(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission, ShmSysConfigAndInfo->ate.TotalBatteryCap, ShmSysConfigAndInfo->ate.MaxBatteryCurrent, ShmSysConfigAndInfo->ate.MaxBatteryVoltage, 1);
				}else{
					if(ShmSysConfigAndInfo->ate.Permission == STOP ){
						if(ShmSysConfigAndInfo->ate.chademo.id03.state == 0){
							//printf("status change0 %d ===== \n", status);
							//SetChargingPermission(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission, ShmSysConfigAndInfo->ate.TotalBatteryCap, ShmSysConfigAndInfo->ate.MaxBatteryCurrent, ShmSysConfigAndInfo->ate.MaxBatteryVoltage, 1);
							SetChargingPermission(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission, ShmSysConfigAndInfo->ate.TotalBatteryCap, ShmSysConfigAndInfo->ate.MaxBatteryCurrent, ShmSysConfigAndInfo->ate.MaxBatteryVoltage, 1);
						}

					}
				}
				//SetChargingPermission(CCS_QUANTITY, ShmSysConfigAndInfo->ate.Permission, ShmSysConfigAndInfo->ate.TotalBatteryCap, ShmSysConfigAndInfo->ate.MaxBatteryCurrent, ShmSysConfigAndInfo->ate.MaxBatteryVoltage, 1);
				//SetChargingPermission(CCS_QUANTITY, START, 1000, 1200, 6000, 1);
				usleep(1000);
				//給火線電壓
				//07
				SetPresentInputPower(ShmSysConfigAndInfo->ate.RequireVoltage, ShmSysConfigAndInfo->ate.RequireCurrent, 1);
				usleep(1000);
				//SetPresentInputRequirement(4800, 6000, 1920, 20);
				SetPresentInputRequirement(ShmSysConfigAndInfo->ate.RequireVoltage, ShmSysConfigAndInfo->ate.RequireCurrent, ShmSysConfigAndInfo->ate.PresentBattVoltage, ShmSysConfigAndInfo->ate.MinimumChargeCurrent, 1);

			}
		}else if(ShmSysConfigAndInfo->ate.ATEState  == 3){//chademo

		}

	}

	#if (!DEMO)

	#else

	#endif
	return FAIL;
}