csu3_am335x/EVSE/Projects/AW-Regular/Apps/Module_InternalComm.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/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 	<math.h>
#include	"define.h"
#include	"main.h"
#include	"Module_InternalComm.h"

#define FAIL_SPEC_COMM		1000
#define ARRAY_SIZE(A)		(sizeof(A) / sizeof(A[0]))
#define PASS				1
#define FAIL				0
#define ON					1
#define OFF					0

struct SysConfigAndInfo			*ShmSysConfigAndInfo;
struct StatusCodeData 			*ShmStatusCodeData;
struct PrimaryMcuData			*ShmPrimaryMcuData;
struct OCPP16Data 				*ShmOCPP16Data;
struct Charger					*ShmCharger;

uint16_t						stepIndex;

void trim(char *s);
int mystrcmp(char *p1,char *p2);
void substr(char *dest, const char* src, unsigned int start, unsigned int cnt);
void split(char **arr, char *str, const char *del);

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

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

	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,
			buffer,
			tm->tm_year+1900,tm->tm_mon+1);

#ifdef SystemLogMessage
	system(Buf);
#endif

	printf("[%04d.%02d.%02d %02d:%02d:%02d] - %s", tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec, buffer);

	return rc;
}

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

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

//=================================
// Common routine
//=================================
void trim(char *s)
{
    int i=0, j, k, l=0;

    while((s[i]==' ')||(s[i]=='\t')||(s[i]=='\n'))
        i++;

    j = strlen(s)-1;
    while((s[j]==' ')||(s[j]=='\t')||(s[j]=='\n'))
        j--;

    if(i==0 && j==strlen(s)-1) { }
    else if(i==0) s[j+1] = '\0';
    else {
        for(k=i; k<=j; k++) s[l++] = s[k];
        s[l] = '\0';
    }
}

int mystrcmp(char *p1,char *p2)
{
    while(*p1==*p2)
    {
        if(*p1=='\0' || *p2=='\0')
            break;
        p1++;
        p2++;
    }
    if(*p1=='\0' && *p2=='\0')
        return(PASS);
    else
        return(FAIL);
}

void substr(char *dest, const char* src, unsigned int start, unsigned int cnt)
{
	strncpy(dest, src + start, cnt);
	dest[cnt] = 0;
}

void split(char **arr, char *str, const char *del)
{
	char *s = strtok(str, del);

	while(s != NULL)
	{
		*arr++ = s;
		s = strtok(NULL, del);
	}
}

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

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

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

	//Initial ShmPrimaryMcuKey
	if ((MeterSMId = shmget(ShmPrimaryMcuKey, sizeof(struct PrimaryMcuData), IPC_CREAT | 0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmget ShmPrimaryMcuData NG\r\n");
		#endif
		result = FAIL;
	}
	else if ((ShmPrimaryMcuData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmat ShmPrimaryMcuData NG\r\n");
		#endif
		result = FAIL;
	}

	//creat ShmOCPP16Data
	if ((MeterSMId = shmget(ShmOcppModuleKey, sizeof(struct OCPP16Data),  0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmget ShmOCPP16Data NG");
		#endif
		result = FAIL;
	}
	else if ((ShmOCPP16Data = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmat ShmOCPP16Data NG");
		#endif
		result = FAIL;
	}
	else
	{}

	//Initial ShmCharger
	if ((MeterSMId = shmget(ShmChargerKey, sizeof(struct Charger), IPC_CREAT | 0777)) < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmget ShmChargerKey NG\r\n");
		#endif
		result = FAIL;
	}
	else if ((ShmCharger = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("shmat ShmChargerKey NG\r\n");
		#endif
		result = FAIL;
	}

	return result;
}

int InitComPort()
{
	int fd;
	struct termios tios;

	fd = open("/dev/ttyS1", O_RDWR);
	if(fd<=0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("open /dev/ttyS1 NG\n");
		#endif
		return -1;
	}
	ioctl (fd, TCGETS, &tios);
	tios.c_cflag = B115200| CS8 | CLOCAL | CREAD;
	tios.c_lflag = 0;
	tios.c_iflag = 0;
	tios.c_oflag = 0;
	tios.c_cc[VMIN]=0;
	tios.c_cc[VTIME]=(unsigned char)5;		// timeout 0.5 secod
	tios.c_lflag=0;
	tcflush(fd, TCIFLUSH);
	ioctl (fd, TCSETS, &tios);

	return fd;
}

int tranceive(int fd, unsigned char* cmd, unsigned char cmd_len, unsigned char* rx)
{
	int len;
	//sleep(2); //required to make flush work, for some reason
	tcflush(fd,TCIOFLUSH);
	if(write(fd, cmd, cmd_len) >= cmd_len)
	{
		usleep(300000);
		len = read(fd, rx, 512);
	}
	else
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("Serial command %s response fail.\n", cmd);
		#endif
	}

	return len;
}

unsigned char Query_FW_Ver(unsigned char fd, unsigned char targetAddr, Ver *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_FW_VER, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx = 0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]))
		{
			strncpy(Ret_Buf->Version_FW, (char *)rx+6, (rx[4] | rx[5]<<8));
			result = PASS;
		}
	}

	return result;
}

unsigned char Query_HW_Ver(unsigned char fd, unsigned char targetAddr, Ver *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_HW_VER, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx = 0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]))
		{
			strncpy(Ret_Buf->Version_HW, (char *)rx+6, (rx[4] | rx[5]<<8));
			result = PASS;
		}
	}

	return result;
}

unsigned char Query_Present_InputVoltage(unsigned char fd, unsigned char targetAddr, PresentInputVoltage *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_PRESENT_INPUTVOLTAGE, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx = 0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]))
		{
			Ret_Buf->inputType = rx[6];
			Ret_Buf->L1N_L12 =( rx[7] | (rx[8]<<8))/10.0;
			Ret_Buf->L2N_L23 =( rx[9] | (rx[10]<<8))/10.0;
			Ret_Buf->L3N_L31 =( rx[11] | (rx[12]<<8))/10.0;

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_Present_OutputVoltage(unsigned char fd, unsigned char targetAddr, PresentOutputVoltage *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_PRESENT_OUTPUTVOLTAGE, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx = 0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]))
		{
			Ret_Buf->behindFuse_Voltage_C1 =(rx[6] | (rx[7]<<8))/10.0;
			Ret_Buf->behindRelay_Voltage_C1 =(rx[8] | (rx[9]<<8))/10.0;
			if((rx[4] | rx[5]<<8) > 4)
			{
				Ret_Buf->behindFuse_Voltage_C2 =(rx[10] | (rx[11]<<8))/10.0;
				Ret_Buf->behindRelay_Voltage_C2 =(rx[12] | (rx[13]<<8))/10.0;
			}
			result = PASS;
		}
	}

	return result;
}

unsigned char Query_Fan_Speed(unsigned char fd, unsigned char targetAddr, FanSpeed *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_FAN_SPEED, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx = 0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]))
		{
			for(int idx=0;idx<((rx[4] | rx[5]<<8)>>1);idx++)
				Ret_Buf->speed[idx] =(rx[6+(2*idx)] | (rx[6+(2*idx)+1]<<8));

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_Temperature(unsigned char fd, unsigned char targetAddr, Temperature *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_TEMPERATURE, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx = 0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]))
		{
			for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
				Ret_Buf->point[idx] = rx[6+idx] - 60;

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_Aux_PowerVoltage(unsigned char fd, unsigned char targetAddr, AuxPower *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_AUX_POWERVOLTAGE, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx = 0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]))
		{
			for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
				Ret_Buf->voltage[idx] = rx[6+idx];

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_Relay_Output(unsigned char fd, unsigned char targetAddr, Relay *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_RELAY_OUTPUT, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx = 0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]))
		{
			for(int idx_connector=0;idx_connector<(rx[4] | rx[5]<<8);idx_connector++)
			{
				for(int idx=0;idx<8;idx++)
					Ret_Buf->relay_status[idx_connector][idx] = (rx[6+idx_connector]>>idx) & 0x01;
			}

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_Gfd_Adc(unsigned char fd, unsigned char targetAddr, Gfd *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_GFD_ADC, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx = 0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]))
		{
			for(int idx_connector=0;idx_connector<((rx[4] | rx[5]<<8)>>2);idx_connector++)
			{
				Ret_Buf->adc_value_positive[idx_connector] = (rx[6+(4*idx_connector)] | rx[6+(4*idx_connector)+1]<<8);
				Ret_Buf->adc_value_negative[idx_connector] = (rx[6+(4*idx_connector)+2] | rx[6+(4*idx_connector)+3]<<8);;
			}

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_Gpio_Input(unsigned char fd, unsigned char targetAddr, Gpio_in *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_GPIO_INPUT, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx = 0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]))
		{
			Ret_Buf->AC_Connector 		= (rx[6] >> 0) & 0x01;
			Ret_Buf->AC_MainBreaker 	= (rx[6] >> 1) & 0x01;
			Ret_Buf->SPD 				= (rx[6] >> 2) & 0x01;
			Ret_Buf->Door_Open 			= (rx[6] >> 3) & 0x01;
			Ret_Buf->GFD[0] 			= (rx[6] >> 4) & 0x01;
			Ret_Buf->GFD[1] 			= (rx[6] >> 5) & 0x01;
			Ret_Buf->Button[0] 			= (rx[6] >> 6) & 0x01;
			Ret_Buf->Button[1] 			= (rx[6] >> 7) & 0x01;
			Ret_Buf->Button_Emergency	= (rx[7] >> 0) & 0x01;

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_Alarm_Log(unsigned char fd, unsigned char targetAddr, Alarm_Log *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[10] = {0xaa, 0x00, targetAddr, CMD_QUERY_ALARM_LOG, 0x03, 0x00, Ret_Buf->logArea, Ret_Buf->alarmIndex&0xff, ((Ret_Buf->alarmIndex>>8)&0xff), 0x00};
	unsigned char rx[512];
	unsigned char chksum = Ret_Buf->logArea ^ (Ret_Buf->alarmIndex&0xff) ^ ((Ret_Buf->alarmIndex>>8)&0xff);
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]))
		{
			memcpy(&Ret_Buf->log[0], &rx[8], 8);

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_RTC(unsigned char fd, unsigned char targetAddr, Rtc *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_RTC, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]))
		{
			Ret_Buf->year = ((rx[6]-'0')*1000) + ((rx[7]-'0')*100) + ((rx[8]-'0')*10) + ((rx[9]-'0')*1);
			Ret_Buf->month = ((rx[10]-'0')*10) + ((rx[11]-'0')*1);
			Ret_Buf->day = ((rx[12]-'0')*10) + ((rx[13]-'0')*1);
			Ret_Buf->hour = ((rx[14]-'0')*10) + ((rx[15]-'0')*1);
			Ret_Buf->min = ((rx[16]-'0')*10) + ((rx[17]-'0')*1);
			Ret_Buf->sec = ((rx[18]-'0')*10) + ((rx[19]-'0')*1);

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_AC_MCU_Status(unsigned char fd, unsigned char targetAddr, Ac_Primary_Mcu *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_AC_STATUS, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]))
		{
			Ret_Buf->cp_state = rx[6];
			Ret_Buf->current_limit = rx[7] | (rx[8]<<0x08);
			Ret_Buf->cp_voltage_positive = (rx[9] | (rx[10]<<0x08))/100.0;
			Ret_Buf->cp_voltage_negtive = (rx[11] | (rx[12]<<0x08))/100.0;
			Ret_Buf->locker_state = rx[13];
			Ret_Buf->relay_state = rx[14];
			Ret_Buf->shutter_state = rx[15];
			Ret_Buf->meter_state = rx[16];
			Ret_Buf->pp_state = rx[17];
			Ret_Buf->rating_current = rx[18];
			Ret_Buf->rotatory_switch = rx[19];

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_AC_MCU_Alarm(unsigned char fd, unsigned char targetAddr, Ac_Primary_Mcu_Alarm *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_AC_ALARM, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]))
		{
			//rx[6]
			Ret_Buf->bits.OVP = (((rx[6]>>0)&0x01)?1:0);
			Ret_Buf->bits.UVP = (((rx[6]>>1)&0x01)?1:0);
			Ret_Buf->bits.OCP = (((rx[6]>>2)&0x01)?1:0);
			Ret_Buf->bits.OTP = (((rx[6]>>3)&0x01)?1:0);
			Ret_Buf->bits.gmi_fault = (((rx[6]>>4)&0x01)?1:0);
			Ret_Buf->bits.cp_fault = (((rx[6]>>5)&0x01)?1:0);
			Ret_Buf->bits.ac_leak = (((rx[6]>>6)&0x01)?1:0);
			Ret_Buf->bits.dc_leak = (((rx[6]>>7)&0x01)?1:0);

			//rx[7]
			Ret_Buf->bits.mcu_selftest_fail = (((rx[7]>>0)&0x01)?1:0);
			Ret_Buf->bits.handshaking_timeout = (((rx[7]>>1)&0x01)?1:0);
			Ret_Buf->bits.emergency_stop = (((rx[7]>>2)&0x01)?1:0);
			Ret_Buf->bits.relay_welding = (((rx[7]>>3)&0x01)?1:0);
			Ret_Buf->bits.leak_module_fail = (((rx[7]>>4)&0x01)?1:0);
			Ret_Buf->bits.shutter_fault = (((rx[7]>>5)&0x01)?1:0);
			Ret_Buf->bits.locker_fault = (((rx[7]>>6)&0x01)?1:0);
			Ret_Buf->bits.power_drop = (((rx[7]>>7)&0x01)?1:0);

			//rx[8] 3~7bits reserved
			Ret_Buf->bits.circuit_short = (((rx[8]>>0)&0x01)?1:0);
			Ret_Buf->bits.set_circuit = (((rx[8]>>1)&0x01)?1:0);
			Ret_Buf->bits.relay_drive_fault = (((rx[8]>>2)&0x01)?1:0);

			//rx[9] 0~7bits reserved

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_Present_OutputCurrent(unsigned char fd, unsigned char targetAddr, Presentoutputcurrent *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_PRESENT_OUTPUTCURRENT, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 0)
	{
		if(len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]))
		{
			Ret_Buf->L1N_L12[0] = (rx[6] | (rx[7]<<8))/10.0;
			Ret_Buf->L2N_L23[0] = (rx[8] | (rx[9]<<8))/10.0;
			Ret_Buf->L3N_L31[0] = (rx[10] | (rx[11]<<8))/10.0;
			Ret_Buf->L1N_L12[1] = (rx[12] | (rx[13]<<8))/10.0;
			Ret_Buf->L2N_L23[1] = (rx[14] | (rx[15]<<8))/10.0;
			Ret_Buf->L3N_L31[1] = (rx[16] | (rx[17]<<8))/10.0;

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_Ble_Config(unsigned char fd, unsigned char targetAddr, Ble_Config_Data *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_BLE_CONFIG_DATA, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 0)
	{
		if(len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]))
		{
			Ret_Buf->isLogin = (rx[6]?0x01:0x00);
			Ret_Buf->isRequestStart = (rx[7]?0x01:0x00);
			Ret_Buf->isRequestStop = (rx[8]?0x01:0x00);

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_Ble_Central_ID(unsigned char fd, unsigned char targetAddr, Ble_Login_Central_Id *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_BLE_CENTRAL_ID, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 0)
	{
		if(len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]))
		{
			memset(Ret_Buf->id, 0x00, ARRAY_SIZE(Ret_Buf->id));
			memcpy(&Ret_Buf->id[0], &rx[6], (rx[4] | (rx[5]<<8)));

			result = PASS;
		}
	}

	return result;
}

unsigned char Query_Power_Consumption(unsigned char fd, unsigned char targetAddr, Power_Consumption *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_POWER_CONSUMPTION, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 0)
	{
		if(len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]))
		{
			Ret_Buf-> power_consumption = ((uint32_t)rx[6] | (((uint32_t)rx[7])<<8) | (((uint32_t)rx[8])<<16) | (((uint32_t)rx[9])<<24));
			result = PASS;
		}
	}

	return result;
}

unsigned char Config_Fan_Speed(unsigned char fd, unsigned char targetAddr, FanSpeed *Set_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[15] = {0xaa, 0x00, targetAddr, CMD_CONFIG_FAN_SPEED, 0x08, 0x00, Set_Buf->speed[0]&0xff, (Set_Buf->speed[0]>>8)&0xff, Set_Buf->speed[1]&0xff, (Set_Buf->speed[1]>>8)&0xff, Set_Buf->speed[2]&0xff, (Set_Buf->speed[2]>>8)&0xff, Set_Buf->speed[3]&0xff, (Set_Buf->speed[3]>>8)&0xff, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
		chksum ^= tx[6+idx];
	tx[14] = chksum;

	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
				return result;

		chksum = 0x00;
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]) &&
		   (rx[6] == 0x01))
		{
			result = PASS;
		}
	}

	return result;
}

unsigned char Config_Serial_Number(unsigned char fd, unsigned char targetAddr, Evse_Id *Set_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[27] = {0xaa, 0x00, targetAddr, CMD_CONFIG_SERIAL_NUMBER, 0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;

	memcpy(&tx[14], &Set_Buf->serial_number[0], ARRAY_SIZE(Set_Buf->serial_number));

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
		chksum ^= tx[6+idx];
	tx[26] = chksum;

	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		chksum = 0x00;
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]) &&
		   (rx[6] == 0x01))
		{
			result = PASS;
		}
	}

	return result;
}

unsigned char Config_Model_Name(unsigned char fd, unsigned char targetAddr, Evse_Id *Set_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[21] = {0xaa, 0x00, targetAddr, CMD_CONFIG_MODEL_NAME, 0x0e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;

	memcpy(&tx[6], &Set_Buf->model_name[0], ARRAY_SIZE(Set_Buf->model_name));

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
		chksum ^= tx[6+idx];
	tx[20] = chksum;

	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		chksum = 0x00;
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]) &&
		   (rx[6] == 0x01))
		{
			result = PASS;
		}
	}

	return result;
}

unsigned char Config_Relay_Output(unsigned char fd, unsigned char targetAddr, Relay *Set_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[9] = {0xaa, 0x00, targetAddr, CMD_CONFIG_RELAY_OUTPUT, 0x02, 0x00, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;

	for(int idx_connector=0;idx_connector<2;idx_connector++)
		for(int idx = 0;idx<8;idx++)
			tx[6+idx_connector] |= ((Set_Buf->relay_status[idx_connector][idx]?0x01:0x00)<<idx);

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
		chksum ^= tx[6+idx];
	tx[8] = chksum;

	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		chksum = 0x00;
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]) &&
		   (rx[6] == 0x01))
		{
			result = PASS;
		}
	}

	return result;
}

unsigned char Config_Gpio_Output(unsigned char fd, unsigned char targetAddr, Gpio_out *Set_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[9] = {0xaa, 0x00, targetAddr, CMD_CONFIG_GPIO_OUTPUT, 0x01, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;

	tx[6] |= (Set_Buf->AC_Connector?0x01:0x00);

	for(int idx=0;idx<2;idx++)
		tx[6] |= (Set_Buf->Button_LED[idx]?0x01:0x00)<<(1+idx);

	for(int idx=0;idx<4;idx++)
			tx[6] |= (Set_Buf->System_LED[idx]?0x01:0x00)<<(3+idx);

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
		chksum ^= tx[6+idx];
	tx[14] = chksum;

	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		chksum = 0x00;
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]) &&
		   (rx[6] == tx[6]))
		{
			result = PASS;
		}
	}

	return result;
}

unsigned char Config_RTC(unsigned char fd, unsigned char targetAddr, Rtc *Set_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[21];
	unsigned char rx[512];
	unsigned char chksum = 0x00;


	tx[0] = 0xaa;
	tx[1] = 0x00;
	tx[2] = targetAddr;
	tx[3] = CMD_CONFIG_RTC;
	tx[4] = 0x0e;
	tx[5] = 0x00;
	tx[6] = ((Set_Buf->year)/1000)+'0';
	tx[7] = ((Set_Buf->year)/100%10)+'0';
	tx[8] = ((Set_Buf->year)/10%10)+'0';
	tx[9] = (Set_Buf->year)%1000+'0';
	tx[10] = ((Set_Buf->month)/10)+'0';
	tx[11] = ((Set_Buf->month)%10)+'0';
	tx[12] = ((Set_Buf->day)/10)+'0';
	tx[13] = ((Set_Buf->day)%10)+'0';
	tx[14] = ((Set_Buf->hour)/10)+'0';
	tx[15] = ((Set_Buf->hour)%10)+'0';
	tx[16] = ((Set_Buf->min)/10)+'0';
	tx[17] = ((Set_Buf->min)%10)+'0';
	tx[18] = ((Set_Buf->sec)/10)+'0';
	tx[19] = ((Set_Buf->sec)%10)+'0';

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
		chksum ^= tx[6+idx];
	tx[20] = chksum;

	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		chksum = 0x00;
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]) &&
		   (rx[6] == 0x01))
		{
			result = PASS;
		}
	}

	return result;
}

unsigned char Config_AC_MCU_LED(unsigned char fd, unsigned char targetAddr, Ac_Primary_Mcu_Led *Set_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[12] ;
	unsigned char rx[512];
	unsigned char chksum = 0x00;

	tx[0] = 0xaa;
	tx[1] = 0x00;
	tx[2] = targetAddr;
	tx[3] = CMD_CONFIG_AC_LED;
	tx[4] = 0x05;
	tx[5] = 0x00;
	tx[6] = Set_Buf->mode;
	tx[7] = ((Set_Buf->alarm_code>>0)&0xff);
	tx[8] = ((Set_Buf->alarm_code>>8)&0xff);
	tx[9] = ((Set_Buf->alarm_code>>16)&0xff);
	tx[10] = ((Set_Buf->alarm_code>>24)&0xff);

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
		chksum ^= tx[6+idx];
	tx[11] = chksum;

	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		chksum = 0x00;
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]) &&
			(rx[6] == 0x01))
		{
			result = PASS;
		}
	}

	return result;
}

unsigned char Config_AC_MCU_LEGACY_REQUEST(unsigned char fd, unsigned char targetAddr, Legacy_Request *Set_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[9];
	unsigned char rx[512];
	unsigned char chksum = 0x00;

	tx[0] = 0xaa;
	tx[1] = 0x00;
	tx[2] = targetAddr;
	tx[3] = CMD_CONFIG_MCU_MODE;
	tx[4] = 0x02;
	tx[5] = 0x00;
	tx[6] = Set_Buf->isLegacyRequest;
	tx[7] = 0x00;

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
		chksum ^= tx[6+idx];
	tx[8] = chksum;

	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		chksum = 0x00;
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]) &&
		   (rx[6] == 0x01))
		{
			result = PASS;

		}
	}

	return result;
}

unsigned char Config_AC_MCU_RESET_REQUEST(unsigned char fd, unsigned char targetAddr, Mcu_Reset_Request *Set_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[9];
	unsigned char rx[512];
	unsigned char chksum = 0x00;

	tx[0] = 0xaa;
	tx[1] = 0x00;
	tx[2] = targetAddr;
	tx[3] = CMD_CONFIG_MCU_RESET_REQUEST;
	tx[4] = 0x02;
	tx[5] = 0x00;
	tx[6] = Set_Buf->isMcuResetRequest;
	tx[7] = 0x00;

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
		chksum ^= tx[6+idx];
	tx[8] = chksum;

	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		chksum = 0x00;
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]) &&
		   (rx[6] == 0x01))
		{
			result = PASS;
		}
	}

	return result;
}

unsigned char Query_AC_GUN_PLUGIN_TIMES(unsigned char fd, unsigned char targetAddr, Gun_Plugin_Times *Ret_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_QUERY_GUN_PLUGIN_TIMES, 0x00, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 0)
	{
		if(len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
		   (rx[2] == tx[1]) &&
		   (rx[1] == tx[2]) &&
		   (rx[3] == tx[3]))
		{
			Ret_Buf-> GunPluginTimes = ((uint32_t)rx[6] | (((uint32_t)rx[7])<<8) | (((uint32_t)rx[8])<<16) | (((uint32_t)rx[9])<<24));
			result = PASS;
		}
	}

	return result;
}

unsigned char Config_AC_MaxCurrent_And_CpPwmDuty(unsigned char fd, unsigned char targetAddr, Ac_Primary_Mcu_Cp_Pwm_Duty*Set_Buf)
{
	unsigned char result = FAIL;
	unsigned char tx[9];
	unsigned char rx[512];
	unsigned char chksum = 0x00;

	tx[0] = 0xaa;
	tx[1] = 0x00;
	tx[2] = targetAddr;
	tx[3] = CMD_CONFIG_CURRENT_LINIT;
	tx[4] = 0x05;
	tx[5] = 0x00;
	tx[6] = Set_Buf->max_current;

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
			chksum ^= tx[6+idx];
	tx[8] = chksum;

	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		chksum = 0x00;
		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]) &&
			(rx[6] == 0x01))
		{
			result = PASS;
		}
	}
		return result;
}

unsigned char Update_Start(unsigned char fd, unsigned char targetAddr, unsigned int crc32)
{
	unsigned char result = FAIL;
	unsigned char tx[11] = {0xaa, 0x00, targetAddr, CMD_UPDATE_START, 0x04, 0x00, (crc32>>0)&0xff, (crc32>>8)&0xff, (crc32>>16)&0xff, (crc32>>24)&0xff, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
		chksum ^= tx[6+idx];
	tx[10] = chksum;

	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);
	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		chksum = 0x00;
		for(int idx = 0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]) &&
			(rx[6] == 0x00))
		{
			result = PASS;
		}
	}

	return result;
}

unsigned char Update_Abord(unsigned char fd, unsigned char targetAddr)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_UPDATE_ABOARD, 0x04, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx = 0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];

		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]) &&
			(rx[6] == 0x00))
		{
			result = PASS;
		}
	}

	return result;
}

unsigned char Update_Transfer(unsigned char fd, unsigned char targetAddr, unsigned int startAddr, unsigned char *data, unsigned short int length)
{
	unsigned char result = FAIL;
	unsigned char tx[11 + length];
	unsigned char rx[512];
	unsigned char chksum = 0x00;

	tx[0] = 0xaa;
	tx[1] = 0x00;
	tx[2] = targetAddr;
	tx[3] = CMD_UPDATE_TRANSFER;
	tx[4] = (4 + length) & 0xff;
	tx[5] = ((4 + length)>>8) & 0xff;
	tx[6] = (startAddr>>0) & 0xff;
	tx[7] = (startAddr>>8) & 0xff;
	tx[8] = (startAddr>>16) & 0xff;
	tx[9] = (startAddr>>24) & 0xff;
	memcpy(tx+10, data, length);

	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
		chksum ^= tx[6+idx];
	tx[sizeof(tx)-1] = chksum;

	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
			return result;

		for(int idx = 0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]) &&
			(rx[6] == 0x00))
		{
			result = PASS;
		}
	}

	return result;
}

unsigned char Update_Finish(unsigned char fd, unsigned char targetAddr)
{
	unsigned char result = FAIL;
	unsigned char tx[7] = {0xaa, 0x00, targetAddr, CMD_UPDATE_END, 0x04, 0x00, 0x00};
	unsigned char rx[512];
	unsigned char chksum = 0x00;
	unsigned char len = tranceive(fd, tx, sizeof(tx), rx);

	if(len > 6)
	{
		if (len < 6+(rx[4] | rx[5]<<8))
				return result;

		for(int idx=0;idx<(rx[4] | rx[5]<<8);idx++)
		{
			chksum ^= rx[6+idx];
		}

		if((chksum == rx[6+(rx[4] | rx[5]<<8)]) &&
			(rx[2] == tx[1]) &&
			(rx[1] == tx[2]) &&
			(rx[3] == tx[3]) &&
			(rx[6] == 0x01))
		{
			result = PASS;
		}
	}
	return result;
}


//================================================
// Main process
//================================================
int main(void)
{
	int Uart1Fd;

	unsigned short int failCount[2] = {0,0};

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

	Uart1Fd=InitComPort();
	if(Uart1Fd<0)
	{
		DEBUG_ERROR("InitComPort NG\n");
		if(ShmStatusCodeData!=NULL)
		{
			ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed=1;
		}
		sleep(5);
		return 0;
	}
	else
	{
		DEBUG_INFO("ttyS1 port open success.\r\n");
	}

	for(;;)
	{
		for(int gun_index=0;gun_index<AC_QUANTITY;gun_index++)
		{
			//===============================
			// Query firmware version
			//===============================
			if(ShmCharger->gun_info[gun_index].mcuFlag.isReadFwVerPass != PASS)
			{
				if(Query_FW_Ver(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].ver) == PASS)
				{
					DEBUG_INFO("MCU-%d get firmware version : %s\r\n", gun_index, ShmCharger->gun_info[gun_index].ver.Version_FW);
					memcpy(ShmPrimaryMcuData->version, ShmCharger->gun_info[gun_index].ver.Version_FW, sizeof(ShmPrimaryMcuData->version));
					ShmCharger->gun_info[gun_index].mcuFlag.isReadFwVerPass = PASS;

					failCount[gun_index] = 0;
				}
				else
				{
					DEBUG_WARN("MCU-%d get firmware version fail...%d\r\n", gun_index, failCount[gun_index]);
					if(failCount[gun_index]<1000)
					{
						failCount[gun_index]++;
					}
				}
			}

			//===============================
			// Config primary MCU serial number
			//===============================
			if(ShmCharger->gun_info[gun_index].mcuFlag.isSetSerialNumberPass != PASS)
			{
				memcpy(ShmCharger->evseId.serial_number, ShmSysConfigAndInfo->SysConfig.SerialNumber, ARRAY_SIZE(ShmCharger->evseId.serial_number));
				if(Config_Serial_Number(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->evseId))
				{
					DEBUG_INFO("MCU-%d set serial number : %.12s\r\n",gun_index,ShmCharger->evseId.serial_number);
					ShmCharger->gun_info[gun_index].mcuFlag.isSetSerialNumberPass = PASS;

					failCount[gun_index] = 0;
				}
				else
				{
					DEBUG_WARN("MCU-%d set serial number fail...%d\r\n", gun_index, failCount[gun_index]);
					if(failCount[gun_index]<1000)
					{
						failCount[gun_index]++;
					}
				}
			}

			//===============================
			// Config primary MCU model name
			//===============================
			if(ShmCharger->gun_info[gun_index].mcuFlag.isSetModelNamePass != PASS)
			{
				memcpy(ShmCharger->evseId.model_name, ShmSysConfigAndInfo->SysConfig.ModelName, ARRAY_SIZE(ShmCharger->evseId.model_name));
				if(Config_Model_Name(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->evseId))
				{
					DEBUG_INFO("MCU-%d set model name : %.14s\r\n",gun_index,ShmCharger->evseId.model_name);
					ShmCharger->gun_info[gun_index].mcuFlag.isSetModelNamePass = PASS;

					failCount[gun_index] = 0;
				}
				else
				{
					DEBUG_WARN("MCU-%d set model name fail...%d\r\n", gun_index, failCount[gun_index]);
					if(failCount[gun_index]<1000)
					{
						failCount[gun_index]++;
					}
				}
			}


			/*
			 * Polling loop
			 */
			if((stepIndex%2)==0)
			{
				/*
				 * High priority communication
				 */

				//===============================
				// Config primary MCU LED
				//===============================
				ShmCharger->gun_info[gun_index].primaryMcuLed.alarm_code = ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode;
				if(Config_AC_MCU_LED(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].primaryMcuLed))
				{
					DEBUG_INFO("MCU-%d set Led mode : %d\r\n",gun_index, ShmCharger->gun_info[gun_index].primaryMcuLed.mode);
					DEBUG_INFO("MCU-%d set Alarm code : %x\r\n",gun_index, ShmCharger->gun_info[gun_index].primaryMcuLed.alarm_code);

					failCount[gun_index] = 0;
				}
				else
				{
					DEBUG_WARN("MCU-%d set led fail...%d\r\n", gun_index, failCount[gun_index]);
					if(failCount[gun_index]<1000)
					{
						failCount[gun_index]++;
					}
				}

				//===============================
				// Config primary Legacy request
				//===============================
				if(Config_AC_MCU_LEGACY_REQUEST(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1),&ShmCharger->gun_info[gun_index].legacyRequest))
				{
					DEBUG_INFO("MCU-%d set relay request : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].legacyRequest.isLegacyRequest);
					DEBUG_INFO("========================================\n");

					failCount[gun_index] = 0;
				}
				else
				{
					DEBUG_WARN("MCU-%d set relay request fail...%d\r\n", gun_index, failCount[gun_index]);
					if(failCount[gun_index]<1000)
						failCount[gun_index]++;
				}

				//===============================
				// Query primary MCU status
				//===============================
				if(Query_AC_MCU_Status(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].primaryMcuState))
				{
					if(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PreviousSystemStatus != ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].SystemStatus)
					{
						DEBUG_INFO("MCU-%d get Pilot State : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuState.cp_state);
						DEBUG_INFO("MCU-%d get Pilot Duty : %.2f\r\n", gun_index, (float)ShmCharger->gun_info[gun_index].primaryMcuState.current_limit);
						DEBUG_INFO("MCU-%d get Pilot Voltage Positive : %.2f\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuState.cp_voltage_positive);
						DEBUG_INFO("MCU-%d get Pilot Voltage Negative : %.2f\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuState.cp_voltage_negtive);
						DEBUG_INFO("MCU-%d get Locker State : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuState.locker_state);
						DEBUG_INFO("MCU-%d get Relay State : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuState.relay_state);
						DEBUG_INFO("MCU-%d get Shutter State : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuState.shutter_state);
						DEBUG_INFO("MCU-%d get Meter State : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuState.meter_state);
						DEBUG_INFO("MCU-%d get PP State : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuState.pp_state);
						DEBUG_INFO("MCU-%d get Rating Current : %.2f\r\n", gun_index, (float)ShmCharger->gun_info[gun_index].primaryMcuState.rating_current);
						DEBUG_INFO("MCU-%d get Rotatory switch : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuState.rotatory_switch);
					}

					ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState = ShmCharger->gun_info[gun_index].primaryMcuState.cp_state;
					ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotDuty = (ShmCharger->gun_info[gun_index].primaryMcuState.current_limit>51?(unsigned char)((ShmCharger->gun_info[gun_index].primaryMcuState.current_limit/2.5)+64):(unsigned char)(ShmCharger->gun_info[gun_index].primaryMcuState.current_limit/0.6));
					ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotVoltage = ShmCharger->gun_info[gun_index].primaryMcuState.cp_voltage_positive;
					ShmCharger->gun_info[gun_index].PilotVoltage.PilotVoltagePositive = ShmCharger->gun_info[gun_index].primaryMcuState.cp_voltage_positive;
					ShmCharger->gun_info[gun_index].PilotVoltage.PilotVoltageNegative = ShmCharger->gun_info[gun_index].primaryMcuState.cp_voltage_negtive;

					failCount[gun_index] = 0;
				}
				else
				{
					DEBUG_WARN("MCU-%d get status fail...%d\r\n", gun_index, failCount[gun_index]);
					if(failCount[gun_index]<1000)
					{
						failCount[gun_index]++;
					}
				}

				//===============================
				// Query primary MCU Alarm code
				//===============================
				if(Query_AC_MCU_Alarm(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].primaryMcuAlarm))
				{
					DEBUG_INFO("MCU-%d get alarm OK...\r\n");
					/*
					// Byte[6]
					// Byte[7]
					// Byte[8] Alarm code 3~7 bits Reserved
					// Byte[9] Alarm code 0~7 bits Reserved
					 */

					//================================================
					// Byte[6]
					//================================================
					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.OVP == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<0;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<0);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.UVP == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<1;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<1);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.OCP == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<2;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<2);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.OTP == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<3;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<3);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.gmi_fault == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<4;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<4);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.cp_fault == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<5;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<5);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.ac_leak == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<6;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<6);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.dc_leak == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<7;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<7);

					//================================================
					// Byte[7]
					//================================================
					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.mcu_selftest_fail == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<8;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<8);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.handshaking_timeout == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<9;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<9);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.emergency_stop == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<10;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<10);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.relay_welding == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<11;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<11);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.leak_module_fail == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<12;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<12);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.shutter_fault == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<13;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<13);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.locker_fault == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<14;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<14);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.power_drop == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<15;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<15);

					//================================================
					// Byte[8]
					//================================================
					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.circuit_short == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<16;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<16);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.set_circuit == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<17;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<17);

					if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.relay_drive_fault == 0x01)
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode |= 1<<18;
					else
						ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode &= ~(1<<18);

					//================================================
					// Byte[9]
					//================================================
					// Debug print out

					if(ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PreviousSystemStatus != ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].SystemStatus)
					{
						DEBUG_INFO("MCU-%d get OVP : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.OVP);
						DEBUG_INFO("MCU-%d get UVP : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.UVP);
						DEBUG_INFO("MCU-%d get OCP : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.OCP);
						DEBUG_INFO("MCU-%d get OTP : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.OTP);
						DEBUG_INFO("MCU-%d get gmi_fault : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.gmi_fault);
						DEBUG_INFO("MCU-%d get cp_fault : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.cp_fault);
						DEBUG_INFO("MCU-%d get ac_leak : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.ac_leak);
						DEBUG_INFO("MCU-%d get dc_leak : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.dc_leak);
						DEBUG_INFO("MCU-%d get mcu_selftest_fail : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.mcu_selftest_fail);
						DEBUG_INFO("MCU-%d get handshaking_timeout : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.handshaking_timeout);
						DEBUG_INFO("MCU-%d get emergency_stop : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.emergency_stop);
						DEBUG_INFO("MCU-%d get relay_welding : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.relay_welding);
						DEBUG_INFO("MCU-%d get leak_module_fail : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.leak_module_fail);
						DEBUG_INFO("MCU-%d get shutter_fault : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.shutter_fault);
						DEBUG_INFO("MCU-%d get locker_fault : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.locker_fault);
						DEBUG_INFO("MCU-%d get power_drop : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.power_drop);
						DEBUG_INFO("MCU-%d get circuit_short : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.circuit_short);
						DEBUG_INFO("MCU-%d get set_circuit : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.set_circuit);
						DEBUG_INFO("MCU-%d get relay_drive_fault : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.relay_drive_fault);
						DEBUG_INFO("MCU-%d get InputAlarmCode : %x\r\n", gun_index, ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode);
					}

					failCount[gun_index] = 0;
				}
				else
				{
					DEBUG_WARN("MCU-%d get alarm fail...%d\r\n", gun_index, failCount[gun_index]);
					if(failCount[gun_index]<1000)
					{
						failCount[gun_index]++;
					}
				}

				//===============================
				// Query primary MCU BLE config
				//===============================
				if(Query_Ble_Config(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].bleConfigData))
				{
					DEBUG_INFO("MCU-%d get isUserLogin : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].bleConfigData.isLogin);
					DEBUG_INFO("MCU-%d get isRequestStartCharger : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].bleConfigData.isRequestStart);
					DEBUG_INFO("MCU-%d get isRequestStopCharger : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].bleConfigData.isRequestStop);

					ShmSysConfigAndInfo->SysConfig.Bluetooth.isLogin = ShmCharger->gun_info[gun_index].bleConfigData.isLogin;
					ShmSysConfigAndInfo->SysConfig.Bluetooth.isRequestStart = ShmCharger->gun_info[gun_index].bleConfigData.isRequestStart;
					ShmSysConfigAndInfo->SysConfig.Bluetooth.isRequestStop = ShmCharger->gun_info[gun_index].bleConfigData.isRequestStop;

					failCount[gun_index] = 0;
				}
				else
				{
					DEBUG_WARN("MCU-%d get ble config fail...%d\r\n", gun_index, failCount[gun_index]);
					if(failCount[gun_index]<1000)
					{
						failCount[gun_index]++;
					}
				}

				//===============================
				// Query primary MCU ble login id
				//===============================
				if(Query_Ble_Central_ID(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].bleLoginCentralId))
				{
					DEBUG_INFO("MCU-%d get ble central id : %s\r\n", gun_index, ShmCharger->gun_info[gun_index].bleLoginCentralId.id);
					memcpy(ShmSysConfigAndInfo->SysConfig.Bluetooth.LoginCentralID, ShmCharger->gun_info[gun_index].bleLoginCentralId.id, sizeof ShmSysConfigAndInfo->SysConfig.Bluetooth.LoginCentralID);

					failCount[gun_index] = 0;
				}
				else
				{
					DEBUG_WARN("MCU-%d get ble login central id fail...%d\r\n", gun_index, failCount[gun_index]);
					if(failCount[gun_index]<1000)
					{
						failCount[gun_index]++;
					}
				}

				//===============================
				// Config primary MCU reset request
				//===============================
				/*
				if(Config_AC_MCU_RESET_REQUEST(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].mcuResetRequest))
				{
					DEBUG_INFO("MCU-%d set MCU reset Request : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].mcuResetRequest.isMcuResetRequest);

					failCount[gun_index] = 0;
				}
				else
				{
					DEBUG_WARN("MCU-%d get MCU reset fail...%d\r\n", gun_index, failCount[gun_index]);
					if(failCount[gun_index]<1000)
					{
						failCount[gun_index]++;
					}
				}
				*/
			}
			else
			{
				/*
				 * Normal priority communication
				 */
				switch(stepIndex)
				{
					case 1:
						//===============================
						// Query present input voltage
						//===============================
						if(Query_Present_InputVoltage(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].inputVoltage) == PASS)
						{
							DEBUG_INFO("MCU-%d get input voltage : %f\r\n", gun_index, (float)ShmCharger->gun_info[gun_index].inputVoltage.L1N_L12);
							ShmSysConfigAndInfo->SysInfo.InputVoltageR = ShmCharger->gun_info[gun_index].inputVoltage.L1N_L12;
							ShmSysConfigAndInfo->SysInfo.InputVoltageS = ShmCharger->gun_info[gun_index].inputVoltage.L2N_L23;
							ShmSysConfigAndInfo->SysInfo.InputVoltageT = ShmCharger->gun_info[gun_index].inputVoltage.L3N_L31;

							failCount[gun_index] = 0;
						}
						else
						{
							DEBUG_WARN("MCU-%d get input voltage fail...%d\r\n", gun_index, failCount[gun_index]);
							if(failCount[gun_index]<1000)
							{
								failCount[gun_index]++;
							}
						}
						break;
					case 3:
						//===============================
						// Query present output current
						//===============================
						if(Query_Present_OutputCurrent(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].outputCurrent) == PASS)
						{
							DEBUG_INFO("MCU-%d get output current : %f\r\n", gun_index, (float)ShmCharger->gun_info[gun_index].outputCurrent.L1N_L12[0]);

							failCount[gun_index] = 0;
						}
						else
						{
							DEBUG_WARN("MCU-%d get output current fail...%d\r\n", gun_index, failCount[gun_index]);
							if(failCount[gun_index]<1000)
								failCount[gun_index]++;
						}
						break;
					case 5:
						//===============================
						// Query gun plug-in times
						//===============================
						if(Query_AC_GUN_PLUGIN_TIMES(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].gunPluginTimes) == PASS)
						{
							DEBUG_INFO("MCU-%d get gun plugin times : %.2f\r\n", gun_index, (float)ShmCharger->gun_info[gun_index].gunPluginTimes.GunPluginTimes);

							ShmSysConfigAndInfo->SysConfig.AcPlugInTimes = (float)ShmCharger->gun_info[gun_index].gunPluginTimes.GunPluginTimes;

							failCount[gun_index] = 0;
						}
						else
						{

							DEBUG_WARN("MCU-%d get gun plugin times fail...%d\r\n", gun_index, failCount[gun_index]);
							if(failCount[gun_index]<1000)
								failCount[gun_index]++;
						}
						break;
					case 7:
						//===============================
						// Query temperature
						//===============================
						if(Query_Temperature(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].temperature) == PASS)
						{
							DEBUG_INFO("MCU-%d get temperature : %d\r\n", gun_index, ShmCharger->gun_info[gun_index].temperature.point[0]);
							ShmSysConfigAndInfo->SysInfo.SystemAmbientTemp = ShmCharger->gun_info[gun_index].temperature.point[0];

							failCount[gun_index] = 0;
						}
						else
						{
							DEBUG_WARN("MCU-%d get temperature fail...%d\r\n", gun_index, failCount[gun_index]);
							if(failCount[gun_index]<1000)
							{
								failCount[gun_index]++;
							}
						}
						break;
					case 9:

						break;
					case 11:

						break;
					case 13:

						break;
					case 15:
						//===============================
						// Query RTC
						//===============================
						if(Query_RTC(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].rtc))
						{
							struct timeb csuTime, mcuTime;
							struct tm *tmCSU;
							struct tm tmMcu;
							ftime(&csuTime);
							tmCSU = localtime(&csuTime.time);
							tmMcu.tm_year = ShmCharger->gun_info[gun_index].rtc.year-1900;
							tmMcu.tm_mon = ShmCharger->gun_info[gun_index].rtc.month-1;
							tmMcu.tm_mday = ShmCharger->gun_info[gun_index].rtc.day;
							tmMcu.tm_hour = ShmCharger->gun_info[gun_index].rtc.hour;
							tmMcu.tm_min = ShmCharger->gun_info[gun_index].rtc.min;
							tmMcu.tm_sec = ShmCharger->gun_info[gun_index].rtc.sec;
							mcuTime.time = mktime(&tmMcu);

							if(ShmCharger->gun_info[gun_index].bleConfigData.isLogin && !ShmOCPP16Data->OcppConnStatus)
							{
								if(abs(DiffTimeb(csuTime, mcuTime)) > 10000)
								{
									char cmdBuf[128];
									sprintf(cmdBuf, "date -u -s \"%04d-%02d-%02d %02d:%02d:%02d\"", ShmCharger->gun_info[gun_index].rtc.year,
																									ShmCharger->gun_info[gun_index].rtc.month,
																									ShmCharger->gun_info[gun_index].rtc.day,
																									ShmCharger->gun_info[gun_index].rtc.hour,
																									ShmCharger->gun_info[gun_index].rtc.min,
																									ShmCharger->gun_info[gun_index].rtc.sec);
									system(cmdBuf);
									system("hwclock -w -u");
									system("hwclock -s");

									DEBUG_INFO("Sync from MCU-%d rtc OK...%04d-%02d-%02d %02d:%02d:%02d\r\n", gun_index,
																											  ShmCharger->gun_info[gun_index].rtc.year,
																											  ShmCharger->gun_info[gun_index].rtc.month,
																											  ShmCharger->gun_info[gun_index].rtc.day,
																											  ShmCharger->gun_info[gun_index].rtc.hour,
																											  ShmCharger->gun_info[gun_index].rtc.min,
																											  ShmCharger->gun_info[gun_index].rtc.sec);
								}
							}
							else
							{
								if(abs(DiffTimeb(csuTime, mcuTime)) > 10000)
								{
									ShmCharger->gun_info[gun_index].rtc.year = tmCSU->tm_year+1900;
									ShmCharger->gun_info[gun_index].rtc.month = tmCSU->tm_mon+1;
									ShmCharger->gun_info[gun_index].rtc.day = tmCSU->tm_mday;
									ShmCharger->gun_info[gun_index].rtc.hour = tmCSU->tm_hour;
									ShmCharger->gun_info[gun_index].rtc.min = tmCSU->tm_hour;
									ShmCharger->gun_info[gun_index].rtc.sec = tmCSU->tm_sec;
									Config_RTC(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].rtc);

									DEBUG_INFO("MCU-%d set rtc OK...%04d-%02d-%02d %02d:%02d:%02d\r\n", gun_index,
																										ShmCharger->gun_info[gun_index].rtc.year,
																										ShmCharger->gun_info[gun_index].rtc.month,
																										ShmCharger->gun_info[gun_index].rtc.day,
																										ShmCharger->gun_info[gun_index].rtc.hour,
																										ShmCharger->gun_info[gun_index].rtc.min,
																										ShmCharger->gun_info[gun_index].rtc.sec);
								}
							}

							failCount[gun_index] = 0;
						}
						else
						{
							DEBUG_WARN("MCU-%d get rtc fail...%d\r\n", gun_index, failCount[gun_index]);
							if(failCount[gun_index]<1000)
								failCount[gun_index]++;
						}
						break;
					case 17:
						//===============================
						// Query primary MCU power consumption
						//===============================
						if(Query_Power_Consumption(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].powerConsumption))
						{
							DEBUG_INFO("MCU-%d get power consumption : %f\r\n",gun_index, ((float)ShmCharger->gun_info[gun_index].powerConsumption.power_consumption/100.0));

							failCount[gun_index] = 0;
						}
						else
						{
							DEBUG_WARN("MCU-%d get power consumption fail...%d\r\n", gun_index, failCount[gun_index]);
							if(failCount[gun_index]<1000)
								failCount[gun_index]++;
						}
						break;
					case 19:
						//===============================
						// Upgrade MCU
						//===============================
						if(ShmCharger->gun_info[gun_index].mcuFlag.isMcuUpgradeReq)
						{
							unsigned char cmd[512];
							if(Upgrade_UART(Uart1Fd, AC_WALLMOUNT_CONTROLLER, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), ShmCharger->fwUpgradeInfo.location, ShmCharger->fwUpgradeInfo.modelName))
							{
								DEBUG_INFO("MCU-%d upgrade firmware OK...%s\r\n", gun_index, ShmCharger->gun_info[gun_index].ver.Version_FW);
								sleep(20);
								ShmCharger->gun_info[gun_index].mcuFlag.isMcuUpgradeReq = OFF;
								failCount[gun_index] = 0;
							}
							else
							{
								DEBUG_WARN("MCU-%d upgrade firmware fail...%d\r\n", gun_index, failCount[gun_index]);
								if(failCount[gun_index]<1000)
									failCount[gun_index]++;
							}

							sprintf((char*)cmd, "yes|rm %s", ShmCharger->fwUpgradeInfo.location);
							system((char*)cmd);
						}
						break;
					case 21:
						//===============================
						// Config primary set CP PWN duty
						//===============================
			//			ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = 32;
			//			if(Config_AC_MaxCurrent_And_CpPwmDuty(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty))
			//			{
			//				DEBUG_INFO("MCU-%d cp pwn duty : %d\r\n",gun_index, &ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current);
			//			}
			//			else
			//			{
			//				DEBUG_WARN("MCU-%d set cp pwn duty fail...%d\r\n", gun_index, failCount[gun_index]);
			//				if(failCount[gun_index]<1000)
			//				{
			//					failCount[gun_index]++;
			//				}
			//			}
			//
			//			if(failCount[gun_index]>=1000)
			//			{
			//				DEBUG_ERROR("Primary MCU-%d communication fault", gun_index);
			//			}
						break;
					default:
						stepIndex = 0;
						break;
				}
			}
			stepIndex++;


			//===============================
			// Communication fail check
			//===============================
			if(failCount[gun_index] >= FAIL_SPEC_COMM)
			{
				if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.comm_timeout == OFF)
				{
					DEBUG_ERROR("Primary MCU-%d communication fault", gun_index);
					ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.comm_timeout = ON;
				}
			}
			else
			{
				if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.comm_timeout == ON)
				{
					DEBUG_ERROR("Primary MCU-%d communication recover", gun_index);
					ShmCharger->gun_info[gun_index].primaryMcuAlarm.bits.comm_timeout = OFF;
				}
			}
		}
		usleep(50000);
	}

	return FAIL;
}