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 	"libwebsockets.h"
#include 	<lws_config.h>
#include	"hashmap.h"
#include	"ShareMemory.h"
#include	"TransactionQueue.h"
#include    "SystemLogMessage.h"
#include	"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>
#include 	<mcheck.h>




#define PASS				1
#define FAIL				-1

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

//ChargePointMaxProfile
#define ChargePointMaxProfile_JSON     "../Storage/OCPP/ChargePointMaxProfile.json"

//TxDefaultProfile
#define TxDefaultProfile_0_JSON			"../Storage/OCPP/TxDefaultProfile_0.json"
#define TxDefaultProfile_1_JSON			"../Storage/OCPP/TxDefaultProfile_1.json"
#define TxDefaultProfile_2_JSON			"../Storage/OCPP/TxDefaultProfile_2.json"

//TxProfile
#define TxProfile_1_JSON			"../Storage/OCPP/TxProfile_1.json"
#define TxProfile_2_JSON			"../Storage/OCPP/TxProfile_2.json"

#define ChargingProfile_0_JSON			"../Storage/OCPP/chargingprofile_0.json"
#define ChargingProfile_1_JSON			"../Storage/OCPP/chargingprofile_1.json"
#define ChargingProfile_2_JSON			"../Storage/OCPP/chargingprofile_2.json"
#define AuthorizationCache_JSON			"../Storage/OCPP/AuthorizationCache.json"
#define LocalAuthorizationList_JSON		"../Storage/OCPP/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

//ConfigurationMaxKeys
#define GetConfigurationMaxKeysNUM 43


//char guid[37];
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
char queuedata[2000]={0};

//===============================
// Configuration: unknownkey
//===============================
static char unknownkey[10][20]={0};
static int UnknownKeynum = 0;

//===============================
// Gun Total  Numbers
//===============================
//#define  gunTotalNumber (ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D') ? (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY): AC_QUANTITY
static int gunTotalNumber=0;

//===============================
// Local List Version
//===============================
static int localversion=0;
static char idTagAuthorization[32]={0};

//===============================
// OCPP Path
//===============================
char OcppPath[160]={};
char OcppProtocol[10]={0},OcppHost[50]={0}, OcppTempPath[50]={0};
int OcppPort=0;

//===============================
// OCPP sign variable
//===============================
int server_sign = FALSE;
int server_pending = FALSE;
int PRE_SYS_MODE[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
int BootNotificationInterval = 0;
static int SystemInitial = CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY;	// System Boot UP

//===============================
// OCPP auth variable
//===============================
int authenrequest = FALSE;
int authorizeRetryTimes = 0;  //number of  Retry times

//===============================
// OCPP other variables
//===============================
int isUpdateRequest = FALSE;
static int HeartBeatWaitTime = 10;
static int FirstHeartBeat = 0;
static int FirmwareStatusNotificationStatus = 3;  // Idle
static int DiagnosticsStatusNotificationStatus = 0; // Idle

//========================================
// OCPP status/previous related variables
//========================================
static int GunStatusInterval = 10;
int statusModeChage[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY] = {FALSE};
static int ChademoPreviousSystemStatus[CHAdeMO_QUANTITY];
static int CcsPreviousSystemStatus[CCS_QUANTITY];
static int GbPreviousSystemStatus[GB_QUANTITY];
static int AcPreviousSystemStatus[AC_QUANTITY];
int TransactionMessageAttemptsValue = 0;
int TransactionMessageRetryIntervalValue = 0;
static struct OCPPAuthLocalElemet
{
	int listVersionInt;
	char idTagstr[20];
	char parentIdTag[20];
	char expiryDate[30];
	char idTagstatus[16];
}idTagQuery;

//=============================================
// OCPP HeartBeat Response Not Receive Counts
//============================================
static int HeartBeatWithNOResponse = 0;


extern struct lws 					*wsi_client;
extern struct lws_context 			*context;
#if 0
extern unsigned char *SendBuffer;
#endif
extern unsigned char SendBuffer[4096];
extern int SendBufLen;
//extern map_t hashMap;
//extern data_struct_t* mapItem;  --- remove for temporally
//extern data_struct_t mapItem[0];

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

int TransactionMessageAttemptsGet(void);
int TransactionMessageRetryIntervalGet(void);
int GetOcppConnStatus(void);
void SetOcppConnStatus(uint8_t status);
int updateSetting(char *key, char *value);
int setKeyValue(char *key, char *value);
void OCPP_get_TableAuthlocalAllData(void);
void processUnkownKey(void);

//static char *querysql = "SELECT * FROM ocpp_auth_local;";

struct StructOCPPMeterValue
{
	unsigned char 				TimeStamp[28];
	struct StructSampledValue	SampledValue[10];
};

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

}clientTime;

typedef union
{
	//Operations Initiated by Central System
	unsigned char CsMsgValue[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_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 + AC_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;

#if 0
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)
};
#endif

/*ChargePointStatus*/
typedef enum {
	Available =0,
	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;

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

/*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,
};

//GetConfiguration Array
struct StructConfigurationKeyItems staticKeyArray[GetConfigurationMaxKeysNUM]={0};
struct StructConfigurationKey staticResponseConfigurationKeyArray[GetConfigurationMaxKeysNUM]={0};
struct StructConfigurationKeyItems staticResponseUnknownKey[10]={0};
struct StructLocalAuthorizationList staticLocalAuthorizationList[500]={0};

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

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


    /****************************** For Initial Settings************************************************/

   	gunTotalNumber = (ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D') ? (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY): AC_QUANTITY;

	memset(ShmOCPP16Data->StatusNotification,0,sizeof(struct StructStatusNotification)*(CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY));

	for(int gun_index=0; gun_index < gunTotalNumber/*(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY)*/; gun_index++ )
	{
		cpinitateMsg.bits[gun_index].StatusNotificationReq = 0;
		cpinitateMsg.bits[gun_index].StatusNotificationConf = 0;
		clientTime.MeterValues[gun_index] = time((time_t*)NULL);

	}

	// Charger PRE_SYS_MODE
	memset(PRE_SYS_MODE, 0, sizeof(PRE_SYS_MODE));

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

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

	for(int gun_index=0;gun_index < gunTotalNumber/*(CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY)*/ ;gun_index++)
	{
		clientTime.StatusNotification[gun_index] = time((time_t*)NULL);
		clientTime.MeterValues[gun_index] = time((time_t*)NULL);
		//strcpy((char *)ShmOCPP16Data->StatusNotification[gun_index].ErrorCode, "NoError");
	}


	//HeartBeatWaitTime = 10;

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

	// allocate Configuration memory address
	ShmOCPP16Data->GetConfiguration.Key = staticKeyArray;
	ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey = staticResponseConfigurationKeyArray;
	ShmOCPP16Data->GetConfiguration.ResponseUnknownKey = staticResponseUnknownKey;
	ShmOCPP16Data->SendLocalList.LocalAuthorizationList = staticLocalAuthorizationList;


	if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D') // 'D' means DC
	{
		SystemInitial = CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY;
		DEBUG_INFO("DC ...\n");
	}
	else if (ShmSysConfigAndInfo->SysConfig.ModelName[0]=='A') //'A' means AC
	{
		SystemInitial = AC_QUANTITY;
		DEBUG_INFO("AC ...\n");
	}

	//Status Setting
	for (int index = 0; index < CHAdeMO_QUANTITY; index++)
	{
		ChademoPreviousSystemStatus[index]= ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PreviousSystemStatus;
	}

	for (int index = 0; index < CCS_QUANTITY; index++)
	{
		CcsPreviousSystemStatus[index]= ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PreviousSystemStatus;
	}

	for (int index = 0; index < GB_QUANTITY; index++)
	{
		GbPreviousSystemStatus[index]= ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PreviousSystemStatus;
	}

	for (int index = 0; index < AC_QUANTITY; index++)
	{
		AcPreviousSystemStatus[index]= ShmSysConfigAndInfo->SysInfo.AcChargingData[index].PreviousSystemStatus;
	}

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

//---------------------------------------------
//  new:
//  enum SYSTEM_STATUS
//	{
//		SYS_MODE_BOOTING		= 0,
//		SYS_MODE_IDLE    	  	= 1,
//		SYS_MODE_AUTHORIZING		= 2,
//		SYS_MODE_PREPARING		= 3,
//		SYS_MODE_CHARGING		= 4,
//		SYS_MODE_TERMINATING		= 5,
//		SYS_MODE_ALARM			= 6,
//		SYS_MODE_FAULT			= 7,
//		SYS_MODE_RESERVATION		= 8,
//		SYS_MODE_BOOKING		= 9,
//		SYS_MODE_MAINTAIN		= 10,
//		SYS_MODE_DEBUG			= 11,
//		SYS_MODE_REASSIGN_CHECK		= 12,
//		SYS_MODE_REASSIGN		= 13,
//		SYS_MODE_PRECHARGE		= 14,
//		SYS_MODE_PREPARING_EV		= 15,
//		SYS_MODE_PREPARING_EVSE		= 16,
//		SYS_MODE_COMPLETE		= 17
//	};
//
//  old:
//	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
//	};
//
//-----------------------------------------

void CheckSystemValue(void)
{
	int meterValueSend[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY]={0};
	int IdleModeCnt = 0;
	char filenmae[100]={0};
	char str[100]={0};

	//===============================
	// send Heartbeat
	//===============================
	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);
		HeartBeatWithNOResponse = HeartBeatWithNOResponse + 1;

	}

	//==============================================
	// Update firmware request
	//==============================================
	if(isUpdateRequest == TRUE )
	{
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for(int gun_index=0;gun_index < (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY) ;gun_index++)
			{
				//check SystemStatus
				/*************************DC*******************************/
				for (int index = 0; index < CHAdeMO_QUANTITY; index++)
				{
					if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_IDLE)) //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 == SYS_MODE_IDLE)) //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_Installing]);
				isUpdateRequest = FALSE;
				//ShmOCPP16Data->MsMsg.bits.UpdateFirmwareReq = 1; // trigger firmware upgrade
			}

		}
		else
		{
			/*************************AC*******************************/
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == 1) //S_IDLE
				{
					IdleModeCnt = IdleModeCnt + 1;
				}
			}

			if(IdleModeCnt == AC_QUANTITY)
			{
				//sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_Installing]);
				isUpdateRequest = FALSE;
				//ShmOCPP16Data->MsMsg.bits.UpdateFirmwareReq = 1; // trigger firmware upgrade
			}
		}
	}

	//DEBUG_INFO("\n gunTotalNumber=%d\n",gunTotalNumber);

	for(int gun_index=0;gun_index < gunTotalNumber /*(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY )*/ ;gun_index++)
	{

		//===============================
		// CSU Trigger Reset Conf
		//===============================
		if((server_sign == TRUE) &&(ShmOCPP16Data->MsMsg.bits.ResetConf == 1))
		{
			sendResetConfirmation((char *)ShmOCPP16Data->Reset.guid, (char *)ShmOCPP16Data->Reset.ResponseStatus);

			if(strcmp((const char *)ShmOCPP16Data->Reset.Type, "Soft") == 0)
			{
				server_sign = FALSE;
			}

		}

		//===============================
		// CSU Trigger Authorize Request
		//===============================
		if((server_sign == TRUE) && (ShmOCPP16Data->SpMsg.bits.AuthorizeReq == 1)&&(authorizeRetryTimes < 3)/*authenrequest == FALSE*/)
		{
			if(strcmp((const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizeRemoteTxRequests].ItemData, "TRUE") == 0)// [If AuthorizeRemoteTxRequests = true
			{
				sendAuthorizeRequest(0);

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

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

		//==============================================
		// Charger start transaction
		//==============================================
		if((server_sign == TRUE) && (ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionReq == 1))
		{
			sendStartTransactionRequest(gun_index);
			ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionReq =0;
			clientTime.StartTransaction = time((time_t*)NULL);
			clientTime.MeterValues[gun_index] = time((time_t*)NULL);
		 }

		//==============================================
		// Charger stop transaction
		//==============================================
		if((server_sign == TRUE) && ((ShmOCPP16Data->CpMsg.bits[gun_index].StopTransactionReq == 1)))
		{
			sendStopTransactionRequest(gun_index);
			ShmOCPP16Data->CpMsg.bits[gun_index].StopTransactionReq =0;
			clientTime.StopTransaction = time((time_t*)NULL);
		}


		//DEBUG_INFO("ShmSysConfigAndInfo->SysInfo.AcChargingData[0].SystemStatus=%d\n",ShmSysConfigAndInfo->SysInfo.AcChargingData[0].SystemStatus);

		//==============================================
		// Charger status report
		//==============================================
		/* Check Mode Change */
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
				{
					if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus != ChademoPreviousSystemStatus[index]/*PRE_SYS_MODE[gun_index]*/ )
					{
						PRE_SYS_MODE[gun_index] = ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus;
						ChademoPreviousSystemStatus[index] = ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus;
						cpinitateMsg.bits[gun_index].StatusNotificationReq = 1;
						statusModeChage[gun_index] = TRUE;

					}

				}
			}

			for (int index = 0; index < CCS_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
				{
					if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus != CcsPreviousSystemStatus[index]/*PRE_SYS_MODE[gun_index]*/ )
					{
						PRE_SYS_MODE[gun_index] = ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus;
						CcsPreviousSystemStatus[index] = ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus;
						cpinitateMsg.bits[gun_index].StatusNotificationReq = 1;
						statusModeChage[gun_index] = 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 != GbPreviousSystemStatus[index]/*PRE_SYS_MODE[gun_index]*/ )
					{
						PRE_SYS_MODE[gun_index] = ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus;
						GbPreviousSystemStatus[index] = ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus;
						cpinitateMsg.bits[gun_index].StatusNotificationReq = 1;
						statusModeChage[gun_index] = TRUE;
					}

				}
			}

		}
		else //AC
		{
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)
				{
					if(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus != AcPreviousSystemStatus[index]/*PRE_SYS_MODE[gun_index]*/ )
					{
						PRE_SYS_MODE[gun_index] = ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus;
						AcPreviousSystemStatus[index] = ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus;
						cpinitateMsg.bits[gun_index].StatusNotificationReq = 1;
						statusModeChage[gun_index] = TRUE;
					}

				}
			}// END OF FOR

		}// END OF ELSE


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

			//GunStatusInterval= GunStatusInterval* gun_index;
			sendStatusNotificationRequest(gun_index);
			clientTime.StatusNotification[gun_index] = time((time_t*)NULL);
			//cpinitateMsg.bits[gun_index].StatusNotificationReq = 0;
			statusModeChage[gun_index] = FALSE;
			//sleep(30); // sleep for 30 seconds
		}

	//==============================================
	// Meter report
	//==============================================
	if((server_sign == TRUE) &&  ((time((time_t*)NULL) - clientTime.MeterValues[gun_index])> (atoi((const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValueSampleInterval].ItemData)- 1 ) ) )
	{
		//check Transaction active
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			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 == SYS_MODE_CHARGING))
				{
						meterValueSend[gun_index] =1;
				}

				if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_COMPLETE)) // complete
				{
					sprintf(filenmae,"../Storage/OCPP/TxProfile_%d.json",(gun_index+1));
					if((access(filenmae,F_OK))!=-1)
					{
						DEBUG_INFO("TxProfile exist. OCPP will delete TX Charging Profile\n");

						sprintf(str,"rm -f %s",filenmae);
						system(str);

					}

				}
			}// End for CHAdeMO

			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 == SYS_MODE_CHARGING))
				{
					meterValueSend[gun_index] =1;
				}

				if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_COMPLETE)) // complete
				{
					sprintf(filenmae,"../Storage/OCPP/TxProfile_%d.json",(gun_index+1));
					if((access(filenmae,F_OK))!=-1)
					{
						DEBUG_INFO("TxProfile exist. OCPP will delete TX Charging Profile\n");

						sprintf(str,"rm -f %s",filenmae);
						system(str);

					}

				}
			} // End for CCS

			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 == SYS_MODE_CHARGING))
				{
					meterValueSend[gun_index] =1;
				}

				if((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_COMPLETE)) // complete
				{
					sprintf(filenmae,"../Storage/OCPP/TxProfile_%d.json",(gun_index+1));
					if((access(filenmae,F_OK))!=-1)
					{
						DEBUG_INFO("TxProfile exist. OCPP will delete TX Charging Profile\n");

						sprintf(str,"rm -f %s",filenmae);
						system(str);

					}

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

				if((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_COMPLETE)) // complete
				{
					sprintf(filenmae,"../Storage/OCPP/TxProfile_%d.json",(gun_index+1));
					if((access(filenmae,F_OK))!=-1)
					{
						DEBUG_INFO("TxProfile exist. OCPP will delete TX Charging Profile\n");

						sprintf(str,"rm -f %s",filenmae);
						system(str);

					}

				}
			}//End for AC


		}//END OF ELSE


		//	sleep(1);
			clientTime.MeterValues[gun_index] = time((time_t*)NULL);

			if(meterValueSend[gun_index] == 1)
				sendMeterValuesRequest(gun_index);


	}

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

	//===============================
	// Check if Reserve is expired
	//===============================
	if((server_sign == TRUE) && (ShmOCPP16Data->ReserveNow[gun_index].ExpiryDate[0] != 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");
		strptime((char *)ShmOCPP16Data->ReserveNow[gun_index].ExpiryDate, "%Y-%m-%dT%H:%M:%S", &tp);
		tp.tm_isdst = -1;
		time_t utc = mktime(&tp);
		diff_t = difftime(utc, t);
		//DEBUG_INFO("diff_t=%f\n",diff_t);
		if(diff_t <= 0)
		{
			DEBUG_INFO("reserve expired !!!   \n");
			memset(ShmOCPP16Data->ReserveNow[gun_index].ExpiryDate,0,sizeof(ShmOCPP16Data->ReserveNow[gun_index].ExpiryDate));
			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((const char *)ShmOCPP16Data->StartTransaction[gun_index].IdTag,(const char *)ShmOCPP16Data->ReserveNow[gun_index].IdTag) ==0))
		{
			ShmOCPP16Data->CsMsg.bits[gun_index].CancelReservationReq = 1;
		}
		else
		{
			//check Transaction active

			if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
			{
				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) &&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].ReservationId !=0))
					{
						//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 == SYS_MODE_ALARM) || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_FAULT) ) // 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)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].ReservationId !=0))
					{
						//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 == SYS_MODE_ALARM) || (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_FAULT) ) // 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)&&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].ReservationId !=0) )
					{
						//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 == SYS_MODE_ALARM) || (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_FAULT) ) // S_ALARM, S_FAULT
						{
							ShmOCPP16Data->CsMsg.bits[gun_index].CancelReservationReq = 1;

						}

					}
				}


			}
			else //AC
			{
				for (int index = 0; index < AC_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.AcChargingData[index].Index == gun_index) &&(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].ReservationId !=0))
					{
						//if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '6') || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '7') || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '9') )
						if((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_ALARM) || (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_FAULT) ) // S_ALARM, S_FAULT
						{
							ShmOCPP16Data->CsMsg.bits[gun_index].CancelReservationReq = 1;

						}

					}
				}

			}// END OF ELSE

		 }// END OF check Transaction active
	  }//END OF Check if Reserve is expired

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

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

	  }

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

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

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

	  //==========================================
	  // csu trigger DataTransferReq
	  //==========================================
	  if((server_sign == TRUE) &&(ShmOCPP16Data->CsMsg.bits[gun_index].DataTransferReq == 1))
	  {
		  sendDataTransferRequest(gun_index);
		  ShmOCPP16Data->CsMsg.bits[gun_index].DataTransferReq = 0;
	  }
	}

}

//==========================================
// send request routine
//==========================================
int sendAuthorizeRequest(int gun_index)
{

	mtrace();
	int result = FAIL;
	char message[100]={0};
	char guid[37];
	char tempdata[65]={0};

	DEBUG_INFO("sendAuthorizeRequest \n");

	//Local Authorize
	if((strcmp((const char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData, "TRUE") == 0)&&(ShmOCPP16Data->OcppConnStatus ==0))
	{
		OCPP_getIdTag((char *)ShmSysConfigAndInfo->SysConfig.UserId);
		if((strcmp(idTagQuery.idTagstr,"") == 0) || (strcmp(idTagQuery.idTagstatus,"Accepted") != 0) )
		{
			DEBUG_INFO("Local Authorization Fail !!!!\n");
			strcpy((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate, "");
			strcpy((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag, (const char *)ShmSysConfigAndInfo->SysConfig.UserId);
			strcpy((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status, "Invalid");
			ShmOCPP16Data->SpMsg.bits.AuthorizeReq = 0;
			ShmOCPP16Data->SpMsg.bits.AuthorizeConf = 1; // inform csu
			authorizeRetryTimes = 0;
			return result;
		}
		else
		{
			DEBUG_INFO("Local Authorization Pass !!!!\n");
			strcpy((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate, idTagQuery.expiryDate);
			strcpy((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag, (const char *)ShmSysConfigAndInfo->SysConfig.UserId);
			strcpy((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status, idTagQuery.idTagstatus);
			result = PASS;
			ShmOCPP16Data->SpMsg.bits.AuthorizeReq = 0;
			ShmOCPP16Data->SpMsg.bits.AuthorizeConf = 1; // inform csu
			authorizeRetryTimes = 0;
			return result;
		}
	}

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

	//get data from shared memory
	strcpy((char *)ShmOCPP16Data->Authorize.IdTag, (const char *)ShmSysConfigAndInfo->SysConfig.UserId);

	random_uuid(guid);
	sprintf(message,"[ %d, \"%s\", \"Authorize\", { \"idTag\": \"%s\" } ]",MESSAGE_TYPE_CALL, guid, ShmOCPP16Data->Authorize.IdTag);
	LWS_Send(message);

	sprintf(tempdata, "Authorize,%d", gun_index);
	if(hashmap_operation(0, guid, tempdata) == 1)
	{
		result = PASS;
		DEBUG_ERROR("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", hashmapForMessageLength()/*hashmap_length(hashMap)*/);
	//#endif

	ShmOCPP16Data->SpMsg.bits.AuthorizeReq = 0;

	return result;
}

int sendBootNotificationRequest(void)
{
	mtrace();
	int result = FAIL;
	char message[500]={0}, payload[700]={0};
    char guid[37]={0};
    char tempdata[65]={0};
    int IsGunCharging = FALSE;


    //check Transaction active
    if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
    {
    	for (int index = 0; index < CHAdeMO_QUANTITY; index++)
    	{
    	   if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_CHARGING) //S_CHARGING
    	   {
    		   IsGunCharging = TRUE;
    	   }

    	}

    	for (int index = 0; index < CCS_QUANTITY; index++)
    	{
    	   if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_CHARGING) //S_CHARGING
    	   {
    		   IsGunCharging = TRUE;
    	   }
    	}

    	for (int index = 0; index < GB_QUANTITY; index++)
    	{
    	   if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_CHARGING) //S_CHARGING
    	   {
    		   IsGunCharging = TRUE;
    	   }
    	}
    }
    else
    {
    	for (int index = 0; index < AC_QUANTITY; index++)
        {
    		if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_CHARGING) //S_CHARGING
        	{
    			IsGunCharging = TRUE;
        	}

        }

    }


    if(IsGunCharging == TRUE)
    {
    	server_sign = TRUE;
    	return result;
    }



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

	sprintf(payload, "{ \"chargeBoxSerialNumber\": \"%s\", \"chargePointModel\": \"%s\", \"chargePointSerialNumber\": \"%s\", \"chargePointVendor\": \"%s\", \"firmwareVersion\": \"%s\", \"iccid\": \"%s\", \"imsi\": \"%s\", \"meterSerialNumber\": \"%s\", \"meterType\": \"%s\"} ",
			ShmOCPP16Data->ChargeBoxId
			,ShmSysConfigAndInfo->SysConfig.ModelName
			,ShmSysConfigAndInfo->SysConfig.SerialNumber
			,ShmSysConfigAndInfo->SysConfig.chargePointVendor
			,ShmOCPP16Data->BootNotification.CpFwVersion
			,ShmOCPP16Data->BootNotification.CpIccid
			,ShmOCPP16Data->BootNotification.CpImsi
			,ShmOCPP16Data->BootNotification.CpMeterSerialNumber
			,ShmOCPP16Data->BootNotification.CpMeterType);
	random_uuid(guid);

	sprintf(message,"[ %d, \"%s\", \"%s\", %s ]",MESSAGE_TYPE_CALL, guid, "BootNotification", payload);
	LWS_Send(message);
	sprintf(tempdata, "BootNotification,0");
	if(hashmap_operation(0, guid, tempdata) == 1)//if(hashmap_operation(0,NULL/*hashMap*/, guid,mapItem, tempdata/*(void**)(&mapItem)*//*(void**)(&mapItem)*/) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
	}

	memset(queuedata, 0, sizeof(queuedata));
	strcpy(queuedata,message);

	//#ifdef  SystemLogMessage
	//DEBUG_INFO(">>>>>BootNotification request\n");
	//DEBUG_INFO("Message: %s\n", SendBuffer);
	//#endif

	return result;
}

int sendDataTransferRequest(int gun_index)
{
	mtrace();
	char message[1000]={0};
	char guid[37]={0};
	char tempdata[65]={0};
	int result = FAIL;

//[2,"696e8a35-f394-45e3-a0c7-7098b86f38a6","DataTransfer",{"vendorId":"Phihong","messageId":"FeePerKWH","data":"1"}]

	random_uuid(guid);

	sprintf(message,"[%d,\"%s\",\"DataTransfer\",{\"vendorId\":\"%s\",\"messageId\":\"%s\",\"data\":\"%s\"}]",
			MESSAGE_TYPE_CALL,
			guid,
			ShmOCPP16Data->DataTransfer[gun_index].VendorId,
			ShmOCPP16Data->DataTransfer[gun_index].MessageId,
			ShmOCPP16Data->DataTransfer[gun_index].Data);

	LWS_Send(message);

	sprintf(tempdata, "DataTransfer,%d", (gun_index + 1));

	if(hashmap_operation(0, guid, tempdata) == 1)//if(hashmap_operation(0,NULL/*hashMap*/, mapItem[0].key_string, mapItem[0].key_value/*mapItem*/, (void**)(&mapItem)/*(void**)(&mapItem)*/) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
		DEBUG_ERROR("DataTransfer mapItem pass\n");
	}

	//#ifdef SystemLogMessage
	//DEBUG_INFO(">>>>>DataTransfer request\n");
	//DEBUG_INFO("Message: %s\n", SendBuffer);
	//#endif

	return result;
}

int sendDiagnosticsStatusNotificationRequest(char *status)
{
	mtrace();
	int result = FAIL;
	char message[110]={0};
	char guid[37]={0};
	char tempdata[65]={0};

	//[ 2, "9f7bced1-b8b1-40ec-b3bb-2e15630e3cdc", "DiagnosticsStatusNotification", { "status": "Idle" } ]

	DEBUG_INFO("sendDiagnosticsStatusNotificationRequest \n");
	sprintf((char *)ShmOCPP16Data->DiagnosticsStatusNotification.Status,"%s",(const char *)status);
	random_uuid(guid);

	sprintf(message,"[%d,\"%s\",\"DiagnosticsStatusNotification\",{\"status\":\"%s\"}]",MESSAGE_TYPE_CALL, guid,status);
	LWS_Send(message);

	sprintf(tempdata, "DiagnosticsStatusNotification,%d", 0);

	if(hashmap_operation(0, guid, tempdata) == 1)
	{
		result = PASS;
		//DEBUG_INFO("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", hashmapForMessageLength()/*hashmap_length(hashMap)*/);
	//#endif

	ShmOCPP16Data->SpMsg.bits.DiagnosticsStatusNotificationReq = 0;
	ShmOCPP16Data->SpMsg.bits.DiagnosticsStatusNotificationConf = 0;

	//record status
	if(strcmp(status,"Idle")==0)
	{
		DiagnosticsStatusNotificationStatus = 0;
	}
	else if(strcmp(status,"Uploaded")==0)
	{
		DiagnosticsStatusNotificationStatus = 1;
	}
	else if(strcmp(status,"UploadFailed")==0)
	{
		DiagnosticsStatusNotificationStatus = 2;
	}
	else if(strcmp(status,"Uploading")==0)
	{
		DiagnosticsStatusNotificationStatus = 3;
	}

	return result;
}

int sendFirmwareStatusNotificationRequest(char *status)
{
	mtrace();
	int result = FAIL;
	char message[110]={0};
	char guid[37]={0};
	char tempdata[65]={0};

//	[ 2, "eb841424-ae56-42b0-8c84-d5296018c33c", "FirmwareStatusNotification", { "status": "Downloaded" } ]

	DEBUG_INFO("sendFirmwareStatusNotificationRequest \n");
	sprintf((char *)ShmOCPP16Data->FirmwareStatusNotification.Status, "%s", (const char *)status);
	random_uuid(guid);

	sprintf(message,"[%d,\"%s\",\"FirmwareStatusNotification\",{\"status\":\"%s\"}]",MESSAGE_TYPE_CALL, guid, status);
	LWS_Send(message);

	sprintf(tempdata, "FirmwareStatusNotification,%d", 0);

	if(hashmap_operation(0, guid, tempdata) == 1)//if(hashmap_operation(0,NULL/*hashMap*/, mapItem[0].key_string, mapItem[0].key_value/*mapItem*/, (void**)(&mapItem)/*(void**)(&mapItem)*/) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
		DEBUG_INFO("FirmwareStatusNotification mapItem pass\n");
	}

	//#ifdef SystemLogMessage
	//DEBUG_INFO(">>>>>FirmwareStatusNotification request\n");
	//DEBUG_INFO("Message: %s\n", SendBuffer);
	//#endif

	ShmOCPP16Data->SpMsg.bits.FirmwareStatusNotificationReq = 0;
	ShmOCPP16Data->SpMsg.bits.FirmwareStatusNotificationConf = 0;

	//record status
	if(strcmp(status,"Downloaded")==0)
	{
		 FirmwareStatusNotificationStatus = 0;
	}
	else if(strcmp(status,"DownloadFailed")==0)
	{
		FirmwareStatusNotificationStatus = 1;
	}
	else if(strcmp(status,"Downloading")==0)
	{
		FirmwareStatusNotificationStatus = 2;
	}
	else if(strcmp(status,"Idle")==0)
	{
		FirmwareStatusNotificationStatus = 3;
	}
	else if(strcmp(status,"InstallationFailed")==0)
	{
		FirmwareStatusNotificationStatus = 4;
	}
	else if(strcmp(status,"Installing")==0)
	{
		FirmwareStatusNotificationStatus = 5;
	}
	else if(strcmp(status,"Installed")==0)
	{
		FirmwareStatusNotificationStatus = 6;
	}


	return result;
}

int sendHeartbeatRequest(int gun_index)
{
	mtrace();
	int result = FAIL;

	char message[80]={0};
	char guid[37]={0};
	char tempdata[65]={0};

	random_uuid(guid);

	sprintf(message, "[%d,\"%s\",\"Heartbeat\",{ }]"
					, MESSAGE_TYPE_CALL
					, guid );

	LWS_Send(message);

	sprintf(tempdata, "Heartbeat,%d", 0);

	if(hashmap_operation(0, guid, tempdata) == 1)//if(hashmap_operation(0,NULL/*hashMap*/, guid, mapItem, tempdata/*(void**)(&mapItem)*/) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
		//DEBUG_ERROR("Heartbeat mapItem pass\n");
	}

	//#ifdef SystemLogMessage
	//DEBUG_INFO(">>>>>Heartbeat request\n");
	//DEBUG_INFO("Message: %s\n", SendBuffer);
	//#endif

	return result;
}

int sendStartTransactionRequest(int gun_index)
{
	mtrace();
	int result = FAIL;
	char message[250]={0};
	char guid[37]={0};
	struct timeval tmnow;
	struct tm *tm;
	char buf[30];//, usec_buf[6];
	char tempdata[65]={0};

	DEBUG_INFO("sendStartTransactionRequest...");
	gettimeofday(&tmnow, NULL);

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

    // set value
	if(ShmOCPP16Data->OcppConnStatus == 1 )
	{
		//memset(&ShmOCPP16Data->StartTransaction[gun_index], 0, sizeof(ShmOCPP16Data->StartTransaction[gun_index])); // Clear StartTransaction Value

	}

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

	if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
	{
		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
			{
				ShmOCPP16Data->StartTransaction[gun_index].MeterStart = ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargedEnergy;
				ShmOCPP16Data->StartTransaction[gun_index].ReservationId = ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].ReservationId;
			}
		}

		for (int index = 0; index < CCS_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
			{
				ShmOCPP16Data->StartTransaction[gun_index].MeterStart = ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargedEnergy;
				ShmOCPP16Data->StartTransaction[gun_index].ReservationId = ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].ReservationId;
			}
		}

		for (int index = 0; index < GB_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
			{
				ShmOCPP16Data->StartTransaction[gun_index].MeterStart = ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargedEnergy;
				ShmOCPP16Data->StartTransaction[gun_index].ReservationId = ShmSysConfigAndInfo->SysInfo.GbChargingData[index].ReservationId;
			}
		}

	}
	else
	{
		for (int index = 0; index < AC_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)
			{
				ShmOCPP16Data->StartTransaction[gun_index].MeterStart = ShmSysConfigAndInfo->SysInfo.AcChargingData[index].PresentChargedEnergy;
				ShmOCPP16Data->StartTransaction[gun_index].ReservationId = ShmSysConfigAndInfo->SysInfo.AcChargingData[index].ReservationId;
			}
		}

	}//END OF ELSE


	random_uuid(guid);

	sprintf(message, "[%d,\"%s\",\"StartTransaction\",{\"connectorId\":%d,\"idTag\":\"%s\",\"meterStart\":%d,\"reservationId\":%d,\"timestamp\":\"%s\"}]"
					, MESSAGE_TYPE_CALL
					, guid
					, ShmOCPP16Data->StartTransaction[gun_index].ConnectorId
					, ShmOCPP16Data->StartTransaction[gun_index].IdTag
					, ShmOCPP16Data->StartTransaction[gun_index].MeterStart
					, ShmOCPP16Data->StartTransaction[gun_index].ReservationId
					, ShmOCPP16Data->StartTransaction[gun_index].Timestamp );

	LWS_Send(message);

	sprintf(tempdata, "StartTransaction,%d", (gun_index));

	if(hashmap_operation(0, guid, tempdata) == 1)//if(hashmap_operation(0,NULL/*hashMap*/, mapItem[0].key_string, mapItem[0].key_value/*mapItem*/, (void**)(&mapItem)/*(void**)(&mapItem)*/) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
	}
	strcpy(queuedata, message);

	queue_operation(4, guid, queuedata );//addq(guid, queuedata); ---> remove temporally
	//#ifdef SystemLogMessage
	//DEBUG_INFO(">>>>>StartTransaction request\n");
	//DEBUG_INFO("Message: %s\n", SendBuffer);
	//#endif

	return result;
}

int sendStatusNotificationRequest(int gun_index)
{
	mtrace();
	int result = FAIL;

	char message[600]={0};
	char guid[37];
	int currentStatus = 0;
	struct timeval tmnow;
	struct tm *tm;
	char buf[30];//, usec_buf[6];
	char tempdata[65]={0};

	gettimeofday(&tmnow, NULL);

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

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

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

	// it's option
	strcpy((char *)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
	if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
	{
		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
		{
			//printf("gun_index=%d\n",gun_index);
			//printf("ShmSysConfigAndInfo->SysInfo.ChademoChargingData[0].SystemStatus=%d\n",ShmSysConfigAndInfo->SysInfo.ChademoChargingData[0].SystemStatus);
			if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_IDLE)) //S_IDLE
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Available");
				currentStatus = 0; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_PREPARING)) //S_PRECHARGE
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Preparing");
				currentStatus = 1; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_CHARGING)) //S_CHARGING
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Charging");
				currentStatus = 2; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_COMPLETE)) //S_COMPLETE
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Finishing");
				currentStatus = 5; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_ALARM)) //S_ALARM   ---> SuspendedEV
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 4; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_MAINTAIN)|| (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_DEBUG))) //S_TERMINATING   ---> Unavailable
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 7; //OCPP Status: Unavailable
			}
			else if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_FAULT)) //S_FAULT   ---> Faulted
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 8; //OCPP Status: Faulted
			}
			else if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_RESERVATION)) //    ---> Reserved
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 6; //OCPP Status: Reserved
			}

		}//end of for CHAdeMO_QUANTITY

		for (int index = 0; index < CCS_QUANTITY; index++)
		{
			//printf("ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].SystemStatus=%d\n",ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].SystemStatus);
			if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_IDLE)) //S_IDLE
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Available");
				currentStatus = 0; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_PREPARING)) //S_PRECHARGE
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Preparing");
				currentStatus = 1; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_CHARGING)) //S_CHARGING
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Charging");
				currentStatus = 2; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_COMPLETE)) //S_COMPLETE
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Finishing");
				currentStatus = 5; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_ALARM)) //S_ALARM   ---> SuspendedEV
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 4; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_MAINTAIN) || (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_DEBUG))) //S_TERMINATING   ---> Unavailable
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 7; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_FAULT)) //S_FAULT   ---> Faulted
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 8; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_RESERVATION)) //   ---> Reserved
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 6; //OCPP Status
			}

		}

		for (int index = 0; index < GB_QUANTITY; index++)
		{
			//printf("ShmSysConfigAndInfo->SysInfo.GbChargingData[0].SystemStatus=%d\n",ShmSysConfigAndInfo->SysInfo.GbChargingData[0].SystemStatus);
			if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index) &&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_IDLE)) //S_IDLE
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Available");
				currentStatus = 0; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index) &&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_PREPARING)) //S_PRECHARGE
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Preparing");
				currentStatus = 1; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_CHARGING)) //S_CHARGING
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Charging");
				currentStatus = 2; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_COMPLETE)) //S_COMPLETE
			{
				//	strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Finishing");
				currentStatus = 5; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_ALARM)) //S_ALARM   ---> SuspendedEV
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 4; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)&&((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_MAINTAIN) || (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_DEBUG))) //S_TERMINATING   ---> Unavailable
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 7; //OCPP Status: Unavailable
			}
			else if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_FAULT)) //S_FAULT   ---> Faulted
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 8; //OCPP Status: Faulted
			}
			else if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_RESERVATION)) //   ---> Reserved
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 6; //OCPP Status: Faulted
			}
		}

	}
	else
	{
		for (int index = 0; index < AC_QUANTITY; index++)
		{
			//printf("gun_index=%d\n",gun_index);
			//printf("ShmSysConfigAndInfo->SysInfo.ChademoChargingData[0].SystemStatus=%d\n",ShmSysConfigAndInfo->SysInfo.ChademoChargingData[0].SystemStatus);
			if ((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_IDLE)) //S_IDLE
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Available");
				currentStatus = 0; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_PREPARING)) //S_PRECHARGE
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Preparing");
				currentStatus = 1; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_CHARGING)) //S_CHARGING
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Charging");
				currentStatus = 2; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_COMPLETE)) //S_COMPLETE
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, "Finishing");
				currentStatus = 5; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_ALARM)) //S_ALARM   ---> SuspendedEV
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 4; //OCPP Status
			}
			else if ((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)&&((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_MAINTAIN)|| (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_DEBUG))) //S_TERMINATING   ---> Unavailable
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 7; //OCPP Status: Unavailable
			}
			else if ((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_FAULT)) //S_FAULT   ---> Faulted
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 8; //OCPP Status: Faulted
			}
			else if ((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)&&(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_RESERVATION)) //    ---> Reserved
			{
				//strcpy(ShmOCPP16Data->StatusNotification[gun_index].Status, ChargePointStatusStr[SuspendedEV]);
				currentStatus = 6; //OCPP Status: Reserved
			}

		}//end of for AC_QUANTITY


	}//END OF ELSE


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

	random_uuid(guid);

	sprintf(message, "[%d,\"%s\",\"StatusNotification\",{\"connectorId\":%d,\"errorCode\":\"%s\",\"info\":\"%s\",\"status\":\"%s\",\"timestamp\":\"%s\",\"vendorId\":\"%s\",\"vendorErrorCode\":\"%s\"}]"
					, MESSAGE_TYPE_CALL
					, guid
					, ShmOCPP16Data->StatusNotification[gun_index].ConnectorId
					, ShmOCPP16Data->StatusNotification[gun_index].ErrorCode
					, ShmOCPP16Data->StatusNotification[gun_index].Info
					, ShmOCPP16Data->StatusNotification[gun_index].Status
					, ShmOCPP16Data->StatusNotification[gun_index].Timestamp
					, ShmOCPP16Data->StatusNotification[gun_index].VendorId
					, ShmOCPP16Data->StatusNotification[gun_index].VendorErrorCode);

	LWS_Send(message);

	sprintf(tempdata, "StatusNotification,%d", (gun_index));

	if(hashmap_operation(0, guid, tempdata) == 1)//if(hashmap_operation(0,NULL/*hashMap*/, guid, mapItem, tempdata/*(void**)(&mapItem)*//*(void**)(&mapItem)*/) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		//DEBUG_ERROR("statusNotification mapitem pass");
		result = PASS;
	}

	//#ifdef SystemLogMessage
	//DEBUG_INFO(">>>>>StatusNotification request\n");
	//DEBUG_INFO("Message: %s\n", SendBuffer);
	//#endif

	return result;
}

int sendStopTransactionRequest(int gun_index)
{
	mtrace();
	int result = FAIL;
	char message[1500]={0};
	char guid[37]={0};
	char tempdata[65]={0};
	int idx_sample=0;

	DEBUG_ERROR("sendStopTransactionRequest \n");

	//memset(&(ShmOCPP16Data->StopTransaction[gun_index].TransactionData), 0, sizeof(struct StructMeterValue));
	//strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].IdTag, (const char *)ShmSysConfigAndInfo->SysConfig.UserId/*ShmOCPP16Data->Authorize.IdTag*/);

	//ENERGY_ACTIVE_IMPORT_REGISTER
	if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
	{
		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
			{
				ShmOCPP16Data->StopTransaction[gun_index].MeterStop = ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargedEnergy;
				//Check Status
				if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_ALARM) // S_ALARM (Temporally for SuspendedEV )
				{
					strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, StopTransactionReasonStr[EVDisconnected]); //
				}

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

		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;

				//Check Status
				if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_ALARM) // S_ALARM (Temporally for SuspendedEV )
				{
					strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, StopTransactionReasonStr[EVDisconnected]); //
				}
				else
				{
					strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, StopTransactionReasonStr[Local]); //
				}

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

		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;

				//Check Status
				if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_ALARM) // S_ALARM (Temporally for SuspendedEV )
				{
					strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, StopTransactionReasonStr[EVDisconnected]); //
				}
				else
				{
					strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, StopTransactionReasonStr[Local]); //
				}

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

	}
	else
	{
		for (int index = 0; index < AC_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)
			{
				ShmOCPP16Data->StopTransaction[gun_index].MeterStop = ShmSysConfigAndInfo->SysInfo.AcChargingData[index].PresentChargedEnergy;
				//Check Status
				if(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_ALARM) // S_ALARM (Temporally for SuspendedEV )
				{
					strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].StopReason, StopTransactionReasonStr[EVDisconnected]); //
				}

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


	}//END OF ELSE

	//Stop Transaction 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:%SZ", tm);
#if 0 // remove temporally
	strftime(buf,30,"%Y-%m-%dT%H:%M:%S", tm);
	strcat(buf,".");
	sprintf(usec_buf,"%dZ",(int)tmnow.tv_usec);
	strcat(buf,usec_buf);
#endif
	printf("StopTransaction Time %s\n",buf);

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


	random_uuid(guid);
	sprintf(message,"[%d,\"%s\",\"StopTransaction\",{\"idTag\":\"%s\",\"meterStop\":%d,\"timestamp\":\"%s\",\"transactionId\":%d,\"reason\":\"%s\",\"transactionData\":"
				,MESSAGE_TYPE_CALL
				,guid
				,ShmOCPP16Data->StopTransaction[gun_index].IdTag
				,ShmOCPP16Data->StopTransaction[gun_index].MeterStop
				,ShmOCPP16Data->StopTransaction[gun_index].Timestamp
				,ShmOCPP16Data->StopTransaction[gun_index].TransactionId
				,ShmOCPP16Data->StopTransaction[gun_index].StopReason);

	/***********************************transactionData******************************************************/

	//ShmOCPP16Data->StopTransaction[gun_index].TransactionData  = (struct StructMeterValue *)malloc(sizeof(struct StructMeterValue));
	//ShmOCPP16Data->StopTransaction[gun_index].TransactionData[0].SampledValue = (struct StructSampledValue *)malloc(sizeof(struct StructSampledValue)*10);

	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((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].TimeStamp, buf/*"2019-05-04T18:15:33Z"*/);
		sprintf(message + strlen(message), "[{\"timestamp\":\"%s\",\"sampledValue\":[", (const char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].TimeStamp);

		//=================================
		// Transaction_Begin
		//=================================
		// Energy.Active.Export.Interval
		idx_sample=0;
		sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f",(float)(ShmOCPP16Data->StartTransaction[gun_index].MeterStart)*1000); // MeterStart is 0~6553.5 kWh
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,ReadingContextStr[ReadingContext_Transaction_Begin]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,ValueFormatStr[Raw]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,MeasurandStr[Energy_Active_Export_Interval/*Energy_Reactive_Export_Register*/]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,PhaseStr[L1_N]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,LocationStr[Location_Outlet]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit,UnitOfMeasureStr[UnitOfMeasure_Wh/*UnitOfMeasure_kWh*/]);

		sprintf(message + strlen(message), "{\"value\":\"%s\",\"context\":\"%s\",\"format\":\"%s\",\"measurand\":\"%s\",\"phase\":\"%s\",\"location\":\"%s\",\"unit\":\"%s\" }",
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit
				);


		//=================================
		// Transaction_End
		//=================================
		//Current.Export

		idx_sample=1;
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargingCurrent );// PresentChargingCurrent is 0~6553.5 amp
				}
			}

			for (int index = 0; index < CCS_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargingCurrent );// PresentChargingCurrent is 0~6553.5 amp
				}
			}

			for (int index = 0; index < GB_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargingCurrent );// PresentChargingCurrent is 0~6553.5 amp
				}
			}

		}
		else
		{
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.AcChargingData[index].PresentChargingCurrent );//  0~6553.5 amp for EVSE
				}
			}

		}// END FOR AC ELSE


		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,ReadingContextStr[ReadingContext_Transaction_End]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,ValueFormatStr[Raw]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,MeasurandStr[Current_Export/*Energy_Reactive_Export_Register*/]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,PhaseStr[L1_N]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,LocationStr[Location_Outlet]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit,UnitOfMeasureStr[UnitOfMeasure_A/*UnitOfMeasure_kWh*/]);
		sprintf(message + strlen(message), ",{\"value\":\"%s\",\"context\":\"%s\",\"format\":\"%s\",\"measurand\":\"%s\",\"phase\":\"%s\",\"location\":\"%s\",\"unit\":\"%s\" }",
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit
				);

		//Energy.Active.Export.Interval
		idx_sample=2;
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargedEnergy*1000 );// PresentChargedEnergy is 0~6553.5 kWh
				}
			}

			for (int index = 0; index < CCS_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargedEnergy*1000 );// PresentChargedEnergy is 0~6553.5 kWh
				}
			}

			for (int index = 0; index < GB_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargedEnergy*1000 );// PresentChargedEnergy is 0~6553.5 kWh
				}
			}

		}
		else
		{
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.AcChargingData[index].PresentChargedEnergy*1000 );// PresentChargedEnergy is 0~6553.5 kWh
				}
			}

		}// END FOR AC ELSE

		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,ReadingContextStr[ReadingContext_Transaction_End]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,ValueFormatStr[Raw]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,MeasurandStr[Energy_Active_Export_Interval/*Energy_Reactive_Export_Register*/]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,PhaseStr[L1_N]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,LocationStr[Location_Outlet]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit,UnitOfMeasureStr[UnitOfMeasure_Wh/*UnitOfMeasure_kWh*/]);
		sprintf(message + strlen(message), ",{\"value\":\"%s\",\"context\":\"%s\",\"format\":\"%s\",\"measurand\":\"%s\",\"phase\":\"%s\",\"location\":\"%s\",\"unit\":\"%s\" }",
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit
				);


		//Power.Active.Export
		idx_sample=3;
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargingPower );//  PresentChargingPower is 0~6553.5 kW
				}
			}

			for (int index = 0; index < CCS_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargingPower );// PresentChargingPower is 0~6553.5 kW
				}
			}

			for (int index = 0; index < GB_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargingPower );// PresentChargingPower is 0~6553.5 kW
				}
			}

		}
		else
		{
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.AcChargingData[index].PresentChargingPower );// PresentChargingPower is 0~6553.5 kW
				}
			}

		}// END FOR AC ELSE

		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,ReadingContextStr[ReadingContext_Transaction_End]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,ValueFormatStr[Raw]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,MeasurandStr[Power_Active_Export/*Energy_Reactive_Export_Register*/]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,PhaseStr[L1_N]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,LocationStr[Location_Outlet]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit,UnitOfMeasureStr[UnitOfMeasure_kW/*UnitOfMeasure_kWh*/]);
		sprintf(message + strlen(message), ",{\"value\":\"%s\",\"context\":\"%s\",\"format\":\"%s\",\"measurand\":\"%s\",\"phase\":\"%s\",\"location\":\"%s\",\"unit\":\"%s\" }",
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit
				);


		//Voltage
		idx_sample=4;
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargingVoltage );// PresentChargingVoltage is 0~6553.5 volt
				}
			}

			for (int index = 0; index < CCS_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargingVoltage );// PresentChargingVoltage is 0~6553.5 volt
				}
			}

			for (int index = 0; index < GB_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargingVoltage );// PresentChargingVoltage is 0~6553.5 volt
				}
			}

		}
		else
		{
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.AcChargingData[index].PresentChargingCurrent );//AcChargingVoltage is 0~6553.5 volt  for AC EVSE
				}
			}

		}// END FOR AC ELSE

		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,ReadingContextStr[ReadingContext_Transaction_End]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,ValueFormatStr[Raw]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,MeasurandStr[Power_Active_Export/*Energy_Reactive_Export_Register*/]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,PhaseStr[L1_N]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,LocationStr[Location_Outlet]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit,UnitOfMeasureStr[UnitOfMeasure_kW/*UnitOfMeasure_kWh*/]);
		sprintf(message + strlen(message), ",{\"value\":\"%s\",\"context\":\"%s\",\"format\":\"%s\",\"measurand\":\"%s\",\"phase\":\"%s\",\"location\":\"%s\",\"unit\":\"%s\" }",
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit
			);

		//SoC
		idx_sample=5;
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%d" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].EvBatterySoc );// 0~100%
				}
			}

			for (int index = 0; index < CCS_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%d" ,ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].EvBatterySoc );// 0~100%
				}
			}

			for (int index = 0; index < GB_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value, "%d" ,ShmSysConfigAndInfo->SysInfo.GbChargingData[index].EvBatterySoc );// 0~100%
				}
			}




		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,ReadingContextStr[ReadingContext_Transaction_End]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,ValueFormatStr[Raw]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,MeasurandStr[SoC/*Energy_Reactive_Export_Register*/]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,PhaseStr[L1_N]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,LocationStr[Location_Outlet]);
		strcpy((char *)ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit,UnitOfMeasureStr[UnitOfMeasure_Percent/*UnitOfMeasure_kWh*/]);
		sprintf(message + strlen(message), ",{\"value\":\"%s\",\"context\":\"%s\",\"format\":\"%s\",\"measurand\":\"%s\",\"phase\":\"%s\",\"location\":\"%s\",\"unit\":\"%s\" }",
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Value,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Context,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Format,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Measurand,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Phase,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Location,
				ShmOCPP16Data->StopTransaction[gun_index].TransactionData[idx_transaction].SampledValue[idx_sample].Unit
				);

		} // END FOR DC CASE

		sprintf(message + strlen(message)," ] } ] } ]");

		//free(ShmOCPP16Data->StopTransaction[gun_index].TransactionData[0].SampledValue);
		//free(ShmOCPP16Data->StopTransaction[gun_index].TransactionData);
	}

	LWS_Send(message);

	sprintf(tempdata, "StopTransaction,%d", (gun_index));
	if(hashmap_operation(0, guid, tempdata) == 1)
	{
		result = PASS;
		DEBUG_INFO("StopTransaction mapitem pass\n");
	}

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

	//#ifdef SystemLogMessage
	//DEBUG_INFO(">>>>>StopTransaction request\n");
	//DEBUG_INFO("Message: %s\n", SendBuffer);
	//#endif

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

	return result;
}

int sendMeterValuesRequest(int gun_index)
{
	mtrace();
	int result = FAIL;
	char message[1500]={0};
	char guid[37]={0};
	int idx_sample=0;
	//int length = 0;
	char tempdata[65]={0};

	DEBUG_ERROR("sendMeterValuesRequest ...\n");
	DEBUG_ERROR("gun_index =%d\n",gun_index);

	if((ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId == 0)&&(ShmOCPP16Data->CsMsg.bits[gun_index].TriggerMessageReq == 0)) // no TransactionId
	{
		DEBUG_INFO("NOT SENT METER Vlaue\n");
		DEBUG_ERROR("ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId =%d\n",ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId);
		DEBUG_ERROR("ShmOCPP16Data->CsMsg.bits[gun_index].TriggerMessageReq =%d\n",ShmOCPP16Data->CsMsg.bits[gun_index].TriggerMessageReq);

		return result;
	}


	if(ShmOCPP16Data->CsMsg.bits[gun_index].TriggerMessageReq == 1)
	{
		ShmOCPP16Data->CsMsg.bits[gun_index].TriggerMessageReq = 0;
	}

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

	random_uuid(guid);
	sprintf(message,"[%d,\"%s\",\"MeterValues\",{\"connectorId\":%d,\"transactionId\":%d,\"meterValue\":"
			,MESSAGE_TYPE_CALL
			,guid
			,ShmOCPP16Data->MeterValues[gun_index].ConnectorId
			,ShmOCPP16Data->MeterValues[gun_index].TransactionId);
			//,comfirmpayload);


	for(int idx_transaction=0;idx_transaction<1;idx_transaction++)
	{
		//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:%SZ", tm);
#if 0 // remove temporally
		strftime(buf,30,"%Y-%m-%dT%H:%M:%S", tm);
		strcat(buf,".");
		sprintf(usec_buf,"%dZ",(int)tmnow.tv_usec);
		strcat(buf,usec_buf);
#endif
	//	printf("%s",buf);

		strcpy((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].TimeStamp, buf);

		//allocate memory space
		//ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue = (struct StructSampledValue *)malloc(sizeof(struct StructSampledValue)*6);
		sprintf(message + strlen(message),"[{\"timestamp\":\"%s\",\"sampledValue\":[",(const char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].TimeStamp);

		idx_sample=0;
		//********************************(1)Current.Export************************************************/
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargingCurrent );
				}
			}

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

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

		}
		else
		{
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.AcChargingData[index].PresentChargingCurrent );
				}
			}

		}// END FOR AC ELSE

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

		sprintf(message + strlen(message),"{\"value\":\"%s\",\"context\":\"%s\",\"format\":\"%s\",\"measurand\":\"%s\",\"phase\":\"%s\",\"location\":\"%s\",\"unit\":\"%s\"},",
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit
		);

#if 0
		idx_sample=1;
		//****************************************************(2)Energy.Active.Export.Register*********************************************/
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargedEnergy );
				}
			}

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

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

		}
		else
		{
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.AcChargingData[index].PresentChargedEnergy );
				}
			}

		}// END FOR AC ELSE


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

		sprintf(message + strlen(message),"{\"value\":\"%s\",\"context\":\"%s\",\"format\":\"%s\",\"measurand\":\"%s\",\"phase\":\"%s\",\"location\":\"%s\",\"unit\":\"%s\"},",
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit
		);
#endif

    	idx_sample=1;
    	//****************************************************(3)Energy.Active.Export.Interval*********************************************/
    	if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
    	{
    		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
    	    {
    			if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
    	    	{
    	      		sprintf((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,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)
    	    	{
    	    		//ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargedEnergy = 100.0;
    	    		sprintf((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].PresentChargedEnergy );
    	    	}
    	    }

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

    	}//END FOR AC ELSE


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

    	sprintf(message + strlen(message),"{\"value\":\"%s\",\"context\":\"%s\",\"format\":\"%s\",\"measurand\":\"%s\",\"phase\":\"%s\",\"location\":\"%s\",\"unit\":\"%s\"},",
    			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value,
    			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context,
    			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format,
    			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand,
    			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase,
    			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location,
    			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit
    	);

    	idx_sample=2;
		//********************************(4)Power.Active.Export************************************************/
    	if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
    	{
    		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
    		{
    			if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
    			{
    				sprintf((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%.1f" , ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargingPower);
    			}
    		}

    		for (int index = 0; index < CCS_QUANTITY; index++)
    		{
    			if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == gun_index)
    			{
    				sprintf((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%.1f" , 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((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%.1f" , ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargingPower);
    			}
    		}
    	}
    	else
    	{
    		for (int index = 0; index < AC_QUANTITY; index++)
    		{
    		   if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)
    		   {
    			   sprintf((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%.1f" , ShmSysConfigAndInfo->SysInfo.AcChargingData[index].PresentChargingPower);
    		   }
    		}

    	}// END FOR AC ELSE


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

		sprintf(message + strlen(message),"{\"value\":\"%s\",\"context\":\"%s\",\"format\":\"%s\",\"measurand\":\"%s\",\"phase\":\"%s\",\"location\":\"%s\",\"unit\":\"%s\"},",
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit
		);

		idx_sample=3;
		//***********************************************(5)VOLTAGE******************************************************/
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].PresentChargingVoltage );
				}
			}

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

			for (int index = 0; index < GB_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.GbChargingData[index].PresentChargingVoltage );
				}
			}
		}
		else
		{
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%.1f" ,ShmSysConfigAndInfo->SysInfo.AcChargingData[index].PresentChargingVoltage );
				}
			}
		}//END FOR AC ELSE


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

		sprintf(message + strlen(message),"{\"value\":\"%s\",\"context\":\"%s\",\"format\":\"%s\",\"measurand\":\"%s\",\"phase\":\"%s\",\"location\":\"%s\",\"unit\":\"%s\"}",
			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value,
			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context,
			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format,
			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand,
			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase,
			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location,
			ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit
		);

		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			idx_sample=4;
			//sampledValue = NULL;
			//***********************************************(6)SOC******************************************************/
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
				{
					sprintf((char *)ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value, "%d" ,ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].EvBatterySoc );
				}
			}

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

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


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


			sprintf(message + strlen(message),",{\"value\":\"%s\",\"context\":\"%s\",\"format\":\"%s\",\"measurand\":\"%s\",\"phase\":\"%s\",\"location\":\"%s\",\"unit\":\"%s\"}",
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Value,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Context,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Format,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Measurand,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Phase,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Location,
				ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue[idx_sample].Unit
			);

		}

		//}

		sprintf(message + strlen(message)," ] } ] } ]");

		//free(ShmOCPP16Data->MeterValues[gun_index].MeterValue[idx_transaction].SampledValue);
	}

	LWS_Send(message);

	//memset(mapItem, 0, sizeof(data_struct_t));

	// Put request guid to hash map
	sprintf(tempdata, "MeterValues,%d", (gun_index));
	if(hashmap_operation(0, guid, tempdata) == 1)//if(hashmap_operation(0,NULL/*hashMap*/, mapItem[0].key_string, mapItem[0].key_value/*mapItem*/, (void**)(&mapItem)/*(void**)(&mapItem)*/) ==  MAP_OK/*hashmap_put(hashMap, mapItem->key_string, mapItem) == MAP_OK*/)
	{
		result = PASS;
		DEBUG_INFO("MeterValues mapitem pass\n");
	}


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

	//#ifdef SystemLogMessage
	//DEBUG_INFO(">>>>>MeerValues request\n");
	//DEBUG_INFO("Message: %s\n", SendBuffer);
	//#endif

	return result;

}


//==========================================
// send confirm routine
//==========================================
int sendCancelReservationConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
	char message[100]={0};

	DEBUG_ERROR("handle sendCancelReservationConfirmation\n");
	sprintf(message,"[%d,\"%s\",{\"status\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT,uuid, payload);
	LWS_Send(message);
	result = TRUE;
	ShmOCPP16Data->CsMsg.bits[0].CancelReservationConf = 0;
	return result;
}

int sendChangeAvailabilityConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
	char message[100]={0};
	DEBUG_ERROR("handle sendChangeAvailabilityConfirmation\n");
	sprintf(message,"[%d,\"%s\",{\"status\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT,uuid, payload);
	LWS_Send(message);
	result = TRUE;

	return result;
}

int sendChangeConfigurationConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
	char message[100]={0};

	DEBUG_ERROR("handle sendChangeConfigurationConfirmation\n");
	sprintf(message,"[%d,\"%s\",{\"status\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT,uuid, payload);
	LWS_Send(message);
	result = TRUE;

	return result;
}

int sendClearCacheConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
    char message[500]={0};
	//	int count = 0;
	//	int gun_index = 0;
	//	char guid[37];
	//	[ 3, "1570592744204", { "status": "Accepted" } ]
    DEBUG_ERROR("sendClearCacheConfirmation\n");
    sprintf(message,"[ %d,\"%s\",{\"%s\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT, uuid, "status", payload);
	LWS_Send(message);

	return result;
}

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

	char message[500]={0};
//	[ 3, "1571284268200", { "status": "Unknown" } ]
	DEBUG_ERROR("sendClearChargingProfileConfirmation\n");
	sprintf(message,"[ %d,\"%s\",{\"%s\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT, uuid, "status", payload);
	LWS_Send(message);

	return result;
}

int sendDataTransferConfirmation(char *uuid,char *payload)
{
	mtrace();
	char statusStr[20]={0};
	char dataStr[10]={0};
	char sstr[20]={0};
	int c = 0;
	char *loc;
	int result = FAIL;

// [3,"792bc950-b279-49e3-ab8f-429e02a2f9a7",{"status":"Accepted","data":"True"}]

	DEBUG_ERROR("sendDataTransferConfirmation ...\n");
	/**********************status**************************/
    loc = strstr(payload, "status");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while (loc[3+strlen("status")+c] != '\"')
	{
		sstr[c] = loc[3+strlen("status")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(statusStr, sstr);


	/**********************data**************************/
	loc = strstr(payload, "data");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while (loc[3+strlen("data")+c] != '\"')
	{
		sstr[c] = loc[3+strlen("data")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(dataStr, sstr);

	return result;
}

int sendGetCompositeScheduleConfirmation(char *uuid,char *payload, int connectorIdInt,int nPeriod)
{
	mtrace();
	int result = FAIL;
	char message[1000]={0};
	double diff_f = 0.0;
	int diff_i = 0;
	struct tm tp;
	int TimeZero = FALSE;
	int CompositeScheduleIndex = 0;

	DEBUG_INFO("handle sendGetCompositeScheduleConfirmation ...\n");


    if(connectorIdInt > 0)
    {
    	if((ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingSchedule.StartSchedule == NULL)||(strcmp((const char *)ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingSchedule.StartSchedule,"")==0))
    	{
    		TimeZero = TRUE;
    	}
    	else
    	{
    		strptime((const char *)ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingSchedule.StartSchedule, "%Y-%m-%dT%H:%M:%S", &tp);
    	}

    }
    else
    {
    	if((ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingSchedule.StartSchedule == NULL)||(strcmp((const char *)ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingSchedule.StartSchedule,"")==0))
    	{
    	   TimeZero = TRUE;
    	}
    	else
    	{
    		strptime((const char *)ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ChargingSchedule.StartSchedule, "%Y-%m-%dT%H:%M:%S", &tp);
    	}
    }

  	DEBUG_INFO("ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ChargingSchedule.StartSchedule=%s\n",ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ChargingSchedule.StartSchedule);

  	if(TimeZero == FALSE)
  	{
  		tp.tm_isdst = -1;
  		time_t utc = mktime(&tp);
  		time_t t = time(NULL);
  		diff_f = difftime(t, utc);
  		diff_i = (int)diff_f;
  	}

  	DEBUG_INFO("\n diff_f=%f \n",diff_f);

  	CompositeScheduleIndex = (connectorIdInt > 0) ?(connectorIdInt -1) : 0;

#if 0 //remove temporally
	sprintf(message,"[%d,\"%s\",{\"status\":\"%s\",\"connectorId\":%d,\"scheduleStart\":\"%s\",\"chargingSchedule\":{\"duration\":%d,\"startSchedule\":\"%s\",\"chargingRateUnit\":\"%s\",\"chargingSchedulePeriod\":[{\"startPeriod\":0,\"limit\":6.0,\"numberPhases\":3},{\"startPeriod\":40,\"limit\":10.0,\"numberPhases\":3},{\"startPeriod\":100,\"limit\":8.0,\"numberPhases\":3}"
				,MESSAGE_TYPE_CALLRESULT
				,uuid
				,payload
				,connectorIdInt
				,ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.StartSchedule
				,ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.Duration
				,ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.StartSchedule
				,ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingRateUnit);
#endif

	if(nPeriod == 0)
	{
		sprintf(message,"[%d,\"%s\",{\"status\":\"%s\",\"connectorId\":%d,\"scheduleStart\":\"%s\"}]"
									,MESSAGE_TYPE_CALLRESULT
									,uuid
									,payload
									,connectorIdInt
									,ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.StartSchedule);
	}
	else
	{
		sprintf(message,"[%d,\"%s\",{\"status\":\"%s\",\"connectorId\":%d,\"scheduleStart\":\"%s\",\"chargingSchedule\":{\"duration\":%d,\"startSchedule\":\"%s\",\"chargingRateUnit\":\"%s\",\"chargingSchedulePeriod\":["
							,MESSAGE_TYPE_CALLRESULT
							,uuid
							,payload
							,connectorIdInt
							,ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.StartSchedule
							,ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.Duration
							,ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.StartSchedule
							,ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.ChargingRateUnit);


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


		#if 1 // remove temporally
			int len = nPeriod;//sizeof(ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod)/sizeof(ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[0]);

			if(ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[len -1].StartPeriod < diff_i)
			{

				sprintf(message + strlen(message), "{\"startPeriod\":%d,\"limit\":%.1f,\"numberPhases\":%d}"
								, 0
								, ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[len -1].Limit
								, ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[len -1].NumberPhases );
			}
			else
			{

				for(int idx_sample=0;idx_sample< len;idx_sample++)
				{

					if (idx_sample == 0)
					{
						sprintf(message + strlen(message), "{\"startPeriod\":%d,\"limit\":%.1f,\"numberPhases\":%d}"
								, ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[idx_sample].StartPeriod
								, ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[idx_sample].Limit
								, ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[idx_sample].NumberPhases );
					}
					else
					{
						sprintf(message + strlen(message), ",{\"startPeriod\":%d,\"limit\":%.1f,\"numberPhases\":%d}"
								, (((ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[idx_sample].StartPeriod - diff_i /*-1*/) <= 0)?(ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[idx_sample].StartPeriod):(ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[idx_sample].StartPeriod - diff_i /*-1*/))
								, ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[idx_sample].Limit
								, ShmOCPP16Data->GetCompositeSchedule[CompositeScheduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[idx_sample].NumberPhases );
					}

				}
			}


		#endif


		sprintf(message + strlen(message), "]}}]");


	}

	LWS_Send(message);

	result = TRUE;
	return result;
}

int sendGetConfigurationConfirmation(char *uuid)
{
	mtrace();
	int result = FAIL;
	int MaxKeySupported = 0;
	int sentConfigurationNumber= 0;
	int sentunConfigurationNumber= 0;
	char message[4000]={0};

	DEBUG_ERROR("handle sendGetConfigurationConfirmation ...\n");

	MaxKeySupported = atoi((const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[GetConfigurationMaxKeys].ItemData);

	sprintf(message,"[%d,\"%s\",{\"configurationKey\":[ "
			,MESSAGE_TYPE_CALLRESULT
			,uuid );

	 //configuration key
	for(int idx_sample=0;idx_sample< MaxKeySupported/*43*/;idx_sample++)
	{
		if(strcmp((const char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].Key, "")!= 0)
		{
			if (sentConfigurationNumber == 0)
			{
				sprintf(message + strlen(message), "{\"key\":\"%s\",\"readonly\": %s,\"value\":\"%s\"}"
						, ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].Key
						, atoi((const char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].ReadOnly) == 1 ? "true":"false"
						, ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].Value );
			}
			else
			{
				sprintf(message + strlen(message), ", {\"key\":\"%s\",\"readonly\":%s,\"value\":\"%s\"}"
						, ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].Key
						, atoi((const char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].ReadOnly) == 1 ? "true":"false"
						, ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[idx_sample].Value );
			}

			sentConfigurationNumber = sentConfigurationNumber + 1;
		}

	}


	sprintf(message + strlen(message), "]");


	if(UnknownKeynum != 0)
	{
		sprintf(message + strlen(message), ",\"unknownKey\":[");
		//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));

			DEBUG_INFO("unkown key:%s\n", ShmOCPP16Data->GetConfiguration.ResponseUnknownKey[idx_sample].Item);

			if(sentunConfigurationNumber == 0)
			{
				sprintf(message + strlen(message), "\"%s\""
						, ShmOCPP16Data->GetConfiguration.ResponseUnknownKey[idx_sample].Item );
			}
			else
			{
				sprintf(message + strlen(message), ",\"%s\""
						, ShmOCPP16Data->GetConfiguration.ResponseUnknownKey[idx_sample].Item );
			}
			sentunConfigurationNumber = sentunConfigurationNumber + 1;

		}

		sprintf(message + strlen(message), "]");

	}

	sprintf(message + strlen(message), "} ]");

	LWS_Send(message);

#if 0
	printf("error 1-0\n");
	if(ShmOCPP16Data->GetConfiguration.ResponseUnknownKey != NULL)
		free(ShmOCPP16Data->GetConfiguration.ResponseUnknownKey);
#endif
	return result;
}

int sendGetDiagnosticsConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
	char message[400]={0};

	DEBUG_ERROR("handle sendGetDiagnosticsConfirmation ...\n");

	if(strcmp(payload,"")==0)
	{
		sprintf(message,"[%d,\"%s\",{}]",MESSAGE_TYPE_CALLRESULT, uuid);
	}
	else
	{
		sprintf(message,"[%d,\"%s\",{\"%s\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT, uuid, "fileName", payload);
	}

	LWS_Send(message);

	result = TRUE;

	return result;
}

int sendGetLocalListVersionConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
	char message[80]={0};

//[ 3, "4f0141fb-f3a0-4634-9179-b1379b514d3c", { "listVersion": 1 } ]
	DEBUG_ERROR("handle    GetLocalListVersionRequest ...\n");
	sprintf(message,"[%d,\"%s\",{\"listVersion\":%d}]",MESSAGE_TYPE_CALLRESULT, uuid, ShmOCPP16Data->GetLocalListVersion.ResponseListVersion);
	LWS_Send(message);
	result = TRUE;

	return result;
}

int sendRemoteStartConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
	char message[80]={0};
//[3,"26f6b7bc-a6e8-48a8-bdc5-a541bf8f9e27",{"status":"Accepted"}]
	DEBUG_ERROR("handleRemoteStartRequest ...\n");
	sprintf(message,"[%d,\"%s\",{\"status\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT, uuid, payload);
	LWS_Send(message);
	result = TRUE;

	return result;
}

int sendRemoteStopTransactionConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
	char message[80]={0};
//	[3,"287d837d-809e-41ea-8385-fdab7f72a01c",{"status":"Accepted"}]
	DEBUG_ERROR("sendRemoteStopTransactionConfirmation ...\n");
	sprintf(message,"[%d,\"%s\",{\"status\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT, uuid, payload);
	LWS_Send(message);
	result = TRUE;

	return result;
}

int sendReserveNowTransactionConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
	char message[80]={0};
//	[3,"287d837d-809e-41ea-8385-fdab7f72a01c",{"status":"Accepted"}]

	DEBUG_ERROR("sendReserveNowTransactionConfirmation\n");
	sprintf(message,"[%d,\"%s\",{\"status\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT, uuid, payload);
	LWS_Send(message);
	result = TRUE;

	return result;
}

int sendResetConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
	//[ 3, "6f88d461-4d17-462c-a69b-1f7a8c5b12df", { "status": 0 } ]
	char message[80]={0};

	ShmOCPP16Data->MsMsg.bits.ResetConf = 0;

	sprintf(message,"[%d,\"%s\",{\"status\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT, uuid, payload);
	LWS_Send(message);
	result = TRUE;

	return result;
}

int sendSendLocalListConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
	char message[500]={0};
//	[ 3, "1571284266109", { "status": "Accepted" } ]
	sprintf(message,"[%d,\"%s\",{\"%s\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT, uuid, "status", payload);
	LWS_Send(message);
	result = TRUE;

	return result;
}

int sendSetChargingProfileConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
//[3,"5748585f-8524-4fa6-9b4f-4a7eca750b90",{"status":"NotSupported"}]
	char message[80]={0};

	DEBUG_ERROR("handleSetChargingProfileRequest\n");
	sprintf(message,"[%d,\"%s\",{\"status\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT, uuid, payload);
	LWS_Send(message);
	result = TRUE;

	return result;
}

int sendTriggerMessageConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
	char message[80]={0};

	DEBUG_ERROR("sendTriggerMessageConfirmation\n");
	sprintf(message,"[%d,\"%s\",{\"status\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT, uuid, payload);
	LWS_Send(message);
	result = TRUE;

	return result;
}

int sendUnlockConnectorConfirmation(char *uuid,char *payload)
{
	mtrace();
	int result = FAIL;
	char message[80]={0};

//[ 3, "ba1cbd49-2a76-493a-8f76-fa23e7606532", { "status": "Unlocked" } ]
	DEBUG_ERROR("sendUnlockConnectorConfirmation\n");
	sprintf(message,"[%d,\"%s\",{\"status\":\"%s\"}]",MESSAGE_TYPE_CALLRESULT, uuid, payload);
	LWS_Send(message);
	result = TRUE;

	return result;
}

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

	char message[60]={0};

	//[ 3, "ba1cbd49-2a76-493a-8f76-fa23e7606532", { "status": "Unlocked" } ]
	DEBUG_ERROR("sendUpdateFirmwareConfirmation\n");
	sprintf(message,"[%d,\"%s\",{}]",MESSAGE_TYPE_CALLRESULT, uuid);
	LWS_Send(message);
	result = TRUE;

	return result;
}


//==========================================
// send CallError routine
//==========================================
void SendCallError(char *uniqueId, char *action, char *errorCode, char *errorDescription)
{
	mtrace();
	//int result = FAIL;

	char message[220]={0};
// [4,"f1c52ff5-e65d-4070-b7d4-6c70bc1e8970","PropertyConstraintViolation","Payload is syntactically correct but at least one field contains an invalid value",{}]

#ifdef SystemLogMessage
	DEBUG_INFO("An error occurred. Sending this information: uniqueId {}: action: {}, errorCore: {}, errorDescription: {}\n",
            uniqueId, action, errorCode, errorDescription);
#endif
	sprintf(message,"[%d,\"%s\",\"%s\",\"%s\",{}]",MESSAGE_TYPE_CALLERROR, uniqueId, errorCode, errorDescription);
	LWS_Send(message);
	//result = TRUE;
}


//==========================================
// Handle server request routine  Start
//==========================================
#define GUN_NUM     1
int handleCancelReservationRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
    int gunNO = 0;
	int reservationIdInt =0;
	char comfirmstr[20];

	int c = 0;
    char *loc;
    char sstr[100]={0};

    DEBUG_INFO("handle CancelReservationRequest\n");

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

	c = 0;
	loc = strstr(payload, "reservationId");
	memset(sstr ,0, sizeof(sstr) );
	while (loc[strlen("reservationId")+2+c] != '}')
	{
		sstr[c] = loc[strlen("reservationId")+2+c];
		//printf("i=%d sstr=%c\n",c, sstr[c]);
		c++;
	}
	sstr[c] = '\0';
	reservationIdInt = atoi(sstr);


	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
	 if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
	 {
		 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;
				goto end;
			}
		 }



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


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


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

	 }// END FOR AC ELSE

	  //The reservationId does NOT match the reservationId
	  sendCancelReservationConfirmation(uuid, comfirmstr);

end:
	  // Fill in ocpp packet uuid
	  strcpy((char *)ShmOCPP16Data->CancelReservation[gunNO].guid, uuid);

	return result;
}

int handleChangeAvailabilityRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
    int gunIndex = 0;
	char sstr[90]={0};
	char typeStr[16]={0};
	char comfirmstr[20];
	int specificId = FALSE;

	DEBUG_ERROR("handle ChangeAvailabilityRequest\n");

	char *loc;
	//int intervalInt = 0;
	int c = 0;

	/*** connectorId ****/
	c = 0;
	loc = strstr(payload, "connectorId");
	memset(sstr ,0, sizeof(sstr) );
	while ((loc != NULL) &&(loc[strlen("connectorId")+2+c] != ',') &&(loc[strlen("connectorId")+2+c] != '}')  )
	{
		sstr[c] = loc[strlen("connectorId")+2+c];
		c++;
	}
	sstr[c] = '\0';
	gunIndex = atoi(sstr);


    /***type ****/
    loc = strstr(payload, "type");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while ((loc != NULL) &&(loc[3+strlen("type")+c] != '\"'))
	{
		sstr[c] = loc[3+strlen("type")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(typeStr, sstr);


	if(gunIndex != 0)
	{
		ShmOCPP16Data->ChangeAvailability[gunIndex - 1].ConnectorId= gunIndex;
		sprintf((char *)ShmOCPP16Data->ChangeAvailability[gunIndex - 1].Type, "%s", typeStr);
	}
	else
	{
		ShmOCPP16Data->ChangeAvailability[0].ConnectorId= gunIndex;
		sprintf((char *)ShmOCPP16Data->ChangeAvailability[0].Type, "%s", typeStr);
	}


	memset(comfirmstr, 0, sizeof comfirmstr);
	sprintf(comfirmstr, "%s", AvailabilityStatusStr[Rejected] );


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

	if(specificId == FALSE)
		goto end;

	if(gunIndex != 0)
	{
		ShmOCPP16Data->CsMsg.bits[gunIndex - 1].ChangeAvailabilityReq = 1;
	}
	else
	{
		for(int i=0; i < gunTotalNumber/*(CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY)*/; i++)
			ShmOCPP16Data->CsMsg.bits[i].ChangeAvailabilityReq = 1;
	}
	/*
	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 *)typeStr, AvailabilityTypeStr[Inoperative]) == 0)
	{
	    //check Transaction active
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if ((gunIndex  == 0) || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == (gunIndex - 1)))
				{
					if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_PREPARING) // S_PRECHARGE
				    {
				    	sprintf(comfirmstr, "%s", AvailabilityStatusStr[Rejected] );
				    }
				    else if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_CHARGING)  // S_CHARGING
				    {
				    	sprintf(comfirmstr, "%s", AvailabilityStatusStr[Scheduled] );
				    }
				    else
				    {
				    	sprintf(comfirmstr, "%s", AvailabilityStatusStr[Accepted] );
				    }

				    goto end;
				}
			}//END FOR CHAdeMO_QUANTITY

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

				    goto end;
				 }
			}//END FOR CCS_QUANTITY

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

				    goto end;
				 }
			}// END FOR GB_QUANTITY
		}
		else
		{
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if ((gunIndex  == 0) || (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == (gunIndex - 1)))
				{
					if(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_PREPARING) // S_PRECHARGE
					{
						sprintf(comfirmstr, "%s", AvailabilityStatusStr[Rejected] );
					}
					else if(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_CHARGING)  // S_CHARGING
					{
						sprintf(comfirmstr, "%s", AvailabilityStatusStr[Scheduled] );
					}
					else
					{
						sprintf(comfirmstr, "%s", AvailabilityStatusStr[Accepted] );
					}

					goto end;
				}
			}//END FOR AC_QUANTITY
		}// END FOR AC ELSE
	}//END FOR AvailabilityTypeStr[Inoperative]


	if(strcmp((const char *)typeStr, 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

		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (((gunIndex  == 0)|| (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == (gunIndex - 1))) &&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus != SYS_MODE_FAULT))  //S_FAULT
				{
				   sprintf(comfirmstr, "%s", AvailabilityStatusStr[Accepted] );
				   goto end;
				}
			}//END FOR CHAdeMO_QUANTITY

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

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

				    //sprintf(comfirmstr, "%s", AvailabilityStatusStr[Rejected] );
		}
		else
		{
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if (((gunIndex  == 0)|| (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == (gunIndex - 1))) &&(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus != SYS_MODE_FAULT))  //S_FAULT
				{
					sprintf(comfirmstr, "%s", AvailabilityStatusStr[Accepted] );
					goto end;
				}
			}//END FOR CHAdeMO_QUANTITY
		}//END FOR AC ELSE
	}//END FOR AvailabilityTypeStr[Operative]

	end:

	if(gunIndex != 0)
	{
		sprintf((char *)ShmOCPP16Data->ChangeAvailability[gunIndex - 1].ResponseStatus, "%s", comfirmstr );
	}
	else
	{
		sprintf((char *)ShmOCPP16Data->ChangeAvailability[0].ResponseStatus, "%s", comfirmstr );
	}

	sendChangeAvailabilityConfirmation(uuid, comfirmstr);

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

	return result;
}

int handleChangeConfigurationRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
	char sstr[100]={0};
	char keystr[40]={0};
	char valuestr[16]={0};
	char *loc;
	int c = 0;
	char comfirmstr[20];

	DEBUG_ERROR("handle ChangeConfigurationRequest\n");

	/***key ****/
	loc = strstr(payload, "key");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while ((loc != NULL) &&(loc[3+strlen("key")+c] != '\"'))
	{
		sstr[c] = loc[3+strlen("key")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(keystr, sstr);

	/***value ****/
	loc = strstr(payload, "value");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while ((loc != NULL) &&(loc[3+strlen("value")+c] != '\"'))
	{
		sstr[c] = loc[3+strlen("value")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(valuestr, sstr);

    if((uuid==NULL) || (payload ==NULL) )
    {
#ifdef Debug
			DEBUG_INFO("payload is null\n");
#endif
		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;
    	}
    }


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


	return result;
}

int handleClearCacheRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
	char comfirmstr[20];
	int fd;
    char rmFileCmd[100]={0};
    struct stat stats;
    DEBUG_ERROR("handle  ClearCacheRequest\n");
    stat("../Storage/OCPP", &stats);

    // Check for directory existence
    if (S_ISDIR(stats.st_mode) == 1)
    {
    	//DEBUG_ERROR("\n OCPP directory exist \n");
    }
    else
    {
    	DEBUG_ERROR("\n OCPP directory not exist, create dir \n");
    	sprintf(rmFileCmd,"mkdir -p %s","../Storage/OCPP");
    	system(rmFileCmd);
    }

    memset(&rmFileCmd, 0, sizeof rmFileCmd);

    if((access(AuthorizationCache_JSON,F_OK))!=-1)
    {
    	DEBUG_ERROR("AuthorizationCache file exist.\n");
    }
    else
    {
    	DEBUG_ERROR("AuthorizationCache file not exist\n");
    	FILE *log = fopen(AuthorizationCache_JSON, "w+");

    	if(log == NULL)
    	{
    		DEBUG_ERROR("AuthorizationCache file is NULL\n");
    		sprintf(comfirmstr, "%s", ClearCacheStatusStr[ClearCacheStatus_Rejected] );
    		goto end;
    	}
    	else
    	{
    		fclose(log);
    	}
    }


    fd = open(AuthorizationCache_JSON,O_RDWR);
    if(fd < 0)
    {
    	DEBUG_ERROR("open AuthorizationCache file failed\n");
        sprintf(comfirmstr, "%s", ClearCacheStatusStr[ClearCacheStatus_Rejected] );
    }
    else
    {
    	DEBUG_ERROR("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
    }

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

int handleClearChargingProfileRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
	int resultRename;
	int connectorIdInt, chargingProfileIdInt, stackLevelInt;
	char chargingProfilePurposeStr[26]={0};
	int tempconnectorIdInt, tempchargingProfileIdInt, tempstackLevelInt;
	char tempchargingProfilePurposeStr[26]={0};
	char sstr[160]={0};//sstr[200]={ 0 };
	char str[100]={0};
	int c = 0;
	//int i = 0;
	//char * pch;
	char *loc;
	char fname[200];
	char comfirmstr[20]={0};
	char word[1000]={0};
	int clearflag = FALSE;
	int chargingProfileIdIsNULL = FALSE;
	int connectorIsNULL = FALSE;
	int chargingProfilePurposeIsNULL = FALSE;
	int stackLevelIsNULL = FALSE;
	FILE *fptr1, *fptr2;
	char temp[] = "../Storage/OCPP/ClearChargingProfiletemp.json";
    int n_chargingProfile=0;
    char sLineWord[1060]={0};

    DEBUG_ERROR("handle  ClearChargingProfileRequest\n");

	connectorIdInt= chargingProfileIdInt= stackLevelInt =0;
	//***id ****/
	c = 0;
	loc = strstr(payload, "id");
	memset(sstr ,0, sizeof(sstr) );
	if(loc == NULL)
	{
		chargingProfileIdIsNULL = TRUE;
	}
	else
	{
		while ((loc != NULL) &&((loc[strlen("id")+2+c] != ',')&& (loc[strlen("id")+2+c] != '}')))
		{
			sstr[c] = loc[strlen("id")+2+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		chargingProfileIdInt = atoi(sstr);
	}

	//***connectorId ****/
	c=0;
	loc = strstr(payload, "connectorId");
	memset(sstr ,0, sizeof(sstr) );

	if(loc == NULL)
	{
		connectorIsNULL = TRUE;
	}
	else
	{
		while ((loc != NULL) &&((loc[strlen("connectorId")+2+c] != ',')&&(loc[strlen("connectorId")+2+c] != '}')))
		{
			sstr[c] = loc[strlen("connectorId")+2+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}

		sstr[c] = '\0';
		connectorIdInt = atoi(sstr);
	}

    //***chargingProfilePurpose ****/
    loc = strstr(payload, "chargingProfilePurpose");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;

	if(loc == NULL)
	{
		chargingProfilePurposeIsNULL = TRUE;
	}
	else
	{
		while ((loc != NULL) &&(loc[3+strlen("chargingProfilePurpose")+c] != '\"'))
		{
			sstr[c] = loc[3+strlen("chargingProfilePurpose")+c];
			c++;
		}
		sstr[c] = '\0';
		strcpy(chargingProfilePurposeStr, sstr);
	}

	//***stackLevel ****/
	c=0;
	loc = strstr(payload, "stackLevel");
	memset(sstr ,0, sizeof(sstr) );

	if(loc == NULL)
	{
		stackLevelIsNULL = TRUE;
	}
	else
	{
		while ((loc != NULL) &&((loc[strlen("stackLevel")+2+c] != '}') && (loc[strlen("stackLevel")+2+c] != ',')))
		{
			sstr[c] = loc[strlen("stackLevel")+2+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		stackLevelInt = atoi(sstr);
	}

	if(connectorIsNULL == FALSE)
	{
		switch(connectorIdInt)
		{
			case 0:

				if((chargingProfilePurposeIsNULL == TRUE)||((chargingProfilePurposeIsNULL == FALSE)&&(strcmp(chargingProfilePurposeStr,"ChargePointMaxProfile")==0)))
				{
					strcpy(fname, ChargePointMaxProfile_JSON);
				}
		//		else
		//		{
		//			strcpy(fname, TxDefaultProfile_0_JSON);
		//		}

				break;

			case 1:
				if((chargingProfilePurposeIsNULL == TRUE)||((chargingProfilePurposeIsNULL == FALSE)&&(strcmp(chargingProfilePurposeStr,"TxDefaultProfile")==0)))
				{
					strcpy(fname, TxDefaultProfile_1_JSON);
				}
		//		else
		//		{
		//			strcpy(fname, TxProfile_1_JSON);
		//		}
				break;

			case 2:
				if((chargingProfilePurposeIsNULL == TRUE)||((chargingProfilePurposeIsNULL == FALSE)&&(strcmp(chargingProfilePurposeStr,"TxDefaultProfile")==0)))
				{
					strcpy(fname, TxDefaultProfile_2_JSON);
				}
		//		else
		//		{
		//			strcpy(fname, TxProfile_2_JSON);
		//		}
				break;

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

	}
	else
	{
		strcpy(fname, ChargePointMaxProfile_JSON );

	}

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

	}
	fclose(fptr1);

	if(connectorIsNULL == FALSE && (connectorIdInt != 0) && ( (connectorIdInt-1) > gunTotalNumber/*(CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY)*/ ) )
	{
		sprintf(comfirmstr, "%s", ClearChargingProfileStatusStr[ClearChargingProfileStatus_Unknown] );
		goto end;
	}


	if((connectorIsNULL == FALSE) && (connectorIdInt == 0) )
	{
		//clear the whole contents of a file in C
		fclose(fopen(ChargePointMaxProfile_JSON, "w"));
		fclose(fopen(TxDefaultProfile_0_JSON, "w"));
		fclose(fopen(TxDefaultProfile_1_JSON, "w"));
		fclose(fopen(TxDefaultProfile_2_JSON, "w"));

		fclose(fopen(TxProfile_1_JSON, "w"));
		fclose(fopen(TxProfile_2_JSON, "w"));
#if 0
		fclose(fopen(ChargingProfile_0_JSON, "w"));
		fclose(fopen(ChargingProfile_1_JSON, "w"));
		fclose(fopen(ChargingProfile_2_JSON, "w"));
#endif
		sprintf(comfirmstr, "%s", ClearChargingProfileStatusStr[ClearChargingProfileStatus_Accepted] );
	}
	else
	{
		fptr1 = fopen(fname, "r");
		fptr2 = fopen(temp, "w+");
		while(fscanf(fptr1, "%s", word) != EOF)
		{
			//DEBUG_INFO("word=%s\n",word);
			if(strcmp(word, "chargingProfileId") == 0)
			{
				n_chargingProfile = n_chargingProfile + 1;
				DEBUG_INFO("chargingProfileId Found\n");
			}
		}
		rewind(fptr1);

		//search Charging Profile Element
        //int i= 0;
		while ( fgets( sLineWord, sizeof sLineWord, fptr1 ) != NULL )
		{

			//*************************tempconnectorIdInt*********************************/
			loc = strstr(sLineWord, "connectorId");
			c = 0;
			memset(sstr ,0, sizeof(sstr) );
			while (loc[strlen("connectorId")+2+c] != ',')
			{
				sstr[c] = loc[strlen("connectorId")+2+c];
				c++;
			}
			sstr[c] = '\0';
			tempconnectorIdInt = atoi(sstr);

			//chargingProfileId
			c = 0;
			loc = strstr(sLineWord, "chargingProfileId");
			memset(sstr ,0, sizeof(sstr) );
			while (loc[strlen("chargingProfileId")+2+c] != ',')
			{
				sstr[c] = loc[strlen("chargingProfileId")+2+c];
				//printf("i=%d sstr=%c\n",c, sstr[c]);
				c++;
			}
			sstr[c] = '\0';
			tempchargingProfileIdInt = atoi(sstr);

			//stackLevel
			c = 0;
			loc = strstr(sLineWord, "stackLevel");
			memset(sstr ,0, sizeof(sstr) );
			while (loc[strlen("stackLevel")+2+c] != ',')
			{
				sstr[c] = loc[strlen("stackLevel")+2+c];
				//printf("i=%d sstr=%c\n",c, sstr[c]);
				c++;
			}
			sstr[c] = '\0';
			tempstackLevelInt = atoi(sstr);

			c = 0;
			loc = strstr(sLineWord, "chargingProfilePurpose");
			memset(sstr ,0, sizeof(sstr) );
			while (loc[3+strlen("chargingProfilePurpose")+c] != '\"')
			{
				sstr[c] = loc[3+strlen("chargingProfilePurpose")+c];
				c++;
			}
			sstr[c] = '\0';
			strcpy(tempchargingProfilePurposeStr, sstr);

			if(chargingProfileIdIsNULL == FALSE)
			{
				if(tempchargingProfileIdInt == chargingProfileIdInt)
				{
					//DEBUG_INFO("\n OCPP clear 0-1 !!!\n");
					sprintf(comfirmstr, "%s", ClearChargingProfileStatusStr[ClearChargingProfileStatus_Accepted] );
					clearflag = TRUE;
					continue;
				}
				else
				{
					//DEBUG_INFO("\n OCPP clear 0-2 !!!\n");
					//json_object_array_add(newHeatMap, jsonitem);
					fprintf(fptr2, sLineWord);//writing data into file
				}
			}
			else
			{
				if((connectorIsNULL == FALSE) && (connectorIdInt != 0) && ( connectorIdInt == tempconnectorIdInt))
				{
					if((stackLevelIsNULL == TRUE)||((stackLevelIsNULL == FALSE)&& (tempstackLevelInt == stackLevelInt)))
					{
						sprintf(comfirmstr, "%s", ClearChargingProfileStatusStr[ClearChargingProfileStatus_Accepted] );
						clearflag = TRUE;
						continue;
					}

				}
				else if((connectorIsNULL == TRUE) && ((tempstackLevelInt == stackLevelInt) || (strcmp(tempchargingProfilePurposeStr, chargingProfilePurposeStr) == 0)))
				{
					if((stackLevelIsNULL == FALSE)|| (chargingProfilePurposeIsNULL == FALSE))
					{
						if( ((stackLevelIsNULL == FALSE) &&(tempstackLevelInt == stackLevelInt)) ||
							((chargingProfilePurposeIsNULL == FALSE)&&(strcmp(tempchargingProfilePurposeStr, chargingProfilePurposeStr) == 0)) )
						{
							sprintf(comfirmstr, "%s", ClearChargingProfileStatusStr[ClearChargingProfileStatus_Accepted] );
							clearflag = TRUE;
							continue;
						}

					}

				}
				else
				{
					//json_object_array_add(newHeatMap, jsonitem);
					fprintf(fptr2, sLineWord);//writing data into file
				}

			}

			memset(sLineWord, 0, sizeof sLineWord);
		}

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

        fclose(fptr1);
        fclose(fptr2);

		sprintf(str,"rm -f %s",fname);
		system(str);

		resultRename = rename(temp, fname);

		if(resultRename == 0)
		{
			DEBUG_ERROR("File ChargingProfile renamed successfully");
		}
		else
		{
			DEBUG_ERROR("Error: unable to rename the ChargingProfile file");
		}
	}

	end:
	sendClearChargingProfileConfirmation(uuid, comfirmstr);

	return result;
}

int handleDataTransferRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
	//Payload={"vendorId":"Phihong","messageId":"MSGID","data":"Data1"}
	char tempvendorId[255]={0};
	char tempmessageId[50]={0};
	char tempdata[50]={0};
	char sstr[160]={0};//sstr[200]={ 0 };
	char message[80]={0};
	int c = 0;
	char *loc;

	DEBUG_INFO("handle DataTransferRequest\n");

	if((uuid != NULL) && (payload != NULL))
	{
		//===============================
		// vendorId
		//===============================
		c = 0;
		loc = strstr(payload, "vendorId");
		while (loc[strlen("vendorId")+3+c] != '\"')
		{
			sstr[c] = loc[strlen("vendorId")+3+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		strcpy(tempvendorId,sstr);

		//===============================
		// messageId
		//===============================
		memset(sstr ,0, sizeof(sstr) );
		c = 0;
		loc = strstr(payload, "messageId");
		while (loc[strlen("messageId")+3+c] != '\"')
		{
			sstr[c] = loc[strlen("messageId")+3+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		strcpy(tempmessageId,sstr);

		//===============================
		// data
		//===============================
		memset(sstr ,0, sizeof(sstr) );
		c = 0;
		loc = strstr(payload, "data");
		printf("loc=%s\n",loc);

		while (loc[strlen("data")+3+c] != '\"')
		{
			sstr[c] = loc[strlen("data")+3+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		strcpy(tempdata,sstr);

		sprintf(message,"[%d,\"%s\",{\"status\":\"%s\",\"data\":\"vendorId-%s messageId-%s data-%s\"}]",MESSAGE_TYPE_CALLRESULT, uuid, "Rejected", tempvendorId, tempmessageId, tempdata );
	}
	else
	{
		char guid[37]={0};
		random_uuid(guid);

		//[2,"1577349264923","DataTransfer",{"vendorId":"Phihong","messageId":"MSGID","data":"Data1"}]
		sprintf(message,"[%d,\"%s\",\"%s\",{\"vendorId\":\"Phihong\",\"messageId\":\"MSGID\",\"data\":\"Data1\"}]",MESSAGE_TYPE_CALL, guid, "DataTransfer");
	}

	LWS_Send(message);
	return result;
}

#if 0
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;
}
#endif


int handleGetCompositeScheduleRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
	int connectorIdInt, durationInt;
	char chargingRateUnitStr[4]={0};
	//int tempconnectorIdInt,
	int tempdurationInt;
	float tempminChargingRateFloat = 0.0;
    char tempvalidFromStr[30]={0},tempchargingRateUnitStr[4]={0}, tempstartScheduleStr[30]={0};
    int tempStartPeriodInt=0;
    float tempLimitInt=0.0;//0.1;
    int tempNumberPhasesInt=0;
    char fname[200];
    char comfirmstr[20];
    //float totallimit =0.0;
    float MinChargingRate =0.0;
	double diff_t;
	struct tm tp;
    //int clearflag = FALSE;
    FILE *fptr1;//, *fptr2;
    //char temp[] = "../Storage/OCPP/temp.json";
	int c = 0;
	//int i = 0;
	char * pch;
	char *loc;
	char sstr[200]={ 0 };
	int n_chargingProfile = 0;
	int n_SchedulePeriods = 0;
	char SchedulePeriodList[10][200]={0};
	char sLineWord[800]={0};
	//int n_periods = 0;
	char word[1000]={0};
	int confirmPeriods = 0;
	struct StructProfile ChargePointMaxProfile;
	struct StructProfile TxDefaultProfile;
	struct StructProfile TxProfile;
	struct StructProfile TxDefaultProfiletemp[2]={0};
	int TxDefaultProfileFileIsNull=FALSE;
	int ChargePointMaxProfileIsNull=FALSE;
	int	TxProfileIsNull=FALSE;
	int CompositeSceduleIndex = 0;



	memset(&ChargePointMaxProfile,0,sizeof(struct StructProfile));
	memset(&TxDefaultProfile,0,sizeof(struct StructProfile));
	memset(&TxProfile,0,sizeof(struct StructProfile));

	DEBUG_INFO("handleGetCompositeScheduleRequest 1\n");

    c=0;
    loc = strstr(payload, "connectorId");
    memset(sstr ,0, sizeof(sstr) );
   	while ((loc[strlen("connectorId")+2+c] != '}') && (loc[strlen("connectorId")+2+c] != ','))
   	{
   		sstr[c] = loc[strlen("connectorId")+2+c];
   		//printf("i=%d sstr=%c\n",c, sstr[c]);
   		c++;
   	}
   	sstr[c] = '\0';
    connectorIdInt = atoi(sstr);

    c=0;
    loc = strstr(payload, "duration");
    memset(sstr ,0, sizeof(sstr) );
   	while ((loc[strlen("duration")+2+c] != '}') && (loc[strlen("duration")+2+c] != ','))
   	{
   		sstr[c] = loc[strlen("duration")+2+c];
   		//printf("i=%d sstr=%c\n",c, sstr[c]);
   		c++;
   	}
   	sstr[c] = '\0';
   	durationInt = atoi(sstr);

   	c = 0;
    loc = strstr(payload, "chargingRateUnit");
  	memset(sstr ,0, sizeof(sstr) );
  	if(loc == NULL)
  	{

  	}
  	else
  	{
  		while (loc[3+strlen("chargingRateUnit")+c] != '\"')
  	  	{
  			sstr[c] = loc[3+strlen("chargingRateUnit")+c];
  	  		c++;
  	  	}
  	  	sstr[c] = '\0';
  	  	strcpy(chargingRateUnitStr, sstr);
  	}

	CompositeSceduleIndex = (connectorIdInt > 0) ?(connectorIdInt -1) :0;

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

  	DEBUG_INFO("handleGetCompositeScheduleRequest 2\n");
  	if(connectorIdInt==0) // connectorId is 0
  	{

  		//******************************ChargePointMaxProfile*****************************************************/
  		strcpy(fname, ChargePointMaxProfile_JSON );

  		char word[30]={0};
  		char sLineWord[1060]={0};
  		int n_chargingProfile=0;

  		ChargePointMaxProfileIsNull=TRUE;
  		if((access(fname,F_OK))!=-1)
  		{
  			fptr1 = fopen(fname, "r");

  			int c;
  			c = fgetc(fptr1);
  			//DEBUG_INFO("c:%d\n",c);
  			rewind(fptr1);

  			if(c == EOF)
  			{
  				DEBUG_INFO("\n End of file ChargingProfile reached.");
  			  	ChargePointMaxProfileIsNull=TRUE;
  			  	fclose(fptr1);
  			}
  			else
  			{
  				ChargePointMaxProfileIsNull=FALSE;
  				while(fscanf(fptr1, "%s", word) != EOF)
  			  	{
  			  		if(strcmp(word, "chargingProfileId") == 0)
  			  		{
  			  			n_chargingProfile = n_chargingProfile + 1;
  			  			printf("Found\n");
  			  		}
  			  	}
  			  	rewind(fptr1);

  			  	//search Charging Profile Element
  			  	int i= 0;
  			  	while ( fgets( sLineWord, sizeof sLineWord, fptr1 ) != NULL ) {
#if 0
  			  	/***********connectorId****************/
  			  	c = 0;
  			  	loc = strstr(sLineWord, "connectorId");
  			  	//	printf("loc=%s\n",loc);
  			  	memset(sstr ,0, sizeof(sstr) );
  			  	while (loc[strlen("connectorId")+2+c] != ',')
  			  	{
  			  		sstr[c] = loc[strlen("connectorId")+2+c];
  			  		//printf("i=%d sstr=%c\n",c, sstr[c]);
  			  		c++;
  			  	}
  			  	sstr[c] = '\0';
  			  	tempconnectorIdInt = atoi(sstr);
#endif
  			  	//***********validFrom**************/
  			  	c = 0;
  			  	loc = strstr(sLineWord, "validFrom");
  			  	//DEBUG_INFO("loc=%s\n",loc);
  			  	memset(sstr ,0, sizeof(sstr) );

  			  	if(loc != NULL)
  			  	{
  			  	  	while (loc[3+strlen("validFrom")+c] != '\"')
  			  	  	{
  			  	  		sstr[c] = loc[3+strlen("validFrom")+c];
  			  	  		//printf("i=%d sstr=%c\n",c, sstr[c]);
  			  	  		c++;
  			  	  	}
  			  	  	sstr[c] = '\0';
  			  	  	DEBUG_INFO("validFrom=%s\n",sstr);
  			  	  	strcpy(tempvalidFromStr,sstr);

  			  	}
  			  	else
  			  	{
  			  		strcpy(tempvalidFromStr,"");
  			  	}


  			  	//**********startSchedule**********/
  			  	c = 0;
  			  	loc = strstr(sLineWord, "startSchedule");
  			  	//DEBUG_INFO("loc=%s\n",loc);
  			  	memset(sstr ,0, sizeof(sstr) );
  			  	while (loc[3+strlen("startSchedule")+c] != '\"')
  			  	{
  			  		sstr[c] = loc[3+strlen("startSchedule")+c];
  			  		//printf("i=%d sstr=%c\n",c, sstr[c]);
  			  		c++;
  			  	}
  			  	sstr[c] = '\0';
  			  	strcpy(tempstartScheduleStr, sstr);


  				//**********startSchedule**********/
  				c = 0;
  				loc = strstr(sLineWord, "chargingRateUnit");
  				memset(sstr ,0, sizeof(sstr) );
  				while (loc[3+strlen("chargingRateUnit")+c] != '\"')
  				{
  				  	 sstr[c] = loc[3+strlen("chargingRateUnit")+c];
  				  	 c++;
  				}
  				sstr[c] = '\0';
  				strcpy(tempchargingRateUnitStr, sstr);

  			  	//**********minChargingRate*******/
  			  	c = 0;
  			  	loc = strstr(sLineWord, "minChargingRate");
  			  	//printf("loc=%s\n",loc);
  			  	if(loc != NULL)
  			  	{
  			  	  	memset(sstr ,0, sizeof(sstr) );
  			  	  	while ((loc[2+strlen("minChargingRate")+c] != ',')&&(loc[2+strlen("minChargingRate")+c] != '}'))
  			  	  	{
  			  	  		sstr[c] = loc[2+strlen("minChargingRate")+c];
  			  	  		//printf("i=%d sstr=%c\n",c, sstr[c]);
  			  	  		c++;
  			  	  	}
  			  	  	sstr[c] = '\0';
  			  		tempminChargingRateFloat = atof(sstr);
  			  	}
  			  	else
  			  	{
  			  		tempminChargingRateFloat = 0.0;
  			  	}


  			  	//
  			  	strptime(tempstartScheduleStr, "%Y-%m-%dT%H:%M:%S", &tp);
  			  	tp.tm_isdst = -1;
  			  	time_t utc = mktime(&tp);
  			  	// current time
  			  	time_t t = time(NULL);

  			  	diff_t = difftime(t, utc);

  			  	//parsing strings to words
  			  	i = 0;
  			  	loc = strstr(sLineWord, "chargingSchedulePeriod");
  			  	loc = loc+3+strlen("chargingSchedulePeriod");
  			  	pch = strtok(loc ,"{");
  			  	while (pch != NULL)
  			  	{
  			  		strcpy(SchedulePeriodList[i], pch);
  			  		//printf ("SchedulePeriodList[%d]:%s\n",i,SchedulePeriodList[i]);
  			  		//printf ("%s\n",pch);
  			  		pch = strtok (NULL, "{");
  			  		i = i + 1;
  			  	}
  			  	n_SchedulePeriods = i;

  			  	for(int i=0;i<n_SchedulePeriods;i++)
  			  	{
  			  		//*************startPeriod****************/
  			  		c = 0;
  			  		loc = strstr(SchedulePeriodList[i], "startPeriod");
  			  		memset(sstr ,0, sizeof(sstr) );
  			  		while (loc[strlen("startPeriod")+2+c] != ',')
  			  		{
  			  			sstr[c] = loc[strlen("startPeriod")+2+c];
  			  			//printf("i=%d sstr=%c\n",c, sstr[c]);
  			  			c++;
  			  		}
  			  		sstr[c] = '\0';
  			  		tempStartPeriodInt = atoi(sstr);

  			  		//*************limit****************/
  			  		c = 0;
  			  		loc = strstr(SchedulePeriodList[i], "limit");
  			  		memset(sstr ,0, sizeof(sstr) );
  			  		while (loc[strlen("limit")+2+c] != ',')
  			  		{
  			  			sstr[c] = loc[strlen("limit")+2+c];
  			  			//printf("i=%d sstr=%c\n",c, sstr[c]);
  			  			c++;
  			  		}
  			  		sstr[c] = '\0';
  			  		tempLimitInt = atof(sstr);

  			  		//*************numberPhases****************/
  			  		c = 0;
  			  		loc = strstr(SchedulePeriodList[i], "numberPhases");
  			  		memset(sstr ,0, sizeof(sstr) );
  			  		while ((loc[strlen("numberPhases")+2+c] != ',')&&(loc[strlen("numberPhases")+2+c] != '}'))
  			  		{
  			  			sstr[c] = loc[strlen("numberPhases")+2+c];
  			  			//printf("i=%d sstr=%c\n",c, sstr[c]);
  			  			c++;
  			  		}
  			  		sstr[c] = '\0';
  			  		tempNumberPhasesInt = atoi(sstr);

  			    	ChargePointMaxProfile.Duration = durationInt;
  			    	ChargePointMaxProfile.TotalPeriod = n_SchedulePeriods;
  			    	ChargePointMaxProfile.Period[i].Limit = tempLimitInt;
  			    	ChargePointMaxProfile.Period[i].NumberPhases = tempNumberPhasesInt;
  			    	ChargePointMaxProfile.Period[i].StartPeriod = tempStartPeriodInt;

  			  	  }

  			  		if(MinChargingRate < tempminChargingRateFloat)
  			  			MinChargingRate = tempminChargingRateFloat;
  			  	}

  			}// End of file ChargingProfile

  		} //THE END OF ACCESS ChargePointMaxProfile



  	  	//******************************TxDefaultProfile***********************************************/

  		strcpy(fname, TxDefaultProfile_0_JSON);

  		memset(word, 0, 30);
  		memset(sLineWord, 0, 1060);
  	  	//char word[30]={0};
  	  	//char sLineWord[1060]={0};
  	  	n_chargingProfile=0;
  	  	TxDefaultProfileFileIsNull=TRUE;
  	  	if((access(fname,F_OK))!=-1)
  	  	{
  	  		fptr1 = fopen(fname, "r");

  	  		c = 0;
  	  	  	c = fgetc(fptr1);
  	  	  	//DEBUG_INFO("c:%d\n",c);
  	  	  	rewind(fptr1);

  	  	  	if(c == EOF)
  	  	  	{
  	  	  		DEBUG_INFO("\n End of file ChargingProfile reached.");

  	  	  	  	TxDefaultProfileFileIsNull=TRUE;
  	  	  	  	fclose(fptr1);
  	  	  	}
  	  	  	else
  	  	  	{
  	  	  	  	TxDefaultProfileFileIsNull=FALSE;
  	  	  	  	while(fscanf(fptr1, "%s", word) != EOF)
  	  	  	  	{
  	  	  	  		if(strcmp(word, "chargingProfileId") == 0)
  	  	  	  		{
  	  	  	  			n_chargingProfile = n_chargingProfile + 1;
  	  	  	  			printf("Found\n");
  	  	  	  		}
  	  	  	  	}
  	  	  	  	rewind(fptr1);

  	  	  	  	//search Charging Profile Element
  	  	  	  	int i= 0;
  	  	  	  	while ( fgets( sLineWord, sizeof sLineWord, fptr1 ) != NULL ) {

#if 0
  	  	  	  	/***********connectorId****************/
  	  	  	  	c = 0;
  	  	  	  	loc = strstr(sLineWord, "connectorId");
  	  	  	  	//	printf("loc=%s\n",loc);
  	  	  	  	memset(sstr ,0, sizeof(sstr) );
  	  	  	  	while (loc[strlen("connectorId")+2+c] != ',')
  	  	  	  	{
  	  	  	  		sstr[c] = loc[strlen("connectorId")+2+c];
  	  	  	  		//printf("i=%d sstr=%c\n",c, sstr[c]);
  	  	  	  		c++;
  	  	  	  	}
  	  	  	  	sstr[c] = '\0';
  	  	  	  	DEBUG_INFO("connectorId=%d\n",atoi(sstr));
  	  	  	  	tempconnectorIdInt = atoi(sstr);
#endif

  	  	  	  	//***********validFrom**************/
  	  	  	  	c = 0;
  	  	  	  	loc = strstr(sLineWord, "validFrom");
  	  	  	  	//DEBUG_INFO("loc=%s\n",loc);
  	  	  	  	memset(sstr ,0, sizeof(sstr) );

  	  	  	  	if(loc != NULL)
  	  	  	  	{
  	  	  	  	  	while (loc[3+strlen("validFrom")+c] != '\"')
  	  	  	  	  	{
  	  	  	  	  		sstr[c] = loc[3+strlen("validFrom")+c];
  	  	  	  	  		//printf("i=%d sstr=%c\n",c, sstr[c]);
  	  	  	  	  		c++;
  	  	  	  	  	}
  	  	  	  	  	sstr[c] = '\0';
  	  	  	  	  	DEBUG_INFO("validFrom=%s\n",sstr);
  	  	  	  	  	strcpy(tempvalidFromStr,sstr);

  	  	  	  	}
  	  	  	  	else
  	  	  	  	{
  	  	  	  		strcpy(tempvalidFromStr,"");
  	  	  	  	}


  	  	  	  	//**********startSchedule**********/
  	  	  	  	c = 0;
  	  	  	  	loc = strstr(sLineWord, "startSchedule");
  	  	  	  	//DEBUG_INFO("loc=%s\n",loc);
  	  	  	  	memset(sstr ,0, sizeof(sstr) );
  	  	  	  	while (loc[3+strlen("startSchedule")+c] != '\"')
  	  	  	  	{
  	  	  	  		sstr[c] = loc[3+strlen("startSchedule")+c];
  	  	  	  		//printf("i=%d sstr=%c\n",c, sstr[c]);
  	  	  	  		c++;
  	  	  	  	}
  	  	  	  	sstr[c] = '\0';
  	  	  	  	strcpy(tempstartScheduleStr, sstr);


  	  	  		DEBUG_INFO(" debug  3-1\n");
  	  	  		//**********startSchedule**********/
  	  	  		c = 0;
  	  	  		loc = strstr(sLineWord, "chargingRateUnit");
  	  	  		memset(sstr ,0, sizeof(sstr) );
  	  	  		while (loc[3+strlen("chargingRateUnit")+c] != '\"')
  	  	  		{
  	  	  		  	sstr[c] = loc[3+strlen("chargingRateUnit")+c];
  	  	  		  	c++;
  	  	  		}
  	  	  		sstr[c] = '\0';
  	  	  		strcpy(tempchargingRateUnitStr, sstr);

  	  	  	  	//**********minChargingRate*******/
  	  	  	  	c = 0;
  	  	  	  	loc = strstr(sLineWord, "minChargingRate");
  	  	  	  	//printf("loc=%s\n",loc);
  	  	  	  	if(loc != NULL)
  	  	  	  	{
  	  	  	  	  	memset(sstr ,0, sizeof(sstr) );
  	  	  	  	  	while ((loc[2+strlen("minChargingRate")+c] != ',')&&(loc[2+strlen("minChargingRate")+c] != '}'))
  	  	  	  	  	{
  	  	  	  	  		sstr[c] = loc[2+strlen("minChargingRate")+c];
  	  	  	  	  		//printf("i=%d sstr=%c\n",c, sstr[c]);
  	  	  	  	  		c++;
  	  	  	  	  	}
  	  	  	  	  	sstr[c] = '\0';
  	  	  	  	  	tempminChargingRateFloat = atof(sstr);
  	  	  	  	}
  	  	  	  	else
  	  	  	  	{
  	  	  	  		tempminChargingRateFloat = 0.0;
  	  	  	  	}


  	  	  	  	//
  	  	  	  	strptime(tempstartScheduleStr, "%Y-%m-%dT%H:%M:%S", &tp);
  	  	  	  	tp.tm_isdst = -1;
  	  	  	  	time_t utc = mktime(&tp);
  	  	  	  	// current time
  	  	  	  	time_t t = time(NULL);
  	  	  	  	diff_t = difftime(t, utc);

  	  	  	  	//parsing strings to words
  	  	  	  	i = 0;
  	  	  	  	loc = strstr(sLineWord, "chargingSchedulePeriod");
  	  	  	  	loc = loc+3+strlen("chargingSchedulePeriod");
  	  	  	  	pch = strtok(loc ,"{");
  	  	  	  	while (pch != NULL)
  	  	  	  	{
  	  	  	  		strcpy(SchedulePeriodList[i], pch);
  	  	  	  		//printf ("SchedulePeriodList[%d]:%s\n",i,SchedulePeriodList[i]);
  	  	  	  		//printf ("%s\n",pch);
  	  	  	  		pch = strtok (NULL, "{");
  	  	  	  		i = i + 1;
  	  	  	  	}
  	  	  	  	n_SchedulePeriods = i;

  	  	  	  	for(int i=0;i<n_SchedulePeriods;i++)
  	  	  	  	{
  	  	  	  		//*************startPeriod****************/
  	  	  	  		c = 0;
  	  	  	  		loc = strstr(SchedulePeriodList[i], "startPeriod");
  	  	  	  		memset(sstr ,0, sizeof(sstr) );
  	  	  	  		while (loc[strlen("startPeriod")+2+c] != ',')
  	  	  	  		{
  	  	  	  			sstr[c] = loc[strlen("startPeriod")+2+c];
  	  	  	  			//printf("i=%d sstr=%c\n",c, sstr[c]);
  	  	  	  			c++;
  	  	  	  		}
  	  	  	  		sstr[c] = '\0';
  	  	  	  		tempStartPeriodInt = atoi(sstr);

  	  	  	  		//*************limit****************/
  	  	  	  		c = 0;
  	  	  	  		loc = strstr(SchedulePeriodList[i], "limit");
  	  	  	  		memset(sstr ,0, sizeof(sstr) );
  	  	  	  		while (loc[strlen("limit")+2+c] != ',')
  	  	  	  		{
  	  	  	  			sstr[c] = loc[strlen("limit")+2+c];
  	  	  	  			//printf("i=%d sstr=%c\n",c, sstr[c]);
  	  	  	  			c++;
  	  	  	  		}
  	  	  	  		sstr[c] = '\0';
  	  	  	  		tempLimitInt = atof(sstr);

  	  	  	  		//*************numberPhases****************/
  	  	  	  		c = 0;
  	  	  	  		loc = strstr(SchedulePeriodList[i], "numberPhases");
  	  	  	  		memset(sstr ,0, sizeof(sstr) );
  	  	  	  		while ((loc[strlen("numberPhases")+2+c] != ',')&&(loc[strlen("numberPhases")+2+c] != '}'))
  	  	  	  		{
  	  	  	  			sstr[c] = loc[strlen("numberPhases")+2+c];
  	  	  	  			//printf("i=%d sstr=%c\n",c, sstr[c]);
  	  	  	  			c++;
  	  	  	  		}
  	  	  	  		sstr[c] = '\0';
  	  	  	  		tempNumberPhasesInt = atoi(sstr);

  	  	  	    	TxDefaultProfile.Duration = durationInt;
  	  	  	    	TxDefaultProfile.TotalPeriod = n_SchedulePeriods;
  	  	  	    	TxDefaultProfile.Period[i].Limit = tempLimitInt;
  	  	  	    	TxDefaultProfile.Period[i].NumberPhases = tempNumberPhasesInt;
  	  	  	    	TxDefaultProfile.Period[i].StartPeriod = tempStartPeriodInt;

  	  	  	  	  }

  	  	  	  		if(MinChargingRate < tempminChargingRateFloat)
  	  	  	  			MinChargingRate = tempminChargingRateFloat;
  	  	  	  	}

  	  	  	  }

  	  		}// the end of ACCESS TxDefaultProfile




  	  	  	 // Composite Schedule
  	  	  	if((ChargePointMaxProfileIsNull==FALSE)&&(TxDefaultProfileFileIsNull==FALSE))
  	  	  	{
  	  	  		for(int index=0; index < TxDefaultProfile.TotalPeriod ; index++)
  	  	  		{
  	  	  			if(ChargePointMaxProfile.Period[0].Limit > TxDefaultProfile.Period[index].Limit)
  	  	  			{
  	  	  				ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[index].Limit = TxDefaultProfile.Period[index].Limit;
  	  	  			}
  	  	  			else
  	  	  			{
  	  	  				ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[index].Limit = ChargePointMaxProfile.Period[0].Limit;
  	  	  			}

  	  	  			ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[index].NumberPhases = TxDefaultProfile.Period[index].NumberPhases;  //for discussion
  	  	  		  	ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[index].StartPeriod = TxDefaultProfile.Period[index].StartPeriod;
  	  	  		  	ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.Duration = TxDefaultProfile.Duration;
  	  	  		}

  	  	  	}


  			//* 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[CompositeSceduleIndex].ResponseChargingSchedule.StartSchedule,buf);

  			//MaxChargingProfilesInstalled is 10
  		//	ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod =  (struct StructChargingSchedulePeriod *) malloc(sizeof(struct StructChargingSchedulePeriod)* 9);
  			memset(ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod, 0, sizeof(struct StructChargingSchedulePeriod)* 9);

  			//nPeriod = 1;

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

  			confirmPeriods = 1;
  		}
  		else if ((connectorIdInt > 0)&&((connectorIdInt -1) < gunTotalNumber/*(CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY)*/)  )
  		{
  			//*****************************ChargePointMaxProfile******************************************/
  			DEBUG_INFO("handleGetCompositeScheduleRequest 3\n");
  			strcpy(fname, ChargePointMaxProfile_JSON);
  			ChargePointMaxProfileIsNull=TRUE;
  			if((access(ChargePointMaxProfile_JSON,F_OK))!=-1)
  			{
  				fptr1 = fopen(fname, "r");

  				int c;
  				c = fgetc(fptr1);
  				//DEBUG_INFO("c:%d\n",c);
  				rewind(fptr1);

  				if(c == EOF)
  				{
  				  	DEBUG_INFO("\n End of file reached.");
  				  ChargePointMaxProfileIsNull=TRUE;
  				  	fclose(fptr1);

  				}
  				else
  				{
  					ChargePointMaxProfileIsNull=FALSE;
  				  	while(fscanf(fptr1, "%s", word) != EOF)
  				  	{
  				  		if(strcmp(word, "chargingProfileId") == 0)
  				  		{
  				  			n_chargingProfile = n_chargingProfile + 1;
  				  		}
  				  	}
  				  	rewind(fptr1);

  				  	//search Charging Profile Element
  				  	int i = 0;
  				  	int j = 0;
  				  	while ( fgets( sLineWord, sizeof sLineWord, fptr1 ) != NULL ) {

#if 0
  				  	/***********connectorId****************/
  				  	c = 0;
  				  	loc = strstr(sLineWord, "connectorId");
  				  	memset(sstr ,0, sizeof(sstr) );
  				  	while (loc[strlen("connectorId")+2+c] != ',')
  				  	{
  				  		sstr[c] = loc[strlen("connectorId")+2+c];
  				  		//printf("i=%d sstr=%c\n",c, sstr[c]);
  				  		c++;
  				  	}
  				  	sstr[c] = '\0';
  				  	tempconnectorIdInt = atoi(sstr);
#endif
  				  	//***********validFrom**************/
  				  	c = 0;
  				  	loc = strstr(sLineWord, "validFrom");
  				  	if(loc != NULL)
  				  	{
  				  		memset(sstr ,0, sizeof(sstr) );
  				  		while (loc[3+strlen("validFrom")+c] != '\"')
  				  		{
  				  			sstr[c] = loc[3+strlen("validFrom")+c];
  				  			c++;
  				  		}
  				  		sstr[c] = '\0';
  				  		strcpy(tempvalidFromStr,sstr);
  				  	}
  				  	else
  				  	{
  				  		strcpy(tempvalidFromStr,"");
  				  	}

  				  	//***********validFrom**************/
  				  	c = 0;
  				  	loc = strstr(sLineWord, "duration");
  				  	if(loc != NULL)
  				  	{
  				  		memset(sstr ,0, sizeof(sstr) );
  				  		while (loc[2+strlen("duration")+c] != ',')
  				  		{
  				  			sstr[c] = loc[2+strlen("duration")+c];
  				  			c++;
  				  		}
  				  		sstr[c] = '\0';
  				  		tempdurationInt = atoi(sstr);
  				  	}
  				  	else
  				  	{
  				  		tempdurationInt = 0;
  				  	}

  				  	//**********startSchedule**********/
  				  	c = 0;
  				  	loc = strstr(sLineWord, "startSchedule");
  				  	memset(sstr ,0, sizeof(sstr) );
  				  	while (loc[3+strlen("startSchedule")+c] != '\"')
  				  	{
  				  		sstr[c] = loc[3+strlen("startSchedule")+c];
  				  		c++;
  				  	}
  				  	sstr[c] = '\0';
  				  	strcpy(tempstartScheduleStr, sstr);

  				  	//**********startSchedule**********/
  				  	c = 0;
  				  	loc = strstr(sLineWord, "chargingRateUnit");
  				  	memset(sstr ,0, sizeof(sstr) );
  				  	while (loc[3+strlen("chargingRateUnit")+c] != '\"')
  				  	{
  				  		sstr[c] = loc[3+strlen("chargingRateUnit")+c];
  				  		c++;
  				  	}
  				  	sstr[c] = '\0';
  				  	strcpy(tempchargingRateUnitStr, sstr);

  				  	//**********minChargingRate*******/
  				  	c = 0;
  				  	loc = strstr(sLineWord, "minChargingRate");
  				  	if(loc != NULL)
  				  	{
  				  		memset(sstr ,0, sizeof(sstr) );
  				  		while ((loc[2+strlen("minChargingRate")+c] != ',')&&(loc[2+strlen("minChargingRate")+c] != '}'))
  				  		{
  				  			sstr[c] = loc[2+strlen("minChargingRate")+c];
  				  			c++;
  				  		}
  				  		sstr[c] = '\0';
  				  		tempminChargingRateFloat = atof(sstr);
  				  	}
  				  	else
  				  	{
  				  		tempminChargingRateFloat = 0.0;
  				  	}

  				  	//
  				  	strptime(tempstartScheduleStr, "%Y-%m-%dT%H:%M:%S", &tp);
  				  	tp.tm_isdst = -1;
  				  	time_t utc = mktime(&tp);
  				  	time_t t = time(NULL);
  				  	diff_t = difftime(t, utc);

  				  	DEBUG_INFO("diff_t=%f\n",diff_t);
  				  	DEBUG_INFO(" debug  5 -1\n");
  				  	//parsing strings to words
  				  	i = 0;
  				  	loc = strstr(sLineWord, "chargingSchedulePeriod");
  				  	loc = loc+3+strlen("chargingSchedulePeriod");
  				  	pch = strtok(loc ,"{");
  				  	while (pch != NULL)
  				  	{
  				  		strcpy(SchedulePeriodList[i], pch);
  				  		pch = strtok (NULL, "{");
  				  		i = i + 1;
  				  	}
  				  	n_SchedulePeriods = i;

  				  	for(int i=0;i<n_SchedulePeriods;i++)
  				  	{
  				  		//*************startPeriod****************/
  				  		c = 0;
  				  		loc = strstr(SchedulePeriodList[i], "startPeriod");
  				  		memset(sstr ,0, sizeof(sstr) );
  				  		while (loc[strlen("startPeriod")+2+c] != ',')
  				  		{
  				  			sstr[c] = loc[strlen("startPeriod")+2+c];
  				  			//printf("i=%d sstr=%c\n",c, sstr[c]);
  				  			c++;
  				  		}
  				  		sstr[c] = '\0';
  				  		tempStartPeriodInt = atoi(sstr);

  				  		//*************limit****************/
  				  		c = 0;
  				  		loc = strstr(SchedulePeriodList[i], "limit");
  				  		memset(sstr ,0, sizeof(sstr) );
  				  		while (loc[strlen("limit")+2+c] != ',')
  				  		{
  				  			sstr[c] = loc[strlen("limit")+2+c];
  				  			//printf("i=%d sstr=%c\n",c, sstr[c]);
  				  			c++;
  				  		}
  				  		sstr[c] = '\0';
  				  		tempLimitInt = atof(sstr);

  				  		//*************numberPhases****************/
  				  		c = 0;
  				  		loc = strstr(SchedulePeriodList[i], "numberPhases");
  				  		memset(sstr ,0, sizeof(sstr) );
  				  		while (loc[strlen("numberPhases")+2+c] != '}')
  				  		{
  				  			sstr[c] = loc[strlen("numberPhases")+2+c];
  				  			//printf("i=%d sstr=%c\n",c, sstr[c]);
  				  			c++;
  				  		}
  				  		sstr[c] = '\0';
  				  		tempNumberPhasesInt = atoi(sstr);

  				  		if(j == 0)
  				  		{
  				  			 ChargePointMaxProfile.Duration = tempdurationInt;
  				  			 ChargePointMaxProfile.TotalPeriod = n_SchedulePeriods;
  				  			 ChargePointMaxProfile.Period[i].Limit = tempLimitInt;
  				  			 ChargePointMaxProfile.Period[i].NumberPhases = tempNumberPhasesInt;
  				  			 ChargePointMaxProfile.Period[i].StartPeriod = tempStartPeriodInt;
  				  		}

  				  	}

  				  	if(MinChargingRate < tempminChargingRateFloat)
  				  	{
  				  		MinChargingRate = tempminChargingRateFloat;
  				  	}



  				  	if(confirmPeriods < n_SchedulePeriods)
  				  	{
  				  		confirmPeriods = n_SchedulePeriods;
  				  	}


  				  		j = j + 1;
  				  }

  				  fclose(fptr1);

  				}

  			}// the end of access file ChargePointMaxProfile



  			//****************************TxDefaultProfile************************************************/

  			switch(connectorIdInt)
  			{
  			  	case 0:
  			  		break;

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

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

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

  			TxDefaultProfileFileIsNull=TRUE;
  			if((access(fname,F_OK))!=-1)
  			{
  				DEBUG_INFO("handleGetCompositeScheduleRequest 4\n");
  	  			fptr1 = fopen(fname, "r");

  	  			c = 0;
  	  			c = fgetc(fptr1);
  	  			//DEBUG_INFO("c:%d\n",c);
  	  			rewind(fptr1);

  	  			if(c == EOF)
  	  			{
  	  				DEBUG_INFO("\n End of file reached.");
  	  			TxDefaultProfileFileIsNull=TRUE;
  	  			  	fclose(fptr1);

  	  			}
  	  			else
  	  			{
  	  				TxDefaultProfileFileIsNull=FALSE;

  	  			  	while(fscanf(fptr1, "%s", word) != EOF)
  	  			  	{
  	  			  	  	if(strcmp(word, "chargingProfileId") == 0)
  	  			  	  	{
  	  			  	  		n_chargingProfile = n_chargingProfile + 1;
  	  			  	  	}
  	  			  	}
  	  			  	rewind(fptr1);

  	  			  	//search Charging Profile Element
  	  			  	int i = 0;
  	  			  	int j = 0;
  	  			  	while ( fgets( sLineWord, sizeof sLineWord, fptr1 ) != NULL ) {
#if 0
  	  			  	/***********connectorId****************/
  	  			  	c = 0;
  	  			  	loc = strstr(sLineWord, "connectorId");
  	  			  	memset(sstr ,0, sizeof(sstr) );
  	  			  	while (loc[strlen("connectorId")+2+c] != ',')
  	  			  	{
  	  			  	  	sstr[c] = loc[strlen("connectorId")+2+c];
  	  			  	  	//printf("i=%d sstr=%c\n",c, sstr[c]);
  	  			  	  	c++;
  	  			  	}
  	  			  	sstr[c] = '\0';
  	  			  	tempconnectorIdInt = atoi(sstr);
#endif

  	  			  	//***********validFrom**************/
  	  			  	c = 0;
  	  			  	loc = strstr(sLineWord, "validFrom");
  	  			  	if(loc != NULL)
  	  			  	{
  	  			  	  	memset(sstr ,0, sizeof(sstr) );
  	  			  	  	while (loc[3+strlen("validFrom")+c] != '\"')
  	  			  	  	{
  	  			  	  		sstr[c] = loc[3+strlen("validFrom")+c];
  	  			  	  		c++;
  	  			  	  	}
  	  			  	  	sstr[c] = '\0';
  	  			  	  	strcpy(tempvalidFromStr,sstr);
  	  			  	}
  	  			  	else
  	  			  	{
  	  			  	  strcpy(tempvalidFromStr,"");
  	  			  	}
  	  			DEBUG_INFO("handleGetCompositeScheduleRequest 5\n");
  	  			    //***********validFrom**************/
  	  			  	c = 0;
  	  			    loc = strstr(sLineWord, "duration");
  	  			  	if(loc != NULL)
  	  			  	{
  	  			  		memset(sstr ,0, sizeof(sstr) );
  	  			  		while (loc[2+strlen("duration")+c] != ',')
  	  			  		{
  	  			  			sstr[c] = loc[2+strlen("duration")+c];
  	  			  			c++;
  	  			  		}
  	  			  		sstr[c] = '\0';
  	  			  		tempdurationInt = atoi(sstr);
  	  			  	}
  	  			  	else
  	  			  	{
  	  			  		tempdurationInt = 0;
  	  			  	}

  	  			DEBUG_INFO("handleGetCompositeScheduleRequest 6\n");
  	  			  	//**********startSchedule**********/
  	  			  	c = 0;
  	  			  	loc = strstr(sLineWord, "startSchedule");
  	  			  	memset(sstr ,0, sizeof(sstr) );
  	  			  	while (loc[3+strlen("startSchedule")+c] != '\"')
  	  			  	{
  	  			  		sstr[c] = loc[3+strlen("startSchedule")+c];
  	  			  	  	c++;
  	  			  	}
  	  			  	sstr[c] = '\0';
  	  			  	strcpy(tempstartScheduleStr, sstr);

  	  			  	//**********startSchedule**********/
  	  			  	c = 0;
  	  			  	loc = strstr(sLineWord, "chargingRateUnit");
  	  			  	memset(sstr ,0, sizeof(sstr) );
  	  			  	while (loc[3+strlen("chargingRateUnit")+c] != '\"')
  	  			  	{
  	  			  		sstr[c] = loc[3+strlen("chargingRateUnit")+c];
  	  			  		c++;
  	  			  	}
  	  			  	sstr[c] = '\0';
  	  			  	strcpy(tempchargingRateUnitStr, sstr);

  	  			  	//**********minChargingRate*******/
  	  			  	c = 0;
  	  			  	loc = strstr(sLineWord, "minChargingRate");
  	  			  	if(loc != NULL)
  	  			  	{
  	  			  		memset(sstr ,0, sizeof(sstr) );
  	  			  		while ((loc[2+strlen("minChargingRate")+c] != ',')&&(loc[2+strlen("minChargingRate")+c] != '}'))
  	  			  	  	{
  	  			  			sstr[c] = loc[2+strlen("minChargingRate")+c];
  	  			  			c++;
  	  			  	  	}
  	  			  	  	sstr[c] = '\0';
  	  			  	  	tempminChargingRateFloat = atof(sstr);
  	  			  	}
  	  			  	else
  	  			  	{
  	  			  	  	tempminChargingRateFloat = 0.0;
  	  			  	}
  	  			DEBUG_INFO("handleGetCompositeScheduleRequest 7\n");
  	  			  	//
  	  			  	strptime(tempstartScheduleStr, "%Y-%m-%dT%H:%M:%S", &tp);
  	  			  	tp.tm_isdst = -1;
  	  			  	time_t utc = mktime(&tp);
  	  			  	time_t t = time(NULL);
  	  			  	diff_t = difftime(t, utc);

  	  			  	DEBUG_INFO("diff_t=%f\n",diff_t);
  	  			  	DEBUG_INFO(" debug  5 -1\n");
  	  			  	//parsing strings to words
  	  			  	i = 0;
  	  			  	loc = strstr(sLineWord, "chargingSchedulePeriod");
  	  			  	loc = loc+3+strlen("chargingSchedulePeriod");
  	  			  	pch = strtok(loc ,"{");
  	  			  	while (pch != NULL)
  	  			  	{
  	  			  		strcpy(SchedulePeriodList[i], pch);
  	  			  	  	pch = strtok (NULL, "{");
  	  			  	  	i = i + 1;
  	  			  	}
  	  			  	n_SchedulePeriods = i;

  	  			DEBUG_INFO("handleGetCompositeScheduleRequest 8\n");

  	  			  	for(int i=0;i<n_SchedulePeriods;i++)
  	  			  	{
  	  			  	  	//*************startPeriod****************/
  	  			  	  	c = 0;
  	  			  	  	loc = strstr(SchedulePeriodList[i], "startPeriod");
  	  			  	  	memset(sstr ,0, sizeof(sstr) );
  	  			  	  	while (loc[strlen("startPeriod")+2+c] != ',')
  	  			  	  	{
  	  			  	  		sstr[c] = loc[strlen("startPeriod")+2+c];
  	  			  	  		//printf("i=%d sstr=%c\n",c, sstr[c]);
  	  			  	  		c++;
  	  			  	  	}
  	  			  	  	sstr[c] = '\0';
  	  			  	  	tempStartPeriodInt = atoi(sstr);

  	  			  	  	//*************limit****************/
  	  			  	  	c = 0;
  	  			  	  	loc = strstr(SchedulePeriodList[i], "limit");
  	  			  	  	memset(sstr ,0, sizeof(sstr) );
  	  			  	  	while (loc[strlen("limit")+2+c] != ',')
  	  			  	  	{
  	  			  	  		sstr[c] = loc[strlen("limit")+2+c];
  	  			  	  		//printf("i=%d sstr=%c\n",c, sstr[c]);
  	  			  	  		c++;
  	  			  	  	}
  	  			  	  	sstr[c] = '\0';
  	  			  	  	tempLimitInt = atof(sstr);

  	  			  	  	//*************numberPhases****************/
  	  			  	  	c = 0;
  	  			  	  	loc = strstr(SchedulePeriodList[i], "numberPhases");
  	  			  	  	memset(sstr ,0, sizeof(sstr) );
  	  			  	  	while (loc[strlen("numberPhases")+2+c] != '}')
  	  			  	  	{
  	  			  	  		sstr[c] = loc[strlen("numberPhases")+2+c];
  	  			  	  		//printf("i=%d sstr=%c\n",c, sstr[c]);
  	  			  	  		c++;
  	  			  	  	}
  	  			  	  	sstr[c] = '\0';
  	  			  	  	tempNumberPhasesInt = atoi(sstr);

  	  			  	  	if(j == 0)
  	  			  	  	{
  	  			  	  		TxDefaultProfile.Duration = tempdurationInt;
  	  			  	  		TxDefaultProfile.TotalPeriod = n_SchedulePeriods;
  	  			  	  		TxDefaultProfile.Period[i].Limit = tempLimitInt;
  	  			  	  		TxDefaultProfile.Period[i].NumberPhases = tempNumberPhasesInt;
  	  			  	  		TxDefaultProfile.Period[i].StartPeriod = tempStartPeriodInt;
  	  			  	  	}
  	  			  	  	else
  	  			  	  	{
  	  			  	  		//other stack level charging Profile
  	  			  	  		TxDefaultProfiletemp[j-1].Period[i].Limit = tempLimitInt;
  	  			  	  		TxDefaultProfiletemp[j-1].Period[i].NumberPhases = tempNumberPhasesInt;
  	  			  	  		TxDefaultProfiletemp[j-1].Period[i].StartPeriod = tempStartPeriodInt;
  	  			  	  		TxDefaultProfiletemp[j-1].Duration = tempdurationInt;
  	  			  	  		TxDefaultProfiletemp[j-1].TotalPeriod = n_SchedulePeriods;

  	  			  	  	}

  	  			  	  }

  	  			  	  	if(MinChargingRate < tempminChargingRateFloat)
  	  			  	  		MinChargingRate = tempminChargingRateFloat;


  	  			  	  	if(confirmPeriods < n_SchedulePeriods)
  	  			  	  		confirmPeriods = n_SchedulePeriods;

  	  			  	  	j = j + 1;
  	  			  	}

  	  			  	fclose(fptr1);

  	  			  	//Stacking Charging Profiles

  	  			  	for(int l=0; l <(j-1) ;l++)
  	  			  	{
  	  			  		for(int k=0; k < TxDefaultProfiletemp[l].TotalPeriod; k++)
  	  			  		{
  	  			  			if(TxDefaultProfiletemp[l].Period[k].StartPeriod > TxDefaultProfile.Duration)
  	  			  		  	{
  	  			  				if((k >0) && ((TxDefaultProfiletemp[l].Period[k-1].StartPeriod < TxDefaultProfile.Duration) &&(TxDefaultProfiletemp[l].Period[k-1].StartPeriod >= TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod-1].StartPeriod )))
  	  			  				{
  	  			  					TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].Limit = TxDefaultProfiletemp[l].Period[k-1].Limit;
  	  			  				  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].NumberPhases = TxDefaultProfiletemp[l].Period[k-1].NumberPhases;
  	  			  				  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].StartPeriod = TxDefaultProfile.Duration;
  	  			  				  	TxDefaultProfile.TotalPeriod = TxDefaultProfile.TotalPeriod + 1;
  	  			  				  	TxDefaultProfile.Duration = TxDefaultProfiletemp[l].Duration;

  	  			  				  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].Limit = TxDefaultProfiletemp[l].Period[k].Limit;
  	  			  				  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].NumberPhases = TxDefaultProfiletemp[l].Period[k].NumberPhases;
  	  			  				  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].StartPeriod = TxDefaultProfiletemp[l].Period[k].StartPeriod;
  	  			  				  	TxDefaultProfile.TotalPeriod = TxDefaultProfile.TotalPeriod + 1;
  	  			  				  	TxDefaultProfile.Duration = TxDefaultProfiletemp[l].Duration;


  	  			  				}
  	  			  				else
  	  			  			  	{
  	  			  			  	  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].Limit = TxDefaultProfiletemp[l].Period[k].Limit;
  	  			  			  	  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].NumberPhases = TxDefaultProfiletemp[l].Period[k].NumberPhases;
  	  			  			  	  	TxDefaultProfile.Period[TxDefaultProfile.TotalPeriod].StartPeriod = TxDefaultProfiletemp[l].Period[k].StartPeriod;
  	  			  			  	  	TxDefaultProfile.TotalPeriod = TxDefaultProfile.TotalPeriod + 1;
  	  			  			  	  	TxDefaultProfile.Duration = TxDefaultProfiletemp[l].Duration;

  	  			  			  	 }


  	  			  		  	}

  	  			  		}

  	  			  	}
  	  			  	//end of Stacking Charging Profiles

  	  			 }

  			}// the end of ACCESS TxDefaultProfile


  			DEBUG_INFO("handleGetCompositeScheduleRequest 9\n");
  			//****************************TxProfile************************************************/
  			switch(connectorIdInt)
  			{
  			  	case 0:
  			  		break;

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

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

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

  			TxProfileIsNull=TRUE;
  			if((access(fname,F_OK))!=-1)
  			{
  				fptr1 = fopen(fname, "r");
  				c = 0;
  				c = fgetc(fptr1);
  				//DEBUG_INFO("c:%d\n",c);
  				rewind(fptr1);

  				if(c == EOF)
  				{
  				  	DEBUG_INFO("\n End of file reached.");
  				  	TxProfileIsNull=TRUE;
  				  	fclose(fptr1);

  				}
  				else
  				{
  				  	TxProfileIsNull=FALSE;

  				  	while(fscanf(fptr1, "%s", word) != EOF)
  				  	{
  				  	  	if(strcmp(word, "chargingProfileId") == 0)
  				  	  	{
  				  	  		n_chargingProfile = n_chargingProfile + 1;
  				  	  	}
  				  	}
  				  	rewind(fptr1);

  					//search Charging Profile Element
  				  	int i= 0;
  				  	while ( fgets( sLineWord, sizeof sLineWord, fptr1 ) != NULL ) {

#if 0
  				  	  	/***********connectorId****************/
  				  	  	c = 0;
  				  	  	loc = strstr(sLineWord, "connectorId");
  				  	  	memset(sstr ,0, sizeof(sstr) );
  				  	  	while (loc[strlen("connectorId")+2+c] != ',')
  				  	  	{
  				  	  		sstr[c] = loc[strlen("connectorId")+2+c];
  				  	  		//printf("i=%d sstr=%c\n",c, sstr[c]);
  				  	  		c++;
  				  	  	}
  				  	  	sstr[c] = '\0';
  				  	  	tempconnectorIdInt = atoi(sstr);
#endif

  				  	  	//***********validFrom**************/
  				  	  	c = 0;
  				  	  	loc = strstr(sLineWord, "validFrom");
  				  	  	if(loc != NULL)
  				  	  	{
  				  	  		memset(sstr ,0, sizeof(sstr) );
  				  	  		while (loc[3+strlen("validFrom")+c] != '\"')
  				  	  		{
  				  	  			sstr[c] = loc[3+strlen("validFrom")+c];
  				  	  			c++;
  				  	  		}
  				  	  		sstr[c] = '\0';
  				  	  		strcpy(tempvalidFromStr,sstr);
  				  	  	}
  				  	  	else
  				  	  	{
  				  	  		strcpy(tempvalidFromStr,"");
  				  	  	}

  				  	  	//**********startSchedule**********/
  				  	  	c = 0;
  				  	  	loc = strstr(sLineWord, "startSchedule");
  				  	  	memset(sstr ,0, sizeof(sstr) );
  				  	  	while (loc[3+strlen("startSchedule")+c] != '\"')
  				  	  	{
  				  	  		sstr[c] = loc[3+strlen("startSchedule")+c];
  				  	  		c++;
  				  	  	}
  				  	  	sstr[c] = '\0';
  				  	  	strcpy(tempstartScheduleStr, sstr);

  				  	  	//**********startSchedule**********/
  				  	  	c = 0;
  				  	  	loc = strstr(sLineWord, "chargingRateUnit");
  				  	  	memset(sstr ,0, sizeof(sstr) );
  				  	  	while (loc[3+strlen("chargingRateUnit")+c] != '\"')
  				  	  	{
  				  	  	 	sstr[c] = loc[3+strlen("chargingRateUnit")+c];
  				  	  	 	c++;
  				  	  	}
  				  	  	sstr[c] = '\0';
  				  	  	strcpy(tempchargingRateUnitStr, sstr);

  				  	  	//**********minChargingRate*******/
  				  	  	c = 0;
  				  	  	loc = strstr(sLineWord, "minChargingRate");
  				  	  	if(loc != NULL)
  				  	  	{
  				  	  		memset(sstr ,0, sizeof(sstr) );
  				  	  		while ((loc[2+strlen("minChargingRate")+c] != ',')&&(loc[2+strlen("minChargingRate")+c] != '}'))
  				  	  		{
  				  	  			sstr[c] = loc[2+strlen("minChargingRate")+c];
  				  	  			c++;
  				  	  		}
  				  	  		sstr[c] = '\0';
  				  	  		tempminChargingRateFloat = atof(sstr);
  				  	  	}
  				  	  	else
  				  	  	{
  				  	  		tempminChargingRateFloat = 0.0;
  				  	  	}

  				  	   	//
  				  	  	strptime(tempstartScheduleStr, "%Y-%m-%dT%H:%M:%S", &tp);
  				  	  	tp.tm_isdst = -1;
  				  	  	time_t utc = mktime(&tp);
  				  	  	time_t t = time(NULL);
  				  	  	diff_t = difftime(t, utc);

  				  	  	DEBUG_INFO("diff_t=%f\n",diff_t);
  				  	  	//parsing strings to words
  				  	  	i = 0;
  				  	  	loc = strstr(sLineWord, "chargingSchedulePeriod");
  				  	  	loc = loc+3+strlen("chargingSchedulePeriod");
  				  	  	pch = strtok(loc ,"{");
  				  	  	while (pch != NULL)
  				  	  	{
  				  	  		strcpy(SchedulePeriodList[i], pch);
  				  	  		pch = strtok (NULL, "{");
  				  	  		i = i + 1;
  				  	  	}
  				  	  	n_SchedulePeriods = i;

  				  	  	for(int i=0;i<n_SchedulePeriods;i++)
  				  	  	{
  				  	  		//*************startPeriod****************/
  				  	  		c = 0;
  				  	  		loc = strstr(SchedulePeriodList[i], "startPeriod");
  				  	  		memset(sstr ,0, sizeof(sstr) );
  				  	  		while (loc[strlen("startPeriod")+2+c] != ',')
  				  	  		{
  				  	  			sstr[c] = loc[strlen("startPeriod")+2+c];
  				  	  			 //printf("i=%d sstr=%c\n",c, sstr[c]);
  				  	  			c++;
  				  	  		}
  				  	  		sstr[c] = '\0';
  				  	  		tempStartPeriodInt = atoi(sstr);

  				  	  		//*************limit****************/
  				  	  		c = 0;
  				  	  		loc = strstr(SchedulePeriodList[i], "limit");
  				  	  		memset(sstr ,0, sizeof(sstr) );
  				  	  		while (loc[strlen("limit")+2+c] != ',')
  				  	  		{
  				  	  			sstr[c] = loc[strlen("limit")+2+c];
  				  	  			//printf("i=%d sstr=%c\n",c, sstr[c]);
  				  	  			c++;
  				  	  		}
  				  	  		sstr[c] = '\0';
  				  	  		tempLimitInt = atof(sstr);

  				  	  		//*************numberPhases****************/
  				  	  		c = 0;
  				  	  		loc = strstr(SchedulePeriodList[i], "numberPhases");
  				  	  		memset(sstr ,0, sizeof(sstr) );
  				  	  		while (loc[strlen("numberPhases")+2+c] != '}')
  				  	  		{
  				  	  			sstr[c] = loc[strlen("numberPhases")+2+c];
  				  	  			//printf("i=%d sstr=%c\n",c, sstr[c]);
  				  	  			c++;
  				  	  		}
  				  	  		sstr[c] = '\0';
  				  	  		tempNumberPhasesInt = atoi(sstr);


  				  	  		TxProfile.Duration = durationInt;
  				  	  		TxProfile.TotalPeriod = n_SchedulePeriods;
  				  	  		TxProfile.Period[i].Limit = tempLimitInt;
  				  	  		TxProfile.Period[i].NumberPhases = tempNumberPhasesInt;
  				  	  		TxProfile.Period[i].StartPeriod = tempStartPeriodInt;
  				  	  	}

  				  	  	if(MinChargingRate < tempminChargingRateFloat)
  				  	  		MinChargingRate = tempminChargingRateFloat;

  				  	  	if(confirmPeriods < n_SchedulePeriods)
  				  	  		confirmPeriods = n_SchedulePeriods;
  				  	  	}

  				  	  	fclose(fptr1);

  				  	}

  			}// the end of ACCESS TxProfile

  			DEBUG_INFO("handleGetCompositeScheduleRequest 10\n");


  			//CompositeSchedule
  			int period=0;



  			if((TxDefaultProfileFileIsNull==FALSE) && (ChargePointMaxProfileIsNull==FALSE) && (TxProfileIsNull==FALSE) )
  			{
  				for(int k=0; k < TxProfile.TotalPeriod;k++)
  				{
  					if(TxProfile.Period[k].Limit < ChargePointMaxProfile.Period[0].Limit)
  					{
  				  		ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].Limit = TxProfile.Period[k].Limit;
  			  			ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].NumberPhases = TxProfile.Period[k].NumberPhases;
  			  			ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].StartPeriod = TxProfile.Period[k].StartPeriod;
  			  			period = period + 1;
  					}
  					else
  					{
  						if( (TxProfile.Period[k-1].Limit >= ChargePointMaxProfile.Period[0].Limit) && (TxProfile.Period[k].Limit >= ChargePointMaxProfile.Period[0].Limit))
  						{

  						}
  						else
  						{
  							ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].Limit = ChargePointMaxProfile.Period[0].Limit;
  							ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].NumberPhases = TxProfile.Period[k].NumberPhases;
  							ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].StartPeriod = TxProfile.Period[k].StartPeriod;
  							period = period + 1;
  						}

  					}
  				}

  				for(int l=0; l < TxDefaultProfile.TotalPeriod;l++)
  				{
  					if((TxDefaultProfile.Period[l].StartPeriod < durationInt)&&(TxDefaultProfile.Period[l].StartPeriod > ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period-1].StartPeriod))
  					{
  						if(TxDefaultProfile.Period[l].Limit < ChargePointMaxProfile.Period[0].Limit)
  						{
  						  	ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].Limit = TxDefaultProfile.Period[l].Limit;
  						}
  						else
  						{
  							ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].Limit = ChargePointMaxProfile.Period[0].Limit;

  						}
  						ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].NumberPhases = TxDefaultProfile.Period[l].NumberPhases;
  					  	ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].StartPeriod = TxDefaultProfile.Period[l].StartPeriod;

  						period = period + 1;
  				   }


  			    }

  				if((TxDefaultProfile.Duration < durationInt) && (ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period-1].Limit) < ChargePointMaxProfile.Period[0].Limit)
  				{
  					ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].Limit = ChargePointMaxProfile.Period[0].Limit;
  			  		ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].NumberPhases = ShmOCPP16Data->GetCompositeSchedule[0].ResponseChargingSchedule.ChargingSchedulePeriod[period-1].NumberPhases;
  			  		ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[period].StartPeriod = TxDefaultProfile.Duration;
  			  		period = period + 1;

  				}

  			}
  			else if((TxDefaultProfileFileIsNull==FALSE) && (ChargePointMaxProfileIsNull==FALSE) && (TxProfileIsNull==TRUE) )
  			{
  				for(int l=0; l < TxDefaultProfile.TotalPeriod;l++)
  				{
  					if(TxProfile.Period[l].Limit < ChargePointMaxProfile.Period[0].Limit)
  					{
  					  	ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].Limit = TxDefaultProfile.Period[l].Limit;
  					  	ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].NumberPhases = TxDefaultProfile.Period[l].NumberPhases;
  					  	ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].StartPeriod = TxDefaultProfile.Period[l].StartPeriod;
  					  	period = period + 1;
  					}
  					else
  					{

  	  				  	ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].Limit = ChargePointMaxProfile.Period[0].Limit;
  	  				  	ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].NumberPhases = TxDefaultProfile.Period[l].NumberPhases;
  	  				  	ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].StartPeriod = TxDefaultProfile.Period[l].StartPeriod;
  	  				  	period = period + 1;
  					}
  				}

  			}
  			else if((TxDefaultProfileFileIsNull==FALSE) && (ChargePointMaxProfileIsNull==TRUE) && (TxProfileIsNull==TRUE) )
  		  	{
  		  		for(int l=0; l < TxDefaultProfile.TotalPeriod;l++)
  		  		{
  		  	  		ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].Limit = TxDefaultProfile.Period[l].Limit;
  		  	  		ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].NumberPhases = TxDefaultProfile.Period[l].NumberPhases;
  		  	  		ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingSchedulePeriod[l].StartPeriod = TxDefaultProfile.Period[l].StartPeriod;
  		  	  		period = period + 1;
  		  		}

  		  	}

  			confirmPeriods = period;
  			//DEBUG_INFO("confirmPeriods=%d\n",confirmPeriods);

  			//* 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[CompositeSceduleIndex].ResponseChargingSchedule.StartSchedule,buf);
  			ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.Duration = durationInt;
  			//DEBUG_INFO(" debug  11\n");

  			strcpy((char *)ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.ChargingRateUnit, tempchargingRateUnitStr );

  			ShmOCPP16Data->GetCompositeSchedule[CompositeSceduleIndex].ResponseChargingSchedule.MinChargingRate = MinChargingRate;
  			sprintf(comfirmstr, "%s", GetCompositeScheduleStatusStr[GetCompositeScheduleStatus_Accepted] );
  		}
  		else
  		{

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

	sendGetCompositeScheduleConfirmation(uuid,comfirmstr, connectorIdInt, confirmPeriods);

	return result;
}

int handleGetConfigurationRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
//	struct json_object *obj=NULL, *key=NULL;// *jsonitem;
	//struct json_object *jsonitem;
	int MaxKeySupported = 0;
	int n_keys = 0;
	char requestKey[43][50]={0};
	char search[]="[";
	char sstr[500]={ 0 };
	//int pos;
	int l, c = 0;
	int i = 0;
	char *delim = "\",\"";
	char * pch;
	char *loc = strstr(payload, search);


	//*********************  Parsing String ***********************************/

	if(loc == NULL) {
		DEBUG_INFO("no key match in Configuration \n");
	}
	else {
		//pos = loc - payload;
		l = strlen(loc)-4;
		while (c < l)
		{
			sstr[c] = loc[c+2];
			c++;
		}
		sstr[c] = '\0';

		//parsing strings to words
		pch = strtok(sstr,delim);
	    if(pch == NULL)
	    {
	    	strcpy(requestKey[0], sstr);
	    }
	    else
	    {
	    	while (pch != NULL)
	    	{
	    		strcpy(requestKey[i], pch);
	    	   	pch = strtok (NULL, delim);
	    		i = i + 1;
	    	}

	    	n_keys = i;
	    }


	}

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

	MaxKeySupported = GetConfigurationMaxKeysNUM;//atoi(ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemData);

	memset(ShmOCPP16Data->GetConfiguration.Key, 0 ,sizeof(struct StructConfigurationKeyItems)*MaxKeySupported);
	memset(ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey, 0, sizeof(struct StructConfigurationKey)*MaxKeySupported);

	if(n_keys != 0)
	{
		for(int i=0;i<n_keys;i++)
		{
			getKeyValue(requestKey[i]);
			//json_object_put(jsonitem);
	   }
	}
	else
	{
		DEBUG_INFO("There is no key in Message, get all configuration\n");
		getKeyValue("");
	}

	processUnkownKey();
	sendGetConfigurationConfirmation(uuid);

	return result;
}

int handleGetDiagnosticsRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
	//void *ret; //
	char fnamePlusPath[50]="";
	char fname[16]="";
	pthread_t t; // pthread 變數
	time_t rawtime;
	struct tm * timeinfo;

	//system("exec /root/Module_WebService 'log' 6"); // for OCTT TEST
	system("exec /root/logPackTools 'log' 6");

	//char buffer [128];
	time (&rawtime);
	//printf("%ld\n", rawtime);
	timeinfo = localtime (&rawtime);
	strftime (fnamePlusPath,sizeof(fnamePlusPath),"../mnt/%4Y-%2m.zip",timeinfo);
	DEBUG_INFO("fnamePlusPath =%s\n",fnamePlusPath);
	if((access(fnamePlusPath,F_OK))!=-1)
	{
		DEBUG_INFO("fnamePlusPath exist.\n");
		strftime (fname,sizeof(fname),"%4Y-%2m.zip",timeinfo);
	}
	else
	{
		DEBUG_INFO("fnamePlusPath not exist!\n");
	}


	sendGetDiagnosticsConfirmation(uuid,fname/*(char*) ret*/);
	pthread_create(&t, NULL, GetDiagnosticsProcess, payload);
    pthread_join(t, NULL/*&ret*/);

	return result;
}


void* GetDiagnosticsProcess(void* data)
{
	mtrace();
	int retriesInt=0, retryIntervalInt=0;
	char locationstr[100]={0}, startTimestr[30]={0}, stopTimestr[30]={0} ;
	int retriesIsNULL,retryIntervalIsNULL, startTimeIsNULL, stopTimeIsNULL;
	char protocol[10]={0}, user[50]={0},password[50]={0},host[50]={0}, path[50]={0}, ftppath[60]={0},host1[50]={0},path1[50]={0};
	int port=0;
	char fnamePlusPath[50]="";//="00000_2019-06-09_160902_CSULog.zip";
	char fname[16]="";
	char sstr[260]={ 0 };//sstr[200]={ 0 };
	int c = 0;
	char *loc;
	int isSuccess = FALSE;
	char ftpbuf[200]={0};
	//char temp[100]={0};
	char * pch;

//	[2,"137d88c7-a403-4ead-bb2d-fc6ec90531c1","GetDiagnostics",{"location":"ftp://ipc_ui:pht2016@ftp.phihong.com.tw/DC/log/","retries":0,"retryInterval":0,"startTime":"0001-01-01T00:00:00.000Z","stopTime":"0001-01-01T00:00:00.000Z"}]
	char *str = (char*) data; // ?��?輸入資�?

	retriesIsNULL = retryIntervalIsNULL = startTimeIsNULL = stopTimeIsNULL = FALSE;

	DEBUG_INFO("sendDiagnosticsStatusNotificationRequest 1\n");
	sendDiagnosticsStatusNotificationRequest(DiagnosticsStatusStr[DiagnosticsStatus_Uploading]);

	//****************location*******************/
	c = 0;
	memset(sstr ,0, sizeof(sstr) );
	loc = strstr(str, "location");
	while (loc[3+strlen("location")+c] != '\"')
	{
		sstr[c] = loc[3+strlen("location")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(locationstr,sstr);

	if(strcmp(locationstr,"")==0)
	{
		DEBUG_INFO("location is <Empty>!\n");
		sendDiagnosticsStatusNotificationRequest(DiagnosticsStatusStr[DiagnosticsStatus_UploadFailed]);
		goto end;

	}

	//****************retries*******************/
	c = 0;
	loc = strstr(str, "retries");
	if(loc == NULL)
	{
		retriesIsNULL = TRUE;
	}
	else
	{
		while (loc[strlen("retries")+2+c] != ',')
		{
			sstr[c] = loc[strlen("retries")+2+c];
			c++;
		}
		sstr[c] = '\0';
		retriesInt = atoi(sstr);
	}

	if(retriesIsNULL == TRUE)
	{
		retriesInt = 0;
	}

	//****************retryInterval*******************/
	c = 0;
	loc = strstr(str, "retryInterval");
	if(loc == NULL)
	{
		retryIntervalIsNULL = TRUE;
	}
	else
	{
		while (loc[strlen("retryInterval")+2+c] != ',')
		{
			sstr[c] = loc[strlen("retryInterval")+2+c];
			c++;
		}
		sstr[c] = '\0';
		retryIntervalInt = atoi(sstr);
	}

	//****************startTime*******************/
	c = 0;
	memset(sstr ,0, sizeof(sstr) );
	loc = strstr(str, "startTime");
	if(loc == NULL)
	{
		startTimeIsNULL = TRUE;
	}
	else
	{
		while (loc[3+strlen("startTime")+c] != '\"')
		{
			sstr[c] = loc[3+strlen("startTime")+c];
			c++;
		}
		sstr[c] = '\0';
		strcpy(startTimestr,sstr);
	}


	//****************stopTime*******************/
	c = 0;
	memset(sstr ,0, sizeof(sstr) );
	loc = strstr(str, "stopTime");
	if(loc == NULL)
	{
		stopTimeIsNULL = TRUE;
	}
	else
	{
		while (loc[3+strlen("stopTime")+c] != '\"')
		{
			sstr[c] = loc[3+strlen("stopTime")+c];
			c++;
		}
		sstr[c] = '\0';
		strcpy(stopTimestr,sstr);
	}

	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);
#if 0 // remove for temporally
	//zip files in /Storage
	system("exec /root/logPackTools 'log' 6");

#endif

//	system("exec /root/Module_WebService 'log' 6");

	time_t rawtime;
	struct tm * timeinfo;
	//char buffer [128];
	time (&rawtime);
	//printf("%ld\n", rawtime);
	timeinfo = localtime (&rawtime);
	strftime (fnamePlusPath,sizeof(fnamePlusPath),"../mnt/%4Y-%2m.zip",timeinfo);
	strftime (fname,sizeof(fname),"%4Y-%2m.zip",timeinfo);
	DEBUG_INFO("fnamePlusPath =%s\n",fnamePlusPath);
	if((access(fnamePlusPath,F_OK))!=-1)
	{
		DEBUG_INFO("fnamePlusPath exist.\n");
	}
	else
	{
		DEBUG_INFO("fnamePlusPath 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
	{
		DEBUG_INFO("pch=%s\n", pch);
		sscanf(locationstr,"%[^:]:%*2[/]%[^:]:%[^@]@%[^:]:%i/%199[^\n]",
				   protocol, user, password, host, &port, path);
	}

	if(strcmp(protocol,"ftp")!=0)
	{
		DEBUG_INFO("protocol is not ftp!\n");
		sendDiagnosticsStatusNotificationRequest(DiagnosticsStatusStr[DiagnosticsStatus_UploadFailed]);
		goto end;

	}

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

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

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

	}

	memset(filenametemp, 0, sizeof(filenametemp));
	strncpy(filenametemp, ftppath+(ftppathlen-i+1), i+1);
	filenametemp[i+1] = 0;


	    //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, fnamePlusPath, fname);
    	 sleep(retryIntervalInt);
    }while((!isSuccess)&&(retriesInt > 0 && retriesInt --));

	if(!isSuccess)
	{
	   //BulldogUtil.sleepMs(interval*1000);
		DEBUG_INFO("Diagnostics fail.\n");
		sendDiagnosticsStatusNotificationRequest(DiagnosticsStatusStr[DiagnosticsStatus_UploadFailed]);
	}
	else
	{
		DEBUG_INFO("sendDiagnosticsStatusNotificationRequest Uploaded\n");
		sendDiagnosticsStatusNotificationRequest(DiagnosticsStatusStr[DiagnosticsStatus_Uploaded]);
		//isUpdateRequest = TRUE;
	}

end:
//	json_object_put(obj);
	DiagnosticsStatusNotificationStatus = 0; //Idle
	pthread_exit(NULL/*(void *) fname*/); // ?��?子執行�?

}




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

	if(strcmp((const char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData, "FALSE") == 0)
	{
		DEBUG_INFO("LocalAuthListEnabled is FALSE \n");
		localversion = -1;
	}
	else
	{
		DEBUG_INFO("handle GetLocalListVersionRequest OCPP_getListVerion \n");
		OCPP_getListVerion();
	}


	//from db.OCPP_getListVerion
	ShmOCPP16Data->GetLocalListVersion.ResponseListVersion = localversion;
	//ShmOCPP16Data->MsMsg.bits.GetLocalListVersionReq = 1;
	sendGetLocalListVersionConfirmation(uuid,"");
	//ShmOCPP16Data->MsMsg.bits.GetLocalListVersionConf = 1;

	return result;
}

int handleRemoteStartRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
	int connectorIdInt=0, chargingProfileIdInt=0, transactionIdInt=0, stackLevelInt=0,
		durationInt=0, startPeriodInt[10]={0}, numberPhasesInt[10]={0};
	char idTagstr[20]={0}, chargingProfilePurposestr[30]={0}, chargingProfileKindstr[14]={0}, recurrencyKindstr[10]={0},
		validFromstr[30]={0}, validTostr[30]={0}, startSchedulestr[30]={0}, chargingRateUnitstr[4]={0};
	int connectorIdIsNULL,chargingProfileIsNULL,transactionIdIsNULL,recurrencyKindIsNULL,validFromIsNULL,validToIsNULL,durationIsNULL,startScheduleIsNULL,minChargingRateIsNULL,numberPhasesIsNULL;
	float minChargingRateflaot=0.0, limitflaot[10]={0.0};
	int chargingSchedulePeriodCount = 0;
	char sstr[30]={ 0 };//sstr[200]={ 0 };
	int c = 0;
	char *loc;
	char comfirmstr[20]={0};

	DEBUG_INFO("handleRemoteStartRequest ...\n");
	if(server_pending == TRUE)
	{
		return 0;
	}

	connectorIdIsNULL = chargingProfileIsNULL = transactionIdIsNULL = recurrencyKindIsNULL = validFromIsNULL = validToIsNULL = durationIsNULL = startScheduleIsNULL = minChargingRateIsNULL = numberPhasesIsNULL= FALSE;

	//**********connectorId****************/
	c = 0;
	memset(sstr ,0, sizeof(sstr) );
	loc = strstr(payload, "connectorId");
	if(loc == NULL)
	{
		connectorIdIsNULL = TRUE;
	}
	else
	{
		while ((loc[strlen("connectorId")+2+c] != '}') && (loc[strlen("connectorId")+2+c] != ','))
		{
			sstr[c] = loc[strlen("connectorId")+2+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		connectorIdInt = atoi(sstr);
	}


	if(connectorIdIsNULL == TRUE)  // need to discussion
	{
		strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
		goto end;
	}

	//****************idTag*******************/
	c = 0;
	memset(sstr ,0, sizeof(sstr) );
	loc = strstr(payload, "idTag");
	while (loc[3+strlen("idTag")+c] != '\"')
	{
		sstr[c] = loc[3+strlen("idTag")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(idTagstr,sstr);



	//****************chargingProfile*******************/
	c = 0;
	memset(sstr ,0, sizeof(sstr) );
	loc = strstr(payload, "chargingProfile");
	if(loc == NULL)
	{
		chargingProfileIsNULL = TRUE;
	}
	else
	{
		//****************chargingProfileId*******************/
		c=0;
		loc = strstr(payload, "chargingProfileId");
		memset(sstr ,0, sizeof(sstr) );
		while ((loc[strlen("chargingProfileId")+2+c] != '}') && (loc[strlen("chargingProfileId")+2+c] != ','))
		{
			sstr[c] = loc[strlen("chargingProfileId")+2+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		chargingProfileIdInt = atoi(sstr);

		//****************transactionId*******************/

		loc = strstr(payload, "transactionId");
		if(loc == NULL)
		{
			transactionIdIsNULL = TRUE;
		}
		else
		{
			c=0;
			memset(sstr ,0, sizeof(sstr) );
			while ((loc[strlen("transactionId")+2+c] != '}') && (loc[strlen("transactionId")+2+c] != ','))
			{
				sstr[c] = loc[strlen("transactionId")+2+c];
				//printf("i=%d sstr=%c\n",c, sstr[c]);
				c++;
			}
			sstr[c] = '\0';
			transactionIdInt = atoi(sstr);
		}

		//****************stackLevel*******************/
		c=0;
		loc = strstr(payload, "stackLevel");
		memset(sstr ,0, sizeof(sstr) );
		while ((loc[strlen("stackLevel")+2+c] != '}') && (loc[strlen("stackLevel")+2+c] != ','))
		{
			sstr[c] = loc[strlen("stackLevel")+2+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		stackLevelInt = atoi(sstr);

		//****************chargingProfilePurpose*******************/
		c = 0;
		memset(sstr ,0, sizeof(sstr) );
		loc = strstr(payload, "chargingProfilePurpose");
		while (loc[3+strlen("chargingProfilePurpose")+c] != '\"')
		{
			sstr[c] = loc[3+strlen("chargingProfilePurpose")+c];
			c++;
		}
		sstr[c] = '\0';
		strcpy(chargingProfilePurposestr,sstr);

		//****************chargingProfileKind*******************/
		c = 0;
		memset(sstr ,0, sizeof(sstr) );
		loc = strstr(payload, "chargingProfileKind");
		while (loc[3+strlen("chargingProfileKind")+c] != '\"')
		{
			sstr[c] = loc[3+strlen("chargingProfileKind")+c];
			c++;
		}
		sstr[c] = '\0';
		strcpy(chargingProfileKindstr,sstr);

		//****************recurrencyKind*******************/
		loc = strstr(payload, "recurrencyKind");
		if(loc == NULL)
		{
			recurrencyKindIsNULL = TRUE;
		}
		else
		{
			c = 0;
			memset(sstr ,0, sizeof(sstr) );
			while (loc[3+strlen("recurrencyKind")+c] != '\"')
			{
				sstr[c] = loc[3+strlen("recurrencyKind")+c];
				c++;
			}
			sstr[c] = '\0';
			strcpy(recurrencyKindstr,sstr);
		}

		//****************validFrom*******************/
		loc = strstr(payload, "validFrom");
		if(loc == NULL)
		{
			validFromIsNULL = TRUE;
		}
		else
		{
			c = 0;
			memset(sstr ,0, sizeof(sstr) );
			while (loc[3+strlen("validFrom")+c] != '\"')
			{
				sstr[c] = loc[3+strlen("validFrom")+c];
				c++;
			}
			sstr[c] = '\0';
			strcpy(validFromstr,sstr);
		}

		//****************validTo*******************/
		loc = strstr(payload, "validTo");
		if(loc == NULL)
		{
			validToIsNULL = TRUE;
		}
		else
		{
			c = 0;
			memset(sstr ,0, sizeof(sstr) );
			while (loc[3+strlen("validTo")+c] != '\"')
			{
				sstr[c] = loc[3+strlen("validTo")+c];
				c++;
			}
			sstr[c] = '\0';
			strcpy(validTostr,sstr);
		}

		//****************chargingSchedule*******************/
		loc = strstr(payload, "chargingSchedule");
		if(loc != NULL)
		{
			//****************duration*******************/

			loc = strstr(payload, "duration");

			if(loc == NULL)
			{
				durationIsNULL = TRUE;
			}
			else
			{
				c=0;
				memset(sstr ,0, sizeof(sstr) );
				while ((loc[strlen("duration")+2+c] != '}') && (loc[strlen("duration")+2+c] != ','))
				{
					sstr[c] = loc[strlen("duration")+2+c];
					//printf("i=%d sstr=%c\n",c, sstr[c]);
					c++;
				}
				sstr[c] = '\0';
				durationInt = atoi(sstr);

			}

			//****************startSchedule******************/

			loc = strstr(payload, "startSchedule");
			if(loc == NULL)
			{
				startScheduleIsNULL = TRUE;
			}
			else
			{
				c = 0;
				memset(sstr ,0, sizeof(sstr) );
				while (loc[3+strlen("startSchedule")+c] != '\"')
				{
					sstr[c] = loc[3+strlen("startSchedule")+c];
					c++;
				}
				sstr[c] = '\0';
				strcpy(startSchedulestr,sstr);
			}

			//****************chargingRateUnit*******************/
			c = 0;
			memset(sstr ,0, sizeof(sstr) );
			loc = strstr(payload, "chargingRateUnit");
			while (loc[3+strlen("chargingRateUnit")+c] != '\"')
			{
				sstr[c] = loc[3+strlen("chargingRateUnit")+c];
				c++;
			}
			sstr[c] = '\0';
			strcpy(chargingRateUnitstr,sstr);

			//****************minChargingRate*******************/
			loc = strstr(payload, "minChargingRate");
			if(loc == NULL)
			{
				minChargingRateIsNULL = TRUE;
			}
			else
			{
				c=0;
				memset(sstr ,0, sizeof(sstr) );
				while ((loc[strlen("minChargingRate")+2+c] != '}') && (loc[strlen("minChargingRate")+2+c] != ','))
				{
					sstr[c] = loc[strlen("minChargingRate")+2+c];
					//printf("i=%d sstr=%c\n",c, sstr[c]);
					c++;
				}
				sstr[c] = '\0';
				minChargingRateflaot = atof(sstr);
			}

			//****************chargingSchedulePeriod count*******************/
			int what_len = strlen("startPeriod");

			char *where = payload;


			while ((where = strstr(where, "startPeriod"))) {
				        where += what_len;
				        chargingSchedulePeriodCount++;
			}

			where = payload;

			for(int periodNums=0; periodNums < chargingSchedulePeriodCount; periodNums++)
			{
				//****************startPeriod*******************/
				c=0;
				loc = strstr(where, "startPeriod");
				memset(sstr ,0, sizeof(sstr) );
				while ((loc[strlen("startPeriod")+2+c] != '}') && (loc[strlen("startPeriod")+2+c] != ','))
				{
					sstr[c] = loc[strlen("startPeriod")+2+c];
					//printf("i=%d sstr=%c\n",c, sstr[c]);
					c++;
				}
				sstr[c] = '\0';
				startPeriodInt[periodNums] = atoi(sstr);

				//****************limit*******************/
				c=0;
				loc = strstr(where, "limit");
				memset(sstr ,0, sizeof(sstr) );
				while ((loc[strlen("limit")+2+c] != '}') && (loc[strlen("limit")+2+c] != ','))
				{
					sstr[c] = loc[strlen("limit")+2+c];
					//printf("i=%d sstr=%c\n",c, sstr[c]);
					c++;
				}
				sstr[c] = '\0';
				limitflaot[periodNums] = atof(sstr);

				//****************numberPhases*******************/
				loc = strstr(where, "numberPhases");
				if(loc == NULL)
				{
					numberPhasesIsNULL = TRUE;
				}
				else
				{
					c=0;
					memset(sstr ,0, sizeof(sstr) );
					while ((loc[strlen("numberPhases")+2+c] != '}') && (loc[strlen("numberPhases")+2+c] != ','))
					{
						sstr[c] = loc[strlen("numberPhases")+2+c];
						//printf("i=%d sstr=%c\n",c, sstr[c]);
						c++;
					}
					sstr[c] = '\0';
					numberPhasesInt[periodNums] = atoi(sstr);
				}

				where = loc;

			}
		}

	}

	/*

	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((connectorIdIsNULL == FALSE)&&(connectorIdInt > 0) && ((connectorIdInt -1) <= gunTotalNumber/*(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
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == (connectorIdInt -1))
				{

					if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].ReservationId != 0)&&(strcmp((const char *)ShmSysConfigAndInfo->SysConfig.UserId, idTagstr) == 0))
					{
						//Reserved
						DEBUG_INFO("Reserved now !!!The idTag matches the idTag of Reservation!!!\n");
					}
					else if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].ReservationId != 0)&&(strcmp((const char *)ShmSysConfigAndInfo->SysConfig.UserId, idTagstr) != 0))
					{
						//Reserved
						DEBUG_INFO("Reserved now !!! The idTag does NOT match the idTag of Reservation!!! Reject it!!!\n");
						strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
						goto end;
					}
					else
					{
						if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus != SYS_MODE_IDLE)				//S_IDLE
								&& (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus != SYS_MODE_PREPARING ) 	//S_PRECHARGE
								&& (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus != SYS_MODE_PREPARE_FOR_EV ) 	//S_PREPARING_FOR_EV
								&& (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus != SYS_MODE_PREPARE_FOR_EVSE ))   // S_PREPARING_FOR_EVSE
						{
							strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
							goto end;
						}

					}//END FOR ELSE

				}
			}// END FOR CHAdeMO_QUANTITY

			for (int index = 0; index < CCS_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == (connectorIdInt -1))
				{
					if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].ReservationId != 0)&&(strcmp((const char *)ShmSysConfigAndInfo->SysConfig.UserId, idTagstr) == 0))
					{
						//Reserved
						DEBUG_INFO("Reserved now !!!The idTag matches the idTag of Reservation!!!\n");
					}
					else if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].ReservationId != 0)&&(strcmp((const char *)ShmSysConfigAndInfo->SysConfig.UserId, idTagstr) != 0))
					{
						//Reserved
						DEBUG_INFO("Reserved now !!! The idTag does NOT match the idTag of Reservation!!! Reject it!!!\n");
						strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
						goto end;
					}
					else
					{
						if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus != SYS_MODE_IDLE)          //S_IDLE
							&& (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus != SYS_MODE_PREPARING)   	//S_PRECHARGE
							&& (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus != SYS_MODE_PREPARE_FOR_EV)   	//S_PREPARING_FOR_EV
							&& (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus != SYS_MODE_PREPARE_FOR_EVSE)) 	// S_PREPARING_FOR_EVSE
						{
							strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
							goto end;
						}

					}// END FOR ELSE
				}
			}// END FOR CCS_QUANTITY

			for (int index = 0; index < GB_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == (connectorIdInt -1))
				{
					if((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].ReservationId != 0)&&(strcmp((const char *)ShmSysConfigAndInfo->SysConfig.UserId, idTagstr) == 0))
					{
						//Reserved
						DEBUG_INFO("Reserved now !!!The idTag matches the idTag of Reservation!!!\n");
					}
					else if((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].ReservationId != 0)&&(strcmp((const char *)ShmSysConfigAndInfo->SysConfig.UserId, idTagstr) != 0))
					{
						//Reserved
						DEBUG_INFO("Reserved now !!! The idTag does NOT match the idTag of Reservation!!! Reject it!!!\n");
						strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
						goto end;
					}
					else
					{
						if((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus != SYS_MODE_IDLE)         	//S_IDLE
							&& (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus != SYS_MODE_PREPARING)		//S_PRECHARGE
							&& (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus != SYS_MODE_PREPARE_FOR_EV)		//S_PREPARING_FOR_EV
							&& (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus != SYS_MODE_PREPARE_FOR_EVSE)) 		// S_PREPARING_FOR_EVSE
						{
							strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
							goto end;
						}

					}// END FOR ELSE
				}
			} // END FOR GB_QUANTITY

		}
		else
		{
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == (connectorIdInt -1))
				{

					if((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].ReservationId != 0)&&(strcmp((const char *)ShmSysConfigAndInfo->SysConfig.UserId, idTagstr) == 0))
					{
						//Reserved
						DEBUG_INFO("Reserved now !!!The idTag matches the idTag of Reservation!!!\n");
					}
					else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].ReservationId != 0)&&(strcmp((const char *)ShmSysConfigAndInfo->SysConfig.UserId, idTagstr) != 0))
					{
						//Reserved
						DEBUG_INFO("Reserved now !!! The idTag does NOT match the idTag of Reservation!!! Reject it!!!\n");
						strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
						goto end;
					}
					else
					{
						if((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus != SYS_MODE_IDLE)				//S_IDLE
							&& (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus != SYS_MODE_PREPARING) 	//S_PRECHARGE
							&& (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus != SYS_MODE_PREPARE_FOR_EV) 	//S_PREPARING_FOR_EV
							&& (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus != SYS_MODE_PREPARE_FOR_EVSE))   // S_PREPARING_FOR_EVSE
							{
								strcpy(comfirmstr, RemoteStartStopStatusStr[RemoteStartStopStatus_Rejected]);
								goto end;
							}

					}//END FOR ELSE
				}
			}// END FOR AC_QUANTITY
		}

		if(chargingProfileIsNULL == FALSE)
		{
			//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(recurrencyKindIsNULL == FALSE) //OPTION
			sprintf((char *)ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.RecurrencyKind, "%s" ,recurrencyKindstr);

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

			if(transactionIdIsNULL == FALSE) // OPTION
			ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.TransactionId = transactionIdInt;

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

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

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

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

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

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


			for(int periodNums=0; periodNums < chargingSchedulePeriodCount; periodNums++)
			{
				//ChargingSchedulePeriod
				ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ChargingSchedule.ChargingSchedulePeriod[periodNums].Limit = limitflaot[periodNums] ;

				if(numberPhasesIsNULL == FALSE)
				{
					ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ChargingProfile.ChargingSchedule.ChargingSchedulePeriod[periodNums].NumberPhases = numberPhasesInt[periodNums];

				}

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

			}

			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(connectorIdIsNULL == FALSE)
	ShmOCPP16Data->RemoteStartTransaction[connectorIdInt -1].ConnectorId = connectorIdInt;

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

	//OCPP send RemoteStartConfirmation by first.
	sendRemoteStartConfirmation(uuid, comfirmstr);

	return result;
}

int handleRemoteStopTransactionRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
	int match = FALSE;
	int GunNO = 0;
	int transactionIdInt=0;
	int transactionIdIsNULL= FALSE;
	char sstr[16]={ 0 };//sstr[200]={ 0 };
	int c = 0;
	char *loc;
	char comfirmstr[20];

//[2,"ff522854-0dea-436e-87ba-23a229269994","RemoteStopTransaction",{"transactionId":1373618380}]

	DEBUG_INFO("handleRemoteStopTransactionRequest...\n");

	if(server_pending == TRUE)
	{

		return 0;
	}


	c=0;
	loc = strstr(payload, "transactionId");

	if(loc == NULL)
	{
		transactionIdIsNULL= TRUE;
	}
	else
	{
		memset(sstr ,0, sizeof(sstr) );
		while ((loc[strlen("transactionId")+2+c] != '}') && (loc[strlen("transactionId")+2+c] != ','))
		{
			sstr[c] = loc[strlen("transactionId")+2+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		transactionIdInt = atoi(sstr);
	}

	if(transactionIdIsNULL == FALSE)
	{

		for(int gun_index=0;gun_index < gunTotalNumber/*(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY)*/;gun_index++)
	    {
			if(ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId == transactionIdInt)
	        {
				//check Transaction active

				if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
				{
					for (int index = 0; index < CHAdeMO_QUANTITY; index++)
					{
						if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == gun_index)
						{
							if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_CHARGING) // S_CHARGING
							{
								match = TRUE;
								GunNO = gun_index;
							}
						}
					}// END FOR CHAdeMO_QUANTITY

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

						}
					}// END FOR CCS_QUANTITY

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

						}
					}// END FOR GB_QUANTITY
				}
				else
				{
					for (int index = 0; index < AC_QUANTITY; index++)
					{
						if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == gun_index)
						{
							if(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_CHARGING) // S_CHARGING
							{
								match = TRUE;
								GunNO = gun_index;
							}
						}
					}// END FOR CHAdeMO_QUANTITY
				}// END FOR AC ELSE


	        }// CHECK IF ResponseTransactionId == transactionIdInt

	    }//END FOR

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


	  }

	sendRemoteStopTransactionConfirmation(uuid, comfirmstr);
	return result;
}

int handleReserveNowTransactionRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
	int connectorIdInt=0, reservationIdInt=0;
	char expiryDatestr[30]={0}, idTagstr[20]={0},parentIdTagstr[20]={0};
	char comfirmstr[20]={0};
	char sstr[180]={ 0 };
	int c = 0;
	char *loc;
	//char *ptr;

//[2,"1571898416054","ReserveNow",{"connectorId":1,"expiryDate":"2020-06-19T09:10:00.000Z","idTag":"B014EA9C","reservationId":1}]
	//***(1)connectorId ****/
	c=0;
	loc = strstr(payload, "connectorId");
	memset(sstr ,0, sizeof(sstr) );
	while ((loc != NULL) &&(loc[strlen("connectorId")+2+c] != ','))
	{
		sstr[c] = loc[strlen("connectorId")+2+c];
		//printf("i=%d sstr=%c\n",c, sstr[c]);
		c++;
	}
	sstr[c] = '\0';
	connectorIdInt = atoi(sstr);

	//***(2)expiryDate ****/
	loc = strstr(payload, "expiryDate");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while ((loc != NULL) &&(loc[3+strlen("expiryDate")+c] != '\"'))
	{
		sstr[c] = loc[3+strlen("expiryDate")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(expiryDatestr, sstr);

	//***(3)idTag ****/
	loc = strstr(payload, "idTag");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while ((loc != NULL) &&(loc[3+strlen("idTag")+c] != '\"'))
	{
		sstr[c] = loc[3+strlen("idTag")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(idTagstr, sstr);

	//***(4)parentIdTag ****/
	loc = strstr(payload, "parentIdTag");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while ((loc != NULL) &&(loc[3+strlen("parentIdTag")+c] != '\"'))
	{
		sstr[c] = loc[3+strlen("parentIdTag")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(parentIdTagstr, sstr);


	//***(5)reservationId ****/
	c=0;
	loc = strstr(payload, "reservationId");
	memset(sstr ,0, sizeof(sstr) );
	while ((loc != NULL) &&((loc[strlen("reservationId")+2+c] != '}') && (loc[strlen("reservationId")+2+c] != ',')))
	{
			sstr[c] = loc[strlen("reservationId")+2+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
	}
	sstr[c] = '\0';
	reservationIdInt = atoi(sstr);

	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) &&(strcmp((const char *)ShmOCPP16Data->ConfigurationTable.ReservationProfile[ReserveConnectorZeroSupported].ItemData, "FALSE") == 0)) //For OCTT Test case
	{
		strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Rejected]);
		goto end;
	}

	if((connectorIdInt > 0) && ((connectorIdInt -1) <= gunTotalNumber/*(CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY)*/))
	{
		//check Transaction active
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			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 != SYS_MODE_FAULT) //S_FAULT
						{
							if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_IDLE) //S_IDLE
							{
								ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].ReserveNowReq = 1;
								strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Accepted]);
							}
							else if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_MAINTAIN)||(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_DEBUG)) //S_TERMINATING  //else if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 11) || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '9'))
							{
								strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Unavailable]);

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

				}
			} // END FOR CHAdeMO_QUANTITY

			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 != SYS_MODE_FAULT) //S_FAULT
						{

							if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_IDLE) //S_IDLE
							{
								ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].ReserveNowReq = 1;
								strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Accepted]);
							}
							else if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_MAINTAIN) ||(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_DEBUG)) //S_TERMINATING  //else if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == '6') || (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == '9'))
							{
								strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Unavailable]);
							}
							else if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_PREPARING) //S_PRECHARGE
							{
								strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Occupied]);
							}
							else
							{
								strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Rejected]);
							}
						}
						else if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus ==SYS_MODE_FAULT) //S_FAULT
						{
							strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Faulted]);
						}
					}
					else
					{
						//replace reservation
						ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].ReserveNowReq = 1;
						strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Accepted]);

					}

				}
			} // END FOR CCS_QUANTITY

			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 != SYS_MODE_FAULT) //S_FAULT
						{

							if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_IDLE) //S_IDLE
							{
								ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].ReserveNowReq = 1;
								strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Accepted]);
							}
							else if((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_MAINTAIN) || (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_DEBUG)) //S_TERMINATING //else if((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '6') || (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '9'))
							{
								strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Unavailable]);
							}
							else if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_PREPARING) //S_PRECHARGE
							{
								strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Occupied]);
							}
							else
							{
								strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Rejected]);
							}
						}
						else if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus ==SYS_MODE_FAULT) //S_FAULT
						{
							strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Faulted]);
						}
					}
					else
					{
						//replace reservation
						ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].ReserveNowReq = 1;
						strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Accepted]);
					}

				}
			}// END FOR GB_QUANTITY

		}
		else
		{
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == (connectorIdInt -1))
				{

					if(reservationIdInt != ShmSysConfigAndInfo->SysInfo.AcChargingData[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.AcChargingData[index].SystemStatus != SYS_MODE_FAULT) //S_FAULT
						{
							if(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_IDLE) //S_IDLE
							{
								ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].ReserveNowReq = 1;
								strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Accepted]);
							}
							else if((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_MAINTAIN) ||(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_DEBUG)) //S_TERMINATING  //else if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 11) || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '9'))
							{
								strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Unavailable]);

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

				}
			} // END FOR AC_QUANTITY
		}//END FOR AC ELSE

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

	  if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
	  {
			//check Transaction active
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if(reservationIdInt != ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].ReservationId)
				{
					if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_MAINTAIN) || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_DEBUG)) //S_TERMINATING  //else if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 11) || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '9'))
					{
						strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Unavailable]);
						goto end;
					}
					else if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_PREPARING) //S_PRECHARGE
					{
						strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Occupied]);
						goto end;
					}
					else if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_FAULT) //S_FAULT
					{
						strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Faulted]);
						goto end;
					}
					else if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus != SYS_MODE_IDLE) //S_IDLE
					{
						strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Rejected]);
						goto end;
					}
				}

			}// END FOR CHAdeMO_QUANTITY

			for (int index = 0; index < CCS_QUANTITY; index++)
			{
			   if(reservationIdInt != ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].ReservationId)
			   {
				   if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_MAINTAIN)||(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_DEBUG)) //S_TERMINATING  //else if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == '6') || (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == '9'))
				   {
					   strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Unavailable]);
				   }
				   else if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_PREPARING) //S_PRECHARGE
				   {
					   strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Occupied]);
				   }
				   else if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus ==SYS_MODE_FAULT) //S_FAULT
				   {
					   strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Faulted]);
				   }
				   else if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus != SYS_MODE_IDLE) //S_IDLE
				   {
					   strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Rejected]);
				   }
			   }
			} // END FOR CCS_QUANTITY

			for (int index = 0; index < GB_QUANTITY; index++)
			{
				if(reservationIdInt != ShmSysConfigAndInfo->SysInfo.GbChargingData[index].ReservationId)
				{
					if((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_MAINTAIN)||(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_DEBUG)) //S_TERMINATING //else if((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '6') || (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == '9'))
					{
						strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Unavailable]);
					}
					else if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_PREPARING) //S_PRECHARGE
					{
						strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Occupied]);
					}
					else if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus ==SYS_MODE_FAULT) //S_FAULT
					{
						strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Faulted]);
					}
					else if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus != SYS_MODE_IDLE) //S_IDLE
					{
						strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Rejected]);
					}
				}

			} // END FOR GB_QUANTITY
	  }
	  else
	  {
		  for (int index = 0; index < AC_QUANTITY; index++)
		  {
		  	 if(reservationIdInt != ShmSysConfigAndInfo->SysInfo.AcChargingData[index].ReservationId)
		  	 {
		  		if((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_MAINTAIN) || (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_DEBUG)) //S_TERMINATING  //else if((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == 11) || (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == '9'))
		  		{
		  			strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Unavailable]);
		  			goto end;
		  		}
		  		else if(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_PREPARING) //S_PRECHARGE
		  		{
		  			strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Occupied]);
		  			goto end;
		  		}
		  		else if(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_FAULT) //S_FAULT
		  		{
		  			strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Faulted]);
		  			goto end;
		  		}
		  		else if(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus != SYS_MODE_IDLE) //S_IDLE
		  		{
		  			strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Rejected]);
		  			goto end;
		  		}
		  	}

		  }// END FOR AC_QUANTITY

	  }

	  //The connectorId is 0
	  ShmOCPP16Data->CsMsg.bits[0].ReserveNowReq = 1;
	  strcpy(comfirmstr, ReservationStatusStr[ReservationStatus_Accepted]);
	  sprintf((char *)ShmOCPP16Data->ReserveNow[0].ResponseStatus, "%s" ,comfirmstr);
	  ShmOCPP16Data->ReserveNow[0].ConnectorId = connectorIdInt;
	  sprintf((char *)ShmOCPP16Data->ReserveNow[0].ExpiryDate, "%s" , expiryDatestr);
	  sprintf((char *)ShmOCPP16Data->ReserveNow[0].IdTag, "%s" , idTagstr);
	  sprintf((char *)ShmOCPP16Data->ReserveNow[0].ParentIdTag, "%s" , parentIdTagstr);
	  ShmOCPP16Data->ReserveNow[0].ReservationId = reservationIdInt;
	  strcpy((char *)ShmOCPP16Data->ReserveNow[0].guid, uuid);

	  result = TRUE;
	  return result;

	}
	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((char *)ShmOCPP16Data->ReserveNow[connectorIdInt-1].guid, uuid);

	    result = TRUE;
	    return result;

	}

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

	return result;
}

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

	char sstr[10]={0};
	char typestr[10]={0};
	char comfirmstr[20]={0};
	int c = 0;
	char *loc;

//[2,"6f88d461-4d17-462c-a69b-1f7a8c5b12df","Reset",{"type":"Hard"}]
	DEBUG_INFO("handleResetRequest ...\n");

	loc = strstr(payload, "type");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while (loc[3+strlen("type")+c] != '\"')
	{
		sstr[c] = loc[3+strlen("type")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(typestr,sstr);

	sprintf((char *)ShmOCPP16Data->Reset.Type, "%s" ,typestr);
	//strcpy(ShmOCPP16Data->Reset.Type, typestr);

	if(strcmp(typestr, ResetTypeStr[Hard])==0)
	{
	   //check Transaction active
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_CHARGING)
				{
				    //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 == SYS_MODE_CHARGING)
				{
				    //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 == SYS_MODE_CHARGING)
				{
				    //0: unplug, 1: Plug-in
				    //ShmSysConfigAndInfo->SysInfo.GbChargingData[index].ConnectorPlugIn = 0;
				}
			}

		}
		else
		{
			for (int index = 0; index < AC_QUANTITY; index++)
			{
				if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_CHARGING)
				{
					//0: unplug, 1: Plug-in
					//ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].ConnectorPlugIn = 0;
				}
			}

		}// END FOR AC ELSE


	    ShmOCPP16Data->MsMsg.bits.ResetReq = 1;
	    strcpy((char *)ShmOCPP16Data->Reset.guid, uuid);
	    result = TRUE;
	    return result;
	 }
	 else if(strcmp(typestr, ResetTypeStr[Soft])==0)
	 {
	     //check Transaction active
		 if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		 {
			 for (int index = 0; index < CHAdeMO_QUANTITY; index++)
			 {
				 if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_CHARGING)
				 {
				    //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 == SYS_MODE_CHARGING)
				{
				    //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 == SYS_MODE_CHARGING)
				{
				   //0: unplug, 1: Plug-in
				   //ShmSysConfigAndInfo->SysInfo.GbChargingData[index].ConnectorPlugIn = 0;
				}
			}

		 }
		 else
		 {
			 for (int index = 0; index < AC_QUANTITY; index++)
			 {
				if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_CHARGING)
				{
					//0: unplug, 1: Plug-in
					//ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].ConnectorPlugIn = 0;
				}
			}

		 }// END FOR AC ELSE

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

errorend:
	sendResetConfirmation(uuid, comfirmstr);
	return result;
}

int handleSendLocalListRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
	int listVersionInt;
	//char *updateTypestr, *idTagstr, *expiryDatestr, *parentIdTagstr, *statusstr;
	char listsearch[]="listVersion";
	char updateTypesearch[]="updateType";
	char localAuthorizationListsearch[]="localAuthorizationList";
	char sstr[60500]={ 0 };//sstr[200]={ 0 };
	char CardList[500][160]={0};
	char updateTypestr[15]={0};
	char idTagstr[20]={0};
	char parentIdTag[20]={0};
	char expiryDate[30]={0};
	char idTagstatus[16]={0};
	int  c = 0;
	int i = 0;
	char *delim1 = "}";
	char * pch;
	char *loc;
	//char *ptr;
	char comfirmstr[20];
	//int n_localAuthorizations = 0;
	int checkState_Faulted = FALSE;

	DEBUG_INFO("handleSendLocalListRequest\n");

	if(strcmp((const char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData, "FALSE") == 0) //For OCTT Test case
	{
		strcpy(comfirmstr, UpdateStatusStr[UpdateStatus_NotSupported]);
		goto end;
	}


	if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
	{
		//check Charge Point state
		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_FAULT) //S_FAULT   ---> Faulted
			{
				checkState_Faulted = TRUE; //OCPP Status: Faulted
			}

		}

		for (int index = 0; index < CCS_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_FAULT) //S_FAULT   ---> Faulted
			{
				checkState_Faulted = TRUE; //OCPP Status
			}

		}

		for (int index = 0; index < GB_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_FAULT) //S_FAULT   ---> Faulted
			{
				checkState_Faulted = TRUE; //OCPP Status: Faulted
			}
		}
	}
	else
	{
		//check Charge Point state
		for (int index = 0; index < AC_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_FAULT) //S_FAULT   ---> Faulted
			{
				checkState_Faulted = TRUE; //OCPP Status: Faulted
			}
		}

	}// END FOR AC ELSE


	if(checkState_Faulted == TRUE)
	{
		strcpy(comfirmstr, UpdateStatusStr[UpdateStatus_Failed]);
		goto end;
	}

	//listVersion
	c = 0;
	loc = strstr(payload, listsearch);
	while (loc[strlen("listVersion")+2+c] != ',')
	{
		sstr[c] = loc[strlen("listVersion")+2+c];
		c++;
	}
	sstr[c] = '\0';
	listVersionInt = atoi(sstr);
	ShmOCPP16Data->SendLocalList.ListVersion = listVersionInt;

	//updateType
	loc = strstr(payload, updateTypesearch);
	c = 0;
	while (loc[3+strlen(updateTypesearch)+c] != '\"')
	{
		sstr[c] = loc[3+strlen(updateTypesearch)+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(updateTypestr, sstr);
	sprintf((char *)ShmOCPP16Data->SendLocalList.UpdateType, "%s",  updateTypestr);

	//localAuthorizationList
	memset(sstr ,0, sizeof(sstr) );
	loc = strstr(payload, localAuthorizationListsearch);
	if(loc != NULL) // localAuthorizationList is not NULL
	{
		//Check UpdateType
		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");

			OCPP_getListVerion();

			if(listVersionInt < localversion )//if(listVersionInt <= localversion ) for OCTT Case ---remove temporally
			{
				strcpy(comfirmstr, UpdateStatusStr[UpdateStatus_VersionMismatch]);
				goto end;
			}
		}
		else
		{
			strcpy(comfirmstr, UpdateStatusStr[UpdateStatus_NotSupported]);
			goto end;
		}


		c = 0;
		while (loc[3+strlen(localAuthorizationListsearch)+c] != ']')
		{
			sstr[c] = loc[3+strlen(localAuthorizationListsearch)+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';

		//parsing strings to words
		i = 0;
		pch = strtok(sstr,delim1);
		while (pch != NULL)
		{
			strcpy(CardList[i], pch);
			pch = strtok (NULL, delim1);
			i = i + 1;
		}

		//local Authorizations List Numbers
		//n_localAuthorizations = i;
		ShmOCPP16Data->SendLocalList.ListVersion = listVersionInt;

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

		c= 0;
		while(c < i)
		{
			//Search "IdToken"
			memset(sstr ,0, sizeof(sstr) );
			loc = strstr(CardList[c], "idTag");
			int j = 0;
			while (loc[3+strlen("idTag")+j] != '\"')
			{
				sstr[j] = loc[3+strlen("idTag")+j];
				//printf("i=%d sstr=%c\n",c, sstr[j]);
				j++;
			}
			sstr[j] = '\0';
			strcpy(idTagstr, sstr);

			//Search "expiryDate"
			memset(sstr ,0, sizeof(sstr) );
			loc = strstr(CardList[c], "expiryDate");
			j = 0;
			while (loc[3+strlen("expiryDate")+j] != '\"')
			{
				sstr[j] = loc[3+strlen("expiryDate")+j];
				//printf("i=%d sstr=%c\n",c, sstr[j]);
				j++;
			}
			sstr[j] = '\0';
			strcpy(expiryDate, sstr);

			//Search "parentIdTag"
			memset(sstr ,0, sizeof(sstr) );
			loc = strstr(CardList[c], "parentIdTag");
			j = 0;
			while (loc[3+strlen("parentIdTag")+j] != '\"')
			{
				sstr[j] = loc[3+strlen("parentIdTag")+j];
				//printf("i=%d sstr=%c\n",c, sstr[j]);
				j++;
			}
			sstr[j] = '\0';
			strcpy(parentIdTag, sstr);

			//Search "status"
			memset(sstr ,0, sizeof(sstr) );
			loc = strstr(CardList[c], "status");
			j = 0;
			while (loc[3+strlen("status")+j] != '\"')
			{
				sstr[j] = loc[3+strlen("status")+j];
				//printf("i=%d sstr=%c\n",c, sstr[j]);
				j++;
			}
			sstr[j] = '\0';
			strcpy(idTagstatus, sstr);

			OCPP_getIdTag(idTagstr);
			//OCPP_getIdTag("test"); For Test
			DEBUG_INFO("idTagAuthorization=%s\n",idTagAuthorization);

			if(strcmp(updateTypestr, UpdateTypeStr[Full]) == 0)
			{
				//Local list full update
				DEBUG_INFO("Local list full update.\n");
				// update list
				OCPP_addLocalList_1(listVersionInt, idTagstr, parentIdTag, expiryDate, idTagstatus);
				OCPP_get_TableAuthlocalAllData();
			}
			else if(strcmp(updateTypestr, UpdateTypeStr[Differential]) == 0)
			{
				if((strcmp(idTagstr, idTagAuthorization) == 0) && (parentIdTag[0] != '\0'))
				{
					OCPP_addLocalList_1(listVersionInt, idTagstr, parentIdTag, expiryDate, idTagstatus);

				}
				else if((strcmp(idTagstr, idTagAuthorization) == 0) && (parentIdTag[0] == '\0'))
				{
					OCPP_deleteIdTag(idTagstr);
				}
				else if((strcmp(idTagstr, idTagAuthorization) != 0) && (parentIdTag[0] != '\0'))
				{
					OCPP_addLocalList_1(listVersionInt, idTagstr, parentIdTag, expiryDate, idTagstatus);

				}

			}

			strcpy((char *)ShmOCPP16Data->SendLocalList.LocalAuthorizationList[c].IdTag, idTagstr);
			strcpy((char *)ShmOCPP16Data->SendLocalList.LocalAuthorizationList[c].IdTagInfo.ExpiryDate, expiryDate);
			strcpy((char *)ShmOCPP16Data->SendLocalList.LocalAuthorizationList[c].IdTagInfo.ParentIdTag, parentIdTag);
			strcpy((char *)ShmOCPP16Data->SendLocalList.LocalAuthorizationList[c].IdTagInfo.Status, idTagstatus);

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

		}
	}

	strcpy(comfirmstr, UpdateStatusStr[UpdateStatus_Accepted]);


end:

	sendSendLocalListConfirmation(uuid, comfirmstr);
	//ShmOCPP16Data->MsMsg.bits.SendLocalListConf = 1;

#if 0
	if(ShmOCPP16Data->SendLocalList.LocalAuthorizationList != NULL)
		free(ShmOCPP16Data->SendLocalList.LocalAuthorizationList);
#endif
	return result;
}


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

*/

#define MAX 200

int handleSetChargingProfileRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
	int connectorIdInt=0, chargingProfileIdInt=0, transactionIdInt=0,stackLevelInt=0, durationInt=0, startPeriodInt[10]={0}, numberPhasesInt[10]={0};
	int tempconnectorIdInt=0, tempchargingProfileIdInt=0, tempstackLevelInt=0;
	char chargingProfilePurposeStr[30]={0};
	char chargingProfileKindStr[16]={0};
	char recurrencyKindStr[10]={0};
	char validFromStr[30]={0}, validToStr[30]={0}, startScheduleStr[30]={0}, chargingRateUnitStr[6]={0};
	float minChargingRateFloat = 0.0, limitflaot[10] = {0.0};
	int chargingSchedulePeriodCount = 0;
	//int updateflag = FALSE;
	char comfirmstr[20]={0};
	int meet= FALSE;
	char sstr[10]={0};
	int c = 0;
	char *loc;
	FILE *fptr1;//, *fptr2;
	//int lno=0;//, linectr = 0;
	//int modifyflag = FALSE;
	char filename[MAX]={0};
	char tempfile[] = "../Storage/OCPP/temp.json";
	int  resultRename=0;
	char rmFileCmd[50]={0};
	char tempchargingProfilePurposeStr[30]={0};


//[2,"d65bcbca-0b07-49c1-b679-e6c6ff9f5627","SetChargingProfile",{"connectorId":0,"csChargingProfiles":{"chargingProfileId":1,"transactionId":0,"stackLevel":0,"chargingProfilePurpose":"TxDefaultProfile","chargingProfileKind":"Absolute","recurrencyKind":"Daily","validFrom":"2019-07-01T02:39:55.000Z","validTo":"2019-07-04T02:39:55.000Z","chargingSchedule":{"duration":86400,"startSchedule":"2019-07-01T02:39:55.000Z","chargingRateUnit":"A","chargingSchedulePeriod":[{"startPeriod":0,"limit":20.0,"numberPhases":3},{"startPeriod":300,"limit":10.0,"numberPhases":3},{"startPeriod":600,"limit":20.0,"numberPhases":3},{"startPeriod":1200,"limit":10.0,"numberPhases":3},{"startPeriod":1800,"limit":20.0,"numberPhases":3},{"startPeriod":2400,"limit":10.0,"numberPhases":3},{"startPeriod":3000,"limit":20.0,"numberPhases":3}],"minChargingRate":20.1}}}]

	DEBUG_INFO("handleSetChargingProfileRequest\n");

	connectorIdInt = chargingProfileIdInt = transactionIdInt = stackLevelInt = 0;

	//*********************connectorId***************************/
	loc = strstr(payload, "connectorId");
	c = 0;
	memset(sstr ,0, sizeof(sstr) );
	while (loc[strlen("connectorId")+2+c] != ',')
	{
		sstr[c] = loc[strlen("connectorId")+2+c];
		c++;
	}
	sstr[c] = '\0';
	connectorIdInt = atoi(sstr);

	if(connectorIdInt == 0) //  an overall limit for the Charge Point.
	{
		ShmOCPP16Data->SetChargingProfile[0].ConnectorId = connectorIdInt;
	}
	else
	{
		ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ConnectorId = connectorIdInt;
	}


	//DEBUG_INFO("handleSetChargingProfileRequest -1\n");
	//*********************chargingProfileId***************************/
	loc = strstr(payload, "chargingProfileId");
	c = 0;
	memset(sstr ,0, sizeof(sstr) );
	while (loc[strlen("chargingProfileId")+2+c] != ',')
	{
		sstr[c] = loc[strlen("chargingProfileId")+2+c];
		c++;
	}
	sstr[c] = '\0';
	chargingProfileIdInt = atoi(sstr);

	if(connectorIdInt == 0) //  an overall limit for the Charge Point.
	{
		ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ChargingProfileId = chargingProfileIdInt;
	}
	else
	{
		ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingProfileId = chargingProfileIdInt;
	}


	//DEBUG_INFO("handleSetChargingProfileRequest -2\n");
	//*********************transactionId***************************/
	loc = strstr(payload, "transactionId");

	if(loc != NULL)
	{
		c = 0;
		memset(sstr ,0, sizeof(sstr) );
		while (loc[strlen("transactionId")+2+c] != ',')
		{
			sstr[c] = loc[strlen("transactionId")+2+c];
			c++;
		}
		sstr[c] = '\0';
		transactionIdInt = atoi(sstr);


		if(connectorIdInt == 0) //  an overall limit for the Charge Point.
		{
			ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.TransactionId = transactionIdInt;
		}
		else
		{
			ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.TransactionId = transactionIdInt;
		}

	}

	//DEBUG_INFO("handleSetChargingProfileRequest -3\n");
	//*********************stackLevel***************************/
	loc = strstr(payload, "stackLevel");
	c = 0;
	memset(sstr ,0, sizeof(sstr) );
	while (loc[strlen("stackLevel")+2+c] != ',')
	{
		sstr[c] = loc[strlen("stackLevel")+2+c];
		c++;
	}
	sstr[c] = '\0';
	stackLevelInt = atoi(sstr);

	if(connectorIdInt == 0) //  an overall limit for the Charge Point.
	{
		ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.StackLevel = stackLevelInt;
	}
	else
	{
		ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.StackLevel = stackLevelInt;
	}

	//DEBUG_INFO("handleSetChargingProfileRequest -4\n");
	//*********************chargingProfilePurpose***************************/
	loc = strstr(payload, "chargingProfilePurpose");
	c = 0;
	memset(sstr ,0, sizeof(sstr) );
	while (loc[3+strlen("chargingProfilePurpose")+c] != '\"')
	{
		sstr[c] = loc[3+strlen("chargingProfilePurpose")+c];
		//printf("i=%d sstr=%c\n",c, sstr[c]);
		c++;
	}
	sstr[c] = '\0';
	strcpy(chargingProfilePurposeStr,sstr);
	//DEBUG_INFO("chargingProfilePurposeStr=%s\n",chargingProfilePurposeStr);

	if(connectorIdInt == 0) //  an overall limit for the Charge Point.
	{
		strcpy((char *)ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ChargingProfilePurpose, chargingProfilePurposeStr);
	}
	else
	{
		strcpy((char *)ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingProfilePurpose, chargingProfilePurposeStr);

	}

	//DEBUG_INFO("handleSetChargingProfileRequest -6\n");
	//*********************chargingProfileKind***************************/
	loc = strstr(payload, "chargingProfileKind");
	c = 0;
	memset(sstr ,0, sizeof(sstr) );
	while (loc[3+strlen("chargingProfileKind")+c] != '\"')
	{
		sstr[c] = loc[3+strlen("chargingProfileKind")+c];
		//printf("i=%d sstr=%c\n",c, sstr[c]);
		c++;
	}
	sstr[c] = '\0';
	strcpy(chargingProfileKindStr,sstr);

	if(connectorIdInt == 0) //  an overall limit for the Charge Point.
	{
		strcpy((char *)ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ChargingProfileKind, chargingProfileKindStr);
	}
	else
	{
		strcpy((char *)ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingProfileKind, chargingProfileKindStr);
	}

	//DEBUG_INFO("handleSetChargingProfileRequest -7\n");
	//*********************recurrencyKind***************************/
	loc = strstr(payload, "recurrencyKind");
	if(loc != NULL)
	{

		c = 0;
		memset(sstr ,0, sizeof(sstr) );
		while (loc[3+strlen("recurrencyKind")+c] != '\"')
		{
			sstr[c] = loc[3+strlen("recurrencyKind")+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		strcpy(recurrencyKindStr,sstr);

		if(connectorIdInt == 0) //  an overall limit for the Charge Point.
		{
			strcpy((char *)ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.RecurrencyKind, recurrencyKindStr);
		}
		else
		{
			strcpy((char *)ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.RecurrencyKind, recurrencyKindStr);
		}

	}

	//DEBUG_INFO("handleSetChargingProfileRequest -8\n");
	//*********************validFrom***************************/
	loc = strstr(payload, "validFrom");
	if(loc != NULL)
	{
		c = 0;
		memset(sstr ,0, sizeof(sstr) );
		while (loc[3+strlen("validFrom")+c] != '\"')
		{
			sstr[c] = loc[3+strlen("validFrom")+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		strcpy(validFromStr,sstr);

		if(connectorIdInt == 0) //  an overall limit for the Charge Point.
		{
			strcpy((char *)ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ValidFrom, validFromStr);
		}
		else
		{
			strcpy((char *)ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ValidFrom, validFromStr);
		}


	}

	//DEBUG_INFO("handleSetChargingProfileRequest -9\n");
	//*********************validTo***************************/
	loc = strstr(payload, "validTo");
	if(loc != NULL)
	{
		c = 0;
		memset(sstr ,0, sizeof(sstr) );
		while (loc[3+strlen("validTo")+c] != '\"')
		{
			sstr[c] = loc[3+strlen("validTo")+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		strcpy(validToStr,sstr);

		if(connectorIdInt == 0) //  an overall limit for the Charge Point.
		{
			strcpy((char *)ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ValidTo, validToStr);
		}
		else
		{
			strcpy((char *)ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ValidTo, validToStr);

		}

	}

	//DEBUG_INFO("handleSetChargingProfileRequest -10\n");
	//*********************duration***************************/
	loc = strstr(payload, "duration");
	if(loc != NULL)
	{
		c = 0;
		memset(sstr ,0, sizeof(sstr) );
		while (loc[strlen("duration")+2+c] != ',')
		{
			sstr[c] = loc[strlen("duration")+2+c];
			c++;
		}
		sstr[c] = '\0';
		durationInt = atoi(sstr);

		if(connectorIdInt == 0) //  an overall limit for the Charge Point.
		{
			ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ChargingSchedule.Duration = durationInt;
		}
		else
		{
			ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingSchedule.Duration = durationInt;
		}

	}

	//DEBUG_INFO("handleSetChargingProfileRequest -11\n");
	//*********************startSchedule***************************/
	loc = strstr(payload, "startSchedule");
	if(loc != NULL)
	{
		c = 0;
		memset(sstr ,0, sizeof(sstr) );
		while (loc[3+strlen("startSchedule")+c] != '\"')
		{
			sstr[c] = loc[3+strlen("startSchedule")+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		strcpy(startScheduleStr,sstr);

		if(connectorIdInt == 0) //  an overall limit for the Charge Point.
		{
			strcpy((char *)ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ChargingSchedule.StartSchedule,startScheduleStr);

		}
		else
		{
			strcpy((char *)ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingSchedule.StartSchedule,startScheduleStr);
		}

	}


	//DEBUG_INFO("handleSetChargingProfileRequest -12\n");
	//*********************chargingRateUnit***************************/
	loc = strstr(payload, "chargingRateUnit");
	if(loc != NULL)
	{
		c = 0;
		memset(sstr ,0, sizeof(sstr) );
		while (loc[3+strlen("chargingRateUnit")+c] != '\"')
		{
			sstr[c] = loc[3+strlen("chargingRateUnit")+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		strcpy(chargingRateUnitStr,sstr);

		if(connectorIdInt == 0) //  an overall limit for the Charge Point.
		{
			strcpy((char *)ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ChargingSchedule.ChargingRateUnit,chargingRateUnitStr);
		}
		else
		{
			strcpy((char *)ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingSchedule.ChargingRateUnit,chargingRateUnitStr);

		}

	}

	//DEBUG_INFO("handleSetChargingProfileRequest -13\n");
	//****************chargingSchedulePeriod count start*******************/
	int what_len = strlen("startPeriod");

	char *where = payload;

	if (what_len)
		while ((where = strstr(where, "startPeriod"))) {
		where += what_len;
		chargingSchedulePeriodCount++;
	}

	//DEBUG_INFO("chargingSchedulePeriodCount=%d\n",chargingSchedulePeriodCount);
	//DEBUG_INFO("handleSetChargingProfileRequest -13 -1\n");
	where = payload;
	for(int periodNums=0; periodNums < chargingSchedulePeriodCount; periodNums++)
	{
		//****************startPeriod*******************/
		c=0;
		loc = strstr(where, "startPeriod");
		memset(sstr ,0, sizeof(sstr) );
		while ((loc[strlen("startPeriod")+2+c] != '}') && (loc[strlen("startPeriod")+2+c] != ','))
		{
			sstr[c] = loc[strlen("startPeriod")+2+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		startPeriodInt[periodNums] = atoi(sstr);
		//DEBUG_INFO("sstr=%d\n",atoi(sstr));
		//DEBUG_INFO("handleSetChargingProfileRequest -13 -1 -1\n");
		if(connectorIdInt == 0) //  an overall limit for the Charge Point.
		{
			ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ChargingSchedule.ChargingSchedulePeriod[periodNums].StartPeriod = startPeriodInt[periodNums];

		}
		else
		{
			ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingSchedule.ChargingSchedulePeriod[periodNums].StartPeriod = startPeriodInt[periodNums];
		}
		//DEBUG_INFO("handleSetChargingProfileRequest -13 -2\n");
		//****************limit*******************/
		c=0;
		loc = strstr(where, "limit");
		memset(sstr ,0, sizeof(sstr) );
		while ((loc[strlen("limit")+2+c] != '}') && (loc[strlen("limit")+2+c] != ','))
		{
			sstr[c] = loc[strlen("limit")+2+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		limitflaot[periodNums] = atof(sstr);

		if(connectorIdInt == 0) //  an overall limit for the Charge Point.
		{
			ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ChargingSchedule.ChargingSchedulePeriod[periodNums].Limit = limitflaot[periodNums];

		}
		else
		{
			ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingSchedule.ChargingSchedulePeriod[periodNums].Limit = limitflaot[periodNums];
		}
		//DEBUG_INFO("handleSetChargingProfileRequest -13 -3\n");
		//****************numberPhases*******************/
		loc = strstr(where, "numberPhases");
		if(loc != NULL)
		{
			c=0;
			memset(sstr ,0, sizeof(sstr) );
			while ((loc[strlen("numberPhases")+2+c] != '}') && (loc[strlen("numberPhases")+2+c] != ','))
			{
				sstr[c] = loc[strlen("numberPhases")+2+c];
				//printf("i=%d sstr=%c\n",c, sstr[c]);
				c++;
			}
			sstr[c] = '\0';
			numberPhasesInt[periodNums] = atoi(sstr);

			if(connectorIdInt == 0) //  an overall limit for the Charge Point.
			{
				ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ChargingSchedule.ChargingSchedulePeriod[periodNums].NumberPhases = numberPhasesInt[periodNums];
			}
			else
			{
				ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingSchedule.ChargingSchedulePeriod[periodNums].NumberPhases = numberPhasesInt[periodNums];

			}
		}

		where = loc;

	}
	//DEBUG_INFO("handleSetChargingProfileRequest -14\n");
	//****************chargingSchedulePeriod count end*******************/


	//*********************minChargingRate***************************/
	loc = strstr(payload, "minChargingRate");

	if(loc != NULL)
	{
		c = 0;
		memset(sstr ,0, sizeof(sstr) );
		while ((loc[strlen("minChargingRate")+2+c] != ',')&&(loc[strlen("minChargingRate")+2+c] != '}'))
		{
			sstr[c] = loc[strlen("minChargingRate")+2+c];
			c++;
		}
		sstr[c] = '\0';
		minChargingRateFloat = atof(sstr);

		if(connectorIdInt == 0) //  an overall limit for the Charge Point.
		{
			ShmOCPP16Data->SetChargingProfile[0].ChargingProfile.ChargingSchedule.MinChargingRate = minChargingRateFloat;
		}
		else
		{
			ShmOCPP16Data->SetChargingProfile[connectorIdInt -1].ChargingProfile.ChargingSchedule.MinChargingRate = minChargingRateFloat;
		}

	}

	DEBUG_INFO("\n\n Replace a specific line in a text file with a new text :\n");
	DEBUG_INFO("-------------------------------------------------------------\n");
	DEBUG_INFO(" Input the file name to be opened : ");
	//fgets(fname, MAX, stdin);
	//fname[strlen(fname) - 1] = '\0';
#if 0
	switch(connectorIdInt)
	{
		case 0:
			strcpy(filename, ChargingProfile_0_JSON );
			break;

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

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

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

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

	}
	fclose(fptr1);
#endif

	//DEBUG_INFO("chargingProfilePurposeStr=%s\n",chargingProfilePurposeStr);
	//DEBUG_INFO(" ChargingProfilePurposeTypeStr[TxProfile]=%s\n", ChargingProfilePurposeTypeStr[TxProfile]);

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

		strcpy(filename, ChargePointMaxProfile_JSON );
		fptr1 = fopen(filename, "r");
		if (!fptr1)
		{
			//file not exist
			DEBUG_INFO("Unable to open the input file!!\n");
			fptr1 = fopen(filename, "w+");
		}
		fclose(fptr1);

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

		switch(connectorIdInt)
		{
			case 0:
				strcpy(filename, TxDefaultProfile_0_JSON );
			break;

			case 1:
				strcpy(filename, TxDefaultProfile_1_JSON );
			break;

			case 2:
				strcpy(filename, TxDefaultProfile_2_JSON );
				break;

			default:
				strcpy(filename, TxDefaultProfile_0_JSON );
				break;
		}

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

		}
		fclose(fptr1);
	}
	else if(strcmp(chargingProfilePurposeStr, ChargingProfilePurposeTypeStr[TxProfile]) == 0)
	{
		//printf("set chargingProfile 1-4\n");
		DEBUG_INFO("chargingProfilePurposeStr is TxProfile !!! \n");
		//check Transaction active
		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == (connectorIdInt -1))
			{

				if(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_CHARGING) // S_CHARGING
				{
					if(transactionIdInt == ShmOCPP16Data->StartTransaction[connectorIdInt -1].ResponseTransactionId)
					{
						meet = TRUE;
						break;
					}

				}

			}
		}

		for (int index = 0; index < CCS_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].Index == (connectorIdInt -1))
			{
				if(ShmSysConfigAndInfo->SysInfo.CcsChargingData[index].SystemStatus == SYS_MODE_CHARGING) // S_CHARGING
				{
					if(transactionIdInt == ShmOCPP16Data->StartTransaction[connectorIdInt -1].ResponseTransactionId)
					{
						meet = TRUE;
						break;
					}
				}

			}
		}

		for (int index = 0; index < GB_QUANTITY; index++)
		{
			if (ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == (connectorIdInt -1))
			{
				if(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_CHARGING) // S_CHARGING
				{
					if(transactionIdInt == ShmOCPP16Data->StartTransaction[connectorIdInt -1].ResponseTransactionId)
					{
						meet = TRUE;
						break;
					}
				}

			}
		}

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

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


		switch(connectorIdInt)
		{
			case 0:
				break;

			case 1:
				strcpy(filename, TxProfile_1_JSON);
				break;

			case 2:
				strcpy(filename, TxProfile_2_JSON);
				break;

			default:
				strcpy(filename, TxProfile_1_JSON);
				break;
		}

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

		}
		fclose(fptr1);
	}


	//**********************************Write to File********************************************************/
	FILE *infile;
	FILE *outfile;

	// open file for writing
	infile = fopen (filename, "r");
	outfile = fopen (tempfile, "w");


	int d =0;
	d = fgetc(infile);
	DEBUG_INFO("d:%d\n",d);
	rewind(infile);

	//*检测到文件结束标识返回1，否则返回0。*/
	if(d == EOF)
	{
		DEBUG_INFO("ChargingProfile content is  NULL\n");

		fprintf(outfile,"[%s]\n",payload);
		sprintf(comfirmstr, "%s", ChargingProfileStatusStr[ChargingProfileStatus_Accepted] );


		fclose(infile);
		fclose(outfile);


		sprintf(rmFileCmd,"rm -f %s",filename);
		system(rmFileCmd);

		resultRename = rename(tempfile, filename);

		if(resultRename == 0)
		{
			DEBUG_INFO("File chargingProfile renamed successfully");
		}
		else
		{
			DEBUG_INFO("Error: unable to rename the chargingProfile file");
		}

		//sprintf(rmFileCmd,"rm -f %s",tempfile);
		//system(rmFileCmd);
	}
	else
	{
		char buf[1000]={0};

		while (fgets(buf, sizeof(buf), infile) != NULL)
		{
			buf[strlen(buf) - 1] = '\0'; // eat the newline fgets() stores
			//*************************tempconnectorIdInt*********************************/
			loc = strstr(buf, "connectorId");
			c = 0;
			memset(sstr ,0, sizeof(sstr) );
			while (loc[strlen("connectorId")+2+c] != ',')
			{
				sstr[c] = loc[strlen("connectorId")+2+c];
				c++;
			}
			sstr[c] = '\0';
			tempconnectorIdInt = atoi(sstr);


			//*************************tempchargingProfileIdInt*********************************/
			loc = strstr(buf, "chargingProfileId");
			c = 0;
			memset(sstr ,0, sizeof(sstr) );
			while (loc[strlen("chargingProfileId")+2+c] != ',')
			{
				sstr[c] = loc[strlen("chargingProfileId")+2+c];
				c++;
			}
			sstr[c] = '\0';
			tempchargingProfileIdInt = atoi(sstr);


			//*************************tempstackLevelInt*********************************/
			loc = strstr(buf, "stackLevel");
			c = 0;
			memset(sstr ,0, sizeof(sstr) );
			while (loc[strlen("stackLevel")+2+c] != ',')
			{
				sstr[c] = loc[strlen("stackLevel")+2+c];
				c++;
			}
			sstr[c] = '\0';
			tempstackLevelInt = atoi(sstr);


			//*************************tempchargingProfilePurposeStr*********************************/
			loc = strstr(payload, "chargingProfilePurpose");
			c = 0;
			memset(sstr ,0, sizeof(sstr) );
			while (loc[3+strlen("chargingProfilePurpose")+c] != '\"')
			{
				sstr[c] = loc[3+strlen("chargingProfilePurpose")+c];
				//printf("i=%d sstr=%c\n",c, sstr[c]);
				c++;
			}
			sstr[c] = '\0';
			strcpy(tempchargingProfilePurposeStr,sstr);


			if((tempconnectorIdInt == connectorIdInt) && (tempchargingProfileIdInt == chargingProfileIdInt))
			{
				if((tempstackLevelInt == stackLevelInt) && (strcmp(tempchargingProfilePurposeStr, chargingProfilePurposeStr) == 0))
				{
					//DEBUG_INFO("update set chargingProfile to file -0\n");
					fprintf(outfile,"[%s]\n",payload);
				}
				else
				{
					//DEBUG_INFO("update set chargingProfile to file -1\n");
					if(tempstackLevelInt < stackLevelInt)
					{
						//DEBUG_INFO("update set chargingProfile to file -2\n");
						fprintf(outfile,"[%s]\n",payload);
						fprintf(outfile,"[%s]\n",buf);
					}
					else
					{
						fprintf(outfile,"[%s]\n",buf);
						fprintf(outfile,"[%s]\n",payload);
					}
				}

				DEBUG_INFO("update set chargingProfile to file\n");

			}
			else
			{

				if(tempchargingProfileIdInt < chargingProfileIdInt)
				{
					fprintf(outfile,"[%s]\n",payload);
					fprintf(outfile,"[%s]\n",buf);
				}
				else if(tempstackLevelInt < stackLevelInt)
				{
					fprintf(outfile,"[%s]\n",payload);
					fprintf(outfile,"[%s]\n",buf);
				}
				else
				{
					fprintf(outfile,"[%s]\n",buf);
					fprintf(outfile,"[%s]\n",payload);
				}

				fprintf(outfile,"[%s]\n",buf);
				DEBUG_INFO("add set chargingProfile to file\n");
			}

		} // end of while loop

		fclose(infile);
		fclose(outfile);

		sprintf(rmFileCmd,"rm -f %s",filename);
		system(rmFileCmd);

		resultRename = rename(tempfile, filename);

		if(resultRename == 0)
		{
			DEBUG_INFO("File chargingProfile renamed successfully");
		}
		else
		{
			DEBUG_INFO("Error: unable to rename the chargingProfile file");
		}

		result = TRUE;
		sprintf(comfirmstr, "%s", ChargingProfileStatusStr[ChargingProfileStatus_Accepted] );
	}


end:
	sendSetChargingProfileConfirmation(uuid, comfirmstr);
	return result;

	return result;
}

int handleTriggerMessageRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
	int connectorIdIsNULL = FALSE;
	int connectorIdInt =0;
	char sstr[40]={0};
	char requestedMessagestr[40]={0};
	char comfirmstr[20]={0};
	int c = 0;
	char *loc;

	DEBUG_INFO("handleTriggerMessageRequest\n");
	//[2,"266e23f4-27a4-41cf-84cb-aadf56b9523f","TriggerMessage",{"requestedMessage":"DiagnosticsStatusNotification","connectorId":1}]

	c = 0;
	loc = strstr(payload, "requestedMessage");
	while (loc[3+strlen("requestedMessage")+c] != '\"')
	{
		sstr[c] = loc[3+strlen("requestedMessage")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(requestedMessagestr, sstr);

	c = 0;
	loc = strstr(payload, "connectorId");
	if(loc == NULL)
	{
		connectorIdIsNULL = TRUE;
	}
	else
	{
		memset(sstr ,0, sizeof(sstr) );
		while ((loc[strlen("connectorId")+2+c] != ',')&&(loc[strlen("connectorId")+2+c] != '}'))
		{
			sstr[c] = loc[strlen("connectorId")+2+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
		connectorIdInt = atoi(sstr);
	}


	if(connectorIdIsNULL == FALSE && ((connectorIdInt > 0)  && (connectorIdInt <= gunTotalNumber /*(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY)*/ )))
	{
		//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;
		sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Accepted] );
		sendTriggerMessageConfirmation(uuid,comfirmstr);
	}
	else if(connectorIdIsNULL == FALSE && ((connectorIdInt <= 0)  || (connectorIdInt > gunTotalNumber /*(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY)*/)  ))
	{
		sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Rejected] );
		sendTriggerMessageConfirmation(uuid,comfirmstr);
		return TRUE;
	}


	if((strcmp(requestedMessagestr, MessageTriggerStr[FirmwareStatusNotification]) != 0) &&
		(strcmp(requestedMessagestr, MessageTriggerStr[DiagnosticsStatusNotification]) != 0) &&
		(strcmp(requestedMessagestr, MessageTriggerStr[BootNotification]) != 0 ) &&
		(strcmp(requestedMessagestr, MessageTriggerStr[Heartbeat]) != 0) &&
		(strcmp(requestedMessagestr, MessageTriggerStr[MeterValues]) != 0) &&
		(strcmp(requestedMessagestr, MessageTriggerStr[StatusNotification]) != 0 ))
	{
		sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_NotImplemented] );
		sendTriggerMessageConfirmation(uuid,comfirmstr);
		return TRUE;
	}
	else
	{
		sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Accepted] );
		sendTriggerMessageConfirmation(uuid,comfirmstr);
	}

	if( strcmp(requestedMessagestr, MessageTriggerStr[FirmwareStatusNotification]) == 0)
	{
		if((FirmwareStatusNotificationStatus != 2) && (FirmwareStatusNotificationStatus != 3) && (FirmwareStatusNotificationStatus != 5) )
		{
			FirmwareStatusNotificationStatus = 3;
		}

		sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatusNotificationStatus]);
		//sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Accepted] );

	}
	else if(strcmp(requestedMessagestr, MessageTriggerStr[DiagnosticsStatusNotification]) == 0 )
	{
		//printf("DiagnosticsStatusStr[DiagnosticsStatus_Idle] =%s\n",DiagnosticsStatusStr[DiagnosticsStatus_Idle]);
		sendDiagnosticsStatusNotificationRequest(DiagnosticsStatusStr[DiagnosticsStatusNotificationStatus]);
		//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(connectorIdIsNULL == FALSE)
		{
			if((connectorIdInt > 0) && ((connectorIdInt -1) < gunTotalNumber/*(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY)*/))
			{
				ShmOCPP16Data->CsMsg.bits[connectorIdInt -1].TriggerMessageReq = 1;
				sendMeterValuesRequest(connectorIdInt -1);
				//sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Accepted] );
			}

		}
		else
		{
			for(int idx=0;idx< gunTotalNumber/*(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY)*/;idx++)
			{
				ShmOCPP16Data->CsMsg.bits[idx].TriggerMessageReq = 1;
				sendMeterValuesRequest(idx);

			}

		}

	}
	else if(strcmp(requestedMessagestr, MessageTriggerStr[StatusNotification]) == 0 )
	{
		if(connectorIdIsNULL == FALSE)
		{
			if((connectorIdInt > 0) && ((connectorIdInt -1) < gunTotalNumber/*(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY)*/))
			{
				sendStatusNotificationRequest(connectorIdInt -1);
				//sprintf(comfirmstr, "%s",TriggerMessageStatusStr[TriggerMessageStatus_Accepted] );
			}
		}
		else
		{
			for(int idx=0;idx< gunTotalNumber/*(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY)*/;idx++)
				sendStatusNotificationRequest(idx);

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

	}

	return result;
}

int handleUnlockConnectorRequest(char *uuid, char *payload)
{
	mtrace();
	int result = FAIL;
	char sstr[6]={0};
	int connectorIdInt =0;
	char comfirmstr[20]={0};
	int c = 0;
	char *loc;

//[2,"ba1cbd49-2a76-493a-8f76-fa23e7606532","UnlockConnector",{"connectorId":1}]
	DEBUG_INFO("handleUnlockConnectorRequest ...\n");
	c = 0;
	loc = strstr(payload, "connectorId");
	memset(sstr ,0, sizeof(sstr) );
	while (loc[strlen("connectorId")+2+c] != '}')
	{
		sstr[c] = loc[strlen("connectorId")+2+c];
		//printf("i=%d sstr=%c\n",c, sstr[c]);
		c++;
	}
	sstr[c] = '\0';
	connectorIdInt = atoi(sstr);
	DEBUG_INFO("\n unlock connectorIdInt=%d\n",connectorIdInt);

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

		  	  }
		  }

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

		  for (int index = 0; index < GB_QUANTITY; index++)
		  {
			  if ((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].Index == (connectorIdInt-1) ) &&((ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_CHARGING)||(ShmSysConfigAndInfo->SysInfo.GbChargingData[index].SystemStatus == SYS_MODE_IDLE)))
			  {
		  		   //stop Transaction
				  ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].UnlockConnectorReq = 1;
			  }
		  }
	  }
	  else
	  {
		  for (int index = 0; index < AC_QUANTITY; index++)
		  {
			  if ((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == (connectorIdInt-1) ) && ((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_CHARGING) || (ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_IDLE) ))
			  {
		 		  ShmOCPP16Data->CsMsg.bits[connectorIdInt-1].UnlockConnectorReq = 1;

			  }
		  }


	  }// END FOR AC ELSE





		ShmOCPP16Data->UnlockConnector[connectorIdInt-1].ConnectorId = connectorIdInt;
		strcpy((char *)ShmOCPP16Data->UnlockConnector[connectorIdInt-1].guid, uuid);
		result = TRUE;
		return result;

	}

end:
	//json_object_put(obj);  --- remove temporally
	sendUnlockConnectorConfirmation(uuid, comfirmstr);
	return result;
}

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

	sendUpdateFirmwareConfirmation(uuid);
	pthread_create(&t, NULL, UpdateFirmwareProcess, payload);
	////pthread_join(t, NULL); //
	pthread_detach(t);

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

void *UpdateFirmwareProcess(void *data)
{
	mtrace();
	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[160]={0}, retrieveDatestr[30]={0};
	//char fname[50]="00000_2018-09-07 160902_CSULog.zip";
	//char comfirmstr[20];
	int isSuccess = 0;
	char ftpbuf[200];
	char temp[100];
	char * pch;
	int retriesISNULL=FALSE;
	int retryInterval=FALSE;
	int c = 0;
	//int i = 0;
	char *loc;
	char sstr[300]={ 0 };
	char *str = (char*) data; // ?��?輸入資�?
	DEBUG_INFO("handleUpdateFirmwareRequest ...\n");

	//***************location **************/
	loc = strstr(str, "location");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while (loc[3+strlen("location")+c] != '\"')
	{
		sstr[c] = loc[3+strlen("location")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(locationstr, sstr);

	//***************retries**************/
	c = 0;
	loc = strstr(str, "retries");
	if(loc == NULL)
	{
		retriesISNULL=TRUE;
	}
	else
	{
		memset(sstr ,0, sizeof(sstr) );
		while (loc[strlen("retries")+2+c] != ',')
		{
			sstr[c] = loc[strlen("retries")+2+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';

	}

	if(retriesISNULL == FALSE)
	{
		retriesInt = atoi(sstr);
	}

	//***************retrieveDate  **************/
	loc = strstr(str, "retrieveDate");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while (loc[3+strlen("retrieveDate")+c] != '\"')
	{
		sstr[c] = loc[3+strlen("retrieveDate")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(retrieveDatestr, sstr);

	//***************retryInterval **************/
	c = 0;
	loc = strstr(str, "retryInterval");
	memset(sstr ,0, sizeof(sstr) );
	if(loc == NULL)
	{
		retryInterval=TRUE;
	}
	else
	{
		while ((loc[strlen("retryInterval")+2+c] != ',') && (loc[strlen("retryInterval")+2+c] != '}'))
		{
			sstr[c] = loc[strlen("retryInterval")+2+c];
			DEBUG_INFO("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';
	}

	if(retryInterval==FALSE)
	{
		retryIntervalInt = atoi(sstr);
	}

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

	sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_Downloading]);
	ShmOCPP16Data->MsMsg.bits.UpdateFirmwareReq = 1;

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

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

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

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

		memset(filenametemp, 0, sizeof(filenametemp));
		strncpy(filenametemp, ftppath+(ftppathlen-i+1), i+1);
		filenametemp[i+1] = 0;
		//sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_Downloading]);


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

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

		if(!isSuccess)
		{
		   	sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_DownloadFailed]);
		}
		else
		{
			//ShmOCPP16Data->MsMsg.bits.UpdateFirmwareReq = 1;
			sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_Downloaded]);
			isUpdateRequest = TRUE;
		}

	}
    else if(strncmp(locationstr,"ftp", 3) == 0) // ftp
	{
    	memset(ftpbuf, 0, sizeof(ftpbuf));
    	memset(temp, 0, sizeof(temp));
    	DEBUG_INFO("locationstr=%s\n",locationstr);
    	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)
    	{
    		int len=ftppathlen-i;
    		if(ftpbuf[len]== 47) // '/' ascll code: 47
    		{
    			DEBUG_INFO(" compare '/' all right\n");
    			break;
    		}

    		i=i+1;

    	}

    	memset(filenametemp, 0, sizeof(filenametemp));
    	strncpy(filenametemp, ftpbuf+(ftppathlen-i+1), i+1);
    	filenametemp[i+1] = 0;
    	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
    	{
    		sscanf(temp,"%[^:]:%*2[/]%[^:]:%[^@]@%[^:]:%i/%199[^\n]",
    				protocol, user, password, host, &port, path);
    	}

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

    	DEBUG_INFO("protocol =%s\n",protocol);
    	DEBUG_INFO("user =%s\n",user);
    	DEBUG_INFO("password =%s\n",password);
    	DEBUG_INFO("host1 =%s\n",host1);
    	DEBUG_INFO("port =%d\n",port);
    	DEBUG_INFO("path1 =%s\n",path1);
    	DEBUG_INFO("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, locationstr);
			 sleep(retryIntervalInt);
		}while((!isSuccess)&&(retriesInt > 0 && retriesInt --));


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

	}
    else
    {

    	sendFirmwareStatusNotificationRequest(FirmwareStatusStr[FirmwareStatus_DownloadFailed]);
    	//ShmOCPP16Data->MsMsg.bits.UpdateFirmwareReq = 1;

    }

	pthread_exit(NULL);

}

//==========================================
// Handle server response routine
//==========================================
void handleAuthorizeResponse(char *payload, int gun_index)
{
	mtrace();
	char expiryDatestr[30]={0};
	char parentIdTagstr[20]={0};
	char statusstr[20]={0};
	char expiryDatestrtemp[30]={0};
	char parentIdTagstrtemp[20]={0};
	char IdTagstrtemp[20]={0};
	char statusstrtemp[20]={0};
	int expiryDateISNULL=FALSE;
	int parentIdTagISNULL=FALSE;
	char sstr[160]={ 0 };
	char* filename = AuthorizationCache_JSON;
	char tempfile[] = "../Storage/OCPP/temp.json";
	int c = 0;
	char *loc;
	int  resultRename=0;
	int responseIdTagInfoAsZero= 0;
	char rmFileCmd[50]={0};

	DEBUG_INFO("handleAuthorizeResponse ...\n");

	//***********expiryDate*************/
	loc = strstr(payload, "expiryDate");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	if(loc == NULL)
	{
		expiryDateISNULL = TRUE;
	}
	else
	{
		while ((loc != NULL)&&(loc[3+strlen("expiryDate")+c] != '\"'))
		{
			sstr[c] = loc[3+strlen("expiryDate")+c];
			c++;
		}
		sstr[c] = '\0';
		strcpy(expiryDatestr, sstr);
	}

	//***********parentIdTag*************/
	loc = strstr(payload, "parentIdTag");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	if(loc == NULL)
	{
		parentIdTagISNULL = TRUE;
	}
	else
	{
		while ((loc != NULL)&&(loc[3+strlen("parentIdTag")+c] != '\"'))
		{
			sstr[c] = loc[3+strlen("parentIdTag")+c];
			c++;
		}
		sstr[c] = '\0';
		strcpy(parentIdTagstr, sstr);
	}

	//***********status*************/
	loc = strstr(payload, "status");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while (loc[3+strlen("status")+c] != '\"')
	{
		sstr[c] = loc[3+strlen("status")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(statusstr, sstr);

//#ifdef SystemLogMessage
//	if(expiryDateISNULL == FALSE)
//		DEBUG_INFO("expiryDate: %s\n", expiryDatestr);

//	if(parentIdTagISNULL == FALSE)
//		DEBUG_INFO("parentIdTag: %s\n", parentIdTagstr);

//	DEBUG_INFO("status: %s\n", statusstr);
//#endif

	if(expiryDateISNULL == FALSE)
		strcpy((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate, expiryDatestr);

	if(parentIdTagISNULL == FALSE)
		strcpy((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag, parentIdTagstr);

	strcpy((char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status, statusstr);

//Update idTag information to authorization cache if supproted
	if((strcmp((const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AuthorizationCacheEnabled].ItemData, "true") == 0) &&  (ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag != NULL) && (ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate != NULL) )
	{
		if((access(filename,F_OK))!=-1)
		{
			DEBUG_INFO("AuthorizationCache exist.\n");
		}
		else
		{
			DEBUG_INFO("AuthorizationCache not exist\n");
			FILE *log = fopen(filename, "w+");

			if(log == NULL)
			{
				DEBUG_INFO("log is NULL\n");
			   goto out;
			}
			else
			{
			   fclose(log);
			}
		}

		FILE *infile;
		FILE *outfile;
		// open file for writing
		infile = fopen (filename, "r");
		outfile = fopen (tempfile, "w");

		//*检测到文件结束标识返回1，否则返回0。*/
		//DEBUG_INFO("feof(infile) =%d\n",feof(infile));
		int c;
		c = fgetc(infile);
		//DEBUG_INFO("c:%d\n",c);
		rewind(infile);

		if(c == EOF)
		{
			DEBUG_INFO("Orignal File is  NULL\n");
			if(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate != NULL)
			{
				strcpy(expiryDatestrtemp, (const char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate);

			}
			else
			{
				strcpy(expiryDatestrtemp, "");

			}


			if(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag != NULL)
			{
				strcpy(parentIdTagstrtemp, (const char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag);
			}
			else
			{
				//write Authorize IdTag
				strcpy(parentIdTagstrtemp, (const char *)ShmOCPP16Data->Authorize.IdTag);
			}

			strcpy(statusstrtemp, (const char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status);

			fprintf(outfile,"[{\"idTag\":\"%s\",\"idTagInfo\":{\"expiryDate\":\"%s\",\"parentIdTag\":\"%s\",\"status\":\"%s\"}}]\n",ShmOCPP16Data->Authorize.IdTag, expiryDatestrtemp, parentIdTagstrtemp, statusstrtemp);
			fclose(infile);
			fclose(outfile);

			sprintf(rmFileCmd,"rm -f %s",filename);
			system(rmFileCmd);

			resultRename = rename(tempfile, filename);

			if(resultRename == 0)
			{
				DEBUG_INFO("File renamed successfully");
			}
			else
			{
				DEBUG_INFO("Error: unable to rename the file");
			}

		}
		else
		{
			char buf[160]={0};


			//DEBUG_INFO("Orignal File is not NULL\n");
			while (fgets(buf, sizeof(buf), infile) != NULL)
			{
				//DEBUG_INFO("Orignal File is not NULL-1\n");
			    buf[strlen(buf) - 1] = '\0'; // eat the newline fgets() stores


			    memset(expiryDatestr, 0, sizeof(expiryDatestrtemp));
			    memset(parentIdTagstr,0, sizeof(parentIdTagstrtemp));
			    memset(statusstr, 0, sizeof(statusstrtemp));
			    memset(IdTagstrtemp, 0, sizeof(IdTagstrtemp));
			    memset(expiryDatestrtemp, 0, sizeof(expiryDatestrtemp));
			    memset(parentIdTagstrtemp, 0, sizeof(parentIdTagstrtemp));
			    memset(statusstrtemp, 0, sizeof(statusstrtemp));


			    //------------------IdTag-----------------------
			    loc = strstr(buf, "idTag");
			 	memset(sstr ,0, sizeof(sstr) );
			 	c = 0;
			 	while (loc[3+strlen("idTag")+c] != '\"')
			 	{
			 		sstr[c] = loc[3+strlen("idTag")+c];
			 		c++;
			 	}
			 	sstr[c] = '\0';
			 	strcpy(IdTagstrtemp,sstr);


			    //*********************expiryDate***************/
			    loc = strstr(buf, "expiryDate");
				memset(sstr ,0, sizeof(sstr) );
				c = 0;
				while (loc[3+strlen("expiryDate")+c] != '\"')
				{
					sstr[c] = loc[3+strlen("expiryDate")+c];
					c++;
				}
				sstr[c] = '\0';
				strcpy(expiryDatestr,sstr);


				//*********************parentIdTag***************/
				loc = strstr(buf, "parentIdTag");
				memset(sstr ,0, sizeof(sstr) );
				c = 0;
				while (loc[3+strlen("parentIdTag")+c] != '\"')
				{
					sstr[c] = loc[3+strlen("parentIdTag")+c];
					c++;
				}
				sstr[c] = '\0';
				strcpy(parentIdTagstr,sstr);


				//*********************status***************/
				loc = strstr(buf, "status");
				memset(sstr ,0, sizeof(sstr) );
				c = 0;
				while (loc[3+strlen("status")+c] != '\"')
				{
					sstr[c] = loc[3+strlen("status")+c];
					c++;
				}
				sstr[c] = '\0';
				strcpy(statusstr,sstr);


				if(((ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag == NULL) || strcmp((const char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag, "") == 0) || (strcmp((const char *)ShmOCPP16Data->Authorize.IdTag, IdTagstrtemp) == 0))
				{
					DEBUG_INFO("ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag is NULL\n");
					responseIdTagInfoAsZero = 1;
				}
				else
				{
					DEBUG_INFO("ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag=%s\n",ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag);
				}

				if((responseIdTagInfoAsZero == 0)&&((strcmp(parentIdTagstr,(const char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag) == 0)|| (strcmp(IdTagstrtemp,(const char *)ShmOCPP16Data->Authorize.IdTag) == 0)))
				{
					//modify item

					if(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate != NULL)
					{
						strcpy(expiryDatestrtemp,(const char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate);
						//json_object_object_add(temp_obj, "expiryDate", json_object_new_string(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ExpiryDate));
					}
					else
					{
						strcpy(expiryDatestrtemp, "");
						//json_object_object_add(temp_obj, "expiryDate", json_object_new_string(""));
					}


					if(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag != NULL)
					{
						strcpy(parentIdTagstrtemp,(const char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag);
						//json_object_object_add(temp_obj, "parentIdTag", json_object_new_string(ShmOCPP16Data->Authorize.ResponseIdTagInfo.ParentIdTag));

					}
					else
					{
						strcpy(parentIdTagstrtemp, parentIdTagstr);
					    //json_object_object_add(temp_obj, "parentIdTag", json_object_new_string(json_object_get_string(parentIdTagitem)));

					}
					strcpy(statusstrtemp,(const char *)ShmOCPP16Data->Authorize.ResponseIdTagInfo.Status);

				}
				else
				{

					//wrie original item
					strcpy(expiryDatestrtemp, expiryDatestr);
					strcpy(parentIdTagstrtemp, parentIdTagstr);
					strcpy(statusstrtemp, statusstr);
				}

				fprintf(outfile,"[{\"idTag\":\"%s\",\"idTagInfo\":{\"expiryDate\":\"%s\",\"parentIdTag\":\"%s\",\"status\":\"%s\"}}]\n",ShmOCPP16Data->Authorize.IdTag,expiryDatestrtemp, parentIdTagstrtemp, statusstrtemp);

			}

			fclose(infile);
			fclose(outfile);



			sprintf(rmFileCmd,"rm -f %s",filename);
			system(rmFileCmd);

			resultRename = rename(tempfile, filename);

			if(resultRename == 0)
			{
				DEBUG_INFO("File renamed successfully");
			}
			else
			{
				DEBUG_INFO("Error: unable to rename the file");
			}
		}
	}

	out:
	ShmOCPP16Data->SpMsg.bits.AuthorizeReq = 0;
	ShmOCPP16Data->SpMsg.bits.AuthorizeConf = 1; // inform csu
	authorizeRetryTimes = 0;
}

void handleBootNotificationResponse(char *payload, int gun_index)
{
	mtrace();
	char sstr[140]={ 0 };//sstr[200]={ 0 };
	char statusStr[12]={0};
	char currentTimeStr[30]={0};
	char *loc;
	int intervalInt = 0;
	int c = 0;
	//double diff_t;
	struct tm tp;
	char buf[28]={0};
	char timebuf[50]={0};

	DEBUG_INFO("handleBootNotificationResponse ...\n");

	//*** interval ****/
	c = 0;
	loc = strstr(payload, "interval");
	//printf("loc=%s\n",loc);
	memset(sstr ,0, sizeof(sstr) );

	while ((loc != NULL) &&(loc[strlen("interval")+2+c] != ',') &&(loc[strlen("interval")+2+c] != '}')  )
	{
		sstr[c] = loc[strlen("interval")+2+c];
		//printf("i=%d sstr=%c\n",c, sstr[c]);
		c++;
	}
	sstr[c] = '\0';
	//DEBUG_INFO("id=%d\n",atoi(sstr));
	intervalInt = atoi(sstr);


    //***status ****/
    loc = strstr(payload, "status");
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while ((loc != NULL) &&(loc[3+strlen("status")+c] != '\"'))
	{
		sstr[c] = loc[3+strlen("status")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(statusStr, sstr);


	//***currentTime ****/
    loc = strstr(payload, "currentTime");
	//printf("loc=%s\n",loc);
	memset(sstr ,0, sizeof(sstr) );
	c = 0;
	while ((loc != NULL) &&(loc[3+strlen("currentTime")+c] != '\"'))
	{
		sstr[c] = loc[3+strlen("currentTime")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy(currentTimeStr, sstr);

	BootNotificationInterval = ShmOCPP16Data->BootNotification.ResponseHeartbeatInterval = intervalInt;
	HeartBeatWaitTime = BootNotificationInterval;


//#ifdef SystemLogMessage
//	DEBUG_INFO("currentTime: %s\n", currentTimeStr);
//	DEBUG_INFO("interval: %d\n", intervalInt);
//	DEBUG_INFO("status: %s\n", statusStr);
//#endif

	//write back to ShmOCPP16Data->BootNotification
	strcpy((char *)ShmOCPP16Data->BootNotification.ResponseCurrentTime, currentTimeStr);
	ShmOCPP16Data->BootNotification.ResponseHeartbeatInterval = intervalInt;
	strcpy((char *)ShmOCPP16Data->BootNotification.ResponseStatus, statusStr);

   	if((strcmp(statusStr, 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(statusStr, RegistrationStatusStr[RegistrationStatus_Pending]) == 0)
	{
		server_pending = TRUE;
	}


	strptime((const char *)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);
	//DEBUG_INFO("timebuf=%s\n",timebuf);
	system(timebuf);

	//==============================================
	// RTC sync
	//==============================================
	system("/sbin/hwclock -w --systohc");

	ShmOCPP16Data->OcppConnStatus = 1; ////0: disconnected, 1: connected
	ShmOCPP16Data->SpMsg.bits.BootNotificationConf = 1;

}

void handleDataTransferResponse(char *payload, int gun_index)
{
	char sstr[160]={0};//sstr[200]={ 0 };
	int c = 0;
	char *loc;
	DEBUG_INFO("handleDataTransferResponse ...\n");
	loc = strstr(payload, "status");
	printf("loc=%s\n",loc);
	c = 0;
	while (loc[3+strlen("status")+c] != '\"')
	{
		sstr[c] = loc[3+strlen("status")+c];
		//printf("i=%d sstr=%c\n",c, sstr[c]);
		c++;
	}
	sstr[c] = '\0';

	DEBUG_INFO(" DataTransferResponse=%s\n", sstr);
	//#ifdef SystemLogMessage
	//DEBUG_INFO("data: %s\n", payload);
	//#endif
}

void handleDiagnosticsStatusNotificationResponse(char *payload, int gun_index)
{
	DEBUG_INFO("handleDiagnosticsStatusNotificationResponse ...\n");
	//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)
{
	DEBUG_INFO("handleFirmwareStatusNotificationResponse ...\n");
	//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)
{
	mtrace();
	//double diff_t;
	struct tm tp;
	char buf[28]={0};
	char timebuf[50]={0};
	char sstr[30]={ 0 };
	int c = 0;
	char *loc;
//[3,"9c2e3c41-ab34-409e-8902-f5f48b6de641",{"currentTime":"2018-09-06T02:22:57.171Z"}]

	DEBUG_INFO("handleHeartbeatResponse ...\n");
	c = 0;
	loc = strstr(payload, "currentTime");
	memset(sstr ,0, sizeof(sstr) );
	while (loc[3+strlen("currentTime")+c] != '\"')
	{
		sstr[c] = loc[3+strlen("currentTime")+c];
		c++;
	}
	sstr[c] = '\0';
	strcpy((char *)ShmOCPP16Data->Heartbeat.ResponseCurrentTime,sstr);

//	#ifdef SystemLogMessage
//	DEBUG_INFO("currentTime: %s\n", ShmOCPP16Data->Heartbeat.ResponseCurrentTime);
//	#endif

	strptime((const char *)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);
	system(timebuf);

	//==============================================
	// RTC sync
	//==============================================
	system("/sbin/hwclock -w --systohc");

	if(FirstHeartBeat == 0)
	{
		FirstHeartBeat = 1;
	}

	HeartBeatWithNOResponse = 0;

}

void handleMeterValuesResponse(char *payload, int gun_index)
{
	mtrace();
	//struct json_object *obj;
	DEBUG_INFO("handleMeterValuesResponse ...\n");

	//No fields are defined.
}

void handleStartTransactionResponse(char *payload, int gun_index)
{
	mtrace();
	char sstr[30]={ 0 };
	int c = 0;
	char *loc;
	int transactionIdInt = 0;
//[3,"f7da35db-9d9b-4362-841f-26424be1064f",{"idTagInfo":{"expiryDate":"2020-06-19T01:10:00.000Z","parentIdTag":"1UF1YvGvmNbLF17sP6LY","status":"Accepted"},"transactionId":2146754131}]
	DEBUG_INFO("handleStartTransactionResponse\n");

	//****************expiryDate********************/

	loc = strstr(payload, "expiryDate");
	if(loc == NULL)
	{
		strcpy((char *)ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.ExpiryDate, "");
	}
	else
	{
		c = 0;
		memset(sstr ,0, sizeof(sstr) );
		while (loc[3+strlen("expiryDate")+c] != '\"')
		{
			sstr[c] = loc[3+strlen("expiryDate")+c];
			c++;
		}
		sstr[c] = '\0';
		sprintf((char *)ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.ExpiryDate, "%s", sstr);
	}



	//****************parentIdTag********************/

	loc = strstr(payload, "parentIdTag");
	if(loc == NULL)
	{
		strcpy((char *)ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.ParentIdTag, "");
	}
	else
	{
		c = 0;
		memset(sstr ,0, sizeof(sstr) );
		while (loc[3+strlen("parentIdTag")+c] != '\"')
		{
			sstr[c] = loc[3+strlen("parentIdTag")+c];
			c++;
		}
		sstr[c] = '\0';
		sprintf((char *)ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.ParentIdTag, "%s", sstr);
	}


	//****************status********************/

	loc = strstr(payload, "status");
	if(loc == NULL)
	{
		strcpy((char *)ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.Status, "");
	}
	else
	{
		c = 0;
		memset(sstr ,0, sizeof(sstr) );
		while (loc[3+strlen("status")+c] != '\"')
		{
			sstr[c] = loc[3+strlen("status")+c];
			c++;
		}
		sstr[c] = '\0';
		sprintf((char *)ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.Status, "%s", sstr);
	}


	//****************transactionId********************/
	 c=0;
	 loc = strstr(payload, "transactionId");
	 memset(sstr ,0, sizeof(sstr) );
	 while ((loc[strlen("transactionId")+2+c] != '}') && (loc[strlen("transactionId")+2+c] != ','))
	 {
		sstr[c] = loc[strlen("transactionId")+2+c];
		c++;
	}
	sstr[c] = '\0';
	ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId = atoi(sstr);
	transactionIdInt = ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId;
	ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionConf = 1;
	ShmOCPP16Data->CpMsg.bits[gun_index].StartTransactionReq = 0;

#ifdef SystemLogMessage
DEBUG_INFO("idTagInfo-expiryDate: %s\n", ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.ExpiryDate);
DEBUG_INFO("idTagInfo-parentIdTag: %s\n", ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.ParentIdTag);
DEBUG_INFO("idTagInfo-status: %s\n", ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.Status);
DEBUG_INFO("transactionId: %d\n", ShmOCPP16Data->StartTransaction[gun_index].ResponseTransactionId);
#endif

	if(strcmp((const char *)ShmOCPP16Data->StartTransaction[gun_index].ResponseIdTagInfo.Status, "Accepted") == 0)
	{
		//add Charging Record
		SettingChargingRecord(gun_index, transactionIdInt);

	}
}

void handleStatusNotificationResponse(char *payload, int gun_index)
{
	mtrace();
	printf("handleStatusNotificationResponse\n");

	cpinitateMsg.bits[gun_index].StatusNotificationReq = 0;
	cpinitateMsg.bits[gun_index].StatusNotificationConf = 1;

}

void handleStopTransactionnResponse(char *payload, int gun_index)
{
	mtrace();
	char sstr[30]={ 0 };
	int c = 0;
	char *loc;
	//[3,"e79c0728-dd4c-4038-a90e-bb0eb23e1ee0",{"idTagInfo":{"expiryDate":"2020-06-19T01:10:00.000Z","parentIdTag":"1UF1YvGvmNbLF17sP6LY","status":"Accepted"}}]

	ShmOCPP16Data->CpMsg.bits[gun_index].StopTransactionConf = 1;
	ShmOCPP16Data->CpMsg.bits[gun_index].StopTransactionReq = 0;

	loc = strstr(payload, "idTagInfo");
	//***********************idTagInfo************************/
	if(loc != NULL)
	{
		//***********************expiryDate************************/
		loc = strstr(payload, "expiryDate");

		if(loc != NULL)
		{
			memset(sstr ,0, sizeof(sstr) );
			c = 0;
			while (loc[3+strlen("expiryDate")+c] != '\"')
			{
				sstr[c] = loc[3+strlen("expiryDate")+c];
				c++;
			}
			sstr[c] = '\0';
			sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].ResponseIdTagInfo.ExpiryDate, "%s", sstr);
		}


		//***********************parentIdTag************************/
		loc = strstr(payload, "parentIdTag");

		if(loc != NULL)
		{
			memset(sstr ,0, sizeof(sstr) );
			c = 0;
			while (loc[3+strlen("parentIdTag")+c] != '\"')
			{
				sstr[c] = loc[3+strlen("parentIdTag")+c];
				c++;
			}
			sstr[c] = '\0';
			sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].ResponseIdTagInfo.ParentIdTag, "%s", sstr);
		}


		//***********************status************************/
		loc = strstr(payload, "status");
		memset(sstr ,0, sizeof(sstr) );
		c = 0;
		while (loc[3+strlen("status")+c] != '\"')
		{
			sstr[c] = loc[3+strlen("status")+c];
			c++;
		}
		sstr[c] = '\0';
		sprintf((char *)ShmOCPP16Data->StopTransaction[gun_index].ResponseIdTagInfo.Status, "%s", sstr);

	}


#ifdef SystemLogMessage
DEBUG_INFO("idTagInfo-expiryDate: %s\n", ShmOCPP16Data->StopTransaction[gun_index].ResponseIdTagInfo.ExpiryDate);
DEBUG_INFO("idTagInfo-parentIdTag: %s\n", ShmOCPP16Data->StopTransaction[gun_index].ResponseIdTagInfo.ParentIdTag);
DEBUG_INFO("idTagInfo-status: %s\n", ShmOCPP16Data->StopTransaction[gun_index].ResponseIdTagInfo.Status);
#endif

}

//==========================================
// Handle Error routine
//==========================================
void handleError(char *id, char *errorCode, char *errorDescription,char *payload)
{
	mtrace();
	#ifdef SystemLogMessage
	DEBUG_INFO("errorCode: %s\n", errorCode);

	DEBUG_INFO("errorDescription: %s\n", errorDescription);

	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" );

	//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, "Current.Export,Energy.Active.Export.Interval,Power.Active.Export,Voltage,SOC" );

	// MeterValuesAlignedDataMaxLength
	ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedDataMaxLength].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedDataMaxLength].ItemName, "MeterValuesAlignedDataMaxLength");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesAlignedDataMaxLength].ItemData, "5" );

	// MeterValuesSampledData
	ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledData].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledData].ItemName, "MeterValuesSampledData");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledData].ItemData, "Current.Export,Energy.Active.Export.Interval,Power.Active.Export,Voltage,SOC" );

	// MeterValuesSampledDataMaxLength
	ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledDataMaxLength].ItemAccessibility = 0;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledDataMaxLength].ItemName, "MeterValuesSampledDataMaxLength");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValuesSampledDataMaxLength].ItemData, "5" );

	// 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" );
	TransactionMessageAttemptsValue = atoi((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageAttempts].ItemData);

	// TransactionMessageRetryInterval
	ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemName, "TransactionMessageRetryInterval");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemData, "60" );
	TransactionMessageRetryIntervalValue = atoi((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemData);

	// 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*/
#if 0
	//For OCTT Test Case
	ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemName, "LocalAuthorizationListEnabled");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData, "TRUE" );
#endif

#if 1
	//LocalAuthListEnabled
	ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemAccessibility = 1;
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemName, "LocalAuthListEnabled");
	strcpy((char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData, "TRUE" );
#endif

	//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" );

	return 0;
}



void getKeyValue(char *keyReq)
{
	 int isEmpty = FALSE;
	 int isKnowKey = FALSE;
	 //int unKnowIndex = 0;

	 DEBUG_INFO("getKeyValue \n");

	 if((keyReq == NULL) || (strlen(keyReq) == 0))
	     isEmpty = TRUE;

	 if(isEmpty || strcmp(keyReq, "AllowOfflineTxForUnknownId") == 0)
	 {
		strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_AllowOfflineTxForUnknownId].Item, "AllowOfflineTxForUnknownId");
		strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AllowOfflineTxForUnknownId].Key, "AllowOfflineTxForUnknownId");
		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"*/);
		}

		strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_AllowOfflineTxForUnknownId].Value, (const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[AllowOfflineTxForUnknownId].ItemData );
		isKnowKey = TRUE;
	 }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	    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;

	    }

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

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

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

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

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

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

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

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

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

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

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

	      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;

	      }

	      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;

	      }

#if 0
	      //For OCTT Test Case
	      if(isEmpty ||  strcmp(keyReq, "LocalAuthorizationListEnabled") == 0 )
	      {
	     	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.Key[GetConfiguration_LocalAuthListEnabled].Item, "LocalAuthorizationListEnabled");
	     	    	  strcpy((char *)ShmOCPP16Data->GetConfiguration.ResponseConfigurationKey[GetConfiguration_LocalAuthListEnabled].Key, "LocalAuthorizationListEnabled");

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

#if 1
	      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;
	      }
#endif

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

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

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

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

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

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

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

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

	     //=========================================================

	      if(!isEmpty && !isKnowKey)
	      {
	    	 DEBUG_INFO("unKnowIndex =%d\n", UnknownKeynum);
	    	 strcpy(unknownkey[UnknownKeynum], keyReq);
			 UnknownKeynum = UnknownKeynum + 1;
	      }


}

void processUnkownKey(void)
{

	DEBUG_INFO("processUnkownKey\n");
	memset(ShmOCPP16Data->GetConfiguration.ResponseUnknownKey, 0 , sizeof(struct StructConfigurationKeyItems)* 10);

	for(int index=0; index < UnknownKeynum; index++)
	{
		if(ShmOCPP16Data->GetConfiguration.ResponseUnknownKey[index].Item[0] == 0)
		{
			strcpy((char *)(ShmOCPP16Data->GetConfiguration.ResponseUnknownKey[index].Item), unknownkey[index]);
		}
	}

}

 int  setKeyValue(char *key, char *value)
{
	int isSuccess = NotSupported;
	int check_ascii=0;

#ifdef Debug
	DEBUG_INFO(" setKeyValue key-value=%s  %s\n",key,value);
#endif

    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, "%s", (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, "%s", value/*(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, "%s", (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)
    	{
    		check_ascii = value[0];
    		if( (check_ascii < 48) || (check_ascii > 57) )
    		{
    			isSuccess = ConfigurationStatus_Rejected;
    		}
    		else
    		{
    			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)
    	{
    		check_ascii = value[0];
    		if( (check_ascii < 48) || (check_ascii > 57) )
    		{
    		   isSuccess = ConfigurationStatus_Rejected;
    		}
    		else
    		{
    			//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)
    	{
    		check_ascii = value[0];
    		if( (check_ascii < 48) || (check_ascii > 57) )
    		{
    			isSuccess = ConfigurationStatus_Rejected;
    		}
    		else
    		{
    			//Charger.ConnectionTimeOut = Integer.parseInt(value)*1000;
    			sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[ConnectionTimeOut].ItemData, "%d", atoi(value));
    			isSuccess = ConfigurationStatus_Accepted;
    		}
    	}
    	else
        {
        	isSuccess = ConfigurationStatus_Rejected;
        }

    }

    if(strcmp(key, "HeartbeatInterval") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[HeartbeatInterval].ItemAccessibility == 1)
    	{
    		check_ascii = value[0];
    		if( (check_ascii < 48) || (check_ascii > 57) )
    	    {
    	    	isSuccess = ConfigurationStatus_Rejected;
    	    }
    		else
    		{
    			//Charger.HeartbeatInterval = Integer.parseInt(value)*1000;
    			sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[HeartbeatInterval].ItemData, "%d", atoi(value)/*atoi(value)*1000*/ );
    			HeartBeatWaitTime = atoi(value);
    			isSuccess = ConfigurationStatus_Accepted;
    		}

    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}

    }

    if(strcmp(key, "LightIntensity") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[LightIntensity].ItemAccessibility == 1)
    	{
    		check_ascii = value[0];
    		if( (check_ascii < 48) || (check_ascii > 57) )
    		{
    			isSuccess = ConfigurationStatus_Rejected;
    		}
    		else
    		{
    			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)
    	{
    		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalAuthorizeOffline].ItemData, "%s", (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)
    	{
    	    sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[LocalPreAuthorize].ItemData, "%s", (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)
    	{
    		check_ascii = value[0];
    		if( (check_ascii < 48) || (check_ascii > 57) )
    		{
    			isSuccess = ConfigurationStatus_Rejected;
    		}
    		else
    		{
    			 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)
    	{
    	 	//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)
    	{
     		//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)
    	{
    		check_ascii = value[0];
    		if( (check_ascii < 48) || (check_ascii > 57) )
    		{
    			isSuccess = ConfigurationStatus_Rejected;
    		}
    		else
    		{
    			//Charger.MeterValueSampleInterval = Integer.parseInt(value)*1000;
    			sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[MeterValueSampleInterval].ItemData, "%d", atoi(value));
    			isSuccess = ConfigurationStatus_Accepted;
    		}

#ifdef Debug
		DEBUG_INFO(" MeterValueSampleInterval is ConfigurationStatus_Accepted \n");
#endif
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
#ifdef Debug
		DEBUG_INFO(" MeterValueSampleInterval is ConfigurationStatus_Rejected \n");
#endif
    	}

    }

    if(strcmp(key, "MinimumStatusDuration") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[MinimumStatusDuration].ItemAccessibility == 1)
    	{
    		check_ascii = value[0];
    		if( (check_ascii < 48) || (check_ascii > 57) )
    		{
    		   isSuccess = ConfigurationStatus_Rejected;
    		}
    		else
    		{
    			//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)
    	{
    		check_ascii = value[0];
    		if( (check_ascii < 48) || (check_ascii > 57) )
    		{
    			isSuccess = ConfigurationStatus_Rejected;
    		}
    		else
    		{
    			//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, "%s", (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, "%s", (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)
    	{
    		check_ascii = value[0];
    		if( (check_ascii < 48) || (check_ascii > 57) )
    		{
    		   isSuccess = ConfigurationStatus_Rejected;
    		}
    		else
    		{
    			//Charger.TransactionMessageAttempts = Integer.parseInt(value);
    			sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageAttempts].ItemData, "%d", atoi(value) );
    			TransactionMessageAttemptsValue = atoi(value);
    			isSuccess = ConfigurationStatus_Accepted;
    		}
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}
    }

    if(strcmp(key, "TransactionMessageRetryInterval") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemAccessibility == 1)
    	{
    		check_ascii = value[0];
    		if( (check_ascii < 48) || (check_ascii > 57) )
    		{
    		    isSuccess = ConfigurationStatus_Rejected;
    		}
    		else
    		{
    			//Charger.TransactionMessageRetryInterval = Integer.parseInt(value)*1000;
    			sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemData, "%d", atoi(value) );
    			TransactionMessageRetryIntervalValue = atoi(value);
    			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, "%s", (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)
    	{
    		check_ascii = value[0];
    		if( (check_ascii < 48) || (check_ascii > 57) )
    		{
    			isSuccess = ConfigurationStatus_Rejected;
    		}
    		else
    		{

        		sprintf((char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[WebSocketPingInterval].ItemData, "%d", atoi(value) );
        		isSuccess = ConfigurationStatus_Accepted;
    		}
    	}
    	else
    	{
    	    isSuccess = ConfigurationStatus_Rejected;
    	}
    }

#if 0
    //For OCPP Test Case
    if(strcmp(key, "LocalAuthorizationListEnabled") == 0)
    {
        if(ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemAccessibility == 1)
        {
            sprintf((char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData, "%s", (strcmp(value, "true")==0) ?"TRUE":"FALSE" );
        	isSuccess = ConfigurationStatus_Accepted;
        	//updateSetting("LocalAuthorizationListEnabled", (char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData);
        }
        else
        {
            isSuccess = ConfigurationStatus_Rejected;
        }

    }
#endif

#if 1
    if(strcmp(key, "LocalAuthListEnabled") == 0)
    {
    	if(ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemAccessibility == 1)
    	{
        	sprintf((char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData, "%s", (strcmp(value, "true")==0) ?"TRUE":"FALSE" );
    		isSuccess = ConfigurationStatus_Accepted;
    		updateSetting("LocalAuthListEnabled", (char *)ShmOCPP16Data->ConfigurationTable.LocalAuthListManagementProfile[LocalAuthListEnabled].ItemData);
    	}
    	else
        {
        	isSuccess = ConfigurationStatus_Rejected;
        }

    }
#endif

    return isSuccess;
}

int updateSetting(char *key, char *value)
{
	mtrace();
    int isSuccess = FALSE;
    char string[1000]={0}, buffer[1000]={0};
    char strtemp[50]={0};
    char sstr[50]={ 0 };//sstr[200]={ 0 };
    int pos, c = 0;
    char *loc;
    int pos1=0;

	FILE *f = fopen("/var/www/settings1", "r");
	if(f == NULL)
	{
#ifdef Debug
	DEBUG_ERROR("/var/www/settings1 does not exist!\n");
#endif
		return isSuccess;
	}

	fseek(f, 0, SEEK_END);
	long fsize = ftell(f);
	fseek(f, 0, SEEK_SET);  /* same as rewind(f); */


	fread(string, 1, fsize, f);
	fclose(f);
	string[fsize] = 0;
	loc = strstr(string, key);

	if(loc != NULL)
	{
		DEBUG_INFO("key exist!\n");
		pos = loc - string-1;
		f = fopen("/var/www/settings1", "w");

		strncpy(buffer, string, pos);
		fprintf(f, "%s", buffer);

		memset(sstr ,0, sizeof(sstr) );
		c = 0;
		while (loc[3+strlen(key/*"LocalAuthListEnabled"*/)+c] != '\"')
		{
			sstr[c] = loc[3+strlen(key/*"LocalAuthListEnabled"*/)+c];
			//printf("i=%d sstr=%c\n",c, sstr[c]);
			c++;
		}
		sstr[c] = '\0';

		pos1 =  fsize -pos -(3+strlen(key/*"LocalAuthListEnabled"*/)+c)-1;

		sprintf(strtemp,"\"%s\":\"%s\"",key,value);

		fprintf(f, "%s", strtemp /*"\"LocalAuthListEnabled\":\"fault\""*/);

		memset(buffer ,0, sizeof(buffer) );

		strncpy(buffer, loc+(3+strlen(key/*"LocalAuthListEnabled"*/)+c)+1, pos1);
		//printf("buffer=%s",buffer);

		fprintf(f, "%s", buffer);

		fclose(f);

	}
	else
	{
		printf("key not exist!\n");
		f = fopen("/var/www/settings1", "w+");
		fputs(string, f);
		fseek(f, -1, SEEK_CUR);
		//fprintf(f, "%s", ",\"LocalAuthListEnabled\":\"true\"}");
		sprintf(strtemp,",\"%s\":\"%s\"}",key,value);
		fputs(strtemp/*",\"LocalAuthListEnabled\":\"true\"}"*/, f);
		fclose(f);

	}

	isSuccess = TRUE;

	return isSuccess;
}

int TransactionMessageAttemptsGet(void)
{
	return TransactionMessageAttemptsValue;//atoi((const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageAttempts].ItemData);
}

int FirstHeartBeatResponse(void)
{
	return FirstHeartBeat;
}


int TransactionMessageRetryIntervalGet(void)
{
	return TransactionMessageRetryIntervalValue;//atoi((const char *)ShmOCPP16Data->ConfigurationTable.CoreProfile[TransactionMessageRetryInterval].ItemData);
}

#define SA struct sockaddr
#define MAXBUF 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;
    DEBUG_INFO("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);

    DEBUG_INFO("%s\n",ptr);
    DEBUG_INFO("status=%d\n",status);
    DEBUG_INFO("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;
    DEBUG_INFO("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

        DEBUG_INFO("Content-Length: %d\n",bytes_received);
    }
    DEBUG_INFO("End HEADER ..\n");
    return  bytes_received ;

}

int httpDownLoadFile(char *location, char *path, char *filename,char *url)
{
	char rmFileCmd[100]={0};
    char FilePath[100]={0};
	char ftpbuf[200];
	int systemresult;

	DEBUG_INFO("filename=%s\n",filename);
	DEBUG_INFO("url=%s\n",url);
	sprintf(FilePath,"../mnt/%s",filename);

	if((access(FilePath,F_OK))!=-1)
	{
		DEBUG_INFO("filename=%s exist.\n",FilePath);
		sprintf(rmFileCmd,"rm -f %s",FilePath);
		system(rmFileCmd);
	}
	memset(ftpbuf, 0, sizeof(ftpbuf));
	sprintf(ftpbuf, "wget --tries=3 -O ../mnt/%s -c %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);

	DEBUG_INFO("systemresult=%d\n",systemresult);
	if(systemresult != 0)
	{
		DEBUG_INFO("http DownLoad error!\n");
		return FALSE;
	}

	return TRUE;
}

int ftpDownLoadFile(char *location, char *user, char *password, int port, char *path, char *filename,char *url)
{
	char rmFileCmd[100]={0};
	char FilePath[100]={0};
	char ftpbuf[200];
	int systemresult;
	//char temp[100];
#if 0
	struct hostent* server;
	char *IPbuffer;
	server = gethostbyname(location);

	// To convert an Internet network
	// address into ASCII string
	IPbuffer = inet_ntoa(*((struct in_addr*)
				 	 server->h_addr_list[0]));
#endif
	sprintf(FilePath,"../mnt/%s",filename);

	if((access(FilePath,F_OK))!=-1)
	{
		DEBUG_INFO("filename=%s exist.\n",FilePath);
		sprintf(rmFileCmd,"rm -f %s",FilePath);
		system(rmFileCmd);
	}

	memset(ftpbuf, 0, sizeof(ftpbuf));

	sprintf(ftpbuf, "wget --tries=3 -O ../mnt/%s -c %s",filename, url);
	//sprintf(ftpbuf, "ftpget -u %s -p %s %s -P %d %s %s%s",user,password,IPbuffer,port/*21*/,filename,path,filename); --- remove temporally
	DEBUG_INFO("ftpbuf=%s\n",ftpbuf);
		//sprintf(ftpbuf, "ftpput -u %s -p %s %s -P %d %s%s %s",user,password,IPbuffer,21,filename,filename,path);
	systemresult = system(ftpbuf);

	DEBUG_INFO("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 *fnamePlusPath,char *filename)
{
	 struct hostent* server;
	 char *IPbuffer;
	 char ftpbuf[200];
	 int systemresult;

	  // 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,fnamePlusPath);
	DEBUG_INFO("ftpbuf=%s\n",ftpbuf);
	//sprintf(ftpbuf, "ftpput -u %s -p %s %s -P %d %s%s %s",user,password,IPbuffer,21,filename,filename,path);
	systemresult = system(ftpbuf);

	DEBUG_INFO("systemresult=%d\n",systemresult);
	if(systemresult != 0)
	{
		DEBUG_INFO("ftpput error!\n");
		return FALSE;
	}

	return TRUE;

}


int SettingChargingRecord(int target, int transactionId)
{
	if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
	{
		for (int index = 0; index < CHAdeMO_QUANTITY; index++)
		{
			if ((ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].Index == target)&&(ShmSysConfigAndInfo->SysInfo.ChademoChargingData[index].SystemStatus == SYS_MODE_CHARGING))
			{
				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 == SYS_MODE_CHARGING))
			{
				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 == SYS_MODE_CHARGING))
			{
					 addBuff(target, transactionId, 0);
					 return TRUE;
			}
		}

	}
	else
	{
		for (int index = 0; index < AC_QUANTITY; index++)
		{
			if ((ShmSysConfigAndInfo->SysInfo.AcChargingData[index].Index == target)&&(ShmSysConfigAndInfo->SysInfo.AcChargingData[index].SystemStatus == SYS_MODE_CHARGING))
			{
				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;
}

static int selectSqlCount = 0;
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);

   //idTag
   sprintf(idTagAuthorization,"%s", argv[1] ? argv[1] : "NULL");
   sprintf(idTagQuery.idTagstr,"%s", argv[1] ? argv[1] : "NULL");

   //parentIdTag
   sprintf(idTagQuery.parentIdTag,"%s", argv[2] ? argv[2] : "NULL");

   //expir_date
   sprintf(idTagQuery.expiryDate,"%s", argv[3] ? argv[3] : "NULL");

   //status
   sprintf(idTagQuery.idTagstatus,"%s", argv[4] ? argv[4] : "NULL");

   //version
   idTagQuery.listVersionInt = atoi(argv[5]);

   DEBUG_INFO("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++){
	   DEBUG_INFO("%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;
}

/** sqlite3_exec的回调。
 *
 *  向控制台打印查询的结果。
 *
 *  @param in data 传递给回调函数的数据。
 *  @param in n_columns sqlite3_exec执行结果集中列的数量。
 *  @param in col_values sqlite3_exec执行结果集中每一列的数据。
 *  @param in col_names sqlite3_exec执行结果集中每一列的名称。
 *  @return 状态码。
 */
int sqlite3_exec_callback(void *data, int n_columns, char **col_values, char **col_names)
{
    for (int i = 0; i < n_columns; i++)
    {
    	DEBUG_INFO("%s/t", col_values[i]);
    }
    DEBUG_INFO("/n");

    return 0;
}

void OCPP_getListVerion()
{
    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 */
    rc = sqlite3_exec(db, sql, versioncallback, 0, (char **)&zErrMsg);
    DEBUG_INFO("rc=%d\n",rc);
    if( rc != SQLITE_OK ){
    	DEBUG_INFO("SQL error: %s", zErrMsg);
          //sqlite3_free(zErrMsg);
    }else{
    	DEBUG_INFO("Operation done successfully");
    }
}

void OCPP_getIdTag(char *idTag)
{
    int rc = 0;
   // const char* data = "Callback function called";
    char sql[100];
    char zErrMsg[100];

    memset(sql, 0, 100);
    memset(zErrMsg, 0, 100);
    memset(idTagAuthorization, 0, sizeof(idTagAuthorization));
    memset(&idTagQuery, 0, sizeof(idTagQuery));


    sprintf(sql,"select * from ocpp_auth_local where idtag='%s'", idTag);

    /* Execute SQL statement */

    rc = sqlite3_exec(db, sql, IdTagcallback, 0, (char **)&zErrMsg);

    if( rc != SQLITE_OK ){
    	DEBUG_INFO("SQL error: %s", zErrMsg);
          //sqlite3_free(zErrMsg);
    }else{
    	printf("Operation done successfully");
    }


   //return ver;
}


void OCPP_get_TableAuthlocalAllData(void)
{
    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 ");

    /* Execute SQL statement */

    rc = sqlite3_exec(db, sql, &sqlite3_exec_callback, 0,(char **)&zErrMsg);
  //  rc = sqlite3_exec(db, sql, IdTagcallback, 0, &zErrMsg);

    if( rc != SQLITE_OK ){
    	DEBUG_INFO("SQL error: %s", zErrMsg);
          //sqlite3_free(zErrMsg);
    }else{
    	DEBUG_INFO("Operation done successfully");
    }

   //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)
  {
	  DEBUG_INFO("%s\n",errMsg);
	  return FALSE;
  }
  else
  {
	  DEBUG_INFO("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];

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

	 //* Execute SQL statement */
	 //zErrMsg  = 0;
	 ret = sqlite3_exec(db, sql, callback, 0, (char **)&zErrMsg);
	 if( ret != SQLITE_OK ){
		 DEBUG_INFO("SQL error: %s\n", zErrMsg);
	     	//  free(zErrMsg);
	     	//  free(sql);
	   return isSuccess;
	 }

	 DEBUG_INFO("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 */
	rc = sqlite3_exec(db, sql, deleteIdTagcallback, 0,(char **)&zErrMsg);
	if( rc != SQLITE_OK ){
		DEBUG_INFO("SQL error: %s", zErrMsg);
	          //sqlite3_free(zErrMsg);
	}else{
		DEBUG_INFO("Operation done successfully");
	}
}

 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';
    sprintf(sql,"select * from ocpp_auth_local where idtag='%s'", idTag);

    //* Execute SQL statement */
    selectSqlCount = 0;
    ret = sqlite3_exec(db, sql, callback, (void*)data,(char **)&zErrMsg);
    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)
    {
       	//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);

    	DEBUG_INFO("sql:%s\n", sql);
       	//* Execute SQL statement */
    	//zErrMsg  = 0;
    	ret = sqlite3_exec(db, sql, callback, 0,(char **)&zErrMsg);
     	if( ret != SQLITE_OK ){
    	  printf("SQL error: %s\n", zErrMsg);
    	  return isSuccess;
    	}

     	DEBUG_INFO("successfully Insert records created\n");
    	isSuccess = TRUE;

    }
    else
    {
     	//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);
    	/* Execute SQL statement */
    	ret = sqlite3_exec(db, sql, callback, (void*)data,(char **)&zErrMsg);
    	if( ret != SQLITE_OK ){
    		printf("SQL error: %s\n", zErrMsg);
    		//sqlite3_free(zErrMsg);
    		//sqlite3_free(sql);
    	   return isSuccess;
    	}

    	DEBUG_INFO("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));

	if((ShmSysConfigAndInfo->SysConfig.OcppServerURL != NULL) && (strcmp((const char *)ShmSysConfigAndInfo->SysConfig.OcppServerURL,"") != 0) )
	{
		DEBUG_INFO("ShmSysConfigAndInfo->SysConfig.OcppServerURL =%s\n",ShmSysConfigAndInfo->SysConfig.OcppServerURL);
		sscanf((const char *)ShmSysConfigAndInfo->SysConfig.OcppServerURL,
						"%[^:]:%*2[/]%[^:]:%i/%[a-zA-Z0-9._/-]",
						OcppProtocol, OcppHost, &OcppPort, OcppTempPath);
	//	DEBUG_INFO("OcppProtocol =%s\n",OcppProtocol);
	//	DEBUG_INFO("OcppHost =%s\n",OcppHost);
	//	DEBUG_INFO("OcppPort =%d\n",OcppPort);
	//	DEBUG_INFO("OcppTempPath =%s\n",OcppTempPath);
		goto End;
	}
	else if((ShmOCPP16Data->OcppServerURL != NULL) && (strcmp((const char *)ShmOCPP16Data->OcppServerURL,"") != 0))
	{
		DEBUG_INFO("ShmOCPP16Data->OcppServerURL =%s\n",ShmOCPP16Data->OcppServerURL);
		sscanf((const char *)ShmOCPP16Data->OcppServerURL,
								"%[^:]:%*2[/]%[^:]:%i/%[a-zA-Z0-9._/-]",
								OcppProtocol, OcppHost, &OcppPort, OcppTempPath);
	//	DEBUG_INFO("OcppProtocol =%s\n",OcppProtocol);
	//	DEBUG_INFO("OcppHost =%s\n",OcppHost);
	//	DEBUG_INFO("OcppPort =%d\n",OcppPort);
	//	DEBUG_INFO("OcppTempPath =%s\n",OcppTempPath);
		goto End;

	}
	else
	{
		strcpy(OcppHost,"");
	}

End:
	return OcppHost;
}

char *GetOcppPath()
{
	if((ShmSysConfigAndInfo->SysConfig.ChargeBoxId != NULL) && (strcmp((const char *)ShmSysConfigAndInfo->SysConfig.ChargeBoxId,"") != 0) )
	{
		if(OcppTempPath == NULL)
		{
			sprintf(OcppPath,"/%s",ShmSysConfigAndInfo->SysConfig.ChargeBoxId);
		}
		else
		{
			sprintf(OcppPath,"/%s%s",OcppTempPath,ShmSysConfigAndInfo->SysConfig.ChargeBoxId);
		}
		goto End;
	}
	else if((ShmOCPP16Data->ChargeBoxId != NULL) && (strcmp((const char *)ShmOCPP16Data->ChargeBoxId,"") != 0))
	{
		if(OcppTempPath == NULL)
		{
			sprintf(OcppPath,"/%s",ShmOCPP16Data->ChargeBoxId);
		}
		else
		{
			sprintf(OcppPath,"/%s%s",OcppTempPath,ShmOCPP16Data->ChargeBoxId);
		}
		goto End;
	}
	else
	{
		strcpy(OcppHost,"");
	}

End:
	DEBUG_INFO("OcppPath=%s\n",OcppPath);
	return OcppPath;
}

int GetOcppPort()
{
	return OcppPort;
}

int GetOcppConnStatus(void)
{
	return ShmOCPP16Data->OcppConnStatus;
}

void SetOcppConnStatus(uint8_t status)
{
	ShmOCPP16Data->OcppConnStatus = status;
	ShmSysConfigAndInfo->SysInfo.OcppConnStatus = status;

	if(status == FALSE)
	{
		if(ShmSysConfigAndInfo->SysConfig.ModelName[0]=='D')
		{
			SystemInitial = CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY;
		}
		else
		{
			SystemInitial = AC_QUANTITY;
		}

	}
}

int GetHeartBeatWithNOResponse(void)
{
	return HeartBeatWithNOResponse;
}

void SetHeartBeatWithNOResponse(void)
{
	HeartBeatWithNOResponse = 0;
}

int InternetDisconnect(void)
{
	//DEBUG_INFO("ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi=%d\n",ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi);
	//DEBUG_INFO("ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet=%d\n",ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet);
	//DEBUG_INFO("ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi=%d\n",ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi);
	return (ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectVia4Gi && ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaEthernet && ShmStatusCodeData->InfoCode.InfoEvents.bits.InternetDisconnectViaWiFi	);
}

#if 0
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));
}
#endif

void LWS_Send(char * str)
{
#if 1
	//=====================================================
	// Check InternetConn 0: disconnected, 1: connected
	//====================================================
	if(ShmSysConfigAndInfo->SysInfo.InternetConn == 0)
	{
		DEBUG_INFO("\n offline  now !!!\n");
		return;
	}
#endif
	pthread_mutex_lock(&lock);
	memset(SendBuffer,0,SendBufLen);
	sprintf((char *)SendBuffer, "%s", str);
	pthread_mutex_unlock(&lock);
	lws_callback_on_writable(wsi_client);
	lws_service(context, 10000);//timeout_ms
	//usleep(10000); // 等�??��?微�?
	//DEBUG_INFO("Send message end\n");
}