/*
 * Module_AlarmDetect.c
 *
 *  Created on: 2019年8月17日
 *      Author: foluswen
 */
#include    <sys/types.h>
#include    <sys/stat.h>
#include 	<sys/time.h>
#include 	<sys/timeb.h>
#include 	<sys/ipc.h>
#include 	<sys/shm.h>
#include 	<sys/mman.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	"define.h"
#include	"main.h"

#define FILTER_SPEC			50

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

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

#define SPEC_OV				275
#define SPEC_UV				160
#define SPEC_OC				(32*1.1)
#define SPEC_OT				85

#define HYSTERETIC_OUV		10
#define HYSTERETIC_OT		10
#define HYSTERETIC_OC		10

struct{
	unsigned short int	OV[3];
	unsigned short int	UV[3];
	unsigned short int	OC;
	unsigned short int	OT_AMB;
	unsigned short int	GMI;
	unsigned short int	Short;
	unsigned short int	Ac_Leak;
	unsigned short int	Dc_Leak;
	unsigned short int	HandShakingTimeout;
	unsigned short int	EmrgencyBTN;
	unsigned short int	Relay_Welding;
	unsigned short int	Relay_DrivingFault;
	unsigned short int	CP_LevelFail;
	unsigned short int	MCU_SelfTestFail;
}Alarm_Counter[2];

void trim(char *s);
void substr(char *dest, const char* src, unsigned int start, unsigned int cnt);

struct SysConfigAndInfo			*ShmSysConfigAndInfo;
struct StatusCodeData 			*ShmStatusCodeData;
struct Charger					*ShmCharger;

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_%s_%s_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,
			ShmSysConfigAndInfo->SysConfig.ModelName,
			ShmSysConfigAndInfo->SysConfig.SerialNumber);
#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;
}

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

	//creat 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;
   	 }
    else
    {}

   	//creat 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;
   	}
    else
    {}

   	//creat ShmStatusCodeData
   	if ((MeterSMId = shmget(ShmChargerKey, sizeof(struct Charger), IPC_CREAT | 0777)) < 0)
	{

		DEBUG_ERROR("shmget ShmCharger NG\r\n");

		result = FAIL;
	}
	else if ((ShmCharger = shmat(MeterSMId, NULL, 0)) == (void *) -1)
	{

		DEBUG_ERROR("shmat ShmCharger NG\r\n");

		result = FAIL;
	}
	else
	{}

    return result;
}

//==========================================
// 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';
    }
}

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

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

	if(InitShareMemory() == FAIL)
	{
		DEBUG_ERROR("InitShareMemory NG\n");

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

	for(;;)
	{
		for(int gun_index = 0;gun_index<AC_QUANTITY;gun_index++)
		{
			//=====================================
			// Over voltage detection
			//=====================================
			if((ShmSysConfigAndInfo->SysInfo.InputVoltageR > SPEC_OV) &&
				(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_VOLTAGE))
			{
				if(Alarm_Counter[gun_index].OV[0] > FILTER_SPEC)
				{
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputOVP == OFF))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputOVP = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_OVER_VOLTAGE;
						DEBUG_INFO("ALARM_OVER_VOLTAGE : alarm \r\n");
					}
				}
				else
				{
					Alarm_Counter[gun_index].OV[0]++;
				}
			}
			else if((ShmSysConfigAndInfo->SysInfo.InputVoltageR < (SPEC_OV-HYSTERETIC_OUV)) &&
					(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_VOLTAGE)))
			{
				Alarm_Counter[gun_index].OV[0] = 0;
				if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputOVP == ON))
				{
					ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputOVP = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_OVER_VOLTAGE;
					DEBUG_INFO("ALARM_OVER_VOLTAGE : recover \r\n");
				}
			}

			if(ShmSysConfigAndInfo->SysConfig.AcPhaseCount == 3)
			{
				if((ShmSysConfigAndInfo->SysInfo.InputVoltageS > SPEC_OV) &&
				   (ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_VOLTAGE))
				{
					if(Alarm_Counter[gun_index].OV[1] > FILTER_SPEC)
					{
						if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputOVP == OFF))
						{
							ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputOVP = ON;
							ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_OVER_VOLTAGE;
							DEBUG_INFO("ALARM_OVER_VOLTAGE : alarm \r\n");
						}
					}
					else
					{
						Alarm_Counter[gun_index].OV[1]++;
					}
				}
				else if((ShmSysConfigAndInfo->SysInfo.InputVoltageS < (SPEC_OV-HYSTERETIC_OUV)) &&
						(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_VOLTAGE)))
				{
					Alarm_Counter[gun_index].OV[1] = 0;
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputOVP == ON))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputOVP = OFF;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_OVER_VOLTAGE;
						DEBUG_INFO("ALARM_OVER_VOLTAGE : recover \r\n");
					}
				}

				if((ShmSysConfigAndInfo->SysInfo.InputVoltageT > SPEC_OV) &&
				   (ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_VOLTAGE))
				{
					if(Alarm_Counter[gun_index].OV[2] > FILTER_SPEC)
					{
						if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputOVP == OFF))
						{
							ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputOVP = ON;
							ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_OVER_VOLTAGE;
							DEBUG_INFO("ALARM_OVER_VOLTAGE : alarm \r\n");
						}
					}
					else
					{
						Alarm_Counter[gun_index].OV[2]++;
					}
				}
				else if((ShmSysConfigAndInfo->SysInfo.InputVoltageT < (SPEC_OV-HYSTERETIC_OUV)) &&
						(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_VOLTAGE)))
				{
					Alarm_Counter[gun_index].OV[2] = 0;
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputOVP == ON))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputOVP = OFF;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_OVER_VOLTAGE;
						DEBUG_INFO("ALARM_OVER_VOLTAGE : recover \r\n");
					}
				}
			}

			//=====================================
			// Under voltage detection
			//=====================================
			if((ShmSysConfigAndInfo->SysInfo.InputVoltageR  < SPEC_UV) &&
				(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_UNDER_VOLTAGE))
			{
				if(Alarm_Counter[gun_index].UV[0] > FILTER_SPEC)
				{
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputUVP == OFF))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputUVP = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_UNDER_VOLTAGE;
						DEBUG_INFO("ALARM_UNDER_VOLTAGE : alarm \r\n");
					}
				}
				else
				{
					Alarm_Counter[gun_index].UV[0]++;
				}
			}
			else if((ShmSysConfigAndInfo->SysInfo.InputVoltageR  > (SPEC_UV+HYSTERETIC_OUV)) &&
					(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_UNDER_VOLTAGE)))
			{
				Alarm_Counter[gun_index].UV[0] = 0;
				if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputUVP == ON))
				{
					ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL1InputUVP = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_UNDER_VOLTAGE;
					DEBUG_INFO("ALARM_UNDER_VOLTAGE : recover \r\n");
				}
			}

			if(ShmSysConfigAndInfo->SysConfig.AcPhaseCount == 3)
			{
				if((ShmSysConfigAndInfo->SysInfo.InputVoltageS < SPEC_UV) &&
				   (ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_UNDER_VOLTAGE))
				{
					if(Alarm_Counter[gun_index].UV[1] > FILTER_SPEC)
					{
						if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputUVP == OFF))
						{
							ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputUVP = ON;
							ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_UNDER_VOLTAGE;
							DEBUG_INFO("ALARM_UNDER_VOLTAGE : alarm \r\n");
						}
					}
					else
					{
						Alarm_Counter[gun_index].UV[1]++;
					}
				}
				else if((ShmSysConfigAndInfo->SysInfo.InputVoltageS > (SPEC_UV+HYSTERETIC_OUV)) &&
						(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_UNDER_VOLTAGE)))
				{
					Alarm_Counter[gun_index].UV[1] = 0;
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputUVP == ON))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL2InputUVP = OFF;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_UNDER_VOLTAGE;
						DEBUG_INFO("ALARM_UNDER_VOLTAGE : recover \r\n");
					}
				}

				if((ShmSysConfigAndInfo->SysInfo.InputVoltageT < SPEC_UV) &&
				   (ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_UNDER_VOLTAGE))
				{
					if(Alarm_Counter[gun_index].UV[2] > FILTER_SPEC)
					{
						if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputUVP == OFF))
						{
							ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputUVP = ON;
							ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_UNDER_VOLTAGE;
							DEBUG_INFO("ALARM_UNDER_VOLTAGE : alarm \r\n");
						}
					}
					else
					{
						Alarm_Counter[gun_index].UV[2]++;
					}
				}
				else if((ShmSysConfigAndInfo->SysInfo.InputVoltageT > (SPEC_OV+HYSTERETIC_OUV)) &&
						(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_UNDER_VOLTAGE)))
				{
					Alarm_Counter[gun_index].UV[2] = 0;
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputUVP == ON))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemL3InputUVP = OFF;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_UNDER_VOLTAGE;
						DEBUG_INFO("ALARM_UNDER_VOLTAGE : recover \r\n");
					}
				}
			}

			//=====================================
			// Over current detection
			//=====================================
			if((ShmCharger->gun_info[gun_index].outputCurrent.L1N_L12[0] > SPEC_OC) &&
			   (ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_CURRENT))
			{
				if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAcOutputOCP == OFF))
				{
					ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAcOutputOCP = ON;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_OVER_CURRENT;
					DEBUG_INFO("ALARM_OVER_CURRENT : alarm \r\n");
				}
			}
			else if ((ShmCharger->gun_info[gun_index].outputCurrent.L1N_L12[0] < (SPEC_OC-HYSTERETIC_OC)) &&
					 (!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_CURRENT)))
			{
				if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAcOutputOCP == ON))
				{
					ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAcOutputOCP = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_OVER_CURRENT;
					DEBUG_INFO("ALARM_OVER_CURRENT : recover \r\n");
				}
			}

			if(ShmSysConfigAndInfo->SysConfig.AcPhaseCount == 3)
			{
				if((ShmCharger->gun_info[gun_index].outputCurrent.L2N_L23[0] > SPEC_OC) &&
				   (ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_CURRENT))
				{
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAcOutputOCP == OFF))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAcOutputOCP = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_OVER_CURRENT;
						DEBUG_INFO("ALARM_OVER_CURRENT : alarm \r\n");
					}
				}
				else if ((ShmCharger->gun_info[gun_index].outputCurrent.L2N_L23[0] < (SPEC_OC-HYSTERETIC_OC)) &&
						 (!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_CURRENT)))
				{
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAcOutputOCP == ON))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAcOutputOCP = OFF;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_OVER_CURRENT;
						DEBUG_INFO("ALARM_OVER_CURRENT : recover \r\n");
					}
				}

				if((ShmCharger->gun_info[gun_index].outputCurrent.L3N_L31[0] > SPEC_OC) &&
				   (ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_CURRENT))
				{
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAcOutputOCP == OFF))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAcOutputOCP = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_OVER_CURRENT;
						DEBUG_INFO("ALARM_OVER_CURRENT : alarm \r\n");
					}
				}
				else if ((ShmCharger->gun_info[gun_index].outputCurrent.L3N_L31[0] < (SPEC_OC-HYSTERETIC_OC)) &&
						 (!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_CURRENT)))
				{
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAcOutputOCP == ON))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAcOutputOCP = OFF;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_OVER_CURRENT;
						DEBUG_INFO("ALARM_OVER_CURRENT : recover \r\n");
					}
				}
			}

			//=====================================
			// Over temperature detection
			//=====================================
			if(//(ShmSysConfigAndInfo->SysInfo.SystemAmbientTemp > SPEC_OT) &&
			   (ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_TEMPERATURE))
			{
				if(Alarm_Counter[gun_index].OT_AMB > FILTER_SPEC)
				{
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAmbientOTP == OFF))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAmbientOTP = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_OVER_TEMPERATURE;
						DEBUG_INFO("ALARM_OVER_TEMPERATURE : alarm \r\n");
					}
				}
				else
				{
					Alarm_Counter[gun_index].OT_AMB++;
				}
			}
			else if(//(ShmSysConfigAndInfo->SysInfo.SystemAmbientTemp < (SPEC_OT-10)) &&
					(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_OVER_TEMPERATURE)))
			{
				Alarm_Counter[gun_index].OT_AMB = 0;
				if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAmbientOTP == ON))
				{
					ShmStatusCodeData->AlarmCode.AlarmEvents.bits.SystemAmbientOTP = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_OVER_TEMPERATURE;
					DEBUG_INFO("ALARM_OVER_TEMPERATURE : recover \r\n");
				}
			}

			//=====================================
			// Ground fault detection
			//=====================================
			if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_GROUND_FAIL)
			{
				if(Alarm_Counter[gun_index].GMI > FILTER_SPEC)
				{
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.GbGfdTrip == OFF))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.GbGfdTrip = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_GROUND_FAIL;
						DEBUG_INFO("ALARM_GROUND_FAIL : alarm \r\n");
					}
				}
				else
				{
					Alarm_Counter[gun_index].GMI++;
				}
			}
			else if (!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_GROUND_FAIL))
			{
				Alarm_Counter[gun_index].GMI = 0;
				if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.GbGfdTrip == ON ))
				{
					ShmStatusCodeData->AlarmCode.AlarmEvents.bits.GbGfdTrip = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_GROUND_FAIL;
					DEBUG_INFO("ALARM_GROUND_FAIL : recover \r\n");
				}
			}

			//=====================================
			// CP level fail detection
			//====================================
			if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_CP_ERROR)
			{
				if(Alarm_Counter[gun_index].CP_LevelFail > FILTER_SPEC)
				{
					if(ShmStatusCodeData->InfoCode.InfoEvents.bits.PilotFault == OFF)
					{
						ShmStatusCodeData->InfoCode.InfoEvents.bits.PilotFault = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_CP_ERROR;
						DEBUG_INFO("ALARM_CP_ERROR : alarm \r\n");
					}
				}
				else
				{
					Alarm_Counter[gun_index].CP_LevelFail++;
				}
			}
			else if(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_CP_ERROR))
			{
				Alarm_Counter[gun_index].CP_LevelFail= 0;
				if(ShmStatusCodeData->InfoCode.InfoEvents.bits.PilotFault == ON)
				{
					ShmStatusCodeData->InfoCode.InfoEvents.bits.PilotFault = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_CP_ERROR;
					DEBUG_INFO("ALARM_CP_ERROR : recover \r\n");
				}
			}

			//=====================================
			// Current AC leak detection
			//=====================================
			if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_CURRENT_LEAK_AC)
			{
				if(Alarm_Counter[gun_index].Ac_Leak > FILTER_SPEC)
				{
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RcdTrip == OFF))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RcdTrip = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_CURRENT_LEAK_AC;
						DEBUG_INFO("ALARM_CURRENT_LEAK_AC : alarm \r\n");
					}
				}
				else
				{
					Alarm_Counter[gun_index].Ac_Leak++;
				}
			}
			else if(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_CURRENT_LEAK_AC))
			{
				Alarm_Counter[gun_index].Ac_Leak = 0;
				if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RcdTrip == ON))
				{
					ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RcdTrip = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_CURRENT_LEAK_AC;
					DEBUG_INFO("ALARM_CURRENT_LEAK_AC : recover \r\n");
				}
			}

			//=====================================
			// Current DC leak detection
			//=====================================
			/*
			if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_CURRENT_LEAK_DC)
			{
				if(Alarm_Counter[gun_index].Dc_Leak > FILTER_SPEC)
				{
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RcdTrip == OFF))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RcdTrip = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_CURRENT_LEAK_DC;
						DEBUG_INFO("ALARM_CURRENT_LEAK_DC : alarm \r\n");
					}
				}
				else
				{
					Alarm_Counter[gun_index].Dc_Leak++;
				}
			}
			else if(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_CURRENT_LEAK_DC))
			{
				Alarm_Counter[gun_index].Dc_Leak = 0;
				if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RcdTrip == ON))
				{
					ShmStatusCodeData->AlarmCode.AlarmEvents.bits.RcdTrip = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_CURRENT_LEAK_DC;
					DEBUG_INFO("ALARM_CURRENT_LEAK_DC : recover \r\n");
				}
			}
			*/

			//=====================================
			// MCU self test fail detection
			//=====================================
			if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_MCU_TESTFAIL)
			{
				if(Alarm_Counter[gun_index].MCU_SelfTestFail > FILTER_SPEC)
				{
					if(ShmCharger->gun_info[gun_index].otherAlarmCode.isMcuSelfTest == OFF)
					{
						ShmCharger->gun_info[gun_index].otherAlarmCode.isMcuSelfTest = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_MCU_TESTFAIL;
						DEBUG_INFO("ALARM_MCU_TESTFAIL : alarm \r\n");
					}
				}
				else
				{
					Alarm_Counter[gun_index].MCU_SelfTestFail++;
				}
			}
			else if(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_MCU_TESTFAIL))
			{
				Alarm_Counter[gun_index].MCU_SelfTestFail = 0;
				if(ShmCharger->gun_info[gun_index].otherAlarmCode.isMcuSelfTest == ON)
				{
					ShmCharger->gun_info[gun_index].otherAlarmCode.isMcuSelfTest = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_MCU_TESTFAIL;
					DEBUG_INFO("ALARM_MCU_TESTFAIL : recover \r\n");
				}
			}

			//=====================================
			// Hand shaking timeout detection
			//=====================================
			if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_HANDSHAKE_TIMEOUT)
			{
				if(ShmCharger->gun_info[gun_index].otherAlarmCode.isHandshakingTimeOut == OFF)
				{
					ShmCharger->gun_info[gun_index].otherAlarmCode.isHandshakingTimeOut  = ON;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_HANDSHAKE_TIMEOUT;
					DEBUG_INFO("ALARM_HANDSHAKE_TIMEOUT : alarm \r\n");
				}

			}
			else if(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_HANDSHAKE_TIMEOUT))
			{
				if(ShmCharger->gun_info[gun_index].otherAlarmCode.isHandshakingTimeOut  == ON)
				{
					ShmCharger->gun_info[gun_index].otherAlarmCode.isHandshakingTimeOut  = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_HANDSHAKE_TIMEOUT;
					DEBUG_INFO("ALARM_HANDSHAKE_TIMEOUT : recover \r\n");
				}
			}

			//=====================================
			// Emergency stop detection
			//=====================================
			if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_EMERGENCY_STOP)
			{
				if(Alarm_Counter[gun_index].EmrgencyBTN > FILTER_SPEC)
				{
					if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip == OFF))
					{
						ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_EMERGENCY_STOP;
						DEBUG_INFO("ALARM_EMERGENCY_STOP : alarm \r\n");
					}
				}
				else
				{
					Alarm_Counter[gun_index].EmrgencyBTN++;
				}
			}
			else if(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_EMERGENCY_STOP))
			{
				Alarm_Counter[gun_index].EmrgencyBTN = 0;
				if((ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip == ON))
				{
					ShmStatusCodeData->AlarmCode.AlarmEvents.bits.EmergencyStopTrip = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_EMERGENCY_STOP;
					DEBUG_INFO("ALARM_EMERGENCY_STOP : recover \r\n");
				}
			}

			//=====================================
			// Relay welding detection
			//=====================================
			if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_RELAY_STATUS)
			{
				if(Alarm_Counter[gun_index].Relay_Welding > FILTER_SPEC)
				{
					if((ShmStatusCodeData->FaultCode.FaultEvents.bits.AcOutputRelayWelding == OFF))
					{
						ShmStatusCodeData->FaultCode.FaultEvents.bits.AcOutputRelayWelding = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_RELAY_STATUS;
						DEBUG_INFO("ALARM_RELAY_STATUS : alarm \r\n");
					}
				}
				else
				{
					Alarm_Counter[gun_index].Relay_Welding++;
				}
			}
			else if(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_RELAY_STATUS))
			{
				Alarm_Counter[gun_index].Relay_Welding = 0;
				if((ShmStatusCodeData->FaultCode.FaultEvents.bits.AcOutputRelayWelding == ON))
				{
					ShmStatusCodeData->FaultCode.FaultEvents.bits.AcOutputRelayWelding = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_RELAY_STATUS;
					DEBUG_INFO("ALARM_RELAY_STATUS : recover \r\n");
				}
			}

			//=====================================
			// Relay driving fault detection
			//=====================================
			if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_RELAY_DRIVE_FAULT)
			{
				if(Alarm_Counter[gun_index].Relay_DrivingFault > FILTER_SPEC)
				{
					if((ShmStatusCodeData->FaultCode.FaultEvents.bits.AcOutputRelayDrivingFault == OFF))
					{
						ShmStatusCodeData->FaultCode.FaultEvents.bits.AcOutputRelayDrivingFault = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_RELAY_DRIVE_FAULT;
						DEBUG_INFO("ALARM_RELAY_DRIVE_FAULT : alarm \r\n");
					}
				}
				else
				{
					Alarm_Counter[gun_index].Relay_DrivingFault++;
				}
			}
			else if(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_RELAY_DRIVE_FAULT))
			{
				Alarm_Counter[gun_index].Relay_DrivingFault = 0;
				if((ShmStatusCodeData->FaultCode.FaultEvents.bits.AcOutputRelayDrivingFault == ON))
				{
					ShmStatusCodeData->FaultCode.FaultEvents.bits.AcOutputRelayDrivingFault = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_RELAY_DRIVE_FAULT;
					DEBUG_INFO("ALARM_RELAY_DRIVE_FAULT : recover \r\n");
				}
			}

			//=====================================
			// Current short detection
			//=====================================
			if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_CIRCUIT_SHORT)
			{
				if(Alarm_Counter[gun_index].Short > FILTER_SPEC)
				{
					if(ShmCharger->gun_info[gun_index].otherAlarmCode.isCurrentShort == OFF)
					{
						ShmCharger->gun_info[gun_index].otherAlarmCode.isCurrentShort = ON;
						ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_CIRCUIT_SHORT;
						DEBUG_INFO("ALARM_CIRCUIT_SHORT : alarm \r\n");
					}
				}
				else
				{
					Alarm_Counter[gun_index].Short++;
				}
			}
			else if(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_CIRCUIT_SHORT))
			{
				Alarm_Counter[gun_index].Short = 0;

				if(ShmCharger->gun_info[gun_index].otherAlarmCode.isCurrentShort == ON)
				{
					ShmCharger->gun_info[gun_index].otherAlarmCode.isCurrentShort = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_CIRCUIT_SHORT;
					DEBUG_INFO("ALARM_CIRCUIT_SHORT : recover \r\n");
				}
			}

			//=====================================
			// Rotatory switch detection
			//=====================================
			if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_ROTATORY_SWITCH_FAULT)
			{
				if(ShmCharger->gun_info[gun_index].otherAlarmCode.isShutter == OFF)
				{
					ShmCharger->gun_info[gun_index].otherAlarmCode.isShutter = ON;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_ROTATORY_SWITCH_FAULT;
					DEBUG_INFO("ALARM_ROTATORY_SWITCH_FAULT : alarm \r\n");
				}
			}
			else if(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_ROTATORY_SWITCH_FAULT))
			{
				if(ShmCharger->gun_info[gun_index].otherAlarmCode.isShutter == ON)
				{
					ShmCharger->gun_info[gun_index].otherAlarmCode.isShutter = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_ROTATORY_SWITCH_FAULT;
					DEBUG_INFO("ALARM_ROTATORY_SWITCH_FAULT : recover \r\n");
				}
			}

			//=====================================
			// Leakage module detection
			//=====================================
			if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_LEAK_MODULE_FAIL)
			{
				if(ShmCharger->gun_info[gun_index].otherAlarmCode.isLeakageModule == OFF)
				{
					ShmCharger->gun_info[gun_index].otherAlarmCode.isLeakageModule = ON;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_LEAK_MODULE_FAIL;

					DEBUG_INFO("ALARM_LEAK_MODULE_FAIL : alarm \r\n");
				}
			}
			else if(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_LEAK_MODULE_FAIL))
			{
				if(ShmCharger->gun_info[gun_index].otherAlarmCode.isLeakageModule == ON)
				{
					ShmCharger->gun_info[gun_index].otherAlarmCode.isLeakageModule = OFF;
					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_LEAK_MODULE_FAIL;

					DEBUG_INFO("ALARM_LEAK_MODULE_FAIL : recover \r\n");
				}
			}
//
//			//=====================================
//			// Shutter detection
//			//=====================================
//			if(ShmCsuInputInfo->AcChargerInfoData[gun_index].InputAlarmCode & ALARM_SHUTTER_FAULT)
//			{
//				if(ShmCsuInputInfo->AcChargerInfoData[gun_index].AlarmCode.bits.SHUTTER_FAULT == OFF)
//				{
//					ShmCsuInputInfo->AcChargerInfoData[gun_index].AlarmCode.bits.SHUTTER_FAULT = ON;
//					ShmCsuInputInfo->AcChargerInfoData[gun_index].SystemAlarmCode |= ALARM_SHUTTER_FAULT;
//
//					DEBUG_INFO("ALARM_SHUTTER_FAULT : alarm \r\n");
//				}
//			}
//			else if(!(ShmCsuInputInfo->AcChargerInfoData[gun_index].InputAlarmCode & ALARM_SHUTTER_FAULT))
//			{
//				if(ShmCsuInputInfo->AcChargerInfoData[gun_index].AlarmCode.bits.SHUTTER_FAULT == ON)
//				{
//					ShmCsuInputInfo->AcChargerInfoData[gun_index].AlarmCode.bits.SHUTTER_FAULT = OFF;
//					ShmCsuInputInfo->AcChargerInfoData[gun_index].SystemAlarmCode &= ~ALARM_SHUTTER_FAULT;
//
//					DEBUG_INFO("ALARM_SHUTTER_FAULT : recover \r\n");
//				}
//			}
//
//			//=====================================
//			// Locker detection
//			//=====================================
//			if(ShmCsuInputInfo->AcChargerInfoData[gun_index].InputAlarmCode & ALARM_LOCKER_FAULT)
//			{
//				if(ShmCsuInputInfo->AcChargerInfoData[gun_index].AlarmCode.bits.LOCKER_FAULT == OFF)
//				{
//					ShmCsuInputInfo->AcChargerInfoData[gun_index].AlarmCode.bits.LOCKER_FAULT = ON;
//					ShmCsuInputInfo->AcChargerInfoData[gun_index].SystemAlarmCode |= ALARM_LOCKER_FAULT;
//
//					DEBUG_INFO("ALARM_LOCKER_FAULT : alarm \r\n");
//				}
//			}
//			else if(!(ShmCsuInputInfo->AcChargerInfoData[gun_index].InputAlarmCode & ALARM_LOCKER_FAULT))
//			{
//				if(ShmCsuInputInfo->AcChargerInfoData[gun_index].AlarmCode.bits.LOCKER_FAULT == ON)
//				{
//					ShmCsuInputInfo->AcChargerInfoData[gun_index].AlarmCode.bits.LOCKER_FAULT = OFF;
//					ShmCsuInputInfo->AcChargerInfoData[gun_index].SystemAlarmCode &= ~ALARM_LOCKER_FAULT;
//
//					DEBUG_INFO("ALARM_LOCKER_FAULT : recover \r\n");
//				}
//			}
//
//			//=====================================
//			// Power drop detection
//			//=====================================
//			if(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_POWER_DROP)
//			{
//				if(ShmCharger->gun_info[gun_index].otherAlarmCode.isPowerDrop == OFF)
//				{
//					ShmCharger->gun_info[gun_index].otherAlarmCode.isPowerDrop = ON;
//					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode |= ALARM_POWER_DROP;
//
//					DEBUG_INFO("ALARM_POWER_DROP : alarm \r\n");
//				}
//			}
//			else if(!(ShmCharger->gun_info[gun_index].primaryMcuAlarm.InputAlarmCode & ALARM_POWER_DROP))
//			{
//				if(ShmCharger->gun_info[gun_index].otherAlarmCode.isPowerDrop == ON)
//				{
//					ShmCharger->gun_info[gun_index].otherAlarmCode.isPowerDrop = OFF;
//					ShmCharger->gun_info[gun_index].systemAlarmCode.SystemAlarmCode &= ~ALARM_POWER_DROP;
//
//					DEBUG_INFO("ALARM_POWER_DROP : recover \r\n");
//				}
//			}
//



			//=====================================
			// Latch alarm recover in state A
			//=====================================
			if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == 1))
			{
				/*
				  TODO: Recover latch alarm here
				*/
			}

			//=====================================
			// Latch alarm recover in state B1 and B2
			//=====================================
			if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == 2) || (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == 3))
			{
				/*
				TODO: Recover latch alarm here
				*/
			}

			//=====================================
			// Latch alarm recover in state C
			//=====================================
			if((ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].PilotState == 4))
			{
				/*
				  TODO: Recover latch alarm here
				*/
			}
		}

		usleep(100000);
	}

	return FAIL;
}