csu3_am335x/EVSE/Modularization/ocppfiles/MessageHandler.c

#define _XOPEN_SOURCE 700
#include 	<sys/types.h>
#include 	<sys/ipc.h>
#include 	<sys/shm.h>
#include    <sys/stat.h>
#include 	<sys/time.h>   // gettimeofday sleep usleep
#include    <fcntl.h>
#include	<stddef.h>
#include 	<stdio.h>
#include	<string.h>
#ifdef _WIN32
#include 	<Windows.h>
#else
#include 	<unistd.h>
#endif

#include 	<stdarg.h>
#include 	<ctype.h>
#include	<json.h>               
#include 	<json_config.h>        
#include 	<json_object.h>        
#include 	<json_tokener.h>      
//#include	<json-c/json.h>               remove temporally
//#include 	<json-c/json_config.h>        remove temporally
//#include 	<json-c/json_object.h>        remove temporally
//#include 	<json-c/json_tokener.h>       remove temporally
#include 	<libwebsockets.h>
#include 	<lws_config.h>
//#include    "./json-c/JsonParser.h" remove temporally
#include    "JsonParser.h"
#include	"hashmap.h"
#include	"ShareMemory.h"
#include	"TransactionQueue.h"
#include    "SystemLogMessage.h"
#include	"../../Projects/define.h"
#include 	"ShareMemory.h"
#include	"SystemLogMessage.h"
//#include 	"config.h"
#include 	<sys/socket.h>
#include 	<netinet/in.h>
#include 	<stdlib.h>
/*for sendfile()*/
#include	<sys/sendfile.h>
 /*for O_RDONLY*/
#include	<fcntl.h>
#include	"sqlite3.h"
#include 	<arpa/inet.h>
#define _GNU_SOURCE
#include 	<time.h>
#include  	"MessageHandler.h"
#include    <assert.h>
#include 	<pthread.h>




#define PASS				1
#define FAIL				-1

#define FALSE 0
#define TRUE 1       		// Option 1


#define ChargingProfile_0_JSON			"chargingprofile_0.json"
#define ChargingProfile_1_JSON			"chargingprofile_1.json"
#define ChargingProfile_2_JSON			"chargingprofile_2.json"
#define AuthorizationCache_JSON			"AuthorizationCache.json"
#define LocalAuthorizationList_JSON		"LocalAuthorizationList.json"


struct SysConfigAndInfo			*ShmSysConfigAndInfo;
struct StatusCodeData 			*ShmStatusCodeData;
struct PsuData 					*ShmPsuData ;
struct OCPP16Data 				*ShmOCPP16Data;


/* 		define Macro				 */
#define SystemLogMessage

/* 		OCPP Message Type			*/
#define MESSAGE_TYPE_CALL			2
#define MESSAGE_TYPE_CALLRESULT		3
#define MESSAGE_TYPE_CALLERROR		4

/*     */
#define server_cycle_Status		120
#define MACROSTR(k) #k

extern struct lws 					*wsi_client;
extern struct lws_context 			*context;
extern unsigned char *SendBuffer;
extern int SendBufLen;
//char guid[37];
char queuedata[2000];
static char unknownkey[10][20];
static int UnknownKeynum = 0;
static int localversion=0;
static char idTagAuthorization[32]={};
char OcppPath[100]={};
char OcppProtocol[10],OcppHost[50], OcppTempPath[50];
int OcppPort=0;
extern map_t hashMap;
extern data_struct_t* mapItem;

extern char *random_uuid( char buf[37] );
extern void split(char **arr, char *str, const char *del);
extern pthread_mutex_t mutex1;

int updateSetting(char *key, char *value);
int setKeyValue(char *key, char *value);
int server_sign = FALSE;
int server_pending = FALSE;
int authenrequest = FALSE;
int PRE_SYS_MODE[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY];
int BootNotificationInterval = 0;

//number of  Retry times
int authorizeRetryTimes = 0;
int isUpdateRequest = FALSE;
int statusModeChage = FALSE;
int HeartBeatWaitTime = 10;





//Test Variables
int teststatus =100; //0: enter test ; 100: test
int testCount= 5;
int testCountInc = 0;

int UserPlugGun = 0; // user plug gun or not


pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;

extern struct Charger_Info Charger;
extern sqlite3 *db;

struct ClientTime
{
	unsigned int Heartbeat;
	unsigned int StatusNotification[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY];
	unsigned int StartTransaction;
	unsigned int StopTransaction;
	unsigned int MeterValues[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY];

}clientTime;

typedef union
{
	//Operations Initiated by Central System
	unsigned char CsMsgValue[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];
	struct
	{
	//CsMsgValue[0]
	unsigned char StatusNotificationReq :1;	//bit 0,
	unsigned char StatusNotificationConf :1;	//bit 0,
	unsigned char :6;	//bit 2~7
	}bits[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];
}CpinitiateMsg;

CpinitiateMsg cpinitateMsg;

//==========================================
// Init all Enumeration & Mapping String
//==========================================
/*ChargePointErrorCode*/
typedef enum {
	ConnectorLockFailure,
	EVCommunicationError,
	GroundFailure,
	HighTemperature,
	InternalError,
	LocalListConflict,
	NoError,
	OtherError,
	OverCurrentFailure,
	OverVoltage,
	PowerMeterFailure,
	PowerSwitchFailure,
	ReaderFailure,
	ResetFailure,
	UnderVoltage,
	WeakSignal
} ChargePointErrorCode;

static char *ChargePointErrorCodeStr[] = {
    MACROSTR(ConnectorLockFailure),
    MACROSTR(EVCommunicationError),
	MACROSTR(GroundFailure),
	MACROSTR(HighTemperature),
	MACROSTR(InternalError),
	MACROSTR(LocalListConflict),
	MACROSTR(NoError),
	MACROSTR(OtherError),
	MACROSTR(OverCurrentFailure),
	MACROSTR(OverVoltage),
	MACROSTR(PowerMeterFailure),
	MACROSTR(PowerSwitchFailure),
	MACROSTR(ReaderFailure),
	MACROSTR(ResetFailure),
	MACROSTR(UnderVoltage),
	MACROSTR(WeakSignal)
};

/*ChargePointStatus*/
typedef enum {
	Available,
	Preparing,
	Charging,
	SuspendedEVSE,
	SuspendedEV,
	Finishing,
	Reserved,
	Unavailable,
	Faulted
}  ChargePointStatus;

static char * ChargePointStatusStr[] = {
    MACROSTR(Available),
    MACROSTR(Preparing),
	MACROSTR(Charging),
	MACROSTR(SuspendedEVSE),
	MACROSTR(SuspendedEV),
	MACROSTR(Finishing),
	MACROSTR(Reserved),
	MACROSTR(Unavailable),
	MACROSTR(Faulted)
};

/*AvailabilityType*/
typedef enum {
	RegistrationStatus_Accepted,
	RegistrationStatus_Pending,
	RegistrationStatus_Rejected
} RegistrationStatus;

static char *RegistrationStatusStr[] = {
    MACROSTR(Accepted),
    MACROSTR(Pending),
	MACROSTR(Rejected)
};

/*AvailabilityType*/
typedef enum {
	Inoperative,
	Operative
} AvailabilityType;

static char *AvailabilityTypeStr[] = {
    MACROSTR(Inoperative),
    MACROSTR(Operative)
};

/*AvailabilityStatus*/
typedef enum {
	Accepted,
	Rejected,
	Scheduled
}  AvailabilityStatus;

static char *AvailabilityStatusStr[] = {
    MACROSTR(Accepted),
    MACROSTR(Rejected),
	MACROSTR(Scheduled)
};

/*ConfigurationStatus*/
typedef enum {
	ConfigurationStatus_Accepted,
	ConfigurationStatus_Rejected,
	RebootRequired,
	NotSupported
}  ConfigurationStatus;

static char *ConfigurationStatusStr[] = {
    MACROSTR(Accepted),
    MACROSTR(Rejected),
	MACROSTR(RebootRequired),
	MACROSTR(NotSupported)
};

/*ClearCacheStatus*/
typedef enum {
	ClearCacheStatus_Accepted,
	ClearCacheStatus_Rejected
}  ClearCacheStatus;

static char *ClearCacheStatusStr[] = {
    MACROSTR(Accepted),
    MACROSTR(Rejected)
};

/*ChargingProfilePurposeType*/
typedef enum {
	ChargePointMaxProfile,
	TxDefaultProfile,
	TxProfile
}  ChargingProfilePurposeType;

static char *ChargingProfilePurposeTypeStr[] = {
    MACROSTR(ChargePointMaxProfile),
    MACROSTR(TxDefaultProfile),
	MACROSTR(TxProfile)
};

/*ChargingProfileStatus*/
typedef enum {
	ChargingProfileStatus_Accepted,
	ChargingProfileStatus_Rejected,
	ChargingProfileStatus_NotSupported
}  ChargingProfileStatus;

static char *ChargingProfileStatusStr[] = {
    MACROSTR(Accepted),
    MACROSTR(Rejected),
	MACROSTR(NotSupported)
};

/*ClearChargingProfileStatus*/
typedef enum {
	ClearChargingProfileStatus_Accepted,
	ClearChargingProfileStatus_Unknown
}  ClearChargingProfileStatus;

static char *ClearChargingProfileStatusStr[] = {
    MACROSTR(Accepted),
    MACROSTR(Unknown)
};

/*GetCompositeScheduleStatus*/
typedef enum {
	GetCompositeScheduleStatus_Accepted,
	GetCompositeScheduleStatus_Rejected
}  GetCompositeScheduleStatus;


static char *GetCompositeScheduleStatusStr[] = {
    MACROSTR(Accepted),
    MACROSTR(Rejected)
};

/*ChargingRateUnitType*/
typedef enum {
	ChargingRateUnitType_W,
	ChargingRateUnitType_A
}  ChargingRateUnitType;


static char *ChargingRateUnitTypeStr[] = {
    MACROSTR(W),
    MACROSTR(A)
};

/*AuthorizationStatus*/
typedef enum {
	AuthorizationStatus_Accepted ,
	AuthorizationStatus_Blocked ,
	AuthorizationStatus_Expired ,
	AuthorizationStatus_Invalid ,
	AuthorizationStatus_ConcurrentTx
}  AuthorizationStatus;


static char *AuthorizationStatusStr[] = {
    MACROSTR(Accepted),
    MACROSTR(Blocked),
	MACROSTR(Expired),
	MACROSTR(Invalid),
	MACROSTR(ConcurrentTx)
};

/*UpdateType*/
typedef enum {
	Differential  ,
	Full
}  UpdateType;

static char *UpdateTypeStr[] = {
    MACROSTR(Differential),
    MACROSTR(Full)
};

/*UpdateStatus*/
typedef enum {
	UpdateStatus_Accepted   ,
	UpdateStatus_Failed ,
	UpdateStatus_NotSupported ,
	UpdateStatus_VersionMismatch
}  UpdateStatus;

static char *UpdateStatusStr[] = {
    MACROSTR(Accepted),
    MACROSTR(Failed),
	MACROSTR(NotSupported),
	MACROSTR(VersionMismatch)
};

/*RemoteStartStopStatus*/
typedef enum {
	RemoteStartStopStatus_Accepted,
	RemoteStartStopStatus_Rejected

}  RemoteStartStopStatus;


static char *RemoteStartStopStatusStr[] = {
    MACROSTR(Accepted),
    MACROSTR(Rejected)

};

/*ReservationStatus*/
typedef enum {
	ReservationStatus_Accepted,
	ReservationStatus_Faulted,
	ReservationStatus_Occupied,
	ReservationStatus_Rejected,
	ReservationStatus_Unavailable

}  ReservationStatus;

static char *ReservationStatusStr[] = {
    MACROSTR(Accepted),
    MACROSTR(Faulted),
	MACROSTR(Occupied),
	MACROSTR(Rejected),
	MACROSTR(Unavailable)
};

/*ResetType*/
typedef enum {
	Hard,
	Soft
}  ResetType;


static char *ResetTypeStr[] = {
    MACROSTR(Hard),
    MACROSTR(Soft)
};


/*ResetStatus*/
typedef enum {
	ResetStatus_Accepted,
	ResetStatus_Rejected
}  ResetStatus;


static char *ResetStatusStr[] = {
    MACROSTR(Accepted),
    MACROSTR(Rejected)
};

/*DiagnosticsStatus*/
typedef enum {
	DiagnosticsStatus_Idle,
	DiagnosticsStatus_Uploaded,
	DiagnosticsStatus_UploadFailed,
	DiagnosticsStatus_Uploading
}  DiagnosticsStatus;


static char * DiagnosticsStatusStr[] = {
    MACROSTR(Idle),
    MACROSTR(Uploaded),
	MACROSTR(UploadFailed),
	MACROSTR(Uploading)
};

/*FirmwareStatus*/
typedef enum {
	FirmwareStatus_Downloaded,
	FirmwareStatus_DownloadFailed,
	FirmwareStatus_Downloading,
	FirmwareStatus_Idle,
	FirmwareStatus_InstallationFailed,
	FirmwareStatus_Installing,
	FirmwareStatus_Installed
}  FirmwareStatus;


static char * FirmwareStatusStr[] = {
    MACROSTR(Downloaded),
    MACROSTR(DownloadFailed),
	MACROSTR(Downloading),
	MACROSTR(Idle),
	MACROSTR(InstallationFailed),
	MACROSTR(Installing),
	MACROSTR(Installed)
};


/*MessageTrigger*/
typedef enum {
	BootNotification,
	DiagnosticsStatusNotification,
	FirmwareStatusNotification,
	Heartbeat,
	MeterValues,
	StatusNotification
}   MessageTrigger;


static char * MessageTriggerStr[] = {
    MACROSTR(BootNotification),
    MACROSTR(DiagnosticsStatusNotification),
	MACROSTR(FirmwareStatusNotification),
	MACROSTR(Heartbeat),
	MACROSTR(MeterValues),
	MACROSTR(StatusNotification)
};


/*TriggerMessageStatus*/
typedef enum {
	TriggerMessageStatus_Accepted ,
	TriggerMessageStatus_Rejected ,
	TriggerMessageStatus_NotImplemented
}   TriggerMessageStatus;


static char * TriggerMessageStatusStr[] = {
    MACROSTR(Accepted),
    MACROSTR(Rejected),
	MACROSTR(NotImplemented)
};


/*UnlockStatus*/
typedef enum {
	Unlocked,
	UnlockFailed,
	UnlockStatus_NotSupported
}   UnlockStatus;


static char * UnlockStatusStr[] = {
    MACROSTR(Unlocked),
    MACROSTR(UnlockFailed),
	MACROSTR(NotSupported)
};

/*StopTransactionReason*/
typedef enum {
	EmergencyStop,
	EVDisconnected,
	HardReset,
	Local,
	Other,
	PowerLoss,
	Reboot,
	Remote,
	SoftReset,
	UnlockCommand,
	DeAuthorized
}   StopTransactionReason;

static char * StopTransactionReasonStr[] = {
    MACROSTR(EmergencyStop),
    MACROSTR(EVDisconnected),
	MACROSTR(HardReset),
	MACROSTR(Local),
	MACROSTR(Other),
	MACROSTR(PowerLoss),
	MACROSTR(Reboot),
	MACROSTR(Remote),
	MACROSTR(SoftReset),
	MACROSTR(UnlockCommand),
	MACROSTR(DeAuthorized)
};

/*CancelReservationStatus*/
typedef enum {
	CancelReservationStatus_Accepted,
	CancelReservationStatus_Rejected
}   CancelReservationStatus;

static char * CancelReservationStatusStr[] = {
    MACROSTR(Accepted),
	MACROSTR(Rejected)
};

/*ReadingContext*/
typedef enum {
	ReadingContext_Interruption_Begin,
	ReadingContext_Interruption_End,
	ReadingContext_Other,
	ReadingContext_Sample_Clock,
	ReadingContext_Sample_Periodic ,
	ReadingContext_Transaction_Begin ,
	ReadingContext_Transaction_End,
	ReadingContext_Trigger
}  ReadingContext;


static char * ReadingContextStr[] = {
    MACROSTR(Interruption.Begin),
	MACROSTR(Interruption.End),
	MACROSTR(Other),
	MACROSTR(Sample.Clock),
	MACROSTR(Sample.Periodic),
	MACROSTR(Transaction.Begin),
	MACROSTR(Transaction.End),
	MACROSTR(Trigger)
};


/*ValueFormat*/
typedef enum {
	Raw,
	SignedData
}  ValueFormat;


static char * ValueFormatStr[] = {
    MACROSTR(Raw),
	MACROSTR(SignedData)
};


/*Measurand*/
typedef enum {
	Current_Export ,
	Current_Import,
	Current_Offered,
	Energy_Active_Export_Register,
	Energy_Active_Import_Register,
	Energy_Reactive_Export_Register,
	Energy_Reactive_Import_Register,
	Energy_Active_Export_Interval,
	Energy_Active_Import_Interval,
	Energy_Reactive_Export_Interval,
	Energy_Reactive_Import_Interval,
	Frequency,
	Power_Active_Export ,
	Power_Active_Import,
	Power_Factor,
	Power_Offered,
	Power_Reactive_Export,
	Power_Reactive_Import,
	RPM,
	SoC,
	Temperature ,
	Voltage
}  Measurand;


static char * MeasurandStr[] = {
    MACROSTR(Current.Export),
	MACROSTR(Current.Import),
	MACROSTR(Current.Offered),
	MACROSTR(Energy.Active.Export.Register),
	MACROSTR(Energy.Active.Import.Register),
	MACROSTR(Energy_Reactive_Export_Register),
	MACROSTR(Energy_Reactive_Import_Register),
	MACROSTR(Energy_Active_Export_Interval),
	MACROSTR(Energy_Active_Import_Interval),
	MACROSTR(Energy_Reactive_Export_Interval),
	MACROSTR(Energy_Reactive_Import_Interval),
	MACROSTR(Frequency),
	MACROSTR(Power_Active_Export),
	MACROSTR(Power_Active_Import),
	MACROSTR(Power_Factor),
	MACROSTR(Power_Offered),
	MACROSTR(Power_Reactive_ExportMACROSTR),
	MACROSTR(Power_Reactive_Import),
	MACROSTR(RPM),
	MACROSTR(SoC),
	MACROSTR(Temperature),
	MACROSTR(Voltage)
};


/*Location*/
typedef enum {
	Location_Body,
	Location_Cable,
	Location_EV,
	Location_Inlet ,
	Location_Outlet
}  Location;


static char * LocationStr[] = {
    MACROSTR(Body),
	MACROSTR(Cable),
	MACROSTR(EV),
	MACROSTR(Inlet),
	MACROSTR(Outlet)
};


/*Phase*/
typedef enum {
	L1,
	L2,
	L3,
	N,
	L1_N,
	L2_N,
	L3_N,
	L1_L2,
	L2_L3,
	L3_L1
}  Phase;


static char * PhaseStr[] = {
    MACROSTR(L1),
	MACROSTR(L2),
	MACROSTR(L3),
	MACROSTR(N),
	MACROSTR(L1-N),
	MACROSTR(L2-N),
	MACROSTR(L3-N),
	MACROSTR(L1-L2),
	MACROSTR(L2-L3),
	MACROSTR(L3-L1)
};


/*UnitOfMeasure*/
typedef enum {
	UnitOfMeasure_Wh,
	UnitOfMeasure_kWh ,
	UnitOfMeasure_varh ,
	UnitOfMeasure_kvarh ,
	UnitOfMeasure_W ,
	UnitOfMeasure_kW ,
	UnitOfMeasure_VA ,
	UnitOfMeasure_kVA ,
	UnitOfMeasure_var ,
	UnitOfMeasure_kvar ,
	UnitOfMeasure_A ,
	UnitOfMeasure_V ,
	UnitOfMeasure_Celsius ,
	UnitOfMeasure_Fahrenheit ,
	UnitOfMeasure_K ,
	UnitOfMeasure_Percent

}  UnitOfMeasure;


static char * UnitOfMeasureStr[] = {
	MACROSTR(Wh),
	MACROSTR(kWh),
	MACROSTR(varh),
	MACROSTR(kvarh),
	MACROSTR(W),
	MACROSTR(kW),
	MACROSTR(VA),
	MACROSTR(kVA),
	MACROSTR(var),
	MACROSTR(kvar),
	MACROSTR(A),
	MACROSTR(V),
	MACROSTR(Celsius),
	MACROSTR(Fahrenheit),
	MACROSTR(K),
	MACROSTR(Percent)
};


/*Configuration enum*/
enum CoreProfile {
	 AllowOfflineTxForUnknownId=0,
	 AuthorizationCacheEnabled,
	 AuthorizeRemoteTxRequests,
	 BlinkRepeat,
	 ClockAlignedDataInterval,
	 ConnectionTimeOut,
	 GetConfigurationMaxKeys,
	 HeartbeatInterval,
	 LightIntensity,
	 LocalAuthorizeOffline,
	 LocalPreAuthorize,
	 MaxEnergyOnInvalidId,
	 MeterValuesAlignedData,
	 MeterValuesAlignedDataMaxLength,
	 MeterValuesSampledData,
	 MeterValuesSampledDataMaxLength,
	 MeterValueSampleInterval,
	 MinimumStatusDuration,
	 NumberOfConnectors,
	 ResetRetries,
	 ConnectorPhaseRotation,
	 ConnectorPhaseRotationMaxLength,
	 StopTransactionOnEVSideDisconnect,
	 StopTransactionOnInvalidId,
	 StopTxnAlignedData,
	 StopTxnAlignedDataMaxLength,
	 StopTxnSampledData,
	 StopTxnSampledDataMaxLength,
	 SupportedFeatureProfiles,
	 SupportedFeatureProfilesMaxLength,
	 TransactionMessageAttempts,
	 TransactionMessageRetryInterval,
	 UnlockConnectorOnEVSideDisconnect,
	 WebSocketPingInterval,
	 _CoreProfile_CNT
};

enum LocalAuthListManagementProfile{
	LocalAuthListEnabled=0,
	LocalAuthListMaxLength,
	SendLocalListMaxLength,
	_LocalAuthListManagementProfile_CNT
};

enum ReservationProfile{
	ReserveConnectorZeroSupported
};

enum SmartChargingProfile{
	ChargeProfileMaxStackLevel,
	ChargingScheduleAllowedChargingRateUnit,
	ChargingScheduleMaxPeriods,
	ConnectorSwitch3to1PhaseSupported,
	MaxChargingProfilesInstalled
};

enum ChargerSystemStatus{
	ChargerSystemStatus_Booting,
	ChargerSystemStatus_Idle,
	ChargerSystemStatus_Authorizing,
	ChargerSystemStatus_Preparing,
	ChargerSystemStatus_Charging,
	ChargerSystemStatus_Terminating,
	ChargerSystemStatus_Alarm,
	ChargerSystemStatus_Fault
};

enum GetConfigurationKey {
	GetConfiguration_AllowOfflineTxForUnknownId=0,
	GetConfiguration_AuthorizationCacheEnabled,
	GetConfiguration_AuthorizeRemoteTxRequests,
	GetConfiguration_BlinkRepeat,
	GetConfiguration_ClockAlignedDataInterval,
	GetConfiguration_ConnectionTimeOut,
	GetConfiguration_GetConfigurationMaxKeys,
	GetConfiguration_HeartbeatInterval,
	GetConfiguration_LightIntensity,
	GetConfiguration_LocalAuthorizeOffline,
	GetConfiguration_LocalPreAuthorize,
	GetConfiguration_MaxEnergyOnInvalidId,
	GetConfiguration_MeterValuesAlignedData,
	GetConfiguration_MeterValuesAlignedDataMaxLength,
	GetConfiguration_MeterValuesSampledData,
	GetConfiguration_MeterValuesSampledDataMaxLength,
	GetConfiguration_MeterValueSampleInterval,
	GetConfiguration_MinimumStatusDuration,
	GetConfiguration_NumberOfConnectors,
	GetConfiguration_ResetRetries,
	GetConfiguration_ConnectorPhaseRotation,
	GetConfiguration_ConnectorPhaseRotationMaxLength,
	GetConfiguration_StopTransactionOnEVSideDisconnect,
	GetConfiguration_StopTransactionOnInvalidId,
	GetConfiguration_StopTxnAlignedData,
	GetConfiguration_StopTxnAlignedDataMaxLength,
	GetConfiguration_StopTxnSampledData,
	GetConfiguration_StopTxnSampledDataMaxLength,
	GetConfiguration_SupportedFeatureProfiles,
	GetConfiguration_SupportedFeatureProfilesMaxLength,
	GetConfiguration_TransactionMessageAttempts,
	GetConfiguration_TransactionMessageRetryInterval,
	GetConfiguration_UnlockConnectorOnEVSideDisconnect,
	GetConfiguration_WebSocketPingInterval,
	GetConfiguration_LocalAuthListEnabled,
	GetConfiguration_LocalAuthListMaxLength,
	GetConfiguration_SendLocalListMaxLength,
	GetConfiguration_ReserveConnectorZeroSupported,
	GetConfiguration_ChargeProfileMaxStackLevel,
	GetConfiguration_ChargingScheduleAllowedChargingRateUnit,
	GetConfiguration_ChargingScheduleMaxPeriods,
	GetConfiguration_ConnectorSwitch3to1PhaseSupported,
	GetConfiguration_MaxChargingProfilesInstalled,
};

//==========================================
// Init all share memory
//==========================================

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

	printf("1\n");

	//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
    {}
	printf("2\n");
   	//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
    {}
   	printf("3\n");


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


   	printf("4\n");

   	//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
	{}

   	printf("5\n");
	//memset(ShmOCPP16Data,0,sizeof(struct OCPP16Data));

    /****************************** For TEST ************************************************/
	//strcpy(ShmOCPP16Data->OcppServerURL,"172.17.40.13");
	//strcpy(ShmOCPP16Data->ChargeBoxId,"RDTEST103");



	//inital settings
#if 0 // For Test
	sprintf(ShmOCPP16Data->BootNotification.CbSN, "");
	sprintf(ShmOCPP16Data->BootNotification.CpModel, "EA873E3EF8P1");
	sprintf(ShmOCPP16Data->BootNotification.CpSN, "RDTEST103");
	sprintf(ShmOCPP16Data->BootNotification.CpVendor, "Phihong Technology");
	sprintf(ShmOCPP16Data->BootNotification.CpFwVersion, "D0.13.50.0087.PH");
	sprintf(ShmOCPP16Data->BootNotification.CpIccid, "");
	sprintf(ShmOCPP16Data->BootNotification.CpImsi,"");
	sprintf(ShmOCPP16Data->BootNotification.CpMeterSerialNumber,"N/A");
	sprintf(ShmOCPP16Data->BootNotification.CpMeterType,"AC");


	memset(ShmOCPP16Data->StatusNotification,0,sizeof(struct StructStatusNotification)*(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY));
	for(int gun_index=0; gun_index < (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY); gun_index++ )
	{
		cpinitateMsg.bits[gun_index].StatusNotificationReq = 0;
		cpinitateMsg.bits[gun_index].StatusNotificationConf = 0;


		//allocate memory
		if(ShmOCPP16Data->StopTransaction[gun_index].TransactionData == NULL)
		{
			ShmOCPP16Data->StopTransaction[gun_index].TransactionData  = (struct StructMeterValue *)malloc(sizeof(struct StructMeterValue));

		}

		if(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[0].SampledValue == NULL)
		{
			ShmOCPP16Data->StopTransaction[gun_index].TransactionData[0].SampledValue = (struct StructSampledValue *)malloc(sizeof(struct StructSampledValue)*5);

		}


		ShmOCPP16Data->StatusNotification[gun_index].ConnectorId = (gun_index + 1);
		strcpy(ShmOCPP16Data->StatusNotification[gun_index].ErrorCode, "NoError");
		strcpy(ShmOCPP16Data->StatusNotification[gun_index].Info, "N/A");
		strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Available");
		strcpy(ShmOCPP16Data->StatusNotification[gun_index].Timestamp, "2019-05-04T18:15:33Z");
		strcpy(ShmOCPP16Data->StatusNotification[gun_index].VendorId, "PhihongTechnology");
		strcpy(ShmOCPP16Data->StatusNotification[gun_index].VendorErrorCode, "000000");

		clientTime.MeterValues[gun_index] = time((time_t*)NULL);
	}
	printf("6\n");
	strcpy(ShmOCPP16Data->Authorize.IdTag,"PaHdImHiOnNG");
//	ShmOCPP16Data->CpMsg.bits[0].StartTransactionReq = 1;


	//Authorize
	//memset(ShmSysConfigAndInfo, 0, sizeof(struct SysConfigAndInfo));
	//strcpy(ShmSysConfigAndInfo->SysConfig.UserId, "B014EA9C");


	//gun index
	ShmSysConfigAndInfo->SysInfo.ChademoChargingData[0].Index = 0;
	ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].Index = 1;
	ShmSysConfigAndInfo->SysInfo.GbChargingData[0].Index = 2;

	//Chademo
	ShmSysConfigAndInfo->SysInfo.ChademoChargingData[0].SystemStatus ='1'; //idle
	ShmSysConfigAndInfo->SysInfo.ChademoChargingData[0].PreviousSystemStatus = '1';
	cpinitateMsg.bits[0].StatusNotificationReq = 1;
#endif
	printf("7\n");
	// Charger PRE_SYS_MODE
	memset(PRE_SYS_MODE, 0, sizeof(PRE_SYS_MODE));

	memset( (void *)unknownkey, 0, sizeof(char)*10*20 );

	clientTime.Heartbeat=time((time_t*)NULL);

	for(int gun_index=0;gun_index < (CHAdeMO_QUANTITY/*+ CCS_QUANTITY + GB_QUANTITY*/) ;gun_index++)
	{
		clientTime.StatusNotification[gun_index] = time((time_t*)NULL);
		clientTime.MeterValues[gun_index] = time((time_t*)NULL);
	}


	printf("8\n");
	HeartBeatWaitTime = 10;

	ShmOCPP16Data->GetConfiguration.ResponseUnknownKey = NULL;
	ShmOCPP16Data->SendLocalList.LocalAuthorizationList = NULL;


	//memset(unknownkey, 0, 10);
    return result;
}


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

void CheckSystemValue(void)
{
	printf("CheckSystemValue \n");
	int meterValueSend=0;
	int IdleModeCnt = 0;

	if((server_sign == TRUE) && (difftime(time((time_t*)NULL), clientTime.Heartbeat) >= HeartBeatWaitTime)/*((time((time_t*)NULL)-clientTime.Heartbeat)>= ShmOCPP16Data->BootNotification.ResponseHeartbeatInterval)*/)
	{
		//parameter for test
		sendHeartbeatRequest(0);

		//==============================================
		// Reset Waiting Time
		//==============================================
		clientTime.Heartbeat=time((time_t*)NULL);

	}

	//==============================================
	// Update request
	//==============================================
	if(isUpdateRequest == TRUE )
	{
		for(int gun_index=0;gun_index < (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY) ;gun_index++)
		{
			//check SystemStatus // 0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 1)) //S_IDLE
				{
					IdleModeCnt = IdleModeCnt + 1;
				}
			}

			for (int index = 0; index < CCS_QUANTITY; index++)
			{
				if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 1)) //S_IDLE
				{
					IdleModeCnt = IdleModeCnt + 1;
				}
			}

			for (int index = 0; index < GB_QUANTITY; index++)
			{
				if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 1)) //S_IDLE
				{
					IdleModeCnt = IdleModeCnt + 1;
				}
			}

		}


		if(IdleModeCnt == (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY ))
		{
			sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_Installed]);
			isUpdateRequest = FALSE;
		    ShmOCPP16Data->MsMsg.bits.UpdateFirmwareReq = 1; // trigger firmware upgrade
		}

	}

	printf("gun no %d\n",(CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY));
	for(int gun_index=0;gun_index < (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY ) ;gun_index++)
	{
		//==============================================
		// Charger status report
		//==============================================
		/* Check Mode Change */
		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
			{
				printf("Chademo Mode status:\n");
				printf("ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus: %c\n",ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus);
				printf("ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PreviousSystemStatus: %c\n",ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PreviousSystemStatus);

				if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus != ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PreviousSystemStatus/*PRE_SYS_MODE[gun_index]*/ )
				{
					printf("Chademo Mode Change\n");
					PRE_SYS_MODE[gun_index] = ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus;
					ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PreviousSystemStatus = ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus;
					cpinitateMsg.bits[gun_index].StatusNotificationReq = 1;
					statusModeChage = TRUE;

				}

			}
		}

		for (int index = 0; index < CCS_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
			{
				if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus != ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PreviousSystemStatus/*PRE_SYS_MODE[gun_index]*/ )
				{
					printf("Ccs Mode Change\n");
					PRE_SYS_MODE[gun_index] = ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus;
					ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PreviousSystemStatus = ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus;
					cpinitateMsg.bits[gun_index].StatusNotificationReq = 1;
					statusModeChage = TRUE;
				}

			}
		}

		for (int index = 0; index < GB_QUANTITY; index++)
		{
			if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)/*&&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '4')*/)
			{
				if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus != ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PreviousSystemStatus/*PRE_SYS_MODE[gun_index]*/ )
				{
					printf("Gb Mode Change\n");
					PRE_SYS_MODE[gun_index] = ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus;
					ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PreviousSystemStatus = ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus;
					cpinitateMsg.bits[gun_index].StatusNotificationReq = 1;
					statusModeChage = TRUE;
				}

			}
		}


		if((server_sign == TRUE) && ((statusModeChage == TRUE)||((time((time_t*)NULL)-clientTime.StatusNotification[gun_index]) > server_cycle_Status)|| ((cpinitateMsg.bits[gun_index].StatusNotificationReq == 1)&&((time((time_t*)NULL)-clientTime.StatusNotification[gun_index]) > 30))))
		{
			sendStatusNotificationRequest(gun_index);
			clientTime.StatusNotification[gun_index] = time((time_t*)NULL);
			cpinitateMsg.bits[gun_index].StatusNotificationReq = 0;
			statusModeChage = FALSE;
        }

	if((server_sign == TRUE) && (ShmOCPP16Data->SpMsg.bits.AuthorizeReq == 1)&&(authorizeRetryTimes < 3)/*authenrequest == FALSE*/)
	{
		sendAuthorizeRequest(0);

		authorizeRetryTimes = authorizeRetryTimes + 1;
		/* authenrequest = TRUE; */
		if(authorizeRetryTimes < 3)
		ShmOCPP16Data->SpMsg.bits.AuthorizeReq = 0;

		//Test Variables
		UserPlugGun = 1;
		teststatus = 0;
	}
	else if((server_sign == TRUE) && (ShmOCPP16Data->SpMsg.bits.AuthorizeReq == 1)&&(authorizeRetryTimes >= 3))
	{
		authorizeRetryTimes = 0;
		ShmOCPP16Data->OcppConnStatus = 0;  // ocpp offline
	}


#if 1
		//==============================================
		// Charger start transaction
		//==============================================
		if((server_sign == TRUE) && (ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionReq == 1))
		{
#if 0 // for test
			 if(teststatus == 0)
			 {
#endif
				 sendStartTransactionRequest(gun_index);
				 ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionReq =0;

				 clientTime.StartTransaction = time((time_t*)NULL);
#if 0// for test
				 teststatus = 1; // finish startTransaction
			 }
#endif

	    }

		//==============================================
		// Charger stop transaction
		//==============================================

		if((server_sign == TRUE) && ((ShmOCPP16Data->CpMsg.bits[gun_index].StopTransactionReq == 1)))
		{
#if 0 // for test
			if(teststatus == 2)
		   {
#endif
			  sendStopTransactionRequest(gun_index);
			  ShmOCPP16Data->CpMsg.bits[gun_index].StopTransactionReq =0;
			  clientTime.StopTransaction = time((time_t*)NULL);
#if 0// for test
			  teststatus = 100;

		   }
#endif

		}

		//==============================================
		// Meter report
		//==============================================
		if((server_sign == TRUE) &&  ((time((time_t*)NULL) - clientTime.MeterValues[gun_index])> atoi(ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValueSampleInterval].ItemData)) )
		{
			//check Transaction active
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				// 0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault
				if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 8))
				{
					meterValueSend =1;
				}
			}

			for (int index = 0; index < CCS_QUANTITY; index++)
			{
				// 0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault
				if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 8))
				{
					meterValueSend =1;
				}
			}

			for (int index = 0; index < GB_QUANTITY; index++)
			{
				// 0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault
				if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 8))
				{
					meterValueSend =1;
				}
			}

            printf("sendMeterValuesRequest \n");
	//		if(meterValueSend == 1)
#if 0 // for test
            if((teststatus == 1) && (testCountInc <= testCount))
			{
#endif
            	sleep(1); //?��?1�
            	if(meterValueSend == 1)
				sendMeterValuesRequest(gun_index);
#if 0  //for test
				testCountInc  = testCountInc + 1;
				printf("testCountInc=%d\n",testCountInc);

			}
            else if((meterValueSend == 1) && (testCountInc > testCount))
            {
            	teststatus = 2;
            	meterValueSend = 0;
            	testCountInc = 0;
            	ShmOCPP16Data->CpMsg.bits[gun_index].StopTransactionReq = 1;
            }
#endif
			clientTime.MeterValues[gun_index] = time((time_t*)NULL);
		}



#endif

		//==============================================
		// Check Connector reserved
		//==============================================

		printf("ShmOCPP16Data->ReserveNow[gun_index].ExpiryDate=%s\n",ShmOCPP16Data->ReserveNow[gun_index].ExpiryDate);
		if((server_sign == TRUE) && (strcmp(ShmOCPP16Data->ReserveNow[gun_index].ExpiryDate, "") != 0) )
		{
			double diff_t;
			struct tm tp;
			// current time
			time_t t = time(NULL);
			sprintf((char *)ShmOCPP16Data->ReserveNow[gun_index].ExpiryDate, "%s", "2018-09-20T02:56:54.973Z");
			printf("ExpiryDate : %s\n", (char *)ShmOCPP16Data->ReserveNow[gun_index].ExpiryDate);
			strptime((char *)ShmOCPP16Data->ReserveNow[gun_index].ExpiryDate, "%Y-%m-%dT%H:%M:%S", &tp);
			printf("handle  check value 1\n");
			tp.tm_isdst = -1;
			printf("handle  check value 2\n");
			time_t utc = mktime(&tp);
			printf("handle  check value 3\n");
			struct tm e0 = { .tm_year = tp.tm_year, .tm_mday = tp.tm_mday, .tm_mon = tp.tm_mon, .tm_hour = tp.tm_hour, .tm_isdst = -1 };
			time_t pseudo = mktime(&e0);
			struct tm e1 = *gmtime(&pseudo);
			e0.tm_sec += utc - diff_tm(&e1, &e0);
			time_t local = e0.tm_sec;
			// ?�到��??�起始�???- chargingScedule起�??��?
			diff_t = difftime(t, local);

			if(diff_t < 0)
			{
				printf("reserve expired !!!   \n");
				ShmOCPP16Data->CsMsg.bits[gun_index].CancelReservationReq = 1;
			}
			else if((ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionConf == 1) &&
					(ShmOCPP16Data->StartTransaction[gun_index].ReservationId == ShmOCPP16Data->ReserveNow[gun_index].ReservationId)&&
					(strcmp(ShmOCPP16Data->StartTransaction[gun_index].IdTag, ShmOCPP16Data->ReserveNow[gun_index].IdTag) ==0))
			{
				ShmOCPP16Data->CsMsg.bits[gun_index].CancelReservationReq = 1;
			}
			else
			{

				//check Transaction active
				for (int index = 0; index < CHAdeMO_QUANTITY; index++)
				{
					//0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault, 8: Reserved, 9: maintain
					if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index) &&(1/*?�ç??—æ?*//*ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus != '8'*/))
					{
						//if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '6') || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '7') || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '9') )
						if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 11) || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 12) ) // S_ALARM, S_FAULT
						{
							ShmOCPP16Data->CsMsg.bits[gun_index].CancelReservationReq = 1;

						}

					}
				}

				for (int index = 0; index < CCS_QUANTITY; index++)
				{
					//0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault, 8: Reserved, 9: maintain
					if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&(1/*?�ç??—æ?*//*ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus != '8'*/))
					{

						//if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == '6') || (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == '7') || (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == '9') )
						if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 11) || (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 12) ) // S_ALARM, S_FAULT
						{
							ShmOCPP16Data->CsMsg.bits[gun_index].CancelReservationReq = 1;

						}

					}
				}

				for (int index = 0; index < GB_QUANTITY; index++)
				{
					//0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault, 8: Reserved, 9: maintain
					if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)&&(1/*?�ç??—æ?*//*ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus != '8'*/) )
					{

						//if((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '6') || (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '7') || (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '9') )
						if((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 11) || (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 12) ) // S_ALARM, S_FAULT
						{
							ShmOCPP16Data->CsMsg.bits[gun_index].CancelReservationReq = 1;

						}

					}
				}
			}
		}


		// csu trigger FirmwareStatusNotificationReq
		if((server_sign == TRUE) && (ShmOCPP16Data->SpMsg.bits.FirmwareStatusNotificationReq == 1))
		{
			sendFirmwareStatusNotificationRequest(ShmOCPP16Data->FirmwareStatusNotification.Status);
		}

		if((server_sign == TRUE) && (ShmOCPP16Data->CsMsg.bits[gun_index].CancelReservationConf == 1))
		{
			//sendCancelReservationConfirmation(uuid, comfirmstr);
			sendCancelReservationConfirmation(ShmOCPP16Data->CancelReservation[gun_index].guid, ShmOCPP16Data->CancelReservation[gun_index].ResponseStatus);

		}


		if((server_sign == TRUE) && (ShmOCPP16Data->CsMsg.bits[gun_index].ChangeAvailabilityConf == 1))
		{
			//sendChangeAvailabilityConfirmation(,(char *)ShmOCPP16Data->ChangeAvailability[gun_index].ResponseStatus);
		}

		if((server_sign == TRUE) && (ShmOCPP16Data->CsMsg.bits[gun_index].UnlockConnectorConf == 1))
		{
			sendUnlockConnectorConfirmation(ShmOCPP16Data->UnlockConnector[gun_index].guid, ShmOCPP16Data->UnlockConnector[gun_index].ResponseStatus);
		}

		if((server_sign == TRUE) &&(ShmOCPP16Data->CsMsg.bits[gun_index].ReserveNowConf == 1))
		{
			sendReserveNowTransactionConfirmation(ShmOCPP16Data->ReserveNow[gun_index].guid, ShmOCPP16Data->ReserveNow[gun_index].ResponseStatus);
		}

		if((server_sign == TRUE) &&(ShmOCPP16Data->MsMsg.bits.ResetConf == 1))
		{
			sendResetConfirmation(ShmOCPP16Data->Reset.guid, ShmOCPP16Data->Reset.ResponseStatus);
		}

	}


}

//==========================================
// send request routine
//==========================================
int sendAuthorizeRequest(int gun_index)
{
	printf("sendAuthorizeRequest \n");
	int result = FAIL;
	int i = 0;
	char *str =	NULL;
	char *arr[1];
	const char *del = ",";
	char *senstr = NULL;
	char *temp = NULL;
	struct json_object *message, *payload;
	char guid[37];
	message = json_object_new_array();
	payload = json_object_new_object();

	//initailize  struct Authorize
	memset(&(ShmOCPP16Data->Authorize), 0 , sizeof(struct StructAuthorize));

	//get data from shared memory
	strcpy(ShmOCPP16Data->Authorize.IdTag, ShmSysConfigAndInfo->SysConfig.UserId);
	//json_object_object_add(payload, "idTag", json_object_new_string((const char *)request.IdTag));
	json_object_object_add(payload, "idTag", json_object_new_string((const char *)ShmOCPP16Data->Authorize.IdTag));
	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALL));
	random_uuid(guid);
	json_object_array_add(message, json_object_new_string(guid));
	json_object_array_add(message, json_object_new_string("Authorize"));
	json_object_array_add(message, payload);

	Send(message);
	// Put request guid to hash map
    if(mapItem == NULL)
    {
    	mapItem = malloc(sizeof(data_struct_t));
    	printf("mapItem is null\n");
    }

    sprintf(mapItem->key_string, "%s", guid);
	sprintf(mapItem->key_value, "Authorize,%d", gun_index);//sprintf(mapItem->key_value, senstr);//sprintf(mapItem->key_value, "Authorize");

	printf("Authorize mapItem->key_string=%s\n",mapItem->key_string);
	printf("Authorize mapItem->key_value=%s\n",mapItem->key_value);
	if(hashmap_operation(0,hashMap, mapItem->key_string, mapItem->key_value/*mapItem*/, (void**)(&mapItem)) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
		printf("Authorize mapItem pass\n");
	}

	#ifdef SystemLogMessage
	DEBUG_INFO(">>>>>Authorize request\n");
	DEBUG_INFO("Message: %s\n", SendBuffer);
	DEBUG_INFO("After push hash length: %d\n", hashmap_length(hashMap));
	#endif

	ShmOCPP16Data->SpMsg.bits.AuthorizeReq = 0;
	json_object_put(message); // Delete the json object

	//for test
	//ShmSysConfigAndInfo->SysInfo.ChademoChargingData[0].SystemStatus ='3'; //preparing
	//ShmOCPP16Data->CpMsg.bits[0].StartTransactionReq = 1;

	return result;
}

int sendBootNotificationRequest(void)
{
	int result = FAIL;
	int i = 0;
	struct json_object *message, *payload;
    int count = 0;
    int gun_index = 0;
    char guid[37];

	message = json_object_new_array();
	payload = json_object_new_object();

	// Fill BootNotification fields
	strcpy(ShmOCPP16Data->BootNotification.CbSN,(const char *)ShmOCPP16Data->ChargeBoxId);
	strcpy(ShmOCPP16Data->BootNotification.CpModel,(const char *)ShmSysConfigAndInfo->SysConfig.ModelName);
	strcpy(ShmOCPP16Data->BootNotification.CpSN,(const char *)ShmSysConfigAndInfo->SysConfig.SerialNumber);
	strcpy(ShmOCPP16Data->BootNotification.CpVendor,(const char *)ShmSysConfigAndInfo->SysConfig.chargePointVendor);

	json_object_object_add(payload, "chargeBoxSerialNumber",  json_object_new_string((const char *)ShmOCPP16Data->ChargeBoxId));
	json_object_object_add(payload, "chargePointModel",  json_object_new_string((const char *)ShmSysConfigAndInfo->SysConfig.ModelName));
	json_object_object_add(payload, "chargePointSerialNumber", json_object_new_string((const char *)ShmSysConfigAndInfo->SysConfig.SerialNumber));
	json_object_object_add(payload, "chargePointVendor",  json_object_new_string((const char *)ShmSysConfigAndInfo->SysConfig.chargePointVendor));
	json_object_object_add(payload, "firmwareVersion", json_object_new_string((const char *)ShmOCPP16Data->BootNotification.CpFwVersion));
	json_object_object_add(payload, "iccid", json_object_new_string((const char *)ShmOCPP16Data->BootNotification.CpIccid));
	json_object_object_add(payload, "imsi",  json_object_new_string((const char *)ShmOCPP16Data->BootNotification.CpImsi));
	json_object_object_add(payload, "meterSerialNumber",  json_object_new_string((const char *)ShmOCPP16Data->BootNotification.CpMeterSerialNumber));
	json_object_object_add(payload, "meterType",  json_object_new_string((const char *)ShmOCPP16Data->BootNotification.CpMeterType));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALL));

	random_uuid(guid);
	json_object_array_add(message, json_object_new_string(guid));
	json_object_array_add(message, json_object_new_string("BootNotification"));
	json_object_array_add(message, payload);


	Send(message);
	// Put request guid to hash map
	sprintf(mapItem->key_string, "%s", guid);
	sprintf(mapItem->key_value, "BootNotification,0");
	printf("BootNotification mapItem->key_string=%s\n",mapItem->key_string);
	printf("BootNotification mapItem->key_value=%s\n",mapItem->key_value);
	if(hashmap_operation(0,hashMap, mapItem->key_string, mapItem->key_value/*mapItem*/, (void**)(&mapItem)) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
	}

	printf("8-2\n");

	memset(queuedata, 0, strlen(queuedata));
	strcpy(queuedata,(char*)json_object_to_json_string(message));
	//addq(guid, queuedata);


	#ifdef SystemLogMessage
	DEBUG_INFO(">>>>>BootNotification request\n");
	DEBUG_INFO("Message: %s\n", SendBuffer);
	DEBUG_INFO("After push hash length: %d\n", hashmap_length(hashMap));
	#endif

    json_object_put(message); // Delete the json object
    //ShmOCPP16Data->SpMsg.bits.BootNotificationReq = 1;

	return result;
}

int sendDataTransferRequest(int gun_index)
{
	int result = FAIL;
	struct json_object *message, *payload, *data;
	char *senstr = NULL;
	char *temp = NULL;
	const char *del = ",";
	char guid[37];
	message = json_object_new_array();
	payload = json_object_new_object();
	data = json_object_new_object();
	json_object_object_add(payload, "vendorId", json_object_new_string("PhihongTechnology"));
	json_object_object_add(payload, "messageId", json_object_new_string("TestingMessage"));
	json_object_object_add(data, "data-1", json_object_new_string("data1 content"));
	json_object_object_add(data, "data-2", json_object_new_string("data2 content"));
	json_object_object_add(payload, "data", json_object_new_string(json_object_get_string(data)));

	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALL));
	random_uuid(guid);
	json_object_array_add(message, json_object_new_string(guid));
	json_object_array_add(message, json_object_new_string("DataTransfer"));
	json_object_array_add(message, payload);

	Send(message);

	// Put request guid to hash map
	if(mapItem == NULL)
	{
		mapItem = malloc(sizeof(data_struct_t));
		printf("mapItem is null\n");
	}

	if(guid == NULL || mapItem->key_string == NULL)
	{
		printf("guid is NULL \n");
	}

	if(mapItem->key_string == NULL)
	{
		printf("mapItem->key_string is NULL\n");
	}

	sprintf(mapItem->key_string, "%s", guid);
	sprintf(mapItem->key_value, "DataTransfer,%d", (gun_index + 1));
	printf("DataTransfer mapItem->key_string=%s\n", mapItem->key_string);
	printf("DataTransfer mapItem->key_value=%s\n", mapItem->key_value);

	if(hashmap_operation(0,hashMap, mapItem->key_string, mapItem->key_value/*mapItem*/, (void**)(&mapItem)) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
		printf("DataTransfer mapItem pass\n");
	}

	#ifdef SystemLogMessage
	DEBUG_INFO(">>>>>DataTransfer request\n");
	DEBUG_INFO("Message: %s\n", SendBuffer);
	DEBUG_INFO("After push hash length: %d\n", hashmap_length(hashMap));
	#endif

	json_object_put(message); // Delete the json object

	return result;
}

int sendDiagnosticsStatusNotificationRequest(char *status)
{
	int result = FAIL;
	char *str =	NULL;
	struct json_object *message, *payload;
	char guid[37];
	message = json_object_new_array();
	payload = json_object_new_object();
	printf("sendDiagnosticsStatusNotificationRequest \n");

	printf("DiagnosticsStatusNotification-1\n");
	printf("DiagnosticsStatusNotification.Status=%s\n", status);
	sprintf(ShmOCPP16Data->DiagnosticsStatusNotification.Status,"%s",(const char *)status);
	printf("DiagnosticsStatusNotification.Status=%s\n", str);
	json_object_object_add(payload, "status", json_object_new_string((const char *)status));
	printf("DiagnosticsStatusNotification-2\n");

	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALL));
	random_uuid(guid);
	json_object_array_add(message, json_object_new_string(guid));
	json_object_array_add(message, json_object_new_string("DiagnosticsStatusNotification"));
	json_object_array_add(message, payload);

	Send(message);

	if(mapItem == NULL)
	{
		mapItem = malloc(sizeof(data_struct_t));
		printf("mapItem is null\n");
	}

	if(guid == NULL || mapItem->key_string == NULL)
	{
		printf("guid is NULL \n");
	}

	if(mapItem->key_string == NULL)
	{
		printf("mapItem->key_string is NULL\n");
	}

	// Put request guid to hash map
	sprintf(mapItem->key_string, "%s", guid);
	sprintf(mapItem->key_value, "DiagnosticsStatusNotification,%d", 0);
	printf("DiagnosticsStatusNotification mapItem->key_string=%s\n", mapItem->key_string);
	printf("DiagnosticsStatusNotification mapItem->key_value=%s\n", mapItem->key_value);
	if(hashmap_operation(0,hashMap, mapItem->key_string, mapItem->key_value/*mapItem*/, (void**)(&mapItem)) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
		printf("DiagnosticsStatusNotification mapItem pass\n");
	}

	#ifdef SystemLogMessage
	DEBUG_INFO(">>>>>DiagnosticsStatusNotification request\n");
	DEBUG_INFO("Message: %s\n", SendBuffer);
	DEBUG_INFO("After push hash length: %d\n", hashmap_length(hashMap));
	#endif

	json_object_put(message); // Delete the json object
	ShmOCPP16Data->SpMsg.bits.DiagnosticsStatusNotificationReq = 1;
	ShmOCPP16Data->SpMsg.bits.DiagnosticsStatusNotificationConf = 0;
	return result;
}

int sendFirmwareStatusNotificationRequest(char *status)
{
	int result = FAIL;
	char *str =	NULL;
	struct json_object *message, *payload;
	char guid[37];
	message = json_object_new_array();
	payload = json_object_new_object();

	sprintf(ShmOCPP16Data->FirmwareStatusNotification.Status, "%s", (const char *)status);
	json_object_object_add(payload, "status", json_object_new_string((const char *)status));

	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALL));
	random_uuid(guid);
	json_object_array_add(message, json_object_new_string(guid));
	json_object_array_add(message, json_object_new_string("FirmwareStatusNotification"));
	json_object_array_add(message, payload);


	Send(message);

	if(mapItem == NULL)
	{
		mapItem = malloc(sizeof(data_struct_t));
		printf("mapItem is null\n");
	}

	if(guid == NULL || mapItem->key_string == NULL)
	{
		printf("guid is NULL \n");
	}

	if(mapItem->key_string == NULL)
	{
		printf("mapItem->key_string is NULL\n");
	}


	// Put request guid to hash map
	sprintf(mapItem->key_string, "%s", guid);
	sprintf(mapItem->key_value, "FirmwareStatusNotification,%d", 0);
	printf("FirmwareStatusNotification mapItem->key_string=%s\n", mapItem->key_string);
	printf("FirmwareStatusNotification mapItem->key_value=%s\n", mapItem->key_value);
	if(hashmap_operation(0,hashMap, mapItem->key_string, mapItem->key_value/*mapItem*/, (void**)(&mapItem)) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
		printf("FirmwareStatusNotification mapItem pass\n");
	}

	#ifdef SystemLogMessage
	DEBUG_INFO(">>>>>FirmwareStatusNotification request\n");
	DEBUG_INFO("Message: %s\n", SendBuffer);
	DEBUG_INFO("After push hash length: %d\n", hashmap_length(hashMap));
	#endif

	json_object_put(message); // Delete the json object
	ShmOCPP16Data->SpMsg.bits.FirmwareStatusNotificationReq = 1;
	ShmOCPP16Data->SpMsg.bits.FirmwareStatusNotificationConf = 0;
	return result;
}

int sendHeartbeatRequest(int gun_index)
{
	int result = FAIL;
	struct json_object *message, *payload;
	char *senstr = NULL;
	char *temp = NULL;
	const char *del = ",";
	char guid[37];
	message = json_object_new_array();
	payload = json_object_new_object();


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALL));
	random_uuid(guid);
	json_object_array_add(message, json_object_new_string(guid));
	json_object_array_add(message, json_object_new_string("Heartbeat"));
	json_object_array_add(message, payload);

	Send(message);

	if(mapItem == NULL)
	{
		mapItem = malloc(sizeof(data_struct_t));
		printf("mapItem is null\n");
	}

	if(guid == NULL || mapItem->key_string == NULL)
	{
		printf("guid is NULL \n");
	}

	if(mapItem->key_string == NULL)
	{
		printf("mapItem->key_string is NULL\n");
	}

	sprintf(mapItem->key_string, "%s", guid);
	sprintf(mapItem->key_value, "Heartbeat,%d", 0);

	printf("Heartbeat mapItem->key_string=%s\n", mapItem->key_string);
	printf("Heartbeat mapItem->key_value=%s\n", mapItem->key_value);
	if(hashmap_operation(0,hashMap, mapItem->key_string, mapItem->key_value/*mapItem*/, (void**)(&mapItem)) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
		printf("Heartbeat mapItem\n");
	}


	#ifdef SystemLogMessage
	DEBUG_INFO(">>>>>Heartbeat request\n");
	DEBUG_INFO("Message: %s\n", SendBuffer);
	DEBUG_INFO("After push hash length: %d\n", hashmap_length(hashMap));
	#endif

	json_object_put(message);

	return result;
}

int sendStartTransactionRequest(int gun_index)
{
	int result = FAIL;
	struct json_object *message, *payload;
	char *senstr = NULL;
	char *temp = NULL;
	const char *del = ",";
	char guid[37];
	struct timeval tmnow;
	struct tm *tm;
	char buf[30], usec_buf[6];

	message = json_object_new_array();
	payload = json_object_new_object();

	gettimeofday(&tmnow, NULL);

	time_t t;
	t = time(NULL);
	/*UTC time and date*/
	tm = gmtime(&t);
	strftime(buf,30,"%Y-%m-%dT%H:%M:%S", tm);
	strcat(buf,".");
	sprintf(usec_buf,"%dZ",(int)tmnow.tv_usec);
	strcat(buf,usec_buf);
	printf("%s",buf);

    // set value
	ShmOCPP16Data->StartTransaction[gun_index].ConnectorId = gun_index +1 ; // gun start from 1~
	strcpy(ShmOCPP16Data->StartTransaction[gun_index].Timestamp, buf);
	strcpy(ShmOCPP16Data->StartTransaction[gun_index].IdTag, ShmSysConfigAndInfo->SysConfig.UserId);


	for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	{
		printf("ShmSysConfigAndInfo->SysInfo.ChademoChargingData[%d].Index=%d\n",index, ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index );
		if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
		{
			printf("Chademo : 0\n");
#if 1 // for test
			ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargedEnergy =100.0;
#endif
			ShmOCPP16Data->StartTransaction[gun_index].MeterStart = ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargedEnergy;
		}
	}

	for (int index = 0; index < CCS_QUANTITY; index++)
	{
		printf("ShmSysConfigAndInfo->SysInfo.CcsChargingData[%d].Index=%d\n",index, ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index );
		if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
		{
			printf("Ccs : 0\n");
#if 1 // fo test
			ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargedEnergy = 100.0;
#endif
			ShmOCPP16Data->StartTransaction[gun_index].MeterStart = ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargedEnergy;
		}
	}

	for (int index = 0; index < GB_QUANTITY; index++)
	{
		printf("ShmSysConfigAndInfo->SysInfo.GbChargingData[%d].Index=%d\n",index, ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index );
		if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
		{
			printf("Gb : 0\n");
#if 1 // fo test
			ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargedEnergy = 100.0;
#endif
			ShmOCPP16Data->StartTransaction[gun_index].MeterStart = ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargedEnergy;
		}
	}



	//ShmOCPP16Data->StartTransaction[gun_index].MeterStart = 100;

	json_object_object_add(payload, "connectorId", json_object_new_int(ShmOCPP16Data->StartTransaction[gun_index].ConnectorId));
	json_object_object_add(payload, "idTag", json_object_new_string((const char *)ShmOCPP16Data->StartTransaction[gun_index].IdTag));
	json_object_object_add(payload, "meterStart", json_object_new_int(ShmOCPP16Data->StartTransaction[gun_index].MeterStart));
	json_object_object_add(payload, "reservationId", json_object_new_int(ShmOCPP16Data->StartTransaction[gun_index].ReservationId));
	json_object_object_add(payload, "timestamp", json_object_new_string((const char *)ShmOCPP16Data->StartTransaction[gun_index].Timestamp));
	printf("test  s 1\n");
	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALL));
	random_uuid(guid);
	json_object_array_add(message, json_object_new_string(guid));
	json_object_array_add(message, json_object_new_string("StartTransaction"));
	json_object_array_add(message, payload);

	Send(message);
	//usleep(500); // 等�??��?微�?
	printf("test  s 2\n");

	if(mapItem == NULL)
	{
	    	mapItem = malloc(sizeof(data_struct_t));
	    	printf("mapItem is null\n");
	}

	if(guid == NULL || mapItem->key_string == NULL)
	{
		printf("guid is NULL \n");
	}

	if(mapItem->key_string == NULL)
	{
		printf("mapItem->key_string is NULL\n");
	}
	// Put request guid to hash map
	sprintf(mapItem->key_string, "%s", guid);
	printf("test  s 2-0-1\n");

	sprintf(mapItem->key_value, "StartTransaction,%d", (gun_index));
	printf("test  s 2-0-2\n");
	printf("StartTransaction mapItem->key_string=%s\n",mapItem->key_string);
	printf("StartTransaction mapItem->key_value=%s\n",mapItem->key_value);


	if(hashmap_operation(0,hashMap, mapItem->key_string, mapItem->key_value/*mapItem*/, (void**)(&mapItem)) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		printf("test  s 2-1\n");
		result = PASS;
	}
	printf("test  s 3\n");

	strcpy(queuedata, (char*)json_object_to_json_string(message));
	queue_operation(4, guid, queuedata );//addq(guid, queuedata); ---> remove temporally
	#ifdef SystemLogMessage
	DEBUG_INFO(">>>>>StartTransaction request\n");
	DEBUG_INFO("Message: %s\n", SendBuffer);
	DEBUG_INFO("After push hash length: %d\n", hashmap_length(hashMap));
	#endif

	json_object_put(message);

	return result;
}

int sendStatusNotificationRequest(int gun_index)
{
	int result = FAIL;
	struct json_object *message, *payload;
	char *senstr = NULL;
	char *temp = NULL;
	const char *del = ",";
	char guid[37];
	int currentStatus = 0;
	struct timeval tmnow;
	struct tm *tm;
	char buf[30], usec_buf[6];

	message = json_object_new_array();
	payload = json_object_new_object();

	gettimeofday(&tmnow, NULL);

	time_t t;
	t = time(NULL);
	/*UTC time and date*/
	tm = gmtime(&t);
	strftime(buf,30,"%Y-%m-%dT%H:%M:%S", tm);
	strcat(buf,".");
	sprintf(usec_buf,"%dZ",(int)tmnow.tv_usec);
	strcat(buf,usec_buf);
	printf("%s",buf);

	ShmOCPP16Data->StatusNotification[gun_index].ConnectorId = (gun_index + 1);

	strcpy(ShmOCPP16Data->StatusNotification[gun_index].ErrorCode, "NoError");

	// it's option
	strcpy(ShmOCPP16Data->StatusNotification[gun_index].Info, "");

	/*
	 enum _SYSTEM_STATUS
{
S_BOOTING               = 0,
S_IDLE,                 = 1
S_AUTHORIZING,          =2
S_REASSIGN_CHECK,       =3
S_REASSIGN,             =4
S_PRECHARGE,            =5
S_PREPARING_FOR_EV,     =6
S_PREPARING_FOR_EVSE,   =7
S_CHARGING,             =8
S_TERMINATING,          =9
S_COMPLETE,             =10
S_ALARM,                =11
S_FAULT                 =12
}

    */



	//check Transaction active
	for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	{
		if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 1)) //S_IDLE
		{
			strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Available");
			currentStatus = 0;
		}
		else if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 5)) //S_PRECHARGE
		{
			strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Preparing");
			currentStatus = 1;
		}
		else if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 8)) //S_CHARGING
		{
			strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Charging");
			currentStatus = 2;
		}
	}

	for (int index = 0; index < CCS_QUANTITY; index++)
	{
		if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 1)) //S_IDLE
		{
			strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Available");
			currentStatus = 0;
		}
		else if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 5)) //S_PRECHARGE
		{
			strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Preparing");
			currentStatus = 1;
		}
		else if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 8)) //S_CHARGING
		{
			strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Charging");
			currentStatus = 2;
		}
	}

	for (int index = 0; index < GB_QUANTITY; index++)
	{
		if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index) &&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 1)) //S_IDLE
		{
			strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Available");
			currentStatus = 0;
		}
		else if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index) &&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 5)) //S_PRECHARGE
		{
			strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Preparing");
			currentStatus = 1;
		}
		else if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 8)) //S_CHARGING
		{
			strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Charging");
			currentStatus = 2;
		}
	}


	//it's option
	strcpy(ShmOCPP16Data->StatusNotification[gun_index].Timestamp, buf);
	strcpy(ShmOCPP16Data->StatusNotification[gun_index].VendorId, "PhihongTechnology");
	strcpy(ShmOCPP16Data->StatusNotification[gun_index].VendorErrorCode, "000000");
	strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[currentStatus]);

	json_object_object_add(payload, "connectorId", json_object_new_int(ShmOCPP16Data->StatusNotification[gun_index].ConnectorId));
	json_object_object_add(payload, "errorCode", json_object_new_string((const char *)(&ShmOCPP16Data->StatusNotification[gun_index].ErrorCode)));
	json_object_object_add(payload, "info", json_object_new_string((const char *)ShmOCPP16Data->StatusNotification[gun_index].Info));
	json_object_object_add(payload, "status", json_object_new_string((const char *)ShmOCPP16Data->StatusNotification[gun_index].Status));
	json_object_object_add(payload, "timestamp", json_object_new_string((const char *)ShmOCPP16Data->StatusNotification[gun_index].Timestamp));
	json_object_object_add(payload, "vendorId", json_object_new_string((const char *)ShmOCPP16Data->StatusNotification[gun_index].VendorId));
	json_object_object_add(payload, "vendorErrorCode", json_object_new_string((const char *)ShmOCPP16Data->StatusNotification[gun_index].VendorErrorCode));

	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALL));
	random_uuid(guid);
	json_object_array_add(message, json_object_new_string(guid));
	json_object_array_add(message, json_object_new_string("StatusNotification"));
	json_object_array_add(message, payload);

	Send(message);
	//usleep(500); // 等�??��?微�?
	// Put request guid to hash map
	if(mapItem == NULL)
	{
		mapItem = malloc(sizeof(data_struct_t));
		printf("mapItem is null\n");
	}


	sprintf(mapItem->key_string, "%s", guid);
	sprintf(mapItem->key_value, "StatusNotification,%d", (gun_index));
	//sprintf(mapItem->key_value, "StatusNotification,%d", gun_index + 1);

	printf("statusNotification mapItem->key_string=%s\n",mapItem->key_string);
	printf("statusNotification mapItem->key_value=%s\n",mapItem->key_value);
	if(hashmap_operation(0,hashMap, mapItem->key_string, mapItem->key_value/*mapItem*/, (void**)(&mapItem)) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		printf("statusNotification mapitem pass");
		result = PASS;
	}

	#ifdef SystemLogMessage
	DEBUG_INFO(">>>>>StatusNotification request\n");
	DEBUG_INFO("Message: %s\n", SendBuffer);
	DEBUG_INFO("After push hash length: %d\n", hashmap_length(hashMap));
	#endif

	json_object_put(message);

	cpinitateMsg.bits[gun_index].StatusNotificationReq = 0;


	//for test
#if 0
	// 0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault
	if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[0].SystemStatus =='1' )
	{
		//ShmOCPP16Data->SpMsg.bits.AuthorizeReq = 1;
	}

	if(UserPlugGun == 0 && ShmSysConfigAndInfo->SysInfo.ChademoChargingData[0].SystemStatus == '3')
	{
		ShmSysConfigAndInfo->SysInfo.ChademoChargingData[0].SystemStatus = '1';
	}
#endif

	return result;
}

int sendStopTransactionRequest(int gun_index)
{
	int result = FAIL;
	struct json_object *message, *payload, *transactionDataArray, *transactionData, *sampledArray, *sampledValue;
	char *senstr = NULL;
	char *temp = NULL;
	const char *del = ",";
	char guid[37];
	int idx_sample=0;
	message = json_object_new_array();
	payload = json_object_new_object();
	transactionDataArray = json_object_new_array();
	sampledArray = json_object_new_array();

	printf("sendStopTransactionRequest \n");

	strcpy(ShmOCPP16Data->StopTransaction[gun_index].IdTag, ShmOCPP16Data->Authorize.IdTag);

	//ENERGY_ACTIVE_IMPORT_REGISTER
	for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
		{
			//for test
			ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargedEnergy =100.0;

			ShmOCPP16Data->StopTransaction[gun_index].MeterStop = ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargedEnergy;
				//sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%s" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargedEnergy );
		}
	}

	for (int index = 0; index < CCS_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
		{
			//for test
			ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargedEnergy = 100.0;

			ShmOCPP16Data->StopTransaction[gun_index].MeterStop = ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargedEnergy;
				//sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%s" ,ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargedEnergy );
		}
	}

	for (int index = 0; index < GB_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
		{
			// for test
			ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargedEnergy = 100.0;

			ShmOCPP16Data->StopTransaction[gun_index].MeterStop = ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargedEnergy;
				//sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%f" ,ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargedEnergy);
		}
	}


	struct timeval tmnow;
	struct tm *tm;
	char buf[30], usec_buf[6];
	gettimeofday(&tmnow, NULL);

	time_t t;
	t = time(NULL);
	/*UTC time and date*/
	tm = gmtime(&t);
	strftime(buf,30,"%Y-%m-%dT%H:%M:%S", tm);
	strcat(buf,".");
	sprintf(usec_buf,"%dZ",(int)tmnow.tv_usec);
	strcat(buf,usec_buf);
	printf("%s",buf);

	//strcpy(ShmOCPP16Data->StopTransaction[gun_index].Timestamp,"2019-05-04T18:15:33Z");
	strcpy(ShmOCPP16Data->StopTransaction[gun_index].Timestamp,buf);
	ShmOCPP16Data->StopTransaction[gun_index].TransactionId = ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId;
	strcpy(ShmOCPP16Data->StopTransaction[gun_index].StopReason, StopTransactionReasonStr[Local]); //

	json_object_object_add(payload, "idTag", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].IdTag));
    json_object_object_add(payload, "meterStop", json_object_new_int(ShmOCPP16Data->StopTransaction[gun_index].MeterStop));
	json_object_object_add(payload, "timestamp", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].Timestamp));
	json_object_object_add(payload, "transactionId", json_object_new_int(ShmOCPP16Data->StopTransaction[gun_index].TransactionId));
	json_object_object_add(payload, "reason", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason));



	printf("sendStopTransactionRequest 1\n");
	ShmOCPP16Data->StopTransaction[gun_index].TransactionData[0].SampledValue = (struct StructSampledValue *)malloc(sizeof(struct StructSampledValue)*3);

	for(int idx_transaction=0;idx_transaction<1;idx_transaction++)
	{
		transactionData = json_object_new_object();
		//json_object_object_add(transactionData, "timestamp", json_object_new_string("2019-05-04T18:15:33Z"));

		strcpy(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].TimeStamp, buf/*"2019-05-04T18:15:33Z"*/);

		json_object_object_add(transactionData, "timestamp", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].TimeStamp));



		//for(int idx_sample=0;idx_sample<1;idx_sample++)
		{
			sampledValue = json_object_new_object();
			printf("sendStopTransactionRequest -2\n");

			//Transaction_Begin
			idx_sample=0;
			printf("ShmOCPP16Data->StartTransaction[gun_index].MeterStart=%d\n",ShmOCPP16Data->StartTransaction[gun_index].MeterStart);
			printf("ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value=%s\n",ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value);
			sprintf(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%d",ShmOCPP16Data->StartTransaction[gun_index].MeterStart);
			printf("sendStopTransactionRequest -2-1\n");
			strcpy(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,ReadingContextStr[ReadingContext_Transaction_Begin]);
			strcpy(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,ValueFormatStr[Raw]);
			strcpy(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,MeasurandStr[Energy_Active_Import_Register]);
			strcpy(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,PhaseStr[L1_N]);
			strcpy(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,LocationStr[Location_Outlet]);
			strcpy(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit,UnitOfMeasureStr[UnitOfMeasure_kWh]);

			printf("sendStopTransactionRequest -2-0\n");
			json_object_object_add(sampledValue, "value", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value));
			json_object_object_add(sampledValue, "context", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context));
			json_object_object_add(sampledValue, "format", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format));
		    json_object_object_add(sampledValue, "measurand", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand));
			json_object_object_add(sampledValue, "phase", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase));
			json_object_object_add(sampledValue, "location", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location));
			json_object_object_add(sampledValue, "unit", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit));

			json_object_array_add(sampledArray, sampledValue);

			//Transaction_End
			idx_sample=1;
			//sampledValue = NULL;
			sampledValue = json_object_new_object();
			//ENERGY_ACTIVE_IMPORT_REGISTER
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
				{
					// for test
					ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargingPower = 100.0;
					sprintf(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%f" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargedEnergy );
				}
			}

			for (int index = 0; index < CCS_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
				{
					// for test
					ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargingPower = 100.0;
					sprintf(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%f" ,ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargedEnergy );
				}
			}

			for (int index = 0; index < GB_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
				{
					// for test
					ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargingPower = 100.0;
					sprintf(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%f" ,ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargedEnergy );
				}
			}



			//sprintf(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%s",ShmOCPP16Data->StartTransaction[gun_index].MeterStart);
			printf("sendStopTransactionRequest -2-1\n");
			strcpy(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,ReadingContextStr[ReadingContext_Transaction_End]);
			strcpy(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,ValueFormatStr[Raw]);
			strcpy(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,MeasurandStr[Energy_Active_Import_Register]);
			strcpy(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,PhaseStr[L1_N]);
			strcpy(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,LocationStr[Location_Outlet]);
			strcpy(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit,UnitOfMeasureStr[UnitOfMeasure_kWh]);

			printf("sendStopTransactionRequest -2-0\n");
			json_object_object_add(sampledValue, "value", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value));
			json_object_object_add(sampledValue, "context", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context));
			json_object_object_add(sampledValue, "format", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format));
			json_object_object_add(sampledValue, "measurand", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand));
			json_object_object_add(sampledValue, "phase", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase));
			json_object_object_add(sampledValue, "location", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location));
			json_object_object_add(sampledValue, "unit", json_object_new_string((const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit));

			json_object_array_add(sampledArray, sampledValue);
		}
		printf("sendStopTransactionRequest -2-1\n");
		json_object_object_add(transactionData, "sampledValue", sampledArray);
		json_object_array_add(transactionDataArray, transactionData);
	}

	printf("sendStopTransactionRequest -3\n");
	json_object_object_add(payload, "transactionData", transactionDataArray);

	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALL));
	random_uuid(guid);
	json_object_array_add(message, json_object_new_string(guid));
	json_object_array_add(message, json_object_new_string("StopTransaction"));
	json_object_array_add(message, payload);

	Send(message);


	if(mapItem == NULL)
	{
		mapItem = malloc(sizeof(data_struct_t));
		printf("mapItem is null\n");
	}

	// Put request guid to hash map
	sprintf(mapItem->key_string, "%s", guid);
	sprintf(mapItem->key_value, "StopTransaction,%d", (gun_index));
	printf("StopTransaction mapItem->key_string=%s\n",mapItem->key_string);
	printf("StopTransaction mapItem->key_value=%s\n",mapItem->key_value);
	//sprintf(mapItem->key_value, senstr);//sprintf(mapItem->key_value, "StopTransaction");
	if(hashmap_operation(0,hashMap, mapItem->key_string, mapItem->key_value/*mapItem*/, (void**)(&mapItem)) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
		printf("StopTransaction mapitem pass");
	}


	strcpy(queuedata, (char*)json_object_to_json_string(message));
	queue_operation(4, guid, queuedata );//addq(guid, queuedata); ---> remove temporally

	//addq(guid, (char*)json_object_to_json_string(message));
	#ifdef SystemLogMessage
	DEBUG_INFO(">>>>>StopTransaction request\n");
	DEBUG_INFO("Message: %s\n", SendBuffer);
	DEBUG_INFO("After push hash length: %d\n", hashmap_length(hashMap));
	#endif

	json_object_put(message);

	//for test
	ShmOCPP16Data->CpMsg.bits[gun_index].StopTransactionReq = 0;

	return result;
}

int sendMeterValuesRequest(int gun_index)
{
	int result = FAIL;
	struct json_object *message, *payload, *meterValueDataArray, *transactionData, *sampledArray, *sampledValue;
	char *senstr = NULL;
	char *temp = NULL;
	const char *del = ",";
	char guid[37];
	int idx_sample=0;

	message = json_object_new_array();
	payload = json_object_new_object();
	meterValueDataArray = json_object_new_array();
	sampledArray = json_object_new_array();

	//set value
	ShmOCPP16Data->MeterValues[gun_index].ConnectorId = gun_index + 1; // gun start from 1~
	//ShmOCPP16Data->MeterValues[gun_index].TransactionId = 93507754;
	ShmOCPP16Data->MeterValues[gun_index].TransactionId = ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId;

	json_object_object_add(payload, "connectorId", json_object_new_int(ShmOCPP16Data->MeterValues[gun_index].ConnectorId));
	json_object_object_add(payload, "transactionId", json_object_new_int(ShmOCPP16Data->MeterValues[gun_index].TransactionId));

	printf("enter sendMeterValuesRequest -2\n");

	for(int idx_transaction=0;idx_transaction<1;idx_transaction++)
	{
		transactionData = json_object_new_object();
		//allocate memory space
		ShmOCPP16Data->MeterValues[gun_index].MeterValue = (struct StructMeterValue *)malloc(sizeof(struct StructMeterValue));

		//UTC Date time
		struct timeval tmnow;
		struct tm *tm;
		char buf[30], usec_buf[6];
		gettimeofday(&tmnow, NULL);

		time_t t;
		t = time(NULL);
		/*UTC time and date*/
		tm = gmtime(&t);
		strftime(buf,30,"%Y-%m-%dT%H:%M:%S", tm);
		strcat(buf,".");
		sprintf(usec_buf,"%dZ",(int)tmnow.tv_usec);
		strcat(buf,usec_buf);
		printf("%s",buf);

		strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].TimeStamp, buf);
		json_object_object_add(transactionData, "timestamp", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].TimeStamp));

		//allocate memory space
	    ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue = (struct StructSampledValue *)malloc(sizeof(struct StructSampledValue)*5);


		//for(int idx_sample=0;idx_sample<1;idx_sample++)
		//{

	sampledValue = json_object_new_object();

#if 1  //DC

	/****************************************************(1)ENERGY_ACTIVE_IMPORT_REGISTER*********************************************/
	for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	{
		printf("ShmSysConfigAndInfo->SysInfo.ChademoChargingData[%d].Index=%d\n",index, ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index );
		if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
		{
			printf("Chademo : 0\n");
			ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargedEnergy =100.0;
			sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%f" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargedEnergy );
		}
	}

	for (int index = 0; index < CCS_QUANTITY; index++)
	{
		printf("ShmSysConfigAndInfo->SysInfo.CcsChargingData[%d].Index=%d\n",index, ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index );
		if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
		{
			printf("Ccs : 0\n");
			ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargedEnergy = 100.0;
			sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%f" ,ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargedEnergy );
		}
	}

	for (int index = 0; index < GB_QUANTITY; index++)
	{
		printf("ShmSysConfigAndInfo->SysInfo.GbChargingData[%d].Index=%d\n",index, ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index );
		if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
		{
			printf("Gb : 0\n");
			ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargedEnergy = 100.0;
			sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%f" ,ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargedEnergy);
		}
	}

	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context, ReadingContextStr[ReadingContext_Sample_Periodic]);
    strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format, ValueFormatStr[Raw]);
    strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand, MeasurandStr[Energy_Active_Import_Register]);
         //   strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase, PhaseStr[L1]);
    strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location, LocationStr[Location_Outlet]);
    strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit,UnitOfMeasureStr[UnitOfMeasure_Wh]);


    printf("meter error 1\n");
    json_object_object_add(sampledValue, "value", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value));
	printf("meter error 2\n");
	json_object_object_add(sampledValue, "context", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context));
	printf("meter error 3\n");
	json_object_object_add(sampledValue, "format", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format));
	printf("meter error 4\n");
	json_object_object_add(sampledValue, "measurand", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand));
	//	json_object_object_add(sampledValue, "phase", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase));
	printf("meter error 5\n");
	json_object_object_add(sampledValue, "location", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location));
	printf("meter error 6\n");
	json_object_object_add(sampledValue, "unit", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit));
	printf("meter error 7\n");
	json_object_array_add(sampledArray, sampledValue);
	printf("meter error 8\n");


	idx_sample=1;
	//sampledValue = NULL;
	sampledValue = json_object_new_object();
	/***********************************************(2)VOLTAGE******************************************************/
	for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
		{
			ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargingVoltage = 80.0;
			sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%f" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargingVoltage );
		}
	}

	for (int index = 0; index < CCS_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
		{
			ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargingVoltage = 80.0;
			sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%f" ,ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargingVoltage );
		}
	}

	for (int index = 0; index < GB_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
		{
			ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargingVoltage = 80.0;
			sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%f" ,ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargingVoltage );
		}
	}

	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context, ReadingContextStr[ReadingContext_Sample_Periodic]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format, ValueFormatStr[Raw]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand, MeasurandStr[Voltage]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase, PhaseStr[L1_N]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location, LocationStr[Location_Outlet]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit,UnitOfMeasureStr[UnitOfMeasure_V]);

	printf("meter error 9\n");
	json_object_object_add(sampledValue, "value", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value));
	printf("meter error 10\n");
	json_object_object_add(sampledValue, "context", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context));
	printf("meter error 11\n");
	json_object_object_add(sampledValue, "format", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format));
	printf("meter error 12\n");
	json_object_object_add(sampledValue, "measurand", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand));
	printf("meter error 13\n");
	json_object_object_add(sampledValue, "phase", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase));
	printf("meter error 14\n");
	json_object_object_add(sampledValue, "location", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location));
	printf("meter error 15\n");
	json_object_object_add(sampledValue, "unit", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit));
	printf("meter error 16\n");
	json_object_array_add(sampledArray, sampledValue);


	idx_sample=2;
	//sampledValue = NULL;
	sampledValue = json_object_new_object();
	/********************************(3)Current************************************************/
	for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
		{
			ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargingCurrent = 60.0;
			sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%f" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargingCurrent );
		}
	}

	for (int index = 0; index < CCS_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
		{
			ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargingCurrent = 60.0;
			sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%f" ,ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargingCurrent );
		}
	}

	for (int index = 0; index < GB_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
		{
			ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargingCurrent = 60.0;
			sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%f" ,ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargingCurrent );
		}
	}

	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context, ReadingContextStr[ReadingContext_Sample_Periodic]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format, ValueFormatStr[Raw]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand, MeasurandStr[Current_Import]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase, PhaseStr[L1_N]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location, LocationStr[Location_Outlet]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit,UnitOfMeasureStr[UnitOfMeasure_A]);

	printf("meter error 17\n");
	json_object_object_add(sampledValue, "value", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value));
	printf("meter error 18\n");
	json_object_object_add(sampledValue, "context", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context));
	printf("meter error 19\n");
	json_object_object_add(sampledValue, "format", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format));
	printf("meter error 20\n");
	json_object_object_add(sampledValue, "measurand", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand));
	printf("meter error 21\n");
	json_object_object_add(sampledValue, "phase", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase));
	printf("meter error 22\n");
	json_object_object_add(sampledValue, "location", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location));
	printf("meter error 23\n");
	json_object_object_add(sampledValue, "unit", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit));
	printf("meter error 24\n");
	json_object_array_add(sampledArray, sampledValue);
	printf("meter error 25\n");



	idx_sample=3;
	//sampledValue = NULL;
	sampledValue = json_object_new_object();
	/********************************(4)Power.Active.Import************************************************/
	for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
		{
			ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargingPower = 100.0;
			sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%f" , ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargingPower);
		}
	}

	for (int index = 0; index < CCS_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
		{
			ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargingPower = 100.0;
			sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%f" , ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargingPower);
		}
	}

	for (int index = 0; index < GB_QUANTITY; index++)
	{
		if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
		{
			ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargingPower = 100.0;
			sprintf(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%f" , ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargingPower);
		}
	}

	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context, ReadingContextStr[ReadingContext_Sample_Periodic]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format, ValueFormatStr[Raw]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand, MeasurandStr[Power_Active_Import]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase, PhaseStr[L1_N]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location, LocationStr[Location_Outlet]);
	strcpy(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit,UnitOfMeasureStr[UnitOfMeasure_A]);

	printf("meter error 35\n");
	json_object_object_add(sampledValue, "value", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value));
	printf("meter error 36\n");
	json_object_object_add(sampledValue, "context", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context));
	printf("meter error 37\n");
	json_object_object_add(sampledValue, "format", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format));
	printf("meter error 38\n");
	json_object_object_add(sampledValue, "measurand", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand));
	printf("meter error 39\n");
	json_object_object_add(sampledValue, "phase", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase));
	printf("meter error 40\n");
	json_object_object_add(sampledValue, "location", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location));
	printf("meter error 41\n");
	json_object_object_add(sampledValue, "unit", json_object_new_string((const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit));
	printf("meter error 42\n");
	json_object_array_add(sampledArray, sampledValue);
	printf("meter error 43\n");

#endif
		//}
			json_object_object_add(transactionData, "sampledValue", sampledArray);
			json_object_array_add(meterValueDataArray, transactionData);
	}
	json_object_object_add(payload, "meterValue", meterValueDataArray);

	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALL));
	random_uuid(guid);
	json_object_array_add(message, json_object_new_string(guid));
	json_object_array_add(message, json_object_new_string("MeterValues"));
	json_object_array_add(message, payload);

	printf("enter sendMeterValuesRequest -3\n");
	printf("before send message=%s\n",json_object_to_json_string(message));
	Send(message);

	if(mapItem == NULL)
	 {
		mapItem = malloc(sizeof(data_struct_t));
		printf("mapItem is null\n");
	}

	if(guid == NULL || mapItem->key_string == NULL)
	{
		printf("guid is NULL \n");
	}

	if(mapItem->key_string == NULL)
	{
		printf("mapItem->key_string is NULL\n");
	}

	printf("enter sendMeterValuesRequest -4\n");
	// Put request guid to hash map
	sprintf(mapItem->key_string, "%s", guid);
	sprintf(mapItem->key_value, "MeterValues,%d", (gun_index));
	//sprintf(mapItem->key_value, senstr);//sprintf(mapItem->key_value, "StopTransaction");
	if(hashmap_operation(0,hashMap, mapItem->key_string, mapItem->key_value/*mapItem*/, (void**)(&mapItem)) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
		printf("MeterValues mapitem pass");
	}


	strcpy(queuedata, (char*)json_object_to_json_string(message));
	queue_operation(4, guid, queuedata );//addq(guid, queuedata);  ---> remove temporally
	printf("enter sendMeterValuesRequest -5\n");

	//addq(guid, (char*)json_object_to_json_string(message));
	#ifdef SystemLogMessage
	DEBUG_INFO(">>>>>MeerValues request\n");
	DEBUG_INFO("Message: %s\n", SendBuffer);
	DEBUG_INFO("After push hash length: %d\n", hashmap_length(hashMap));
	#endif

	json_object_put(message);
	return result;

}


//==========================================
// send confirm routine
//==========================================
int sendCancelReservationConfirmation(char *uuid,char *payload)
{
	int result = FAIL;

	struct json_object *message, *comfirmpayload;
	char guid[37];

	printf("handle CancelReservationRequest\n");
	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "status", json_object_new_string((const char *)payload));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);


	Send(message);

	json_object_put(message);


	return result;
}

int sendChangeAvailabilityConfirmation(char *uuid,char *payload)
{
	int result = FAIL;

	struct json_object *message, *comfirmpayload;
	char guid[37];

	printf("handle sendChangeAvailabilityConfirmation\n");
	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "status", json_object_new_string((const char *)payload));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);


	Send(message);

	json_object_put(message);

	return result;
}

int sendChangeConfigurationConfirmation(char *uuid,char *payload)
{
	int result = FAIL;

	struct json_object *message, *comfirmpayload;
	char guid[37];

	printf("handle sendChangeConfigurationConfirmation\n");
	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "status", json_object_new_string((const char *)payload));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

    json_object_array_add(message, comfirmpayload);

    printf("handle sendChangeConfigurationConfirmation -1\n");
	Send(message);
	printf("handle sendChangeConfigurationConfirmation- 2\n");
	json_object_put(message);

	return result;
}

int sendClearCacheConfirmation(char *uuid,char *payload)
{
	int result = FAIL;

	struct json_object *message, *comfirmpayload;
	char guid[37];

	printf("sendClearCacheConfirmation\n");
	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "status", json_object_new_string((const char *)payload));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

    json_object_array_add(message, comfirmpayload);

	Send(message);
	json_object_put(message);

	return result;
}

int sendClearChargingProfileConfirmation(char *uuid,char *payload)
{
	int result = FAIL;

	struct json_object *message, *comfirmpayload;
	char guid[37];

	printf("sendClearChargingProfileConfirmation\n");
	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "status", json_object_new_string((const char *)payload));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

    json_object_array_add(message, comfirmpayload);


	Send(message);

	json_object_put(message);


	return result;
}

int sendDataTransferConfirmation(char *uuid,char *payload)
{
	int result = FAIL;

	struct json_object *obj;
	char guid[37];
	obj = json_tokener_parse(payload);
	printf("handle   DataTransferRequest\n");

	return result;
}

int sendGetCompositeScheduleConfirmation(char *uuid,char *payload, int connectorIdInt,int nPeriod)
{
	int result = FAIL;


	struct json_object *message, *comfirmpayload, *chargingSchedule, *sampledArray, *sampledValue;

	printf("handle sendGetCompositeScheduleConfirmation\n");
	message = json_object_new_array();

	comfirmpayload = json_object_new_object();
	chargingSchedule  = json_object_new_object();

	json_object_object_add(comfirmpayload, "status", json_object_new_string((const char *)payload));
	json_object_object_add(comfirmpayload, "connectorId ", json_object_new_int(connectorIdInt));
	json_object_object_add(comfirmpayload, "scheduleStart", json_object_new_string((const char *)ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.StartSchedule));


	json_object_object_add(chargingSchedule, "duration", json_object_new_int(ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.Duration) );
	json_object_object_add(chargingSchedule, "startSchedule", json_object_new_string((const char *)ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.StartSchedule) );
	json_object_object_add(chargingSchedule, "chargingRateUnit", json_object_new_string((const char *)ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingRateUnit) );


	sampledArray = json_object_new_array();
	int len = nPeriod;//sizeof(ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod)/sizeof(ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[0]);

	printf("sendGetCompositeScheduleConfirmation nPeriod =%d\n", len);
	for(int idx_sample=0;idx_sample< len;idx_sample++)
	{
		sampledValue = json_object_new_object();

		json_object_object_add(sampledValue, "startPeriod", json_object_new_int(ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[0].StartPeriod));
		json_object_object_add(sampledValue, "limit", json_object_new_double((double)ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[0].Limit));
		json_object_object_add(sampledValue, "numberPhases", json_object_new_int(ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[0].NumberPhases));

		json_object_array_add(sampledArray, sampledValue);
	}

	json_object_object_add(chargingSchedule, "chargingSchedulePeriod", sampledArray);

	json_object_object_add(chargingSchedule, "minChargingRate ", json_object_new_double((double)ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.MinChargingRate) );


	json_object_object_add(comfirmpayload, "chargingSchedule", chargingSchedule );

	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

    json_object_array_add(message, comfirmpayload);


	Send(message);

	json_object_put(message);
	return result;
}

int sendGetConfigurationConfirmation(char *uuid)
{
	int result = FAIL;
	int MaxKeySupported = 0;

	struct json_object *message, *comfirmpayload, *configurationKeyArray, *unknownKeyArray, *sampledValue;

	printf("handle sendGetConfigurationConfirmation\n");
	message = json_object_new_array();

    comfirmpayload = json_object_new_object();


    configurationKeyArray = json_object_new_array();

    MaxKeySupported = atoi(ShmOCPP16Data->ConfigurationTable.CoreProfile[GetConfigurationMaxKeys].ItemData);
    printf("MaxKeySupported=%d\n",MaxKeySupported);
//	int configurationKeyArraylen = sizeof(ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey)/sizeof(ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[0]);
    sampledValue = json_object_new_object();
//	printf("configurationKeyArraylen =%d\n", configurationKeyArraylen);

    //configuration key
	for(int idx_sample=0;idx_sample< MaxKeySupported/*43*/;idx_sample++)
	{
		if(strcmp(ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].Key, "")!= 0)
		{
			printf("test test enter add configurationKey\n");


			printf("ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].Key=%s\n",ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].Key);
			printf("ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].ReadOnly=%d\n", atoi(ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].ReadOnly));
			printf("ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].Value=%s\n",ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].Value);

			json_object_object_add(sampledValue, "key", json_object_new_string((const char *)(ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].Key)));
			printf("error 1\n");
			json_object_object_add(sampledValue, "readonly", json_object_new_boolean(atoi(ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].ReadOnly)));
			printf("error 2\n");
			json_object_object_add(sampledValue, "value", json_object_new_string((const char *)(ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].Value)));
			printf("error 3\n");
			json_object_array_add(configurationKeyArray, sampledValue);
			printf("error 4\n");
		}

	}

	json_object_object_add(comfirmpayload, "configurationKey", configurationKeyArray );
	printf("error 5\n");

	unknownKeyArray = json_object_new_array();
	printf("error 6\n");
	//sampledValue = NULL;

	//unkown key
	for(int idx_sample=0;idx_sample< UnknownKeynum ;idx_sample++)
	{
		// json_object *jstring1 = json_object_new_string((const char *)((ShmOCPP16Data->GetConfiguration.ResponseUnknownKey + idx_sample)->Item));
		printf("unkown key:%s\n", ShmOCPP16Data->GetConfiguration.ResponseUnknownKey[idx_sample].Item);
		json_object *jstring1 = json_object_new_string((const char *)(ShmOCPP16Data->GetConfiguration.ResponseUnknownKey[idx_sample].Item));

		json_object_array_add(unknownKeyArray, jstring1);
	}
	printf("error 7\n");
	if(UnknownKeynum != 0)
	json_object_object_add(comfirmpayload, "unknownKey ", unknownKeyArray );

	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);
	printf("error 8\n");
	Send(message);
	if(UnknownKeynum == 0)
		json_object_put(unknownKeyArray);

	json_object_put(message);
	printf("error 9\n");

	return result;
}

int sendGetDiagnosticsConfirmation(char *uuid,char *payload)
{
	int result = FAIL;

	printf("handle     GetDiagnosticsRequest\n");

	struct json_object *message, *comfirmpayload;

	printf("handle sendChangeConfigurationConfirmation\n");
	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "fileName", json_object_new_string((const char *)payload));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);

	Send(message);
    json_object_put(message);

	return result;
}

int sendGetLocalListVersionConfirmation(char *uuid,char *payload)
{
	int result = FAIL;
	printf("handle    GetLocalListVersionRequest\n");
	struct json_object *message, *comfirmpayload;

	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "listVersion", json_object_new_int(ShmOCPP16Data->GetLocalListVersion.ResponseListVersion));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);

	Send(message);

	json_object_put(message);


	return result;
}

int sendRemoteStartConfirmation(char *uuid,char *payload)
{
	int result = FAIL;
	printf("handleRemoteStartRequest\n");
	struct json_object *message, *comfirmpayload;

	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "status", json_object_new_string(payload));

	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);


	Send(message);
	json_object_put(message);

	return result;
}

int sendRemoteStopTransactionConfirmation(char *uuid,char *payload)
{
	int result = FAIL;

	struct json_object *message, *comfirmpayload;
	printf("handleRemoteStopTransactionRequest\n");
	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "status", json_object_new_string(payload));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);


	Send(message);

	json_object_put(message);

	return result;
}

int sendReserveNowTransactionConfirmation(char *uuid,char *payload)
{
	int result = FAIL;

	struct json_object *message, *comfirmpayload;
	printf("sendReserveNowTransactionConfirmation\n");
	message = json_object_new_array();
	comfirmpayload = json_object_new_object();

	json_object_object_add(comfirmpayload, "status", json_object_new_string(payload));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);


	Send(message);
	json_object_put(message);

	return result;
}

int sendResetConfirmation(char *uuid,char *payload)
{
	int result = FAIL;

	struct json_object *message, *comfirmpayload;
	printf("sendResetConfirmation\n");
	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "status", json_object_new_string((const char *)payload));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);


	Send(message);

	json_object_put(message);

	return result;
}

int sendSendLocalListConfirmation(char *uuid,char *payload)
{
	int result = FAIL;
	struct json_object *message, *comfirmpayload;

	printf("handle sendSendLocalListConfirmation\n");
	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "status", json_object_new_string((const char *)payload));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);

	Send(message);

	json_object_put(message);

	return result;
}

int sendSetChargingProfileConfirmation(char *uuid,char *payload)
{
	int result = FAIL;

	printf("handleSetChargingProfileRequest\n");
	struct json_object *message, *comfirmpayload;

	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "status", json_object_new_string((const char *)payload));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);

	Send(message);

	json_object_put(message);

	return result;
}

int sendTriggerMessageConfirmation(char *uuid,char *payload)
{
	int result = FAIL;

	printf("sendTriggerMessageConfirmation\n");
	struct json_object *message, *comfirmpayload;

	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "status", json_object_new_string((const char *)payload));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);


	Send(message);

	json_object_put(message);
	return result;
}

int sendUnlockConnectorConfirmation(char *uuid,char *payload)
{
	int result = FAIL;

	printf("sendUnlockConnectorConfirmation\n");
	struct json_object *message, *comfirmpayload;

	message = json_object_new_array();
	comfirmpayload = json_object_new_object();
	json_object_object_add(comfirmpayload, "status", json_object_new_string((const char *)payload));


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);

	Send(message);

    json_object_put(message);

	return result;
}

int sendUpdateFirmwareConfirmation(char *uuid)
{
	int result = FAIL;

	printf("sendUpdateFirmwareConfirmation\n");
	struct json_object *message, *comfirmpayload;

	message = json_object_new_array();
	comfirmpayload = json_object_new_object();


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLRESULT));

	json_object_array_add(message, json_object_new_string(uuid));

	json_object_array_add(message, comfirmpayload);


	Send(message);

	json_object_put(message);

	return result;
}


//==========================================
// send CallError routine
//==========================================
void SendCallError(char *uniqueId, char *action, char *errorCode, char *errorDescription)
{


	#ifdef SystemLogMessage
	DEBUG_INFO("An error occurred. Sending this information: uniqueId {}: action: {}, errorCore: {}, errorDescription: {}\n",
            uniqueId, action, errorCode, errorDescription);
	#endif

	printf("SendCallError\n");
	struct json_object *message/*, *comfirmpayload*/;

	message = json_object_new_array();
	//comfirmpayload = json_object_new_object();


	json_object_array_add(message, json_object_new_int(MESSAGE_TYPE_CALLERROR));

	json_object_array_add(message, json_object_new_string(uniqueId));
	json_object_array_add(message, json_object_new_string(errorCode));
	json_object_array_add(message, json_object_new_string(errorDescription));

	json_object_array_add(message, json_object_new_string("{}"));


	Send(message);

	json_object_put(message);

}


//==========================================
// Handle server request routine  Start
//==========================================
#define GUN_NUM     1
int handleCancelReservationRequest(char *uuid, char *payload)
{
	int result = FAIL;
    int gunNO = 0;
	struct json_object *obj, *reservationId;
	int reservationIdInt =0;
	char comfirmstr[20];
	obj = json_tokener_parse(payload);
	printf("handle CancelReservationRequest\n");

	ShmOCPP16Data->CsMsg.bits[gunNO].CancelReservationReq = 1;

	reservationId = json_object_object_get(obj, "reservationId");
	reservationIdInt = json_object_get_int(reservationId);

	memset(comfirmstr, 0, sizeof comfirmstr);
	sprintf(comfirmstr, "%s", CancelReservationStatusStr[CancelReservationStatus_Rejected]);

	 //0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault, 8: Reserved, 9: maintain
	 //check Transaction active
	 for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	 {
		 if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].ReservationId == reservationIdInt)
		 {
			 sprintf(comfirmstr, "%s", CancelReservationStatusStr[CancelReservationStatus_Accepted] );
			 sprintf((char *)ShmOCPP16Data->CancelReservation[ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index].ResponseStatus, "%s", comfirmstr );
			 gunNO = ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index;
			 ShmOCPP16Data->CsMsg.bits[gunNO].CancelReservationReq = 1;
		 }
	  }

	  for (int index = 0; index < CCS_QUANTITY; index++)
	  {
		  if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].ReservationId == reservationIdInt)
		  {
			  sprintf(comfirmstr, "%s", CancelReservationStatusStr[CancelReservationStatus_Accepted] );
			  sprintf((char *)ShmOCPP16Data->CancelReservation[ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index].ResponseStatus, "%s", comfirmstr );
			  gunNO = ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index;
			  ShmOCPP16Data->CsMsg.bits[gunNO].CancelReservationReq = 1;
		  }
	  }

	  for (int index = 0; index < GB_QUANTITY; index++)
	  {
		  if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].ReservationId == reservationIdInt)
		  {
			  sprintf(comfirmstr, "%s", CancelReservationStatusStr[CancelReservationStatus_Accepted] );
			  sprintf((char *)ShmOCPP16Data->CancelReservation[ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index].ResponseStatus, "%s", comfirmstr );
			  gunNO = ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index;

			  ShmOCPP16Data->CsMsg.bits[gunNO].CancelReservationReq = 1;
		  }
	  }

	  // Fill in ocpp packet uuid
	  strcpy(ShmOCPP16Data->CancelReservation[gunNO].guid, uuid);
	  json_object_put(obj);
#if 0 // CSU Will do it.
	sendCancelReservationConfirmation(uuid, comfirmstr);
	ShmOCPP16Data->CsMsg.bits[gunNO].CancelReservationConf = 1;
#endif
	return result;
}

int handleChangeAvailabilityRequest(char *uuid, char *payload)
{
	int result = FAIL;
    int gunIndex = 0;
	struct json_object *obj, *connectorId, *type;
	char comfirmstr[20];
	int specificId = FALSE;

	obj = json_tokener_parse(payload);
	printf("handle ChangeAvailabilityRequest\n");

	connectorId = json_object_object_get(obj, "connectorId");
	type = json_object_object_get(obj, "type");

	gunIndex = json_object_get_int(connectorId);
	ShmOCPP16Data->ChangeAvailability[gunIndex - 1].ConnectorId= gunIndex;
	sprintf((char *)ShmOCPP16Data->ChangeAvailability[gunIndex - 1].Type, "%s", json_object_get_string(type)  );


	memset(comfirmstr, 0, sizeof comfirmstr);
	sprintf(comfirmstr, "%s", AvailabilityStatusStr[Rejected] );
	ShmOCPP16Data->CsMsg.bits[gunIndex - 1].ChangeAvailabilityReq = 1;

	if((gunIndex  == 0) || ((gunIndex - 1) < (CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY)))
	{
		specificId = TRUE;
	}

	if(specificId == FALSE)
		goto end;
	/*
	enum _SYSTEM_STATUS
	{
	S_BOOTING               = 0,
	S_IDLE,                 = 1
	S_AUTHORIZING,          =2
	S_REASSIGN_CHECK,       =3
	S_REASSIGN,             =4
	S_PRECHARGE,            =5
	S_PREPARING_FOR_EV,     =6
	S_PREPARING_FOR_EVSE,   =7
	S_CHARGING,             =8
	S_TERMINATING,          =9
	S_COMPLETE,             =10
	S_ALARM,                =11
	S_FAULT                 =12
	}
 	 */
	if(strcmp((const char *)ShmOCPP16Data->ChangeAvailability[gunIndex - 1].Type, AvailabilityTypeStr[Inoperative]) == 0)
	{

		//0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault, 8: Reserved, 9: maintain
	    //check Transaction active
	    for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	    {
	    	if ((gunIndex  == 0) || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == (gunIndex - 1)))
	    	{

	    		if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 5) // S_PRECHARGE
	    		{
	    			sprintf(comfirmstr, "%s", AvailabilityStatusStr[Rejected] );
	    		}
	    		else if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 8)  // S_CHARGING
	    		{
	    			sprintf(comfirmstr, "%s", AvailabilityStatusStr[Scheduled] );
	    		}
	    		else
	    		{
	    			sprintf(comfirmstr, "%s", AvailabilityStatusStr[Accepted] );
	    		}

	    		goto end;
	    	}
	    }

	    for (int index = 0; index < CCS_QUANTITY; index++)
	    {
	    	if ((gunIndex  == 0)|| (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == (gunIndex - 1)))
	    	{
	    		if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 5)// S_PRECHARGE
	    		{
	    			sprintf(comfirmstr, "%s", AvailabilityStatusStr[Rejected] );
	    		}
	    		else if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 8) // S_CHARGING
	    		{
	    			sprintf(comfirmstr, "%s", AvailabilityStatusStr[Scheduled] );
	    		}
	    		else
	    		{
	    			sprintf(comfirmstr, "%s", AvailabilityStatusStr[Accepted] );
	    		}


	    		goto end;
	    	}
	    }

	    for (int index = 0; index < GB_QUANTITY; index++)
	    {
	    	if ((gunIndex  == 0)||(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == (gunIndex - 1)))
	    	{
	    		if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 5) // S_PRECHARGE
	    		{
	    			sprintf(comfirmstr, "%s", AvailabilityStatusStr[Rejected] );
	    		}
	    		else if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 8) // S_CHARGING
	    		{
	    			sprintf(comfirmstr, "%s", AvailabilityStatusStr[Scheduled] );
	    		}
	    		else
	    		{
		    		sprintf(comfirmstr, "%s", AvailabilityStatusStr[Accepted] );
	    		}

	    		goto end;
	    	}
	    }

	}


	if(strcmp((const char *)ShmOCPP16Data->ChangeAvailability[gunIndex - 1].Type, AvailabilityTypeStr[Operative]) == 0)
	{

	    //0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault, 8: Reserved, 9: maintain
	    //check Transaction active
	    for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	    {
	    	if (((gunIndex  == 0)|| (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == (gunIndex - 1))) &&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus != 12))  //S_FAULT
	    	{
	    		ShmOCPP16Data->CsMsg.bits[gunIndex - 1].ChangeAvailabilityReq = 1;
	    		sprintf(comfirmstr, "%s", AvailabilityStatusStr[Accepted] );
	    		goto end;
	    	}
	    }

	    for (int index = 0; index < CCS_QUANTITY; index++)
	    {
	    	if (((gunIndex  == 0)|| (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == (gunIndex - 1)))&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus != 12)) //S_FAULT
	    	{
	    		ShmOCPP16Data->CsMsg.bits[gunIndex - 1].ChangeAvailabilityReq = 1;
	    		sprintf(comfirmstr, "%s", AvailabilityStatusStr[Accepted] );
	    		goto end;
	    	}
	    }

	    for (int index = 0; index < GB_QUANTITY; index++)
	    {
	    	if (((gunIndex  == 0)||(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == (gunIndex - 1)))&&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus != 12)) //S_FAULT
	    	{
	    		ShmOCPP16Data->CsMsg.bits[gunIndex - 1].ChangeAvailabilityReq = 1;
	    		sprintf(comfirmstr, "%s", AvailabilityStatusStr[Accepted] );
	    		goto end;
	    	}
	    }

	    //sprintf(comfirmstr, "%s", AvailabilityStatusStr[Rejected] );
	}

	end:
	json_object_put(obj);
	sprintf((char *)ShmOCPP16Data->ChangeAvailability[gunIndex - 1].ResponseStatus, "%s", comfirmstr );
	sendChangeAvailabilityConfirmation(uuid, comfirmstr);

	//ShmOCPP16Data->CsMsg.bits[gunIndex - 1].ChangeAvailabilityConf = 1;

	return result;
}

int handleChangeConfigurationRequest(char *uuid, char *payload)
{

	int result = FAIL;
	char comfirmstr[20];

	printf("handle ChangeConfigurationRequest\n");

	struct json_object *obj, *key, *value;
	char *keystr, *valuestr;

	obj = json_tokener_parse(payload);

	key = json_object_object_get(obj, "key");
	value = json_object_object_get(obj, "value");

	keystr= json_object_get_string(key);
	valuestr = json_object_get_string(value);

    if((uuid==NULL) || (payload ==NULL) )
    {
    	sprintf(comfirmstr, "%s", ConfigurationStatusStr[ConfigurationStatus_Rejected] );

    }
    else
    {
    	int status = setKeyValue(keystr, valuestr);

    	switch(status)
    	{
    		case ConfigurationStatus_Accepted:
    			sprintf(comfirmstr, "%s", ConfigurationStatusStr[ConfigurationStatus_Accepted]);
    			ShmOCPP16Data->MsMsg.bits.ChangeConfigurationReq = 1;

    		break;

    		case ConfigurationStatus_Rejected:
    			sprintf(comfirmstr, "%s", ConfigurationStatusStr[ConfigurationStatus_Rejected] );
    		break;

    		case RebootRequired:
    			sprintf(comfirmstr, "%s", ConfigurationStatusStr[RebootRequired]);
    		break;

    		case NotSupported:
    			sprintf(comfirmstr, "%s", ConfigurationStatusStr[NotSupported] );
    			break;

    		default:
    		break;
    	}
    }

    if(errno >=1)
    {
    	sprintf(comfirmstr, "%s", ConfigurationStatusStr[ConfigurationStatus_Rejected] );
    	fprintf(stderr,"%d %s\\n",errno,strerror(errno));
    }

    //confirmation.setStatus(ConfigurationStatus.Rejected);
    json_object_put(obj);
	sendChangeConfigurationConfirmation(uuid, comfirmstr);
	ShmOCPP16Data->MsMsg.bits.ChangeConfigurationConf = 1;


	return result;
}

int handleClearCacheRequest(char *uuid, char *payload)
{
	int result = FAIL;
	char comfirmstr[20];
	int fd;
    printf("handle  ClearCacheRequest\n");

    /* ?��?一个�?�*/
    fd = open(AuthorizationCache_JSON,O_RDWR);
    if(fd < 0)
    {
        printf("open AuthorizationCache file failed\n");
        sprintf(comfirmstr, "%s", ClearCacheStatusStr[ClearCacheStatus_Rejected] );
    }
    else
    {
        printf("open AuthorizationCache file successful\n");

        /* 清空?�件 */
        ftruncate(fd,0);

        /* ?�新设置?�件?�移??*/
        lseek(fd,0,SEEK_SET);

        close(fd);
        sprintf(comfirmstr, "%s", ClearCacheStatusStr[ClearCacheStatus_Accepted] );
        //ShmOCPP16Data->MsMsg.bits.ClearCacheReq = 1;	//OCPP handle byself
    }

    sendClearCacheConfirmation(uuid, comfirmstr);
    //ShmOCPP16Data->MsMsg.bits.ClearCacheConf = 1;		//OCPP handle byself
	return result;
}

int handleClearChargingProfileRequest(char *uuid, char *payload)
{
	int result = FAIL;
	struct json_object *obj, *connectorId, *csChargingProfiles, *chargingProfileId, *stackLevel, *chargingProfilePurpose;
	int connectorIdInt, chargingProfileIdInt, stackLevelInt;
	const char*chargingProfilePurposeStr;

	struct json_object *tempobj, *tempconnectorId, *tempcsChargingProfiles, *tempchargingProfileId, *tempstackLevel, *tempchargingProfilePurpose;
	int tempconnectorIdInt, tempchargingProfileIdInt, tempstackLevelInt;
	char *tempchargingProfilePurposeStr;

	char fname[200];

	json_object *test_obj = NULL;
	json_object *tmp_obj = NULL;
	struct array_list *json_list;
	struct json_object *jsonitem;
	char comfirmstr[20];
	size_t n_friends;
	int clearflag = FALSE;

	FILE *fptr1, *fptr2;
	char temp[] = "temp.json";
	struct json_object *newHeatMap = json_object_new_array();


	obj = json_tokener_parse(payload);
	printf("handle  ClearChargingProfileRequest\n");

	connectorId = json_object_object_get(obj, "connectorId");
	chargingProfileId = json_object_object_get(obj, "id");
	stackLevel = json_object_object_get(obj, "stackLevel");
	chargingProfilePurpose = json_object_object_get(obj, "chargingProfilePurpose");

	printf("handle  ClearChargingProfileRequest error 1\n");
	if(connectorId != NULL)
	connectorIdInt = json_object_get_int(connectorId);

	if(chargingProfileId != NULL)
	chargingProfileIdInt = json_object_get_int(chargingProfileId);

	if(stackLevel != NULL)
	stackLevelInt = json_object_get_int(stackLevel);

	if(chargingProfilePurpose != NULL)
	chargingProfilePurposeStr = json_object_get_string(chargingProfilePurpose);

	printf("handle  ClearChargingProfileRequest error 2\n");
	if(connectorId != NULL)
	{
		switch(connectorIdInt)
		{
			case 0:
				strcpy(fname, ChargingProfile_0_JSON );
				break;

			case 1:
				strcpy(fname, ChargingProfile_1_JSON );
				break;

			case 2:
				strcpy(fname, ChargingProfile_2_JSON );
				break;

			default:
				strcpy(fname, ChargingProfile_0_JSON );
				break;
		}

	}
	else
	{
		strcpy(fname, ChargingProfile_0_JSON );

	}

	printf("handle  ClearChargingProfileRequest error 3\n");

	fptr1 = fopen(fname, "r");
	if (!fptr1)
	{
		//file not exist
		printf("Unable to open the input file!!\n");
		fptr1 = fopen(fname, "w+");

	}
	fclose(fptr1);

	printf("handle  ClearChargingProfileRequest error 4\n");

	if(connectorId != NULL && (connectorIdInt != 0) && ( (connectorIdInt-1) > (CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY) ) )
	{

		sprintf(comfirmstr, "%s", ClearChargingProfileStatusStr[ClearChargingProfileStatus_Unknown] );
		goto end;
	}


	//get json object from file
	test_obj = json_object_from_file(fname);
	printf("handle  ClearChargingProfileRequest error 5\n");

	if(json_object_get_type(test_obj) == json_type_array)
	{

		//
		if(connectorId == NULL || connectorIdInt == 0 )
		{
			printf("handle  ClearChargingProfileRequest error 6\n");

			//clear the whole contents of a file in C
			fclose(fopen(ChargingProfile_0_JSON, "w"));
			fclose(fopen(ChargingProfile_1_JSON, "w"));
			fclose(fopen(ChargingProfile_2_JSON, "w"));
			printf("handle  ClearChargingProfileRequest error 7\n");

		}
		else
		{
			printf("handle  ClearChargingProfileRequest error 8\n");

			n_friends = json_object_array_length(test_obj);
			printf("Found %lu friends\n",n_friends);

			for(int i=0;i<n_friends;i++)
			{
				jsonitem = json_object_array_get_idx(test_obj, i);
				printf("%lu. %s\n",i+1,json_object_get_string(jsonitem));


				tempconnectorId = json_object_object_get(jsonitem, "connectorId");
				tempcsChargingProfiles = json_object_object_get(jsonitem, "csChargingProfiles");

				tempchargingProfileId = json_object_object_get(tempcsChargingProfiles, "chargingProfileId");
				tempstackLevel = json_object_object_get(tempcsChargingProfiles, "stackLevel");
				tempchargingProfilePurpose = json_object_object_get(tempcsChargingProfiles, "chargingProfilePurpose");

				tempconnectorIdInt = json_object_get_int(tempconnectorId);
				tempchargingProfileIdInt = json_object_get_int(tempchargingProfileId);
				tempstackLevelInt = json_object_get_int(tempstackLevel);
				tempchargingProfilePurposeStr = (char *)json_object_get_string(tempchargingProfilePurpose);


				if(chargingProfileId != NULL)
				{
					if(tempchargingProfileIdInt == chargingProfileIdInt)
					{
						sprintf(comfirmstr, "%s", ClearChargingProfileStatusStr[ClearChargingProfileStatus_Accepted] );
						clearflag = TRUE;
						continue;
					}
					else
					{
						json_object_array_add(newHeatMap, jsonitem);
					}
				}
				else
				{
					if((tempconnectorIdInt == connectorIdInt) && ((tempchargingProfileIdInt == chargingProfileIdInt) || (tempstackLevelInt == stackLevelInt) && (strcmp(tempchargingProfilePurposeStr, chargingProfilePurposeStr) == 0)))
					{
						sprintf(comfirmstr, "%s", ClearChargingProfileStatusStr[ClearChargingProfileStatus_Accepted] );
						clearflag = TRUE;
						continue;
					}
					else
					{
						json_object_array_add(newHeatMap, jsonitem);
					}


				}


			}

			printf("handle  ClearChargingProfileRequest error 9\n");


			if(clearflag == FALSE)
			{
				sprintf(comfirmstr, "%s", ClearChargingProfileStatusStr[ClearChargingProfileStatus_Unknown] );
				goto end;
			}



		}

		FILE *fp;
		fp=fopen(temp,"w");
		fclose(fp);


		remove(fname);
		rename(temp, fname);

		json_object_to_file(fname, newHeatMap);
		printf("handle  ClearChargingProfileRequest error 12\n");



	}
	else
	{
		sprintf(comfirmstr, "%s", ClearChargingProfileStatusStr[ClearChargingProfileStatus_Unknown] );
		printf("handle  ClearChargingProfileRequest error 13\n");


	}

	end:
	json_object_put(obj);
	printf("handle  ClearChargingProfileRequest error 14\n");

	json_object_put(test_obj);
	printf("handle  ClearChargingProfileRequest error 15\n");

	sendClearChargingProfileConfirmation(uuid, comfirmstr);

	return result;
}

int handleDataTransferRequest(char *uuid, char *payload)
{
	int result = FAIL;

	struct json_object *obj;
	obj = json_tokener_parse(payload);
	printf("handle   DataTransferRequest\n");

	return result;
}


long long diff_tm(struct tm *a, struct tm *b) {
 return a->tm_sec - b->tm_sec
      + 60LL * (a->tm_min - b->tm_min)
      + 3600LL * (a->tm_hour - b->tm_hour)
      + 86400LL * (a->tm_yday - b->tm_yday)
      + (a->tm_year - 70) * 31536000LL
      - (a->tm_year - 69) / 4 * 86400LL
      + (a->tm_year - 1) / 100 * 86400LL
      - (a->tm_year + 299) / 400 * 86400LL
      - (b->tm_year - 70) * 31536000LL
      + (b->tm_year - 69) / 4 * 86400LL
      - (b->tm_year - 1) / 100 * 86400LL
      + (b->tm_year + 299) /400 * 86400LL;
}




int handleGetCompositeScheduleRequest(char *uuid, char *payload)
{
	int result = FAIL;
	struct json_object *obj, *connectorId, *duration, *chargingRateUnit;
	int connectorIdInt, durationInt;
	const char*chargingRateUnitStr;

	struct json_object *tempobj, *tempconnectorId, *tempcsChargingProfiles, *tempvalidFrom,*tempChargingSchedule, *tempstartSchedule, *tempchargingSchedulePeriod, *tempminChargingRate;
	int tempconnectorIdInt, tempdurationInt;
	float tempminChargingRateFloat = 0.0;
	char *tempvalidFromStr,*tempchargingRateUnitStr, *tempstartScheduleStr;

	char fname[200];

	json_object *test_obj = NULL;
	json_object *tmp_obj = NULL;
	struct array_list *json_list;
	struct json_object *jsonitem;
	char comfirmstr[20];
	size_t n_friends;
	float totallimit =0.0;
	float MinChargingRate =0.0;
	int clearflag = FALSE;
	int n_periods = 0;
	int nPeriod = 0;

	FILE *fptr1, *fptr2;
	char temp[] = "temp.json";
	struct json_object *newHeatMap = json_object_new_array();

	printf("handle   GetCompositeScheduleRequest\n");
	obj = json_tokener_parse(payload);

	connectorId = json_object_object_get(obj, "connectorId");
	duration  = json_object_object_get(obj, "duration");
	chargingRateUnit  = json_object_object_get(obj, "chargingRateUnit");

	connectorIdInt = json_object_get_int(connectorId);
	durationInt = json_object_get_int(duration);
	if(chargingRateUnit != NULL)
	chargingRateUnitStr = json_object_get_string(chargingRateUnit);

	// current time
	time_t t = time(NULL);

	memset(ShmOCPP16Data->GetCompositeSchedule, 0, sizeof(struct StructChargingSchedulePeriod)* (CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY) );

	if(connectorIdInt==0) // connectorId is 0
	{
		strcpy(fname, ChargingProfile_0_JSON );
		test_obj = NULL;
		test_obj = json_object_from_file(fname);
		n_friends = 0;
		n_friends = json_object_array_length(test_obj);
		printf("Found %lu friends\n",n_friends);

		for(int i=0;i<n_friends;i++)
		{
			printf("handle   GetCompositeScheduleRequest -1\n");
			jsonitem = json_object_array_get_idx(test_obj, i);
			printf("%lu. %s\n",i+1,json_object_get_string(jsonitem));


			printf("handle   GetCompositeScheduleRequest -2\n");
			tempconnectorId = json_object_object_get(jsonitem, "connectorId");
			tempcsChargingProfiles = json_object_object_get(jsonitem, "csChargingProfiles");

			tempvalidFrom  = json_object_object_get(tempcsChargingProfiles, "validFrom");
			tempChargingSchedule = json_object_object_get(tempcsChargingProfiles, "chargingSchedule");
			printf("handle   GetCompositeScheduleRequest -3\n");
			tempstartSchedule = json_object_object_get(tempChargingSchedule, "startSchedule");
			tempminChargingRate  = json_object_object_get(tempstartSchedule, "minChargingRate");
			printf("handle   GetCompositeScheduleRequest -4n");

			tempminChargingRateFloat = (float)json_object_get_double(tempminChargingRate);
			tempchargingSchedulePeriod = json_object_object_get(tempChargingSchedule, "chargingSchedulePeriod");



			tempstartScheduleStr = (char *)json_object_get_string(tempstartSchedule);
			printf("handle   GetCompositeScheduleRequest -5\n");
			tempvalidFromStr = (char *)json_object_get_string(tempvalidFrom);
			double diff_t;
			struct tm tp;
			printf("tempstartScheduleStr 1 : %s\n", tempstartScheduleStr);
			printf("handle   GetCompositeScheduleRequest -6\n");
			printf("tempstartScheduleStr 2 : %s\n", tempstartScheduleStr);
			strptime(tempstartScheduleStr, "%Y-%m-%dT%H:%M:%S", &tp);
			printf("handle   GetCompositeScheduleRequest -6 -1\n");
			tp.tm_isdst = -1;
			printf("handle   GetCompositeScheduleRequest -6 -2\n");
			time_t utc = mktime(&tp);
			printf("handle   GetCompositeScheduleRequest -7\n");
			struct tm e0 = { .tm_year = tp.tm_year, .tm_mday = tp.tm_mday, .tm_mon = tp.tm_mon, .tm_hour = tp.tm_hour, .tm_isdst = -1 };
			time_t pseudo = mktime(&e0);
			struct tm e1 = *gmtime(&pseudo);
			e0.tm_sec += utc - diff_tm(&e1, &e0);
			time_t local = e0.tm_sec;
			printf("handle   GetCompositeScheduleRequest -8\n");
			// ?�到��??�起始�???- chargingScedule起�??��?
			diff_t = difftime(t, local);

			n_periods = json_object_array_length(tempchargingSchedulePeriod);

			printf("handle   GetCompositeScheduleRequest -9\n");
			for(int i=0;i<n_periods;i++)
			{
				struct json_object *tempstartPeriod, *templimit, *tempnumberPhases;

				jsonitem = json_object_array_get_idx(tempchargingSchedulePeriod, i);
				printf("%lu. %s\n",i+1,json_object_get_string(jsonitem));


				tempstartPeriod = json_object_object_get(jsonitem, "startPeriod");
				templimit = json_object_object_get(jsonitem, "limit");
				tempnumberPhases = json_object_object_get(jsonitem, "numberPhases");

				int tempstartPeriodInt = json_object_get_int(tempstartPeriod);

				if(diff_t >= 0)
				{
					diff_t = ((diff_t - tempstartPeriodInt) <=0) ? 0 : (diff_t - tempstartPeriodInt);
					printf("diff_t=%d\n",diff_t);
				}



				float  temp = (float)json_object_get_double(templimit);
				if(diff_t == 0)
				{
					//loat temp = (float)json_object_get_double(templimit);

				    if(totallimit <  temp)
				    {

				    	totallimit = temp;
				    	printf("totallimit=%d\n",totallimit);
				    }
				}



			}

			if(MinChargingRate < tempminChargingRateFloat)
			MinChargingRate = tempminChargingRateFloat;
		}

		printf("handle   GetCompositeScheduleRequest -10\n");

		/* Define temporary variables */
		struct tm *gtime;
		time_t now;
        char buf[28];
		/* Read the current system time */
        printf("handle   GetCompositeScheduleRequest -11\n");
		time(&now);
		printf("handle   GetCompositeScheduleRequest -12\n");
		/* Convert the system time to GMT (now UTC) */
		gtime = gmtime(&now);
		printf("handle   GetCompositeScheduleRequest -13\n");
		strftime(buf, 28, "%Y-%m-%dT%H:%M:%SZ", gtime);
		printf("handle   GetCompositeScheduleRequest -14\n");


		// make .conf
		strcpy((char *)ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.StartSchedule,buf);

		ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod =  (struct StructChargingSchedulePeriod *) malloc(sizeof(struct StructChargingSchedulePeriod)* n_periods);


		memset(ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod, 0, sizeof(struct StructChargingSchedulePeriod)* n_periods);

		nPeriod = 1;

		ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[0].Limit = 100.0;//totallimit;
		printf("(1)ChargingSchedulePeriod[0].Limit =%d\n",ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[0].Limit);
		ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[0].NumberPhases = 3.0;
		printf("(2)NumberPhases =%f\n",ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[0].NumberPhases);
		ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[0].StartPeriod = 0;

		ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.Duration = durationInt;
		sleep(10);
		printf("1.totallimit =%d\n",totallimit);
		printf("2. totallimit =%d\n",ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[0].Limit);
		printf("NumberPhases =%f\n",ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[0].NumberPhases);
		printf("StartPeriod = %d\n",ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[0].StartPeriod);
		printf("durationInt = %d\n",ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.Duration);
		printf("handle   GetCompositeScheduleRequest -14 -1\n");
		if(chargingRateUnitStr != NULL)
		{
			strcpy((char *)ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingRateUnit, chargingRateUnitStr );
		}
		else
		{
			strcpy((char *)ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingRateUnit, "" );
		}
		ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.MinChargingRate = MinChargingRate;
		sprintf(comfirmstr, "%s", GetCompositeScheduleStatusStr[GetCompositeScheduleStatus_Accepted] );

		printf("handle   GetCompositeScheduleRequest -15\n");

	}
	else if ((connectorIdInt > 0)&&((connectorIdInt -1) < (CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY))  )
	{
		//connectorId is specific Id
		switch(connectorIdInt)
		{
			case 0:
					strcpy(fname, ChargingProfile_0_JSON );
					break;

			case 1:
					strcpy(fname, ChargingProfile_1_JSON );
					break;

			case 2:
					strcpy(fname, ChargingProfile_2_JSON );
					break;

			default:
					strcpy(fname, ChargingProfile_0_JSON );
					break;
		}

		//get json object from file
	    test_obj = json_object_from_file(fname);

		n_friends = 0;
	    n_friends = json_object_array_length(test_obj);
		printf("Found %lu friends\n",n_friends);

		for(int i=0;i<n_friends;i++)
		{
            printf("GetCompositeScheduleRequest -1\n");
			jsonitem = json_object_array_get_idx(test_obj, i);
			printf("%lu. %s\n",i+1,json_object_get_string(jsonitem));


			tempconnectorId = json_object_object_get(jsonitem, "connectorId");
			tempcsChargingProfiles = json_object_object_get(jsonitem, "csChargingProfiles");

			tempvalidFrom  = json_object_object_get(tempcsChargingProfiles, "validFrom");
			tempChargingSchedule = json_object_object_get(tempcsChargingProfiles, "ChargingSchedule");

			tempstartSchedule = json_object_object_get(tempChargingSchedule, "startSchedule");
			tempminChargingRate  = json_object_object_get(tempChargingSchedule, "minChargingRate");
			tempminChargingRateFloat = (float)json_object_get_double(tempminChargingRate);
			tempchargingSchedulePeriod = json_object_object_get(tempChargingSchedule, "chargingSchedulePeriod");
			tempstartScheduleStr =(char *) json_object_get_string(tempstartSchedule);
			printf("GetCompositeScheduleRequest -2\n");
			tempvalidFromStr = (char *)json_object_get_string(tempvalidFrom);
		    double diff_t;
			struct tm tp;
			strptime(tempstartScheduleStr, "%Y-%m-%dT%H:%M:%S", &tp);
			tp.tm_isdst = -1;
			time_t utc = mktime(&tp);

			struct tm e0 = { .tm_year = tp.tm_year, .tm_mday = tp.tm_mday, .tm_mon = tp.tm_mon, .tm_hour = tp.tm_hour, .tm_isdst = -1 };
			time_t pseudo = mktime(&e0);
			struct tm e1 = *gmtime(&pseudo);
			e0.tm_sec += utc - diff_tm(&e1, &e0);
			time_t local = e0.tm_sec;

			// ?�到��??�起始�???- chargingScedule起�??��?
			diff_t = difftime(t, local);

			n_periods = json_object_array_length(tempchargingSchedulePeriod);
			nPeriod = n_periods;
			printf("GetCompositeScheduleRequest -3\n");
			ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod =  (struct StructChargingSchedulePeriod *) malloc(sizeof(struct StructChargingSchedulePeriod)* nPeriod);

			for(int i=0;i<n_periods;i++)
			{
				struct json_object *tempstartPeriod, *templimit, *tempnumberPhases;
				printf("GetCompositeScheduleRequest -4\n");
				jsonitem = json_object_array_get_idx(tempchargingSchedulePeriod, i);
				printf("%lu. %s\n",i+1,json_object_get_string(jsonitem));


				tempstartPeriod = json_object_object_get(jsonitem, "startPeriod");
				templimit = json_object_object_get(jsonitem, "limit");
				tempnumberPhases = json_object_object_get(jsonitem, "numberPhases");

				int tempstartPeriodInt = json_object_get_int(tempstartPeriod);


				ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[i].Limit = json_object_get_int(templimit);
				ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[i].NumberPhases = (float)json_object_get_double(templimit);
				ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[i].StartPeriod = json_object_get_int(tempstartPeriod);

				if(diff_t >= 0)
					diff_t = ((diff_t - tempstartPeriodInt) <=0) ? 0 : (diff_t - tempstartPeriodInt);

				if(diff_t < 0)
				{
					float temp = (float)json_object_get_double(templimit);

					if(totallimit <  temp)
					{


						totallimit = temp;
					}
				}


			}

			if(MinChargingRate < tempminChargingRateFloat)
				MinChargingRate = tempminChargingRateFloat;
		}

		/* Define temporary variables */
		struct tm *gtime;
		time_t now;
	    char buf[28];
		/* Read the current system time */
		time(&now);


		/* Convert the system time to GMT (now UTC) */
		gtime = gmtime(&now);

		strftime(buf, 28, "%Y-%m-%dT%H:%M:%SZ", gtime);

		// make .conf

		strcpy((char *)ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.StartSchedule,buf);

		ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.Duration = durationInt;
		if(chargingRateUnitStr != NULL)
		{
			strcpy((char *)ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingRateUnit, chargingRateUnitStr );
		}
		else
		{
			strcpy((char *)ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingRateUnit, "" );
		}
		ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.MinChargingRate = MinChargingRate;
		sprintf(comfirmstr, "%s", GetCompositeScheduleStatusStr[GetCompositeScheduleStatus_Accepted] );

	}
	else
	{

		sprintf(comfirmstr, "%s", GetCompositeScheduleStatusStr[GetCompositeScheduleStatus_Accepted] );
	}

	json_object_put(obj);
	sendGetCompositeScheduleConfirmation(uuid,comfirmstr, connectorIdInt, nPeriod);

	return result;
}

int handleGetConfigurationRequest(char *uuid, char *payload)
{
	int result = FAIL;

	struct json_object *obj, *key, *test_obj, *jsonitem;
	int MaxKeySupported = 0;
	obj = json_tokener_parse(payload);
	printf("handle   GetConfigurationRequest\n");

	key  = json_object_object_get(obj, "key");

	int n_keys = json_object_array_length(key);

	UnknownKeynum = 0;
	memset( (void *)unknownkey, 0, sizeof(int)*10*20 );

	MaxKeySupported = atoi(ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemData);
	if(ShmOCPP16Data->GetConfiguration.Key ==  NULL)
	{
		 ShmOCPP16Data->GetConfiguration.Key = (struct StructConfigurationKeyItems *)malloc(sizeof(struct StructConfigurationKeyItems)*MaxKeySupported);
		 memset(ShmOCPP16Data->GetConfiguration.Key, 0 ,sizeof(struct StructConfigurationKeyItems)*MaxKeySupported);
		 printf("memset 0 for GetConfiguration table \n");
	}
	else
	{
		memset(ShmOCPP16Data->GetConfiguration.Key, 0 ,sizeof(struct StructConfigurationKeyItems)*MaxKeySupported);
	}

	if(ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey ==  NULL)
	{
		ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey = (struct StructConfigurationKey *)malloc(sizeof(struct StructConfigurationKey)*MaxKeySupported);
		memset(ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey, 0, sizeof(struct StructConfigurationKey)*MaxKeySupported);
	}
	else
	{
		memset(ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey, 0, sizeof(struct StructConfigurationKey)*MaxKeySupported);
	}

	if(n_keys != 0)
	{
		printf("key sent num=%d\n",n_keys);
		for(int i=0;i<n_keys;i++)
		{
			printf("test test 1\n");
			jsonitem = json_object_array_get_idx(key, i);
			printf("test test 2\n");
			getKeyValue((char *)json_object_get_string(jsonitem));
			printf("test test 3\n");
		}
	}
	else
	{
		printf("no key sent, get all configuration\n");
		getKeyValue("");
	}

	printf("test test 4\n");
	processUnkownKey();

	printf("test test 5\n");
	//ShmOCPP16Data->MsMsg.bits.GetConfigurationReq = 1;
	json_object_put(obj);
	printf("test test 6\n");
	sendGetConfigurationConfirmation(uuid);
	printf("test test 7\n");
	//ShmOCPP16Data->MsMsg.bits.GetConfigurationConf = 1;


	return result;
}

int handleGetDiagnosticsRequest(char *uuid, char *payload)
{
	int result = FAIL;
	void *ret; // �執行�??��???
	pthread_t t; // �? pthread 變數
	pthread_create(&t, NULL, GetDiagnosticsProcess, payload); // 建�?�執行�?
    pthread_join(t, &ret);
  //  ShmOCPP16Data->MsMsg.bits.GetDiagnosticsReq = 1;
	//sendGetDiagnosticsConfirmation(uuid,fname);
    sendGetDiagnosticsConfirmation(uuid,(char*) ret);
  //  ShmOCPP16Data->MsMsg.bits.GetDiagnosticsConf = 1;


	return result;
}


void* GetDiagnosticsProcess(void* data)
{
	struct json_object *obj, *location , *retries, *retryInterval , *startTime , *stopTime;
	int retriesInt=0, retryIntervalInt=0;
	const char *locationstr, *startTimestr, *stopTimestr ;

	char protocol[10], user[50],password[50],host[50], path[50], ftppath[60],host1[50],path1[50];
	int port=0;
	char fname[50]="";//="00000_2019-06-09_160902_CSULog.zip";

	char *str = (char*) data; // ?��?輸入資�?
	int isSuccess = FALSE;
	char ftpbuf[200];
	char temp[100];
	char * pch;


	obj = json_tokener_parse(str);
	printf("handle     GetDiagnosticsRequest\n");


	location = json_object_object_get(obj, "location");
	retries  = json_object_object_get(obj, "retries");
	retryInterval  = json_object_object_get(obj, "retryInterval");
	startTime  = json_object_object_get(obj, "startTime");
	stopTime   = json_object_object_get(obj, "stopTime");

	locationstr = json_object_get_string(location);

	if(retries != NULL)
	retriesInt = json_object_get_int(retries);

	if(retryInterval != NULL)
	retryIntervalInt = json_object_get_int(retryInterval);

	if(startTime != NULL)
	startTimestr = json_object_get_string(startTime);

	if(stopTime != NULL)
	stopTimestr = json_object_get_string(stopTime);

	printf("handle     GetDiagnosticsRequest -1\n");

	memset(protocol, 0, sizeof(protocol));
	memset(user, 0, sizeof(user) );
	memset(password, 0, sizeof(password));
	memset(host, 0, sizeof(host));

	memset(path, 0, sizeof(path));
	memset(ftppath, 0, sizeof(ftppath));
	memset(host1, 0, sizeof(host1));
	memset(path1, 0, sizeof(path1));
	/*location: ftp://user:password@host:port/path*/
	//sscanf(locationstr,"%[^:]:%*2[/]%[^:]:%[^@]@%[^:]%d[^/]/%[a-zA-Z0-9._/-]",

	//       protocol, user, password, host, &port, path);
	//zip files in /Storage
	system("exec /root/logPackTools 'log' 6");

	time_t rawtime;
	struct tm * timeinfo;
	//char buffer [128];
	time (&rawtime);
	//printf("%ld\n", rawtime);
	timeinfo = localtime (&rawtime);
	strftime (fname,sizeof(fname),"/mnt/%4Y_%2m.zip",timeinfo);
	if((access(fname,F_OK))!=-1)
	{
		printf("?‡ä»¶ test.c exist.\n");
	}
	else
	{
		printf("test.c not exist!\n");
		goto end;

	}

	pch=strchr(locationstr,'@');

	if(pch==NULL)
	{
		sscanf(locationstr,
			         "%[^:]:%*2[/]%[^:]:%i/%[a-zA-Z0-9._/-]",
			         protocol, host, &port, path);
		strcpy(user,"anonymous");
		strcpy(password,"");
	}
	else
	{
		printf("pch=%s\n", pch);
		sscanf(locationstr,"%[^:]:%*2[/]%[^:]:%[^@]@%[^:]:%i/%199[^\n]",
				   protocol, user, password, host, &port, path);
	}

  	sscanf(host,"%[^/]%s",host1, path1);
	sprintf(ftppath,"%s", path1);

	printf("protocol =%s\n",protocol);
	printf("user =%s\n",user);
	printf("password =%s\n",password);
	printf("host1 =%s\n",host1);
	printf("port =%d\n",port);
	printf("path1 =%s\n",path1);
	printf("ftppath=%s\n",ftppath);

	int ftppathlen=strlen(ftppath);
	int i=1;
	char filenametemp[50];
	while(i < ftppathlen)
	{
	   printf("ftppath[ftppathlen-i]:%c\n",ftppath[ftppathlen-i]);
	   int len=ftppathlen-i;
	   if(ftppath[len]== 47) // '/' ascll code: 47
	   {
	     printf("all right\n");
	     break;
	   }

	   printf("test substr\n");
	   i=i+1;

	}

	memset(filenametemp, 0, sizeof(filenametemp));
	strncpy(filenametemp, ftppath+(ftppathlen-i+1), i+1);
	filenametemp[i+1] = 0;
	printf("filenametemp:%s\n", filenametemp);



	sendDiagnosticsStatusNotificationRequest(DiagnosticsStatusStr[DiagnosticsStatus_Uploading]);
	    //httpDownLoadFile(host, ftppath, fname);
	memset(ftpbuf, 0, sizeof(ftpbuf));

    if(port == 0)
    	port = 21;
	//isSuccess = httpDownLoadFile(host1, ftppath, filenametemp, "http://evsocket.phihong.com.tw/UploadFiles/SW/C81FBD4A740F69286B276C68B5074373.jar");


    do{
    	 isSuccess = ftpFile(/*"test.evsocket.phihong.com.cn","phihong","y42j/4cj84",21,"/",fname*/host1, user, password, port, ftppath, fname);
    	 sleep(retryIntervalInt);
    }while((!isSuccess)&&(retriesInt > 0 && retriesInt --));

	if(!isSuccess)
	{
	   //BulldogUtil.sleepMs(interval*1000);
	   printf("Update firmware request and download file fail.\n");
	   sendDiagnosticsStatusNotificationRequest(DiagnosticsStatusStr[DiagnosticsStatus_UploadFailed]);
	}
	else
	{
		sendDiagnosticsStatusNotificationRequest(DiagnosticsStatusStr[DiagnosticsStatus_Uploaded]);
		isUpdateRequest = TRUE;
	}

end:
	json_object_put(obj);
	pthread_exit((void *) fname); // ?��?�執行�?

}




int handleGetLocalListVersionRequest(char *uuid, char *payload)
{
	int result = FAIL;
	printf("handle    GetLocalListVersionRequest\n");

	if(strcmp(ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData, "FALSE") == 0)
	{
		localversion = -1;
	}
	else
	{
		OCPP_getListVerion();
	}


	//from db.OCPP_getListVerion
	printf("handle    GetLocalListVersionRequest -1\n");

	ShmOCPP16Data->GetLocalListVersion.ResponseListVersion = localversion;
	printf("handle    GetLocalListVersionRequest -2\n");
	//ShmOCPP16Data->MsMsg.bits.GetLocalListVersionReq = 1;
	sendGetLocalListVersionConfirmation(uuid,"");
	//ShmOCPP16Data->MsMsg.bits.GetLocalListVersionConf = 1;

	return result;
}

int handleRemoteStartRequest(char *uuid, char *payload)
{
	int result = FAIL;

	struct json_object *obj, *connectorId, *idTag, *chargingProfile,
			*chargingProfileId, *transactionId, *stackLevel,
			*chargingProfilePurpose, *chargingProfileKind,
			*recurrencyKind, *validFrom, *validTo, *chargingSchedule,
			*duration, *startSchedule, *chargingRateUnit, *chargingSchedulePeriod,
			*minChargingRate,*limit, *startPeriod, *numberPhases;
	int connectorIdInt=0, chargingProfileIdInt=0, transactionIdInt=0, stackLevelInt=0,
		durationInt=0, startPeriodInt =0, numberPhasesInt=0;
	char *idTagstr, *chargingProfilePurposestr, *chargingProfileKindstr, *recurrencyKindstr,
		*validFromstr, *validTostr, *startSchedulestr, *chargingRateUnitstr, *chargingSchedulePeriodstr;
	float minChargingRateflaot=0.0, limitflaot=0.0;
	char comfirmstr[20];

	if(server_pending == TRUE)
	{

		return 0;
	}

	obj = json_tokener_parse(payload);
	printf("handleRemoteStartRequest\n");

	connectorId = json_object_object_get(obj, "connectorId");
	idTag  = json_object_object_get(obj, "idTag");
	chargingProfile   = json_object_object_get(obj, "chargingProfile");

	if(connectorId != NULL)
	{
		connectorIdInt = json_object_get_int(connectorId);
	}
	else
	{
		strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
		goto end;
	}


	idTagstr = (char *)json_object_get_string(idTag);

	if(chargingProfile != NULL)
	{
		chargingProfileId = json_object_object_get(chargingProfile, "chargingProfileId");
		transactionId = json_object_object_get(chargingProfile, "transactionId");
		stackLevel = json_object_object_get(chargingProfile, "stackLevel");
		chargingProfilePurpose = json_object_object_get(chargingProfile, "chargingProfilePurpose");
		chargingProfileKind = json_object_object_get(chargingProfile, "chargingProfileKind");
		recurrencyKind = json_object_object_get(chargingProfile, "recurrencyKind");
		validFrom  = json_object_object_get(chargingProfile, "validFrom");
		validTo  = json_object_object_get(chargingProfile, "validTo");
		chargingSchedule   = json_object_object_get(chargingProfile, "chargingSchedule");

		chargingProfileIdInt = json_object_get_int(chargingProfileId);

		if(transactionId != NULL) // OPTION
		transactionIdInt = json_object_get_int(transactionId);

		stackLevelInt = json_object_get_int(stackLevel);
		chargingProfilePurposestr =(char *)json_object_get_string(chargingProfilePurpose);
		chargingProfileKindstr = (char *)json_object_get_string(chargingProfileKind);

		if(recurrencyKind != NULL) //OPTION
		recurrencyKindstr = (char *)json_object_get_string(recurrencyKind);

		if(validFrom != NULL) // OPTION
		validFromstr =  (char *)json_object_get_string(validFrom);

		if(validTo != NULL) //OPTION
		validTostr =  (char *)json_object_get_string(validTo);


		duration  = json_object_object_get(chargingSchedule, "duration");
		startSchedule  = json_object_object_get(chargingSchedule, "startSchedule");
		chargingRateUnit  = json_object_object_get(chargingSchedule, "chargingRateUnit");
		chargingSchedulePeriod  = json_object_object_get(chargingSchedule, "chargingSchedulePeriod");
		minChargingRate  = json_object_object_get(chargingSchedule, "minChargingRate");

		if(duration != NULL) //OPTION
		durationInt = json_object_get_int(duration);

		if(startSchedule != NULL) //OPTION
		startSchedulestr = (char *)json_object_get_string(startSchedule);

		chargingRateUnitstr = (char *)json_object_get_string(chargingRateUnit);
		chargingSchedulePeriodstr = (char *)json_object_get_string(chargingSchedulePeriod);

		if(minChargingRate != NULL) //OPTION
		minChargingRateflaot = (float)json_object_get_double(minChargingRate);

		limit = json_object_object_get(chargingSchedulePeriod, "limit");
		startPeriod = json_object_object_get(chargingSchedulePeriod, "startPeriod");
		numberPhases  = json_object_object_get(chargingSchedulePeriod, "numberPhases");

		startPeriodInt = json_object_get_int(startPeriod);
		limitflaot = (float)json_object_get_double(limit);

		if(numberPhases != NULL)
		numberPhasesInt = json_object_get_int(numberPhases);

	}



	/*

	enum _SYSTEM_STATUS
	{
	S_BOOTING               = 0,
	S_IDLE,                 = 1
	S_AUTHORIZING,          =2
	S_REASSIGN_CHECK,       =3
	S_REASSIGN,             =4
	S_PRECHARGE,            =5
	S_PREPARING_FOR_EV,     =6
	S_PREPARING_FOR_EVSE,   =7
	S_CHARGING,             =8
	S_TERMINATING,          =9
	S_COMPLETE,             =10
	S_ALARM,                =11
	S_FAULT                 =12
	}
	 */
	if((connectorId != NULL)&&(connectorIdInt > 0) && ((connectorIdInt -1) <= (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY)))
	{
		sprintf((char *)ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].IdTag, "%s" , idTagstr);
		ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.TransactionId = transactionIdInt;
	    //0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault  8: Reserved

		//check Transaction active
		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == (connectorIdInt -1))
			{

				if((1/*?�ç??—æ?*//*ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '8'*/)&&(strcmp(ShmSysConfigAndInfo->SysConfig.UserId, idTagstr) == 0))
				{

					//ShmSysConfigAndInfo->SysInfo.ChademoChargingData[connectorIdInt-1].SystemStatus = 8; //S_CHARGING
					//ShmOCPP16Data->CsMsg.bits[connectorIdInt -1].RemoteStartTransactionReq = 1;

				}
				else
				{
					if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus != 1)   //S_IDLE
					{
						strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
						goto end;
					}

				}

			}
		}

		for (int index = 0; index < CCS_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == (connectorIdInt -1))
			{
				if((1/*?�ç??—æ?*//*ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == '8'*/)&&(strcmp(ShmSysConfigAndInfo->SysConfig.UserId, idTagstr) == 0))
				{

					//ShmSysConfigAndInfo->SysInfo.CcsChargingData[connectorIdInt-1].SystemStatus = 8; //S_CHARGING
					//ShmOCPP16Data->CsMsg.bits[connectorIdInt -1].RemoteStartTransactionReq = 1;

				}
				else
				{
					if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus != 1) //S_IDLE
					{
						strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
						goto end;
					}

				}

			}
		}

		for (int index = 0; index < GB_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == (connectorIdInt -1))
			{
				if((1/*?�ç??—æ?*//*ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '8'*/)&&(strcmp(ShmSysConfigAndInfo->SysConfig.UserId, idTagstr) == 0))
				{

					//ShmSysConfigAndInfo->SysInfo.GbChargingData[connectorIdInt-1].SystemStatus = 8;  //S_CHARGING
					//ShmOCPP16Data->CsMsg.bits[connectorIdInt -1].RemoteStartTransactionReq = 1;

				}
				else
				{
					if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus != 1) //S_IDLE
					{
						strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
						goto end;
					}

				}

			}
		}


		if(chargingProfile != NULL)
		{
			//ChargingProfile
			ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ChargingProfileId = chargingProfileIdInt;
			sprintf((char *)ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ChargingProfileKind, "%s" ,chargingProfileKindstr);
			sprintf((char *)ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ChargingProfilePurpose, "%s" ,chargingProfilePurposestr);

			if(recurrencyKind != NULL) //OPTION
			sprintf((char *)ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.RecurrencyKind, "%s" ,recurrencyKindstr);

			ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.StackLevel = stackLevelInt;

			if(transactionId != NULL) // OPTION
			ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.TransactionId = transactionIdInt;

			if(validFrom != NULL) // OPTION
			sprintf((char *)ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ValidFrom, "%s" ,validFromstr);

			if(validTo != NULL) //OPTION
			sprintf((char *)ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ValidTo, "%s" ,validTostr);

			//ChargingSchedule
			sprintf((char *)ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ChargingSchedule.ChargingRateUnit, "%s" ,chargingRateUnitstr);

			if(duration != NULL) //OPTION
			ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ChargingSchedule.Duration = durationInt;

			if(minChargingRate != NULL) //OPTION
			ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ChargingSchedule.MinChargingRate = minChargingRateflaot;

			if(startSchedule != NULL) //OPTION
			sprintf((char *)ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ChargingSchedule.StartSchedule, "%s" ,startSchedulestr);

			//ChargingSchedulePeriod
			ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ChargingSchedule.ChargingSchedulePeriod->Limit = limitflaot ;

			if(numberPhases != NULL)
			ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ChargingSchedule.ChargingSchedulePeriod->NumberPhases = numberPhasesInt;

			ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ChargingSchedule.ChargingSchedulePeriod->StartPeriod = startPeriodInt;

			if(strcmp(chargingProfilePurposestr, ChargingProfilePurposeTypeStr[TxProfile]) == 0)
			{
				ShmOCPP16Data->CsMsg.bits[connectorIdInt -1].RemoteStartTransactionReq = 1;
				strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Accepted]);
			}
			else
			{
				strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
			}

		}
		else
		{
			ShmOCPP16Data->CsMsg.bits[connectorIdInt -1].RemoteStartTransactionReq = 1;
			strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Accepted]);
		}
	 }
	 else
	 {
		 strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
		 //sprintf((char *)ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ResponseStatus, "%s" ,comfirmstr);
	 }

end:
	if(connectorId != NULL)
	ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ConnectorId = connectorIdInt;

	strcpy(ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].IdTag, idTagstr);
	sprintf((char *)ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ResponseStatus, "%s" ,comfirmstr);
	json_object_put(obj);

	//OCPP send RemoteStartConfirmation by first.
	sendRemoteStartConfirmation(uuid, comfirmstr);
	//ShmOCPP16Data->CsMsg.bits[connectorIdInt -1].RemoteStartTransactionConf = 1;

	return result;
}

int handleRemoteStopTransactionRequest(char *uuid, char *payload)
{
	int result = FAIL;
	int match = FALSE;
	int GunNO = 0;
	struct json_object *obj, *transactionId;
	int transactionIdInt=0;
	char comfirmstr[20];

	printf("handleRemoteStopTransactionRequest\n");

	if(server_pending == TRUE)
	{

		return 0;
	}

	obj = json_tokener_parse(payload);

	transactionId = json_object_object_get(obj, "transactionId");
	transactionIdInt = json_object_get_int(transactionId);

	if(transactionId != NULL)
	{

		for(int gun_index=0;gun_index< (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY);gun_index++)
	    {
			if(ShmOCPP16Data->RemoteStartTransaction[gun_index].ChargingProfile.TransactionId == transactionIdInt)
	        {
				//check Transaction active
				for (int index = 0; index < CHAdeMO_QUANTITY; index++)
				{
					if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
					{

						if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 8) // S_CHARGING
						{
							match = TRUE;
							GunNO = gun_index;
						}


					}
				}

				for (int index = 0; index < CCS_QUANTITY; index++)
				{
					if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
					{
						if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 8) // S_CHARGING
						{
							match = TRUE;
							GunNO = gun_index;
						}

					}
				}

				for (int index = 0; index < GB_QUANTITY; index++)
				{
					if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
					{
						if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 8) // S_CHARGING
						{
							match = TRUE;
							GunNO = gun_index;
						}

					}
				}

	        }


	    }

		if(	match == TRUE)
		{
			ShmOCPP16Data->CsMsg.bits[GunNO].RemoteStopTransactionReq = 1; // inform csu of StopTransaction
			strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Accepted]);
			sprintf((char *)ShmOCPP16Data->RemoteStopTransaction[GunNO].ResponseStatus, "%s" ,comfirmstr);
		}
		else
		{
			strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
		}


	  }

	json_object_put(obj);

	sendRemoteStopTransactionConfirmation(uuid, comfirmstr);
	//ShmOCPP16Data->CsMsg.bits[GunNO].RemoteStopTransactionConf = 1;

	return result;
}

int handleReserveNowTransactionRequest(char *uuid, char *payload)
{
	int result = FAIL;

	struct json_object *obj, *connectorId, *expiryDate, *idTag, *parentIdTag, *reservationId;
	int connectorIdInt=0, reservationIdInt=0;
	char *expiryDatestr, *idTagstr, *parentIdTagstr;
	char comfirmstr[20];
	obj = json_tokener_parse(payload);
	printf("handleReserveNowRequest\n");

	connectorId = json_object_object_get(obj, "connectorId");
	expiryDate  = json_object_object_get(obj, "expiryDate");
	idTag  = json_object_object_get(obj, "idTag");
	parentIdTag   = json_object_object_get(obj, "parentIdTag");
	reservationId  = json_object_object_get(obj, "reservationId");

	connectorIdInt = json_object_get_int(connectorId);
	expiryDatestr = (char *)json_object_get_string(expiryDate);
	idTagstr = (char *)json_object_get_string(idTag);

	if(parentIdTag != NULL) // option flag
	parentIdTagstr = (char *)json_object_get_string(parentIdTag);
	reservationIdInt = json_object_get_int(reservationId);

	strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Rejected]);

	/*
	enum _SYSTEM_STATUS
	{
		S_BOOTING               = 0,
		S_IDLE,                 = 1
		S_AUTHORIZING,          =2
		S_REASSIGN_CHECK,       =3
		S_REASSIGN,             =4
		S_PRECHARGE,            =5
		S_PREPARING_FOR_EV,     =6
		S_PREPARING_FOR_EVSE,   =7
		S_CHARGING,             =8
		S_TERMINATING,          =9
		S_COMPLETE,             =10
		S_ALARM,                =11
		S_FAULT                 =12
	}

	*/
	if((connectorIdInt > 0) && ((connectorIdInt -1) <= (CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY)))
	{
		//0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault
		//check Transaction active
		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == (connectorIdInt -1))
			{

				if(reservationIdInt != ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].ReservationId)
				{
					//SystemStatus:   0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault, 8: Reserved, 9: maintain
					if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus != 12) //S_FAULT
					{
						if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 1) //S_IDLE
						{
							ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].ReserveNowReq = 1;
							strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Accepted]);
						}
						else if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 11) //S_ALARM  //else if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 11) || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '9'))
						{
							strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Unavailable]);

						}
						else
						{
							strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Occupied]);
						}
					}
					else if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 12) //S_FAULT
					{
						strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Faulted]);
					}
				}
				else
				{
					//replace reservation
					ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].ReserveNowReq = 1;
					strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Accepted]);

				}

			}
		}

		for (int index = 0; index < CCS_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == (connectorIdInt -1))
			{

				if(reservationIdInt != ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].ReservationId)
				{
					//SystemStatus:   0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault, 8: Reserved, 9: maintain
					if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus != 12) //S_FAULT
					{

						if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 1) //S_IDLE
						{
							ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].ReserveNowReq = 1;
							strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Accepted]);
						}
						else if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 11) //S_ALARM  //else if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == '6') || (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == '9'))
						{
							strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Unavailable]);
						}
						else
						{
							strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Occupied]);

						}
					}
					else if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus ==12) //S_FAULT
					{
						strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Faulted]);
					}
				}
				else
				{
					//replace reservation
					ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].ReserveNowReq = 1;
					strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Accepted]);

				}

			}
		}

		for (int index = 0; index < GB_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == (connectorIdInt - 1))
			{

				if(reservationIdInt != ShmSysConfigAndInfo->SysInfo.GbChargingData[index].ReservationId)
				{
					//SystemStatus:   0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault, 8: Reserved, 9: maintain
					if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus != 12) //S_FAULT
					{

						if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 1) //S_IDLE
						{
							ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].ReserveNowReq = 1;
							strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Accepted]);
						}
						else if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 11) //S_ALARM //else if((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '6') || (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '9'))
						{
							strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Unavailable]);
						}
						else
						{
							strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Occupied]);
						}
					}
					else if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus ==12) //S_FAULT
					{
						strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Faulted]);
					}
				}
				else
				{
					//replace reservation
					ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].ReserveNowReq = 1;
					strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Accepted]);

				}

			}
		}

		sprintf((char *)ShmOCPP16Data->ReserveNow[connectorIdInt-1].ResponseStatus, "%s" ,comfirmstr);
	}
	else
	{
		strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Rejected]);
		sprintf((char *)ShmOCPP16Data->ReserveNow[connectorIdInt-1].ResponseStatus, "%s" ,comfirmstr);
	}

	if(strcmp(comfirmstr,"Accepted") == 0)
	{
		ShmOCPP16Data->ReserveNow[connectorIdInt-1].ConnectorId = connectorIdInt;
		sprintf((char *)ShmOCPP16Data->ReserveNow[connectorIdInt-1].ExpiryDate, "%s" , expiryDatestr);
		sprintf((char *)ShmOCPP16Data->ReserveNow[connectorIdInt-1].IdTag, "%s" , idTagstr);
		sprintf((char *)ShmOCPP16Data->ReserveNow[connectorIdInt-1].ParentIdTag, "%s" , parentIdTagstr);
		ShmOCPP16Data->ReserveNow[connectorIdInt-1].ReservationId = reservationIdInt;
	    strcpy(ShmOCPP16Data->ReserveNow[connectorIdInt-1].guid, uuid);
	    json_object_put(obj);
	    result = TRUE;
	    return result;

	}

	json_object_put(obj);

	sendReserveNowTransactionConfirmation(uuid,comfirmstr);
	//ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].ReserveNowConf = 1;

	return result;
}

int handleResetRequest(char *uuid, char *payload)
{
	int result = FAIL;

	struct json_object *obj, *type;
	char *typestr;
	char comfirmstr[20];
	obj = json_tokener_parse(payload);
	printf("handleResetRequest\n");

	type = json_object_object_get(obj, "type");
	typestr = (char *)json_object_get_string(type);
	sprintf((char *)ShmOCPP16Data->Reset.Type, "%s" ,typestr);
	//strcpy(ShmOCPP16Data->Reset.Type, typestr);

	if(strcmp(typestr, ResetTypeStr[Hard])==0)
	{
	       //check Transaction active
	       for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	       {
	        	if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 8)
	        	{
	        		//0: unplug, 1: Plug-in
	        		//ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].ConnectorPlugIn = 0;
	            }
	        }

	        for (int index = 0; index < CCS_QUANTITY; index++)
	        {
	        	if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 8)
	        	{
	        		//0: unplug, 1: Plug-in
	        		//ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].ConnectorPlugIn = 0;
	        	}
	        }

	        for (int index = 0; index < GB_QUANTITY; index++)
	        {
	        	if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 8)
	        	{
	        		//0: unplug, 1: Plug-in
	        	    //ShmSysConfigAndInfo->SysInfo.GbChargingData[index].ConnectorPlugIn = 0;
	        	}
	        }


	    ShmOCPP16Data->MsMsg.bits.ResetReq = 1;
	    strcpy(ShmOCPP16Data->Reset.guid, uuid);
	    json_object_put(obj);
	    result = TRUE;
	    return result;

	//	strcpy(comfirmstr, ResetStatusStr[ResetStatus_Accepted]);
	//	sprintf((char *)ShmOCPP16Data->Reset.ResponseStatus, "%s" ,comfirmstr);

	 }
	 else if(strcmp(typestr, ResetTypeStr[Soft])==0)
	 {
	     //check Transaction active
	     for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	     {
	        if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 8)
	        {
	        	//0: unplug, 1: Plug-in
	        	//ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].ConnectorPlugIn = 0;
	        }
	     }

	     for (int index = 0; index < CCS_QUANTITY; index++)
	     {
	        if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == 8)
	        {
	        	//0: unplug, 1: Plug-in
	        	//ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].ConnectorPlugIn = 0;
	        }
	     }

	     for (int index = 0; index < GB_QUANTITY; index++)
	     {
	        if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == 8)
	        {
	        	//0: unplug, 1: Plug-in
	        	//ShmSysConfigAndInfo->SysInfo.GbChargingData[index].ConnectorPlugIn = 0;
	        }
	     }

	     ShmOCPP16Data->MsMsg.bits.ResetReq = 1;
	     strcpy(ShmOCPP16Data->Reset.guid, uuid);
	     json_object_put(obj);
	     result = TRUE;
	     return result;
		// strcpy(comfirmstr, ResetStatusStr[ResetStatus_Accepted]);
		// sprintf((char *)ShmOCPP16Data->Reset.ResponseStatus, "%s" ,comfirmstr);
	 }
	 else
	 {
		 strcpy(comfirmstr, ResetStatusStr[ResetStatus_Rejected]);
		 sprintf((char *)ShmOCPP16Data->Reset.ResponseStatus, "%s" ,comfirmstr);
		 goto errorend;
	 }

errorend:
	json_object_put(obj);
	sendResetConfirmation(uuid, comfirmstr);
	//ShmOCPP16Data->MsMsg.bits.ResetConf = 1;

	return result;
}

int handleSendLocalListRequest(char *uuid, char *payload)
{
	int result = FAIL;

	struct json_object *obj, *listVersion , *localAuthorizationList, *updateType, *jsonitem, *idTag, *idTagInfo ,
	                   *expiryDate, *parentIdTag, *status;
	int listVersionInt;
	char *updateTypestr, *idTagstr, *expiryDatestr, *parentIdTagstr, *statusstr;
	char comfirmstr[20];
	int n_localAuthorizations = 0;

	obj = json_tokener_parse(payload);
	printf("handleSendLocalListRequest\n");

	listVersion  = json_object_object_get(obj, "listVersion");
	localAuthorizationList   = json_object_object_get(obj, "localAuthorizationList");
	updateType   = json_object_object_get(obj, "updateType");

	listVersionInt = json_object_get_int(listVersion);
	ShmOCPP16Data->SendLocalList.ListVersion = listVersionInt;

	updateTypestr = (char *)json_object_get_string(updateType);
	sprintf((char *)ShmOCPP16Data->SendLocalList.UpdateType, "%s",  updateTypestr);

	printf("handleSendLocalListRequest -1\n");

	if(localAuthorizationList != NULL)
	n_localAuthorizations = json_object_array_length(localAuthorizationList);

	printf("n_localAuthorizations=%d\n",n_localAuthorizations);

	if(ShmOCPP16Data->SendLocalList.LocalAuthorizationList != NULL)
		free(ShmOCPP16Data->SendLocalList.LocalAuthorizationList);

	ShmOCPP16Data->SendLocalList.LocalAuthorizationList = (struct StructLocalAuthorizationList *)malloc(sizeof(struct StructLocalAuthorizationList)*n_localAuthorizations);
	memset(ShmOCPP16Data->SendLocalList.LocalAuthorizationList, 0 ,sizeof(ShmOCPP16Data->SendLocalList.LocalAuthorizationList));

	//ShmOCPP16Data->MsMsg.bits.SendLocalListReq = 1;
	if(strcmp(updateTypestr, UpdateTypeStr[Full]) == 0)
	{
		//Local list full update
		printf("Local list full update.\n");
		OCPP_cleanLocalList();

	}
	else if(strcmp(updateTypestr, UpdateTypeStr[Differential]) == 0)
	{
		//Local list different update
		printf("Local list different update.\n");
		if(localAuthorizationList == NULL)
		{
			strcpy(comfirmstr, UpdateStatusStr[UpdateStatus_Accepted]);
			goto end;
		}

		OCPP_getListVerion();

		if(listVersionInt <= localversion )
		{
			strcpy(comfirmstr, UpdateStatusStr[UpdateStatus_VersionMismatch]);
			goto end;
		}
	}
	else
	{
		strcpy(comfirmstr, UpdateStatusStr[UpdateStatus_NotSupported]);
		goto end;
	}

	for(int i=0;i<n_localAuthorizations;i++)
	{
		printf("handleSendLocalListRequest -2\n");
		jsonitem = json_object_array_get_idx(localAuthorizationList, i);
		printf("handleSendLocalListRequest -2 -0\n");
		idTag  = json_object_object_get(jsonitem, "IdToken"/*"idTag"*/);
		printf("handleSendLocalListRequest -2 -0 -0\n");
		idTagInfo   = json_object_object_get(jsonitem, "idTagInfo");
		printf("handleSendLocalListRequest -2 -0 -0 -0\n");

		if(idTagInfo != NULL)
		{
			expiryDate  = json_object_object_get(idTagInfo, "expiryDate");
			printf("handleSendLocalListRequest -2 -0 -0 -0 -0\n");
			parentIdTag  = json_object_object_get(idTagInfo, "parentIdTag");
			printf("handleSendLocalListRequest -2 -0 -0 -0 -0 -0\n");
			status  = json_object_object_get(idTagInfo, "status");
		}


		if(idTag != NULL)
		idTagstr = (char *)json_object_get_string(idTag);
		printf("idTagstr=%s\n",idTagstr);

		if(expiryDate != NULL)
		expiryDatestr = (char *)json_object_get_string(expiryDate);
		printf("expiryDatestr=%s\n",expiryDatestr);

		if(parentIdTag != NULL)
		parentIdTagstr = (char *)json_object_get_string(parentIdTag);
		printf("parentIdTagstr=%s\n",parentIdTagstr);

		statusstr = (char *)json_object_get_string(status);
		printf("statusstr=%s\n",statusstr);

		printf("handleSendLocalListRequest -2 -1\n");

		OCPP_getIdTag(idTagstr);

		if(strcmp(updateTypestr, UpdateTypeStr[Full]) == 0)
		{
			//Local list full update
			printf("Local list full update.\n");
			// update list
			OCPP_addLocalList_1(listVersionInt, idTagstr, parentIdTagstr, expiryDatestr, statusstr);

		}
		else if(strcmp(updateTypestr, UpdateTypeStr[Differential]) == 0)
		{
			if((strcmp(idTagstr, idTagAuthorization) == 0) && (parentIdTag != NULL))
			{
				OCPP_addLocalList_1(listVersionInt, idTagstr, parentIdTagstr, expiryDatestr, statusstr);

			}
			else if((strcmp(idTagstr, idTagAuthorization) == 0) && (parentIdTag == NULL))
			{
				OCPP_deleteIdTag(idTagstr);
			}
			else if((strcmp(idTagstr, idTagAuthorization) != 0) && (parentIdTag != NULL))
			{
				OCPP_addLocalList_1(listVersionInt, idTagstr, parentIdTagstr, expiryDatestr, statusstr);

			}

		}

		strcpy((char *)ShmOCPP16Data->SendLocalList.LocalAuthorizationList[i].IdTag, idTagstr);
		printf("handleSendLocalListRequest -2 -1 -1\n");
		strcpy((char *)ShmOCPP16Data->SendLocalList.LocalAuthorizationList[i].IdTagInfo.ExpiryDate, expiryDatestr);
		strcpy((char *)ShmOCPP16Data->SendLocalList.LocalAuthorizationList[i].IdTagInfo.ParentIdTag, parentIdTagstr);
		strcpy((char *)ShmOCPP16Data->SendLocalList.LocalAuthorizationList[i].IdTagInfo.Status, statusstr);

		printf("handleSendLocalListRequest -3\n");
	}

	printf("handleSendLocalListRequest -4\n");
	strcpy(comfirmstr, UpdateStatusStr[UpdateStatus_Accepted]);

end:
	json_object_put(obj);
	sendSendLocalListConfirmation(uuid, comfirmstr);
	//ShmOCPP16Data->MsMsg.bits.SendLocalListConf = 1;
	printf("handleSendLocalListRequest -5\n");

	return result;
}

#define MAX 2000

int handleSetChargingProfileRequest(char *uuid, char *payload)
{
	int result = FAIL;
	struct json_object *obj, *connectorId, *csChargingProfiles, *chargingProfileId, *stackLevel, *chargingProfilePurpose;
	struct json_object *tempobj, *tempconnectorId, *tempcsChargingProfiles, *tempchargingProfileId, *tempstackLevel, *tempchargingProfilePurpose;
	int connectorIdInt, chargingProfileIdInt, stackLevelInt;
	int tempconnectorIdInt, tempchargingProfileIdInt, tempstackLevelInt;
	const char*chargingProfilePurposeStr;
	char *tempchargingProfilePurposeStr;
	int updateflag = FALSE;
	char comfirmstr[20];
	int meet= FALSE;


	printf("handleSetChargingProfileRequest\n");

	obj = json_tokener_parse(payload);

	connectorId = json_object_object_get(obj, "connectorId");
	csChargingProfiles = json_object_object_get(obj, "csChargingProfiles");

	chargingProfileId = json_object_object_get(csChargingProfiles, "chargingProfileId");
	stackLevel = json_object_object_get(csChargingProfiles, "stackLevel");
	chargingProfilePurpose = json_object_object_get(csChargingProfiles, "chargingProfilePurpose");

	connectorIdInt = json_object_get_int(connectorId);
	chargingProfileIdInt = json_object_get_int(chargingProfileId);
	stackLevelInt = json_object_get_int(stackLevel);
	chargingProfilePurposeStr = json_object_get_string(chargingProfilePurpose);


#if 1 // get json object from file

	FILE *fptr1, *fptr2;
	int lno, linectr = 0;
	int modifyflag = FALSE;
	char str[MAX],fname[MAX];
	char newln[MAX], temp[] = "temp.json";
	struct json_object *newHeatMap = json_object_new_array();

	printf("\n\n Replace a specific line in a text file with a new text :\n");
	printf("-------------------------------------------------------------\n");
	printf(" Input the file name to be opened : ");
	//fgets(fname, MAX, stdin);
	//fname[strlen(fname) - 1] = '\0';

	switch(connectorIdInt)
	{
		case 0:
			strcpy(fname, ChargingProfile_0_JSON );
			break;

		case 1:
			strcpy(fname, ChargingProfile_1_JSON );
			break;

		case 2:
			strcpy(fname, ChargingProfile_2_JSON );
			break;

		default:
			strcpy(fname, ChargingProfile_0_JSON );
			break;
	}


	fptr1 = fopen(fname, "r");
	if (!fptr1)
	{
			//file not exist
			printf("Unable to open the input file!!\n");
			fptr1 = fopen(fname, "w+");

	}
	fclose(fptr1);

	json_object *test_obj = NULL;
	json_object *tmp_obj = NULL;
	struct array_list *json_list;
	struct json_object *jsonitem;
	size_t n_friends;

	printf("set chargingProfile 1\n");
	//get json object from file
	test_obj = json_object_from_file(fname);
	if(test_obj ==NULL)
	{

		printf("set chargingProfile: test_obj is Null!!!\n");
		//assert(test_obj != NULL);

	}
	tempchargingProfilePurposeStr = NULL;
	printf("set chargingProfile 1-1\n");
	if(strcmp(chargingProfilePurposeStr, ChargingProfilePurposeTypeStr[ChargePointMaxProfile]) == 0)
	{
		printf("set chargingProfile 1-2\n");
		if(connectorIdInt != 0)
		{
				sprintf(comfirmstr, "%s", ChargingProfileStatusStr[ChargingProfileStatus_Rejected] );
				goto end;
		}


	}
	else if(strcmp(chargingProfilePurposeStr, ChargingProfilePurposeTypeStr[TxDefaultProfile]) == 0)
	{
		printf("set chargingProfile 1-3\n");
		if((connectorIdInt != 0) && (connectorIdInt > (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY)))
		{
				sprintf(comfirmstr, "%s", ChargingProfileStatusStr[ChargingProfileStatus_Rejected] );
				goto end;
		}

	}
	else if(strcmp(chargingProfilePurposeStr, ChargingProfilePurposeTypeStr[TxProfile]) == 0)
	{
		printf("set chargingProfile 1-4\n");

		//check Transaction active
		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == connectorIdInt)
			{

				if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '4')
				{
					meet = TRUE;
				}

			}
		}

		for (int index = 0; index < CCS_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == connectorIdInt)
			{
				if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == '4')
				{
					meet = TRUE;
				}

			}
		}

		for (int index = 0; index < GB_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == connectorIdInt)
			{
				if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '4')
				{
					meet = TRUE;
				}

			}
		}

		if(meet == FALSE)
		{
			sprintf(comfirmstr, "%s", ChargingProfileStatusStr[ChargingProfileStatus_Rejected] );
			goto end;
		}

		if((connectorIdInt != 0) && (connectorIdInt > (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY)))
		{
				sprintf(comfirmstr, "%s", ChargingProfileStatusStr[ChargingProfileStatus_Rejected] );
				goto end;
		}


	}

	printf("set chargingProfile 2\n");

	if((test_obj != NULL) &&(json_object_get_type(test_obj) == json_type_array))
	{

		/* Get array of tests */
		json_list = json_object_get_array(test_obj);

		n_friends = json_object_array_length(test_obj);
		printf("Found %lu friends\n",n_friends);

		for(int i=0;i<n_friends;i++)
		{
			jsonitem = json_object_array_get_idx(test_obj, i);
			printf("%lu. %s\n",i+1,json_object_get_string(jsonitem));


			tempconnectorId = json_object_object_get(jsonitem, "connectorId");
			tempcsChargingProfiles = json_object_object_get(jsonitem, "csChargingProfiles");

			tempchargingProfileId = json_object_object_get(tempcsChargingProfiles, "chargingProfileId");
			tempstackLevel = json_object_object_get(tempcsChargingProfiles, "stackLevel");
			tempchargingProfilePurpose = json_object_object_get(tempcsChargingProfiles, "chargingProfilePurpose");

			tempconnectorIdInt = json_object_get_int(tempconnectorId);
			tempchargingProfileIdInt = json_object_get_int(tempchargingProfileId);
			tempstackLevelInt = json_object_get_int(tempstackLevel);
			tempchargingProfilePurposeStr =(char *)json_object_get_string(tempchargingProfilePurpose);

			printf("s t 1\n");

			if((tempconnectorIdInt == connectorIdInt) && ((tempchargingProfileIdInt == chargingProfileIdInt) || (tempstackLevelInt == stackLevelInt) && (strcmp(tempchargingProfilePurposeStr, chargingProfilePurposeStr) == 0)))
			{
			    		   //fprintf(fptr2, "%s", str);
			    		  //fprintf(fptr2, "%s", newln);
			    		  //modifyflag = TRUE;
				//tmp_obj = json_object_new_string(payload);
				//json_object_array_add(newHeatMap, tmp_obj);
				printf("s t 2\n");
				json_object_array_add(newHeatMap, obj);
				printf("s t 3\n");
				//updateflag = TRUE;
				printf("update set chargingProfile to file\n");

			}
			else
			{
			    		  // fprintf(fptr2, "%s", newln);
			    		  //fprintf(fptr2, "%s", str);
				json_object_array_add(newHeatMap, jsonitem);
				printf("add set chargingProfile to file\n");
			}


		}

#if 0
		if(updateflag == FALSE)
		{
			tmp_obj = json_object_new_string(payload);
			json_object_array_add(newHeatMap, tmp_obj);
			updateflag = TRUE;
		}
#endif

		remove(fname);
	    rename(temp, fname);

		json_object_to_file(fname, newHeatMap);
		json_object_put ( newHeatMap );


		result = TRUE;

#if 0
		if(errno >=1)
		{
			printf("has errno \n");
			sprintf(comfirmstr, "%s", ChargingProfileStatusStr[ChargingProfileStatus_Rejected] );
		}
		else
#endif
		{
			printf("has no error \n");
			sprintf(comfirmstr, "%s", ChargingProfileStatusStr[ChargingProfileStatus_Accepted] );

		}

	}
	else
	{

		printf("set chargingProfile 3\n");
		//write the base object to write.json
		json_object_array_add(newHeatMap, obj);
		json_object_to_file(fname, newHeatMap);
		//sprintf(comfirmstr, "%s", ChargingProfileStatusStr[ChargingProfileStatus_Rejected] );
		sprintf(comfirmstr, "%s", ChargingProfileStatusStr[ChargingProfileStatus_Accepted] );
		json_object_put ( newHeatMap );

		printf("set chargingProfile 4\n");

	}

	end:
	printf("set chargingProfile 1-5\n");
	sendSetChargingProfileConfirmation(uuid, comfirmstr);
	return result;


#endif

#if 0 // file style handleing
	FILE *fptr1, *fptr2;
	int lno, linectr = 0;
	int modifyflag = FALSE;
	char str[MAX],fname[MAX];
	char newln[MAX], temp[] = "./mnt/temp.json";

	printf("\n\n Replace a specific line in a text file with a new text :\n");
	printf("-------------------------------------------------------------\n");
	printf(" Input the file name to be opened : ");
	//fgets(fname, MAX, stdin);
	//fname[strlen(fname) - 1] = '\0';

	switch(connectorIdInt)
	{
		case 0:
		strcpy(fname, ChargingProfile_0_JSON );
		break;

		case 1:
		strcpy(fname, ChargingProfile_1_JSON );
		break;

		case 2:
		strcpy(fname, ChargingProfile_2_JSON );
		break;

		default:
		strcpy(fname, ChargingProfile_0_JSON );
		break;
	}


	fptr1 = fopen(fname, "r");
	if (!fptr1)
	{
		//file not exist
		printf("Unable to open the input file!!\n");
		fptr1 = fopen(fname, "wb");
		fwrite(newln , 1 , sizeof(newln) , fptr1 );

		fclose(fptr1);
		json_object_put(obj);
		json_object_put(tempobj);

	    return result;
	}


	fptr2 = fopen(temp, "w");
	if (!fptr2)
	{
		printf("Unable to open a temporary file to write!!\n");
	    fclose(fptr1);
	    return 0;
	}

	/* get the new line from the user */
	printf(" Input the content of the new line : ");
	//fgets(newln, MAX, stdin);
	memcpy(newln,payload,strlen(payload));
	/* get the line number to delete the specific line */
	printf(" Input the line no you want to replace : ");
    //scanf("%d", &lno);
	//lno++;

	// copy all contents to the temporary file other except specific line
	while (!feof(fptr1))
	{
	       strcpy(str, "\0");
	       fgets(str, MAX, fptr1);
	       if (!feof(fptr1))
	       {
	          // linectr++;
	          // if (linectr != lno)
	    	   tempobj = json_tokener_parse(str);

	    	   tempconnectorId = json_object_object_get(tempobj, "connectorId");
	    	   tempcsChargingProfiles = json_object_object_get(tempobj, "csChargingProfiles");

	    	   tempchargingProfileId = json_object_object_get(tempcsChargingProfiles, "chargingProfileId");
	    	   tempstackLevel = json_object_object_get(tempcsChargingProfiles, "stackLevel");
	    	   tempchargingProfilePurpose = json_object_object_get(tempcsChargingProfiles, "chargingProfilePurpose");

	    	   tempconnectorIdInt = json_object_get_int(connectorId);
	    	   tempchargingProfileIdInt = json_object_get_int(chargingProfileIdInt);
	    	   tempstackLevelInt = json_object_get_int(stackLevel);
	    	   tempchargingProfilePurposeStr = json_object_get_string(chargingProfilePurpose);

	    	   if((tempconnectorId == connectorId) && ((tempchargingProfileIdInt == chargingProfileIdInt) || (tempstackLevelInt == stackLevelInt) && (strcmp(tempchargingProfilePurposeStr, chargingProfilePurposeStr) == 0)))
	           {
	               //fprintf(fptr2, "%s", str);
	    		   fprintf(fptr2, "%s", newln);
	               modifyflag = TRUE;
	           }
	           else
	           {
	              // fprintf(fptr2, "%s", newln);
	        	   fprintf(fptr2, "%s", str);
	           }
	       }
	 }

	 if(modifyflag == FALSE)
	 {

		 fwrite(newln , 1 , sizeof(newln) , fptr2 );
	 }

	 result = TRUE;

	 fclose(fptr1);
	 fclose(fptr2);
	 remove(fname);
	 rename(temp, fname);
	 printf(" Replacement did successfully..!! \n");
#endif
	 json_object_put(obj);
	 json_object_put(tempobj);

	return result;
}

int handleTriggerMessageRequest(char *uuid, char *payload)
{
	int result = FAIL;

	struct json_object *obj, *requestedMessage, *connectorId;
	int connectorIdInt =0;
	char *requestedMessagestr;
	char comfirmstr[20];
	obj = json_tokener_parse(payload);
	printf("handleTriggerMessageRequest\n");

	requestedMessage = json_object_object_get(obj, "requestedMessage");
	connectorId  = json_object_object_get(obj, "connectorId");

	requestedMessagestr = (char *)json_object_get_string(requestedMessage);

	if(connectorId != NULL && connectorId > 0)
	{
		connectorIdInt = json_object_get_int(connectorId);
		sprintf((char *)ShmOCPP16Data->TriggerMessage[connectorIdInt -1].RequestedMessage, "%s" ,requestedMessagestr);
		ShmOCPP16Data->TriggerMessage[connectorIdInt -1].ConnectorId = connectorIdInt;
		ShmOCPP16Data->CsMsg.bits[connectorIdInt -1].TriggerMessageReq = 1;
	}
	else if(connectorId != NULL && connectorId <= 0)
	{
		sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Rejected] );
		goto end;
	}

	if( strcmp(requestedMessagestr, MessageTriggerStr[FirmwareStatusNotification]) == 0)
	{
		sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_Downloaded]);
		sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Accepted] );

	}
	else if(strcmp(requestedMessagestr, MessageTriggerStr[DiagnosticsStatusNotification]) == 0 )
	{
		printf("DiagnosticsStatusStr[DiagnosticsStatus_Idle] =%s\n",DiagnosticsStatusStr[DiagnosticsStatus_Idle]);
		sendDiagnosticsStatusNotificationRequest(DiagnosticsStatusStr[DiagnosticsStatus_Idle]);
		sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Accepted] );

	}
	else if(strcmp(requestedMessagestr, MessageTriggerStr[BootNotification]) == 0 )
	{
		sendBootNotificationRequest();
		sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Accepted] );

	}
	else if(strcmp(requestedMessagestr, MessageTriggerStr[Heartbeat]) == 0 )
	{
		sendHeartbeatRequest(connectorIdInt);
		sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Accepted] );
	}
	else if (strcmp(requestedMessagestr, MessageTriggerStr[MeterValues]) == 0 )
	{
		if(connectorId != NULL)
		{
			if((connectorIdInt > 0) && ((connectorIdInt -1) < (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY)))
			{
				sendMeterValuesRequest(connectorIdInt -1);
				sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Accepted] );
			}
			else
			{
				sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Rejected] );
			}

		}
		else
		{
			for(int idx=0;idx<(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY);idx++)
				sendMeterValuesRequest(idx);

			sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Accepted] );
		}

	}
	else if(strcmp(requestedMessagestr, MessageTriggerStr[StatusNotification]) == 0 )
	{
		if(connectorId != NULL)
		{
			if((connectorIdInt > 0) && ((connectorIdInt -1) < (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY)))
			{
				sendStatusNotificationRequest(connectorIdInt -1);
				sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Accepted] );
			}
			else
			{
				sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Rejected] );
			}

		}
		else
		{
			for(int idx=0;idx<(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY);idx++)
				sendStatusNotificationRequest(idx);

			sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Accepted] );
		}

	}
	else
	{
		sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_NotImplemented] );
	}

end:
	json_object_put(obj);
	sendTriggerMessageConfirmation(uuid,comfirmstr);
	//if(connectorId != NULL)
	//ShmOCPP16Data->CsMsg.bits[connectorIdInt -1].TriggerMessageConf = 1;

	return result;
}

int handleUnlockConnectorRequest(char *uuid, char *payload)
{
	int result = FAIL;

	struct json_object *obj, *connectorId;
	int connectorIdInt =0;
	char comfirmstr[20];

	obj = json_tokener_parse(payload);
	printf("handleUnlockConnectorRequest\n");

	connectorId  = json_object_object_get(obj, "connectorId");
	connectorIdInt = json_object_get_int(connectorId);

	if(CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY == 0)
	{
		sprintf(comfirmstr, "%s", UnlockStatusStr[UnlockStatus_NotSupported] );
		goto end;
	}
	else if((connectorIdInt > CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY) || (connectorIdInt <= 0))
	{
		//sprintf(comfirmstr, "%s", UnlockStatusStr[UnlockStatus_NotSupported] );
		sprintf(comfirmstr, "%s", UnlockStatusStr[UnlockFailed] );
		goto end;
	}
	else
	{
	  //check Transaction active
		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
		{
		     if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == connectorIdInt ) &&  (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '4') )
		     {
		    	 //stop Transaction
		    	 //ShmOCPP16Data->CpMsg.bits[connectorIdInt-1].StopTransactionReq = 1;
		    	 ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].UnlockConnectorReq = 1;

		     }
		}

		for (int index = 0; index < CCS_QUANTITY; index++)
		{
		     if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == connectorIdInt ) &&  (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == '4'))
		     {
		    	 //stop Transaction
		    	 //ShmOCPP16Data->CpMsg.bits[connectorIdInt-1].StopTransactionReq = 1;
		    	 ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].UnlockConnectorReq = 1;

		     }
		}

		for (int index = 0; index < GB_QUANTITY; index++)
		{
		     if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == connectorIdInt ) &&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '4'))
		     {
		    	 //stop Transaction
		    	 //ShmOCPP16Data->CpMsg.bits[connectorIdInt-1].StopTransactionReq = 1;
		    	 ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].UnlockConnectorReq = 1;

		     }
		}



		ShmOCPP16Data->UnlockConnector[connectorIdInt-1].ConnectorId = connectorIdInt;
		strcpy(ShmOCPP16Data->UnlockConnector[connectorIdInt-1].guid, uuid);
	//	sprintf(comfirmstr, "%s",  UnlockStatusStr[Unlocked] );
		json_object_put(obj);
		result = TRUE;
		return result;

	}

end:
	json_object_put(obj);
	sendUnlockConnectorConfirmation(uuid, comfirmstr);
	return result;
}

int handleUpdateFirmwareRequest(char *uuid, char *payload)
{
	int result = FAIL;
	pthread_t t;


	pthread_create(&t, NULL, UpdateFirmwareProcess, payload); // 建�?�執行�?
	pthread_join(t, NULL); // 等�?�執行�??��?完�?

	sendUpdateFirmwareConfirmation(uuid);
	ShmOCPP16Data->MsMsg.bits.UpdateFirmwareConf =1;
	//ShmOCPP16Data->MsMsg.bits.UpdateFirmwareReq = 1;
	return result;
}

void UpdateFirmwareProcess(void* data)
{
	struct json_object *obj, *location, *retries, *retrieveDate, *retryInterval;
	int retriesInt =0, retryIntervalInt=0;
	char protocol[10], user[50],password[50],host[50], path[50], ftppath[60],host1[50],path1[20];
	int port=0;
	char *locationstr, *retrieveDatestr;
	//char fname[50]="00000_2018-09-07 160902_CSULog.zip";
	char comfirmstr[20];
	int isSuccess = 0;
	char ftpbuf[200];
	char temp[100];
	char * pch;

	char *str = (char*) data; // ?��?輸入資�?

	obj = json_tokener_parse(str);
	printf("handleUpdateFirmwareRequest\n");

	location  = json_object_object_get(obj, "location");
	retries    = json_object_object_get(obj, "retries");
	retrieveDate  = json_object_object_get(obj, "retrieveDate");
	retryInterval   = json_object_object_get(obj, "retrieveDate");

	locationstr = (char *)json_object_get_string(location);

	if(retries != NULL)
	retriesInt = json_object_get_int(retries);

	retrieveDatestr = (char *)json_object_get_string(retrieveDate);

	if(retryInterval != NULL)
	retryIntervalInt = json_object_get_int(retryInterval);

	memset(ftppath, 0, sizeof(ftppath));
	memset(path, 0, sizeof(path));

	if(strncmp(locationstr,"http", 4) == 0)
	{
		sscanf(locationstr,"%[^:]:%*2[/]%[^/]/%199[^\n]",
		    	    			         protocol, host, path);

		    	//sscanf(locationstr,"%[^:]:%*2[/]%[^:]:%[^@]@%[^/]%199[^\n]",
		    	    	//	         protocol, user, password, host, path);
		sprintf(ftppath,"/%s", path);

		printf("protocol =%s\n",protocol);

		printf("host =%s\n",host);

		printf("path =%s\n",path);
		printf("ftppath=%s\n",ftppath);
		int ftppathlen=strlen(ftppath);
		int i=1;
		char filenametemp[50];
		while(i < ftppathlen)
		{
		   printf("ftppath[ftppathlen-i]:%c\n",ftppath[ftppathlen-i]);
		   int len=ftppathlen-i;
		   if(ftppath[len]== 47) // '/' ascll code: 47
		    {
		       printf("compare all right\n");
		       break;
		    }

		    printf("test substr\n");
		    i=i+1;

		}

		memset(filenametemp, 0, sizeof(filenametemp));
		strncpy(filenametemp, ftppath+(ftppathlen-i+1), i+1);
		filenametemp[i+1] = 0;
		printf("filenametemp:%s\n", filenametemp);

		sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_Downloading]);


		 do{
			 isSuccess = httpDownLoadFile(host, ftppath, filenametemp, locationstr);
		    	 sleep(retryIntervalInt);
		    }while((!isSuccess)&&(retriesInt > 0 && retriesInt --));

		isSuccess = httpDownLoadFile(host, ftppath, filenametemp, locationstr);

		if(!isSuccess)
		{
		    //BulldogUtil.sleepMs(interval*1000);
		    printf("Update firmware request and download file fail.\n");
			sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_DownloadFailed]);
		}
		else
		{
			ShmOCPP16Data->MsMsg.bits.UpdateFirmwareReq = 1;
			sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_Downloaded]);
			isUpdateRequest = TRUE;
		}

	}
    else // ftp
	{
    	memset(ftpbuf, 0, sizeof(ftpbuf));
    	memset(temp, 0, sizeof(temp));
    	strcpy(ftpbuf, locationstr/*"ftp://ipc_ui:pht2016@ftp.phihong.com.tw/DC/log/DemoDC1_2018-07-13_185011_PSULog.zip"*/ );
    	int ftppathlen=strlen(ftpbuf);
    	int i=1;
    	char filenametemp[50];
    	while(i < ftppathlen)
    	{
    		printf("ftppath[ftppathlen-i]:%c\n",ftpbuf[ftppathlen-i]);
    		int len=ftppathlen-i;
    		if(ftpbuf[len]== 47) // '/' ascll code: 47
    		{
    			printf("all right\n");
    			break;
    		}

    		printf("test substr\n");
    		i=i+1;

    	}

    	memset(filenametemp, 0, sizeof(filenametemp));
    	strncpy(filenametemp, ftpbuf+(ftppathlen-i+1), i+1);
    	filenametemp[i+1] = 0;
    	printf("filenametemp:%s\n", filenametemp);
    	strncpy(temp, ftpbuf, ftppathlen-i+1);

    	pch=strchr(temp,'@');
    	if(pch==NULL)
    	{
    		sscanf(temp,"%[^:]:%*2[/]%[^:]:%i/%[a-zA-Z0-9._/-]",
    				         protocol, host, &port, path);
    		strcpy(user,"anonymous");
    		strcpy(password,"");
    	}
    	else
    	{
    		printf("pch=%s\n", pch);
    		sscanf(temp,"%[^:]:%*2[/]%[^:]:%[^@]@%[^:]:%i/%199[^\n]",
    				protocol, user, password, host, &port, path);
    	}

    	sscanf(host,"%[^/]%s",host1, path1);
    	sprintf(ftppath,"%s", path1);

    	printf("protocol =%s\n",protocol);
    	printf("user =%s\n",user);
    	printf("password =%s\n",password);
    	printf("host1 =%s\n",host1);
    	printf("port =%d\n",port);
    	printf("path1 =%s\n",path1);
    	printf("ftppath=%s\n",ftppath);

		//ftpFile(host, user, password, port, ftppath, fname);
		//download firmware pthred
    	if(port == 0)
    		port = 21;

		sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_Downloading]);

		do{
			 isSuccess = ftpDownLoadFile(host1, user, password, port, ftppath, filenametemp);
			 sleep(retryIntervalInt);
		}while((!isSuccess)&&(retriesInt > 0 && retriesInt --));




		if(!isSuccess)
		{
	        //BulldogUtil.sleepMs(interval*1000);
	        printf("Update firmware request and download file fail.\n");
			sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_DownloadFailed]);
		}
		else
		{
			ShmOCPP16Data->MsMsg.bits.UpdateFirmwareReq = 1;
			sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_Downloaded]);
			isUpdateRequest = TRUE;
		}

	}

	json_object_put(obj);
	pthread_exit(NULL); // ?��?�執行�?

}

//==========================================
// Handle server response routine
//==========================================
void handleAuthorizeResponse(char *payload, int gun_index)
{
	struct json_object *obj, *message, *context;
	struct json_object *root_obj, *temp_obj, *jsonitem, *expiryDateitem, *parentIdTagitem, *statusitem;
	char* filename = AuthorizationCache_JSON;
	char* buffer = NULL;
	FILE *pFile;
	char temp[400];
	obj = json_tokener_parse(payload);
	printf("handleAuthorizeResponse\n");

	#ifdef SystemLogMessage
	if(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "expiryDate") != NULL)
	DEBUG_INFO("expiryDate: %s\n", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "expiryDate")));

	if(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "parentIdTag") != NULL)
	DEBUG_INFO("parentIdTag: %s\n", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "parentIdTag")));
	DEBUG_INFO("status: %s\n", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "status")));
	#endif

	printf("handleAuthorizeResponse -1\n");
	if(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "expiryDate") != NULL)
	strcpy((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate, (char *)json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "expiryDate")));
	printf("handleAuthorizeResponse -1-0\n");
	if(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "parentIdTag") != NULL)
	strcpy((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag, (char *)json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "parentIdTag")));
	strcpy((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status, (char *)json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "status")));
	printf("handleAuthorizeResponse -2\n");

    printf("authen reponce 1\n");
	//Update idTag information to authorization cache if supproted
	if((strcmp(ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizationCacheEnabled].ItemData, "TRUE") == 0) &&  (ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag != NULL) && (ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate != NULL) )
	{
		 printf("authen reponce 2\n");
		if((access(filename,F_OK))!=-1)
		{
			printf("authen reponce 3\n");
			printf("AuthorizationCache exist.\n");
		}
		else
		{
			printf("authen reponce 4\n");
			printf("AuthorizationCache not exist\n");
			FILE *log = fopen(filename, "w+");
			printf("authen reponce 4 -1\n");
			//fprintf( log , "" ); --- remove temporally
			printf("authen reponce 4 -2\n");
			if(log == NULL)
			{
			   printf("log is NULL\n");
			   goto out;
			}
			else
			{
			   fclose(log);
			}
		}
		printf("authen reponce 5\n");

		get_file_contents(filename, &buffer);
		printf("%s",buffer);
		root_obj = json_tokener_parse(buffer);
		if(root_obj == NULL)
		{
			message = json_object_new_array();
			context = json_object_new_object();
			if(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate != NULL)
			{
				json_object_object_add(context, "expiryDate", json_object_new_string(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate));
			}
			else
			{
				json_object_object_add(context, "expiryDate", json_object_new_string(""));
			}


			if(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag != NULL)
			{
				json_object_object_add(context, "parentIdTag",json_object_new_string(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag));
			}
			else
			{
				//write Authorize IdTag
				json_object_object_add(context, "parentIdTag",json_object_new_string(ShmOCPP16Data->Authorize.IdTag));
			}


			json_object_object_add(context, "status", json_object_new_string(ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status));

			json_object_array_add(message, context);
			memset(temp,0,sizeof temp);
			sprintf(temp, "%s", json_object_to_json_string(message));

			pFile = fopen( filename,"w" );

		    if( NULL == pFile ){
				printf( "open failure" );

		    }else{
				fwrite(temp,1,sizeof(temp),pFile);
				fclose(pFile);
		    }

		    json_object_put(message); // Delete the json object

		}
		else
		{
			struct json_object *newHeatMap = json_object_new_array();
			int n_items = json_object_array_length(root_obj);

		    for(int i=0;i<n_items;i++)
			{
		    	int responseIdTagInfoAsZero= 0;
				jsonitem = json_object_array_get_idx(root_obj, i);
				printf("%lu. %s\n",i+1,json_object_get_string(jsonitem));

				expiryDateitem = json_object_object_get(jsonitem, "expiryDate");
				parentIdTagitem = json_object_object_get(jsonitem, "parentIdTag");
				statusitem = json_object_object_get(jsonitem, "status");

				printf("parentIdTagitem=%s\n",json_object_get_string(parentIdTagitem));

				//printf message
				if((ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag == NULL) || strcmp(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag, "") == 0)
				{
					printf("ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag is NULL\n");
					responseIdTagInfoAsZero = 1;
				}
				else
				{
					printf("ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag=%s\n",ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag);
				}

			   if((responseIdTagInfoAsZero == 0)&&(strcmp(json_object_get_string(parentIdTagitem), ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag) == 0))
			   {
				   //modify item
				   temp_obj = json_object_new_object();
				   if(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate != NULL)
				   {
					   json_object_object_add(temp_obj, "expiryDate", json_object_new_string(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate));
				   }
				   else
				   {
					   json_object_object_add(temp_obj, "expiryDate", json_object_new_string(""));
				   }


				   if(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag != NULL)
				   {
					   json_object_object_add(temp_obj, "parentIdTag", json_object_new_string(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag));

				   }
				   else
				   {
					   json_object_object_add(temp_obj, "parentIdTag", json_object_new_string(json_object_get_string(parentIdTagitem)));

				   }


				   json_object_object_add(temp_obj, "status", json_object_new_string(ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status));
				   json_object_array_add(newHeatMap, temp_obj);

			   }
			   else
			   {
				   //wrie original item
				   json_object_array_add(newHeatMap, jsonitem);
				   printf("authen reponce 5-1\n");
			   }

			}

		    //(1)write to temp file (2)remove original file (3) rename filename  of temp file
		    char temp[] = "temp.json";

		    FILE *fp;
		    fp=fopen(temp,"w");
		    fclose(fp);

		    remove(filename);
		    rename(temp, filename);

		    json_object_to_file(filename, newHeatMap);
			printf("authen reponce 5-2\n");
		    json_object_put(newHeatMap); // Delete the json object
		    printf("authen reponce 5-3\n");

		}

		 printf("authen reponce 5-4\n");
		 free(buffer);
		 printf("authen reponce 5-5\n");
		// json_object_put(root_obj); // Delete the json object
		 printf("authen reponce 5-6\n");

	}

	out:
	json_object_put(obj);
	ShmOCPP16Data->SpMsg.bits.AuthorizeReq = 0;
	ShmOCPP16Data->SpMsg.bits.AuthorizeConf = 1; // inform csu
	authorizeRetryTimes = 0;

	//for test
#if 0
	ShmOCPP16Data->CpMsg.bits[0].StartTransactionReq = 1;
	ShmOCPP16Data->CpMsg.bits[0].StartTransactionConf = 1;
	ShmSysConfigAndInfo->SysInfo.ChademoChargingData[0].SystemStatus ='3'; //preparing
	teststatus = 0; //for  startTransaction
#endif
}

void handleBootNotificationResponse(char *payload, int gun_index)
{
	struct json_object *obj;
	char *status;
	obj = json_tokener_parse(payload);

	printf("handleBootNotificationResponse\n");
	#ifdef SystemLogMessage
	DEBUG_INFO("currentTime: %s\n", json_object_get_string(json_object_object_get(obj, "currentTime")));
	DEBUG_INFO("interval: %d\n", json_object_get_int(json_object_object_get(obj, "interval")));
	DEBUG_INFO("status: %s\n", json_object_get_string(json_object_object_get(obj, "status")));
	#endif

	//write back to ShmOCPP16Data->BootNotification
	strcpy((char *)ShmOCPP16Data->BootNotification.ResponseCurrentTime,(char *)json_object_get_string(json_object_object_get(obj, "currentTime")));
	ShmOCPP16Data->BootNotification.ResponseHeartbeatInterval = json_object_get_int(json_object_object_get(obj, "interval"));
	strcpy((char *)ShmOCPP16Data->BootNotification.ResponseStatus, (char *)json_object_get_string(json_object_object_get(obj, "status")));

	status = json_object_get_string(json_object_object_get(obj, "status"));


	BootNotificationInterval = ShmOCPP16Data->BootNotification.ResponseHeartbeatInterval;
	HeartBeatWaitTime = BootNotificationInterval;

    printf("test 1\n");
	if((strcmp(status, RegistrationStatusStr[RegistrationStatus_Accepted]) == 0 )/* ||
		(strcmp(status, RegistrationStatusStr[RegistrationStatus_Pending]) == 0) ||
		(strcmp(status, RegistrationStatusStr[RegistrationStatus_Rejected]) == 0)*/)
	{
		server_sign = TRUE;
		server_pending =FALSE;

	}
	else if(strcmp(status, RegistrationStatusStr[RegistrationStatus_Pending]) == 0)
	{
		server_pending = TRUE;
	}


	double diff_t;
	struct tm tp;
	char buf[28];
	char timebuf[50];
	strptime(ShmOCPP16Data->BootNotification.ResponseCurrentTime, "%Y-%m-%dT%H:%M:%S", &tp);
	tp.tm_isdst = -1;
	time_t utc = mktime(&tp);

	strftime(buf, 28, "%Y-%m-%d %H:%M:%S", &tp);
	memset(timebuf, 0, sizeof timebuf);
	sprintf(timebuf,"date -s '%s'",buf);
	printf("timebuf=%s\n",timebuf);
	system(timebuf);

	//==============================================
	// RTC sync
	//==============================================
	system("/sbin/hwclock -w --systohc");

	printf("test 2\n");
	json_object_put(obj); // Delete the json object

	printf("test 3\n");

	ShmOCPP16Data->OcppConnStatus = 1; ////0: disconnected, 1: connected

	ShmOCPP16Data->SpMsg.bits.BootNotificationConf = 1;

}

void handleDataTransferResponse(char *payload, int gun_index)
{
	struct json_object *obj;
	obj = json_tokener_parse(payload);

	#ifdef SystemLogMessage
	DEBUG_INFO("data: %s\n", json_object_get_string(json_object_object_get(obj, "data")));
	#endif
}

void handleDiagnosticsStatusNotificationResponse(char *payload, int gun_index)
{
	struct json_object *obj;
	obj = json_tokener_parse(payload);
//	ShmOCPP16Data->SpMsg.bits.DiagnosticsStatusNotificationReq = 0;
//	ShmOCPP16Data->SpMsg.bits.DiagnosticsStatusNotificationConf = 1;
	//No fields are defined.
}

void handleFirmwareStatusNotificationResponse(char *payload, int gun_index)
{
	struct json_object *obj;
	obj = json_tokener_parse(payload);
	ShmOCPP16Data->SpMsg.bits.FirmwareStatusNotificationReq = 0;
	ShmOCPP16Data->SpMsg.bits.FirmwareStatusNotificationConf = 1;

	//No fields are defined.
}

void handleHeartbeatResponse(char *payload, int gun_index)
{
	struct json_object *obj;
	obj = json_tokener_parse(payload);
	printf("handleHeartbeatResponse\n");

	#ifdef SystemLogMessage
	DEBUG_INFO("currentTime: %s\n", json_object_get_string(json_object_object_get(obj, "currentTime")));
	#endif

	strcpy((char *)ShmOCPP16Data->Heartbeat.ResponseCurrentTime,(char *)json_object_get_string(json_object_object_get(obj, "currentTime")));

	double diff_t;
	struct tm tp;
	char buf[28];
	char timebuf[50];
	strptime(ShmOCPP16Data->Heartbeat.ResponseCurrentTime, "%Y-%m-%dT%H:%M:%S", &tp);
	tp.tm_isdst = -1;
	time_t utc = mktime(&tp);

	strftime(buf, 28, "%Y-%m-%d %H:%M:%S", &tp);
	memset(timebuf, 0, sizeof timebuf);
	sprintf(timebuf,"date -s '%s'",buf);
	printf("timebuf=%s\n",timebuf);
	system(timebuf);

	//==============================================
	// RTC sync
	//==============================================
	system("/sbin/hwclock -w --systohc");

	json_object_put(obj); // Delete the json object


}

void handleMeterValuesResponse(char *payload, int gun_index)
{
	struct json_object *obj;
	obj = json_tokener_parse(payload);

	//No fields are defined.
}

void handleStartTransactionResponse(char *payload, int gun_index)
{
	struct json_object *obj;
	obj = json_tokener_parse(payload);

//	gun_index = gun_index-1;
	#ifdef SystemLogMessage
	DEBUG_INFO("idTagInfo-expiryDate: %s\n", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "expiryDate")));
	DEBUG_INFO("idTagInfo-parentIdTag: %s\n", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "parentIdTag")));
	DEBUG_INFO("idTagInfo-status: %s\n", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "status")));
	DEBUG_INFO("transactionId: %d\n", json_object_get_int(json_object_object_get(obj, "transactionId")));
	#endif

	printf("handleStartTransactionResponse\n");

	if(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "expiryDate") != NULL) // expiryDate is option
	sprintf((char *)ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.ExpiryDate, "%s", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "expiryDate")));
	printf("handleStartTransactionResponse 01\n");

	if(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "parentIdTag") != NULL) // parentIdTag is option
	sprintf((char *)ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.ParentIdTag, "%s", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "parentIdTag")));

	printf("handleStartTransactionResponse 02\n");
	sprintf((char *)ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.Status, "%s", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "status")));
	//ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId  = json_object_get_int(json_object_object_get(obj, "transactionId"));
	ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId = json_object_get_int(json_object_object_get(obj, "transactionId"));
	printf("handleStartTransactionResponse 03\n");
	int transactionIdInt = json_object_get_int(json_object_object_get(obj, "transactionId"));

	printf("handleStartTransactionResponse 1\n");

	printf("handleStartTransactionResponse 2\n");
	ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionConf = 1;
	ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionReq = 0;


	//for test
#if 0
	cpinitateMsg.bits[gun_index].StatusNotificationReq = 1;
	ShmOCPP16Data->SpMsg.bits.AuthorizeReq = 0;
#endif
	if(strcmp(ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.Status, "Accepted") == 0)
	{
#if 0
		//check Transaction active
		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
			{
				ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus = '4';
			}
		}

		for (int index = 0; index < CCS_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
			{
				ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus = '4';
			}
		}

		for (int index = 0; index < GB_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
			{
				ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus = '4';
			}
	    }
#endif
		//add Charging Record
		SettingChargingRecord(gun_index, transactionIdInt);

	}
}

void handleStatusNotificationResponse(char *payload, int gun_index)
{
	struct json_object *obj;
	obj = json_tokener_parse(payload);

	printf("handleStatusNotificationResponse\n");

	cpinitateMsg.bits[gun_index].StatusNotificationReq = 0;
	cpinitateMsg.bits[gun_index].StatusNotificationConf = 1;

	//for test
#if 0
	if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[gun_index].SystemStatus =='1') // Idle
	{
		ShmSysConfigAndInfo->SysInfo.ChademoChargingData[gun_index].SystemStatus ='3'; //preparing
		cpinitateMsg.bits[gun_index].StatusNotificationReq = 1;
	}
	else if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[gun_index].SystemStatus =='3')//preparing
	{
		printf("preparing UserPlugGun=%d\n",UserPlugGun);
		if(UserPlugGun == 1)
		{
			ShmSysConfigAndInfo->SysInfo.ChademoChargingData[gun_index].SystemStatus ='1';
			cpinitateMsg.bits[gun_index].StatusNotificationReq = 1;
			UserPlugGun = 0;
		}
		else
		{
			ShmOCPP16Data->SpMsg.bits.AuthorizeReq = 1;

		}

	}
#endif
	//No fields are defined.
}

void handleStopTransactionnResponse(char *payload, int gun_index)
{
	struct json_object *obj;
	obj = json_tokener_parse(payload);
    printf("handleStopTransactionnResponse\n");
   // gun_index = gun_index - 1;
	if(json_object_object_get(obj, "idTagInfo") != NULL) // option
	{

		if(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "expiryDate") != NULL) // option
		sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].ResponseIdTagInfo.ExpiryDate, "%s", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "expiryDate")));

		if(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "parentIdTag") != NULL) // option
		sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].ResponseIdTagInfo.ParentIdTag, "%s", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "parentIdTag")));

		sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].ResponseIdTagInfo.Status, "%s", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "status")));


#ifdef SystemLogMessage
DEBUG_INFO("idTagInfo-expiryDate: %s\n", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "expiryDate")));
DEBUG_INFO("idTagInfo-parentIdTag: %s\n", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "parentIdTag")));
DEBUG_INFO("idTagInfo-status: %s\n", json_object_get_string(json_object_object_get(json_object_object_get(obj, "idTagInfo"), "status")));
#endif

	}

	ShmOCPP16Data->CpMsg.bits[gun_index].StopTransactionConf = 1;
	ShmOCPP16Data->CpMsg.bits[gun_index].StopTransactionReq = 0;
	json_object_put(obj); // Delete the json object

	//for test
	//UserPlugGun = 0;
#if 0
	if(strcmp(ShmOCPP16Data->StopTransaction[gun_index].ResponseIdTagInfo.Status, "Accepted") == 0)
	{
		//check Transaction active
		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
			{
				ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus = '3'; //3: preparing

			}
		}

		for (int index = 0; index < CCS_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
			{
				ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus = '3'; //3: preparing

			}
		}

		for (int index = 0; index < GB_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
			{
				ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus = '3'; //3: preparing

			}
		}

		cpinitateMsg.bits[gun_index].StatusNotificationReq = 1;
		//ShmOCPP16Data->SpMsg.bits.AuthorizeReq = 1;

	}
#endif


}

//==========================================
// Handle Error routine
//==========================================
void handleError(char *id, char *errorCode, char *errorDescription,char *payload)
{
	printf("handleError 1\n");
	struct json_object *obj;
	obj = json_tokener_parse(payload);
	printf("handleError 2\n");
	#ifdef SystemLogMessage
	DEBUG_INFO("errorCode: %s\n", errorCode);

	DEBUG_INFO("errorDescription: %s\n", errorDescription);
	if(obj != NULL)
	DEBUG_INFO("errorDetails: %s\n", payload);
	#endif
}



//===============================================
// Common routine
//===============================================
int initialConfigurationTable(void)
{
	printf("initialConfigurationTable  \n");
	memset(&(ShmOCPP16Data->ConfigurationTable), 0, sizeof(struct OCPP16ConfigurationTable) );
	/*Core Profile*/
	//AllowOfflineTxForUnknownId
	ShmOCPP16Data->ConfigurationTable.CoreProfile[AllowOfflineTxForUnknownId].ItemAccessibility = 1;
	printf("AllowoddlineTXForUnknownId type: %d  \n", ShmOCPP16Data->ConfigurationTable.CoreProfile[AllowOfflineTxForUnknownId].ItemAccessibility);
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AllowOfflineTxForUnknownId].ItemName, "AllowOfflineTxForUnknownId");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AllowOfflineTxForUnknownId].ItemData, "TRUE" );
	printf("initialConfigurationTable -1  \n");
	//AuthorizationCacheEnabled
	ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizationCacheEnabled].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizationCacheEnabled].ItemName, "AuthorizationCacheEnabled");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizationCacheEnabled].ItemData, "FALSE" );


	//AuthorizeRemoteTxRequests
	ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizeRemoteTxRequests].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizeRemoteTxRequests].ItemName, "AuthorizeRemoteTxRequests");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizeRemoteTxRequests].ItemData, "TRUE" );


	//BlinkRepeat
	ShmOCPP16Data->ConfigurationTable.CoreProfile[BlinkRepeat].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[BlinkRepeat].ItemName, "BlinkRepeat");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[BlinkRepeat].ItemData, "0" );

	//ClockAlignedDataInterval
	ShmOCPP16Data->ConfigurationTable.CoreProfile[ClockAlignedDataInterval].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ClockAlignedDataInterval].ItemName, "ClockAlignedDataInterval");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ClockAlignedDataInterval].ItemData, "0" );

	//ConnectionTimeOut
	ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemName, "ConnectionTimeOut");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemData, "60" );

	//GetConfigurationMaxKeys
	ShmOCPP16Data->ConfigurationTable.CoreProfile[GetConfigurationMaxKeys].ItemAccessibility =0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[GetConfigurationMaxKeys].ItemName, "GetConfigurationMaxKeys");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[GetConfigurationMaxKeys].ItemData, "43" );

	// HeartbeatInterval
	ShmOCPP16Data->ConfigurationTable.CoreProfile[HeartbeatInterval].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[HeartbeatInterval].ItemName, "HeartbeatInterval");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[HeartbeatInterval].ItemData, "10" );

	// LightIntensity
	ShmOCPP16Data->ConfigurationTable.CoreProfile[LightIntensity].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LightIntensity].ItemName, "LightIntensity");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LightIntensity].ItemData, "0" );

	// LocalAuthorizeOffline
	ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalAuthorizeOffline].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalAuthorizeOffline].ItemName, "LocalAuthorizeOffline");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalAuthorizeOffline].ItemData, "TRUE" );

	// LocalPreAuthorize
	ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalPreAuthorize].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalPreAuthorize].ItemName, "LocalPreAuthorize");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalPreAuthorize].ItemData, "FALSE" );

	// MaxEnergyOnInvalidId
	ShmOCPP16Data->ConfigurationTable.CoreProfile[MaxEnergyOnInvalidId].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MaxEnergyOnInvalidId].ItemName, "MaxEnergyOnInvalidId");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MaxEnergyOnInvalidId].ItemData, "0" );

	// MeterValuesAlignedData
	ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedData].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedData].ItemName, "MeterValuesAlignedData");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedData].ItemData, "V,A,KW,KWh" );

	// MeterValuesAlignedDataMaxLength
	ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedDataMaxLength].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedDataMaxLength].ItemName, "MeterValuesAlignedDataMaxLength");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedDataMaxLength].ItemData, "4" );

	// MeterValuesSampledData
	ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledData].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledData].ItemName, "MeterValuesSampledData");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledData].ItemData, "V,A,KW,KWh" );

	// MeterValuesSampledDataMaxLength
	ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledDataMaxLength].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledDataMaxLength].ItemName, "MeterValuesSampledDataMaxLength");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledDataMaxLength].ItemData, "4" );

	// MeterValueSampleInterval
	ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValueSampleInterval].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValueSampleInterval].ItemName, "MeterValueSampleInterval");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValueSampleInterval].ItemData, "10" );


	// MinimumStatusDuration
	ShmOCPP16Data->ConfigurationTable.CoreProfile[MinimumStatusDuration].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MinimumStatusDuration].ItemName, "MinimumStatusDuration");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MinimumStatusDuration].ItemData, "0" );

	// NumberOfConnectors
	ShmOCPP16Data->ConfigurationTable.CoreProfile[NumberOfConnectors].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[NumberOfConnectors].ItemName, "NumberOfConnectors");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[NumberOfConnectors].ItemData, "3" );

	// ResetRetries
	ShmOCPP16Data->ConfigurationTable.CoreProfile[ResetRetries].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ResetRetries].ItemName, "ResetRetries");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ResetRetries].ItemData, "3" );

	// ConnectorPhaseRotation
	ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectorPhaseRotation].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectorPhaseRotation].ItemName, "ConnectorPhaseRotation");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectorPhaseRotation].ItemData, "Unknown" );

	// ConnectorPhaseRotationMaxLength
	ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectorPhaseRotationMaxLength].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectorPhaseRotationMaxLength].ItemName, "ConnectorPhaseRotationMaxLength");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectorPhaseRotationMaxLength].ItemData, "1" );

	// StopTransactionOnEVSideDisconnect
	ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnEVSideDisconnect].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnEVSideDisconnect].ItemName, "StopTransactionOnEVSideDisconnect");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnEVSideDisconnect].ItemData, "TRUE" );

	// StopTransactionOnInvalidId
	ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnInvalidId].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnInvalidId].ItemName, "StopTransactionOnInvalidId");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnInvalidId].ItemData, "FALSE" );

	// StopTxnAlignedData
	ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnAlignedData].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnAlignedData].ItemName, "StopTxnAlignedData");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnAlignedData].ItemData, "Energy.Active.Import.Register" );

	// StopTxnAlignedDataMaxLength
	ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnAlignedDataMaxLength].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnAlignedDataMaxLength].ItemName, "StopTxnAlignedDataMaxLength");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnAlignedDataMaxLength].ItemData, "0" );

	// StopTxnSampledData
	ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnSampledData].ItemAccessibility = 1;

	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnSampledData].ItemName, "StopTxnSampledData");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnSampledData].ItemData, "Energy.Active.Import.Register" );

	// StopTxnSampledDataMaxLength
	ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnSampledDataMaxLength].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnSampledDataMaxLength].ItemName, "StopTxnSampledDataMaxLength");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnSampledDataMaxLength].ItemData, "0" );

	// SupportedFeatureProfiles
	ShmOCPP16Data->ConfigurationTable.CoreProfile[SupportedFeatureProfiles].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[SupportedFeatureProfiles].ItemName, "SupportedFeatureProfiles");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[SupportedFeatureProfiles].ItemData, "Core,FirmwareManagement,LocalAuthListManagement,Reservation,SmartCharging,RemoteTrigger" );

	// SupportedFeatureProfilesMaxLength
	ShmOCPP16Data->ConfigurationTable.CoreProfile[SupportedFeatureProfilesMaxLength].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[SupportedFeatureProfilesMaxLength].ItemName, "SupportedFeatureProfilesMaxLength");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[SupportedFeatureProfilesMaxLength].ItemData, "6" );

	// TransactionMessageAttempts
	ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageAttempts].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageAttempts].ItemName, "TransactionMessageAttempts");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageAttempts].ItemData, "3" );

	// TransactionMessageRetryInterval
	ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemName, "TransactionMessageRetryInterval");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemData, "60" );

	// UnlockConnectorOnEVSideDisconnect
	ShmOCPP16Data->ConfigurationTable.CoreProfile[UnlockConnectorOnEVSideDisconnect].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[UnlockConnectorOnEVSideDisconnect].ItemName, "UnlockConnectorOnEVSideDisconnect");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[UnlockConnectorOnEVSideDisconnect].ItemData, "TRUE" );

	// WebSocketPingInterval
	ShmOCPP16Data->ConfigurationTable.CoreProfile[WebSocketPingInterval].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[WebSocketPingInterval].ItemName, "WebSocketPingInterval");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[WebSocketPingInterval].ItemData, "30" );


	/* Local Auth List Management Profile*/
	//LocalAuthListEnabled
	ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemName, "LocalAuthListEnabled");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData, "TRUE" );

	//LocalAuthListMaxLength
	ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListMaxLength].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListMaxLength].ItemName, "LocalAuthListMaxLength");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListMaxLength].ItemData, "500" );

	//SendLocalListMaxLength
	ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[SendLocalListMaxLength].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[SendLocalListMaxLength].ItemName, "SendLocalListMaxLength");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[SendLocalListMaxLength].ItemData, "500" );

	//ReserveConnectorZeroSupported
	ShmOCPP16Data->ConfigurationTable.ReservationProfile[ReserveConnectorZeroSupported].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.ReservationProfile[ReserveConnectorZeroSupported].ItemName, "ReserveConnectorZeroSupported");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.ReservationProfile[ReserveConnectorZeroSupported].ItemData, "FALSE" );


	/*  Smart Charging Profile */
	//ChargeProfileMaxStackLevel
	ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargeProfileMaxStackLevel].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargeProfileMaxStackLevel].ItemName, "ChargeProfileMaxStackLevel");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargeProfileMaxStackLevel].ItemData, "3" );

	// ChargingScheduleAllowedChargingRateUnit
	ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargingScheduleAllowedChargingRateUnit].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargingScheduleAllowedChargingRateUnit].ItemName, "ChargingScheduleAllowedChargingRateUnit");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargingScheduleAllowedChargingRateUnit].ItemData, "Current" );

	// ChargingScheduleMaxPeriods
	ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargingScheduleMaxPeriods].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargingScheduleMaxPeriods].ItemName, "ChargingScheduleMaxPeriods");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargingScheduleMaxPeriods].ItemData, "10" );

	// ConnectorSwitch3to1PhaseSupported
	ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ConnectorSwitch3to1PhaseSupported].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ConnectorSwitch3to1PhaseSupported].ItemName, "ConnectorSwitch3to1PhaseSupported");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ConnectorSwitch3to1PhaseSupported].ItemData, "TRUE" );

	// MaxChargingProfilesInstalled
	ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[MaxChargingProfilesInstalled].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[MaxChargingProfilesInstalled].ItemName, "MaxChargingProfilesInstalled");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[MaxChargingProfilesInstalled].ItemData, "9" );

#if 0
	//write Configuration to flash
	unsigned int i,Chk;
	unsigned char *ptr;
	int fd,wrd;

	// Save factory default setting value to flash backup setting block
	fd = open("/Storage/OCPP/OCPPConfiguration.txt", O_RDWR);
	if (fd < 0)
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("open /Storage/OCPP/OCPPConfiguration.txt NG");
		#endif
		free(ptr);
		return 0;
	}
	wrd=write(fd, &ShmOCPP16Data->ConfigurationTable, sizeof(struct OCPP16ConfigurationTable));
	close(fd);
	if(wrd!=(sizeof(struct SysConfigData)))
	{
		#ifdef SystemLogMessage
		DEBUG_ERROR("write /Storage/OCPP/OCPPConfiguration.txt NG");
		#endif
		free(ptr);
		return 0;
	}
#endif
	return 0;
}



void getKeyValue(char *keyReq)
{
	 int isEmpty = FALSE;
	 int isKnowKey = FALSE;
	 int unKnowIndex = 0;

	 printf("enter getKeyValue \n");
	 printf("keyReq= %s\n", keyReq);

	 if((keyReq == NULL) || (strlen(keyReq) == 0))
	     isEmpty = TRUE;

	 printf("getkey_1\n");

	 if(isEmpty || strcmp(keyReq, "AllowOfflineTxForUnknownId") == 0)
	 {
		printf("getkey_1_0_0\n");
	             		//debug.logout("Request key: " + (isEmpty?"AllowOfflineTxForUnknownId":keyReq[iReq]));
		strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_AllowOfflineTxForUnknownId].Item, "AllowOfflineTxForUnknownId");
		printf("getkey_1_0\n");

		strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AllowOfflineTxForUnknownId].Key, "AllowOfflineTxForUnknownId");
		printf("getkey_1_1\n");
		if(ShmOCPP16Data->ConfigurationTable.CoreProfile[AllowOfflineTxForUnknownId].ItemAccessibility == 1)
		{
			strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AllowOfflineTxForUnknownId].ReadOnly, "0"/*"FALSE"*/);
		}
		else
		{
			strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AllowOfflineTxForUnknownId].ReadOnly, "1"/*"TRUE"*/);
		}

		printf("getkey_1_2\n");
		strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AllowOfflineTxForUnknownId].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AllowOfflineTxForUnknownId].ItemData );
		isKnowKey = TRUE;
	 }
	 printf("getkey_2\n");

	 if(isEmpty || strcmp(keyReq, "AuthorizationCacheEnabled") == 0 )
	 {

		strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_AuthorizationCacheEnabled].Item, "AuthorizationCacheEnabled");
		strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AuthorizationCacheEnabled].Key, "AuthorizationCacheEnabled");

		if(ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizationCacheEnabled].ItemAccessibility == 1)
		{
			strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AuthorizationCacheEnabled].ReadOnly, "0"/*"FALSE"*/);
		}
		else
		{
			strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AuthorizationCacheEnabled].ReadOnly, "1"/*"TRUE"*/);
		}

		strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AuthorizationCacheEnabled].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizationCacheEnabled].ItemData );
		isKnowKey = TRUE;
		printf("AuthorizationCacheEnabled\n");
	 }

	 if(isEmpty || strcmp(keyReq, "AuthorizeRemoteTxRequests") == 0 )
	 {
		strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_AuthorizeRemoteTxRequests].Item, "AuthorizeRemoteTxRequests");
		strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AuthorizeRemoteTxRequests].Key, "AuthorizeRemoteTxRequests");

		if(ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizeRemoteTxRequests].ItemAccessibility == 1)
		{
			strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AuthorizeRemoteTxRequests].ReadOnly, "0"/*"FALSE"*/);
		}
		else
		{
			strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AuthorizeRemoteTxRequests].ReadOnly, "1"/*"TRUE"*/);
		}

		strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AuthorizeRemoteTxRequests].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizeRemoteTxRequests].ItemData );
		isKnowKey = TRUE;
		printf("AuthorizeRemoteTxRequests\n");
	 }

	  if(isEmpty || strcmp(keyReq, "BlinkRepeat") == 0 )
	  {
		  strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_BlinkRepeat].Item, "BlinkRepeat");
		  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_BlinkRepeat].Key, "BlinkRepeat");

		  if(ShmOCPP16Data->ConfigurationTable.CoreProfile[BlinkRepeat].ItemAccessibility == 1)
		  {
			  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_BlinkRepeat].ReadOnly, "0"/*"FALSE"*/);
		  }
		  else
		  {
			  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_BlinkRepeat].ReadOnly, "1"/*"TRUE"*/);
		  }

		  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_BlinkRepeat].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[BlinkRepeat].ItemData );
		  isKnowKey = TRUE;
		  printf("BlinkRepeat\n");
	  }

	   if(isEmpty ||  strcmp(keyReq, "ClockAlignedDataInterval") == 0 )
	   {
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_ClockAlignedDataInterval].Item, "ClockAlignedDataInterval");
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ClockAlignedDataInterval].Key, "ClockAlignedDataInterval");

		   if(ShmOCPP16Data->ConfigurationTable.CoreProfile[ClockAlignedDataInterval].ItemAccessibility == 1)
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ClockAlignedDataInterval].ReadOnly, "0"/*"FALSE"*/);
		   }
		   else
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ClockAlignedDataInterval].ReadOnly, "1"/*"TRUE"*/);
		   }


		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ClockAlignedDataInterval].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ClockAlignedDataInterval].ItemData );
		   isKnowKey = TRUE;
		   printf("ClockAlignedDataInterval\n");
	   }

	   if(isEmpty ||   strcmp(keyReq, "ConnectionTimeOut") == 0 )
	   {
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_ConnectionTimeOut].Item, "ConnectionTimeOut");
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectionTimeOut].Key, "ConnectionTimeOut");

		   if(ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemAccessibility == 1)
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectionTimeOut].ReadOnly, "0"/*"FALSE"*/);
		   }
		   else
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectionTimeOut].ReadOnly, "1"/*"TRUE"*/);
		   }


		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectionTimeOut].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemData );
		   isKnowKey = TRUE;
		   printf("ConnectionTimeOut\n");
	   }

	   if(isEmpty ||  strcmp(keyReq, "GetConfigurationMaxKeys") == 0 )
	   {

		   strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_GetConfigurationMaxKeys].Item, "GetConfigurationMaxKeys");
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_GetConfigurationMaxKeys].Key, "GetConfigurationMaxKeys");

		   if(ShmOCPP16Data->ConfigurationTable.CoreProfile[GetConfigurationMaxKeys].ItemAccessibility == 1)
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_GetConfigurationMaxKeys].ReadOnly, "0"/*"FALSE"*/);
		   }
		   else
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_GetConfigurationMaxKeys].ReadOnly, "1"/*"TRUE"*/);
		   }

		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_GetConfigurationMaxKeys].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[GetConfigurationMaxKeys].ItemData );
		   isKnowKey = TRUE;
		   printf("GetConfigurationMaxKeys\n");
	   }

	   if(isEmpty ||  strcmp(keyReq, "HeartbeatInterval") == 0 )
	   {

		   strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_HeartbeatInterval].Item, "HeartbeatInterval");
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_HeartbeatInterval].Key, "HeartbeatInterval");

		   if(ShmOCPP16Data->ConfigurationTable.CoreProfile[HeartbeatInterval].ItemAccessibility == 1)
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_HeartbeatInterval].ReadOnly, "0"/*"FALSE"*/);
		   }
		   else
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_HeartbeatInterval].ReadOnly, "1"/*"TRUE"*/);
		   }

		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_HeartbeatInterval].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[HeartbeatInterval].ItemData );
		   isKnowKey = TRUE;
		   printf("HeartbeatInterval\n");
	   }

	   if(isEmpty ||  strcmp(keyReq, "LightIntensity") == 0 )
	   {
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_LightIntensity].Item, "LightIntensity");
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LightIntensity].Key, "LightIntensity");

		   if(ShmOCPP16Data->ConfigurationTable.CoreProfile[LightIntensity].ItemAccessibility == 1)
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LightIntensity].ReadOnly, "0"/*"FALSE"*/);
		   }
		   else
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LightIntensity].ReadOnly, "1"/*"TRUE"*/);
		   }

		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LightIntensity].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LightIntensity].ItemData );
		   isKnowKey = TRUE;
		   printf("LightIntensity\n");
	   }

	   if(isEmpty ||  strcmp(keyReq, "LocalAuthorizeOffline") == 0 )
	   {

		   strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_LocalAuthorizeOffline].Item, "LocalAuthorizeOffline");
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalAuthorizeOffline].Key, "LocalAuthorizeOffline");

		   if(ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalAuthorizeOffline].ItemAccessibility == 1)
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalAuthorizeOffline].ReadOnly, "0"/*"FALSE"*/);
		   }
		   else
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalAuthorizeOffline].ReadOnly, "1"/*"TRUE"*/);
		   }

		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalAuthorizeOffline].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalAuthorizeOffline].ItemData );
		   isKnowKey = TRUE;
		   printf("LocalAuthorizeOffline\n");
	   }

	   if(isEmpty || strcmp(keyReq, "LocalPreAuthorize") == 0 )
	   {

		   strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_LocalPreAuthorize].Item, "LocalPreAuthorize");
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalPreAuthorize].Key, "LocalPreAuthorize");

		   if(ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalPreAuthorize].ItemAccessibility == 1)
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalPreAuthorize].ReadOnly, "0"/*"FALSE"*/);
		   }
		   else
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalPreAuthorize].ReadOnly, "1"/*"TRUE"*/);
		   }

		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalPreAuthorize].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalPreAuthorize].ItemData );
		   isKnowKey = TRUE;
		   printf("LocalPreAuthorize\n");
	    }

	    if(isEmpty ||  strcmp(keyReq, "MaxEnergyOnInvalidId") == 0 )
	    {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_MaxEnergyOnInvalidId].Item, "MaxEnergyOnInvalidId");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MaxEnergyOnInvalidId].Key, "MaxEnergyOnInvalidId");

	    	 if(ShmOCPP16Data->ConfigurationTable.CoreProfile[MaxEnergyOnInvalidId].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MaxEnergyOnInvalidId].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MaxEnergyOnInvalidId].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MaxEnergyOnInvalidId].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MaxEnergyOnInvalidId].ItemData );
	    	 isKnowKey = TRUE;
	    	 printf("MaxEnergyOnInvalidId\n");
	    }

	    if(isEmpty ||  strcmp(keyReq, "MeterValuesAlignedData") == 0 )
	    {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_MeterValuesAlignedData].Item, "MeterValuesAlignedData");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesAlignedData].Key, "MeterValuesAlignedData");

	    	 if(ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedData].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesAlignedData].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesAlignedData].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesAlignedData].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedData].ItemData );
	    	 isKnowKey = TRUE;
	    	 printf("MeterValuesAlignedData\n");
	    }

	     if(isEmpty ||  strcmp(keyReq, "MeterValuesAlignedDataMaxLength") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_MeterValuesAlignedDataMaxLength].Item, "MeterValuesAlignedDataMaxLength");
	         strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesAlignedDataMaxLength].Key, "MeterValuesAlignedDataMaxLength");

	         if(ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedDataMaxLength].ItemAccessibility == 1)
	         {
	        	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesAlignedDataMaxLength].ReadOnly, "0"/*"FALSE"*/);
	         }
	         else
	         {
	        	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesAlignedDataMaxLength].ReadOnly, "1"/*"TRUE"*/);
	         }

	         strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesAlignedDataMaxLength].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedDataMaxLength].ItemData );
	         isKnowKey = TRUE;
	         printf("MeterValuesAlignedDataMaxLength\n");
	      }

	     if(isEmpty ||  strcmp(keyReq, "MeterValuesSampledData") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_MeterValuesSampledData].Item, "MeterValuesSampledData");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesSampledData].Key, "MeterValuesSampledData");

	    	 if(ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledData].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesSampledData].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesSampledData].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesSampledData].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledData].ItemData );
	    	 isKnowKey = TRUE;
	    	 printf("MeterValuesSampledData\n");
	     }

	    if(isEmpty ||   strcmp(keyReq, "MeterValuesSampledDataMaxLength") == 0 )
	    {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_MeterValuesSampledDataMaxLength].Item, "MeterValuesSampledDataMaxLength");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesSampledDataMaxLength].Key, "MeterValuesSampledDataMaxLength");

	    	 if(ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledDataMaxLength].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesSampledDataMaxLength].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesSampledDataMaxLength].ReadOnly, "1"/*"TRUE"*/);
	    	 }
	         strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValuesSampledDataMaxLength].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledDataMaxLength].ItemData );
	         isKnowKey = TRUE;
	         printf("MeterValuesSampledDataMaxLength\n");
	    }

	   if(isEmpty ||  strcmp(keyReq, "MeterValueSampleInterval") == 0 )
	   {
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_MeterValueSampleInterval].Item, "MeterValueSampleInterval");
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValueSampleInterval].Key, "MeterValueSampleInterval");

		   if(ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValueSampleInterval].ItemAccessibility == 1)
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValueSampleInterval].ReadOnly, "0"/*"FALSE"*/);
		   }
		   else
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValueSampleInterval].ReadOnly, "1"/*"TRUE"*/);
		   }

		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MeterValueSampleInterval].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValueSampleInterval].ItemData );
		   isKnowKey = TRUE;
		   printf("MeterValueSampleInterval\n");
	    }

	   if(isEmpty || strcmp(keyReq, "MinimumStatusDuration") == 0 )
	   {
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_MinimumStatusDuration].Item, "MinimumStatusDuration");
		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MinimumStatusDuration].Key, "MinimumStatusDuration");

		   if(ShmOCPP16Data->ConfigurationTable.CoreProfile[MinimumStatusDuration].ItemAccessibility == 1)
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MinimumStatusDuration].ReadOnly, "0"/*"FALSE"*/);
		   }
		   else
		   {
			   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MinimumStatusDuration].ReadOnly, "1"/*"TRUE"*/);
		   }

		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MinimumStatusDuration].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[17].ItemData );
		   isKnowKey = TRUE;
		   printf("MinimumStatusDuration\n");
	    }

	    if(isEmpty || strcmp(keyReq, "NumberOfConnectors") == 0 )
	    {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_NumberOfConnectors].Item, "NumberOfConnectors");
	         strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_NumberOfConnectors].Key, "NumberOfConnectors");

	         if(ShmOCPP16Data->ConfigurationTable.CoreProfile[NumberOfConnectors].ItemAccessibility == 1)
	         {
	        	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_NumberOfConnectors].ReadOnly, "0"/*"FALSE"*/);
	         }
	         else
	         {
	        	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_NumberOfConnectors].ReadOnly, "1"/*"TRUE"*/);
	         }

	         strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_NumberOfConnectors].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[NumberOfConnectors].ItemData );
	         isKnowKey = TRUE;
	         printf("NumberOfConnectors\n");
	    }

	    if(isEmpty || strcmp(keyReq, "ResetRetries") == 0 )
	    {
	    	strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_ResetRetries].Item, "ResetRetries");
	        strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ResetRetries].Key, "ResetRetries");

	        if(ShmOCPP16Data->ConfigurationTable.CoreProfile[ResetRetries].ItemAccessibility == 1)
	        {
	        	strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ResetRetries].ReadOnly, "0"/*"FALSE"*/);
	        }
	        else
	        {
	        	strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ResetRetries].ReadOnly, "1"/*"TRUE"*/);
	        }

	        strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ResetRetries].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ResetRetries].ItemData );
	        isKnowKey = TRUE;
	        printf("ResetRetries\n");
	    }

	    if(isEmpty || strcmp(keyReq, "ConnectorPhaseRotation") == 0 )
	    {
	    	strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_ConnectorPhaseRotation].Item, "ConnectorPhaseRotation");
	        strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectorPhaseRotation].Key, "ConnectorPhaseRotation");

	        if(ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectorPhaseRotation].ItemAccessibility == 1)
	        {
	        	strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectorPhaseRotation].ReadOnly, "0"/*"FALSE"*/);
	        }
	        else
	        {
	        	strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectorPhaseRotation].ReadOnly, "1"/*"TRUE"*/);
	        }

	        strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectorPhaseRotation].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectorPhaseRotation].ItemData );
	        isKnowKey = TRUE;
	        printf("ConnectorPhaseRotation\n");
	     }

	     if(isEmpty ||  strcmp(keyReq, "ConnectorPhaseRotationMaxLength") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_ConnectorPhaseRotationMaxLength].Item, "ConnectorPhaseRotationMaxLength");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectorPhaseRotationMaxLength].Key, "ConnectorPhaseRotationMaxLength");

	    	 if(ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectorPhaseRotationMaxLength].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectorPhaseRotationMaxLength].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectorPhaseRotationMaxLength].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectorPhaseRotationMaxLength].Value,(const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectorPhaseRotationMaxLength].ItemData );
	    	 isKnowKey = TRUE;
	    	 printf("ConnectorPhaseRotationMaxLength\n");
	     }

	      if(isEmpty ||  strcmp(keyReq, "StopTransactionOnEVSideDisconnect") == 0 )
	      {
	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_StopTransactionOnEVSideDisconnect].Item, "StopTransactionOnEVSideDisconnect");
	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTransactionOnEVSideDisconnect].Key, "StopTransactionOnEVSideDisconnect");

	    	  if(ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnEVSideDisconnect].ItemAccessibility == 1)
	    	  {
	    		  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTransactionOnEVSideDisconnect].ReadOnly, "0"/*"FALSE"*/);
	    	  }
	    	  else
	    	  {
	    		  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTransactionOnEVSideDisconnect].ReadOnly, "1"/*"TRUE"*/);
	    	  }

	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTransactionOnEVSideDisconnect].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnEVSideDisconnect].ItemData );
	    	  isKnowKey = TRUE;
	    	  printf("StopTransactionOnEVSideDisconnect\n");
	      }

	      if(isEmpty || strcmp(keyReq, "StopTransactionOnInvalidId") == 0 )
	      {
	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_StopTransactionOnInvalidId].Item, "StopTransactionOnInvalidId");
	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTransactionOnInvalidId].Key, "StopTransactionOnInvalidId");

	    	  if(ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnInvalidId].ItemAccessibility == 1)
	    	  {
	    		  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTransactionOnInvalidId].ReadOnly, "0"/*"FALSE"*/);
	    	  }
	    	  else
	    	  {
	    		  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTransactionOnInvalidId].ReadOnly, "1"/*"TRUE"*/);
	    	  }

	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTransactionOnInvalidId].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnInvalidId].ItemData );
	    	  isKnowKey = TRUE;
	    	  printf("StopTransactionOnInvalidId\n");
	      }

	     if(isEmpty ||  strcmp(keyReq, "StopTxnAlignedData") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_StopTxnAlignedData].Item, "StopTxnAlignedData");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnAlignedData].Key, "StopTxnAlignedData");

	    	 if(ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnAlignedData].ItemAccessibility  == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnAlignedData].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnAlignedData].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnAlignedData].Value,(const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnAlignedData].ItemData );
	    	 isKnowKey = TRUE;
	    	 printf("StopTxnAlignedData\n");
	     }

	     if(isEmpty ||  strcmp(keyReq, "StopTxnAlignedDataMaxLength") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_StopTxnAlignedDataMaxLength].Item, "StopTxnAlignedDataMaxLength");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnAlignedDataMaxLength].Key, "StopTxnAlignedDataMaxLength");

	    	 if(ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnAlignedDataMaxLength].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnAlignedDataMaxLength].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnAlignedDataMaxLength].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnAlignedDataMaxLength].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnAlignedDataMaxLength].ItemData );
	    	 isKnowKey = TRUE;
	    	 printf("StopTxnAlignedDataMaxLength\n");
	      }

	     if(isEmpty ||  strcmp(keyReq, "StopTxnSampledData") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_StopTxnSampledData].Item, "StopTxnSampledData");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnSampledData].Key, "StopTxnSampledData");

	    	 if(ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnSampledData].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnSampledData].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnSampledData].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnSampledData].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnSampledData].ItemData );
	    	 isKnowKey = TRUE;
	    	 printf("StopTxnSampledData\n");
	     }

	     if(isEmpty ||  strcmp(keyReq, "StopTxnSampledDataMaxLength") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_StopTxnSampledDataMaxLength].Item, "StopTxnSampledDataMaxLength");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnSampledDataMaxLength].Key, "StopTxnSampledDataMaxLength");

	    	 if(ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnSampledDataMaxLength].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnSampledDataMaxLength].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnSampledDataMaxLength].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_StopTxnSampledDataMaxLength].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnSampledDataMaxLength].ItemData );
	    	 isKnowKey = TRUE;
	    	 printf("StopTxnSampledDataMaxLength\n");
	     }

	     if(isEmpty ||  strcmp(keyReq, "SupportedFeatureProfiles") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_SupportedFeatureProfiles].Item, "SupportedFeatureProfiles");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_SupportedFeatureProfiles].Key, "SupportedFeatureProfiles");

	    	 if(ShmOCPP16Data->ConfigurationTable.CoreProfile[SupportedFeatureProfiles].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_SupportedFeatureProfiles].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_SupportedFeatureProfiles].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_SupportedFeatureProfiles].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[SupportedFeatureProfiles].ItemData );
	    	 isKnowKey = TRUE;
	    	 printf("SupportedFeatureProfiles\n");
	     }

	     if(isEmpty ||  strcmp(keyReq, "SupportedFeatureProfilesMaxLength") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_SupportedFeatureProfilesMaxLength].Item, "SupportedFeatureProfilesMaxLength");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_SupportedFeatureProfilesMaxLength].Key, "SupportedFeatureProfilesMaxLength");

	    	 if(ShmOCPP16Data->ConfigurationTable.CoreProfile[SupportedFeatureProfilesMaxLength].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_SupportedFeatureProfilesMaxLength].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_SupportedFeatureProfilesMaxLength].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_SupportedFeatureProfilesMaxLength].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[SupportedFeatureProfilesMaxLength].ItemData );
	    	 isKnowKey = TRUE;
	    	 printf("SupportedFeatureProfilesMaxLength\n");
	     }

	     if(isEmpty ||  strcmp(keyReq, "TransactionMessageAttempts") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_TransactionMessageAttempts].Item, "TransactionMessageAttempts");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_TransactionMessageAttempts].Key, "TransactionMessageAttempts");

	    	 if(ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageAttempts].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_TransactionMessageAttempts].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_TransactionMessageAttempts].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_TransactionMessageAttempts].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageAttempts].ItemData );
	    	 isKnowKey = TRUE;
	    	 printf("TransactionMessageAttempts\n");
	      }

	     if(isEmpty ||  strcmp(keyReq, "TransactionMessageRetryInterval") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_TransactionMessageRetryInterval].Item, "TransactionMessageRetryInterval");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_TransactionMessageRetryInterval].Key, "TransactionMessageRetryInterval");

	    	 if(ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_TransactionMessageRetryInterval].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_TransactionMessageRetryInterval].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_TransactionMessageRetryInterval].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemData );
	    	 isKnowKey = TRUE;
	    	 printf("TransactionMessageRetryInterval\n");
	     }

	      if(isEmpty ||  strcmp(keyReq, "UnlockConnectorOnEVSideDisconnect") == 0 )
	      {
	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_UnlockConnectorOnEVSideDisconnect].Item, "UnlockConnectorOnEVSideDisconnect");
	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_UnlockConnectorOnEVSideDisconnect].Key, "UnlockConnectorOnEVSideDisconnect");

	    	  if(ShmOCPP16Data->ConfigurationTable.CoreProfile[UnlockConnectorOnEVSideDisconnect].ItemAccessibility == 1)
	    	  {
	    		  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_UnlockConnectorOnEVSideDisconnect].ReadOnly, "0"/*"FALSE"*/);
	    	  }
	    	  else
	    	  {
	    		  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_UnlockConnectorOnEVSideDisconnect].ReadOnly, "1"/*"TRUE"*/);
	    	  }

	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_UnlockConnectorOnEVSideDisconnect].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[UnlockConnectorOnEVSideDisconnect].ItemData );
	    	  isKnowKey = TRUE;
	    	  printf("UnlockConnectorOnEVSideDisconnect\n");
	       }

	       if(isEmpty ||  strcmp(keyReq, "WebSocketPingInterval") == 0 )
	       {
	    	   strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_WebSocketPingInterval].Item, "WebSocketPingInterval");
	    	   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_WebSocketPingInterval].Key, "WebSocketPingInterval");

	    	   if(ShmOCPP16Data->ConfigurationTable.CoreProfile[WebSocketPingInterval].ItemAccessibility == 1)
	    	   {
	    		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_WebSocketPingInterval].ReadOnly, "0"/*"FALSE"*/);
	    	   }
	    	   else
	    	   {
	    		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_WebSocketPingInterval].ReadOnly, "1"/*"TRUE"*/);
	    	   }

	    	   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_WebSocketPingInterval].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[WebSocketPingInterval].ItemData );
	    	   isKnowKey = TRUE;
	    	   printf("WebSocketPingInterval\n");
	       }

	      if(isEmpty ||  strcmp(keyReq, "LocalAuthListEnabled") == 0 )
	      {
	    	   strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_LocalAuthListEnabled].Item, "LocalAuthListEnabled");
	    	   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalAuthListEnabled].Key, "LocalAuthListEnabled");

	    	   if(ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemAccessibility == 1)
	    	   {
	    		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalAuthListEnabled].ReadOnly, "0"/*"FALSE"*/);
	    	   }
	    	   else
	    	   {
	    		   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalAuthListEnabled].ReadOnly, "1"/*"TRUE"*/);
	    	   }

	    	   strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalAuthListEnabled].Value, (const char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData );
	    	   isKnowKey = TRUE;
	    	   printf("LocalAuthListEnabled\n");
	      }

	     if(isEmpty ||  strcmp(keyReq, "LocalAuthListMaxLength") == 0 )
	     {
	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_LocalAuthListMaxLength].Item, "LocalAuthListMaxLength");
	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalAuthListMaxLength].Key, "LocalAuthListMaxLength");

	    	  if(ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListMaxLength].ItemAccessibility == 1)
	    	  {
	    		  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalAuthListMaxLength].ReadOnly, "0"/*"FALSE"*/);
	    	  }
	    	  else
	    	  {
	    		  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalAuthListMaxLength].ReadOnly, "1"/*"TRUE"*/);
	    	  }

	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalAuthListMaxLength].Value, (const char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListMaxLength].ItemData );
	    	  isKnowKey = TRUE;
	    	  printf("LocalAuthListMaxLength\n");
	     }

	     if(isEmpty ||  strcmp(keyReq, "SendLocalListMaxLength") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_SendLocalListMaxLength].Item, "SendLocalListMaxLength");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_SendLocalListMaxLength].Key, "SendLocalListMaxLength");

	    	 if(ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[SendLocalListMaxLength].ItemAccessibility == 1)
	    	 {
	    	  	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_SendLocalListMaxLength].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    	  	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_SendLocalListMaxLength].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_SendLocalListMaxLength].Value, (const char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[SendLocalListMaxLength].ItemData );
	    	 isKnowKey = TRUE;
	    	 printf("SendLocalListMaxLength\n");
	     }

	     if(isEmpty ||  strcmp(keyReq, "ReserveConnectorZeroSupported") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_ReserveConnectorZeroSupported].Item, "ReserveConnectorZeroSupported");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ReserveConnectorZeroSupported].Key, "ReserveConnectorZeroSupported");

	    	 if(ShmOCPP16Data->ConfigurationTable.ReservationProfile[ReserveConnectorZeroSupported].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ReserveConnectorZeroSupported].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ReserveConnectorZeroSupported].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ReserveConnectorZeroSupported].Value,(const char *)ShmOCPP16Data->ConfigurationTable.ReservationProfile[ReserveConnectorZeroSupported].ItemData);
	    	 isKnowKey = TRUE;
	    	 printf("ReserveConnectorZeroSupported\n");
	     }

	     if(isEmpty ||  strcmp(keyReq, "ChargeProfileMaxStackLevel") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_ChargeProfileMaxStackLevel].Item, "ChargeProfileMaxStackLevel");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ChargeProfileMaxStackLevel].Key, "ChargeProfileMaxStackLevel");

	    	 if(ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargeProfileMaxStackLevel].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ChargeProfileMaxStackLevel].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ChargeProfileMaxStackLevel].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ChargeProfileMaxStackLevel].Value, (const char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargeProfileMaxStackLevel].ItemData);
	    	 isKnowKey = TRUE;
	    	 printf("ChargeProfileMaxStackLevel\n");
	     }

	     if(isEmpty ||  strcmp(keyReq, "ChargingScheduleAllowedChargingRateUnit") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_ChargingScheduleAllowedChargingRateUnit].Item, "ChargingScheduleAllowedChargingRateUnit");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ChargingScheduleAllowedChargingRateUnit].Key, "ChargingScheduleAllowedChargingRateUnit");

	    	 if(ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargingScheduleAllowedChargingRateUnit].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ChargingScheduleAllowedChargingRateUnit].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ChargingScheduleAllowedChargingRateUnit].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ChargingScheduleAllowedChargingRateUnit].Value, (const char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargingScheduleAllowedChargingRateUnit].ItemData);
	    	 isKnowKey = TRUE;
	    	 printf("ChargingScheduleAllowedChargingRateUnit\n");
	     }

	     if(isEmpty ||  strcmp(keyReq, "ChargingScheduleMaxPeriods") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_ChargingScheduleMaxPeriods].Item, "ChargingScheduleMaxPeriods");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ChargingScheduleMaxPeriods].Key, "ChargingScheduleMaxPeriods");

	    	 if(ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargingScheduleMaxPeriods].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ChargingScheduleMaxPeriods].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ChargingScheduleMaxPeriods].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ChargingScheduleMaxPeriods].Value, (const char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ChargingScheduleMaxPeriods].ItemData);
	    	 isKnowKey = TRUE;
	    	 printf("ChargingScheduleMaxPeriods\n");
	     }

	     if(isEmpty ||  strcmp(keyReq, "ConnectorSwitch3to1PhaseSupported") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_ConnectorSwitch3to1PhaseSupported].Item, "ConnectorSwitch3to1PhaseSupported");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectorSwitch3to1PhaseSupported].Key, "ConnectorSwitch3to1PhaseSupported");

	    	 if(ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ConnectorSwitch3to1PhaseSupported].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectorSwitch3to1PhaseSupported].ReadOnly, "0"/*"FALSE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectorSwitch3to1PhaseSupported].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_ConnectorSwitch3to1PhaseSupported].Value, (const char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[ConnectorSwitch3to1PhaseSupported].ItemData);
	    	 isKnowKey = TRUE;
	    	 printf("ConnectorSwitch3to1PhaseSupported\n");
	     }

	     if(isEmpty ||  strcmp(keyReq, "MaxChargingProfilesInstalled") == 0 )
	     {
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_MaxChargingProfilesInstalled].Item, "MaxChargingProfilesInstalled");
	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MaxChargingProfilesInstalled].Key, "MaxChargingProfilesInstalled");

	    	 if(ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[MaxChargingProfilesInstalled].ItemAccessibility == 1)
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MaxChargingProfilesInstalled].ReadOnly, "0"/*"FLASE"*/);
	    	 }
	    	 else
	    	 {
	    		 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MaxChargingProfilesInstalled].ReadOnly, "1"/*"TRUE"*/);
	    	 }

	    	 strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_MaxChargingProfilesInstalled].Value, (const char *)ShmOCPP16Data->ConfigurationTable.SmartChargingProfile[MaxChargingProfilesInstalled].ItemData);
	    	 isKnowKey = TRUE;
	    	 printf("MaxChargingProfilesInstalled\n");
	     }

	     //=========================================================

	     if(!isEmpty && !isKnowKey)
	     {
	    	 printf("unKnowIndex =%d\n", UnknownKeynum);
	    	 strcpy(unknownkey[UnknownKeynum], keyReq);
			 UnknownKeynum = UnknownKeynum + 1;
	     }


}

void processUnkownKey(void)
{

	if(ShmOCPP16Data->GetConfiguration.ResponseUnknownKey != NULL)
		free(ShmOCPP16Data->GetConfiguration.ResponseUnknownKey);

	ShmOCPP16Data->GetConfiguration.ResponseUnknownKey = (struct StructConfigurationKeyItems *)malloc(sizeof(struct StructConfigurationKeyItems)*UnknownKeynum);

	memset(ShmOCPP16Data->GetConfiguration.ResponseUnknownKey, 0 , sizeof(struct StructConfigurationKeyItems)* UnknownKeynum);

	printf("processUnkownKey UnknownKeynum =%d\n",UnknownKeynum);
	for(int index=0; index < UnknownKeynum; index++)
	{
		printf("ShmOCPP16Data->GetConfiguration.ResponseUnknownKey[%d].Item[0]=%c\n",index,ShmOCPP16Data->GetConfiguration.ResponseUnknownKey[index].Item[0]);
		if(ShmOCPP16Data->GetConfiguration.ResponseUnknownKey[index].Item[0] == 0)
		{
			strcpy((char *)(ShmOCPP16Data->GetConfiguration.ResponseUnknownKey[index].Item), unknownkey[index]);
		    printf("getkeyValue: %s\n", ShmOCPP16Data->GetConfiguration.ResponseUnknownKey[index].Item);
		}

	}

}

 int  setKeyValue(char *key, char *value)
{
	int isSuccess = NotSupported;

	printf("setKeyValue : key : %s\n", key);

    if(strcmp(key, "AllowOfflineTxForUnknownId") == 0)
    {
        //Charger.AllowOfflineTxForUnknownId = (value.toLowerCase().equals("true")?true:false);
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[AllowOfflineTxForUnknownId].ItemAccessibility == 1)
    	{
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AllowOfflineTxForUnknownId].ItemData, "%d", (strcmp(value, "true")==0) ?TRUE:FALSE );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    		isSuccess = ConfigurationStatus_Rejected;
    	}
     }

    if(strcmp(key, "AuthorizationCacheEnabled") == 0)
    {
        //Charger.AuthorizationCacheEnabled = (value.toLowerCase().equals("true")?true:false);
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizationCacheEnabled].ItemAccessibility == 1)
    	{
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizationCacheEnabled].ItemData, "%d", (strcmp(value, "true")==0) ?TRUE:FALSE );
    		isSuccess = ConfigurationStatus_Accepted;

    		//updateSetting("AuthorizationCacheEnabled", (Charger.AuthorizationCacheEnabled?"1":"0"));
    		updateSetting("AuthorizationCacheEnabled",(char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[1].ItemData);
    	}
    	else
    	{
    		isSuccess = ConfigurationStatus_Rejected;
    	}

    }

    if(strcmp(key, "AuthorizeRemoteTxRequests") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizeRemoteTxRequests].ItemAccessibility == 1)
    	{
    		//Charger.AuthorizeRemoteTxRequests = (value.toLowerCase().equals("true")?true:false);
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizeRemoteTxRequests].ItemData, "%d", (strcmp(value, "true")==0) ?TRUE:FALSE );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}

    }

    if(strcmp(key, "BlinkRepeat") == 0)
    {
    		//Charger.BlinkRepeat = Integer.parseInt(value);
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[BlinkRepeat].ItemAccessibility == 1)
    	{
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[BlinkRepeat].ItemData, "%d", atoi(value) );
    	    isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}
    }

    if(strcmp(key, "ClockAlignedDataInterval") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[ClockAlignedDataInterval].ItemAccessibility == 1)
    	{
    		//Charger.ClockAlignedDataInterval = Integer.parseInt(value)*1000;
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ClockAlignedDataInterval].ItemData, "%d", atoi(value)*1000 );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}

    }

    if(strcmp(key, "ConnectionTimeOut") == 0 )
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemAccessibility == 1)
    	{
    		//Charger.ConnectionTimeOut = Integer.parseInt(value)*1000;
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemData, "%d", atoi(value)*1000 );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
        {
        	isSuccess = ConfigurationStatus_Rejected;
        }

    }

    if(strcmp(key, "HeartbeatInterval") == 0)
    {
    	printf("HeartbeatInterval ItemAccessibility: %d\n", ShmOCPP16Data->ConfigurationTable.CoreProfile[HeartbeatInterval].ItemAccessibility);
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[HeartbeatInterval].ItemAccessibility == 1)
    	{
    		//Charger.HeartbeatInterval = Integer.parseInt(value)*1000;
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[HeartbeatInterval].ItemData, "%d", atoi(value)/*atoi(value)*1000*/ );
    		HeartBeatWaitTime = atoi(value);
    		printf("set HeartbeatInterval value \n");
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}

    }

    if(strcmp(key, "LightIntensity") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[LightIntensity].ItemAccessibility == 1)
    	{
    		//Charger.LightIntensity = Integer.parseInt(value);
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LightIntensity].ItemData, "%d", atoi(value) );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    		isSuccess = ConfigurationStatus_Rejected;
    	}
    }

    if(strcmp(key, "LocalAuthorizeOffline") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalAuthorizeOffline].ItemAccessibility == 1)
    	{

    		//Charger.LocalAuthorizeOffline = (value.toLowerCase().equals("true")?true:false);
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalAuthorizeOffline].ItemData, "%d", (strcmp(value, "true")==0) ?TRUE:FALSE );
    		isSuccess = ConfigurationStatus_Accepted;

    		updateSetting("LocalAuthorizeOffline", (char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalAuthorizeOffline].ItemData);
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}

    }

    if(strcmp(key, "LocalPreAuthorize") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalPreAuthorize].ItemAccessibility == 1)
    	{
    		//Charger.LocalPreAuthorize = (value.toLowerCase().equals("true")?true:false);
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalPreAuthorize].ItemData, "%d", (strcmp(value, "true")==0) ?TRUE:FALSE );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
        {
        	isSuccess = ConfigurationStatus_Rejected;
        }

    }

    if(strcmp(key, "MaxEnergyOnInvalidId") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[MaxEnergyOnInvalidId].ItemAccessibility == 1)
    	{

    		//Charger.MaxEnergyOnInvalidId = Integer.parseInt(value);
    	    sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MaxEnergyOnInvalidId].ItemData, "%d", atoi(value) );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}

    }

    if(strcmp(key, "MeterValuesAlignedData") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedData].ItemAccessibility == 1)
    	{
    		//Charger.MeterValuesAlignedData = value.toLowerCase();
    		int valueLength = strlen(value);
    		for(int i = 0; value[i]; i++){
    		    value[i] = tolower(value[i]);
    		}
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedData].ItemData, "%s", value );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	   isSuccess = ConfigurationStatus_Rejected;
    	}

    }

    if(strcmp(key, "MeterValuesSampledData") == 0 )
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledData].ItemAccessibility == 1)
    	{
    		//Charger.MeterValuesSampledData = value.toLowerCase();
    		int valueLength = strlen(value);
    		for(int i = 0; value[i]; i++){
    		    	value[i] = tolower(value[i]);
    		}
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledData].ItemData, "%s", value );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}

    }

    if(strcmp(key, "MeterValueSampleInterval") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValueSampleInterval].ItemAccessibility == 1)
    	{
    		//Charger.MeterValueSampleInterval = Integer.parseInt(value)*1000;
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValueSampleInterval].ItemData, "%d", atoi(value)*1000 );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}

    }

    if(strcmp(key, "MinimumStatusDuration") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[MinimumStatusDuration].ItemAccessibility == 1)
    	{
    		//Charger.MinimumStatusDuration = Integer.parseInt(value);
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MinimumStatusDuration].ItemData, "%d", atoi(value) );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
        {
        	isSuccess = ConfigurationStatus_Rejected;
        }

    }

    if(strcmp(key, "ResetRetries") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[ResetRetries].ItemAccessibility == 1)
    	{
    		//Charger.ResetRetries = Integer.parseInt(value);
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ResetRetries].ItemData, "%d", atoi(value) );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}

   }

   if(strcmp(key, "ConnectorPhaseRotation") == 0)
   {
	   if(ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectorPhaseRotation].ItemAccessibility == 1)
	   {
		   //Charger.ConnectorPhaseRotation = value.toLowerCase();
		   int valueLength = strlen(value);
		   for(int i = 0; value[i]; i++){
		       		    	value[i] = tolower(value[i]);
		   }
		   sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectorPhaseRotation].ItemData, "%s", value );
		   isSuccess = ConfigurationStatus_Accepted;
	   }
	   else
	   {
	       isSuccess = ConfigurationStatus_Rejected;
	   }

   }

   if(strcmp(key, "StopTransactionOnEVSideDisconnect") == 0)
   {
	   if(ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnEVSideDisconnect].ItemAccessibility == 1)
	   {
		   //Charger.StopTransactionOnEVSideDisconnect = (value.toLowerCase().equals("true")?true:false);
		   sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnEVSideDisconnect].ItemData, "%d", (strcmp(value, "true")==0) ?TRUE:FALSE );
		   isSuccess = ConfigurationStatus_Accepted;
	   }
	   else
	   {
	       isSuccess = ConfigurationStatus_Rejected;
	   }

   }

    if(strcmp(key, "StopTransactionOnInvalidId") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnInvalidId].ItemAccessibility == 1)
    	{
    		//Charger.StopTransactionOnInvalidId = (value.toLowerCase().equals("true")?true:false);
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTransactionOnInvalidId].ItemData, "%d", (strcmp(value, "true")==0) ?TRUE:FALSE );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
        else
        {
    		isSuccess = ConfigurationStatus_Rejected;
        }
    }

    if(strcmp(key, "StopTxnAlignedData") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnAlignedData].ItemAccessibility == 1)
    	{

    		//Charger.StopTxnAlignedData = value.toLowerCase();
    		int valueLength = strlen(value);
    	    for(int i = 0; value[i]; i++){
    	    	value[i] = tolower(value[i]);
    	    }
    	    sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnAlignedData].ItemData, "%s", value );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}
    }

    if(strcmp(key, "StopTxnSampledData") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnSampledData].ItemAccessibility == 1)
    	{
    		//Charger.StopTxnSampledData = value.toLowerCase();
    		int valueLength = strlen(value);
    		for(int i = 0; value[i]; i++){
    		    value[i] = tolower(value[i]);
    		}
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[StopTxnSampledData].ItemData, "%s", value );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}

    }

    if(strcmp(key, "TransactionMessageAttempts") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageAttempts].ItemAccessibility == 1)
    	{

    		//Charger.TransactionMessageAttempts = Integer.parseInt(value);
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageAttempts].ItemData, "%d", atoi(value) );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}
    }

    if(strcmp(key, "TransactionMessageRetryInterval") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemAccessibility == 1)
    	{
    		//Charger.TransactionMessageRetryInterval = Integer.parseInt(value)*1000;
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemData, "%d", atoi(value)*1000 );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}

    }

    if(strcmp(key, "UnlockConnectorOnEVSideDisconnect") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[UnlockConnectorOnEVSideDisconnect].ItemAccessibility == 1)
    	{
    		//Charger.UnlockConnectorOnEVSideDisconnect = (value.toLowerCase().equals("true")?true:false);
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[UnlockConnectorOnEVSideDisconnect].ItemData, "%d", (strcmp(value, "true")==0) ?TRUE:FALSE );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
        {
        	isSuccess = ConfigurationStatus_Rejected;
        }

    }

    if(strcmp(key, "WebSocketPingInterval") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[WebSocketPingInterval].ItemAccessibility == 1)
    	{

    		//Charger.WebSocketPingInterval = Integer.parseInt(value)*1000;
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[WebSocketPingInterval].ItemData, "%d", atoi(value)*1000 );
    		isSuccess = ConfigurationStatus_Accepted;
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}
    }

    if(strcmp(key, "LocalAuthListEnabled") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemAccessibility == 1)
    	{
    		//Charger.LocalAuthListEnabled = (value.toLowerCase().equals("true")?true:false);
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData, "%d", (strcmp(value, "true")==0) ?TRUE:FALSE );
    		isSuccess = ConfigurationStatus_Accepted;

    		updateSetting("LocalAuthListEnabled", (char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData);
    	}
    	else
        {
        	isSuccess = ConfigurationStatus_Rejected;
        }

    }

    return isSuccess;
}

int updateSetting(char *key, char *value)
{
    int isSuccess = FALSE;
    json_object *json_obj = NULL;
    json_object *tmp_obj = NULL;

    //new a base object
    json_obj = json_object_new_object();
    tmp_obj = json_object_new_string(value);
    json_object_object_add(json_obj, key, tmp_obj);

    json_object_to_file("/var/www/settings", json_obj);


	isSuccess = TRUE;

	return isSuccess;
}

json_object * getJSONfromFile(char *filename)
{
    FILE *fptr;
    char str[] = "{}";
    json_object * obj ;

    fptr = fopen(filename, "rw+");
    if(fptr == NULL) //if file does not exist, create it
    {

    	fptr = fopen(filename, "w");
    	fwrite(str , 1 , sizeof(str) , fptr );
    }
    fclose(fptr);

    //obj = new JSONObject(new JSONTokener((new URI("file:///" + filename)).toURL().openStream()));
    obj = json_object_from_file(filename);

    return obj;
}


#define SA struct sockaddr
#define MAXBUF 1024
static char m_send_buffer[1024];
static char m_recv_buffer[1024];

static int  m_socket_data;
static int  sockfd;


int ReadHttpStatus(int sock){
    char c;
    char buff[1024]="",*ptr=buff+1;
    int bytes_received, status;
    printf("Begin Response ..\n");
    while(bytes_received = recv(sock, ptr, 1, 0)){
        if(bytes_received==-1){
            perror("ReadHttpStatus");
            exit(1);
        }

        if((ptr[-1]=='\r')  && (*ptr=='\n' )) break;
        ptr++;
    }
    *ptr=0;
    ptr=buff+1;

    sscanf(ptr,"%*s %d ", &status);

    printf("%s\n",ptr);
    printf("status=%d\n",status);
    printf("End Response ..\n");
    return (bytes_received>0)?status:0;

}

//the only filed that it parsed is 'Content-Length'
int ParseHeader(int sock){
    char c;
    char buff[1024]="",*ptr=buff+4;
    int bytes_received, status;
    printf("Begin HEADER ..\n");
    while(bytes_received = recv(sock, ptr, 1, 0)){
        if(bytes_received==-1){
            perror("Parse Header");
            exit(1);
        }

        if(
            (ptr[-3]=='\r')  && (ptr[-2]=='\n' ) &&
            (ptr[-1]=='\r')  && (*ptr=='\n' )
        ) break;
        ptr++;
    }

    *ptr=0;
    ptr=buff+4;
    //printf("%s",ptr);

    if(bytes_received){
        ptr=strstr(ptr,"Content-Length:");
        if(ptr){
            sscanf(ptr,"%*s %d",&bytes_received);

        }else
            bytes_received=-1; //unknown size

       printf("Content-Length: %d\n",bytes_received);
    }
    printf("End HEADER ..\n");
    return  bytes_received ;

}

int httpDownLoadFile(char *location, char *path, char *filename,char *url)
{
	//char domain[] = "sstatic.net", path[]="stackexchange/img/logos/so/so-logo-med.png";

	int sock, bytes_received;
	char send_data[1024],recv_data[1024], *p;
	struct sockaddr_in server_addr;
	struct hostent *he;
	char ftpbuf[200];
	int systemresult;
	char temp[100];


	memset(ftpbuf, 0, sizeof(ftpbuf));
	sprintf(ftpbuf, "wget --tries=3 -o %s -cb %s ",filename, url);
			//sprintf(ftpbuf, "ftpput -u %s -p %s %s -P %d %s%s %s",user,password,IPbuffer,21,filename,filename,path);
	systemresult = system(ftpbuf);

	printf("systemresult=%d\n",systemresult);
	if(systemresult != 0)
	{
		printf("ftpget error!\n");
		return FALSE;
	}

	return TRUE;
}

int ftpDownLoadFile(char *location, char *user, char *password, int port, char *path, char *filename)
{
	 //int sockfd;
	static int ret= 0;
	int reclen=0, off;
	int n, fileSize;
	char fname[40];
	char fileSizeBuffer[256];
	int len;
	int k, size, status;
	struct sockaddr_in servaddr,cliaddr;
	struct sockaddr_in servaddr_data;
	struct hostent* server;
	char bufferTemp[500000];
	char *IPbuffer;
	char ftpbuf[200];
	int systemresult;
	char temp[100];

	server = gethostbyname(location);
	// To convert an Internet network
	// address into ASCII string
	IPbuffer = inet_ntoa(*((struct in_addr*)
				 	 server->h_addr_list[0]));

	memset(ftpbuf, 0, sizeof(ftpbuf));
	sprintf(ftpbuf, "ftpget -u %s -p %s %s -P %d %s %s%s",user,password,IPbuffer,port/*21*/,filename,path,filename);
		//sprintf(ftpbuf, "ftpput -u %s -p %s %s -P %d %s%s %s",user,password,IPbuffer,21,filename,filename,path);
	systemresult = system(ftpbuf);

	printf("systemresult=%d\n",systemresult);
	if(systemresult != 0)
	{
		printf("ftpget error!\n");
		return FALSE;
	}

	return TRUE;

}

int ftpFile(char *location, char *user, char *password, int port, char *path, char *filename)
{
	 //int sockfd;
	 static int ret= 0;
	 int reclen=0, off;
	 int n, fileSize;
	 char fname[40];
	 char fileSizeBuffer[256];
	 int len;
	 int k, size, status;
	 struct sockaddr_in servaddr,cliaddr;
	 struct sockaddr_in servaddr_data;
	 struct hostent* server;
	 char *IPbuffer;
	 char ftpbuf[200];
	 int systemresult;

	 printf("ftpFile -1\n");
	  // To retrieve host information
	 server = gethostbyname(location);
	 // To convert an Internet network
	 // address into ASCII string
	 IPbuffer = inet_ntoa(*((struct in_addr*)
			 	 server->h_addr_list[0]));

	memset(ftpbuf, 0, sizeof(ftpbuf));

	/* format : ftpput -u  username -p passwd IP  target  source*/
	sprintf(ftpbuf, "ftpput -u %s -p %s %s -P %d %s%s %s",user,password,IPbuffer,port/*21*/,path,filename,filename);
	//sprintf(ftpbuf, "ftpput -u %s -p %s %s -P %d %s%s %s",user,password,IPbuffer,21,filename,filename,path);
	systemresult = system(ftpbuf);

	printf("systemresult=%d\n",systemresult);
	if(systemresult != 0)
	{
		printf("ftpput error!\n");
		return FALSE;
	}

	return TRUE;

}


int SettingChargingRecord(int target, int transactionId)
{
	 for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	 {
		 if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == target)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '4'))
		 {
			 addBuff(target, transactionId, 0);
			 return TRUE;
		 }
	 }

	 for (int index = 0; index < CCS_QUANTITY; index++)
	 {
		 if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == target)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == '4'))
		 {
			 addBuff(target, transactionId, 0);
			 return TRUE;
		 }
	 }

	 for (int index = 0; index < GB_QUANTITY; index++)
	 {
		 if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == target)&&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '4'))
		 {
			 addBuff(target, transactionId, 0);
			 return TRUE;
		 }
	 }
 return FALSE;
}


int addBuff(int gun_idx, int user_id, int cmd_sn)
{
	int isSuccess = FALSE;
	char *query = NULL;
    sqlite3_stmt *stmt;
    int rc;             // return code
    char str[20];

    sprintf(str,"%d",user_id);
    sqlite3_prepare_v2(db, "insert into log_buffer (user_id, cmd_sn, charger_id, gun_type, gun_no, rfid_no, stime, etime, time_len, s_soc, e_soc, stop_reason, power, meter_before, meter_after, charge_price, reserve, surplus_before, surplus_after, service_price, is_pay ,charge_strategy, charge_parameter, vin, vehicle_no, start_method, card_type, is_upload, guid, is_buf2OK) values (?1,?2,?3,?4,?5,?6,?7,?8,?9,?10,?11,?12,?13,?14,?15,?16,?17,?18,?19,?20,?21,?22,?23,?24,?25,?26,?27,?28,?29,?30);", -1, &stmt, NULL);       /* 1 */

    sqlite3_bind_text(stmt, 1, str, -1, SQLITE_STATIC);      /* 2 */


    rc = sqlite3_step(stmt);			   /* 3 */
    if (rc != SQLITE_DONE) {
    	printf("ERROR inserting data: %s\n", sqlite3_errmsg(db));
    	goto out;
    }

    sqlite3_finalize(stmt);
    free(query);

out:
    /*
     * close SQLite database
     */
    sqlite3_close(db);
    printf("database closed.\n");

    return isSuccess;
}

/**
 * Place the contents of the specified file into a memory buffer
 *
 * @param[in] filename The path and name of the file to read
 * @param[out] filebuffer A pointer to the contents in memory
 * @return status 0 success, 1 on failure
 */
int get_file_contents(const char* filename, char** outbuffer) {
	FILE* file = NULL;
	long filesize;
	const int blocksize = 1;
	size_t readsize;
	char* filebuffer;

	// Open the file
	file = fopen(filename, "r");
	if (NULL == file)
	{
		printf("'%s' not opened\n", filename);
		exit(EXIT_FAILURE);
	}

	// Determine the file size
	fseek(file, 0, SEEK_END);
	filesize = ftell(file);
	rewind (file);

	// Allocate memory for the file contents
	filebuffer = (char*) malloc(sizeof(char) * filesize);
	*outbuffer = filebuffer;
	if (filebuffer == NULL)
	{
		fputs ("malloc out-of-memory", stderr);
		exit(EXIT_FAILURE);
	}

	// Read in the file
	readsize = fread(filebuffer, blocksize, filesize, file);
	if (readsize != filesize)
	{
		fputs ("didn't read file completely",stderr);
		exit(EXIT_FAILURE);
	}

	// Clean exit
	fclose(file);
	return EXIT_SUCCESS;
}

//Command Port, Receive Answer
static int ftp_recv_respond(int m_socket_cmd, char *resp, int len)
{
	int ret;
	int off;
	len -= 1;
	for(off=0; off<len; off+=ret)
	{
		ret = recv(m_socket_cmd, &resp[off], 1 ,0);
	//	ret = socket_recv(m_socket_cmd, &resp[off], 1);
		if(ret < 0)
		{
			printf("recv respond error(ret=%d)!\r\n", ret);
			return 0;
		}
		if(resp[off] == '\n')
		{
			break;
		}
	}
	resp[off+1] = 0;
	printf("respond:%s", resp);
	return atoi(resp);
}

static int selectSqlCount = 0;
void getMemory(char** s, int num)
{
    *s = (char*)malloc(sizeof(char) * num);
    printf("s = %p\n", s);
    printf("*s = %p\n", *s);
}
static int callback(void *data, int argc, char **argv, char **azColName){
   int i;
   printf("%s: ", (const char*)data);
   selectSqlCount = argc;
   for(i = 0; i<argc; i++){
      printf("%s = %s\n", azColName[i], argv[i] ? argv[i] : "NULL");
   }

   printf("\n");
   return 0;
}

static int versioncallback(void *data, int argc, char **argv, char **azColName){
   int i;
   //printf("%s:\n", (const char*)data);
   localversion = argv[5] ? atoi(argv[5]) : 0;
   printf("localversion=%d\n", localversion);
   return 0;
}

static int IdTagcallback(void *data, int argc, char **argv, char **azColName){
   int i;
   //printf("%s:\n", (const char*)data);
   sprintf(idTagAuthorization,"%s", argv[1] ? argv[1] : "NULL");
   printf("IdTag=%s\n", idTagAuthorization);
   return 0;
}

static int deleteIdTagcallback(void *data, int argc, char **argv, char **azColName){
   int i;
   //printf("%s:\n", (const char*)data);
#if 1
   for(i=0; i<argc; i++){
      printf("%s = %s", azColName[i], argv[i] ? argv[i] : "NULL");
   }
   printf("");
#endif
//   localversion = argv[5] ? atoi(argv[5]) : 0;
//   printf("localversion=%d\n", localversion);
   return 0;
}

void OCPP_getListVerion()
{
    int ver = 0;
    int isSuccess = FALSE;
    int rc = 0;
   // const char* data = "Callback function called";
    char sql[100];
    char zErrMsg[100];

    memset(sql, 0, 100);
    memset(zErrMsg, 0, 100);
    strcpy(sql, "select * from ocpp_auth_local order by idx desc");

    /* Execute SQL statement */
    printf("OCPP_getListVerion -1\n");
    rc = sqlite3_exec(db, sql, versioncallback, 0, &zErrMsg);
    printf("OCPP_getListVerion -2\n");
    printf("rc=%d\n",rc);
    if( rc != SQLITE_OK ){
    	printf("SQL error: %s", zErrMsg);
          //sqlite3_free(zErrMsg);
    }else{
    	printf("Operation done successfully");
    }
    printf("OCPP_getListVerion -3\n");

   //return ver;
}

void OCPP_getIdTag(char *idTag)
{
    int ver = 0;
    int isSuccess = FALSE;
    int rc = 0;
   // const char* data = "Callback function called";
    char sql[100];
    char zErrMsg[100];

    memset(sql, 0, 100);
    memset(zErrMsg, 0, 100);

    sprintf(sql,"select * from ocpp_auth_local where idtag='%s'", idTag);

    /* Execute SQL statement */
    printf("OCPP_getIdTag -1\n");
    rc = sqlite3_exec(db, sql, versioncallback, 0, &zErrMsg);
    printf("OCPP_getIdTag -2\n");
    printf("rc=%d\n",rc);
    if( rc != SQLITE_OK ){
    	printf("SQL error: %s", zErrMsg);
          //sqlite3_free(zErrMsg);
    }else{
    	printf("Operation done successfully");
    }
    printf("OCPP_getIdTag -3\n");

   //return ver;
}

int OCPP_cleanLocalList()
{
  char * sqlcleanLocalList = "delete from ocpp_auth_local";
  char *errMsg = 0;
  int rc =sqlite3_exec(db, sqlcleanLocalList, 0, 0, &errMsg);
  if (SQLITE_OK != rc)
  {
	  printf("%s\n",errMsg);
	  return FALSE;
  }
  else
  {
	  printf("delete ocpp_auth_local table successfully\n");
  }

  return TRUE;

}

int OCPP_addLocalList_1(int version, char *idTag, char *parentTage, char *expiryDate, char *status)
{
	 int isSuccess = FALSE;
	 int ret = 0;
	 const char* data = "Callback function called";
	 char sql[200];
	 char zErrMsg[100];
	   // char* sql = NULL;
	   // char* zErrMsg = NULL;

	  //  sql = (char*)malloc(sizeof(char)*200); // getMemory(&sql, 200);
	  //  zErrMsg = (char*)malloc(sizeof(char)*100);      // getMemory(&zErrMsg, 100);
	 memset(sql, 0, 200);
	 memset(zErrMsg, 0, 100);

	 sprintf(sql,"insert or replace into ocpp_auth_local (idtag, parent_idtag, expir_date, status, version) " "VALUES ('%s', '%s', '%s', '%s', %d ); ""SELECT * from ocpp_auth_local", idTag, parentTage, expiryDate, status, version);

	 printf("sql:%s\n", sql);
	 printf("OCPP_addLocalList -5\n");
	 /* Execute SQL statement */
	 //zErrMsg  = 0;
	 ret = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
	 printf("OCPP_addLocalList -6\n");
	 if( ret != SQLITE_OK ){
	    printf("SQL error: %s\n", zErrMsg);
	     	//  free(zErrMsg);
	     	//  free(sql);
	   return isSuccess;
	 }

	 printf("successfully Insert records created\n");
	 isSuccess = TRUE;
	 return isSuccess;
}

void OCPP_deleteIdTag(char *idTag)
{
	int ver = 0;
	int isSuccess = FALSE;
	int rc = 0;
	char sql[100];
	char zErrMsg[100];

	memset(sql, 0, 100);
	memset(zErrMsg, 0, 100);
	sprintf(sql,"DELETE from ocpp_auth_local where idtag='%s'; SELECT * from ocpp_auth_local;", idTag);

	/* Execute SQL statement */
	printf("OCPP_getIdTag -1\n");
	rc = sqlite3_exec(db, sql, deleteIdTagcallback, 0, &zErrMsg);
	printf("OCPP_getIdTag -2\n");
	printf("rc=%d\n",rc);
	if( rc != SQLITE_OK ){
		printf("SQL error: %s", zErrMsg);
	          //sqlite3_free(zErrMsg);
	}else{
		printf("Operation done successfully");
	}
	printf("OCPP_getIdTag -3\n");
}

 int OCPP_addLocalList(int version, char *idTag, char *parentTage, char *expiryDate, char *status)
 {
    int isSuccess = FALSE;
    int ret = 0;
    const char* data = "Callback function called";
    char sql[200];
    char zErrMsg[100];

    memset(sql, 0, 200);
    memset(zErrMsg, 0, 100);
    /* selectFromTable */
   // sql = select * from ocpp_auth_local where starring='Jodie Foster';
    printf("OCPP_addLocalList -1\n");
    sprintf(sql,"select * from ocpp_auth_local where idtag='%s'", idTag);

    printf("OCPP_addLocalList -2\n");
    /* Execute SQL statement */
    selectSqlCount = 0;
    ret = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
    printf("OCPP_addLocalList -3\n");
    if( ret != SQLITE_OK ){
           printf("Error SQL: %s\n", zErrMsg);
    }

    printf("successfully select operation done\n");

    memset(sql, 0, 200);
    memset(zErrMsg, 0, 100);

    if(selectSqlCount  == 0)
    {
    	printf("OCPP_addLocalList -4\n");
    	//Insert
    	//sql = "INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY) "      "VALUES (1, ?�Paul?? 32, ?�California?? 20000.00 ); ";
    	sprintf(sql,"INSERT INTO ocpp_auth_local (idtag, parent_idtag, expir_date, status, version) " "VALUES ('%s', '%s', '%s', '%s', %d ); ", idTag, parentTage, expiryDate, status, version);

    	printf("sql:%s\n", sql);
    	printf("OCPP_addLocalList -5\n");
    	/* Execute SQL statement */
    	//zErrMsg  = 0;
    	ret = sqlite3_exec(db, sql, callback, 0, &zErrMsg);
    	printf("OCPP_addLocalList -6\n");
    	if( ret != SQLITE_OK ){
    	  printf("SQL error: %s\n", zErrMsg);
    	  return isSuccess;
    	}

    	printf("successfully Insert records created\n");
    	isSuccess = TRUE;

    }
    else
    {
    	printf("OCPP_addLocalList -7\n");
    	//Update
    	/* Create merged SQL statement */
    	sprintf(sql, "UPDATE ocpp_auth_local set parent_idtag = '%s', expir_date = '%s',  status ='%s', version =%d where idtag='%s'; "     "SELECT * from ocpp_auth_local", parentTage, expiryDate, status, version, idTag);

    	printf("OCPP_addLocalList -8\n");
    	/* Execute SQL statement */
    	ret = sqlite3_exec(db, sql, callback, (void*)data, &zErrMsg);
    	printf("OCPP_addLocalList -9\n");
    	if( ret != SQLITE_OK ){
    		printf("SQL error: %s\n", zErrMsg);
    		//sqlite3_free(zErrMsg);
    		//sqlite3_free(sql);
    	   return isSuccess;
    	}

    	printf("Successfully operation done \n");
    	isSuccess = TRUE;
    }

    return isSuccess;

 }

char *GetOcppServerURL()
{

	memset(OcppProtocol, 0, sizeof(OcppProtocol));
	memset(OcppHost, 0, sizeof(OcppHost));
	memset(OcppTempPath, 0, sizeof(OcppTempPath));
	sscanf(ShmOCPP16Data->OcppServerURL,
				"%[^:]:%*2[/]%[^:]:%i/%[a-zA-Z0-9._/-]",
				OcppProtocol, OcppHost, &OcppPort, OcppTempPath);
	printf("OcppProtocol =%s\n",OcppProtocol);
	printf("OcppHost =%s\n",OcppHost);
	printf("OcppPort =%d\n",OcppPort);
	printf("OcppTempPath =%s\n",OcppTempPath);

	return OcppHost;
}

char *GetOcppPath()
{

	if(OcppTempPath == NULL)
	{
		sprintf(OcppPath,"/%s",OcppTempPath,ShmOCPP16Data->ChargeBoxId);
	}
	else
	{
		sprintf(OcppPath,"/%s%s",OcppTempPath,ShmOCPP16Data->ChargeBoxId);
	}

	printf("OcppPath=%s\n",OcppPath);
	return OcppPath;
}

int GetOcppPort()
{
	return OcppPort;
}

void Send(struct json_object *message)
{
	printf("Send -1 \n");
	printf("message=%s\n",json_object_to_json_string(message));
	LWS_Send(json_object_to_json_string(message));
}

void LWS_Send(char * str)
{
	pthread_mutex_lock(&lock);
	printf("LWS_Send -1-1 \n");
	printf("message=%s\n",str);
	memset(SendBuffer,0,SendBufLen);
	sprintf((char *)SendBuffer, "%s", str);
	printf("LWS_Send -2 \n");
	pthread_mutex_unlock(&lock);
	lws_callback_on_writable(wsi_client);
	lws_service(context, 10000);//timeout_ms
	//usleep(10000); // 等�??��?微�?
	printf("Send message\n");

}