csu3_am335x/EVSE/Projects/define.h

#ifndef	DEFINE_H_
#define	DEFINE_H_

/**************************************************************************************/
/*********************************NAND Flash mapping *****************************/
/**************************************************************************************/
/*
  sector size	512 KiB
  Page size       4096 b
  OOB size        224 b
  Erase size    	524288 b
-------------------------------------------------------------------------------------------------------------------------------
Segment 					Physical address 			Size
-------------------------------------------------------------------------------------------------------------------------------
MLO								0x00000000-0x0007FFFF		512 KB
Primary u-boot 					0x00080000-0x0017FFFF		1 MB
Environment 					0x00180000-0x001FFFFF		512 KB
Secondary u-boot	 			0x00200000-0x002FFFFF		1 MB
Primary dtb						0x00300000-0x0037FFFF		512 KB
Secondary dtb					0x00380000-0x003FFFFF		512 KB
Primary kernel					0x00400000-0x00DFFFFF		10 MB
Secondary Kernel 				0x00E00000-0x017FFFFF		10 MB
Primary root file system		0x03000000-0x05FFFFFF		48 MB
Secondary root file system		0x06000000-0x08FFFFFF		48 MB
Primary user configuration 		0x09000000-0x095FFFFF		6 MB
Secondary user configuration	0x09600000-0x09BFFFFF		6 MB
Factory default configuration	0x09C00000-0x0A1FFFFF		6 MB
Storage							0x0A200000-0x7FFFFFFF		1886 MB
*/

/**************************************************************************************/
/*********************************System Limitation**********************************/
/**************************************************************************************/
/*Rating outout power and current*/
#define RATED_POWER			25		//kW
#define RATED_CURRENT			350		//Amp, it depend on the capacity of charging connector

/*relevant to Quantity */
#ifdef AWRegular
    #define MAX_PSU_QUANTITY        62
    #define CHAdeMO_QUANTITY        1
    #define CCS_QUANTITY            1
    #define GB_QUANTITY             0
    #define AC_QUANTITY             1
    #define GENERAL_GUN_QUANTITY    0
    #define PSU_QUANTITY            0
    #define ONE_CONNECTOR_USE       0
#elif defined AWChargeLab
    #define MAX_PSU_QUANTITY        62
    #define CHAdeMO_QUANTITY        1
    #define CCS_QUANTITY            1
    #define GB_QUANTITY             0
    #define AC_QUANTITY             1
    #define GENERAL_GUN_QUANTITY    0
    #define PSU_QUANTITY            0
    #define ONE_CONNECTOR_USE       0
#elif defined AWCCS
    #define MAX_PSU_QUANTITY        62
    #define CHAdeMO_QUANTITY        1
    #define CCS_QUANTITY            1
    #define GB_QUANTITY             0
    #define AC_QUANTITY             1
    #define GENERAL_GUN_QUANTITY    0
    #define PSU_QUANTITY            0
    #define ONE_CONNECTOR_USE       0
#elif defined NoodoeAX
    #define MAX_PSU_QUANTITY        62
    #define CHAdeMO_QUANTITY        1
    #define CCS_QUANTITY            1
    #define GB_QUANTITY             0
    #define AC_QUANTITY             1
    #define GENERAL_GUN_QUANTITY    0
    #define PSU_QUANTITY            0
    #define ONE_CONNECTOR_USE       0
#elif defined AX80
    #define MAX_PSU_QUANTITY        62
    #define CHAdeMO_QUANTITY        1
    #define CCS_QUANTITY            1
    #define GB_QUANTITY             0
    #define AC_QUANTITY             3
    #define GENERAL_GUN_QUANTITY    3
    #define PSU_QUANTITY            0
    #define ONE_CONNECTOR_USE       0
#elif defined DW30
	#define MAX_PSU_QUANTITY        62
	#define CHAdeMO_QUANTITY        0
	#define CCS_QUANTITY            1
	#define GB_QUANTITY             0
	#define AC_QUANTITY             0
    #define GENERAL_GUN_QUANTITY	0
	#define PSU_QUANTITY            2
	#define ONE_CONNECTOR_USE       0
#elif defined DM30
	#define MAX_PSU_QUANTITY        62
	#define CHAdeMO_QUANTITY        0
	#define CCS_QUANTITY            1
	#define GB_QUANTITY             0
	#define AC_QUANTITY             0
    #define GENERAL_GUN_QUANTITY	0
	#define PSU_QUANTITY            2
	#define ONE_CONNECTOR_USE       0
#elif defined DS60120
	#define MAX_PSU_QUANTITY        62
	#define CHAdeMO_QUANTITY        2
	#define CCS_QUANTITY            2
	#define GB_QUANTITY             2
	#define AC_QUANTITY             1
    #define GENERAL_GUN_QUANTITY	0
	#define PSU_QUANTITY            2
	#define ONE_CONNECTOR_USE       0
#elif defined DS60210
	#define MAX_PSU_QUANTITY        62
	#define CHAdeMO_QUANTITY        1
	#define CCS_QUANTITY            1
	#define GB_QUANTITY             0
	#define AC_QUANTITY             0
    #define GENERAL_GUN_QUANTITY	0
	#define PSU_QUANTITY            2
	#define ONE_CONNECTOR_USE       0
#elif defined PlugIt360
    #define MAX_PSU_QUANTITY        62
    #define CHAdeMO_QUANTITY        0
    #define CCS_QUANTITY            1
    #define GB_QUANTITY             0
    #define AC_QUANTITY             0
    #define GENERAL_GUN_QUANTITY	0
    #define PSU_QUANTITY            2
    #define ONE_CONNECTOR_USE       0
#elif defined DD360 || defined DD360Audi || defined DD360ComBox || defined DD360UCar || defined DD360Tcci
    #define MAX_PSU_QUANTITY        62
    #define CHAdeMO_QUANTITY        2
    #define CCS_QUANTITY            2
    #define GB_QUANTITY             2
    #define AC_QUANTITY             0
    #define GENERAL_GUN_QUANTITY	0
    #define PSU_QUANTITY            2
    #define ONE_CONNECTOR_USE       0
#elif defined DO360
    #define MAX_PSU_QUANTITY        62
    #define CHAdeMO_QUANTITY        0
    #define CCS_QUANTITY            0
    #define GB_QUANTITY             0
    #define AC_QUANTITY             0
    #define GENERAL_GUN_QUANTITY    4
    #define PSU_QUANTITY            6
    #define ONE_CONNECTOR_USE       0
#elif defined ATE
    #define MAX_PSU_QUANTITY        62
    #define CHAdeMO_QUANTITY        0
    #define CCS_QUANTITY            1
    #define GB_QUANTITY             0
    #define AC_QUANTITY             0
    #define GENERAL_GUN_QUANTITY	0
    #define PSU_QUANTITY            2
    #define ONE_CONNECTOR_USE       0
#else
    #define MAX_PSU_QUANTITY        62
    #define CHAdeMO_QUANTITY        2
    #define CCS_QUANTITY            2
    #define GB_QUANTITY             2
    #define AC_QUANTITY             1
    #define GENERAL_GUN_QUANTITY    0
    #define PSU_QUANTITY            2
    #define ONE_CONNECTOR_USE       0
#endif

#define CONNECTOR_QUANTITY			(CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY + GENERAL_GUN_QUANTITY)

/*SystemLog message*/
#define SystemLogMessage			//for debug info save to log file
//#define ConsloePrintLog				//for debug info print to console

/**************************************************************************************/
/*****************************share memory key information*****************************/
/**************************************************************************************/
#define ShmSysConfigAndInfoKey	1001
#define ShmPsuKey				1002
#define ShmCHAdeMOCommKey		1003
#define ShmCcsCommKey			1004
#define ShmStatusCodeKey		1005
#define ShmPrimaryMcuKey		1006
#define ShmFanBdKey				1007
#define ShmRelayBdKey			1008
#define ShmOcppModuleKey		1009
#define ShmGBTCommKey			1010
#define ShmLedBdKey				1011
#define ShmOcpp20ModuleKey		1012
#define ShmRelay2BdKey			1013
#define ShmYesCustomKey         1014
#define ShmOcppPHModuleKey      1015
#define ShmSmartBoxKey          1016

#define FaultCodeLength         5
#define AlarmCodeLength         20
#define InfoCodeLength          41

/**************************************************************************************/
/****************** Share memory configuration value constant define ******************/
/**************************************************************************************/
struct NoneUse
{
    unsigned char       unknown;                    // None use struct
};

enum SYSTEM_STATUS
{
	SYS_MODE_BOOTING		= 0,
	SYS_MODE_IDLE    	  	= 1,
	SYS_MODE_AUTHORIZING		= 2,
	SYS_MODE_MODE_REASSIGN_CHECK	= 3,
	SYS_MODE_REASSIGN		= 4,
	SYS_MODE_PREPARING		= 5,
	SYS_MODE_PREPARE_FOR_EV		= 6,
	SYS_MODE_PREPARE_FOR_EVSE	= 7,
	SYS_MODE_CHARGING		= 8,
	SYS_MODE_TERMINATING		= 9,
	SYS_MODE_COMPLETE		= 10,
	SYS_MODE_ALARM			= 11,
	SYS_MODE_FAULT			= 12,
	SYS_MODE_RESERVATION		= 13,
	SYS_MODE_BOOKING		= 14,
	SYS_MODE_MAINTAIN		= 15,
	SYS_MODE_DEBUG			= 16,
	SYS_MODE_CCS_PRECHARGE_STEP0	= 17,
	SYS_MODE_CCS_PRECHARGE_STEP1	= 18,
	SYS_MODE_UPDATE			= 19
};

enum AUTHORIZATION_MODE
{
	AUTH_MODE_ENABLE		= 0,
	AUTH_MODE_DISABLE		= 1
};

enum LCD_LANGUAGE
{
	LCD_LANG_ENGLISH		= 0,
	LCD_LANG_CHT			= 1,
	LCD_LANG_CHS			= 2,
	LCD_LANG_JAPANESE		= 3,
	LCD_LANG_FRENCH			= 4,
	LCD_LANG_ITALIAN		= 5,
	LCD_LANG_SPANISH		= 6,
	LCD_LANG_GERMAN			= 7,
	LCD_LANG_DUTCH			= 8,
	LCD_LANG_NORWEGIAN		= 9,
	LCD_LANG_FINNISH		= 10,
	LCD_LANG_SWEDISH		= 11,
	LCD_LANG_SLOVENIAN		= 12,
	LCD_LANG_THAI			= 13,
};


enum RFID_ENDIAN
{
	RFID_ENDIAN_LITTLE		= 0,
	RFID_ENDIAN_BIG			= 1
};

enum PHASE_LOSS_POLICY
{
	LOSS_POLICY_CHARGING		= 0,
	LOSS_POLICY_STOP		= 1
};

enum CCS_AUTHPRIZATION_MODE
{
	CCS_AUTH_MODE_EIM		= 0,
	CCS_AUTH_MODE_MIXED		= 1
};

enum OFF_LINE_POLICY
{
	OFF_POLICY_LOCALLIST		= 0,
	OFF_POLICY_PH_RFID		= 1,
	OFF_POLICY_FREE			= 2,
	OFF_POLICY_NOCHARGE		= 3
};

/*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,
	 QueueOffLineMeterValues,
	 AuthorizationKey,
	 SecurityProfile,
     DefaultPrice,
     CustomDisplayCostAndPrice,
     CustomIdleFeeAfterStop,
     TimeOffset,
     NextTimeOffsetTransitionDateTime,
     TimeOffsetNextTransition,
     SystemUptimeSec,
     FreeVend,
     FreeVendIdtag,
     OcppServer,
     MaintainServer,
     StatusNotificationPeriodically,
     StatusNotificationInterval,
     PreAuthAmount,
     isEnableLocalPowerSharing,
     PowerSharingServerIP,
     EVCCID_PREFIX,
     OffLineMaxChargingPower,
     ConfigurationVersion,
	 _CoreProfile_CNT
};

enum OCPP_RUNNING_VERSION {
    OCPP_RUNNING_VERSION_16=0,
    OCPP_RUNNING_VERSION_20
};

enum OCPP_START_ID_TYPE {
    IdTokenType_Central=0,
    IdTokenType_eMAID,
    IdTokenType_ISO14443,
    IdTokenType_ISO15693,
    IdTokenType_KeyCode,
    IdTokenType_Local,
    IdTokenType_MacAddress,
    IdTokenType_NoAuthorization
};
/**************************************************************************************/
/****structure SysConfigData => shall store the data to NAND flash****************/
/****structure SysInfoData => shall NOT store the data to NAND flash***************/
/****according to System Configuration and Information Table.xlsx Rev.0.2 *******/
/**************************************************************************************/

struct EthConfigData
{
	unsigned char		EthDhcpClient;				//0: enable,1: disable
	unsigned char		EthMacAddress[18];			//default: Null
	unsigned char		EthIpAddress[16];			//Eth0 default:192.168.0.10	,Eth1 default:192.168.1.10
	unsigned char		EthSubmaskAddress[16];		//Eth0 default:255.255.255.0	,Eth1 default:255.255.255.0
	unsigned char		EthGatewayAddress[16];		//Eth0 default:192.168.0.254	,Eth1 default:192.168.1.254
};

struct WifiConfigData
{
	unsigned char		WifiMode;					//0: disable, 1: Infrastructure client, 2: Infrastructure server, 3: Ad-Hoc
	unsigned char		WifiSsid[256];				//default: Null
    unsigned char       WifiPassword[224];          //default: Null
    unsigned char       WifiBroadcastSsid;          //the SSID broadcast configuration, 0: hidden   1: broadcast
    unsigned char       WifiTargetBssidMac[31];     //Target connect SSID MAC address, default: Null
	int					WifiRssi;					//dbm
	unsigned char		WifiDhcpServer;				//0: enable, 1: disable
	unsigned char		WifiDhcpClient;				//0: enable, 1: disable
	unsigned char		WifiMacAddress[18];			//default: Null
	unsigned char		WifiIpAddress[16];			//default:192.168.2.10
	unsigned char		WifiSubmaskAddress[16];		//default:255.255.255.0
	unsigned char		WifiGatewayAddress[16];		//default:192.168.2.254
	unsigned char		WifiNetworkConn;			//0: disconnected, 1: connected
};

struct TeleConfigData
{
	unsigned char		TelcomModelName[64];		//default: Null
	unsigned char		TelcomSoftwareVer[64];		//default: Null
    unsigned char       TelcomApn[255];             //default: Null
    unsigned char       TelcomNetworkType;          //0: Auto   1: CDMA  2: WCDMA  3: LTE  4: TD-SCDMA  5: UMTS  6: CDMA  7: HDR  8: CDMA/HDR
	int					TelcomRssi;					//dbm
	unsigned char		TelcomChapPapId[256];		//default: Null
	unsigned char		TelcomChapPapPwd[256];		//default: Null
	unsigned char		TelcomModemImei[16];		//default: Null
	unsigned char		TelcomSimImsi[16];			//default: Null
	unsigned char		TelcomSimIccid[22];			//default: Null
	unsigned char		TelcomSimStatus;			//0: no SIM card is found, 1: valid SIM card, 2: invalid SIM card
	unsigned char       TelcomModemMode;            //0: No services, 1: CDMA, 2: GSM/GPRS, 3: WCDMA, 4: GSM/WCDMA, 5: TD_SCDMA, 6: HSPA, 7: LTE 9: Unknown
	unsigned char		TelcomIpAddress[16];		//default: Null
	unsigned char		TelcomNetworkConn;			//0: disconnected, 1: connected
	unsigned char		TelcomEnabled;				//0: disable, 1: enable
};

struct BtConfigData
{
	unsigned char		LoginCentralID[64];			//default: Null
	unsigned char		isLogin;					//0: Central device non-login	1: Central device login
	unsigned char		isRequestStart;				//0: no action	1: request start charging
	unsigned char		isRequestStop;				//0: no action	1: request stop charging
};

struct BillingConfigData
{
	unsigned char		isBilling;					//0:not for business	1:for business
	unsigned char		Currency;					//
	float				Fee[24];					//fee for 24 hours
	float 				Cur_fee;					// display current fee
};

struct LED
{
	unsigned char 			Intensity;					// LED bar intensity	0: Darkest	1: Medium	2: Brightest

	unsigned char			Red[3];						// Red color	0~100, element 0: IDLE		1: CHARGING		2: FAULT
	unsigned char			Green[3];					// Green color	0~100, element 0: IDLE		1: CHARGING		2: FAULT
	unsigned char			Blue[3];					// Blue color	0~100, element 0: IDLE		1: CHARGING		2: FAULT
};

struct LCD_NOUSE
{
    unsigned char           page_index;                 // LCD override page index
    unsigned char           duration;                   // LCD override duration
    unsigned char           isOverideReq:1;             // LCD override request
};

struct LCD_OVERRIDE
{
    unsigned char           connectorId;                // LCD override connector id
    unsigned char           page_index;                 // LCD override page index
    unsigned char           duration;                   // LCD override duration
    unsigned char           isOverideReq:1;             // LCD override request
};

struct Schedule
{
	unsigned char   isEnable;     						// 0: disable schedule function  1: enable schedule function
	unsigned char   scheduleType;    					// 0: Once   1: Daily
	unsigned char   scheduleMethod;    					// 0: Continuous 1: Specificate end time
	unsigned char   startTimeHour;    					// Schedule start trigger time hour
	unsigned char   startTimeMinute;   					// Schedule start trigger time minute
	unsigned char   stopTimeHour;    					// Schedule stop trigger time hour
	unsigned char   stopTimeMinute;    					// Schedule stop trigger time minute
	unsigned char   isTriggerStart;    					// 0: disable; 1: enable
	unsigned char   isTriggerStop;    					// 0: disable; 1: enable
};

struct TTIA
{
    unsigned char   server_addr[512];                   // Target server address
    unsigned int    server_port;                        // Target server port
    unsigned int    busVenderId;                        // Bus vender id, 0~65535
    unsigned char   EquipmentProvider[16];              // EVSE vender max 15 bytes
    unsigned char   TransportationCompanyNo;            // Data provider company number
    unsigned char   ChargeBoxId;                        // 1 byte
    unsigned char   evseStation[16];                    // UTF-8 15 bytes, Chinese 5 words
    unsigned char   isEnableTTIA:1;                     // TTIA function enable
};

struct LocalSharingInfo
{
    unsigned short      AvailableShargingCurrent[4];    // 0 ~ rating value amp,  Synchronize from local sharing server
    unsigned char       isConnectedSharingServer:1;     // 0: Disconnected, 1: Connected
};

typedef union
{
    unsigned int ChargingStopValue;
    struct
    {
        unsigned int NormalStop:1;                  // 0: no effect,    1: normal stop
        unsigned int AlarmStop:1;                   // 0: no effect,    1: alarm stop
        unsigned int BackendStop:1;                 // 0: no effect,    1: backend stop
        unsigned int ManualStop:1;                  // 0: no effect,    1: manual stop
        unsigned int HardResetStop:1;               // 0: no effect,    1: hard reset stop
        unsigned int SoftResetStop:1;               // 0: no effect,    1: soft reset stop
        unsigned int InvalidIdStop:1;               // 0: no effect,    1: invalid stop when StopTransactionOnInvalidId is true
        unsigned int RemoteStop:1;                  // 0: no effect,    1: remote stop
        unsigned int UnlockStop:1;                  // 0: no effect,    1: unlock stop
        unsigned int SessionTargetStop:1;           // 0: no effect,    1: session target stop
        unsigned int res:22;
    }bits;
}ChargingStop;

typedef struct
{
    unsigned char DispenserSequence;                    // dispenser sequence
    unsigned char MaxConnectorQuantity;                 // max connector quantity
    unsigned char WiringSetting[8];                     // record connector quantity of dispenser
    unsigned char PowerCabinetReserved[32];
}WiringInfoData;

typedef struct
{
    unsigned int isCalibratedVaGain:1;                  // Voltage phase a gain is calibrated, 0: default   1: Calibrated
    unsigned int isCalibratedVbGain:1;                  // Voltage phase b gain is calibrated, 0: default   1: Calibrated
    unsigned int isCalibratedVcGain:1;                  // Voltage phase c gain is calibrated, 0: default   1: Calibrated
    unsigned int isCalibratedVaOffset:1;                // Voltage phase a offset is calibrated, 0: default 1: Calibrated
    unsigned int isCalibratedVbOffset:1;                // Voltage phase b offset is calibrated, 0: default 1: Calibrated
    unsigned int isCalibratedVcOffset:1;                // Voltage phase c offset is calibrated, 0: default 1: Calibrated
    unsigned int isCalibratedCaGain:1;                  // Current phase a gain is calibrated, 0: default   1: Calibrated
    unsigned int isCalibratedCbGain:1;                  // Current phase b gain is calibrated, 0: default   1: Calibrated
    unsigned int isCalibratedCcGain:1;                  // Current phase c gain is calibrated, 0: default   1: Calibrated
    unsigned int isCalibratedCaOffset:1;                // Current phase a offset is calibrated, 0: default 1: Calibrated
    unsigned int isCalibratedCbOffset:1;                // Current phase b offset is calibrated, 0: default 1: Calibrated
    unsigned int isCalibratedCcOffset:1;                // Current phase c offset is calibrated, 0: default 1: Calibrated
    unsigned int isCalibratedPa:1;                      // Phase angle a is calibrated, 0: default          1: Calibrated
    unsigned int isCalibratedPb:1;                      // Phase angle b gain is calibrated, 0: default     1: Calibrated
    unsigned int isCalibratedPc:1;                      // Phase angle c gain is calibrated, 0: default     1: Calibrated
    unsigned int :1;
}MeterIcCalibration;

struct SysConfigData
{
	/**************System***************/
	unsigned char 			CsuBootLoadFwRev[32];			//CSU board bootloader firmware version
	unsigned char			ModelName[64];				//charger model name
	unsigned char			AcModelName[64];			//for third gun (DC + AC)
	unsigned char			SerialNumber[64];			//charger system serial number
	unsigned char			SystemId[128];				//charger system ID
	unsigned char			SystemDateTime[32];			//charger system date and time
	unsigned char			AcPhaseCount;				//AC EVSE power phase quantity,  1: One phase	3: Three phase
	unsigned char			AuthorisationMode;			//0: enable, 1: disable
	unsigned char			DefaultLanguage;			//
	unsigned char			RfidCardNumEndian;			//0: little endian,  1: big endian
	unsigned short			AcPlugInTimes;				//0~65535
	unsigned short			GbPlugInTimes;				//0~65535
	unsigned short			Ccs1PlugInTime;				//0~65535
	unsigned short			Ccs2PlugInTimes;			//0~65535
	unsigned short			ChademoPlugInTimes;			//0~65535
	unsigned char			PsuAcInputType;				//0: 220, 1: 277
	unsigned short			RatingCurrent;				//0: Depend on Model name,	1 ~ rating value amp
	unsigned short			AcRatingCurrent;			//for third gun; 0: Depend on Model name,	1 ~ rating value amp
	unsigned char			isAPP;						//for AuthorisationMode=0; 0:false, 1:true
	unsigned char			isQRCode;					//for AuthorisationMode=0; 0:false, 1:true
	unsigned char			isRFID;						//for AuthorisationMode=0; 0:false, 1:true
	unsigned char			QRCodeMadeMode;				//for isQRCode=1 ; 0: default	1:customized
	unsigned char			QRCodeContent[128];			//for QRCodeMadeMode=1
	unsigned char			TotalConnectorCount;		//Connector count
	unsigned char 			AcConnectorCount;			// For DC type
	unsigned char			SwitchDebugFlag;			// Console Debug
	unsigned char			AlwaysGfdFlag;
	/**************Charging***************/
	unsigned short			MaxChargingEnergy;			//0: no limit,	1 ~ 65535	kWh
	unsigned short			MaxChargingPower;			//0: rating value, 1 ~ RATING_POWER	kW
	unsigned short			MaxChargingCurrent;			//0: rating value, 1 ~ RATING_CURRENT	amp
	unsigned short			AcMaxChargingCurrent;		//for third gun; 0: rating value, 1 ~ RATING_CURRENT	amp
	unsigned short			MaxChargingDuration;		//0: no limit,	1 ~ 65535	minutes
	unsigned char			PhaseLossPolicy;			//0: charging,  1: stop charging
	unsigned char			LocalWhiteCard[10][32];		//Max. card quantity is 10
	unsigned char			UserId[32];					//the user use this ID to trigger charging event, it can be RFID card number, OCPP IdTag, etc.
	struct BillingConfigData BillingData;
	/**************Network***************/
	unsigned char 			FtpServer[256];				//the ftp server for Phihong server to do data transimission
	struct EthConfigData	Eth0Interface;
	struct EthConfigData	Eth1Interface;
	struct WifiConfigData 	AthInterface;
	struct TeleConfigData	TelecomInterface;
	struct BtConfigData		Bluetooth;
	/**************Backend***************/
	unsigned int 			BackendConnTimeout;			//default : 300s
	unsigned char   		OfflinePolicy;				//0: local list, 1: Phihong RFID tag, 2: free charging, 3: no charging
	unsigned short	   		OfflineMaxChargeEnergy;		//0: same as MaxChargingEnergy, 1 ~ 65535 kWh
	unsigned short	   		OfflineMaxChargeDuration;	//0: same as MaxChargeDuration, 1 ~ 65535 minutes
	unsigned char 			OcppServerURL[512];			//ws: non-secure OCPP 1.6-J, wss: secure OCPP 1.6-J"
	unsigned char 			ChargeBoxId[128];
	unsigned char			chargePointVendor[20];		//the Vendor of the ChargePoint
    unsigned char           OcppSecurityProfile;        //OCPP security profile 0~3
    unsigned char           OcppSecurityPassword[41];   //OCPP AuthorizationKey for security profile
	unsigned int 			Checksum;					//4 bytes checksum
	struct LED				LedInfo;					// LED configuration info
	unsigned char			ShowInformation;
	unsigned char           isReqFirstUpgrade;          //EVSE is request first upgrade from PH server
	unsigned char           isEnableLocalPowerSharing;  //0: Disable power sharing  1: Master   2: Slave
	unsigned char           StopChargingByButton;       //0: Disable  1: Enable
    struct LCD_NOUSE        Legacy_LcdOveride;          // LCD override info (no use anymore)
    struct TTIA             TTIA_Info;                  // TTIA configuration struct

    /************PowerCabinet************/
    WiringInfoData          WiringInfo;

    unsigned char           OcppReceiptrURL[512];               // Charging receipt display URL
    unsigned char           isAuthrizeByEVCCID;                 // is Authorize by EVCCID (CCS)
    unsigned char           MaintainServerURL[512];             // ws: non-secure OCPP 1.6-J, wss: secure OCPP 1.6-J"
    unsigned char           MaintainServerSecurityProfile;      // Maintain server security profile 0~3
    unsigned char           MaintainServerSecurityPassword[41]; // Maintain server AuthorizationKey for security profile
    unsigned char           PowerSharingServerIP[512];          // Local power sharing server ip address
    unsigned int            PowerSharingCapacityPower;          // Local power sharing capacity power
    unsigned char           MaxChargingSoc;                     //0: unlimit, 1 ~ 100 percent
};

struct DERATING_BY_OTP
{
    unsigned char isNeedDerating;
    unsigned char deratingIndex;        // Current used power or current
    double deratingTargetRate[5];       // Reduce the output energy rate
    double deratingTargetCurrent[5];    // derating target current
};

struct ChargingInfoData
{
	unsigned char 		Index;
	unsigned char 		slotsIndex;
	unsigned char 		Type;					// 0 : Chademo, 1 : CCS, 2: GB
	unsigned char 		type_index;
	unsigned char 		Evboard_id;				// for EV board
	unsigned char 		StopChargeFlag;			// for EV board
	unsigned char		SystemStatus;				//0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault
	unsigned char		PreviousSystemStatus;		// 0: Booting, 1: idle, 2: authorizing, 3: preparing, 4: charging, 5: terminating, 6: alarm, 7: fault	
	int 			ReservationId;
	unsigned char 		IsAvailable;
	float MaximumChargingVoltage;	// unit 0.1V
	float AvailableChargingCurrent;	// unit 0.1A
	float AvailableChargingPower;	// unit 0.1kW
	float DividChargingCurrent;		//0~6553.5 amp
	float DeratingChargingCurrent;  // unit 0.1A
	float DeratingChargingPower;	// unit 0.1kW
	float FuseChargingVoltage;		//0~6553.5 volt
	float FireChargingVoltage;		//0~6553.5 volt
	float PresentChargingVoltage;   // unit: 1V
	float PresentChargingCurrent;   // unit: 1A
	float PresentChargingPower;		//0~6553.5 kW
	float PresentChargedEnergy;		//0~6553.5 kWh
	float presentChargedEnergyPeriod[24];       // Session present charged energy at each period
	int PresentChargedDuration;	// second
	int RemainChargingDuration;	// second
	float EvBatteryMaxVoltage;		// 0~6553.5 volt
	float EvBatterytargetVoltage;		// 0~6553.5 volt
	float EvBatterytargetCurrent; 	//102.3				0~200(A) (unit:1A)
	int EvBatterySoc;				// 0~100%
	unsigned char ConnectorPlugIn;			//0: unplug, 1: Plug-in
	unsigned char GunLocked;				//0: unlocked 1: locked
	unsigned char InProgress;               //0: real idle, 1: session(transaction) in progress
	float PilotVoltage;
	unsigned char PilotState;//1:state A, 2:State B1, 3:State B2, 4:State C, 5:State D, 6:State E, 7:State F, 8: Pilot error
	unsigned char PilotDuty;					// 0~100%
	unsigned char			StartUserId[32];			// This ID is trigger start charging event user by RFID, back-end, BLE.
	unsigned char           StartIdType;                // 0: Central   1: eMAID    2: ISO14443 3: ISO15693 4: KeyCode  5: Local    6: MacAddress   7: NoAuthorization
	unsigned char			StartDateTime[32];			// Charging cycle start date time
	unsigned char			StopDateTime[32];			// Charging cycle stop date time
	unsigned char			StartMethod;
	float					ChargingFee;
	// Connector Temp
	unsigned char 		ConnectorTemp;			//0x00: -60¢XC  ~  0xFE: 194
    //Chiller Temp
    unsigned char       ChillerTemp;            //0x00: -60¢XC  ~  0xFE: 194
	// Charging Status
	unsigned char 		GroundFaultStatus;		// for GFD result => 0x00 : None, 0x01 : Can Start Charging, 0x02 : Stop Charging
	unsigned short		RealRatingPower;        // unit: 0.1kW
	unsigned char 		RelayWeldingCheck;		// 0 : No Comp., 1 : Comp.
	unsigned char 		PrechargeStatus;		// for ccs precharge => 0x00 : None defined, 0x01 : Accepted
	float 				PowerConsumption;		// This contains the meter value (Power Consumption) kWh
	unsigned char		RelayK1K2Status;		// 0x00 : open, 0x01 : close
	unsigned char		RelayKPK2Status;		// 0x00 : open, 0x01 : close
	unsigned char 	 	TimeoutFlag;			// 0 : none,
	struct timeval		TimeoutTimer;
	unsigned char 		MaxChargeEnable;
	unsigned char		IsReadyToCharging;
	unsigned char		CcsAuthentication;				// 0:EIM, 1:EIM & PnC mixed
	unsigned char		AcCcsChargingMode;				// 0:BC (PWM) only, 1:BC & PLC mixed
	unsigned short		SampleChargingCur[10];

	/************** Alston ***************/
	unsigned char 		SelfTest_Comp;
	unsigned char		version[16];
	unsigned char 		IsModeChagned;
	unsigned char 		IsCharging;
	unsigned char 		IsErrorOccur;
	float 				RealMaxVoltage;
	float				RealMaxCurrent;
	float 				RealMaxPower;
	unsigned char 		ConnectorWarningCode[7];
	unsigned char 		ConnectorAlarmCode[7];
	unsigned char 		EvConnAlarmCode[7];
	float 				ChargingProfileCurrent;			// unit: 0.1A
	float 				ChargingProfilePower;			// unit: 1W
	float 				PresentChargingVoltageL2;		//0~6553.5 volt
	float 				PresentChargingVoltageL3;		//0~6553.5 volt
	float 				PresentChargingCurrentL2;		//0~6553.5 amp	
	float 				PresentChargingCurrentL3;		//0~6553.5 amp
	char 				RemoteStartFlag;
	unsigned char 		MaxChargingToAverPassFlag;
	unsigned char		EVCCID[18];						//the MAC address of the EVCC in Hex
	unsigned char 		isRemoteStart;
	struct Schedule		schedule;						// Schedule
	int 				EvBatteryStartSoc;				// 0~100%
	unsigned char 		NormalStopChargeFlag;			// for EV board
	ChargingStop        ChargingStopFlag;
    char                ReservedStartFlag;
    float               ConnectorMaxVoltage;            // 0~6553.5 volt
    float               ConnectorMaxCurrent;            // 0~6553.5 volt
    unsigned char       ModelType;
    MeterIcCalibration  meterIcCalInfo;
    float               PowerOffered;                   //0~6553.5 kW
    float               CurrentOffered;                 //0~6553.5 amp
    struct timespec     ConnectorTimeout;
    unsigned char       PantographFlag;                 // 0: normal gun type,  1: pantograph gun type
    unsigned char       Replug_flag;
    unsigned char       isEVCCIDVerify;
    unsigned char       CCSGunType;
    struct timeval      PreChargeTimer;
    unsigned char       _SaftyDetect;
    unsigned char       _TotalPsuCount;                 // Psu count for connector
    unsigned char       _TakePsuGpCount;                // Get the used psu group count
    struct DERATING_BY_OTP deratingByConnOtp;
};

typedef struct
{
    unsigned char       AuthId[32];
                                                        // 0: Authorize idle, 1: Authorize wait,   2: Authorizing
    unsigned char       AuthStatus;                     // 3: Authorize done, 4: Authorize end
    unsigned char       AuthTarget;                     // Authorize Target Connector ID: 1 ~ 4, AutoSelection: 0xFF
    unsigned char       AuthType;                       // 0: _AuthType_None,   1: _AuthType_RFID, 2: _AuthType_RemoteStart
    unsigned char       AuthResult;                     // 0: _AuthResult_None, 1: _AuthResult_Valid,   2: _AuthResult_Invalid
    unsigned char       AuthRequest;                    // 0: no request, 1: authorize request
    unsigned char       AuthIdType;
}AuthorizingInfoData;

typedef union
{
    unsigned int SettingValue;
    struct
    {
        unsigned int DuplicateIp:1;
        unsigned int DuplicateIpConfirm:1;
        unsigned int DispenserConfigSync:1;             // 0: not synced,   1: synced
        unsigned int MiscNeedAnnouncement:1;            // 0: no need,      1: need send misc command
        unsigned int NeedDispenserVerInfo:1;            // 0: no need,      1: need dispenser to report it's version info
        unsigned int AuthorizeRequest:1;                // 0: idle,         1: requesting                           ( dispenser -> cabinet)
        unsigned int HardwareRebootConfirm:1;           // 0: no effect,    1: dispenser confirmed
        unsigned int SoftwareResetConfirm:1;            // 0: no effect,    1: dispenser confirmed
        unsigned int FirmwareUpdateRequest:1;           // firmware update request
        unsigned int FirmwareUpdateConfirm:1;           // firmware update start
        unsigned int FirmwareUpdateCompleted:1;         // firmware update completed
        unsigned int res:21;
    }bits;
}DispenserSettingFlag;

struct DispenserModule
{
    unsigned char   LocalStatus;                // 0: None, 1: Identification, 2: Idle, 3: Alarm, 4: Charging, 5: _DS_Timeout
    unsigned char   ConnectorQuantity;          //Connector count
    unsigned char   ConnectorID[2];             //Available Connector ID: 1 ~ 4
    unsigned char   UserId[32];                 //the user use this ID to trigger charging event, it can be RFID card number, OCPP IdTag, etc.
    unsigned char   ModelName[64];              //charger model name
    unsigned char   SerialNumber[64];           //charger system serial number
    unsigned char   SystemId[128];              //charger system ID
    unsigned char   AuthorisationMode;          //0: enable, 1: disable
    unsigned char   RfidCardNumEndian;          //0: little endian,  1: big endian
    unsigned char   isAPP;                      //for AuthorisationMode=0; 0:false, 1:true
    unsigned char   isQRCode;                   //for AuthorisationMode=0; 0:false, 1:true
    unsigned char   isRFID;                     //for AuthorisationMode=0; 0:false, 1:true; for Noodoe Credit Card +2^1:true
    unsigned char   QRCodeMadeMode;             //for isQRCode=1 ; 0: default	1:customized
    unsigned char   QRCodeContent[128];         //for QRCodeMadeMode=1

    unsigned char   FactoryConfiguration;       //0: normal, 1: trigger, charger will return the configuration to factory default if trigger
    unsigned char   CsuBootLoadFwRev[32];       //CSU board bootloader firmware version
    unsigned char   CsuKernelFwRev[32];         //CSU board OS kernel firmware version
    unsigned char   CsuRootFsFwRev[32];         //CSU board root file system firmware version
    unsigned char   CsuPrimFwRev[32];           //CSU board root file system firmware version
    unsigned char   LcmFwRev[32];               //LCM module firmware version
    unsigned char   PsuPrimFwRev[32];           //PSU primary firmware version
    unsigned char   PsuSecFwRev[32];            //PSU secondary firmware version
    unsigned char   FanModuleFwRev[32];         //Fan  module firmware version
    unsigned char   RelayModuleFwRev[32];       //Relay control  module firmware version
    unsigned char   TelcomModemFwRev[32];       //the 3G/4G modem firmware version
    unsigned char   LedModuleFwRev[32];         //LED control module firmware version
    unsigned char   Connector1FwRev[32];        //Connector1 module firmware version
    unsigned char   Connector2FwRev[32];        //Connector2 module firmware version
    struct   LED    LedInfo;                    // LED configuration info

    AuthorizingInfoData     AuthInfo;
    DispenserSettingFlag    Setting;
    char                    FwFileName[128];
    unsigned char           ConnectionChannel;
};

struct ConnectionInfoData
{
    unsigned char Status;                       // 0: free, 1: WaitModelName, 2: DispenserMatched
    unsigned char DispenserIndex;
    unsigned int  IpAddress;
};

struct DispenserInfoData
{
    unsigned char               DispenserQuantity;                  // record max dispenser quantity
    unsigned char               TotalConnectorQuantity;             // record max connector quantity
    struct DispenserModule      Dispenser[GENERAL_GUN_QUANTITY];

    unsigned char               PresentDispenserQuantity;
    unsigned char               PresentConnectorQuantity;

    union
    {
        unsigned char Status;
        struct
        {
            unsigned char Dispenser1:1;             // 1: ever checkin, 0: never checkin
            unsigned char Dispenser2:1;             // 1: ever checkin, 0: never checkin
            unsigned char Dispenser3:1;             // 1: ever checkin, 0: never checkin
            unsigned char Dispenser4:1;             // 1: ever checkin, 0: never checkin
            unsigned char Dispenser5:1;             // 1: ever checkin, 0: never checkin
            unsigned char Dispenser6:1;             // 1: ever checkin, 0: never checkin
            unsigned char Dispenser7:1;             // 1: ever checkin, 0: never checkin
            unsigned char Dispenser8:1;             // 1: ever checkin, 0: never checkin
        }Flag;
    }CheckInLog;                                                        // record dispenser checkin status
    unsigned char               ConnectorLog[GENERAL_GUN_QUANTITY];     // record connector quantity of dispenser
    struct ConnectionInfoData   ConnectionInfo[GENERAL_GUN_QUANTITY];
};

struct WARNING_CODE_INFO
{
    unsigned char WarningCount;
    unsigned char PageIndex;
    unsigned char WarningCode[10][7];
    unsigned char Level;
    unsigned char ExtraErrProcess;                      // 0 : none, 1 : input uvp..
};

typedef union
{
    unsigned int Value;
    struct
    {
        unsigned int  PermissionRequest:1;              // 0: no request,    1: dispenser request to charging                   ( dispenser -> cabinet)
        unsigned int  RemoteStartConfirm:1;
        unsigned int  RemoteStopConfirm:1;
        unsigned int  UnlockStopConfirm:1;
        unsigned int  TimeoutStopRequest:1;             // 0: no request,    1: ethernet timeout stop                           ( dispenser -> cabinet)
        unsigned int  PsuReleasable:1;
        unsigned int  AnnounceBalance:1;                //
        unsigned int  StartWaitPlug:1;                  //
        unsigned int  NeedCleanAuthorizeInfo:1;         //
        unsigned int  SwipeRfidConfirm:1;
        unsigned int  OutputLimitEnable:1;              // 0: disable,      1: enable
        unsigned int  ChargingPermission:2;             // 0: not allowed,  1: allowed,         2: wait
        unsigned int  NormalStopRequest:1;              // 0: no effect,    1: connector normal stop request                    ( dispenser -> cabinet)
        unsigned int  AlarmStopRequest:1;               // 0: no effect,    1: connector alarm stop request                     ( dispenser -> cabinet)
        unsigned int  FaultStatusRequest:1;
        unsigned int  Disconnection:1;
        unsigned int  GfdDetection:1;                   // 0: stop,         1: start
        unsigned int  GetStartChargingSoc:1;            // 0: no effect,    1: get start soc
        unsigned int  res:13;
    }bits;
}ConnectorParameter;

struct ConnectorInfoData
{
    unsigned char RemoteStatus;                         // 0: Idle, 1: Preparing, 2: Charging, 3: Terminating, 4: Alarm
    unsigned char Enable;                               // 0: Disable, 1: Enable
    unsigned char ReadyToCharge;                        // 0: Not Ready, 1: Ready to Charge (no use)
    unsigned char ParentDispensetIndex;                 // Parent Dispenser Index: 0 ~ 3
    ConnectorParameter       Parameter;

    AuthorizingInfoData      AuthInfo;
    struct ChargingInfoData  GeneralChargingData;
    struct WARNING_CODE_INFO WarningInfo;

    unsigned char           RemotenAlarmCode[7];
    unsigned short          RemoteChargingVoltage;          // charging voltage from connector, unit: 0.1V
    unsigned short          RemoteChargingCurrent;          // charging current from connector, unit: 0.1A
    unsigned int            RemoteRemainChargingDuration;   // remain charging duration from connector, unit: 1s
    unsigned char           RemoteSoc;                      // ev battery soc from connector, unit: 1%

    unsigned short          RemoteMaxPhysicalVoltage;       // max physical voltage from connector, unit: 0.1V
    unsigned short          RemoteMaxPhysicalCurrent;       // max physical current from connector, unit: 0.1A
    unsigned short          RemoteTargetVoltage;            // target voltage from connector, unit: 0.1V
    unsigned short          RemoteTargetCurrent;            // target current from connector, unit: 0.1A
    unsigned short          RemoteLimitVoltage;             // limit voltage to psu voltage command, unit: 0.1V
    unsigned short          RemoteLimitCurrent;             // limit current to psu current command, unit: 0.1A

    unsigned short          MaxTotalChargingCurrent;        // max total output current, unit: 0.1A
    unsigned short          MaxTotalChargingPower;          // max total output power, unit: 0.1kw
    unsigned short          MaxOutputEnergy;                // 0: no limit,  1 ~ 65535   kWh
    unsigned short          MaxOutputDuration;              // 0: no limit,  1 ~ 65535   minutes
    float                   CapabilityVoltage;              // unit 0.1V
    float                   CapabilityCurrent;              // unit 0.1A
    float                   CapabilityPower;                // unit 0.1kW

    float                   UserPrice;                      // connector user's user price, unit: 1 (dollar / kWh)
    float                   TotalCost;                      // connector user's total cost, unit: 1 dollar
    float                   AccountBalance;                 // connector user's account balance, unit: 1 dollar
    float                   CostDiscount;                   // connector user's Discount or couponPoint, unit: 1 point
    float                   EnergyCost;                     // connector user's energy cost, unit: 1 dollar
    float                   ParkingFee;                     // connector user's parking fee, unit: 1 dollar
    float                   RemainAmount;                   // connector user's remain amount, unit: 1 dollar
};

typedef union
{
    unsigned int SettingValue;
    struct
    {
        unsigned int res:32;
    }bits;
}CabinetSettingFlag;

struct DC_METER_INFO
{
    double presetVoltage;                       // resolution: 1.000v
    double presentCurrent;                      // resolution: 1.000a
    double presentPower;                        // resolution: 1.000kw
    double totlizeImportEnergy;                 // resolution: 1.000kwh
    double totlizeExportEnergy;                 // resolution: 1.000kwh
    unsigned char LinkStatus;                   // 0 = unknow ,1 = link , 2 miss link
};

typedef struct Bazel8Command
{
    unsigned char isReq:1;
    unsigned char isRes:1;
    unsigned char isWaitRes:1;
    unsigned char isResultPass:1;
} bazel8Command;

typedef struct EventInfo
{
    int messageId;
    char messageString[64];
    unsigned char isGetOn:1;
}eventInfo;

typedef struct StartTxResp
{
    char statusCode[8];
    char statusText[128];
    char txnId[32];
    unsigned char isGetOn:1;
}startTxResp;

struct BAZEL8
{
    eventInfo       event;
    startTxResp     txResp;

    bazel8Command   cmdPreAuth;
};

struct Enegate
{
	union
	{
		unsigned char OperationValue[CONNECTOR_QUANTITY];
		struct
		{
			unsigned char isAuthorizing:1;
			unsigned char isAuthorized:1;
			unsigned char isAuthorizedPass:1;
			unsigned char isSessionStopReq:1;
			unsigned char isStopService:1;
			unsigned char isAutoStartEnable:1;
			unsigned char isConnectTimeout:1;
			unsigned char :1;
		} bits[CONNECTOR_QUANTITY];
	}Operation;

	unsigned char	serviceStartTimestamp[36];
	unsigned char	serviceStopTimestamp[36];
	unsigned char 	isEnable:1;
};

struct SysInfoData
{
	/**************System***************/
    unsigned char OcppRunningVer;           // 0: 1.6J      1:2.0
	unsigned char BootingStatus;			// 0 : booting, 1 : Initializing Complete.
	unsigned char AuthorizeFlag;			// 0 : None, 1 : Authorizing
	unsigned char FactoryConfiguration;	//0: normal, 1: trigger, charger will return the configuration to factory default if trigger
	float InputVoltageR;                    //0~655.35 volt
	float InputVoltageS;                    //0~655.35 volt
	float InputVoltageT;                    //0~655.35 volt
	float InputVoltageDc;                   //0~655.35 volt
	unsigned int SystemFanRotaSpeed;		//0 ~ 65535 RPM
	unsigned int PsuFanRotaSpeed;			//0 ~ 65535 RPM
	unsigned char AuxPower5V;				//0 ~ 255 volt
	unsigned char AuxPower12V;				//0 ~ 255 volt
	unsigned char AuxPower24V;				//0 ~ 255 volt
	unsigned char AuxPower48V;				//0 ~ 255 volt
	unsigned char CsuHwRev[32];			//CSU board hardware version
	unsigned char CsuBootLoadFwRev[32];	//CSU board bootloader firmware version
	unsigned char CsuKernelFwRev[32];//CSU board OS kernel firmware version
	unsigned char CsuRootFsFwRev[32];//CSU board root file system firmware version
	unsigned char CsuPrimFwRev[32];	//CSU board root file system firmware version
	unsigned char LcmHwRev[32];	//LCM module hardware version
	unsigned char LcmFwRev[32];	//LCM module firmware version
	unsigned char PsuHwRev[32];		//PSU hardware version
	unsigned char PsuPrimFwRev[32];		//PSU primary firmware version
	unsigned char PsuSecFwRev[32];			//PSU secondary firmware version
	unsigned char AuxPwrHwRev[32];		//Aux. power module hardware version
	unsigned char AuxPwrFwRev[32];		//Aux. power module firmware version
	unsigned char FanModuleHwRev[32];		//Fan  module hardware version
	unsigned char FanModuleFwRev[32];		//Fan  module firmware version
	unsigned char RelayModuleHwRev[32];	//Relay control  module hardware version
	unsigned char RelayModuleFwRev[32];	//Relay control  module firmware version
	unsigned char TelcomModemFwRev[32];	//the 3G/4G modem firmware version
	unsigned char LedModuleFwRev[32];	//LED control module firmware version
	unsigned char Connector1FwRev[32];	//Connector1 module firmware version
	unsigned char Connector2FwRev[32];	//Connector2 module firmware version
	int SystemAmbientTemp;		// -40 ~ 215 degree C
	int SystemCriticalTemp;		// -40 ~ 215 degree C
	int CcsConnectorTemp;		// -40 ~ 215 degree C
	int PsuAmbientTemp;			// -40 ~ 215 degree C
	/**************Charging***************/
	struct ChargingInfoData 	ChademoChargingData[CHAdeMO_QUANTITY];
	struct ChargingInfoData 	CcsChargingData[CCS_QUANTITY];
	struct ChargingInfoData 	GbChargingData[GB_QUANTITY];
	struct ChargingInfoData 	AcChargingData[AC_QUANTITY];
	unsigned char CurGunSelected;
	unsigned char CurGunSelectedByAc;
	/**************Network***************/
	unsigned char 		InternetConn;					//0: disconnected, 1: connected
	/**************Backend***************/
	unsigned char 		OcppConnStatus;					//0: disconnected, 1: connected
    unsigned char       MaintainServerConnStatus;       //0: disconnected, 1: connected
	char 				OrderCharging;
    float               MaxChargingProfilePower;        // unit: 1W
	/**************Alston***************/
	unsigned char 		WaitForPlugit;					//0: none scan, 1: scanning
	unsigned char 		PageIndex;						//0 : Initialize
														//1 : idle
														//4 : Authorizing
														//5 : Authorizing complete
														//6 : Authorizing fail
														//7 : Wait for Plug
														//8 : Pre-charge
														//9 : Charging
	unsigned char 		SelfTestSeq;					//
	unsigned char 		ReAssignedFlag;					//
	unsigned char		CanAverageCharging;
	unsigned char 		MainChargingMode;				// 0 : Max, 1 : Average 
	unsigned char 		BridgeRelayStatus;
	unsigned char 		FirmwareUpdate;					// 0 : none, 1 : update.
	unsigned char 		AcContactorStatus;				// 0: disconnected, 1: connected
	unsigned char 	 	SystemTimeoutFlag;				// 0 : none, 1 : self test
	struct timespec		SystemTimeoutTimer;
	unsigned char 		SystemPage;
	unsigned char 		ConnectorPage;
	unsigned char		IsAlternatvieConf;				// 0 : normal, 1 : alternative
	unsigned char		StartToChargingFlag;			// 0 : Stop, 1 : Start for modbus
	unsigned char 		ChargerType;					// 0 : IEC, 1 : UL
    unsigned char       ethInternetConn;                // 0 : disconnected, 1: connected

    // DO360
    unsigned char Relay2ModuleHwRev[32];	//Relay control  module hardware version
    unsigned char Relay2ModuleFwRev[32];	//Relay control  module firmware version
    struct DispenserInfoData DispenserInfo;
    struct ConnectorInfoData ConnectorInfo[GENERAL_GUN_QUANTITY];

    unsigned char           AuthorizedDispenser;        // record authorized dispenser index
    unsigned char           AuthorizedTarget;           // record authorized target: 1 ~ 4, 0xFF
    unsigned char           AuthorizedType;             // record authorized type
    unsigned char           AuthorizedStatus;           // cabinet authorized status
    CabinetSettingFlag      CabinetSetting;
    struct LocalSharingInfo localSharingInfo;           // Local power sharing info structure
    struct DC_METER_INFO 	DcMeterInfo[4];
    unsigned char           OTPTemp;                    // OTP Temperature
    unsigned char           OTPTempR;                   // OTP Recovery Temperature
    struct LCD_OVERRIDE     LcdOveride;                 // LCD override info (no use anymore)
    struct BAZEL8           bazel8;                     // Bazel8 payment used
    struct Enegate	    enegate;			// Enegate payment used
};

struct SysConfigAndInfo
{
	struct SysConfigData				SysConfig;
	struct SysInfoData					SysInfo;
	struct WARNING_CODE_INFO			SysWarningInfo;
};

char Currency[54][3]=
{
	"AED",	// - Emirati Dirham
	"ARS",	// - Argentine Peso
	"AUD",	// - Australian Dollar
	"BGN",	// - Bulgarian Lev
	"BHD",	// - Bahraini Dinar
	"BND",	// - Bruneian Dollar
	"BRL",	// - Brazilian Real
	"BWP",	// - Botswana Pula
	"CAD",	// - Canadian Dollar
	"CHF",	// - Swiss Franc
	"CLP",	// - Chilean Peso
	"CNY",	// - Chinese Yuan Renminbi
	"COP",	// - Colombian Peso
	"CZK",	// - Czech Koruna
	"DKK",	// - Danish Krone
	"EUR",	// - Euro
	"GBP",	// - British Pound
	"HKD",	// - Hong Kong Dollar
	"HRK",	// - Croatian Kuna
	"HUF",	// - Hungarian Forint
	"IDR",	// - Indonesian Rupiah
	"ILS",	// - Israeli Shekel
	"INR",	// - Indian Rupee
	"IRR",	// - Iranian Rial
	"ISK",	// - Icelandic Krona
	"JPY",	// - Japanese Yen
	"KRW",	// - South Korean Won
	"KWD",	// - Kuwaiti Dinar
	"KZT",	// - Kazakhstani Tenge
	"LKR",	// - Sri Lankan Rupee
	"LYD",	// - Libyan Dinar
	"MUR",	// - Mauritian Rupee
	"MXN",	// - Mexican Peso
	"MYR",	// - Malaysian Ringgit
	"NOK",	// - Norwegian Krone
	"NPR",	// - Nepalese Rupee
	"NZD",	// - New Zealand Dollar
	"OMR",	// - Omani Rial
	"PHP",	// - Philippine Peso
	"PKR",	// - Pakistani Rupee
	"PLN",	// - Polish Zloty
	"QAR",	// - Qatari Riyal
	"RON",	// - Romanian New Leu
	"RUB",	// - Russian Ruble
	"SAR",	// - Saudi Arabian Riyal
	"SEK",	// - Swedish Krona
	"SGD",	// - Singapore Dollar
	"THB",	// - Thai Baht
	"TRY",	// - Turkish Lira
	"TTD",	// - Trinidadian Dollar
	"TWD",	// - Taiwan New Dollar
	"USD",	// - US Dollar
	"VEF",	// - Venezuelan Bolivar
	"ZAR"	// - South African Rand	
};

/**************************************************************************************/
/**************************Alarm Share memory**************************************/
/***************************************************************************************
	Status Code	A				B					C											D	E	F
				0: Issue		1: From EVSE 		1: Fault (unrecoverable)					001 ~ 999 serial number
			    										e.g., hardware broken, system latch
				1: Recovered	2: From EV			2: Alarm (recoverable)
			   											e.g., OTP, OVP
								3: From Backend		3: Information
			  											e.g., swipe card to stop charging

according to XXX.Revxx
***************************************************************************************/
/**************************************************************************************/
char FaultStatusCode[40][6]=
{
	"011001",	//CHAdeMO output fuse blew
	"011002",	//CCS output fuse blew
	"011003",	//GB output fuse blew
	"011004",	//RCD/CCID self-test fail
	"011005",	//AC input contactor 1 welding
	"011006",	//AC input contactor 1 driving fault
	"011007",	//AC input contactor 2 welding
	"011008",	//AC input contactor 2 driving fault
	"011009",	//AC output relay welding
	"011010",	//AC output relay  driving fault
	"011011",	//CHAdeMO output relay welding
	"011012",	//CHAdeMO output relay driving fault
	"011013",	//CCS output relay welding
	"011014",	//CCS output relay driving fault
	"011015",	//GB output relay welding
	"011016",	//GB output relay driving fault
	"011017",	//AC connector temperature sensor broken
	"011018",	//CHAdeMO connector temperature sensor broken
	"011019",	//CCS connector temperature sensor broken
	"011020",	//GB connector temperature sensor broken
	"011021",	//WiFi module broken
	"011022",	//3G/4G module broken
	"011023",	//Aux. power module broken
	"011024",	//Relay control module /smart box broken
	"011025",	//CHAdeMO connector lock fail
	"011026",	//GB connector lock fail
	"011027",	//AC connector lock fail
	"011028",	//CHAdeMO module broken
	"011029",	//CCS module broken
	"011030",	//GBT module broken
	"011031",	//PSU module broken
	"011032",	//RCD/CCID module broken
	"011033",	//Maximum Output Current setup error
	"011034",	//Shutter fault 
	"011035",	//Ble module broken
	"011036",	//Rotary switch fault
	"011037",	//CCS liquid chiller water level fault
	"011038",	//Chiller temperature sensor broken
	"011039",	//Parallel relay welding
	"011040"	//Parallel output relay driving fault
};

struct FaultCodeData
{
	unsigned char PreviousFaultVal[FaultCodeLength];
	union
	{
		unsigned char FaultVal[FaultCodeLength];
		struct
		{
			//FaultVal[0]
		    unsigned char ChademoOutputFuseBlew:1;				//bit 0
			unsigned char CcsOutputFuseBlew:1;					//bit 1
			unsigned char GbOutputFuseBlew:1;   				//bit 2
			unsigned char RcdSelfTestFail:1;					//bit 3
			unsigned char AcInputContactor1Welding:1;			//bit 4
			unsigned char AcInputContactor1DrivingFault:1;		//bit 5
			unsigned char AcInputContactor2Welding:1;			//bit 6
			unsigned char AcInputContactor2DrivingFault:1;		//bit 7
			//FaultVal[1]
			unsigned char AcOutputRelayWelding:1;				//bit 0
			unsigned char AcOutputRelayDrivingFault:1;			//bit 1
			unsigned char ChademoOutputRelayWelding:1;			//bit 2
			unsigned char ChademoOutputRelayDrivingFault:1;		//bit 3
			unsigned char CcsOutputRelayWelding:1;				//bit 4
			unsigned char CcsOutputRelayDrivingFault:1;			//bit 5
			unsigned char GbOutputRelayWelding:1;				//bit 6
			unsigned char GbOutputRelayDrivingFault:1;			//bit 7
			//FaultVal[2]
			unsigned char AcConnectorTempSensorBroken:1;		//bit 0
			unsigned char ChademoConnectorTempSensorBroken:1;	//bit 1
			unsigned char CcsConnectorTempSensorBroken:1;		//bit 2
			unsigned char GbConnectorTempSensorBroken:1;		//bit 3
			unsigned char WiFiModuleBroken:1;					//bit 4
			unsigned char Telecom4GModuleBroken:1;				//bit 5
			unsigned char AuxPowerModuleBroken:1;				//bit 6
			unsigned char RelayControlModuleBroken :1;			//bit 7
			//FaultVal[3]
			unsigned char ChademoConnectorLockFail:1;			//bit 0
			unsigned char GbConnectorLockFail:1;				//bit 1
			unsigned char AcConnectorLockFail:1;				//bit 2
			unsigned char ChademoModuleBroken:1;				//bit 3
			unsigned char CcsModuleBroken:1;					//bit 4
			unsigned char GbModuleBroken:1;						//bit 5
			unsigned char PsuModuleBroken:1;					//bit 6
			unsigned char RcdCcidModuleBroken:1;				//bit 7		
			//FaultVal[4]
			unsigned char MaximumOutputCurrentSetupError:1;		//bit 0
			unsigned char ShutterFault:1;						//bit 1
			unsigned char BleModuleBroken:1;					//bit 2
			unsigned char RotarySwitchFault:1;					//bit 3 
			unsigned char CcsLiquidChillerWaterLevelFault:1;    //bit 4
            unsigned char ChillerTempSensorBroken:1;            //bit 5
            unsigned char ParallelRelayWelding:1;               //bit 6
            unsigned char ParallelRelayDriving:1;               //bit 7
		}bits;
	}FaultEvents;
};

char AlarmStatusCode[160][6]=
{
	"012200",	//System L1 input OVP
	"012201",	//System L2 input OVP
	"012202",	//System L3 input OVP
	"012203",	//System L1 input UVP
	"012204",	//System L2 input UVP
	"012205",	//System L3 input UVP
	"012206",	//PSU L1 input OVP
	"012207",	//PSU L2 input OVP
	"012208",	//PSU L3 input OVP
	"012209",	//PSU L1 input UVP
	"012210",	//PSU L2 input UVP
	"012211",	//PSU L3 input UVP
	"012212",	//System L1 input drop
	"012213",	//System L2 input drop
	"012214",	//System L3 input drop
	"012215",	//System AC output OVP
	"012216",	//System AC output OCP L1
	"012217",	//System CHAdeMO output OVP
	"012218",	//System CHAdeMO output OCP
	"012219",	//System CCS output OVP
	"012220",	//System CCS output OCP
	"012221",	//System GB output OVP
	"012222",	//System GB output OCP
	"012223",	//System ambient/inlet OTP
	"012224",	//System critical point OTP
	"012225",	//PSU ambient/inlet OTP
	"012226",	//PSU critical point OTP
	"012227",	//Aux. power module OTP
	"012228",	//Relay board/smart box OTP
	"012229",	//CHAdeMO connector OTP
	"012230",	//CCS connector OTP
	"012231",	//GB connector OTP
	"012232",	//AC connector OTP
	"012233",	//RCD/CCID trip
	"012234",	//CHAdeMO GFD trip
	"012235",	//CCS GFD trip
	"012236",	//GB GFD trip
	"012237",	//SPD trip
	"012238",	//Main power breaker trip
	"012239",	//Aux. power breaker trip
	"012240",	//PSU communication fail
	"012241",	//WiFi module communication fail
	"012242",	//3G/4G module communication fail
	"012243",	//RFID module communication fail
	"012244",	//Bluetooth module communication fail
	"012245",	//LCM module communication fail
	"012246",	//Aux. power module communication fail
	"012247",	//Relay control boaed/smart box communication fail
	"012248",	//CCS module communication fail
	"012249",	//CHAdeMO module communication fail
	"012250",	//GBT module communication fail
	"012251",	//Emergency stop
	"012252",	//Door open
	"012253",	//System fan decay
	"012254",	//Fail to create share memory
	"012255",	//CSU initialization failed
	"012256",	//AC Ground Fault
	"012257",	//MCU self-test Fault
	"012258",	//Relay self-test Fault
	"012259",	//CHAdeMO groundfault detection timeout (GFD)
	"012260",	//CCS groundfault detection timeout (GFD)
	"012261",	//GB groundfault detection timeout (GFD)
	"012262",	//Circuit Short L1
	"012263",	// PSU Duplicate ID
	"012264", 	// Psu Fault : Infy => Output Short Circuit，UU => Abnormal discharge circuit
	"012265", 	// PSU Discharge Abnormal
	"012266", 	// PSU Dc Side ShutDown
	"012267", 	// PSU Failure Alarm
	"012268", 	// PSU Protection Alarm
	"012269", 	// Psu Fault : Infy => Fan Fault，UU => Fan Fault
	"012270", 	// PSU Input UVP
	"012271",	// PSU Input OVP
	"012272", 	// PSU WalkIn State
	"012273", 	// Psu Fault : Infy => Power Limited State，UU => Dc OVP and shutdown
	"012274", 	// Psu Fault : Infy => Id Repeat，UU => Id Repeat
	"012275", 	// Psu Fault : Infy => Severe Uneven Current，UU => Pfc internal unbalance
	"012276", 	// PSU Three Phase Input Inadequate
	"012277", 	// PSU Three Phase Onput Imbalance
	"012278", 	// PSU Ffc Side ShutDown
	"012279", 	// NO PSU Resource
	"012280", 	// Self test Failed due to communication of Relayboard failure
	"012281", 	// Self test Failed due to communication of Fanboard failure
	"012282", 	// Self test Failed due to communication of Primary failure
	"012283", 	// Self test Failed due to communication of Chademoboard failure
	"012284", 	// Self test Failed due to communication of CCSboard failure
	"012285", 	// Self test Failed due to AC Contact failure
	"012286", 	// Self test Failed due to communication of PSU failure
	"012287", 	// Self test Failed due to Model name is none match
	"012288",	// CCS output UVP
	"012289",	// Chademo output UVP
	"012290",	// GBT output UVP
	"012291",	// Self test Failed due to communication of GBTboard failure
	"012292",	// Self test Failed due to communication of AC failure
	"012293",	// Self test Failed due to communication of Ledboard failure
	"012294",	// Ac input OVP
	"012295",	// Ac input UVP
	"012296",	// CHAdeMO groundfault detection - warning
	"012297",	// CCS groundfault detection - warning
	"012298",	// GB groundfault detection - warning
	"012299",	// System AC output OCP L2
	"012300",	// System AC output OCP L3
	"012301",	// Circuit Short L2
	"012302",	// Circuit Short L3
	"012303",   // CCS liquid chiller water level warning
	"012304",   // connection disconnected from power cabinet
	"012305",   // Meter communication timeout
	"012306",   // The dip switch of the PSU may be incorrect
    "012307",   // Psu Fault : Infy => Fuse Burn-Out，UU => Pfc internal OVP
    "012308",   // Psu Fault : Infy => Pfc And Dcdc Communication Fault，UU => Pfc And Dcdc Communication Fault
    "012309",   // Psu Fault : Infy => Bus Voltage Unbalance，UU => Dc output voltage unbalance
    "012310",   // Psu Fault : Infy => Bus Over Voltage，UU => Ac site OVP
    "012311",   // Psu Fault : Infy => Bus Voltage Abnormal，UU => Ac site UVP
    "012312",   // Psu Fault : Infy => Bus Under Voltage，UU => Pfc internal UVP
    "012313",   // Psu Fault : Infy => Input Phase Loss，UU => Dc to Dc don’t work
    "012314",   // Psu Fault : Infy => Fan Full Speed，UU => Fan don’t work
    "012315",   // Psu Fault : Infy => Temperature Power Limit，UU => env OTP、Pfc OTP、output relay broken、Dc OTP
    "012316",   // Psu Fault : Infy => Ac Power Limit，UU => Ac OVP and shutdown
    "012317",   // Psu Fault : Infy => Dcdc Eeprom Fault，UU => Dc to Dc broken
    "012318",   // Psu Fault : Infy => Pfc Eeprom Fault，UU => Pfc broken
    "012319",   // Psu Dcdc Over Voltage
    "012320",   // System CHAdeMO output UCP
    "012321",   // System CCS output UCP
    "012322",   // System GBT output UCP
    "012323",   // System Chiller output OTP
    "012324",   // Connector 1 detects abnormal voltage on the output line
    "012325",   // Connector 2 detects abnormal voltage on the output line
    "012326",   // System task is lost
    "012327",   // System DC input ovp
    "012328",   // System DC input uvp
    "012329",   // Psu Fault : Infy => Psu Can Communication Fault，UU =>
    "012330",   // Psu Fault : Infy => Psu Dc to Dc OTP，UU => env UTP
    "012331",   // Psu Fault : Infy => Psu Dc to Dc OVP，UU => Dc output OVP
    "012332",   // Chiller Tube OTP
    "012333",   // Psu Fault : Infy => DC input ovp (Phase OVP)，UU => Dc output UVP
    "012334",   // reserved
    "012335",   // reserved
    "012336",   // reserved
    "012337",   // reserved
    "012338",   // reserved
    "012339",   // reserved
    "012340",   // reserved
    "012341",   // reserved
    "012342",   // reserved
    "012343",   // reserved
    "012344",   // AC: Meter IC communication timeout
    "012345",   // AC: Pilot negative error
    "012346",   // Psu Communication error with CSU
    "012347",   // AC: Local power sharing communication error (Slave disconnect from Master)
    "012348",   // reserved
    "012349",   // reserved
    "012350",   // reserved
    "012351",   // reserved
    "012352",   // Payment system communication timeout
    "012353",   // reserved
    "012354",   // reserved
    "012355",   // reserved
    "012356",   // reserved
    "012357",   // reserved
    "012358",   // reserved
    "012359",   // reserved
};
struct AlarmCodeData
{
	unsigned char PreviousAlarmVal[AlarmCodeLength];
	union
	{
		unsigned char AlarmVal[AlarmCodeLength];
		struct
		{
			//AlarmVal[0]
		    unsigned char SystemL1InputOVP:1;					//bit 0
			unsigned char SystemL2InputOVP:1;					//bit 1
			unsigned char SystemL3InputOVP:1;   				//bit 2
			unsigned char SystemL1InputUVP:1;					//bit 3
			unsigned char SystemL2InputUVP:1;					//bit 4
			unsigned char SystemL3InputUVP:1;					//bit 5
			unsigned char PsuL1InputOVP:1;						//bit 6
			unsigned char PsuL2InputOVP:1;						//bit 7
			//AlarmVal[1]
			unsigned char PsuL3InputOVP:1;						//bit 0
			unsigned char PsuL1InputUVP:1;						//bit 1
			unsigned char PsuL2InputUVP:1;						//bit 2
			unsigned char PsuL3InputUVP	:1;						//bit 3
			unsigned char SystemL1InputDrop:1;					//bit 4
			unsigned char SystemL2InputDrop:1;					//bit 5
			unsigned char SystemL3InputDrop:1;					//bit 6
			unsigned char SystemAcOutputOVP:1;					//bit 7
			//AlarmVal[2]
			unsigned char SystemAcOutputOCP:1;					//bit 0
			unsigned char SystemChademoOutputOVP:1;				//bit 1
			unsigned char SystemChademoOutputOCP:1;				//bit 2
			unsigned char SystemCcsOutputOVP:1;					//bit 3
			unsigned char SystemCcsOutputOCP:1;					//bit 4
			unsigned char SystemGbOutputOVP:1;					//bit 5
			unsigned char SystemGbOutputOCP:1;					//bit 6
			unsigned char SystemAmbientOTP :1;					//bit 7
			//AlarmVal[3]
			unsigned char SystemCriticalPointOTP:1;				//bit 0
			unsigned char PsuAmbientOTP:1;						//bit 1
			unsigned char PsuCriticalPointOTP:1;				//bit 2
			unsigned char AuxPowerModuleOTP:1;					//bit 3
			unsigned char RelayBoardOTP:1;						//bit 4
			unsigned char ChademoConnectorOTP:1;				//bit 5
			unsigned char CcsConnectorOTP:1;					//bit 6
			unsigned char GbConnectorOTP:1;						//bit 7
			 //AlarmVal[4]
			unsigned char AcConnectorOTP:1;						//bit 0
			unsigned char RcdTrip:1;							//bit 1
			unsigned char ChademoGfdTrip:1;						//bit 2
			unsigned char CcsGfdTrip:1;							//bit 3
			unsigned char GbGfdTrip:1;							//bit 4
			unsigned char SpdTrip:1;							//bit 5
			unsigned char MainPowerBreakerTrip:1;				//bit 6
			unsigned char AuxPowerBreakerTrip:1;				//bit 7
			//AlarmVal[5]
			unsigned char PsuCommunicationFail:1;				//bit 0
			unsigned char WiFiModuleCommFail:1;					//bit 1
			unsigned char Telecom4GModuleCommFail:1;			//bit 2
			unsigned char RfidModuleCommFail:1;					//bit 3
			unsigned char BluetoothModuleCommFail:1;			//bit 4
			unsigned char LcmModuleCommFail:1;					//bit 5
			unsigned char AuxPowerModuleCommFail:1;				//bit 6
			unsigned char RelayBoardCommFail:1;					//bit 7
			//AlarmVal[6]
			unsigned char CcsModuleCommFail:1;					//bit 0
			unsigned char ChademoModuleCommFail:1;				//bit 1
			unsigned char GbModuleCommFail:1;					//bit 2
			unsigned char EmergencyStopTrip:1;					//bit 3
			unsigned char DoorOpen:1;							//bit 4
			unsigned char SystemFanDecay:1;						//bit 5
			unsigned char FailToCreateShareMemory:1;			//bit 6
			unsigned char CsuInitFailed:1;						//bit 7
			//AlarmVal[7]
			unsigned char AcGroundfaultFail:1;					//bit 0
			unsigned char McuSelftestFail:1;					//bit 1
			unsigned char RelaySelftestFail:1;					//bit 2
			unsigned char ChademoGroundfaultTimeout:1;			//bit 3
			unsigned char CcsGroundfaultTimeout:1;				//bit 4
			unsigned char GbGroundfaultTimeout:1;				//bit 5
			unsigned char CircuitShort:1;						//bit 6
			unsigned char PsuDuplicateID:1;						//bit 7
			//AlarmVal[8]
			unsigned char PsuOutputShortCircuit :1;				//bit 0
			unsigned char PsuDischargeAbnormal :1;				//bit 1
			unsigned char PsuDcSideShutDown :1;					//bit 2
			unsigned char PsuFailureAlarm :1;					//bit 3
			unsigned char PsuProtectionAlarm :1;				//bit 4
			unsigned char PsuFanFailureAlarm :1;				//bit 5
			unsigned char PsuInputUVP:1;						//bit 6
			unsigned char PsuInputOVP:1;						//bit 7
			//AlarmVal[9]
			unsigned char PsuWalkInState :1;					//bit 0
			unsigned char PsuPowerLimitedState :1;				//bit 1
			unsigned char PsuIdRepeat :1;						//bit 2
			unsigned char PsuSevereUnevenCurrent :1;			//bit 3
			unsigned char PsuThreePhaseInputInadequate :1;		//bit 4
			unsigned char PsuThreePhaseOnputImbalance :1;		//bit 5
			unsigned char PsuFfcSideShutDown :1;				//bit 6
			unsigned char PsuNoResource:1;						//bit 7
			//AlarmVal[10]
			unsigned char RelayboardStestFail :1;				//bit 0
			unsigned char FanboardStestFail :1;					//bit 1
			unsigned char PrimaryStestFail :1;					//bit 2
			unsigned char ChademoboardStestFail :1;				//bit 3
			unsigned char CCSboardStestFail :1;					//bit 4
			unsigned char AcContactStestFail :1;				//bit 5
			unsigned char PsuModuleStestFail :1;				//bit 6
			unsigned char ModelNameNoneMatchStestFail:1;		//bit 7	
			//AlarmVal[11]
			unsigned char CcsOutputUVPFail :1;					//bit 0
			unsigned char ChademoOutputUVPFail :1;				//bit 1
			unsigned char GbtOutputUVPFail :1;					//bit 2
			unsigned char GbtboardStestFail :1;					//bit 3
			unsigned char AcConnectorStestFail:1;				//bit 4
			unsigned char LedboardStestFail:1;					//bit 5
			unsigned char AcSystemInputOVP:1;					//bit 6
			unsigned char AcSystemInputUVP:1;					//bit 7
			//AlarmVal[12]
			unsigned char ChademoGroundWarning :1;					//bit 0
			unsigned char CcsGroundfaultWarning :1;					//bit 1
			unsigned char GbGroundfaultWarning :1;					//bit 2
			unsigned char SystemAcOutputOCPL2:1;					//bit 3
			unsigned char SystemAcOutputOCPL3:1;					//bit 4
			unsigned char CircuitShortL2:1;							//bit 5
			unsigned char CircuitShortL3:1;							//bit 6
			unsigned char CcsLiquidChillerWaterLevelWarning:1;      //bit 7
			//AlarmVal[13]
			unsigned char DisconnectedFromDo:1;                     //bit 0
            		unsigned char MeterCommTimeout:1;                       //bit 1
            		unsigned char PsuDipSwitchStestFail:1;                  //bit 2
            		unsigned char PsuFuseBurnOut:1;                         //bit 3
            		unsigned char PsuPfcAndDcdcCommFault:1;                 //bit 4
            		unsigned char PsuBusVoltageUnbalance:1;                 //bit 5
            		unsigned char PsuBusOverVoltage:1;                      //bit 6
            		unsigned char PsuBusVoltageAbnormal:1;                  //bit 7
            		//AlarmVal[14]
            		unsigned char PsuBusUnderVoltage:1;                     //bit 0
            		unsigned char PsuInputPhaseLoss:1;                      //bit 1
            		unsigned char PsuFanFullSpeed:1;                        //bit 2
            		unsigned char PsuTemperaturePowerLimit:1;               //bit 3
            		unsigned char PsuAcPowerLimit:1;                        //bit 4
            		unsigned char PsuDcdcEepromFault:1;                     //bit 5
            		unsigned char PsuPfcEepromFault:1;                      //bit 6
            		unsigned char PsuDcdcOverVoltage:1;                     //bit 7
            		//AlarmVal[15]
            		unsigned char SystemChademoOutputUCP:1;                 //bit 0
            		unsigned char SystemCCSOutputUCP:1;                     //bit 1
            		unsigned char SystemGBTOutputUCP:1;                     //bit 2
            		unsigned char SystemChillerOTP:1;                       //bit 3
            		unsigned char AbnormalVoltageOnOutputLine_1:1;          //bit 4
            		unsigned char AbnormalVoltageOnOutputLine_2:1;          //bit 5
            		unsigned char SystemTaskLost:1;                         //bit 6
            		unsigned char DcInputOVP:1;                             //bit 7
            		//AlarmVal[16]
            		unsigned char DcInputUVP:1;                             //bit 0
            		unsigned char PsuCanCommFault:1;                        //bit 1
            		unsigned char PsuDcDcOtp:1;                             //bit 2
            		unsigned char PsuDcDcOvp:1;                             //bit 3
            		unsigned char ChillerTubeOTP : 1;                       //bit 4
            		unsigned char PsuPhaseOvp:1;                            //bit 5
            		unsigned char :2;                                       //reserved bit 6 ~ bit 7
            		//AlarmVal[17]
            		unsigned char :8;                                       //reserved bit 0 ~ bit 7
            		//AlarmVal[18]
            		unsigned char MeterIcCommTimeout:1;                     //bit 0
            		unsigned char PilotNegativeError:1;                     //bit 1
            		unsigned char PsuComminicationErrWithCSU:1;             //bit 2
            		unsigned char LocalPowerSharingCommunicationError:1;    //bit 3
            		unsigned char :4;                                       //reserved bit 4 ~ bit 7
            		//AlarmVal[19]
            		unsigned char PaymentCommTimeout;			//Payment system communication timeout
	    		unsigned char :7;					//reserved bit 0 ~ bit 7        
		}bits;
	}AlarmEvents;
};

char InfoStatusCode[384][6]=
{
	//Information comes from EVSE
	"013600",	//Normal stop charging by user
	"013601",	//Charging Time's up
	"013602",	//Replace system air filter
	"013603",	//Reach to CHAdeMO max. plugging times.
	"013604",	//Reach to CCS max. plugging times.
	"013605",	//Reach to GB max. plugging times.
	"013606",	//Reach to AC max. plugging times.
	"013607",	//CSU fimrware update fail
	"013608",	//CHAdeMO Module fimrware update fail
	"013609",	//CCS Module fimrware update fail
	"013610",	//GB Module fimrware update fail
	"013611",	//Aux. power module fimrware update fail
	"013612",	//Relay control module fimrware update fail
	"013613",	//LCM module fimrware update fail
	"013614",	//Bluetooth module fimrware update fail
	"013615",	//WiFi module fimrware update fail
	"013616",	//3G/4G module fimrware update fail
	"013617",	//SMR fimrware update fail
	"013618",	//RFID module fimrware update fail
	"013619",	//configured by USB flash drive
	"013620",	//configured by backend
	"013621",	//configured by webpage
	"013622",	//disconnected from Internet through Ethernet
	"013623",	//disconnected from Internet through WiFi
	"013624",	//disconnected from Internet through 3G/4G
	"013625",	//disconnected from AP through WiFi
	"013626",	//disconnected from APN through 3G/4G
	"013627",	//WiFi disabled (separated charger only)
	"013628",	//4G disabled (separated charger only)
	"013629",	//Reserved
	"013630",	//Reserved
	"013631",	//Reserved
	//Information comes from EV
	"023700",	//CHAdeMO EV communication Fail
	"023701",	//CCS EV communication Fail
	"023702",	//GB EV communication Fail
	"023703",	//AC: pilot fault
	"023704",	//CHAdeMO:  battery malfunction
	"023705",	//CHAdeMO:  no charging permission
	"023706",	//CHAdeMO:  battery incompatibility
	"023707",	//CHAdeMO:  battery OVP
	"023708",	//CHAdeMO:  battery UVP
	"023709",	//CHAdeMO:  battery OTP
	"023710",	//CHAdeMO:  battery current difference
	"023711",	//CHAdeMO:  battery voltage difference
	"023712",	//CHAdeMO:  shift position
	"023713",	//CHAdeMO:  battery other fault
	"023714",	//CHAdeMO:  charging system error
	"023715",	//CHAdeMO:  EV normal stop
	"023716",	//CHAdeMO:  connector temperature sensor broken
	"023717",	//CHAdeMO:  connector lock fail
	"023718",	//CHAdeMO:	D1 ON No Receive
	"023719",	//CHAdeMO:	BMS K to J Timeout
	"023720",	//CHAdeMO:	BMS Charge Allow Timeout
	"023721",	//CHAdeMO:	Wait GroundFault Timeout
	"023722",	//CHAdeMO:	BMS EV Relay Timeout
	"023723",	//CHAdeMO:	BMS Request Current Timeout
	"023724",	//CHAdeMO:	BMS K to J OFF Timeout
	"023725",	//CHAdeMO:	BMS EV Relay OFF Timeout
	"023726",	//CHAdeMO:	ADC More Than 10V
	"023727",	//CHAdeMO:	ADC More Than 20V
	"023728",	//CHAdeMO:	BMS Charge Before Stop
	"023729",	//CHAdeMO:	Charger Get Normal Stop
	"023730",	//CHAdeMO:	Charger Get Emergency Stop
	"023731",	//CHAdeMO:  Isolation Result Fail
	"023732",	//CHAdeMO: 	Miss Link With MotherBoard
	"023733",	//CHAdeMO:	Output Voltage More Than Limit
	"023734",	//CHAdeMO:	Request Current More Than Limit
	"023735",	//CHAdeMO: 	Re Cap BMS Eqr Current Exceed
	"023736",	//CHAdeMO:	Charge Remain Count Down
	"023737",	//CCS:CCS_EVCC_EVErrorCode_FAILED_RESSTemperatureInhibit
	"023738",	//CCS:CCS_EVCC_EVErrorCode_FAILED_EVShiftPosition
	"023739",	//CCS:CCS_EVCC_EVErrorCode_FAILED_ChargerConnectorLockFault
	"023740",	//CCS:CCS_EVCC_EVErrorCode_FAILED_EVRESSMalfunction
	"023741",	//CCS:CCS_EVCC_EVErrorCode_FAILED_ChargingCurrentdifferential
	"023742",	//CCS:CCS_EVCC_EVErrorCode_FAILED_ChargingVoltageOutOfRange
	"023743",	//CCS:CCS_EVCC_EVErrorCode_FAILED_ChargingSystemIncompatibility
	"023744",	//CCS:CCS_EVCC_EVErrorCode_FAILED_EmergencyEvent
	"023745",	//CCS:CCS_EVCC_EVErrorCode_FAILED_Breaker
	"023746",	//CCS:CCS_EVCC_EVErrorCode_FAILED_NoData
	"023747",	//CCS:CCS_EVCC_EVErrorCode_FAILED_reserved_by_DIN_A
	"023748",	//CCS:CCS_EVCC_EVErrorCode_FAILED_reserved_by_DIN_B
	"023749",	//CCS:CCS_EVCC_EVErrorCode_FAILED_reserved_by_DIN_C
	"023750",	//CCS:CCS_EVCC_EVErrorCode_FAILED_reserved_by_ISO_1
	"023751",	//CCS:CCS_EVCC_EVErrorCode_FAILED_reserved_by_ISO_2
	"023752",	//CCS:CCS_EVCC_EVErrorCode_FAILED_reserved_by_ISO_3
	"023753",	//CCS:CCS_EVCC_EVErrorCode_FAILED_reserved_by_OEM_1
	"023754",	//CCS:CCS_EVCC_EVErrorCode_FAILED_reserved_by_OEM_2
	"023755",	//CCS:CCS_EVCC_EVErrorCode_FAILED_reserved_by_OEM_3
	"023756",	//CCS:CCS_EVCC_EVErrorCode_FAILED_reserved_by_OEM_4
	"023757",	//CCS:CCS_EVCC_EVErrorCode_FAILED_reserved_by_OEM_5
	"023758",	//CCS:CCS_SECC_ResponseCode_FAILED_SequenceError
	"023759",	//CCS:CCS_SECC_ResponseCode_FAILED_SignatureError
	"023760",	//CCS:CCS_SECC_ResponseCode_FAILED_UnknownSession
	"023761",	//CCS:CCS_SECC_ResponseCode_FAILED_ServiceIDInvalid
	"023762",	//CCS:CCS_SECC_ResponseCode_FAILED_Payment SelectionInvalid
	"023763",	//CCS:CCS_SECC_ResponseCode_FAILED_IdentificationSelectionInvalid
	"023764",	//CCS:CCS_SECC_ResponseCode_FAILED_ServiceSelectionInvalid
	"023765",	//CCS:CCS_SECC_ResponseCode_FAILED_CertificateExpired
	"023766",	//CCS:CCS_SECC_ResponseCode_FAILED_CertificateNotYetValid
	"023767",	//CCS:CCS_SECC_ResponseCode_FAILED_CertificateRevoked
	"023768",	//CCS:CCS_SECC_ResponseCode_FAILED_NoCertificateAvailable
	"023769",	//CCS:CCS_SECC_ResponseCode_FAILED_CertChainError
	"023770",	//CCS:CCS_SECC_ResponseCode_FAILED_CertValidationError
	"023771",	//CCS:CCS_SECC_ResponseCode_FAILED_CertVerificationError
	"023772",	//CCS:CCS_SECC_ResponseCode_FAILED_ContractCanceled
	"023773",	//CCS:CCS_SECC_ResponseCode_FAILED_ChallengeInvalid
	"023774",	//CCS:CCS_SECC_ResponseCode_FAILED_WrongEnergyTransferMode
	"023775",	//CCS:CCS_SECC_ResponseCode_FAILED_WrongChargeParameter
	"023776",	//CCS:CCS_SECC_ResponseCode_FAILED_ChargingProfileInvalid
	"023777",	//CCS:CCS_SECC_ResponseCode_FAILED_TariffSelectionInvalid
	"023778",	//CCS:CCS_SECC_ResponseCode_FAILED_EVSEPresentVoltageToLow
	"023779",	//CCS:CCS_SECC_ResponseCode_FAILED_PowerDeliveryNotApplied
	"023780",	//CCS:CCS_SECC_ResponseCode_FAILED_MeteringSignatureNotValid
	"023781",	//CCS:CCS_SECC_ResponseCode_FAILED_NoChargeServiceSelected
	"023782",	//CCS:CCS_SECC_ResponseCode_FAILED_ContactorError
	"023783",	//CCS:CCS_SECC_ResponseCode_FAILED_CertificateNotAllowedAtThisEVSE
	"023784",	//CCS:CCS_SECC_ResponseCode_FAILED_GAChargeStop
	"023785",	//CCS:CCS_SECC_ResponseCode_FAILED_AlignmentError
	"023786",	//CCS:CCS_SECC_ResponseCode_FAILED_ACDError
	"023787",	//CCS:CCS_SECC_ResponseCode_FAILED_AssociationError
	"023788",	//CCS:CCS_SECC_ResponseCode_FAILED_EVSEChargeAbort
	"023789",	//CCS:CCS_SECC_ResponseCode_FAILED_NoSupportedApp-Protocol-Protocol
	"023790",	//CCS:CCS_SECC_ResponseCode_FAILED_ContractNotAccepted
	"023791",	//CCS:CCS_SECC_ResponseCode_FAILED_MOUnknown
	"023792",	//CCS:CCS_SECC_ResponseCode_FAILED_OEM_Prov_CertificateRevoke
	"023793",	//CCS:CCS_SECC_ResponseCode_FAILED_OEM_SubCA1_CertificateRevoked
	"023794",	//CCS:CCS_SECC_ResponseCode_FAILED_OEM_SubCA2_CertificateRevoked
	"023795",	//CCS:CCS_SECC_ResponseCode_FAILED_OEM_RootCA_CertificateRevoked
	"023796",	//CCS:CCS_SECC_ResponseCode_FAILED_MO_Prov_CertificateRevoked
	"023797",	//CCS:CCS_SECC_ResponseCode_FAILED_MO_SubCA1_CertificateRevoked
	"023798",	//CCS:CCS_SECC_ResponseCode_FAILED_MO_SubCA2_CertificateRevoked
	"023799",	//CCS:CCS_SECC_ResponseCode_FAILED_MO_RootCA_CertificateRevoked
	"023800",	//CCS:CCS_SECC_ResponseCode_FAILED_CPS_Prov_CertificateRevoked
	"023801",	//CCS:CCS_SECC_ResponseCode_FAILED_CPS_SubCA1_CertificateRevoked
	"023802",	//CCS:CCS_SECC_ResponseCode_FAILED_CPS_SubCA2_CertificateRevoked
	"023803",	//CCS:CCS_SECC_ResponseCode_FAILED_CPS_RootCA_CertificateRevoked
	"023804",	//CCS:CCS_SECC_ResponseCode_FAILED_reserved_1
	"023805",	//CCS:CCS_SECC_ResponseCode_FAILED_reserved_2
	"023806",	//CCS:CCS_SECC_ResponseCode_FAILED_reserved_3
	"023807",	//CCS:CCS_SECC_ResponseCode_FAILED_reserved_4
	"023808",	//CCS:CCS_SECC_ResponseCode_FAILED_reserved_5
	"023809",	//CCS:CCS_SECC_TIMEOUT_SLAC_TT_EVSE_SLAC_init
	"023810",	//CCS:CCS_SECC_TIMEOUT_SLAC_TP_match_response
	"023811",	//CCS:CCS_SECC_TIMEOUT_CM_START_ATTEN_CHAR_IND
	"023812",	//CCS:CCS_SECC_TIMEOUT_SLAC_TT_EVSE_match_MNBC
	"023813",	//CCS:CCS_SECC_TIMEOUT_SLAC_TP_EVSE_avg_atten_calc
	"023814",	//CCS:CCS_SECC_TIMEOUT_SLAC_CM_ATTEN_CHAR_RSP
	"023815",	//CCS:CCS_SECC_TIMEOUT_SLAC_CM_VALIDATE_REQ_1ST__CM_SLAC_MATCH_REQ
	"023816",	//CCS:CCS_SECC_TIMEOUT_SLAC_TT_EVSE_assoc_session
	"023817",	//CCS:CCS_SECC_TIMEOUT_SLAC_TT_EVSE_vald_toggle
	"023818",	//CCS:CCS_SECC_TIMEOUT_SLAC_CM_MNBC_SOUND_IND
	"023819",	//CCS:CCS_SECC_TIMEOUT_SLAC_CM_VALIDATE_REQ_2ND__CM_SLAC_MATCH_REQ
	"023820",	//CCS:CCS_SECC_TIMEOUT_SLAC_reserved_3
	"023821",	//CCS:CCS_SECC_TIMEOUT_SLAC_reserved_4
	"023822",	//CCS:CCS_SECC_TIMEOUT_SLAC_reserved_5
	"023823",	//CCS:CCS_SECC_TIMEOUT_SLACC_SDP_UDP_TT_match_join
	"023824",	//CCS:CCS_SECC_TIMEOUT_SLACC_SDP_TCP_TT_match_join
	"023825",	//CCS:CCS_SECC_TIMEOUT_SLACC_SDP_TP_amp_map_exchange
	"023826",	//CCS:CCS_SECC_TIMEOUT_SLACC_SDP_TP_link_ready_notification
	"023827",	//CCS:CCS_SECC_TIMEOUT_SLACC_SDP_reserved_1
	"023828",	//CCS:CCS_SECC_TIMEOUT_SLACC_SDP_reserved_2
	"023829",	//CCS:CCS_SECC_TIMEOUT_SLACC_SDP_reserved_3
	"023830",	//CCS:CCS_SECC_TIMEOUT_SLACC_SDP_reserved_4
	"023831",	//CCS:CCS_SECC_TIMEOUT_SLACC_SDP_reserved_5
	"023832",	//CCS:CCS_SECC_TIMEOUT_V2G_Msg_Performance_Time_SupportedAppProtocolRes
	"023833",	//CCS:CCS_SECC_TIMEOUT_V2G_Msg_Performance_Time_SessionSetupRes
	"023834",	//CCS:CCS_SECC_TIMEOUT_V2G_Msg_Performance_Time_ServiceDiscoveryRes
	"023835",	//CCS:CCS_SECC_TIMEOUT_V2G_Msg_Performance_Time_ServicePaymentSelectionRes
	"023836",	//CCS:CCS_SECC_TIMEOUT_V2G_Msg_Performance_Time_ContractAuthenticationRes
	"023837",	//CCS:CCS_SECC_TIMEOUT_V2G_Msg_Performance_Time_ChargeParameterDiscoveryRes
	"023838",	//CCS:CCS_SECC_TIMEOUT_V2G_Msg_Performance_Time_PowerDeliveryRes
	"023839",	//CCS:CCS_SECC_TIMEOUT_V2G_Msg_Performance_Time_CableCheckRes
	"023840",	//CCS:CCS_SECC_TIMEOUT_V2G_Msg_Performance_Time_PreChargeRes
	"023841",	//CCS:CCS_SECC_TIMEOUT_V2G_Msg_Performance_Time_CurrentDemandRes
	"023842",	//CCS:CCS_SECC_TIMEOUT_V2G_Msg_Performance_Time_WeldingDetectionRes
	"023843",	//CCS:CCS_SECC_TIMEOUT_V2G_Msg_Performance_Time_SessionStopRes
	"023844",	//CCS:CCS_SECC_TIMEOUT_V2G_Sequence_Time
	"023845",	//CCS:CCS_SECC_TIMEOUT_V2G_ReadyToCharge_Performance_Time
	"023846",	//CCS:CCS_SECC_TIMEOUT_V2G_CommunicationSetup_Performance_Time
	"023847",	//CCS:CCS_SECC_TIMEOUT_V2G_CableCheck_Performance_Time
	"023848",	//CCS:CCS_SECC_TIMEOUT_V2G_CPState_Detection_Time
	"023849",	//CCS:CCS_SECC_TIMEOUT_V2G_CPOscillator_Retain_Time
	"023850",	//CCS:CCS_SECC_TIMEOUT_V2G_PreCharge_Performace_Time
	"023851",	//CCS:CCS_SECC_TIMEOUT_V2G_reserved_2
	"023852",	//CCS:CCS_SECC_TIMEOUT_V2G_reserved_3
	"023853",	//CCS:CCS_SECC_TIMEOUT_V2G_reserved_4
	"023854",	//CCS:CCS_SECC_TIMEOUT_V2G_reserved_5
	"023855",	//CCS:CCS_CAN_TIMEOUT_TP_GET_EV_TARGET_INFO
	"023856",	//CCS:CCS_CAN_TIMEOUT_TT_GET_EV_TARGET_INFO
	"023857",	//CCS:CCS_CAN_TIMEOUT_TP_GET_EV_BATTERY_INFO
	"023858",	//CCS:CCS_CAN_TIMEOUT_TT_GET_EV_BATTERY_INFO
	"023859",	//CCS:CCS_CAN_TIMEOUT_TP_EV_STOP_EVENT
	"023860",	//CCS:CCS_CAN_TIMEOUT_TT_EV_STOP_EVENT
	"023861",	//CCS:CCS_CAN_TIMEOUT_TP_EVSE_STOP_EVENT
	"023862",	//CCS:CCS_CAN_TIMEOUT_TT_EVSE_STOP_EVENT
	"023863",	//CCS:CCS_CAN_TIMEOUT_TP_GET_MISC_INFO
	"023864",	//CCS:CCS_CAN_TIMEOUT_TT_GET_MISC_INFO
	"023865",	//CCS:CCS_CAN_TIMEOUT_TP_DOWNLOAD_REQUEST
	"023866",	//CCS:CCS_CAN_TIMEOUT_TT_DOWNLOAD_REQUEST
	"023867",	//CCS:CCS_CAN_TIMEOUT_TP_START_BLOCK_TRANSFER
	"023868",	//CCS:CCS_CAN_TIMEOUT_TT_START_BLOCK_TRANSFER
	"023869",	//CCS:CCS_CAN_TIMEOUT_TP_DATA_TRANSFER
	"023870",	//CCS:CCS_CAN_TIMEOUT_TT_DATA_TRANSFER
	"023871",	//CCS:CCS_CAN_TIMEOUT_TP_DOWNLOAD_FINISH
	"023872",	//CCS:CCS_CAN_TIMEOUT_TT_DOWNLOAD_FINISH
	"023873",	//CCS:CCS_CAN_TIMEOUT_TP_ISOLATION_STATUS
	"023874",	//CCS:CCS_CAN_TIMEOUT_TT_ISOLATION_STATUS
	"023875",	//CCS:CCS_CAN_TIMEOUT_TP_CONNECTOR_INFO
	"023876",	//CCS:CCS_CAN_TIMEOUT_TT_CONNECTOR_INFO
	"023877",	//CCS:CCS_CAN_TIMEOUT_TT_RTC_INFO
	"023878",	//CCS:CCS_CAN_TIMEOUT_TP_RTC_INFO
	"023879",	//CCS:CCS_CAN_TIMEOUT_TP_EVSE_PRECHARGE_INFO
	"023880",	//CCS:CCS_CAN_TIMEOUT_TT_EVSE_PRECHARGE_INFO
	"023881",	//CCS:CCS_CAN_TIMEOUT_MSG_Sequence
	"023882",	//CCS:CCS_CAN_MSG_Unrecognized_CMD_ID
	"023883",	//CCS:CCS_SECC_DIN_Msg_Decode_Error
	"023884",	//CCS:CCS_SECC_DIN_Msg_Encode_Error
	"023885",	//CCS:CCS_SECC_ISO1_Msg_Decode_Error
	"023886",	//CCS:CCS_SECC_ISO1_Msg_Encode_Error
	"023887",	//CCS:CCS_SECC_ISO2_Msg_Decode_Error
	"023888",	//CCS:CCS_SECC_ISO2_Msg_Encode_Error
	"023889",	//CCS:CCS_SECC_CP_STATUS_Error
	"023890",	//CCS:CCS_SECC_Unexpected_60V_Before_Charing_Error
	"023891",	//CCS:CCS_SECC_Not_Ready_For_Charging
	"023892",	//CCS:CCS_SECCC_TIMEOUT_QCA7000_COMM (The firmware code of QCA7000 may not be installed, yet)
	"023893",	//CCS:CCS_SECC_FAIL_QCA7000_SETKEY
	"023894",	//Reserved
	"023895",	//Reserved
	"023896",	//Reserved
	"023897",	//Reserved
	"023898",	//Reserved
	"023899",	//Reserved
	"023900",	//GBT: ERROR_CODE_GBT_LOS_CC1
	"023901",	//GBT: ERROR_CODE_GBT_CONNECTOR_LOCK_FAIL
	"023902",	//GBT: ERROR_CODE_GBT_BATTERY_INCOMPATIBLE
	"023903",	//GBT: ERROR_CODE_GBT_BMS_BROAA_TIMEOUT
	"023904",	//GBT: ERROR_CODE_GBT_CSU_PRECHARGE_TIMEOUT
	"023905",	//GBT: ERROR_CODE_GBT_BMS_PRESENT_VOLTAGE_FAULT
	"023906",	//GBT: ERROR_CODE_GBT_BMS_VOLTAGE_OVER_RANGE
	"023907",	//GBT: ERROR_CODE_GBT_BSM_CHARGE_ALLOW_00_10MIN_COUUNTDONE
	"023908",	//GBT: ERROR_CODE_GBT_WAIT_GROUNDFAULT_TIMEOUT
	"023909",	//GBT: ERROR_CODE_GBT_ADC_MORE_THAN_10V
	"023910",	//GBT: ERROR_CODE_GBT_ADC_MORE_THAN_60V
	"023911",	//GBT: ERROR_CODE_GBT_CHARGER_GET_NORMAL_STOP_CMD
	"023912",	//GBT: ERROR_CODE_GBT_CHARGER_GET_EMERGENCY_STOP_CMD
	"023913",	//GBT: ERROR_CODE_GBT_ISOLATION_RESULT_FAIL
	"023914",	//GBT: ERROR_CODE_GBT_MOTHER_BOARD_MISS_LINK
	"023915",	//GBT: ERROR_CODE_GBT_OUTPUT_VOLTAGE_MORE_THAN_LIMIT
	"023916",	//GBT: ERROR_CODE_GBT_REQ_CURRENT_MORE_THAN_LIMIT
	"023917",	//GBT: ERROR_CODE_GBT_OUTPUT_VOLTAGE_MORE_THAN_10_PERCENT
	"023918",	//GBT: ERROR_CODE_GBT_OUTPUT_VOLTAGE_DIFF_BCS_5_PERCENT
	"023919",	//GBT: ERROR_CODE_GBT_STOP_ADC_MORE_THAN_10V
	"023920",	// Reserved
	"023921",	// Reserved
	"023922",	// Reserved
	"023923",	// Reserved
	"023924",	// Reserved
	"023925",	// Reserved
	"023926",	// Reserved
	"023927",	// Reserved
	"023928",	// Reserved
	"023929",	// Reserved
	"023930",	//GBT: ERROR_CODE_CEM_BHM_TIMEOUT
	"023931",	//GBT: ERROR_CODE_CEM_BRM_TIMEOUT
	"023932",	//GBT: ERROR_CODE_CEM_BCP_TIMEOUT
	"023933",	//GBT: ERROR_CODE_CEM_BRO_TIMEOUT
	"023934",	//GBT: ERROR_CODE_CEM_BCL_TIMEOUT
	"023935",	//GBT: ERROR_CODE_CEM_BCS_TIMEOUT
	"023936",	//GBT: ERROR_CODE_CEM_BSM_TIMEOUT
	"023937",	//GBT: ERROR_CODE_CEM_BST_TIMEOUT
	"023938",	//GBT: ERROR_CODE_CEM_BSD_TIMEOUT
	"023939",	//GBT: ERROR_CODE_CEM_BEM_OTHER_TIMEOUT
	"023940",	//GBT: ERROR_CODE_BEM_CRM_TIMEOUT
	"023941",	//GBT: ERROR_CODE_BEM_CRMAA_TIMEOUT
	"023942",	//GBT: ERROR_CODE_BEM_CTS_CML_TIMEOUT
	"023943",	//GBT: ERROR_CODE_BEM_CRO_TIMEOUT
	"023944",	//GBT: ERROR_CODE_BEM_CCS_TIMEOUT
	"023945",	//GBT: ERROR_CODE_BEM_CST_TIMEOUT
	"023946",	//GBT: ERROR_CODE_BEM_CSD_TIMEOUT
	"023947",	//GBT: ERROR_CODE_BEM_BEM_OTHER_TIMEOUT
	"023948",	// Reserved
	"023949",	// Reserved
	"023950",	//GBT: ERROR_CODE_BST_SOC_GOAL
	"023951",	//GBT: ERROR_CODE_BST_TOTAL_VOLTAGE_GOAL
	"023952",	//GBT: ERROR_CODE_BST_CELL_VOLTAGE_GOAL
	"023953",	//GBT: ERROR_CODE_BST_GET_CST
	"023954",	//GBT: ERROR_CODE_BST_ISOLATION
	"023955",	//GBT: ERROR_CODE_BST_OUTPUT_CONNECTOR_OTP
	"023956",	//GBT: ERROR_CODE_BST_COMPONENT
	"023957",	//GBT: ERROR_CODE_BST_CHARGE_CONNECTOR
	"023958",	//GBT: ERROR_CODE_BST_OTP
	"023959",	//GBT: ERROR_CODE_BST_OTHER
	"023960",	//GBT: ERROR_CODE_BST_HIGH_V
	"023961",	//GBT: ERROR_CODE_BST_CC2
	"023962",	//GBT: ERROR_CODE_BST_CURRENT
	"023963",	//GBT: ERROR_CODE_BST_VOLTAGE
	"023964",	//GBT: ERROR_CODE_GET_BST_NO_REASON
	"023965",	// Reserved
	"023966",	// Reserved
	"023967",	// Reserved
	"023968",	// Reserved
	"023969",	// Reserved
	"023970",	//GBT: ERROR_CODE_BSM_CELL_OVER_VOLTAGE
	"023971",	//GBT: ERROR_CODE_BSM_CELL_UNDER_VOLTAGE
	"023972",	//GBT: ERROR_CODE_BSM_OVER_SOC
	"023973",	//GBT: ERROR_CODE_BSM_UNDER_SOC
	"023974",	//GBT: ERROR_CODE_BSM_CURRENT
	"023975",	//GBT: ERROR_CODE_BSM_TEMPERATURE
	"023976",	//GBT: ERROR_CODE_BSM_ISOLATE
	"023977",	//GBT: ERROR_CODE_BSM_OUTPUT_CONNECTOR
	"023978",	// Reserved
	"023979",	// EV full charging
    "023980",   // ERROR_CODE_CHADEMO_BMS_CHARGE_ALLOW_ERROR
    "023981",   // ERROR_CODE_CHADEMO_OUTPUT_VOLTAGE_MORE_THEN_10_PERCENT
    "023982",   // ERROR_CODE_CHADEMO_ADC_LESS_THAN_10V
    "023983",   // STOP by EV with unknow reason
    "023984",   // STOP by EVSE condition (Config or OCPP)
    "023985",   // Reserved
    "023986",   // Reserved
    "023987",   // Reserved
	"033900",	//disconnected from backend through Ethernet
	"033901",	//disconnected from backend through WiFi
	"033902",	//disconnected from backend through 3G/4G
	"033903",	//Remote start charging by backend
	"033904",	//Remote stop charging by backend
	"033905",	//Remote reset by backend
	"033906",	//Authorization failed
	"033907",	//Reserved
};
struct InfoCodeData
{
	unsigned char PreviousInfoVal[InfoCodeLength];
	union
	{
		unsigned char InfoVal[InfoCodeLength];
		struct
		{
			//InfoVal[0]
		    unsigned char NormalStopChargingByUser:1;				//bit 0
			unsigned char ChargingTimesUp:1;						//bit 1
			unsigned char ReplaceSystemAirFilter:1; 				//bit 2
			unsigned char ReachChademoMaxPluggingTimes:1;			//bit 3
			unsigned char ReachCcsMaxPluggingTimes:1;				//bit 4
			unsigned char ReachGbMaxPluggingTimes:1;				//bit 5
			unsigned char ReachAcMaxPluggingTimes:1;				//bit 6
			unsigned char CsuFimrwareUpdateFail:1;					//bit 7
			//InfoVal[1]
			unsigned char ChademoModuleFimrwareUpdateFail:1;		//bit 0
			unsigned char CcsModuleFimrwareUpdateFail:1;			//bit 1
			unsigned char GbModuleFimrwareUpdateFail:1;				//bit 2
			unsigned char AuxPowerModuleFimrwareUpdateFail:1;		//bit 3
			unsigned char RelayBoardFimrwareUpdateFail:1;			//bit 4
			unsigned char LcmModuleFimrwareUpdateFail:1;			//bit 5
			unsigned char BluetoothModuleFimrwareUpdateFail:1;		//bit 6
			unsigned char WiFiModuleFimrwareUpdateFail:1;			//bit 7
			//InfoVal[2]
			unsigned char Telocom4GModuleFimrwareUpdateFail:1;		//bit 0
			unsigned char PsuFimrwareUpdateFail:1;					//bit 1
			unsigned char RfidModuleFimrwareUpdateFail:1;			//bit 2
			unsigned char ConfiguredByUsbFlashDrive:1;				//bit 3
			unsigned char ConfiguredByBackend:1;					//bit 4
			unsigned char ConfiguredByWebpage:1;					//bit 5
			unsigned char InternetDisconnectViaEthernet:1;			//bit 6
			unsigned char InternetDisconnectViaWiFi :1;				//bit 7
	        //InfoVal[3]
			unsigned char InternetDisconnectVia4Gi:1;				//bit 0
			unsigned char ApDisconnectViaWiFi:1;					//bit 1
			unsigned char ApnDisconnectVia4Gi:1;					//bit 2
			unsigned char WiFiDisable:1;                            //bit 3
			unsigned char Telocom4GModuleDisable:1;                 //bit 4
			unsigned char :3;										//bit 5~7 reserved
			 //InfoVal[4]
			unsigned char ChademoEvCommFail:1;						//bit 0
			unsigned char CcsEvCommFail:1;							//bit 1
			unsigned char GbEvCommFail:1;							//bit 2
			unsigned char PilotFault:1;								//bit 3
			unsigned char ChademoBatteryMalfun:1;					//bit 4
			unsigned char ChademoNoPermission:1;					//bit 5
			unsigned char ChademoBatteryIncompatibility:1;			//bit 6
			unsigned char ChademoBatteryOVP:1;						//bit 7
			//InfoVal[5]
			unsigned char ChademoBatteryUVP:1;						//bit 0
			unsigned char ChademoBatteryOTP:1;						//bit 1
			unsigned char ChademoBatteryCurrentDiff:1;				//bit 2
			unsigned char ChademoBatteryVoltageDiff:1;				//bit 3
			unsigned char ChademoShiftPosition:1;					//bit 4
			unsigned char ChademoBatteryOtherFault:1;				//bit 5
			unsigned char ChademoChargingSystemError:1;				//bit 6
			unsigned char ChademoEvNormalStop:1;					//bit 7
			//InfoVal[6]
			unsigned char ChademoTempSensorBroken:1;				//bit 0
			unsigned char ChademoConnectorLockFail:1;				//bit 1
			unsigned char ChademoD1OnNoReceive:1;					//bit 2
			unsigned char ChademoBmsKtoJTimeout:1;					//bit 3
			unsigned char ChademoBmsChargeAllowTimeout:1;			//bit 4
			unsigned char ChademoWaitGfdTimeout:1;					//bit 5
			unsigned char ChademoBmsEvRelayTimeout:1;				//bit 6
			unsigned char ChademoBmsReqCurrentTimeout:1;			//bit 7
			//InfoVal[7]
			unsigned char ChademoBmsKtoJOffTimeout :1;				//bit 0
			unsigned char ChademoBmsEvRelayOffTimeout :1;			//bit 1
			unsigned char ChademoAdcMoreThan10V :1;					//bit 2
			unsigned char ChademoAdcMoreThan20V :1;					//bit 3
			unsigned char ChademoBmsChargeBeforeStop :1;			//bit 4
			unsigned char ChademoChargerGetNormalStop :1;			//bit 5
			unsigned char ChademoChargerGetEmergencyStop :1;		//bit 6
			unsigned char ChademoIsolationResultFail :1;			//bit 7
			//InfoVal[8]
			unsigned char ChademoMissLinkWithMotherBoard :1;		//bit 0
			unsigned char ChademoOutputVolMoreThanLimit :1;			//bit 1
			unsigned char ChademoReqCurrentMoreThanLimit :1;				//bit 2
			unsigned char ChademoReCapBmsEqrCurrentExceed :1;				//bit 3
			unsigned char ChademoChargeRemainCountDown :1;		//bit 4
			unsigned char CcsRESTemperatureInhibit:1;				//bit 5
			unsigned char CcsEVShiftPosition:1;				//bit 6
			unsigned char CcsChargerConnectorLockFault:1;				//bit 7
			//InfoVal[9]
			unsigned char CcsEVRESSMalfunction:1;					//bit 0
			unsigned char CcsChargingCurrentdifferential:1;		//bit 1
			unsigned char CcsChargingVoltageOutOfRange:1;		//bit 2
			unsigned char CcsChargingSystemIncompatibility:1;		//bit 3
			unsigned char CcsEmergencyEvent:1;				//bit 4
			unsigned char CcsBreaker:1;					//bit 5
			unsigned char CcsNoData:1;							//bit 6
			unsigned char Ccsreserved_by_DIN_A:1;				//bit 7
			//InfoVal[10]
			unsigned char Ccsreserved_by_DIN_B:1;				//bit 0
			unsigned char Ccsreserved_by_DIN_C:1;					//bit 1
			unsigned char Ccsreserved_by_ISO_1:1;				//bit 2
			unsigned char Ccsreserved_by_ISO_2:1;					//bit 3
			unsigned char Ccsreserved_by_ISO_3:1;					//bit 4
			unsigned char Ccsreserved_by_OEM_1:1;				//bit 5
			unsigned char Ccsreserved_by_OEM_2:1;			//bit 6
			unsigned char Ccsreserved_by_OEM_3:1;				//bit 7
			//InfoVal[11]
			unsigned char Ccsreserved_by_OEM_4:1;			//bit 0
			unsigned char Ccsreserved_by_OEM_5:1;			//bit 1
			unsigned char CcsSequenceError:1;			//bit 2
			unsigned char CcsSignatureError:1;		//bit 3
			unsigned char CcsUnknownSession:1;					//bit 4
			unsigned char CcsServiceIDInvalid:1;					//bit 5
			unsigned char CcsPaymentSelectionInvalid:1;					//bit 6
			unsigned char CcsIdentificationSelectionInvalid:1;			//bit 7
			//InfoVal[12]
			unsigned char CcsServiceSelectionInvalid:1;			//bit 0
			unsigned char CcsCertificateExpired:1;			//bit 1
			unsigned char CcsCertificateNotYetValid:1;			//bit 2
			unsigned char CcsCertificateRevoked:1;			//bit 3
			unsigned char CcsNoCertificateAvailable:1;			//bit 4
			unsigned char CcsCertChainError:1;			//bit 5
			unsigned char CcsCertValidationError:1;			//bit 6
			unsigned char CcsCertVerificationError:1;			//bit 7
			//InfoVal[13]
			unsigned char CcsContractCanceled:1;				//bit 0
			unsigned char CcsChallengeInvalid:1;				//bit 1
			unsigned char CcsWrongEnergyTransferMode:1;				//bit 2
			unsigned char CcsWrongChargeParameter:1;				//bit 3
			unsigned char CcsChargingProfileInvalid:1;				//bit 4
			unsigned char CcsTariffSelectionInvalid:1;				//bit 5
			unsigned char CcsEVSEPresentVoltageToLow:1;				//bit 6
			unsigned char CcsPowerDeliveryNotApplied:1;			//bit 7
			//InfoVal[14]
			unsigned char CcsMeteringSignatureNotValid:1;			//bit 0
			unsigned char CcsNoChargeServiceSelected:1;			//bit 1
			unsigned char CcsContactorError:1;					//bit 2
			unsigned char CcsCertificateNotAllowedAtThisEVSE:1;			//bit 3
			unsigned char CcsGAChargeStop:1;				//bit 4
			unsigned char CcsAlignmentError:1;					//bit 5
			unsigned char CcsACDError:1;					//bit 6
			unsigned char CcsAssociationError:1;			//bit 7
			//InfoVal[15]
			unsigned char CcsEVSEChargeAbort:1;				//bit 0
			unsigned char CcsNoSupportedAppProtocol:1;					//bit 1
			unsigned char CcsContractNotAccepted:1;				//bit 2
			unsigned char CcsMOUnknown:1;					//bit 3
			unsigned char CcsOEM_Prov_CertificateRevoke:1;				//bit 4
			unsigned char CcsOEM_SubCA1_CertificateRevoked:1;		//bit 5
			unsigned char CcsOEM_SubCA2_CertificateRevoked:1;		//bit 6
			unsigned char CcsOEM_RootCA_CertificateRevoked:1;		//bit 7
			//InfoVal[16]
			unsigned char CcsMO_Prov_CertificateRevoked:1;			//bit 0
			unsigned char CcsMO_SubCA1_CertificateRevoked:1;		//bit 1
			unsigned char CcsMO_SubCA2_CertificateRevoked:1;		//bit 2
			unsigned char CcsMO_RootCA_CertificateRevoked:1;		//bit 3
			unsigned char CcsCPS_Prov_CertificateRevoked:1;		//bit 4
			unsigned char CcsCPS_SubCA1_CertificateRevoked:1;		//bit 5
			unsigned char CcsCPS_SubCA2_CertificateRevoked:1;		//bit 6
			unsigned char CcsCPS_RootCA_CertificateRevoked:1;		//bit 7
			//InfoVal[17]
			unsigned char :5;					//bit 0~4 reserved
			unsigned char CcsTT_EVSE_SLAC_init:1;				//bit 5
			unsigned char CcsTP_match_response:1;			//bit 6
			unsigned char CcsTT_match_sequence:1;			//bit 7
			//InfoVal[18]
			unsigned char CcsTT_EVSE_match_MNBC:1;				//bit 0
			unsigned char CcsTP_EVSE_avg_atten_calc:1;				//bit 1
			unsigned char CcsTT_match_response:1;			//bit 2
			unsigned char CcsTP_EVSE_match_session:1;			//bit 3
			unsigned char CcsTT_EVSE_assoc_session:1;			//bit 4
			unsigned char CcsTT_EVSE_vald_toggle:1;			//bit 5
			unsigned char CcsSeccSlacTimeoutCmMnbcSound:1;			//bit 6 reserved
			unsigned char CcsSeccSlacTimeoutCmValidateReq:1;			//bit 7 reserved
			//InfoVal[19]
			unsigned char :3;					//bit 0~2 reserved
			unsigned char CcsUDP_TT_match_join:1;			//bit 3
			unsigned char CcsTCP_TT_match_join:1;				//bit 4
			unsigned char CcsTP_amp_map_exchange:1;			//bit 5
			unsigned char CcsTP_link_ready_notification:1;			//bit 6
			unsigned char :1;				//bit 7 resetved
			//InfoVal[20]
			unsigned char :4;						//bit 0~3 reserved
			unsigned char CcsSupportedAppProtocolRes:1;			//bit 4
			unsigned char CcsSessionSetupRes:1;				//bit 5
			unsigned char CcsServiceDiscoveryRes:1;				//bit 6
			unsigned char CcsServicePaymentSelectionRes:1;		//bit 7
			//InfoVal[21]
			unsigned char CcsContractAuthenticationRes:1;			//bit 0
			unsigned char CcsChargeParameterDiscoveryRes:1;			//bit 1
			unsigned char CcsPowerDeliveryRes:1;			//bit 2
			unsigned char CcsCableCheckRes:1;			//bit 3
			unsigned char CcsPreChargeRes:1;					//bit 4
			unsigned char CcsCurrentDemandRes:1;					//bit 5
			unsigned char CcsWeldingDetectionRes:1;				//bit 6
			unsigned char CcsSessionStopRes:1;					//bit 7
			//InfoVal[22]
			unsigned char CcsSequence_Time:1;						//bit 0
			unsigned char CcsReadyToCharge_Performance_Time:1;				//bit 1
			unsigned char CcsCommunicationSetup_Performance_Time:1;					//bit 2
			unsigned char CcsCableCheck_Performance_Time:1;				//bit 3
			unsigned char CcsCPState_Detection_Time:1;			//bit 4
			unsigned char CcsCPOscillator_Retain_Time:1;					//bit 5
			unsigned char CcsSeccTimeoutV2GPreChargePerformaceTime:1;			//bit 6
			unsigned char :1;			//bit 7 reserved
			//InfoVal[23]
			unsigned char :3;					//bit 0~2 reserved
			unsigned char CcsTP_GET_EV_TARGET_INFO:1;			//bit 3
			unsigned char CcsTT_GET_EV_TARGET_INFO:1;		//bit 4
			unsigned char CcsTP_GET_EV_BATTERY_INFO:1;		//bit 5
			unsigned char CcsTT_GET_EV_BATTERY_INFO:1;		//bit 6
			unsigned char CcsTP_EV_STOP_EVENT:1;				//bit 7
			//InfoVal[24]
			unsigned char CcsTT_EV_STOP_EVENT:1;			//bit 0
			unsigned char CcsTP_EVSE_STOP_EVENT:1;			//bit 1
			unsigned char CcsTT_EVSE_STOP_EVENT:1;			//bit 2
			unsigned char CcsTP_GET_MISC_INFO:1;			//bit 3
			unsigned char CcsTT_GET_MISC_INFO:1;			//bit 4
			unsigned char CcsTP_DOWNLOAD_REQUEST:1;			//bit 5
			unsigned char CcsTT_DOWNLOAD_REQUEST:1;			//bit 6
			unsigned char CcsTP_START_BLOCK_TRANSFER:1;			//bit 7
			//InfoVal[25]
			unsigned char CcsTT_START_BLOCK_TRANSFER:1;		//bit 0
			unsigned char CcsTP_DATA_TRANSFER:1;			//bit 1
			unsigned char CcsTT_DATA_TRANSFER:1;			//bit 2
			unsigned char CcsTP_DOWNLOAD_FINISH:1;			//bit 3
			unsigned char CcsTT_DOWNLOAD_FINISH:1;			//bit 4
			unsigned char CcsTP_ISOLATION_STATUS:1;			//bit 5
			unsigned char CcsTT_ISOLATION_STATUS:1;			//bit 6
			unsigned char CcsTP_CONNECTOR_INFO:1;			//bit 7
			//InfoVal[26]
			unsigned char CcsTT_CONNECTOR_INFO:1;			//bit 0
			unsigned char CcsTT_RTC_INFO:1;				//bit 1
			unsigned char CcsTP_RTC_INFO:1;			//bit 2
			unsigned char CcsTP_EVSE_PRECHARGE_INFO:1;		//bit 3
			unsigned char CcsTT_EVSE_PRECHARGE_INFO:1;			//bit 4
			unsigned char CcsMSG_Sequence:1;			//bit 5
			unsigned char CcsCAN_MSG_Unrecognized_CMD_ID:1;			//bit 6
			unsigned char CcsDIN_Msg_Decode_Error:1;			//bit 7
			//InfoVal[27]
			unsigned char CcsDIN_Msg_Encode_Error:1;			//bit 0
			unsigned char CcsISO1_Msg_Decode_Error:1;			//bit 1
			unsigned char CcsISO1_Msg_Encode_Error:1;			//bit 2
			unsigned char CcsISO2_Msg_Decode_Error:1;			//bit 3
			unsigned char CcsISO2_Msg_Encode_Error:1;			//bit 4
			unsigned char CcsCpStatus_Error:1;					//bit 5
			unsigned char CcsUnexpectVolBeforeCharing_Error:1;	//bit 6
			unsigned char CcsSeccNotReadyForCharging:1;			//bit 7 reserved
			//InfoVal[28]
			unsigned char CcsSeccTimeoutQCA7000Comm:1;			//bit 0
			unsigned char CcsSeccFailForQCA7000SetKey:1;		//bit 1
			unsigned char :6;									//bit 2~7 reserved
			//InfoVal[29]
			unsigned char ERROR_CODE_GBT_LOS_CC1 :1;									//bit 0
			unsigned char ERROR_CODE_GBT_CONNECTOR_LOCK_FAIL :1;						//bit 1
			unsigned char ERROR_CODE_GBT_BATTERY_INCOMPATIBLE :1;						//bit 2
			unsigned char ERROR_CODE_GBT_BMS_BROAA_TIMEOUT :1;							//bit 3
			unsigned char ERROR_CODE_GBT_CSU_PRECHARGE_TIMEOUT :1;						//bit 4
			unsigned char ERROR_CODE_GBT_BMS_PRESENT_VOLTAGE_FAULT :1;					//bit 5
			unsigned char ERROR_CODE_GBT_BMS_VOLTAGE_OVER_RANGE :1;						//bit 6
			unsigned char ERROR_CODE_GBT_BSM_CHARGE_ALLOW_00_10MIN_COUUNTDONE :1;		//bit 7
			//InfoVal[30]
			unsigned char ERROR_CODE_GBT_WAIT_GROUNDFAULT_TIMEOUT :1;					//bit 0
			unsigned char ERROR_CODE_GBT_ADC_MORE_THAN_10V :1;							//bit 1
			unsigned char ERROR_CODE_GBT_ADC_MORE_THAN_60V :1;							//bit 2
			unsigned char ERROR_CODE_GBT_CHARGER_GET_NORMAL_STOP_CMD :1;				//bit 3
			unsigned char ERROR_CODE_GBT_CHARGER_GET_EMERGENCY_STOP_CMD :1;				//bit 4
			unsigned char ERROR_CODE_GBT_ISOLATION_RESULT_FAIL :1;						//bit 5
			unsigned char ERROR_CODE_GBT_MOTHER_BOARD_MISS_LINK :1;						//bit 6
			unsigned char ERROR_CODE_GBT_OUTPUT_VOLTAGE_MORE_THAN_LIMIT :1;				//bit 7
			//InfoVal[31]
			unsigned char ERROR_CODE_GBT_REQ_CURRENT_MORE_THAN_LIMIT :1;				//bit 0
			unsigned char ERROR_CODE_GBT_OUTPUT_VOLTAGE_MORE_THAN_10_PERCENT :1;		//bit 1
			unsigned char ERROR_CODE_GBT_OUTPUT_VOLTAGE_DIFF_BCS_5_PERCENT :1;			//bit 2
			unsigned char ERROR_CODE_GBT_STOP_ADC_MORE_THAN_10V :1;						//bit 3
			unsigned char :4;															//bit 4 ~ 7 reserved
			//InfoVal[32]
			unsigned char :6;															//bit 0 ~ 5 reserved
			unsigned char ERROR_CODE_CEM_BHM_TIMEOUT :1;								//bit 6
			unsigned char ERROR_CODE_CEM_BRM_TIMEOUT :1;								//bit 7
			//InfoVal[33]
			unsigned char ERROR_CODE_CEM_BCP_TIMEOUT :1;								//bit 0
			unsigned char ERROR_CODE_CEM_BRO_TIMEOUT :1;								//bit 1
			unsigned char ERROR_CODE_CEM_BCL_TIMEOUT :1;								//bit 2
			unsigned char ERROR_CODE_CEM_BCS_TIMEOUT :1;								//bit 3
			unsigned char ERROR_CODE_CEM_BSM_TIMEOUT :1;								//bit 4
			unsigned char ERROR_CODE_CEM_BST_TIMEOUT :1;								//bit 5
			unsigned char ERROR_CODE_CEM_BSD_TIMEOUT :1;								//bit 6
			unsigned char ERROR_CODE_CEM_BEM_OTHER_TIMEOUT :1;							//bit 7
			//InfoVal[34]
			unsigned char ERROR_CODE_BEM_CRM_TIMEOUT :1;			//bit 0
			unsigned char ERROR_CODE_BEM_CRMAA_TIMEOUT :1;			//bit 1
			unsigned char ERROR_CODE_BEM_CTS_CML_TIMEOUT :1;		//bit 2
			unsigned char ERROR_CODE_BEM_CRO_TIMEOUT :1;			//bit 3
			unsigned char ERROR_CODE_BEM_CCS_TIMEOUT :1;			//bit 4
			unsigned char ERROR_CODE_BEM_CST_TIMEOUT :1;			//bit 5
			unsigned char ERROR_CODE_BEM_CSD_TIMEOUT :1;			//bit 6
			unsigned char ERROR_CODE_BEM_BEM_OTHER_TIMEOUT :1;		//bit 7
			//InfoVal[35]
			unsigned char :2;										//bit 0 ~ 1
			unsigned char ERROR_CODE_BST_SOC_GOAL :1;				//bit 2
			unsigned char ERROR_CODE_BST_TOTAL_VOLTAGE_GOAL :1;		//bit 3
			unsigned char ERROR_CODE_BST_CELL_VOLTAGE_GOAL :1;		//bit 4
			unsigned char ERROR_CODE_BST_GET_CST :1;				//bit 5
			unsigned char ERROR_CODE_BST_ISOLATION :1;				//bit 6
			unsigned char ERROR_CODE_BST_OUTPUT_CONNECTOR_OTP :1;	//bit 7
			//InfoVal[36]
			unsigned char ERROR_CODE_BST_COMPONENT :1;				//bit 0
			unsigned char ERROR_CODE_BST_CHARGE_CONNECTOR :1;		//bit 1
			unsigned char ERROR_CODE_BST_OTP :1;					//bit 2
			unsigned char ERROR_CODE_BST_OTHER :1;					//bit 3
			unsigned char ERROR_CODE_BST_HIGH_V :1;					//bit 4
			unsigned char ERROR_CODE_BST_CC2 :1;					//bit 5
			unsigned char ERROR_CODE_BST_CURRENT :1;				//bit 6
			unsigned char ERROR_CODE_BST_VOLTAGE :1;				//bit 7
			//InfoVal[37]
			unsigned char ERROR_CODE_GET_BST_NO_REASON :1;			//bit 0
			unsigned char :5;										//bit 1 ~ 5 reserved
			unsigned char ERROR_CODE_BSM_CELL_OVER_VOLTAGE :1;		//bit 6
			unsigned char ERROR_CODE_BSM_CELL_UNDER_VOLTAGE :1;		//bit 7
			//InfoVal[38]
			unsigned char ERROR_CODE_BSM_OVER_SOC :1;				//bit 0
			unsigned char ERROR_CODE_BSM_UNDER_SOC :1;				//bit 1
			unsigned char ERROR_CODE_BSM_CURRENT :1;				//bit 2
			unsigned char ERROR_CODE_BSM_TEMPERATURE :1;			//bit 3
			unsigned char ERROR_CODE_BSM_ISOLATE :1;				//bit 4
			unsigned char ERROR_CODE_BSM_OUTPUT_CONNECTOR :1;		//bit 5
			unsigned char :1;										//bit 6
			unsigned char EV_Full_Charging:1;                       //bit 7
            //InfoVal[39]
            unsigned char CHADEMO_BMS_CHARGE_ALLOW_ERROR:1;         //bit 0
            unsigned char CHADEMO_OUTPUT_VOLTAGE_MORE_THEN_10_PERCENT:1; //bit 1
            unsigned char CHADEMO_ADC_LESS_THAN_10V:1;              //bit 2
            unsigned char Stop_by_EV_with_unknow_reason:1;          //bit 3
            unsigned char Stop_by_EVSE_condition:1;                 //bit 4
            unsigned char :3;                                       //bit 5 ~ 7 reserved
			//InfoVal[40]
			unsigned char BackendDisconnectedViaEthernet:1;			//bit 0
			unsigned char BackendDisconnectViaWiFi:1;				//bit 1
			unsigned char BackendDisconnectVia4G:1;					//bit 2
			unsigned char BackendRemoteStart:1;						//bit 3
			unsigned char BackendRemoteStop:1;						//bit 4
			unsigned char BackendRemoteReset:1;						//bit 5
			unsigned char AuthorizationFailed:1;					//bit 6
			unsigned char :1;										//bit 7	reserved
		}bits;
	}InfoEvents;
};

struct StatusCodeData
{
	struct FaultCodeData	FaultCode;
	struct AlarmCodeData	AlarmCode;
	struct InfoCodeData		InfoCode;
};
/**************************************************************************************/
/**************************PSU Share memory***************************************/
/**************************************************************************************/
typedef union
{
    unsigned int PsuGroupErrorValue;
    struct
    {
        unsigned int PsuFailure:1;              // 0: no effect,    1: Psu Failure
        unsigned int res:31;
    }bits;
}PsuGroupError;

struct PsuModuleVer
{
	unsigned char 		FwPrimaryVersion[16];
	unsigned char 		FwSecondVersion[16];
};

/*Following are the information for each PSU module*/
struct PsuModuleData
{
	unsigned char 		AssignID;
	unsigned char 		PhysicalID;
	unsigned char 		GroupID;
	unsigned char 		Address;
	unsigned char 		FireWireIndex;
	unsigned char 		FwVersion[16];
	unsigned char 		SerialNumber[32];
	unsigned char 		StateMachine;			//0: Identification,  1:Operation,  2: Alarm,  3: Failure,  s4:Upgrade
	unsigned char 		OutputPowerSwitch;	//0: D.D normal OFF,  1: D.D emergency OFF,  2: D.D ON
	unsigned short 	FanSpeed_1;			//RPM
	unsigned short 	FanSpeed_2;			//RPM
	unsigned short 	FanSpeed_3;			//RPM
	unsigned short 	FanSpeed_4;			//RPM
	unsigned short 	InputVoltage_Type;	//0x00 = Line to Line Vol, 0x01 = Line to Neutral Vol
	unsigned short 	InputVoltageL1;		//abcd=abc.d volt
	unsigned short 	InputVoltageL2;		//abcd=abc.d volt
	unsigned short 	InputVoltageL3;		//abcd=abc.d volt
	unsigned short 	InputCurrentL1;		//abcd=abc.d amp
	unsigned short 	InputCurrentL2;		//abcd=abc.d amp
	unsigned short 	InputCurrentL3;		//abcd=abc.d amp
	unsigned short 	PresentOutputVoltage;	//abcd=abc.d volt
	unsigned short 	PresentOutputCurrent;	//abcd=abc.d amp
	unsigned short 	AvailableCurrent;		// unit: 0.1A
	unsigned int 		AvailablePower;		// unit: 0.1kW
	char 				CriticalTemp1;			//0x00: -60¢XC  ~  0xFE: 194¢XC, resolution: 1¢XC, offset: -60¢XC, 0xFF: invalid
	char 				CriticalTemp2;			//0x00: -60¢XC  ~  0xFE: 194¢XC, resolution: 1¢XC, offset: -60¢XC, 0xFF: invalid
	char 				CriticalTemp3;			//0x00: -60¢XC  ~  0xFE: 194¢XC, resolution: 1¢XC, offset: -60¢XC, 0xFF: invalid
	char 				ExletTemp;			//0x00: -60¢XC  ~  0xFE: 194¢XC, resolution: 1¢XC, offset: -60¢XC, 0xFF: invalid
	char 				InletTemp_1;			//0x00: -60¢XC  ~  0xFE: 194¢XC, resolution: 1¢XC, offset: -60¢XC, 0xFF: invalid
	char 				InletTemp_2;			//0x00: -60¢XC  ~  0xFE: 194¢XC, resolution: 1¢XC, offset: -60¢XC, 0xFF: invalid
	char 				InletTemp;			//0x00: -60¢XC  ~  0xFE: 194¢XC, resolution: 1¢XC, offset: -60¢XC, 0xFF: invalid
	char 				OutletTemp;			//0x00: -60¢XC  ~  0xFE: 194¢XC, resolution: 1¢XC, offset: -60¢XC, 0xFF: invalid
	unsigned int 		AlarmCode;
	unsigned int 		FaultCode;			//
	unsigned int 		IAvailableCurrent;		            // unit: 0.1A
    unsigned short  PresentMaxOutputVoltage;//abcd=abc.d volt
    unsigned short  KwAvailablePower;       // unit: 0.1 kw
};

/*Following are the information for each PSU Group*/
struct PsuGroupData
{
	unsigned char           GroupPresentPsuQuantity;
	unsigned char           GroupOutputPowerSwitch;         //0: D.D normal OFF,  1: D.D emergency OFF,  2: D.D ON
	unsigned short          GroupTargetOutputVoltage;       //abcd=abc.d volt
	unsigned short          GroupTargetOutputCurrent;       //abcd=abc.d amp
	unsigned short          GroupAvailableCurrent;          // unit: 0.1A
	unsigned int            GroupAvailablePower;            // unit: 0.1kW
	unsigned int            GroupRealOutputPower;           // unit: 1kW
	unsigned short          GroupPresentOutputVoltage; 	    // unit: 0.1V
	unsigned short          GroupPresentOutputCurrent;      // unit: 0.1A
	unsigned int            GroupPresentOutputPower;        // unit: 0.1kW
	struct PsuModuleData 	PsuModule[MAX_PSU_QUANTITY];
	PsuGroupError           GroupErrorFlag;
    unsigned short          TotalIAvailableCurrent;         // unit: 0.1A
    unsigned short          TempIAvailableCurrent;          // unit: 0.1A
    unsigned short          StableIAvailableCurrent;        // unit: 0.1A
    unsigned short          StableCurrentCounter;           // stable current counter
    unsigned short          GroupMaxVoltage;                // unit: 0.1V
    unsigned char           IsUsing;                        // 0 : none use
    unsigned char           UsingTarget;                    // 0xFF : Check
    unsigned char           PwSwitchStatus;
    unsigned short          TotalRatingPower;               // unit: 1kW
};

/*Following is the information for system all PSU*/
struct PsuData
{
	unsigned char           SystemPresentPsuQuantity;
	unsigned short          SystemAvailableCurrent;			//abcd=abc.d amp
	unsigned int            SystemAvailablePower;			//Watt
	struct PsuGroupData     PsuGroup[4];
	unsigned char           GroupCount;
	unsigned char           Work_Step;
	struct PsuModuleVer     PsuVersion[MAX_PSU_QUANTITY];
	unsigned char           PsuStopChargeFlag;
};

struct SmartTimeChk
{
    struct timespec     FetchLoopTime;
    unsigned char       IsFetchStart;

    struct timespec     ReleaseLoopTime;
    unsigned char       IsReleaseStart;
};

struct DynamicFetchCtrl
{
    unsigned char       ShareGroup;         // 255 : None
    unsigned char       FetchLoopStep;      // 0 : None, 1 : Output Vol, 2 : RCB ON, 3 : Current sharing, 4 : Finish
    unsigned short      ShareTargetCurrent; // 0.1A
    unsigned char       TargetRelay;        // 255 : None
};

struct DynamicReleaseCtrl
{
    unsigned char       ReleaseGroup;       // 255 : None
    unsigned char       ReleaseLoopStep;    // 0 : None, 1 : Limit Pwr, 2 : Pwr OFF, 3. RCB OFF, 4. Finish
    float               CheckOutPwrIsStable;// 0.1kw
    unsigned char       TargetRelay;        // 255 : None

    float               LimitCurCap;        // Inform 0.1A
    float               LimitPwrCap;        // Inform 0.1kw
    float               LimitCur;           // Target 0.1A
    float               LimitPwr;           // Target 0.1kw
};

struct ConnInfo
{
    unsigned char ConnectorStaus;
    unsigned char NeedToFetch;
};

struct SmartBoxData
{
    struct ConnInfo     ConnectorStatus[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];     // Connector 1 / 2 Status : None, Wait, Using
    struct ConnInfo     AnotherConnectorStatus[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];
    unsigned char       ConnectorUsingGroupCount[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY]; // Psu group for connector
    struct SmartTimeChk SmartChk[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];
    struct DynamicFetchCtrl Dynamic4Fetch[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];
    struct DynamicReleaseCtrl Dynamic4Release[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY];
    unsigned char       ParallelRelayStatus[3];
    unsigned char       RcbParallelStatus[3];
};

/************************************************************************************/
/**************************CHAdeMO protocol Share memory*********************/
/**************************************************************************************/
struct CHAdeMOEvData
{
	unsigned char  SupportDynamicControl;	//110.0
										//					bit0=1:supported
	unsigned char  SupportHighCurrent;		//110.0
										//					bit1=1:supported
	unsigned char  MiniChargeCurrent;		//100.0				0~200(A) (unit:1A)
										//					0x00: request for current equivalent to 1.5kW
										//					0x01: no request
										//					0x02: request of 1A and following are the same rule
	unsigned short MaxiBatteryVoltage;		//100.5,100.4 			0~600(V) (unit:1V)
	unsigned short MaxiChargingTime;			//101.2,101.1			10(sec.)~255(min.)	(Unit:sec)
										//					Set 0xFF to 101.1 (Unit: 10sec) in case 101.2 (Unit: 1min) is used
	unsigned char  EstimatChargingTime;		//101.3				0~254(min.)	(Unit:sec)
										//					Display Only
	unsigned short TotalBatteryCapacity;		//101.6,101.5 			0.1~6553.5(kWh)	(unit:0.1 kWh)
	unsigned char  ProtocolVersion;			//102.0				0~255
										//					0x02: CHAdeMO specification ver.1.2
	unsigned short TargetBatteryVoltage;		//102.2,102.1 			0~600(V) (unit:1V)
	unsigned short ChargingCurrentRequest;	//102.3				0~200(A) (unit:1A)
										//110.2,110.1 			0~1023(A) (unit:1A)
	unsigned char  BatteryAlarm;				//102.4				>0:alarm
										//					bit0=1:Battery overvoltage
										//					bit1=1:Battery undervoltage
										//					bit2=1:Battery current deviation error
										//					bit3=1:High battery temperature
										//					bit4=1:Battery voltage deviation error
	unsigned char  EvDetection;				//102.5
										//					bit0=0:Vehicle charging disabled,	(stop charging)
										//					bit0=1:Vehicle charging enabled,
										//					bit1=0:¡§Parking¡¨ position
										//					bit1=1:other position				(stop charging)
										//					bit2=0:Charging system normal
										//					bit2=1:Charging system error		(stop charging)
										//					bit3=0:EV contactor close or during welding detection
										//					bit3=1:EV contactor open or termination of welding detection (stop charging)
										//					bit4=0:No stop request before charging
										//					bit4=1:Normal stop request before charging	(stop charging)
	unsigned char  SOC;					//102.6				0~100(%) (unit:%)
										//					Display Only
	unsigned char  Communicating;			//					it is true if receive EV CAN message within every 1500ms
	unsigned char  PresentMsgFlowStatus;	//
};

struct CHAdeMOEvseData
{
	unsigned char 	SelfTest_Comp;
	unsigned char	version[16];									//Chademo firmware version
	unsigned char  SupportDynamicControl;	//118.0
										//					bit0=1:supported
	unsigned char  SupportHighCurrent;		//118.0
										//					bit1=1:supported
	unsigned short  AvailableOutputVoltage;	//108.2,108.1 			0~600(V) (unit:1V)
	unsigned short  AvailableOutputCurrent;	//108.3				0~255(A) (unit:1A)
										//118.2,118.1 			0~1023(A) (unit:1A)
	unsigned short  ThresholdVoltage;			//108.5,108.4 			0~600(V) (unit:1V)
	unsigned char   ConnectorTemperatureP;	//108.6				-40~215(degC) (unit:degC) //value 0=-40	[NISSAN customized]
	unsigned char   ConnectorTemperatureN;	//108.7				-40~215(degC) (unit:degC) //value 0=-40	[NISSAN customized]
	unsigned char   ProtocolVersion;			//109.0				0~255
										//					0x00: CHAdeMO specification 0.9 and earlier
										//					0x01: CHAdeMO specification 0.9 and 0.9.1
										//					0x02: CHAdeMO specification 1.0.0, 1.0.1, 1.1 and 1.2
	unsigned short  PresentOutputVoltage;		//109.2,109.1	 		0~600(V) (unit:1V)
	unsigned short   PresentOutputCurrent;		//109.3				0~255(A) (unit:1A)
										//118.4,118.3			0~1023(A) (unit:1A)
	unsigned char   EvseDetection;			//109.5
										//					bit0=0:not charging state now
										//					bit0=1:charging state now
										//					bit1=0:EVSE normal
										//					bit1=1:EVSE error
										//					bit2=0:Not Energizing state
										//					bit2=1:Energizing state
										//					bit3=0:No Battery incompatibility
										//					bit3=1:Battery incompatibility
										//					bit4=0:No Charging system error
										//					bit4=1:Charging system error
										//					bit5=0:No Charging stop control
										//					bit5=1:Charging stop control
	unsigned short RemainChargingTime;		//109.7,109.6			10(sec.)~255(min.)	(Unit:sec)
										//					Set 0xFF to 109.6 (Unit: 10sec) in case 109.7 (Unit: 1min) is used
	unsigned char  HighPowerCondition;		//118.5
										//					bit0=0:Present charging current H¡¦118.3,H¡¦118.4¡¨ is less than or equal to rated current of a charging cable
										//					bit0=1:Present charging current H¡¦118.3,H¡¦118.4¡¨ is exceeds to rated current of a charging cable
										//					bit1=1:charging cable Cooling function Operating Installed
										//					bit2=1:charging cable Current limiting function
										//					bit3=1:charging connector Cooling function Operating
										//					bit4=1:charging connector Current limiting function Installed
										//					bit5=1:charging connector Over-temperature protection Installed
										//					bit6=1:Functional safety Applied
	unsigned int 	MaxiGroupPower;			//					XXXXXXXX (Unit:Watt)depend on which group to be used
	unsigned int 	MaxiGroupCurrent;			//					XXXXXXXX (unit:1A)depend on which group to be used
	unsigned short  ApplyOutputVoltage;		// 					0~600(V) (unit:1V)
	unsigned short  ElapseChargingTime;		//					(Unit:sec)
	unsigned short  ElapseEnergy;				//					(Unit:10xkWh)
	unsigned char	EvboardStatus;			// 	0 : init
};

struct CHAdeMOData
{
	struct CHAdeMOEvData 		ev[CHAdeMO_QUANTITY];
	struct CHAdeMOEvseData 	evse[CHAdeMO_QUANTITY];
};

/************************************************************************************/
/**************************GBT protocol Share memory*********************/
/**************************************************************************************/
struct GBTEvData
{
	unsigned short MaxiBatteryVoltage;		// 0~600(V) (unit:1V)
	unsigned short MaxiChargingTime;		// 10(sec.)~255(min.)	(Unit:sec)

	unsigned char  EstimatChargingTime;		// 0~254(min.)	(Unit:sec)

	unsigned short TotalBatteryCapacity;	// 0.1~6553.5(kWh)	(unit:0.1 kWh)
	unsigned char  ProtocolVersion;			// 0~255

	unsigned short TargetBatteryVoltage;	// 0~600(V) (unit:1V)
	unsigned short ChargingCurrentRequest;	// 0~200(A) (unit:1A)
											// 0~1023(A) (unit:1A)

	unsigned char  EvDetection;				//102.5
										//					bit0=0:Vehicle charging disabled,	(stop charging)
										//					bit0=1:Vehicle charging enabled,
										//					bit1=0:¡§Parking¡¨ position
										//					bit1=1:other position				(stop charging)
										//					bit2=0:Charging system normal
										//					bit2=1:Charging system error		(stop charging)
										//					bit3=0:EV contactor close or during welding detection
										//					bit3=1:EV contactor open or termination of welding detection (stop charging)
										//					bit4=0:No stop request before charging
										//					bit4=1:Normal stop request before charging	(stop charging)
	unsigned char  SOC;					//102.6				0~100(%) (unit:%)
										//					Display Only
	unsigned char  PresentMsgFlowStatus;	//
};

struct GBTEvseData
{
	unsigned char 	SelfTest_Comp;
	unsigned char	version[16];				// GBT firmware version

	unsigned short  AvailableOutputVoltage;		// 0~600(V) (unit:1V)
	unsigned short  AvailableOutputCurrent;		// 0~255(A) (unit:1A)

	unsigned char   ConnectorTemperatureP;	// -40~215(degC) (unit:degC) //value 0=-40	[NISSAN customized]
	unsigned char   ConnectorTemperatureN;	// -40~215(degC) (unit:degC) //value 0=-40	[NISSAN customized]

	unsigned short  PresentOutputVoltage;		// 0~600(V) (unit:1V)
	unsigned short  PresentOutputCurrent;		// 0~255(A) (unit:1A)

	unsigned short RemainChargingTime;		//109.7,109.6			10(sec.)~255(min.)	(Unit:sec)
	unsigned char	EvboardStatus;			// 	0 : init
};

struct GBTData
{
	struct GBTEvData 		ev[GB_QUANTITY];
	struct GBTEvseData 		evse[GB_QUANTITY];
};

/************************************************************************************/
/**************************CCS protocol Share memory***************************/
/**************************DIN70121: 201412***************************************/
/**************************ISO15118_2014: 2014************************************/
/**************************ISO15118_2018: 2018************************************/
/************************************************************************************/
typedef enum boolean { FALSE, TRUE } BOOL;
enum ResponseCodeType_DIN70121		{ OK_DIN70121 = 0, OK_NewSessionEstablished_DIN70121 = 1, OK_OldSessionJoined_DIN70121 = 2, OK_CertificateExpiresSoon_DIN70121 = 3,
									   FAILED_DIN70121 = 4, FAILED_SequenceError_DIN70121 = 5, FAILED_ServiceIDInvalid_DIN70121 = 6, FAILED_UnknownSession_DIN70121 = 7,
									   FAILED_ServiceSelectionInvalid_DIN70121 = 8, FAILED_PaymentSelectionInvalid_DIN70121 = 9, FAILED_CertificateExpired_DIN70121 = 10,
									   FAILED_SignatureError_DIN70121 = 11, FAILED_NoCertificateAvailable_DIN70121 = 12, FAILED_CertChainError_DIN70121 = 13, FAILED_ChallengeInvalid_DIN70121 = 14,
									   FAILED_ContractCanceled_DIN70121 = 15, FAILED_WrongChargeParameter_DIN70121 = 16, FAILED_PowerDeliveryNotApplied_DIN70121 = 17,
									   FAILED_TariffSelectionInvalid_DIN70121 = 18, FAILED_ChargingProfileInvalid_DIN70121 = 19, FAILED_EVSEPresentVoltageToLow_DIN70121 = 20,
									   FAILED_MeteringSignatureNotValid_DIN70121 = 21, FAILED_WrongEnergyTransferType_DIN70121 = 22};
enum ResponseCodeType_ISO15118_2014	{ OK_ISO15118_2014 = 0, OK_NewSessionEstablished_ISO15118_2014 = 1, OK_OldSessionJoined_ISO15118_2014 = 2, OK_CertificateExpiresSoon_ISO15118_2014 = 3,
									   FAILED_ISO15118_2014 = 4, FAILED_SequenceError_ISO15118_2014 = 5, FAILED_ServiceIDInvalid_ISO15118_2014 = 6, FAILED_UnknownSession_ISO15118_2014 = 7,
									   FAILED_ServiceSelectionInvalid_ISO15118_2014 = 8, FAILED_PaymentSelectionInvalid_ISO15118_2014 = 9, FAILED_CertificateExpired_ISO15118_2014 = 10,
									   FAILED_SignatureError_ISO15118_2014 = 11, FAILED_NoCertificateAvailable_ISO15118_2014 = 12, FAILED_CertChainError_ISO15118_2014 = 13, FAILED_ChallengeInvalid_ISO15118_2014 = 14,
									   FAILED_ContractCanceled_ISO15118_2014 = 15, FAILED_WrongChargeParameter_ISO15118_2014 = 16, FAILED_PowerDeliveryNotApplied_ISO15118_2014 = 17,
									   FAILED_TariffSelectionInvalid_ISO15118_2014 = 18, FAILED_ChargingProfileInvalid_ISO15118_2014 = 19, FAILED_MeteringSignatureNotValid_ISO15118_2014 = 20,
									   FAILED_NoChargeServiceSelected_ISO15118_2014 = 21, FAILED_WrongEnergyTransferMode_ISO15118_2014 = 22, FAILED_ContactorError_ISO15118_2014 = 23,
									   FAILED_CertificateNotAllowedAtThisEVSE_ISO15118_2014 = 24, FAILED_CertificateRevoked_ISO15118_2014 = 25  };
enum ResponseCodeType_ISO15118_2018	{ OK_ISO15118_2018 = 0, OK_NewSessionEstablished_ISO15118_2018 = 1, OK_OldSessionJoined_ISO15118_2018 = 2, OK_CertificateExpiresSoon_ISO15118_2018 = 3,
									   OK_IsolationValid_ISO15118_2018 = 4, OK_IsolationWarning_ISO15118_2018 = 5, WARNING_CertificateExpired_ISO15118_2018 = 6, WARNING_NoCertificateAvailable_ISO15118_2018 = 7,
									   WARNING_CertValidationError_ISO15118_2018 = 8, WARNING_CertVerificationError_ISO15118_2018 = 9, WARNING_ContractCanceled_ISO15118_2018 = 10,
									   FAILED_ISO15118_2018 = 11, FAILED_SequenceError_ISO15118_2018 = 12, FAILED_ServiceIDInvalid_ISO15118_2018 = 13, FAILED_UnknownSession_ISO15118_2018 = 14,
									   FAILED_ServiceSelectionInvalid_ISO15118_2018 = 15, FAILED_SignatureError_ISO15118_2018 = 16, FAILED_IdentificationSelectionInvalid_ISO15118_2018 = 17,
									   FAILED_ChallengeInvalid_ISO15118_2018 = 18, FAILED_WrongChargeParameter_ISO15118_2018 = 19, FAILED_IsolationFault_ISO15118_2018 = 20,
									   FAILED_PowerDeliveryNotApplied_ISO15118_2018 = 21, FAILED_TariffSelectionInvalid_ISO15118_2018 = 22, FAILED_ChargingProfileInvalid_ISO15118_2018 = 23,
									   FAILED_MeteringSignatureNotValid_ISO15118_2018 = 24, FAILED_NoChargeServiceSelected_ISO15118_2018 = 25, FAILED_WrongEnergyTransferMode_ISO15118_2018 = 26,
									   FAILED_ContactorError_ISO15118_2018 = 27, FAILED_CertificateRevoked_ISO15118_2018 = 28, FAILED_CertificateNotYetValid_ISO15118_2018 = 29 };
enum EVSENotificationType		 		{ None = 0, StopCharging = 1, ReNegotiation = 2};
enum ServiceCategoryType 				{ EVCharging = 0, Internet = 1, ContractCertificate = 2, OtherCustom = 3};
enum PaymentOptionType 		      		{ Contract = 0, ExternalPayment = 1};
/*enum EVSESupportedEnergyTransferType 	{ AC_single_phase_core = 0, AC_three_phase_core = 1, DC_core = 2, DC_extended = 3,
									  DC_combo_core = 4, DC_dual = 5, AC_core1p_DC_extended = 6, AC_single_DC_core = 7,
									  AC_single_phase_three_phase_core_DC_extended = 8, AC_core3p_DC_extended = 9};*/
enum EnergyTransferModeType			{ AC_single_phase_core = 0, AC_three_phase_core = 1, DC_core = 2, DC_extended = 3,
									  DC_combo_core = 4, DC_unique = 5};
//enum identificationOptionType 			{ Contract = 0, ExternalIdentification = 1};
enum unitSymbolType_DIN70121			{ h_DIN70121 = 0, m_DIN70121 = 1, s_DIN70121 = 2, A_DIN70121 = 3, Ah_DIN70121 = 4, V_DIN70121 = 5, VA_DIN70121 = 6, W_DIN70121 = 7, Ws_DIN70121 = 8, Wh_DIN70121 = 9};
enum unitSymbolType_ISO15118_2014		{ h_ISO15118_2014 = 0, m_ISO15118_2014 = 1, s_ISO15118_2014 = 2, A_ISO15118_2014 = 3, V_ISO15118_2014 = 4, W_ISO15118_2014 = 5, Wh_ISO15118_2014 = 6};
enum ProcessingType					{ Finished = 0, Ongoing = 1, Ongoing_WaitingForCustomerInteraction = 2};
enum EVSEProcessingType_DIN70121		{ Finished_DIN70121 = 0, Ongoing_DIN70121 = 1};
enum EVSEProcessingType_ISO15118_2014	{ Finished_ISO15118_2014 = 0, Ongoing_ISO15118_2014 = 1, Ongoing_WaitingForCustomerInteraction_ISO15118_2014=2 };
enum DC_EVErrorCodeType 		  		{ NO_ERROR = 0, FAILED_RESSTemperatureInhibit = 1, FAILED_EVShiftPosition = 2, FAILED_ChargerConnectorLockFault = 3,
									  FAILED_EVRESSMalfunction = 4, FAILED_ChargingCurrentdifferential = 5, FAILED_ChargingVoltageOutOfRange = 6,
									  Reserved_A = 7, Reserved_B = 8, Reserved_C = 9, FAILED_ChargingSystemIncompatibility = 10, NoData = 11};
enum IsolationLevelType_DIN70121 		{ Invalid_DIN70121 = 0, Valid_DIN70121 = 1, Warning_DIN70121 = 2, Fault_DIN70121 = 3};
enum IsolationLevelType_ISO15118_2014		{ Invalid_ISO15118_2014 = 0, Valid_ISO15118_2014 = 1, Warning_ISO15118_2014 = 2, Fault_ISO15118_2014 = 3, No_IMD_ISO15118_2014	 = 4};
enum DC_EVSEStatusCodeType			{ EVSE_NotReady = 0, EVSE_Ready = 1, EVSE_Shutdown = 2, EVSE_UtilityInterruptEvent = 3,
						 			  EVSE_IsolationMonitoringActive = 4, EVSE_EmergencyShutdown = 5, EVSE_Malfunction = 6,
						 			  Reserved_8 = 7, Reserved_9 = 8};
enum ScheduleOriginType				{ EV = 0, SA = 1};
enum ChargeProgressType_ISO15118_2014	{start_ISO15118_2014 = 0, Stop_ISO15118_2014 = 1, Renegotiate_ISO15118_2014 = 2};
enum ChargeProgressType_ISO15118_2018	{start_ISO15118_2018 = 0, Renegotiate_ISO15118_2018 = 1, Standby_ISO15118_2018 = 2, Stop_ISO15118_2018 = 3};
enum evOperationType					{Charge = 0, Discharge = 1, Standby = 2};
enum mechanicalChargingDeviceStatusType {Home = 0, Moving = 1, EndPosition = 2};
enum EV_CP_StatusType					{A = 0, B = 1, C = 2, D = 3, E = 4, F = 5};
enum EV_Error_Status_CodeType			{ No_EV_Error = 0, EV_FAILED_EmergencyEvent = 1, EV_FAILED_Breaker = 2, EV_FAILED_RESSTemperatureInhibit = 3,
						 			  EV_FAILED_RESS = 4, EV_FAILED_ChargingCurrentDifferential = 5, EV_FAILED_ChargingVoltageOutOfRange = 6,
						 			  Reserved_by_ISO_1 = 7,  Reserved_by_ISO_2 = 8, Reserved_by_ISO_3 = 9, OEM1 = 10,
						 			  OEM2 = 11,  OEM3 = 12, OEM4 = 13};
enum IsolationStatusType				{ Invalid = 0, Safe = 1, Warning = 2, Fault = 3};
enum ChargingSessionType				{ Terminate = 0, Pause = 1};
enum CostKindType						{ relativePricePercentage = 0, RenewableGenerationPercentage = 1, CarbonDioxideEmission = 2};



struct PhysicalValueType_DIN70121 				//The final physical value is determined by: Value * 10 ^ Multiplier [Unit]
{
	int									Multiplier;			//range: -3..+3
	enum unitSymbolType_DIN70121			Unit;
	short 								Value;
};
struct PhysicalValueType_ISO15118_2014			//The final physical value is determined by: Value * 10 ^ Multiplier [Unit]
{
	int									Multiplier;			//range: -3..+3
	enum unitSymbolType_ISO15118_2014		Unit;
	short 								Value;
};
struct PhysicalValueType_ISO15118_2018			//The final physical value is determined by: Value * 10 ^ Exponent [Unit]
{
	int									Exponent;		//range: -3..+3
	short 								Value;
};
struct AppProtocolType
{
	unsigned char	ProtocolNamespace[100];
	unsigned int	VersionNumberMajor;
	unsigned int	VersionNumberMinor;
	unsigned char	SchemaID;
	unsigned char	Priority;					//range 1..20
};
struct ACD_SSEnergyTransferModeType
{
	unsigned char	EVID[20];
};
struct EVSEStatusType
{
	unsigned short				NotificationMaxDelay;	//in seconds
	enum EVSENotificationType	EVSENotification;
};
struct ServiceIDListType
{
	unsigned short	ServiceID[10];	//refer to chapter 8.6.2.1 Table 192
};
struct PaymentOptionListType
{
	enum PaymentOptionType	PaymentOption[2];
};
struct ServiceTagType
{
	unsigned short				ServiceID;
	unsigned char				ServiceName[32];//Optional Element
	enum ServiceCategoryType	ServiceCategory;
	unsigned char				ServiceScope[32];//Optional Element
};
struct ServiceType_DIN70121
{
	struct ServiceTagType		ServiceTag;
	BOOL					FreeService;
};
struct ServiceType_ISO15118_2014
{
	unsigned short				ServiceID;
	unsigned char				ServiceName[32];	//Optional
	enum ServiceCategoryType	ServiceCategory;
	unsigned char				ServiceScope[64];	//Optional
	BOOL					FreeService;
};
/*struct ServiceType_ISO15118_2018
{
	unsigned short				ServiceID;
	BOOL					FreeService;
}; */
struct SupportedEnergyTransferModeType
{
	enum EnergyTransferModeType	EnergyTransferMode[6];
};
struct ServiceChargeType
{
	struct ServiceType_DIN70121				Services;
	//enum EVSESupportedEnergyTransferType		EnergyTransferType;
	enum EnergyTransferModeType			EnergyTransferType;
};

struct ChargeServiceType
{
	struct ServiceType_ISO15118_2014			Services;
	struct SupportedEnergyTransferModeType	SupportedEnergyTransferMode;
};
struct ServiceListType
{
	struct ServiceType_ISO15118_2014			Service[8];
};
struct IdentificationOptionListType
{
	enum PaymentOptionType				IdentificationOption[2];
};
struct ParameterType
{
	unsigned char							Name[32];
	struct PhysicalValueType_ISO15118_2014		PhysicalValue_ISO15118_2014;
	struct PhysicalValueType_ISO15118_2018		PhysicalValue_ISO15118_2018;
};
struct ParameterSetType
{
	short 				ParameterSetID;
	struct ParameterType	Parameter[16];
};
struct ServiceParameterListType
{
	struct ParameterSetType		ParameterSet[255];
};
struct WPT_SDlEnergyTransferModeType
{
	struct ServiceParameterListType	ServiceParameterList;
};
struct SelectedServiceType
{
	unsigned short			ServiceID;
	short					ParameterSetID;
};
struct SelectedServiceListType
{
	struct SelectedServiceType	SelectedService[16];
};

struct CertificateChainType
{
	unsigned char 				Id[32];				//Optional
	unsigned char 				Certificate[800];		//check size again
	unsigned char				SubCertificates[4][800];	//Optional, 	check size again
};
struct PNC_AReqIdentificationModeType
{
	unsigned char 			GenChallenge[16];					//DIN70121=> None,	ISO15118_2014=>None,	ISO15118_2018=>Optional
	unsigned char 			Id[32];							//DIN70121=> None,	ISO15118_2014=>None,	ISO15118_2018=>Optional
};
struct AC_EVChargeParameterType
{
	unsigned int 								DepartureTime;		//Optional
	struct PhysicalValueType_ISO15118_2014			EAmount;
	struct PhysicalValueType_ISO15118_2014			EVMaxVoltage;
	struct PhysicalValueType_ISO15118_2014			EVMaxCurrent;
	struct PhysicalValueType_ISO15118_2014			EVMinCurrent;
};
struct DC_EVStatusType_DIN70121
{
	BOOL						EVReady;
	BOOL						EVCabinConditioning;
	BOOL						EVRESSConiditioning;
	enum DC_EVErrorCodeType		EVErrorCode;
	unsigned char 					EVRESSSOC;		/*0-100 percentage*/
};
struct DC_EVChargeParameterType_DIN70121
{
	struct DC_EVStatusType_DIN70121			DC_EVStatus;
	struct PhysicalValueType_DIN70121		EVMaximumCurrentLimit;
	struct PhysicalValueType_DIN70121		EVMaximumPowerLimit;			//Optional
	struct PhysicalValueType_DIN70121		EVMaximumVoltageLimit;
	struct PhysicalValueType_DIN70121		EVEnergyCapacity;				//Optional
	struct PhysicalValueType_DIN70121		EVEnergyRequest;				//Optional
	unsigned char							FullSOC;/*0-100 percentage*/	//Optional
	unsigned char							BulkSOC;/*0-100 percentage*/	//Optional
};
struct DC_EVStatusType_ISO15118_2014
{
	BOOL						EVReady;
	enum DC_EVErrorCodeType		EVErrorCode;
	unsigned char 					EVRESSSOC;		/*0-100 percentage*/
};
struct DC_EVChargeParameterType_ISO15118_2014
{
	unsigned int 								DepartureTime;				//Optional
	struct DC_EVStatusType_ISO15118_2014			DC_EVStatus;
	struct PhysicalValueType_ISO15118_2014 			EVMaximumCurrentLimit;
	struct PhysicalValueType_ISO15118_2014			EVMaximumPowerLimit;			//Optional
	struct PhysicalValueType_ISO15118_2014			EVMaximumVoltageLimit;
	struct PhysicalValueType_ISO15118_2014			EVEnergyCapacity;				//Optional
	struct PhysicalValueType_ISO15118_2014			EVEnergyRequest;				//Optional
	unsigned char								FullSOC;/*0-100 percentage*/		//Optional
	unsigned char								BulkSOC;/*0-100 percentage*/	//Optional
};
struct Dynamic_CPDReqControlModeType
{
	unsigned int 								DepartureTime;
};
struct RelativeTimeIntervalType
{
	unsigned int 	duration;			//Optional
	unsigned int	start;
};
struct PMaxScheduleEntryType
{
	struct RelativeTimeIntervalType	RelativeTimeInterval;
	unsigned short					PMax;
};
struct PMaxScheduleType
{
	unsigned short					PMaxScheduleID;			//no this itme in ISO15118_2014
	struct PMaxScheduleEntryType		PMaxScheduleEntry[1024];
};
struct CostType
{
	unsigned int 					amount;
	enum CostKindType				costKind;
	int 							amountMultiplier;		//Optional , range: -3..+3
};
struct ConsumptionCostType
{
	struct CostType						Cost[3];
	struct PhysicalValueType_ISO15118_2014		startValue;
};
struct SalesTariffEntryType
{
	struct RelativeTimeIntervalType	RelativeTimeInterval;
	unsigned char 					EPriceLevel;			//Optional
	struct ConsumptionCostType		ConsumptionCost[3];	//Optional
};
struct SalesTariffType
{
	unsigned char 					Id[32];					//Optional
	short 						SalesTariffID;
	unsigned char 					SalesTariffDescription[32];	//Optional
	unsigned char 					NumEPriceLevels;			//Optional
	struct SalesTariffEntryType			SalesTariffEntry[1024];
};
struct SAScheduleTupleType
{
	short 						SAScheduleTupleID;
	struct PMaxScheduleType			PMaxSchedule;
	struct SalesTariffType				SalesTariff;				//Optional
};
struct ScheduleListType
{
	enum ScheduleOriginType					ScheduleOrigin;
	struct SAScheduleTupleType					ScheduleTuple[3];
};
struct Scheduled_CPDReqControlModeType
{
	enum ProcessingType						EVProcessing;
	unsigned int 								DepartureTime;		//Optional
	unsigned short 							MaxSupportingPoints;
	struct ScheduleListType						ScheduleList;			//Optional
};
struct AC_CPDReqEnergyTransferModeType
{
	struct PhysicalValueType_ISO15118_2018			EVTargetEnergyRequest;			//Optional
	struct PhysicalValueType_ISO15118_2018			EVMaximumEnergyRequest;		//Optional
	struct PhysicalValueType_ISO15118_2018			EVMinimumEnergyRequest;		//Optional
	struct PhysicalValueType_ISO15118_2018			EVMaximumChargePower;
	struct PhysicalValueType_ISO15118_2018			EVMaximumChargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVMinimumChargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVMaximumVoltage;
};
struct DC_CPDReqEnergyTransferModeType
{
	struct PhysicalValueType_ISO15118_2018			EVMaximumChargePower;			//Optional
	struct PhysicalValueType_ISO15118_2018			EVMinimumChargePower;			//Optional
	struct PhysicalValueType_ISO15118_2018			EVMaximumChargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVMinimumChargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVMaximumVoltage;
	struct PhysicalValueType_ISO15118_2018			EVTargetEnergyRequest;				//Optional
	struct PhysicalValueType_ISO15118_2018			EVMaximumEnergyRequest;			//Optional
	struct PhysicalValueType_ISO15118_2018			EVMinimumEnergyRequest;			//Optional
	unsigned char								TargetSOC;						//Optional
	unsigned char								BulkSOC;							//Optional
};
struct BPT_AC_CPDReqEnergyTransferModeType
{
	struct PhysicalValueType_ISO15118_2018			EVMaximumChargePower;
	struct PhysicalValueType_ISO15118_2018			EVMaximumDischargePower;
	struct PhysicalValueType_ISO15118_2018			EVMinimumDischargePower;
	struct PhysicalValueType_ISO15118_2018			EVMaximumChargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVMaximumDischargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVMinimumChargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVMinimumDischargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVTargetEnergyRequest;				//Optional
	struct PhysicalValueType_ISO15118_2018			EVMinimumEnergyRequest;			//Optional
	struct PhysicalValueType_ISO15118_2018			EVMaximumEnergyRequest;			//Optional
	struct PhysicalValueType_ISO15118_2018			EVMaximumVoltage;
};
struct BPT_DC_CPDReqEnergyTransferModeType
{
	struct PhysicalValueType_ISO15118_2018			EVMaximumChargePower;
	struct PhysicalValueType_ISO15118_2018			EVMinimumChargePower;
	struct PhysicalValueType_ISO15118_2018			EVMaximumDischargePower;
	struct PhysicalValueType_ISO15118_2018			EVMinimumDischargePower;
	struct PhysicalValueType_ISO15118_2018			EVMaximumChargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVMinimumChargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVMaximumDischargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVMinimumDischargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVMaximumVoltage;
	struct PhysicalValueType_ISO15118_2018			EVMinimumVoltage;
	struct PhysicalValueType_ISO15118_2018			EVTargetEnergyRequest;
	struct PhysicalValueType_ISO15118_2018			EVMaximumEnergyRequest;
	struct PhysicalValueType_ISO15118_2018			EVMinimumEnergyRequest;
	unsigned char								TargetSOC;					//Optional
	unsigned char								BulkSOC;						//Optional
};
struct WPT_CPDReqEnergyTransferModeType
{
	struct PhysicalValueType_ISO15118_2018			EVMaximumPower;				//Optional
	struct PhysicalValueType_ISO15118_2018			EVMinimumPower;				//Optional
	struct PhysicalValueType_ISO15118_2018			EVTargetEnergyRequest;			//Optional
	struct PhysicalValueType_ISO15118_2018			EVMaximumEnergyRequest;		//Optional
	struct PhysicalValueType_ISO15118_2018			EVMinimumEnergyRequest;		//Optional
};
struct ACD_CPDReqEnergyTransferModeType
{
	//cannot be found in standard
};
struct SAScheduleListType
{
	struct SAScheduleTupleType		SAScheduleTuple[3];
};
struct DC_EVSEStatusType_DIN70121
{
	enum IsolationLevelType_DIN70121			EVSEIsolationStatus;			//Optional
	enum DC_EVSEStatusCodeType			EVSEStatusCode;
	unsigned int							NotificationMaxDelay;
	enum EVSENotificationType				EVSENotification;
};
struct DC_EVSEChargeParameterType_DIN70121
{
	struct DC_EVSEStatusType_DIN70121		DC_EVSEStatus;
	struct PhysicalValueType_DIN70121			EVSEMaximumCurrentLimit;
	struct PhysicalValueType_DIN70121			EVSEMaximumPowerLimit;			//Optional
	struct PhysicalValueType_DIN70121			EVSEMaximumVoltageLimit;
	struct PhysicalValueType_DIN70121			EVSEMinimumCurrentLimit;
	struct PhysicalValueType_DIN70121			EVSEMinimumVoltageLimit;
	struct PhysicalValueType_DIN70121			EVSECurrentRegulationTolerance;		//Optional
	struct PhysicalValueType_DIN70121			EVSEPeakCurrentRipple;
	struct PhysicalValueType_DIN70121			EVSEEnergyToBeDelivered;			//Optional
};
struct AC_EVSEStatusType
{
	BOOL							  		RCD;
	unsigned short 							NotificationMaxDelay;
	enum EVSENotificationType					EVSENotification;		//need to be confirmed
};
struct AC_EVSEChargeParameterType
{
	struct AC_EVSEStatusType					AC_EVSEStatus;
	struct PhysicalValueType_ISO15118_2014			EVSENominalVoltage;
	struct PhysicalValueType_ISO15118_2014			EVSEMaxCurrent;
};
struct DC_EVSEStatusType_ISO15118_2014
{
	unsigned short								NotificationMaxDelay;
	enum EVSENotificationType					EVSENotification;
	enum IsolationLevelType_ISO15118_2014			EVSEIsolationStatus;					//Optional
	enum DC_EVSEStatusCodeType				DC_EVSEStatusCode;
};
struct DC_EVSEChargeParameterType_ISO15118_2014
{
	struct DC_EVSEStatusType_ISO15118_2014		DC_EVSEStatus;
	struct PhysicalValueType_ISO15118_2014			EVSEMaximumCurrentLimit;
	struct PhysicalValueType_ISO15118_2014			EVSEMaximumPowerLimit;
	struct PhysicalValueType_ISO15118_2014			EVSEMaximumVoltageLimit;
	struct PhysicalValueType_ISO15118_2014			EVSEMinimumCurrentLimit;
	struct PhysicalValueType_ISO15118_2014			EVSEMinimumVoltageLimit;
	struct PhysicalValueType_ISO15118_2014			EVSECurrentRegulationTolerance;		//Optional
	struct PhysicalValueType_ISO15118_2014			EVSEPeakCurrentRipple;
	struct PhysicalValueType_ISO15118_2014			EVSEEnergyToBeDelivered;			//Optional
};
struct Scheduled_CPDResControlModeType
{
	struct ScheduleListType						ScheduleList;
};
struct AC_CPDResEnergyTransferModeType
{
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumChargeCurrent[3];
	struct PhysicalValueType_ISO15118_2018			EVSENominalVoltage;
	struct PhysicalValueType_ISO15118_2018			EVSENominalFrequency;
};
struct DC_CPDResEnergyTransferModeType
{
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumChargePower;
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumChargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVSEMinimumChargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumVoltage;
	struct PhysicalValueType_ISO15118_2018			EVSEMinimumVoltage;
};
struct BPT_AC_CPDResEnergyTransferModeType
{
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumChargeCurrent[3];
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumDischargeCurrent[3];
	struct PhysicalValueType_ISO15118_2018			EVSENominalVoltage;
	struct PhysicalValueType_ISO15118_2018			EVSENominalFrequency;
};
struct BPT_DC_CPDResEnergyTransferModeType
{
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumChargePower;
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumDischargePower;
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumChargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumDischargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVSEMinimumChargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVSEMinimumDischargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumVoltage;
	struct PhysicalValueType_ISO15118_2018			EVSEMinimumVoltage;
};
struct WPT_CPDResEnergyTransferModeType
{
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumPower;
	struct PhysicalValueType_ISO15118_2018			EVSEMinimumPower;
};
struct ACD_CPDResEnergyTransferModeType
{
	//not found in ISO15118_2018
};
struct ProfileEntryType_DIN70121
{
	unsigned int 				ChargingProfileEntryStart;
	short						ChargingProfileEntryMaxPower;
};
struct ChargingProfileType_DIN70121
{
	short 							SAScheduleTupleID;
	struct ProfileEntryType_DIN70121		ProfileEntry[24];
};
struct DC_EVPowerDeliveryParameterType_DIN70121
{
	struct DC_EVStatusType_DIN70121			DC_EVStatus;
	BOOL								BulkChargingComplete;		//Optional
	BOOL								ChargingComplete;
};
struct ProfileEntryType_ISO15118_2014
{
	unsigned int 								ChargingProfileEntryStart;
	struct PhysicalValueType_ISO15118_2018			ChargingProfileEntryMaxPower;
	unsigned char 								ChargingProfileEntryMaxNumberOfPhasesInUse;	//Optional
};
struct ChargingProfileType_ISO15118_2014
{
	struct ProfileEntryType_ISO15118_2014			ProfileEntry[24];
};
struct DC_EVPowerDeliveryParameterType_ISO15118_2014
{
	struct DC_EVStatusType_ISO15118_2014 			DC_EVStatus;
	BOOL									BulkChargingComplete;		//Optional
	BOOL									ChargingComplete;
};
struct TimeInterval
{
	unsigned int 								start;
	unsigned int 								duration;				//Optional
};
struct PowerScheduleEntryType
{
	struct TimeInterval							TimeInterval;
	struct PhysicalValueType_ISO15118_2018			Power[3];
};
struct EVPowerProfileType
{
	struct PowerScheduleEntryType				EVPowerProfileEntry[2048];
};
struct Scheduled_PDReqControlModeType
{
	unsigned char 								ScheduleTupleID;
	struct EVPowerProfileType					EVPowerProfile;
};
struct BPT_Scheduled_PDReqControlModeType
{
	unsigned char 								ScheduleTupleID;
	struct EVPowerProfileType					EVPowerProfile;			//Optional
	enum evOperationType						EVOperation;
};
struct ListOfRootCertificateIDsType
{
	unsigned char 								RootCertificateID[20][40];
};
struct ContractSignatureEncryptedPrivateKeyType
{
	unsigned char 								Id[32];
};
struct DiffieHellmanPublickeyType
{
	unsigned char 								Id[32];
};
struct ContractCertificateEncryptedPrivateKeyType
{
	unsigned char 								Id[32];
};
struct EVTechnicalStatusType
{
	BOOL									EV_Status_ReadyToCharge;
	BOOL									EV_Status_ImmobilizationRequest;		//Optional
	BOOL									EV_Status_Immobilized;
	struct PhysicalValueType_ISO15118_2018			EV_Status_WLAN_Strength;
	enum EV_CP_StatusType						EV_CP_Status;
	unsigned char								EV_Status_RESSSOC;					//0~100%
	enum EV_Error_Status_CodeType				EV_Error_Status_Code;
	BOOL									EVSE_Timeout;
};
struct MeterInfoType_ISO15118_2014
{
	unsigned char								MeterID[32];
	unsigned long 								MeterReading;						//Optional
	unsigned char								SigMeterReading[64];				//Optional
	short 									MeterStatus;						//Optional
	short 									TMeter;							//Optional
};
struct Scheduled_MRReqControlModeType
{
	unsigned char 								ScheduleTupleID;
};
struct MeterInfoType_ISO15118_2018
{
	unsigned char								MeterID[32];
	unsigned long 								MeterReadingWhCharged;			//Optional
	unsigned long 								MeterReadingWhDischarged;			//Optional
	unsigned long 								MeterReadingVARhLeading;			//Optional
	unsigned long 								MeterReadingVARhLagging;			//Optional
	unsigned char								SignatureMeterReading[64];			//Optional
	short 									MeterStatus;						//Optional
	short 									TimeStampMeter;					//Optional
	BOOL									ReceiptRequired;					//Optional
};
struct PnC_CLReqIdentificationModeType
{
	BOOL									MeteringReceiptRequested;
};
struct Dynamic_CSReqControlModeType
{
	struct PhysicalValueType_ISO15118_2018			EVTargetEnergyRequest;
	struct PhysicalValueType_ISO15118_2018			EVMaximumEnergyRequest;
	struct PhysicalValueType_ISO15118_2018			EVMinimumEnergyRequest;
	struct PhysicalValueType_ISO15118_2018			EVMaximumChargePower;
	struct PhysicalValueType_ISO15118_2018			EVMaximumChargeCurrent;
	struct PhysicalValueType_ISO15118_2018			EVMinimumChargeCurrent;
};
struct Scheduled_CSReqControlModeType
{
	struct PhysicalValueType_ISO15118_2018			EVTargetEnergyRequest;				//Optional
	struct PhysicalValueType_ISO15118_2018			EVMaximumEnergyRequest;			//Optional
	struct PhysicalValueType_ISO15118_2018			EVMinimumEnergyRequest;			//Optional
	BOOL									Standby;
	struct PhysicalValueType_ISO15118_2018			EVMaximumChargePower;			//Optional
	struct PhysicalValueType_ISO15118_2018			EVMaximumChargeCurrent;			//Optional
	struct PhysicalValueType_ISO15118_2018			EVMinimumChargeCurrent;			//Optional
};
struct DisplayParametersType
{
	unsigned short 							CurrentRange;
	unsigned char	 							CurrentSOC;						//0~100%
	unsigned char	 							MinimumSOC;						//0~100%
	struct PhysicalValueType_ISO15118_2018			RemainingTimeToMaximumSOC;
	struct PhysicalValueType_ISO15118_2018			RemainingTimeToTargetSOC;
	struct PhysicalValueType_ISO15118_2018			RemainingTimeToBulkSOC;
	struct PhysicalValueType_ISO15118_2018			RemainingTimeToMinimumSOC;
	BOOL									ChargingComplete;
	BOOL									BulkChargingComplete;
	BOOL									InletHot;
};
struct PnC_CLResIdentificationModeType
{
	struct MeterInfoType_ISO15118_2018			MeterInfo;
};
struct Dynamic_CSResControlModeType
{
	struct PhysicalValueType_ISO15118_2018			EVSETargetActivePower;
};
struct Scheduled_CDResControlModeType
{
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumChargePower;		//Optional
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumChargeCurrent;	//Optional
	struct PhysicalValueType_ISO15118_2018			EVSEMaximumVoltage;			//Optional
};
struct LFA_EVFinePositioningSetupParametersType
{
	unsigned char 								NumberOfSensors;
	//NOT complete yet,  to be continue.....
};

/****SupportedAppProtocolRequest****/
struct SupportedAppProtocolRequest_DIN70121
{
	struct AppProtocolType	AppProtocol[20];
};
struct SupportedAppProtocolRequest_ISO15118_2014
{
	struct AppProtocolType	AppProtocol[20];
};
struct SupportedAppProtocolRequest_ISO15118_2018
{
	struct AppProtocolType	AppProtocol[20];
};
/****SupportedAppProtocolResponse****/
struct SupportedAppProtocolResponse_DIN70121
{
	enum ResponseCodeType_DIN70121		ResponseCode;
	unsigned char							SchemaID;				//Optional
};
struct SupportedAppProtocolResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014	ResponseCode;
	unsigned char							SchemaID;				//Optional
};
struct SupportedAppProtocolResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018	ResponseCode;
	unsigned char							SchemaID;					//Optional
};
/****SessionSetupRequest****/
struct SessionSetupRequest_DIN70121
{
	unsigned char						EVCCID[8];						//the MAC address of the EVCC in Hex
};
struct SessionSetupRequest_ISO15118_2014
{
	unsigned char						EVCCID[8];						//the MAC address of the EVCC in Hex
};
struct SessionSetupRequest_ISO15118_2018
{
	unsigned char						EVCCID[8];						//the MAC address of the EVCC in Hex
	struct ACD_SSEnergyTransferModeType	ACD_SSEnergyTransferMode;			//For ACD mandatory, optional for rest
};
/****SessionSetupResponse****/
struct SessionSetupResponse_DIN70121
{
	enum ResponseCodeType_DIN70121		ResponseCode;
	unsigned char							EVSEID[40];					//DIN70121=>Max length:32,	ISO15118=>min length:7, max length:37
	unsigned int							EVSETimeStamp;				//EPOCH format, Optional
};
struct SessionSetupResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014	ResponseCode;
	unsigned char							EVSEID[40];					//DIN70121=>Max length:32,	ISO15118=>min length:7, max length:37
	unsigned int							EVSETimeStamp;				//EPOCH format, Optional
};
struct SessionSetupResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018	ResponseCode;
	unsigned char							EVSEID[40];					//DIN70121=>Max length:32,	ISO15118=>min length:7, max length:37
	struct EVSEStatusType					EVSEStatus;					//Optional
};
/****ServiceDiscoveryRequest****/
struct ServiceDiscoveryRequest_DIN70121
{
	unsigned char				ServiceScope[32];		//Optional
	enum ServiceCategoryType	ServiceCategory;		//Optional
};
struct ServiceDiscoveryRequest_ISO15118_2014
{
	unsigned char				ServiceScope[32];		//Optional
	enum ServiceCategoryType	ServiceCategory;		//Optional
};
struct ServiceDiscoveryRequest_ISO15118_2018
{
	struct ServiceIDListType		SupportedServiceIDs;	//Optional
};
/****ServiceDiscoveryResponse****/
struct ServiceDiscoveryResponse_DIN70121
{
	enum ResponseCodeType_DIN70121		ResponseCode;
	struct PaymentOptionListType				PaymentOptions;
	struct ServiceChargeType				ChargeService_DIN70121;
};
struct ServiceDiscoveryResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014	ResponseCode;
	struct PaymentOptionListType				PaymentOptions;
	struct ChargeServiceType				ChargeService;
	struct ServiceListType					ServiceList;					//Optional
};
struct ServiceDiscoveryResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018	ResponseCode;
	struct EVSEStatusType					EVSEStatus;					//Optional
	struct IdentificationOptionListType			IdentificationOptionList;
	struct ServiceListType					EnergyTransferServiceList;
	struct ServiceListType					VASList;						//Optional
};
/****ServiceDetailRequest****/
//Only in ISO15118_2014 and ISO15118_2018
struct ServiceDetailRequest_ISO15118_2014
{
	unsigned short						ServiceID;
};
struct ServiceDetailRequest_ISO15118_2018
{
	unsigned short						ServiceID;
	struct WPT_SDlEnergyTransferModeType	WPT_SDlEnergyTransferMode;
};
/****ServiceDetailResponse****/
struct ServiceDetailResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014	ResponseCode;
	unsigned short							ServiceID;
	struct ServiceParameterListType 			ServiceParameterList;
};
struct ServiceDetailResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018	ResponseCode;
	unsigned short							ServiceID;
	struct ServiceParameterListType 			ServiceParameterList;
	struct EVSEStatusType					EVSEStatus;					//Optional
};
/****ServiceAndPaymentSelectionRequest / ServiceSelectionRequest****/
struct ServiceAndPaymentSelectionRequest_DIN70121
{
	enum PaymentOptionType		SelectedPaymentOption;
	struct SelectedServiceListType		SelectedServiceList;
};
struct ServiceAndPaymentSelectionRequest_ISO15118_2014
{
	enum PaymentOptionType		SelectedPaymentOption;
	struct SelectedServiceListType		SelectedServiceList;
};
struct ServiceSelectionRequest_ISO15118_2018
{
	enum PaymentOptionType			SelectedPaymentOption;
	struct SelectedServiceType			SelectedEnergyTransferService;
	struct SelectedServiceListType			SelectedVASList;
	enum ProcessingType				EVProcessing;
};
/****ServiceAndPaymentSelectionResponse / ServiceSelectionResponse****/
struct ServiceAndPaymentSelectionResponse_DIN70121
{
	enum ResponseCodeType_DIN70121		ResponseCode;
};
struct ServiceAndPaymentSelectionResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014	ResponseCode;
};
struct ServiceSelectionResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018	ResponseCode;
	struct EVSEStatusType					EVSEStatus;					//Optional
};
/****PaymentDetailsRequest / IdentificationDetailsRequest****/
struct PaymentDetailsRequest_ISO15118_2014
{
	unsigned char 					eMAID[16];
	struct CertificateChainType		ContractSignatureCertChain;
};
struct IdentificationDetailsRequest_ISO15118_2018
{
	struct CertificateChainType		ContractSignatureCertChain;
};
/****PaymentDetailsResponse  / IdentificationDetailsResponse ****/
struct PaymentDetailsResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014	ResponseCode;
	unsigned char 							GenChallenge[16];
	long 								EVSETimeStamp;
};
struct IdentificationDetailsResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018	ResponseCode;
	struct EVSEStatusType					EVSEStatus;						//Optional
	unsigned char 							GenChallenge[16];
	enum ProcessingType					EVSEProcessing;
};
/****ContractAuthenticationRequest / AuthorizationRequest****/
struct ContractAuthenticationRequest_DIN70121
{
	//None
};
struct AuthorizationRequest_ISO15118_2014
{
	unsigned char 			GenChallenge[16];					//Optional
	unsigned char 			Id[32];							//Optional
};
struct AuthorizationRequest_ISO15118_2018
{
	struct PNC_AReqIdentificationModeType		PNC_AReqIdentificationMode;	//Optional
};
/****ContractAuthenticationResponse  / AuthorizationResponse****/
struct ContractAuthenticationResponse_DIN70121
{
	enum ResponseCodeType_DIN70121		ResponseCode;
	enum EVSEProcessingType_DIN70121		EVSEProcessing;
};
struct AuthorizationResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014	ResponseCode;
	enum EVSEProcessingType_ISO15118_2014	EVSEProcessing;
};
struct AuthorizationResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018	ResponseCode;
	enum ProcessingType					EVSEProcessing;
	struct EVSEStatusType					EVSEStatus;						//Optional
};
/****ChargeParameterDiscoveryRequest****/
struct ChargeParameterDiscoveryRequest_DIN70121
{
	enum EnergyTransferModeType					EVRequestedEnergyTransferType;
	struct DC_EVChargeParameterType_DIN70121		DC_EVChargeParameter;
};
struct ChargeParameterDiscoveryRequest_ISO15118_2014
{
	unsigned short										MaxEntriesSAScheduleTuple;			//Optional
	enum EnergyTransferModeType						RequestedEnergyTransferMode;
	struct AC_EVChargeParameterType					AC_EVChargeParameter;
	struct DC_EVChargeParameterType_ISO15118_2014		DC_EVChargeParameter;
};
struct ChargeParameterDiscoveryRequest_ISO15118_2018
{
	struct Dynamic_CPDReqControlModeType			Dynamic_CPDReqControlMode;
	struct Scheduled_CPDReqControlModeType			Scheduled_CPDReqControlMode;
	struct AC_CPDReqEnergyTransferModeType			AC_CPDReqEnergyTransferMode;
	struct DC_CPDReqEnergyTransferModeType			DC_CPDReqEnergyTransferMode;
	struct BPT_AC_CPDReqEnergyTransferModeType		BPT_AC_CPDReqEnergyTransferMode;
	struct BPT_DC_CPDReqEnergyTransferModeType		BPT_DC_CPDReqEnergyTransferMode;
	struct WPT_CPDReqEnergyTransferModeType			WPT_CPDReqEnergyTransferMode;
	struct ACD_CPDReqEnergyTransferModeType			ACD_CPDReqEnergyTransferMode;
};
/****ChargeParameterDiscoveryResponse****/
struct ChargeParameterDiscoveryResponse_DIN70121
{
	enum ResponseCodeType_DIN70121					ResponseCode;
	enum EVSEProcessingType_DIN70121					EVSEProcessing;
	struct SAScheduleListType 							SAScheduleList;
	struct DC_EVSEChargeParameterType_DIN70121			DC_EVSEChargeParameter;
};
struct ChargeParameterDiscoveryResponse_ISO15118_2014
{
	enum EVSEProcessingType_ISO15118_2014				EVSEProcessing;
	enum ResponseCodeType_ISO15118_2014				ResponseCode;
	struct SAScheduleListType 							SAScheduleList;
	struct AC_EVSEChargeParameterType					AC_EVSEChargeParameter;
	struct DC_EVSEChargeParameterType_ISO15118_2014		DC_EVSEChargeParameter;
};
struct ChargeParameterDiscoveryResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018				ResponseCode;
	struct EVSEStatusType								EVSEStatus;					//Optional
	enum ProcessingType								EVSEProcessing;
	struct Scheduled_CPDResControlModeType				Scheduled_CPDResControlMode;	//Optional
	struct AC_CPDResEnergyTransferModeType				AC_CPDResEnergyTransferMode;
	struct DC_CPDResEnergyTransferModeType				DC_CPDResEnergyTransferMode;
	struct BPT_AC_CPDResEnergyTransferModeType			BPT_AC_CPDResEnergyTransferMode;
	struct BPT_DC_CPDResEnergyTransferModeType			BPT_DC_CPDResEnergyTransferMode;
	struct WPT_CPDResEnergyTransferModeType				WPT_CPDResEnergyTransferMode;
	struct ACD_CPDResEnergyTransferModeType				ACD_CPDResEnergyTransferMode;
};
/****PowerDeliveryRequest****/
struct PowerDeliveryRequest_DIN70121
{
	BOOL											ReadyToChargeState;
	struct ChargingProfileType_DIN70121					ChargingProfile;
	struct DC_EVPowerDeliveryParameterType_DIN70121		DC_EVPowerDeliveryParameter;
};
struct PowerDeliveryRequest_ISO15118_2014
{
	enum ChargeProgressType_ISO15118_2014				ChargeProgress;
	short 											SAScheduleTupleID;
	struct ChargingProfileType_ISO15118_2014 				ChargingProfile;
	struct DC_EVPowerDeliveryParameterType_ISO15118_2014	DC_EVPowerDeliveryParameter;
};
struct PowerDeliveryRequest_ISO15118_2018
{
	enum ChargeProgressType_ISO15118_2018				ChargeProgress;
	struct Scheduled_PDReqControlModeType				Scheduled_PDReqControlMode;
	struct BPT_Scheduled_PDReqControlModeType			BPT_Scheduled_PDReqControlMode;
};
/****PowerDeliveryResponse****/
struct PowerDeliveryResponse_DIN70121
{
	enum ResponseCodeType_DIN70121				ResponseCode;
	struct DC_EVSEStatusType_DIN70121				DC_EVSEStatus;
};
struct PowerDeliveryResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014				ResponseCode;
	struct AC_EVSEStatusType							AC_EVSEStatus;
	struct DC_EVSEStatusType_ISO15118_2014				DC_EVSEStatus;
};
struct PowerDeliveryResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018				ResponseCode;
	struct EVSEStatusType								EVSEStatus;			//Optional
};
/****CertificateUpdateRequest****/
struct CertificateUpdateRequest_ISO15118_2014
{
	unsigned char 										Id[32];
	struct CertificateChainType							ContractSignatureCertChain;
	unsigned char 										eMAID[16];
	struct ListOfRootCertificateIDsType						ListOfRootCertificateIDs;
};
/****CertificateUpdateResponse****/
struct CertificateUpdateResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014				ResponseCode;
	struct CertificateChainType							SAProvisioningCertificateChain;
	struct CertificateChainType							ContractSignatureCertChain;
	struct ContractSignatureEncryptedPrivateKeyType			ContractSignatureEncryptedPrivateKey;
	struct DiffieHellmanPublickeyType						DHpublickey;
	unsigned char 										eMAID[16];
	short 											RetryCounter;							//Optional
};
/****CertificateInstallationRequest****/
struct CertificateInstallationRequest_ISO15118_2014
{
	unsigned char 										Id[32];
	unsigned char 										OEMProvisioningCert[800];
	struct ListOfRootCertificateIDsType						ListOfRootCertificateIDs;
};
struct CertificateInstallationRequest_ISO15118_2018
{
	unsigned char 										Id[32];
	struct CertificateChainType							OEMProvisioningCertChain;
	struct ListOfRootCertificateIDsType						ListOfRootCertificateIDs;
	unsigned short										MaxSupportedCerts;
};
/****CertificateInstallationResponse****/
struct CertificateInstallationResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014				ResponseCode;
	struct CertificateChainType							SAProvisioningCertificateChain;
	struct CertificateChainType							ContractSignatureCertChain;
	struct ContractSignatureEncryptedPrivateKeyType			ContractSignatureEncryptedPrivateKey;
	struct DiffieHellmanPublickeyType						DHpublickey;
	unsigned char 										eMAID[16];
};
struct CertificateInstallationResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018				ResponseCode;
	struct EVSEStatusType								EVSEStatus;					//Optional
	struct CertificateChainType							SAProvisioningCertificateChain;
	struct CertificateChainType							ContractCertificateChain;
	struct ContractCertificateEncryptedPrivateKeyType		ContractEncryptedPrivateKey;
	struct DiffieHellmanPublickeyType						DHpublickey;
	enum ProcessingType								EVSEProcessing;
	unsigned short 									RemainingContractCertificateChains;
};
/****SystemStatusRequest****/
struct SystemStatusRequest_ISO15118_2018
{
	enum mechanicalChargingDeviceStatusType			EVMechanicalChargingDeviceStatus;
	struct EVTechnicalStatusType							EVTechnicalStatus;
	unsigned char 										EV_OEMStatus[800];					//Optional
};
/****SystemStatusResponse****/
struct SystemStatusResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018				ResponseCode;
	enum mechanicalChargingDeviceStatusType			EVSEMechanicalChargingDeviceStatus;
	BOOL											EVSE_ReadyToCharge;
	enum IsolationStatusType							EVSE_IsolationStatus;
	BOOL											EVSE_Disabled;
	BOOL											EVSE_UtilityInterruptEvent;
	BOOL											EVSE_EmergencyShutdown;
	BOOL											EVSE_Malfunction;
	BOOL											EV_InChargePosition;
	BOOL											EV_AssociationStatus;
};
/****SessionStopRequest****/
struct SessionStopRequest_DIN70121
{
	//No member in standard
};
struct SessionStopRequest_ISO15118_2014
{
	enum ChargingSessionType							ChargingSession;
};
struct SessionStopRequest_ISO15118_2018
{
	enum ChargingSessionType							ChargingSession;
};
/****SessionStopResponse****/
struct SessionStopResponse_DIN70121
{
	enum ResponseCodeType_DIN70121					ResponseCode;
};
struct SessionStopResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014				ResponseCode;
};
struct SessionStopResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018				ResponseCode;
	struct EVSEStatusType								EVSEStatus;					//Optional
};
/****MeteringReceiptRequest****/
struct MeteringReceiptRequest_ISO15118_2014
{
	unsigned char 										Id[32];						//Optional
	unsigned char 										SessionID[8];
	short 											SAScheduleTupleID;				//Optional
	struct MeterInfoType_ISO15118_2014					MeterInfo;
};
struct MeteringReceiptRequest_ISO15118_2018
{
	unsigned char 										Id[32];						//Optional
	unsigned char 										SessionID[8];
	struct Scheduled_MRReqControlModeType				Schedule_MRReqControlMode;
	struct MeterInfoType_ISO15118_2018					MeterInfo;
};
/****MeteringReceiptResponse****/
struct MeteringReceiptResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014				ResponseCode;
	struct AC_EVSEStatusType							AC_EVSEStatus;
	struct DC_EVSEStatusType_ISO15118_2014				DC_EVSEStatus;
};
struct MeteringReceiptResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018				ResponseCode;
	struct EVSEStatusType								EVSEStatus;					//Optional
};
/****ChargingStatusRequest (AC Only)****/
struct ChargingStatusRequest_ISO15118_2014
{
	//No member in standard
};
struct ChargingStatusRequest_ISO15118_2018
{
	struct PnC_CLReqIdentificationModeType				PnC_CLReqIdentificationMode;
	struct Dynamic_CSReqControlModeType				Dynamic_CSReqControlMode;
	struct Scheduled_CSReqControlModeType				Scheduled_CSReqControlMode;
	struct DisplayParametersType							DisplayParameters;
};
/****ChargingStatusResponse (AC Only)****/
struct ChargingStatusResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014				ResponseCode;
	unsigned char										EVSEID[40];			//DIN70121=>Max length:32,	ISO15118=>min length:7, max length:37
	short 											SAScheduleTupleID;
	struct PhysicalValueType_ISO15118_2014					EVSEMaxCurrent;		//Optional
	struct MeterInfoType_ISO15118_2014					MeterInfo;			//Optional
	BOOL											ReceiptRequired;		//Optional
	struct AC_EVSEStatusType							AC_EVSEStatus;
};
struct ChargingStatusResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018				ResponseCode;
	struct EVSEStatusType								EVSEStatus;					//Optional
	unsigned char										EVSEID[40];					//DIN70121=>Max length:32,	ISO15118=>min length:7, max length:37
	struct PhysicalValueType_ISO15118_2018					EVSETargetFrequency;			//Optional
	struct PnC_CLResIdentificationModeType				PnC_CLResIdentificationMode;
	struct Dynamic_CSResControlModeType					Dynamic_CSResControlMode;
	struct Scheduled_CSReqControlModeType				Scheduled_CSReqControlMode;
};
/****CableCheckRequest (DC Only)****/
struct CableCheckRequest_DIN70121
{
	struct DC_EVStatusType_DIN70121						DC_EVStatus;
};
struct CableCheckRequest_ISO15118_2014
{
	struct DC_EVStatusType_ISO15118_2014 					DC_EVStatus;
};
struct CableCheckRequest_ISO15118_2018
{
	//No member in standard
};
/****CableCheckResponse (DC Only)****/
struct CableCheckResponse_DIN70121
{
	enum ResponseCodeType_DIN70121					ResponseCode;
	struct DC_EVSEStatusType_DIN70121					DC_EVSEStatus;
	enum EVSEProcessingType_DIN70121					EVSEProcessing;
};
struct CableCheckResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014				ResponseCode;
	struct DC_EVSEStatusType_ISO15118_2014				DC_EVSEStatus;
	enum EVSEProcessingType_ISO15118_2014				EVSEProcessing;
};
struct CableCheckResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018				ResponseCode;
	struct EVSEStatusType								EVSEStatus;					//Optional
	enum ProcessingType								EVSEProcessing;
};
/****PreChargeRequest (DC Only)****/
struct PreChargeRequest_DIN70121
{
	struct DC_EVStatusType_DIN70121						DC_EVStatus;
	struct PhysicalValueType_DIN70121						EVTargetVoltage;
	struct PhysicalValueType_DIN70121						EVTargetCurrent;
};
struct PreChargeRequest_ISO15118_2014
{
	struct DC_EVStatusType_ISO15118_2014 					DC_EVStatus;
	struct PhysicalValueType_ISO15118_2014					EVTargetVoltage;
	struct PhysicalValueType_ISO15118_2014					EVTargetCurrent;
};
struct PreChargeRequest_ISO15118_2018
{
	struct PhysicalValueType_ISO15118_2018					EVTargetVoltage;
	struct PhysicalValueType_ISO15118_2018					EVTargetCurrent;
};
/****PreChargeResponse (DC Only)****/
struct PreChargeResponse_DIN70121
{
	enum ResponseCodeType_DIN70121					ResponseCode;
	struct DC_EVSEStatusType_DIN70121					DC_EVSEStatus;
	struct PhysicalValueType_DIN70121						EVSEPresentVoltage;
};
struct PreChargeResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014				ResponseCode;
	struct DC_EVSEStatusType_ISO15118_2014				DC_EVSEStatus;
	struct PhysicalValueType_ISO15118_2014					EVSEPresentVoltage;
};
struct PreChargeResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018				ResponseCode;
	struct EVSEStatusType								EVSEStatus;					//Optional
	struct PhysicalValueType_ISO15118_2018					EVSEPresentVoltage;
};
/****CurrentDemandRequest (DC Only)****/
struct CurrentDemandRequest_DIN70121
{
	struct DC_EVStatusType_DIN70121						DC_EVStatus;
	struct PhysicalValueType_DIN70121						EVTargetCurrent;
	struct PhysicalValueType_DIN70121						EVMaximumVoltageLimit;		//Optional
	struct PhysicalValueType_DIN70121						EVMaximumCurrentLimit;		//Optional
	struct PhysicalValueType_DIN70121						EVMaximumPowerLimit;			//Optional
	BOOL											BulkChargingComplete;			//Optional
	BOOL											ChargingComplete;
	struct PhysicalValueType_DIN70121						RemainingTimeToFullSoC;		//Optional
	struct PhysicalValueType_DIN70121						RemainingTimeToBulkSoC;		//Optional
	struct PhysicalValueType_DIN70121						EVTargetVoltage;
};
struct CurrentDemandRequest_ISO15118_2014
{
	struct DC_EVStatusType_ISO15118_2014 					DC_EVStatus;
	struct PhysicalValueType_ISO15118_2014					EVTargetCurrent;
	struct PhysicalValueType_ISO15118_2014					EVMaximumVoltageLimit;		//Optional
	struct PhysicalValueType_ISO15118_2014					EVMaximumCurrentLimit;		//Optional
	struct PhysicalValueType_ISO15118_2014					EVMaximumPowerLimit;			//Optional
	BOOL											BulkChargingComplete;			//Optional
	BOOL											ChargingComplete;
	struct PhysicalValueType_ISO15118_2014					RemainingTimeToFullSoC;		//Optional
	struct PhysicalValueType_ISO15118_2014					RemainingTimeToBulkSoC;		//Optional
	struct PhysicalValueType_ISO15118_2014					EVTargetVoltage;
};
struct CurrentDemandRequest_ISO15118_2018
{
	struct DisplayParametersType							DisplayParameters;				//Optional
	struct PnC_CLReqIdentificationModeType				PnC_CLReqIdentificationMode;
	struct Dynamic_CSReqControlModeType				Dynamic_CDReqControlMode;
	struct Scheduled_CSReqControlModeType				Scheduled_CDReqControlMode;
};
/****CurrentDemandResponse (DC Only)****/
struct CurrentDemandResponse_DIN70121
{
	enum ResponseCodeType_DIN70121					ResponseCode;
	struct DC_EVSEStatusType_DIN70121					DC_EVSEStatus;
	struct PhysicalValueType_DIN70121						EVSEPresentVoltage;
	struct PhysicalValueType_DIN70121						EVSEPresentCurrent;
	BOOL											EVSECurrentLimitAchieved;
	BOOL											EVSEVoltageLimitAchieved;
	BOOL											EVSEPowerLimitAchieved;
	struct PhysicalValueType_DIN70121						EVSEMaximumVoltageLimit;		//Optional
	struct PhysicalValueType_DIN70121						EVSEMaximumCurrentLimit;		//Optional
	struct PhysicalValueType_DIN70121						EVSEMaximumPowerLimit;		//Optional
};
struct CurrentDemandResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014				ResponseCode;
	struct DC_EVSEStatusType_ISO15118_2014				DC_EVSEStatus;
	struct PhysicalValueType_ISO15118_2014					EVSEPresentVoltage;
	struct PhysicalValueType_ISO15118_2014					EVSEPresentCurrent;
	BOOL											EVSECurrentLimitAchieved;
	BOOL											EVSEVoltageLimitAchieved;
	BOOL											EVSEPowerLimitAchieved;
	struct PhysicalValueType_ISO15118_2014					EVSEMaximumVoltageLimit;		//Optional
	struct PhysicalValueType_ISO15118_2014					EVSEMaximumCurrentLimit;		//Optional
	struct PhysicalValueType_ISO15118_2014					EVSEMaximumPowerLimit;		//Optional
	unsigned char										EVSEID[40];			//DIN70121=>Max length:32,	ISO15118=>min length:7, max length:37
	short 											SAScheduleTupleID;
	struct MeterInfoType_ISO15118_2014					MeterInfo;			//Optional
	BOOL											ReceiptRequired;		//Optional
};
struct CurrentDemandResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018				ResponseCode;
	struct EVSEStatusType								EVSEStatus;						//Optional
	struct PhysicalValueType_ISO15118_2018					EVSEPresentVoltage;
	struct PhysicalValueType_ISO15118_2018					EVSEPresentCurrent;
	BOOL											EVSECurrentLimitAchieved;
	BOOL											EVSEVoltageLimitAchieved;
	BOOL											EVSEPowerLimitAchieved;
	struct PhysicalValueType_ISO15118_2018					EVSEMaximumChargeVoltage;		//Optional
	struct PhysicalValueType_ISO15118_2018					EVSEMaximumChargeCurrent;		//Optional
	struct PhysicalValueType_ISO15118_2018					EVSEMaximumChargePower;			//Optional
	unsigned char										EVSEID[40];						//DIN70121=>Max length:32,	ISO15118=>min length:7, max length:37
	struct PnC_CLResIdentificationModeType				PnC_CLResIdentificationMode;
	struct Scheduled_CDResControlModeType				Scheduled_CDResControlMode;
};
/****WeldingDetectionRequest (DC Only)*****/
struct WeldingDetectionRequest_DIN70121
{
	struct DC_EVStatusType_DIN70121						DC_EVStatus;
};
struct WeldingDetectionRequest_ISO15118_2014
{
	struct DC_EVStatusType_ISO15118_2014 					DC_EVStatus;
};
struct WeldingDetectionRequest_ISO15118_2018
{
	//No member in Standard
};
/****WeldingDetectionResponse (DC Only)****/
struct WeldingDetectionResponse_DIN70121
{
	enum ResponseCodeType_DIN70121					ResponseCode;
	struct DC_EVSEStatusType_DIN70121					DC_EVSEStatus;
	struct PhysicalValueType_DIN70121						EVSEPresentVoltage;
};
struct WeldingDetectionResponse_ISO15118_2014
{
	enum ResponseCodeType_ISO15118_2014				ResponseCode;
	struct DC_EVSEStatusType_ISO15118_2014				DC_EVSEStatus;
	struct PhysicalValueType_ISO15118_2014					EVSEPresentVoltage;
};
struct WeldingDetectionResponse_ISO15118_2018
{
	enum ResponseCodeType_ISO15118_2018				ResponseCode;
	struct EVSEStatusType								EVSEStatus;						//Optional
	struct PhysicalValueType_ISO15118_2018					EVSEPresentVoltage;
};
/****FinePositioningSetupRequest (WPT Only)****/
struct FinePositioningSetupRequest_ISO15118_2018
{
	struct LFA_EVFinePositioningSetupParametersType			LFA_EVFinePositioningSetupParameters;	//Optional
};
/****FinePositioningSetupResponse (WPT Only)****/
struct FinePositioningSetupResponse_ISO15118_2018
{
	//NOT complete yet,  to be continue.....
};


struct V2GMessageType_DIN70121
{
	unsigned char 	SelfTest_Comp;
	unsigned char	version[16];
	unsigned char											PresentMsgFlowStatus;
														/* 0: Idle(wait B2 state), 1: CM_SLAC_PARM.REQ, 2: CM_SLAC_PARM.CNF, 3: CM_START_ATTEN_CHAR.IND
														    4: CM_MNBC_SOUND.IND, 5: CM_ATTEN_CHAR.IND, 6: CM_ATTEN_CHAR.RSP, 7: CM_VALIDATE.REQ
														    8: CM_VALIDATE.CNF, 9: CM_SLAC_MATCH.REQ, 10: CM_SLAC_MATCH.CNF, 11: CM_AMP_MAP.REQ
														    12: CM_AMP_MAP.CNF, 13: SLACC/SDP/TCP connection,
														    16: SupportedAppProtocolRequest, 17: SupportedAppProtocolResponse, 18: SessionSetupRequest
														    19: SessionSetupResponse, 20: ServiceDiscoveryRequest, 21: ServiceDiscoveryResponse
														    22: ServiceDetailRequest, 23: ServiceDetailResponse
														    24: ServiceAndPaymentSelectionRequest/ServiceSelectionRequest, 25: ServiceAndPaymentSelectionResponse/ServiceSelectionResponse
														    26: PaymentDetailsRequest/IdentificationDetailsRequest;, 27: PaymentDetailsResponse/IdentificationDetailsResponse,
														     28: AuthorizationRequest, 29: AuthorizationResponse,
														    30: CertificateUpdateRequest, 31: CertificateUpdateResponse, 32:CertificateInstallationRequest, 33: CertificateInstallationResponse
														    34: ChargeParameterDiscoveryRequest, 35: ChargeParameterDiscoveryResponse
														    36: CableCheckRequest, 37: CableCheckResponse, 38: PreChargeRequest, 39: PreChargeResponse
														    40: PowerDeliveryRequest start, 41: PowerDeliveryResponse start, 42: ChargingStatusRequest, 43: ChargingStatusResponse
														    44: CurrentDemandRequest, 45: CurrentDemandResponse, 46: MeteringReceiptRequest, 47: MeteringReceiptResponse
														    48: PowerDeliveryRequest end, 49: PowerDeliveryRequest end, 50: WeldingDetectionRequest, 51: WeldingDetectionResponse,
														    52: SessionStopRequest, 53: SessionStopResponse
														   253: Performance Timeout, 254: Sequence Timeout, 255: Fault
														*/
	struct SupportedAppProtocolRequest_DIN70121 			SupportedAppProtocolRequest;
	struct SupportedAppProtocolResponse_DIN70121 			SupportedAppProtocolResponse;
	struct SessionSetupRequest_DIN70121  					SessionSetupRequest;
	struct SessionSetupResponse_DIN70121   				SessionSetupResponse;
	struct ServiceDiscoveryRequest_DIN70121    				ServiceDiscoveryRequest;
	struct ServiceDiscoveryResponse_DIN70121    				ServiceDiscoveryResponse;
	struct ServiceAndPaymentSelectionRequest_DIN70121		ServiceAndPaymentSelectionRequest;
	struct ServiceAndPaymentSelectionResponse_DIN70121		ServiceAndPaymentSelectionResponse;
	struct ContractAuthenticationRequest_DIN70121			ContractAuthenticationRequest;
	struct ContractAuthenticationResponse_DIN70121	 		ContractAuthenticationResponse;
	struct ChargeParameterDiscoveryRequest_DIN70121		ChargeParameterDiscoveryRequest;
	struct ChargeParameterDiscoveryResponse_DIN70121		ChargeParameterDiscoveryResponse;
	struct CableCheckRequest_DIN70121					CableCheckRequest;
	struct CableCheckResponse_DIN70121					CableCheckResponse;
	struct PreChargeRequest_DIN70121					PreChargeRequest;
	struct PreChargeResponse_DIN70121 					PreChargeResponse;
	struct PowerDeliveryRequest_DIN70121					PowerDeliveryRequest;
	struct PowerDeliveryResponse_DIN70121	   				PowerDeliveryResponse;
	struct CurrentDemandRequest_DIN70121 				CurrentDemandRequest;
	struct CurrentDemandResponse_DIN70121				CurrentDemandResponse;
	struct WeldingDetectionRequest_DIN70121 				WeldingDetectionRequest;
	struct WeldingDetectionResponse_DIN70121  			WeldingDetectionResponse;
	struct SessionStopRequest_DIN70121					SessionStopRequest;
	struct SessionStopResponse_DIN70121	    				SessionStopResponse;
};

struct V2GMessageType_ISO15118_2014
{
	unsigned char											PresentMsgFlowStatus;
														/* 0: Idle(wait B2 state), 1: CM_SLAC_PARM.REQ, 2: CM_SLAC_PARM.CNF, 3: CM_START_ATTEN_CHAR.IND
														    4: CM_MNBC_SOUND.IND, 5: CM_ATTEN_CHAR.IND, 6: CM_ATTEN_CHAR.RSP, 7: CM_VALIDATE.REQ
														    8: CM_VALIDATE.CNF, 9: CM_SLAC_MATCH.REQ, 10: CM_SLAC_MATCH.CNF, 11: CM_AMP_MAP.REQ
														    12: CM_AMP_MAP.CNF, 13: SLACC/SDP/TCP connection,
														    16: SupportedAppProtocolRequest, 17: SupportedAppProtocolResponse, 18: SessionSetupRequest
														    19: SessionSetupResponse, 20: ServiceDiscoveryRequest, 21: ServiceDiscoveryResponse
														    22: ServiceDetailRequest, 23: ServiceDetailResponse
														    24: ServiceAndPaymentSelectionRequest/ServiceSelectionRequest, 25: ServiceAndPaymentSelectionResponse/ServiceSelectionResponse
														    26: PaymentDetailsRequest/IdentificationDetailsRequest;, 27: PaymentDetailsResponse/IdentificationDetailsResponse,
														     28: AuthorizationRequest, 29: AuthorizationResponse,
														    30: CertificateUpdateRequest, 31: CertificateUpdateResponse, 32:CertificateInstallationRequest, 33: CertificateInstallationResponse
														    34: ChargeParameterDiscoveryRequest, 35: ChargeParameterDiscoveryResponse
														    36: CableCheckRequest, 37: CableCheckResponse, 38: PreChargeRequest, 39: PreChargeResponse
														    40: PowerDeliveryRequest start, 41: PowerDeliveryResponse start, 42: ChargingStatusRequest, 43: ChargingStatusResponse
														    44: CurrentDemandRequest, 45: CurrentDemandResponse, 46: MeteringReceiptRequest, 47: MeteringReceiptResponse
														    48: PowerDeliveryRequest end, 49: PowerDeliveryRequest end, 50: WeldingDetectionRequest, 51: WeldingDetectionResponse,
														    52: SessionStopRequest, 53: SessionStopResponse
														   253: Performance Timeout, 254: Sequence Timeout, 255: Fault
														*/
	struct SupportedAppProtocolRequest_ISO15118_2014 			SupportedAppProtocolRequest;
	struct SupportedAppProtocolResponse_ISO15118_2014 			SupportedAppProtocolResponse;
	struct SessionSetupRequest_ISO15118_2014  					SessionSetupRequest;
	struct SessionSetupResponse_ISO15118_2014   				SessionSetupResponse;
	struct ServiceDiscoveryRequest_ISO15118_2014    				ServiceDiscoveryRequest;
	struct ServiceDiscoveryResponse_ISO15118_2014    				ServiceDiscoveryResponse;
	struct ServiceDetailRequest_ISO15118_2014 					ServiceDetailRequest;
	struct ServiceDetailResponse_ISO15118_2014					ServiceDetailResponse;
	struct ServiceAndPaymentSelectionRequest_ISO15118_2014 		ServiceAndPaymentSelectionRequest;
	struct ServiceAndPaymentSelectionResponse_ISO15118_2014  	ServiceAndPaymentSelectionResponse;
	struct PaymentDetailsRequest_ISO15118_2014 				PaymentDetailsRequest;
	struct PaymentDetailsResponse_ISO15118_2014 				PaymentDetailsResponse;
	struct AuthorizationRequest_ISO15118_2014					AuthorizationRequest;
	struct AuthorizationResponse_ISO15118_2014					AuthorizationResponse;
	struct CertificateUpdateRequest_ISO15118_2014				CertificateUpdateRequest;
	struct CertificateUpdateResponse_ISO15118_2014				CertificateUpdateResponse;
	struct CertificateInstallationRequest_ISO15118_2014			CertificateInstallationRequest;
	struct CertificateInstallationResponse_ISO15118_2014			CertificateInstallationResponse;
	struct ChargeParameterDiscoveryRequest_ISO15118_2014 		ChargeParameterDiscoveryRequest;
	struct ChargeParameterDiscoveryResponse_ISO15118_2014  		ChargeParameterDiscoveryResponse;
	struct CableCheckRequest_ISO15118_2014 					CableCheckRequest;
	struct CableCheckResponse_ISO15118_2014  					CableCheckResponse;
	struct PreChargeRequest_ISO15118_2014 					PreChargeRequest;
	struct PreChargeResponse_ISO15118_2014					PreChargeResponse;
	struct PowerDeliveryRequest_ISO15118_2014					PowerDeliveryRequest;
	struct PowerDeliveryResponse_ISO15118_2014					PowerDeliveryResponse;
	struct ChargingStatusRequest_ISO15118_2014	  				ChargingStatusRequest;
	struct ChargingStatusResponse_ISO15118_2014				ChargingStatusResponse;
	struct CurrentDemandRequest_ISO15118_2014	 			CurrentDemandRequest;
	struct CurrentDemandResponse_ISO15118_2014				CurrentDemandResponse;
	struct MeteringReceiptRequest_ISO15118_2014				MeteringReceiptRequest;
	struct MeteringReceiptResponse_ISO15118_2014				MeteringReceiptResponse;
	struct WeldingDetectionRequest_ISO15118_2014 				WeldingDetectionRequest;
	struct WeldingDetectionResponse_ISO15118_2014  			WeldingDetectionResponse;
	struct SessionStopRequest_ISO15118_2014 					SessionStopRequest;
	struct SessionStopResponse_ISO15118_2014					SessionStopResponse;
};
struct V2GMessageType_ISO15118_2018
{
	unsigned char										PresentMsgFlowStatus;
													/* 0: Idle(wait B2 state), 1: CM_SLAC_PARM.REQ, 2: CM_SLAC_PARM.CNF, 3: CM_START_ATTEN_CHAR.IND
													    4: CM_MNBC_SOUND.IND, 5: CM_ATTEN_CHAR.IND, 6: CM_ATTEN_CHAR.RSP, 7: CM_VALIDATE.REQ
													    8: CM_VALIDATE.CNF, 9: CM_SLAC_MATCH.REQ, 10: CM_SLAC_MATCH.CNF, 11: CM_AMP_MAP.REQ
													    12: CM_AMP_MAP.CNF, 13: SLACC/SDP/TCP connection,
													    16: SupportedAppProtocolRequest, 17: SupportedAppProtocolResponse, 18: SessionSetupRequest
													    19: SessionSetupResponse, 20: ServiceDiscoveryRequest, 21: ServiceDiscoveryResponse
													    22: ServiceDetailRequest, 23: ServiceDetailResponse
													    24: ServiceAndPaymentSelectionRequest/ServiceSelectionRequest, 25: ServiceAndPaymentSelectionResponse/ServiceSelectionResponse
													    26: PaymentDetailsRequest/IdentificationDetailsRequest;, 27: PaymentDetailsResponse/IdentificationDetailsResponse,
													     28: AuthorizationRequest, 29: AuthorizationResponse,
													    30: CertificateUpdateRequest, 31: CertificateUpdateResponse, 32:CertificateInstallationRequest, 33: CertificateInstallationResponse
													    34: ChargeParameterDiscoveryRequest, 35: ChargeParameterDiscoveryResponse
													    36: CableCheckRequest, 37: CableCheckResponse, 38: PreChargeRequest, 39: PreChargeResponse
													    40: PowerDeliveryRequest start, 41: PowerDeliveryResponse start, 42: ChargingStatusRequest, 43: ChargingStatusResponse
													    44: CurrentDemandRequest, 45: CurrentDemandResponse, 46: MeteringReceiptRequest, 47: MeteringReceiptResponse
													    48: PowerDeliveryRequest end, 49: PowerDeliveryRequest end, 50: WeldingDetectionRequest, 51: WeldingDetectionResponse,
													    52: SessionStopRequest, 53: SessionStopResponse
													   253: Performance Timeout, 254: Sequence Timeout, 255: Fault
													*/
	struct SupportedAppProtocolRequest_ISO15118_2018			SupportedAppProtocolRequest;
	struct SupportedAppProtocolResponse_ISO15118_2018 			SupportedAppProtocolResponse;
	struct SessionSetupRequest_ISO15118_2018					SessionSetupRequest;
	struct SessionSetupResponse_ISO15118_2018  					SessionSetupResponse;
	struct ServiceDiscoveryRequest_ISO15118_2018    				ServiceDiscoveryRequest;
	struct ServiceDiscoveryResponse_ISO15118_2018    				ServiceDiscoveryResponse;
	struct ServiceDetailRequest_ISO15118_2018 					ServiceDetailRequest;
	struct ServiceDetailResponse_ISO15118_2018					ServiceDetailResponse;
	struct ServiceSelectionRequest_ISO15118_2018				ServiceSelectionRequest;
	struct ServiceSelectionResponse_ISO15118_2018				ServiceSelectionResponse;
	struct IdentificationDetailsRequest_ISO15118_2018  			IdentificationDetailsRequest;
	struct IdentificationDetailsResponse_ISO15118_2018  			IdentificationDetailsResponse;
	struct AuthorizationRequest_ISO15118_2018  					AuthorizationRequest;
	struct AuthorizationResponse_ISO15118_2018					AuthorizationResponse;
	struct CertificateInstallationRequest_ISO15118_2018			CertificateInstallationRequest;
	struct CertificateInstallationResponse_ISO15118_2018			CertificateInstallationResponse;
	struct ChargeParameterDiscoveryRequest_ISO15118_2018 		ChargeParameterDiscoveryRequest;
	struct ChargeParameterDiscoveryResponse_ISO15118_2018  		ChargeParameterDiscoveryResponse;
	struct CableCheckRequest_ISO15118_2018 					CableCheckRequest;
	struct CableCheckResponse_ISO15118_2018 					CableCheckResponse;
	struct PreChargeRequest_ISO15118_2018 					PreChargeRequest;
	struct PreChargeResponse_ISO15118_2018					PreChargeResponse;
	struct PowerDeliveryRequest_ISO15118_2018					PowerDeliveryRequest;
	struct PowerDeliveryResponse_ISO15118_2018					PowerDeliveryResponse;
	struct ChargingStatusRequest_ISO15118_2018	  				ChargingStatusRequest;
	struct ChargingStatusResponse_ISO15118_2018				ChargingStatusResponse;
	struct CurrentDemandRequest_ISO15118_2018	 			CurrentDemandRequest;
	struct CurrentDemandResponse_ISO15118_2018				CurrentDemandResponse;
	struct MeteringReceiptRequest_ISO15118_2018				MeteringReceiptRequest;
	struct MeteringReceiptResponse_ISO15118_2018				MeteringReceiptResponse;
	struct WeldingDetectionRequest_ISO15118_2018 				WeldingDetectionRequest;
	struct WeldingDetectionResponse_ISO15118_2018  			WeldingDetectionResponse;
	struct SessionStopRequest_ISO15118_2018 					SessionStopRequest;
	struct SessionStopResponse_ISO15118_2018					SessionStopResponse;
};

struct CcsData
{
	unsigned char 							CommProtocol;	// 1: V2GMessage_DIN70121, 2:V2GMessage_ISO15118_2014, 3:V2GMessage_ISO15118_2018
	struct V2GMessageType_DIN70121			V2GMessage_DIN70121[CCS_QUANTITY];
	struct V2GMessageType_ISO15118_2014  		V2GMessage_ISO15118_2014[CCS_QUANTITY];
	struct V2GMessageType_ISO15118_2018  		V2GMessage_ISO15118_2018[CCS_QUANTITY];
};
/**************************************************************************************/
/***************STM32F407 Communication Share memory**************************/
/**************************************************************************************/
struct PrimaryMcuData
{
    unsigned char   SelfTest_Comp;
    unsigned char   version[16];                                //STM32F407 firmware version
    unsigned int    InputVoltage;                               //value comes from external meter
    unsigned int    InputCurrent;                               //value comes from external meter
    union
    {
        unsigned char OutputDrvValue[1];
        struct
        {
            //OutputDrvValue[0]
            unsigned char OnButtonLedDrv:1;                     //bit 0,    H: ON,      L:OFF
            unsigned char OffButtonLedDrv:1;                    //bit 1,    H: ON,      L:OFF
            unsigned char SystemLed1Drv:1;                      //bit 2,    H: ON,      L:OFF
            unsigned char SystemLed2Drv:1;                      //bit 3,    H: ON,      L:OFF
            unsigned char SystemLed3Drv:1;                      //bit 4,    H: ON,      L:OFF
            unsigned char SystemLed4Drv:1;                      //bit 5,    H: ON,      L:OFF
            unsigned char AcContactorDrv:1;                     //bit 6,    H: ON,      L:OFF
            unsigned char:1;                                    //bit 7 reserved
        }bits;
    }OutputDrv;
    union
    {
        unsigned char InputDetValue[2];
        struct
        {
            //InputDetValue[0]
            unsigned char AcContactorDetec:1;                   //bit 0,    H: ON,      L:OFF
            unsigned char AcMainBreakerDetec:1;                 //bit 1,    H: ON,      L:OFF
            unsigned char SpdDetec:1;                           //bit 2,    H: ON,      L:OFF
            unsigned char DoorOpen:1;                           //bit 3,    H: Open,    L:Close
            unsigned char Gfd1:1;                               //bit 4,    H: Trigger, L:Normal
            unsigned char Gfd2:1;                               //bit 5,    H: Trigger, L:Normal
            unsigned char Button1:1;                            //bit 6 ,   H: Push,    L:Release
            unsigned char Button2:1;                            //bit 7,    H: Push,    L:Release
            //InputDetValue[1]
            unsigned char EmergencyButton:1;                    //bit 0,    H: Push,    L:Release
            unsigned char Key0:1;                               //bit 1,    H: ON,      L:OFF
            unsigned char Key1:1;                               //bit 2,    H: ON,      L:OFF
            unsigned char Key2:1;                               //bit 3,    H: ON,      L:OFF
            unsigned char Key3:1;                               //bit 4,    H: ON,      L:OFF
            unsigned char :3;                                   //bit 5~7,  Reserved
        }bits;
    }InputDet;
};
/**************************************************************************************/
/*************Fan power module Communication Share memory******************/
/**************************************************************************************/
struct FanModuleData
{
	unsigned char  SelfTest_Comp;
	unsigned char	version[16];			//fan power module firmware version
	unsigned short	PresentFan1Speed;		//RPM
	unsigned short	PresentFan2Speed;		//RPM
	unsigned short	PresentFan3Speed;		//RPM
	unsigned short	PresentFan4Speed;		//RPM
	unsigned short	SetFan1Speed;			//RPM
	unsigned short	SetFan2Speed;			//RPM
	unsigned short	SetFan3Speed;			//RPM
	unsigned short	SetFan4Speed;			//RPM
	unsigned short	TestFanSpeed;			//RPM
	unsigned char	DiffOfAirPressure;		//pa
	unsigned char	UpdateFW;			//1:do update
};

/**************************************************************************************/
/***********Relay control module Communication Share memory******************/
/**************************************************************************************/
struct RelayModuleData
{
	unsigned char 	SelfTest_Comp;
	unsigned char	version[16];				//relay module firmware version
	unsigned short	InputL1Volt;				//XXXXX.x volt
	unsigned short	InputL2Volt;				//XXXXX.x volt
	unsigned short	InputL3Volt;				//XXXXX.x volt
	unsigned short	Gun1FuseOutputVolt;		//XXXXX.x volt
	unsigned short	Gun2FuseOutputVolt;		//XXXXX.x volt
	unsigned short	Gun1RelayOutputVolt;		//XXXXX.x volt
	unsigned short	Gun2RelayOutputVolt;		//XXXXX.x volt
	unsigned short	Gun1OutputCurrent;		//XXXXX.x amp
	unsigned short	Gun2OutputCurrent;		//XXXXX.x amp
	unsigned char	UpdateFW;				//1:do update
};

/**************************************************************************************/
/***********Led control module Communication Share memory******************/
/**************************************************************************************/
struct LedModuleData
{
	unsigned char 	SelfTest_Comp;
	unsigned char	version[16];				//led module firmware version
	unsigned short	Connect_1_Status;			// Idle : 0, Charging : 1, Alarm : 2
	unsigned short	Connect_2_Status;			// Idle : 0, Charging : 1, Alarm : 2
	unsigned short	EnableFunc;					// reserved
};

/**************************************************************************************/
/************************OCPP Share memory***************************************/
/**************************************************************************************/
struct StructIdTagInfo
{
	unsigned char 	ExpiryDate[36];
	unsigned char 	ParentIdTag[21];
	unsigned char 	Status[16];		//Accepted, Blocked, Expired, Invalid, ConcurrentTx
};
struct StructLocalAuthorizationList
{
	unsigned char 			IdTag[21];
	struct StructIdTagInfo	IdTagInfo;
};
struct StructSampledValue
{
	unsigned char 			Value[128];
	unsigned char 			Context[30];//Interruption.Begin, Interruption.End, Sample.Clock, Sample.Periodic, Transaction.Begin, Transaction.End, Trigger, Other
	unsigned char 			Format[16];//Raw,SignedData
	unsigned char 			Measurand[40];/*	"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",
										"Power.Active.Export",
										"Power.Active.Import",
										"Power.Offered",
										"Power.Reactive.Export",
										"Power.Reactive.Import",
										"Power.Factor",
										"Current.Import",
										"Current.Export",
										"Current.Offered",
										"Voltage",
										"Frequency",
										"Temperature",
										"SoC",
										"RPM"
										*/

	unsigned char 			Phase[10];	/*		"L1",
										"L2",
										"L3",
										"N",
										"L1-N",
										"L2-N",
										"L3-N",
										"L1-L2",
										"L2-L3",
										"L3-L1"
								*/

	unsigned char 			Location[10];		//Cable,EV,Inlet,Outlet,Body
	unsigned char 			Unit[20];	/*		"Wh",
										"kWh",
										"varh",
										"kvarh",
										"W",
										"kW",
										"VA",
										"kVA",
										"var",
										"kvar",
										"A",
										"V",
										"K",
										"Celcius",
										"Fahrenheit",
										"Percent"
								*/
};
struct StructMeterValue
{
	unsigned char 				TimeStamp[36];
	struct StructSampledValue	SampledValue[20];
};
struct StructConfigurationKeyItems
{
	unsigned char 	Item[50];
};
struct StructConfigurationKey
{
	unsigned char 	Key[50];
	unsigned char 	ReadOnly[8];	//boolean
	unsigned char 	Value[500];
};
struct StructChargingSchedulePeriod
{
	int		StartPeriod;
	float 	Limit;//0.1;
	int		NumberPhases;
};
struct StructChargingSchedule
{
	int											Duration;
	unsigned char 								StartSchedule[36];
	unsigned char 								ChargingRateUnit[4];		//A, W
	struct StructChargingSchedulePeriod			ChargingSchedulePeriod[10];
	float 										MinChargingRate;			//0.1;
};
struct StructChargingProfile
{
	int								ChargingProfileId;
	int								TransactionId;
	int								StackLevel;
	unsigned char 					ChargingProfilePurpose[24];	//ChargePointMaxProfile, TxDefaultProfile, TxProfile
	unsigned char 					ChargingProfileKind[12];		//Absolute, Recurring, Relative
	unsigned char 					RecurrencyKind[8];			//Daily, Weekly
	unsigned char 					ValidFrom[36];
	unsigned char 					ValidTo[36];
	struct StructChargingSchedule	ChargingSchedule;
};

struct StructBootNotification
{
	unsigned char CpVendor[20];				//chargePointVendor				//mandatory
	unsigned char CpModel[20];				//chargePointModel				//mandatory
	unsigned char CpSN[25];					//chargePointSerialNumber
	unsigned char CbSN[25];					//chargeBoxSerialNumber
	unsigned char CpFwVersion[50];			//firmwareVersion
	unsigned char CpIccid[22];				//iccid
	unsigned char CpImsi[20];				//imsi
	unsigned char CpMeterType[25];			//meterType
	unsigned char CpMeterSerialNumber[25];	//meterSerialNumber
	unsigned char ResponseStatus[16];			//Accepted, Pending, Rejected
	unsigned char ResponseCurrentTime[36];	//currentTime					//mandatory
	int 			ResponseHeartbeatInterval;	//interval						//mandatory

};
struct StructHeartbeat
{
	unsigned char 				ResponseCurrentTime[36];
};
struct StructAuthorize
{
	unsigned char 				IdTag[21];
	struct StructIdTagInfo		ResponseIdTagInfo;
};
struct StructStartTransaction
{
	int 						ConnectorId;
	unsigned char 				IdTag[21];
	int 						MeterStart;
	int 						ReservationId;
	unsigned char 				Timestamp[36];
	struct StructIdTagInfo		ResponseIdTagInfo;
	int 						ResponseTransactionId;
};
struct StructStopTransaction
{
	unsigned char 				IdTag[21];
	int 						MeterStop;
	unsigned char 				Timestamp[36];
	int 						TransactionId;
	unsigned char 				StopReason[20];				/*	"EmergencyStop",
															"EVDisconnected",
															"HardReset",
															"Local",
															"Other",
															"PowerLoss",
															"Reboot",
															"Remote",
															"SoftReset",
															"UnlockCommand",
															"DeAuthorized"
														*/
	struct StructMeterValue		TransactionData[1];
	struct StructIdTagInfo		ResponseIdTagInfo;
};

struct StructStatusNotification
{
	int 			ConnectorId;
	unsigned char 	ErrorCode[25];				/*	"ConnectorLockFailure",
								                "EVCommunicationError",
								                "GroundFailure",
								                "HighTemperature",
								                "InternalError",
								                "LocalListConflict",
								                "NoError",
								                "OtherError",
								                "OverCurrentFailure",
								                "PowerMeterFailure",
								                "PowerSwitchFailure",
								                "ReaderFailure",
								                "ResetFailure",
								                "UnderVoltage",
								                "OverVoltage",
								                "WeakSignal"
								            */

	unsigned char 	Info[50];
	unsigned char 	Status[20];					/*	"Available",
								                "Preparing",
								                "Charging",
								                "SuspendedEVSE",
								                "SuspendedEV",
								                "Finishing",
								                "Reserved",
								                "Unavailable",
								                "Faulted"
								            */

	unsigned char 	Timestamp[36];
	unsigned char 	VendorId[256];
	unsigned char 	VendorErrorCode[50];
};


struct StructCancelReservation
{
	int 				ReservationId;
	unsigned char 		ResponseStatus[16];		//Accepted, Rejected
	unsigned char 		guid[37];
};
struct StructChangeAvailability
{
	int 				ConnectorId;
	unsigned char 		Type[16];					//Inoperative, Operative
	unsigned char 		ResponseStatus[16];		//Accepted, Rejected, Scheduled
	unsigned char 		guid[37];
};
struct StructChangeConfiguration
{
	unsigned char Key[50];
	unsigned char Value[500];
	unsigned char ResponseStatus[16];		//Accepted, Rejected, RebootRequired, NotSupported
};
struct StructClearCache
{
	unsigned char ResponseStatus[16];		//Accepted, Rejected
};
struct StructClearChargingProfile
{
	int			 			Id;
	int						ConnectorId;
	unsigned char 			ChargingProfilePurpose[24];	//ChargePointMaxProfile, TxDefaultProfile, TxProfile
	int			 			StackLevel;
	unsigned char 			ResponseStatus[16];			//Accepted, Unknown
};
struct StructDataTransfer
{
	unsigned char VendorId[256];
	unsigned char MessageId[52];
	unsigned char Data[512];
	unsigned char ResponseStatus[18];	//Accepted, Rejected,UnknownMessageId,UnknownVendorId
	unsigned char ResponseData[512];
};
struct StructDiagnosticsStatusNotification
{
	unsigned char Status[16];		//Idle,Uploaded,UploadFailed,Uploading
};
struct StructFirmwareStatusNotification
{
	unsigned char Status[20];			//Downloaded,DownloadFailed,Downloading,Idle,InstallationFailed,Installing,Installed
};
struct StructGetCompositeSchedule
{
	int 							ConnectorId;
	int 							Duration;
	unsigned char					ChargingRateUnit[4];		//A,W
	unsigned char 					ResponseStatus[12];			//Accepted,Rejected
	int 							ResponseConnectorId;
	unsigned char					ResponseScheduleStart[36];
	struct StructChargingSchedule	ResponseChargingSchedule;
};
struct StructGetConfiguration
{
	struct StructConfigurationKeyItems 			*Key;
	struct StructConfigurationKey			 	*ResponseConfigurationKey;
	struct StructConfigurationKeyItems 			*ResponseUnknownKey;

};
struct StructGetDiagnostics
{
	unsigned char 			Location[256];
	int 					Retries;
	int						RetryInterval;
	unsigned char 			StartTime[36];
	unsigned char 			StopTime[36];
	unsigned char 			ResponseFileName[256];
};
struct StructGetLocalListVersion
{
	int ResponseListVersion;
};
struct StructMeterValues
{
	int					 			ConnectorId;
	int 							TransactionId;
	struct StructMeterValue			MeterValue[1];
};
struct StructRemoteStartTransaction
{
	int								ConnectorId;
	unsigned char 					IdTag[21];
	struct StructChargingProfile	ChargingProfile;
	unsigned char 					ResponseStatus[10];	//Accepted,	Rejected
	unsigned char 					guid[37];
};
struct StructRemoteStopTransaction
{
	int 				TransactionId;
	unsigned char 		ResponseStatus[10];	//Accepted,	Rejected
};
struct StructReserveNow
{
	int			 		ConnectorId;
	unsigned char 		ExpiryDate[36];
	unsigned char 		IdTag[21];
	unsigned char 		ParentIdTag[21];
	int					ReservationId;
	unsigned char 		ResponseStatus[12];		//Accepted, Faulted, Occupied, Rejected, Unavailable
	unsigned char 		guid[37];   			//OCPP Server request message uuid
};
struct StructReset
{
	unsigned char		Type[8];			//Hard,	Soft
	unsigned char 		ResponseStatus[10];	//Accepted,	Rejected
	unsigned char 		guid[37];   		//OCPP Server request message uuid
};
struct StructSendLocalList
{
	int										ListVersion;
	unsigned char 							UpdateType[16];	//Differential,	Full
	struct StructLocalAuthorizationList		*LocalAuthorizationList;
	unsigned char 							ResponseStatus[16];	//Accepted,	Failed, NotSupported, VersionMismatch
};
struct StructSetChargingProfile
{
	int 								ConnectorId;
	struct StructChargingProfile		ChargingProfile;
	unsigned char				 		ResponseStatus[16];	//Accepted,	Rejected, NotSupported
};
struct StructTriggerMessage
{
	unsigned char 		RequestedMessage[32];	/*
											"BootNotification",
											"DiagnosticsStatusNotification",
											"FirmwareStatusNotification",
											"Heartbeat",
											"MeterValues",
											"StatusNotification"
										*/
	int					ConnectorId;
	unsigned char 		ResponseStatus[16];	//Accepted,	Rejected, NotImplemented
};
struct StructUnlockConnector
{
	int					ConnectorId;
	unsigned char 		ResponseStatus[16];	//Unlocked,	UnlockFailed, NotSupported
	unsigned char 		guid[37];   		//OCPP Server request message uuid
};
struct StructUpdateFirmware
{
	unsigned char 		Location[256];
	int					Retries;
	unsigned char 		RetrieveDate[36];
	int 				RetryInterval;
};

struct OCPP16ConfigurationItem
{
	unsigned char 		ItemName[64];
	unsigned char 		ItemAccessibility;//0:RO, 1:RW
	unsigned char 		ItemData[501];//value should be limited in 500 bytes
};

struct OCPP16ConfigurationTable
{
	//please refer to OCPP 1.6 chapter 9
	struct OCPP16ConfigurationItem 			CoreProfile[_CoreProfile_CNT];
	struct OCPP16ConfigurationItem 			LocalAuthListManagementProfile[3];
	struct OCPP16ConfigurationItem 			ReservationProfile[1];
	struct OCPP16ConfigurationItem 			SmartChargingProfile[5];
};


struct StrcutSetUserPrice
{
    unsigned char   idToken[21];
    unsigned char   price[1024];
};

struct ChargingPrice
{
    float kWhPrice;                                 // Price per kWh
    float hourPrice;                                // Price per hour of charging
    float flatFee;                                  // Flat fee for (part of) charging session
};

struct IdlePrice
{
    unsigned int graceMinutes;                      // Grace period in minutes before idle time is charged
    float hourPrice;                                // Price per hour while idle
};

struct NextPeriod
{
    unsigned char atTime[36];                       // Time when these prices become active
    struct ChargingPrice chargingPrice;             // Price components while charging
    struct IdlePrice idlePrice;                     // Price components while idle. Optional if no idle fee charged.
};

struct Triggers
{
    unsigned char atTime[36];                       // Time when these prices become active
    float atEnergykWh;                              // Consumed energy amount in kWh upon which a meter value must be sent
    float atPowerkW;                                // Power threshold in kW when meter value must be sent when crossing in downward or upward direction. Can either
                                                    // be used to trigger a meter value when vehicle stops charging or when vehicle charges at a high power that requires a
                                                    // different tariff.
                                                    // It is recommended to implement a hysteresis around this value to avoid repetitive triggers when the power fluctuates around this level.
    unsigned char atCPStatus[100];
};

struct StrcutRunningCost
{
    int                     txId;                   // Transaction to which this applies
    unsigned char           timestamp[36];          // Timestamp of the meter value upon which this cost is based
    unsigned int            meterValue;             // Meter value (Wh) upon which this cost is based
    float                   cost;                   // Calculated total running cost
    unsigned char           state[16];              // "Charging" or "Idle"
    struct ChargingPrice    chargingPrice;          // Price components while charging
    struct IdlePrice        idlePrice;              // (optional) Price components while not charging. Optional if no idle fee is charged.
    struct NextPeriod       nextPeriod;             // (optional) Pricing for next period
    struct Triggers         triggerMeterValue;      // (optional) Triggers to request a new meter value. Optional if no idle fee charged.
    unsigned char           description[1024];      // Compatible California pricing V1.0
};

struct StrcutFinalCost
{
    int             txId;
    unsigned char   description[1024];

    float           cost;
    unsigned char   priceText[1024];
    unsigned char   qrCodeText[1024];
};

struct StructCost
{
    struct StrcutSetUserPrice       SetUserPrice;
    struct StrcutRunningCost        RunningCost[CONNECTOR_QUANTITY];
    struct StrcutFinalCost          FinalCost[CONNECTOR_QUANTITY];
};

struct CertificateHashDataType
{
    unsigned char hashAlgorithm[8];                             // Required. Used algorithms for the hashes provided.
    unsigned char issuerNameHash[129];                          // Required. hashed value of the IssuerName.
    unsigned char issuerKeyHash[129];                           // Required. Hashed value of the issuers public key
    unsigned char serialNumber[41];                             // Required. The serial number of the certificate.
};

struct LogParametersType
{
    unsigned char remoteLocation[513];                              // Required. The URL of the location at the remote system where the log should be stored.
    unsigned char oldestTimestamp[36];                              // Optional. This contains the date and time of the oldest logging information to include in the diagnostics.
    unsigned char latestTimestamp[36];                              // Optional. This contains the date and time of the latest logging information to include in the diagnostics.
};

struct FirmwareType
{
    unsigned char location[513];                                    // Required. URI defining the origin of the firmware.
    unsigned char retrieveDateTime[36];                             // Required. Date and time at which the firmware shall be retrieved.
    unsigned char installDateTime[36];                              // Optional. Date and time at which the firmware shall be installed.
    unsigned char signingCertificate[5501];                         // Optional. Certificate with which the firmware was signed. X.509 certificate, first DER encoded into binary, and then Base64 encoded.
    unsigned char signature[801];                                   // Optional. Base64 encoded firmware signature.
};

struct StructCertificateSigned
{
    unsigned char certificateChain[10001];
    unsigned char Response_status[16];
};

struct StructDeleteCertificate
{
    struct CertificateHashDataType certificateHashData;
    unsigned char Response_status[16];
};

struct StructExtendedTrigger
{
    unsigned char requestedMessage[32];
    int connectorId;
    unsigned char Response_status[16];
};

struct StructGetInstalledCertificateIds
{
    unsigned char certificateType[32];
    unsigned char Response_status[16];
    struct CertificateHashDataType Response_certificateHashData[3];
};

struct StructGetLog
{
    unsigned char logType[16];
    int requestId;
    int retries;
    int retryInterval;
    struct LogParametersType log;
    unsigned char Response_status[16];
    unsigned char Response_filename[256];
};

struct StructInstallCertificate
{
    unsigned char certificateType[32];
    unsigned char certificate[5501];
    unsigned char Response_status[16];
};

struct StructSignedUpdateFirmware
{
    int retries;
    int retryInterval;
    int requestId;
    struct FirmwareType firmware;
    unsigned char Response_status[16];
};

struct StructLogStatusNotification
{
    unsigned char status[32];
    int requestId;
};

struct StructSecurityEventNotification
{
    unsigned char type[51];
    unsigned char timestamp[28];
    unsigned char techInfo[256];
};

struct StructSignCertificate
{
    unsigned char csr[5501];
    unsigned char Response_status[16];
};

struct StructSignedFirmwareStatusNotification
{
    unsigned char status[32];
    int requestId;
};

struct StructSessionTarget
{
    unsigned char       targetSoc;          // Unit: %,         0 is unlimit
    unsigned short      targetEnergy;       // Unit: KWH        0 is unlimit
    unsigned short      targetDuration;     // Unit: Minutes    0 is unlimit
};

//===================================
// YES custom protocol
//===================================
struct StructChargerInfo
{
    unsigned char station_name[64];
};

struct StructWeatherInfo
{
    int   weatherId;
    float temperature;
};

struct StructCreditDeductResult
{
    int txId;
    unsigned char creditNo[64];
    unsigned char vemData[80];
    unsigned char ROC[20];
    unsigned char RRN[20];
    unsigned char storeId[20];
    unsigned char approvalNo[20];
    double        amount;
    unsigned char deductResult:1;
    unsigned char isDonateInvoice:1;
};

struct StructReaderStatus
{
    int readerStatus;
    unsigned char creditNo[64];
    unsigned char ReportReaderStatusReq:1;
};

struct StructTcciCustomData
{
    struct StructChargerInfo ChargerInfo;
    struct StructWeatherInfo WeatherInfo;
    struct StructCreditDeductResult DeductInfo;
    struct StructReaderStatus ReaderStatus[CONNECTOR_QUANTITY];
    unsigned char TriggerReaderReq[3];
    unsigned char SerialNo[CONNECTOR_QUANTITY][37];
    unsigned char VEMData[CONNECTOR_QUANTITY][65];

    unsigned char ReportCreditDeductReq:1;
    unsigned char ChargerInfoReq:1;
    unsigned char ChargerInfoConf:1;
    unsigned char WeatherInfoReq:1;
    unsigned char WeatherInfoConf:1;
};

struct OCPP16Data
{
    unsigned char                           OcppServerURL[512];     //http: non-secure OCPP 1.5-S, https: secure OCPP 1.5-S, ws: non-secure OCPP 1.6-J, wss: secure OCPP 1.6-J"
    unsigned char                           ChargeBoxId[128];
    unsigned char                           OcppConnStatus;         //0: disconnected, 1: connected
    unsigned int                            Timeout_Secs;
    unsigned short                          Ping_Pong_Interval;
    unsigned int                            procDogTime;            // Process watch dog refresh timer
    union
    {
        //Operations Initiated by Charge Point
        unsigned char CpMsgValue[CONNECTOR_QUANTITY];
        struct
        {
            //CpMsgValue[0]
            unsigned char DataTransferReq:1;        //bit 0,
            unsigned char DataTransferConf:1;       //bit 1,
            unsigned char StartTransactionReq:1;    //bit 2,
            unsigned char StartTransactionConf:1;   //bit 3,
            unsigned char StopTransactionReq:1;     //bit 4,
            unsigned char StopTransactionConf:1;    //bit 5,
            unsigned char :2;                       //bit 6,7 , reserved
        } bits[CONNECTOR_QUANTITY];
    }CpMsg;

    union
    {
        //Operations Initiated by Sequence Point
        unsigned char SpMsgValue[2];
        struct
        {
            //SpMsgValue[0]
            unsigned char BootNotificationReq :1;                   //bit 0,
            unsigned char BootNotificationConf :1;                  //bit 1,
            unsigned char AuthorizeReq :1;                          //bit 2,
            unsigned char AuthorizeConf :1;                         //bit 3,
            unsigned char DiagnosticsStatusNotificationReq :1;      //bit 4,
            unsigned char DiagnosticsStatusNotificationConf :1;     //bit 5,
            unsigned char FirmwareStatusNotificationReq :1;         //bit 6,
            unsigned char FirmwareStatusNotificationConf :1;        //bit 7,
            //SpMsgValue[1]
            unsigned char LogStatusNotificationReq :1;              //bit 0,
            unsigned char LogStatusNotificationConf :1;             //bit 1,
            unsigned char SecurityEventNotificationReq :1;          //bit 2,
            unsigned char SecurityEventNotificationConf :1;         //bit 3,
            unsigned char SignCertificateReq :1;                    //bit 4,
            unsigned char SignCertificateConf :1;                   //bit 5,
            unsigned char SignedFirmwareStatusNotificationReq :1;   //bit 6,
            unsigned char SignedFirmwareStatusNotificationConf :1;  //bit 7,
        } bits;
    } SpMsg;

    union
    {
        //Operations Initiated by Central System
        unsigned char CsMsgValue[3 * (CONNECTOR_QUANTITY)];
        struct
        {
            //CsMsgValue[0]
            unsigned char CancelReservationReq :1;      //bit 0,
            unsigned char CancelReservationConf :1;     //bit 1,
            unsigned char ChangeAvailabilityReq :1;     //bit 2,
            unsigned char ChangeAvailabilityConf :1;    //bit 3,
            unsigned char ReserveNowReq :1;             //bit 4,
            unsigned char ReserveNowConf :1;            //bit 5,
            unsigned char SetChargingProfileReq :1;     //bit 6,
            unsigned char SetChargingProfileConf :1;    //bit 7,
            //CsMsgValue[1]
            unsigned char TriggerMessageReq :1;         //bit 0,
            unsigned char TriggerMessageConf :1;        //bit 1,
            unsigned char UnlockConnectorReq :1;        //bit 2,
            unsigned char UnlockConnectorConf :1;       //bit 3,
            unsigned char RemoteStartTransactionReq :1; //bit 4,
            unsigned char RemoteStartTransactionConf :1;//bit 5,
            unsigned char RemoteStopTransactionReq :1;  //bit 6,
            unsigned char RemoteStopTransactionConf :1; //bit 7,
            //CsMsgValue[2]
            unsigned char ClearChargingProfileReq :1;   //bit 0,
            unsigned char ClearChargingProfileConf :1;  //bit 1,
            unsigned char DataTransferReq :1;           //bit 2,
            unsigned char DataTransferConf :1;          //bit 3,
            unsigned char GetCompositeScheduleReq :1;   //bit 4,
            unsigned char GetCompositeScheduleConf :1;  //bit 5,
            unsigned char :2;                           //bit 6,7
        } bits[CONNECTOR_QUANTITY];
    }CsMsg;

    union
    {
        //Operations Initiated by Main System
        unsigned char MsMsgValue[4];
        struct
        {
            //CsMsgValue[0]
            unsigned char ChangeConfigurationReq :1;                //bit 0,
            unsigned char ChangeConfigurationConf :1;               //bit 1,
            unsigned char ClearCacheReq :1;                         //bit 2,
            unsigned char ClearCacheConf :1;                        //bit 3,
            unsigned char GetConfigurationReq :1;                   //bit 4,
            unsigned char GetConfigurationConf :1;                  //bit 5,
            unsigned char UpdateFirmwareReq :1;                     //bit 6,
            unsigned char UpdateFirmwareConf :1;                    //bit 7,
            //CsMsgValue[1]
            unsigned char GetDiagnosticsReq :1;                     //bit 0,
            unsigned char GetDiagnosticsConf :1;                    //bit 1,
            unsigned char GetLocalListVersionReq :1;                //bit 2,
            unsigned char GetLocalListVersionConf :1;               //bit 3,
            unsigned char ResetReq :1;                              //bit 4,
            unsigned char ResetConf :1;                             //bit 5,
            unsigned char SendLocalListReq :1;                      //bit 6,
            unsigned char SendLocalListConf :1;                     //bit 7,
            //CsMsgValue[2]
            unsigned char CertificateSignedReq :1;                  //bit 0
            unsigned char CertificateSignedConf :1;                 //bit 1
            unsigned char DeleteCertificateReq :1;                  //bit 2
            unsigned char DeleteCertificateConf :1;                 //bit 3
            unsigned char ExtendedTriggerMessageReq :1;             //bit 4
            unsigned char ExtendedTriggerMessageConf :1;            //bit 5
            unsigned char GetInstalledCertificateIdsReq :1;         //bit 6
            unsigned char GetInstalledCertificateIdsConf :1;        //bit 7
            //CsMsgValue[3]
            unsigned char GetLogReq :1;                             //bit 0
            unsigned char GetLogConf :1;                            //bit 1
            unsigned char InstallCertificateReq :1;                 //bit 2
            unsigned char InstallCertificateConf :1;                //bit 3
            unsigned char SignedUpdateFirmwareReq :1;               //bit 4
            unsigned char SignedUpdateFirmwareConf :1;              //bit 5
            unsigned char isRemoteStartWaitReq :1;                  //bit 6
            unsigned char :1;                                       //bit 7
        } bits;
    } MsMsg;

    union
    {
        //Operations triggered by CSU
        unsigned char CSUMsgValue[CONNECTOR_QUANTITY];
        struct
        {
            //CSUMsgValue[0]
            unsigned char ChargingProfileReq:1;     //bit 0,
            unsigned char ChargingProfileConf:1;    //bit 0,
            unsigned char :6;                       //bit 1,2,3,4,5,6,7 , reserved
        } bits[CONNECTOR_QUANTITY];
    }CSUMsg;

    struct StructBootNotification                   BootNotification;
    struct StructHeartbeat                          Heartbeat;
    struct StructAuthorize                          Authorize;
    struct StructStartTransaction                   StartTransaction[CONNECTOR_QUANTITY];
    struct StructStopTransaction                    StopTransaction[CONNECTOR_QUANTITY];
    struct StructStatusNotification                 StatusNotification[CONNECTOR_QUANTITY];
    struct StructCancelReservation                  CancelReservation[CONNECTOR_QUANTITY];
    struct StructChangeAvailability                 ChangeAvailability[CONNECTOR_QUANTITY];
    struct StructChangeConfiguration                ChangeConfiguration;
    struct StructClearCache                         ClearCache;
    struct StructClearChargingProfile               ClearChargingProfile[CONNECTOR_QUANTITY];
    struct StructDataTransfer                       DataTransfer[CONNECTOR_QUANTITY];
    struct StructDiagnosticsStatusNotification      DiagnosticsStatusNotification;
    struct StructFirmwareStatusNotification         FirmwareStatusNotification;
    struct StructGetCompositeSchedule               GetCompositeSchedule[CONNECTOR_QUANTITY];
    struct StructGetConfiguration                   GetConfiguration;
    struct StructGetDiagnostics                     GetDiagnostics;
    struct StructGetLocalListVersion                GetLocalListVersion;
    struct StructMeterValues                        MeterValues[CONNECTOR_QUANTITY];
    struct StructRemoteStartTransaction             RemoteStartTransaction[CONNECTOR_QUANTITY];
    struct StructRemoteStopTransaction              RemoteStopTransaction[CONNECTOR_QUANTITY];
    struct StructReserveNow                         ReserveNow[CONNECTOR_QUANTITY];
    struct StructReset                              Reset;
    struct StructSendLocalList                      SendLocalList;
    struct StructSetChargingProfile                 SetChargingProfile[CONNECTOR_QUANTITY];
    struct StructTriggerMessage                     TriggerMessage[CONNECTOR_QUANTITY];
    struct StructUnlockConnector                    UnlockConnector[CONNECTOR_QUANTITY];
    struct StructUpdateFirmware                     UpdateFirmware;
    struct OCPP16ConfigurationTable                 ConfigurationTable;
    struct StructChargingProfile                    SmartChargingProfile[CONNECTOR_QUANTITY];
    struct StructChargingProfile                    MaxChargingProfile;
    struct StructCost                               Cost;
    struct StructCertificateSigned                  CertificateSigned;
    struct StructDeleteCertificate                  DeleteCertificate;
    struct StructExtendedTrigger                    ExtendedTriggerMessage;
    struct StructGetInstalledCertificateIds         GetInstalledCertificateIds;
    struct StructGetLog                             GetLog;
    struct StructInstallCertificate                 InstallCertificate;
    struct StructSignedUpdateFirmware               SignedUpdateFirmware;
    struct StructLogStatusNotification              LogStatusNotification;
    struct StructSecurityEventNotification          SecurityEventNotification;
    struct StructSignCertificate                    SignCertificate;
    struct StructSignedFirmwareStatusNotification   SignedFirmwareStatusNotification;
    struct StructSessionTarget                      SessionTarget[CONNECTOR_QUANTITY];
    struct StructTcciCustomData                     TcciCustomData;
};


/**************************************************************************************/
/************************* OCPP 2.0 Share memory **************************************/
/**************************************************************************************/
/*
 * =============== Enum variable content ===============
 */
enum OCPP20CtrlrVariable
{
	AlignedDataCtrlr_Enabled=0,
	AlignedDataCtrlr_Available,
	AlignedDataCtrlr_Measurands,
	AlignedDataCtrlr_Interval,
	AlignedDataCtrlr_SendDuringIdle,
	AlignedDataCtrlr_SignReadings,
	AlignedDataCtrlr_TxEndedMeasurands,
	AlignedDataCtrlr_TxEndedInterval,
	AuthCtrlr_Enabled,
	AuthCtrlr_AdditionalInfoItemsPerMessage,
	AuthCtrlr_OfflineTxForUnknownIdEnabled,
	AuthCtrlr_AuthorizeRemoteStart,
	AuthCtrlr_LocalAuthorizeOffline,
	AuthCtrlr_LocalPreAuthorize,
	AuthCtrlr_MasterPassGroupId,
	AuthCacheCtrlr_Enabled,
	AuthCacheCtrlr_Available,
	AuthCacheCtrlr_LifeTime,
	AuthCacheCtrlr_Storage,
	AuthCacheCtrlr_Policy,
	ClockCtrlr_DateTime,
	ClockCtrlr_NtpSource,
	ClockCtrlr_NtpServerUri,
	ClockCtrlr_TimeOffset,
	ClockCtrlr_NextTimeOffsetTransitionDateTime,
	ClockCtrlr_NextTransition_TimeOffset,
	ClockCtrlr_TimeSource,
	ClockCtrlr_TimeZone,
	ChargingStation_Available,
	ChargingStation_AvailabilityState,
	ChargingStation_SupplyPhases,
	ChargingStation_SystemUptimeSec,
	ChargingStation_FreeVend,
	ChargingStation_FreeVendIdtag,
	ChargingStation_OffLineMaxChargingPower,
	Connector_Available,
	Connector_ConnectorType,
	Connector_SupplyPhases,
	CustomizationCtrlr_CustomImplementationEnabled,
	DeviceDataCtrlr_GetReport_ItemsPerMessage,
	DeviceDataCtrlr_GetVariables_ItemsPerMessage,
	DeviceDataCtrlr_GetReport_BytesPerMessage,
	DeviceDataCtrlr_GetVariables_BytesPerMessage,
	DeviceDataCtrlr_ConfigurationValueSize,
	DeviceDataCtrlr_ReportingValueSize,
	DeviceDataCtrlr_SetVariables_ItemsPerMessage,
	DeviceDataCtrlr_SetVariables_BytesPerMessage,
	DisplayMessageCtrlr_Enabled,
	DisplayMessageCtrlr_Available,
	DisplayMessageCtrlr_DisplayMessages,
	DisplayMessageCtrlr_SupportedFormats,
	DisplayMessageCtrlr_SupportedPriorities,
	EVSE_Available,
	EVSE_AvailabilityState,
	EVSE_SupplyPhases,
	EVSE_Power,
	LocalAuthListCtrlr_Enabled,
	LocalAuthListCtrlr_Entries,
	LocalAuthListCtrlr_Available,
	LocalAuthListCtrlr_ItemsPerMessage,
	LocalAuthListCtrlr_BytesPerMessage,
	LocalAuthListCtrlr_Storage,
	MonitoringCtrlr_Enabled,
	MonitoringCtrlr_Available,
	MonitoringCtrlr_ClearVariableMonitoring_ItemsPerMessage,
	MonitoringCtrlr_SetVariableMonitoring_ItemsPerMessage,
	MonitoringCtrlr_ClearVariableMonitoring_BytesPerMessage,
	MonitoringCtrlr_SetVariableMonitoring_BytesPerMessage,
	MonitoringCtrlr_OfflineQueuingSeverity,
	OCPPCommCtrlr_ActiveNetworkProfile,
	OCPPCommCtrlr_MessageTimeout,
	OCPPCommCtrlr_FileTransferProtocols,
	OCPPCommCtrlr_HeartbeatInterval,
	OCPPCommCtrlr_NetworkConfigurationPriority,
	OCPPCommCtrlr_NetworkProfileConnectionAttempts,
	OCPPCommCtrlr_OfflineThreshold,
	OCPPCommCtrlr_QueueAllMessages,
	OCPPCommCtrlr_MessageAttempts,
	OCPPCommCtrlr_MessageAttemptInterval,
	OCPPCommCtrlr_UnlockOnEVSideDisconnect,
	OCPPCommCtrlr_WebSocketPingInterval,
	OCPPCommCtrlr_ResetRetries,
	OCPPCommCtrlr_PublicKeyWithSignedMeterValue,
    OCPPCommCtrlr_StatusNotificationPeriodically,
    OCPPCommCtrlr_StatusNotificationInterval,
    OCPPCommCtrlr_VariableVersion,
	ReservationCtrlr_Enabled,
	ReservationCtrlr_Available,
	ReservationCtrlr_NonEvseSpecific,
	SampledDataCtrlr_Enabled,
	SampledDataCtrlr_Available,
	SampledDataCtrlr_SignReadings,
	SampledDataCtrlr_TxEndedMeasurands,
	SampledDataCtrlr_TxEndedInterval,
	SampledDataCtrlr_TxStartedMeasurands,
	SampledDataCtrlr_TxUpdatedMeasurands,
	SampledDataCtrlr_TxUpdatedInterval,
	SecurityCtrlr_BasicAuthPassword,
	SecurityCtrlr_Identity,
	SecurityCtrlr_OrganizationName,
	SecurityCtrlr_CertificateEntries,
	SecurityCtrlr_SecurityProfile,
	SecurityCtrlr_AdditionalRootCertificateCheck,
	SecurityCtrlr_MaxCertificateChainSize,
	SmartChargingCtrlr_Enabled,
	SmartChargingCtrlr_Available,
	SmartChargingCtrlr_ACPhaseSwitchingSupported,
	SmartChargingCtrlr_ProfileStackLevel,
	SmartChargingCtrlr_RateUnit,
	SmartChargingCtrlr_PeriodsPerSchedule,
	SmartChargingCtrlr_ExternalControlSignalsEnabled,
	SmartChargingCtrlr_NotifyChargingLimitWithSchedules,
	SmartChargingCtrlr_Phases3to1,
	SmartChargingCtrlr_Entries,
	SmartChargingCtrlr_LimitChangeSignificance,
	Tariff_Enabled,
	Tariff_Available,
	Tariff_TariffFallbackMessage,
	Cost_Enabled,
	Cost_Available,
	Cost_TotalCostFallbackMessage,
	Cost_Currency,
	TxCtrlr_ChargingBeforeAcceptedEnabled,
	TxCtrlr_EVConnectionTimeOut,
	TxCtrlr_StopTxOnEVSideDisconnect,
	TxCtrlr_TxBeforeAcceptedEnabled,
	TxCtrlr_TxStartPoint,
	TxCtrlr_TxStopPoint,
	TxCtrlr_MaxEnergyOnInvalidId,
	TxCtrlr_StopTxOnInvalidId,
	CtrlrVariable_CNT
};

/*
 * =============== Common class ===============
 */
struct ACChargingParametersType
{
	int energyAmount;											// Required, Amount of energy requested (in Wh). This includes energy required for preconditioning.
	int evMinCurrent;											// Required. Minimum current (amps) supported by the electric vehicle (per phase).
	int evMaxCurrent;											// Required. Maximum current (amps) supported by the electric vehicle (per phase). Includes cable capacity.
	int evMaxVoltage;											// Required. Maximum voltage supported by the electric vehicle
};

struct DCChargingParametersType
{
	int evMaxCurrent;											// Required. Maximum current (amps) supported by the electric vehicle. Includes cable capacity.
	int evMaxVoltage;											// Required. Maximum voltage supported by the electric vehicle
	int energyAmount;											// Optional. Amount of energy requested (in Wh). This inludes energy required for preconditioning.
	int evMaxPower;												// Optional. Maximum power (in W) supported by the electric vehicle. Required for DC charging.
	unsigned char stateOfCharge;								// Optional. Energy available in the battery (in percent of the battery capacity)
	int evEnergyCapacity;										// Optional. Capacity of the electric vehicle battery (in Wh)
	unsigned char fullSoC;										// Optional. Percentage of SoC at which the EV considers the battery fully charged. (possible values: 0 - 100)
	unsigned char bulkSoC;										// Optional. Percentage of SoC at which the EV considers a fast charging process to end. (possible values: 0 - 100)
};

struct AdditionalInfoType
{
	unsigned char	additionalIdToken[37];						// Required. This field specifies the additional IdToken.
	unsigned char	type[50];									// Required. This defines the type of the additionalIdToken. This is a custom type, so the implementation needs to be agreed upon by all involved parties.
};

struct APNType
{
	unsigned char apn[512];										// Required. The Access Point Name as an URL.
	unsigned char apnUserName[20];								// Optional. APN user name.
	unsigned char apnPassword[20];								// Optional. APN Password.
	short int	simPin;											// Optional. SIM card pin code.
	unsigned char	preferredNetwork[6];						// Optional. Preferred network, written as MCC and MNC concatenated. See note.
	unsigned char useOnlyPreferredNetwork;						// Optional. Default: false. Use only the preferred Network, do not dial in when not available. See Note.
	short int apnAuthentication[8];								// Required. Authentication method.
};

struct VPNType
{
	unsigned char server[512];									// Required. VPN Server Address
	unsigned char user[20];										// Required. VPN User
	unsigned char group[20];									// Optional. VPN group.
	unsigned char password[20];									// Required. VPN Password.
	unsigned char key[255];										// Required. VPN shared secret.
	unsigned char type[8];										// Required. Type of VPN
};

struct GroupIdTokenType
{
	unsigned char idToken[37];									// Required. IdToken is case insensitive. Might hold the hidden id of an RFID tag, but can for example also contain a UUID.
	unsigned char type[16];										// Required. Enumeration of possible idToken types.
};

struct MessageContentType
{
	unsigned char format[8];									// Required. Format of the message.
	unsigned char	language[8];								// Optional. Message language identifier. Contains a language code as defined in [RFC5646].
	unsigned char content[512];									// Required. Message contents.
};

struct IdTokenInfoType
{
	unsigned char status[32];									// Required. Current status of the ID Token.
	unsigned char cacheExpiryDateTime[28];						// Optional. Date and Time after which the token must be considered invalid.
	short int	chargingPriority;								// Optional. Priority from a business point of view. Default priority is 0, The range is from -9 to 9. Higher values indicate a higher priority.
	unsigned char language1[8];									// Optional. Preferred user interface language of identifier user. Contains a language code as defined in [RFC5646].
	unsigned int evseId[100];									// Optional. Only used when the IdToken is only valid for one or more specific EVSEs, not for the entire Charging Station.
	unsigned char language2[8];									// Optional. Second preferred user interface language of identifier user. Don’t use when language1 is omitted, has to be different from language1.
	struct GroupIdTokenType groupIdToken;						// Optional. This contains the group identifier.
	struct MessageContentType personalMessage;					// Optional. Personal message that can be shown to the EV Driver and can be used for tariff information, user greetings etc.
};

struct IdTokenType
{
	unsigned char idToken[37];									// Required. IdToken is case insensitive. Might hold the hidden id of an RFID tag, but can for example also contain a UUID.
	unsigned char	type[16];									// Required. Enumeration of possible idToken types.
	struct AdditionalInfoType additionalInfo[10];				// Optional. AdditionalInfo can be used to send extra information which can be validated by the CSMS in addition to the regular authorization with IdToken.
};

struct AuthorizationData
{
	struct IdTokenInfoType idTokenInfo;							// Optional. Required when UpdateType is Full. This contains information about authorization status, expiry and group id.
	struct IdTokenType idToken;									// Required. This contains the identifier which needs to be stored for authorization.
};

struct CertificateHashDataChainType
{
	unsigned char certificateType[32];							// Required. Indicates the type of the requested certificate(s).
	struct CertificateHashDataType certificateHashData;			// Required. Information to identify a certificate.
	struct CertificateHashDataType childCertificateHashData[4]; // Optional. Information to identify the child certificate(s).
};


struct ChargingLimitType
{
	unsigned char chargingLimitSource[8];						// Required. Represents the source of the charging limit.
	unsigned char isGridCritical;								// Optional. Indicates whether the charging limit is critical for the grid.
};

struct ChargingNeedsType
{
	unsigned char requestedEnergyTransfer[32];					// Required. Mode of energy transfer requested by the EV.
	unsigned char departureTime[28];							// Optional. Estimated departure time of the EV.
	struct ACChargingParametersType acChargingParameters;		// Optional. EV AC charging parameters.
	struct DCChargingParametersType dcChargingParameters;		// Optional. EV DC charging parameters
};

struct ChargingProfileCriterionType
{
	unsigned char chargingProfilePurpose[36];					// Optional. Defines the purpose of the schedule transferred by this profile
	unsigned short int stackLevel;								// Optional. Value determining level in hierarchy stack of profiles. Higher values have precedence over lower values. Lowest level is 0.
	unsigned short int chargingProfileId[10];					// Optional. List of all the chargingProfileIds requested. Any ChargingProfile that matches one of these profiles will be reported.
	unsigned char chargingLimitSource[4][8];					// Optional. For which charging limit sources, charging profiles SHALL be reported. If omitted, the Charging Station SHALL not filter on chargingLimitSource.
};

struct RelativeTimeIntervalTypeOCPP
{
	unsigned int start;											// Required. Start of the interval, in seconds from NOW.
	unsigned int duration;										// Optional. Duration of the interval, in seconds.
};

struct CostTypeOCPP
{
	unsigned char costKind[36];									// Required. The kind of cost referred to in the message element amount
	int amount;													// Required. The estimated or actual cost per kWh
};

struct ConsumptionCostTypeOCPP
{
	float startValue;											// Required. The lowest level of consumption that defines the starting point of this consumption block. The block interval extends to the start of the next interval.
	struct CostTypeOCPP cost[3];								// Required. This field contains the cost details.
};

struct SalesTariffEntryTypeOCPP
{
	unsigned short int ePriceLevel;								// Optional. Defines the price level of this SalesTariffEntry (referring to NumEPriceLevels). Small values for the EPriceLevel represent a cheaper TariffEntry. Large values for the EPriceLevel represent a more expensive TariffEntry.
	struct RelativeTimeIntervalTypeOCPP relativeTimeInterval;	// Required. Defines the time interval the SalesTariffEntry is valid for, based upon relative times.
	struct ConsumptionCostTypeOCPP consumptionCost[3];			// Optional. Defines additional means for further relative price information and/or alternative costs.
};

struct SalesTariffTypeOCPP
{
	unsigned short int id;										// Required. SalesTariff identifier used to identify one sales tariff. An SAID remains a unique identifier for one schedule throughout a charging session.
	unsigned char salesTariffDescription[32];					// Optional. A human readable title/short description of the sales tariff e.g. for HMI display purposes.
	unsigned short int numEPriceLevels;							// Optional. Defines the overall number of distinct price levels used across all provided SalesTariff elements.
	struct SalesTariffEntryTypeOCPP salesTariffEntry[1024];		// Required. Encapsulating element describing all relevant details for one time interval of the SalesTariff. The number of SalesTariffEntry elements is limited by the parameter maxScheduleTuples.
};

struct ChargingSchedulePeriodType
{
	int startPeriod;											// Required. Start of the period, in seconds from the start of schedule. The value of StartPeriod also defines the stop time of the previous period.
	float limit;												// Required. Charging rate limit during the schedule period, in the applicable chargingRateUnit, for example in Amperes (A) or Watts (W). Accepts at most one digit fraction (e.g. 8.1).
	unsigned char	numberPhases;								// Optional. The number of phases that can be used for charging. If a number of phases is needed, numberPhases=3 will be assumed unless another number is given.
	unsigned char phaseToUse;									// Optional. Values: 1..3, Used if numberPhases=1 and if the EVSE is capable of switching the phase connected to theEV, i.e. ACPhaseSwitchingSupported is defined and true.
};

struct ChargingScheduleType
{
	unsigned char startSchedule[28];							// Optional. Starting point of an absolute schedule. If absent the schedule will be relative to start of charging.
	unsigned int duration;										// Optional. Duration of the charging schedule in seconds.
	unsigned char chargingRateUnit[8];							// Required. The unit of measure Limit is expressed in.
	float minChargingRate;										// Optional. Minimum charging rate supported by the EV.
	unsigned short int id;										// Required. Identifies the ChargingSchedule.
	struct ChargingSchedulePeriodType chargingSchedulePeriod[1024];	// Required. List of ChargingSchedulePeriod elements defining maximum power or current usage over time.
	struct SalesTariffTypeOCPP salesTariff;						// Optional. Sales tariff associated with this charging schedule.
};

struct ChargingProfileType
{
	int id;											                // Required. Id of ChargingProfile.
	unsigned short int stackLevel;									// Required. Value determining level in hierarchy stack of profiles. Higher values have precedence over lower values. Lowest level is 0.
	unsigned char chargingProfilePurpose[36];						// Required. Defines the purpose of the schedule transferred by this profile
	unsigned char chargingProfileKind[16];							// Required. Indicates the kind of schedule.
	unsigned char recurrencyKind[8];								// Optional. Indicates the start point of a recurrence.
	unsigned char validFrom[28];									// Optional. Point in time at which the profile starts to be valid. If absent, the profile is valid as soon as it is received by the Charging Station.
	unsigned char validTo[28];										// Optional. Point in time at which the profile stops to be valid. If absent, the profile is valid until it is replaced by another profile.
	unsigned char transactionId[37];								// Optional. SHALL only be included if ChargingProfilePurpose is set to TxProfile. The transactionId is used to match the profile to a specific transaction.
	struct ChargingScheduleType chargingSchedule[3];				// Required. Schedule that contains limits for the available power or current over time. In order to support ISO 15118 schedule negotiation, it supports at most three schedules with associated tariff to choose from.
};

struct ModemType
{
	unsigned char iccid[20];										// Optional. This contains the ICCID of the modem’s SIM card.
	unsigned char imsi[20];											// Optional. This contains the IMSI of the modem’s SIM card.
};

struct ChargingStationType
{
	unsigned char serialNumber[25];									// Optional. Vendor-specific device identifier.
	unsigned char model[20];										// Required. Defines the model of the device.
	unsigned char vendorName[50];									// Required. Identifies the vendor (not necessarily in a unique manner).
	unsigned char firmwareVersion[50];								// Optional. This contains the firmware version of the Charging Station.
	struct ModemType modem;											// Optional. Defines the functional parameters of a communication link.
};

struct ClearChargingProfileType
{
	unsigned int evseId;											// Optional. Specifies the id of the EVSE for which to clear charging profiles.
	unsigned char chargingProfilePurpose[36];						// Optional. Specifies to purpose of the charging profiles that will be cleared, if they meet the other criteria in the request.
	unsigned short int stackLevel;									// Optional. Specifies the stackLevel for which charging profiles will be cleared, if they meet the other criteria in the request.
};

struct ClearMonitoringResultType
{
	unsigned short int id;											// Required. Id of the monitor of which a clear was requested.
	unsigned char status[16];										// Required. Result of the clear request for this monitor, identified by its Id.
};

struct EVSEType
{
	unsigned int id;												// Required. EVSE Identifier. This contains a number (> 0) designating an EVSE of the Charging Station.
	unsigned char connectorId;										// Optional. An id to designate a specific connector (on an EVSE) by connector index number.
};

struct VariableType
{
	unsigned char name[50];											// Required. Name of the variable.
	unsigned char instance[50];										// Optional. Name of instance in case the variable exists as multiple instances.
};

struct VariableAttributeType
{
	unsigned char type[8];											// Optional. Attribute: Actual, MinSet, MaxSet, etc. Defaults to Actual if absent.
	unsigned char value[2500];										// Optional. Value of the attribute. May only be omitted when mutability is set to 'WriteOnly'.
	unsigned char mutability[16];									// Optional. Defines the mutability of this attribute. Default is ReadWrite when omitted.
	unsigned char persistent;										// Optional. If true, value will be persistent across system reboots or power down. Default when omitted is false.
	unsigned char constant;											// Optional. If true, value that will never be changed by the Charging Station at runtime. Default when omitted is false.
};

struct VariableCharacteristicsType
{
	unsigned char unit[16];											// Optional. Unit of the variable. When the transmitted value has a unit, this field SHALL be included.
	unsigned char dataType[16];										// Required. Data type of this variable.
	float 	minLimit;												// Optional. Minimum possible value of this variable.
	float 	maxLimit;												// Optional. Maximum possible value of this variable.
	unsigned char valuesList[1000];									// Optional. Allowed values when variable is Option/Member/SequenceList.
	unsigned char supportsMonitoring;								// Required. Flag indicating if this variable supports monitoring.
};

struct ComponentType
{
	unsigned char name[50];											// Required. Name of the component.
	unsigned char instance[50];										// Optional. Name of instance in case the component exist as multiple instances.
	struct EVSEType evse;											// Optional. Specifies the EVSE when component is located at EVSE level, also specifies the connector when component is located at Connector level.
};

struct ComponentVariableType
{
	struct ComponentType component;									// Required. Component for which a report of Variable is requested.
	struct VariableType variable;									// Optional. Variable(s) for which the report is requested.
};

struct CompositeScheduleType
{
	unsigned char startDateTime[28];								// Required. Date and time at which the schedule becomes active.
	struct ChargingScheduleType chargingSchedule;					// Required. Charging schedule structure defines a list of charging periods.
};

struct EventDataType
{
	unsigned int eventId;											// Required. Identifies the event. This field can be referred to as a cause by other events.
	unsigned char timestamp[28];									// Required. Timestamp of the moment the report was generated.
	unsigned char trigger[16];										// Required. Type of monitor that triggered this event, e.g. exceeding a threshold value.
	unsigned int cause;												// Optional. Refers to the Id of an event that is considered to be the cause for this event.
	unsigned char actualValue[2500];								// Required. Actual value (attributeType Actual) of the variable.
	unsigned char techcode[50];										// Optional. Technical (error) code as reported by component.
	unsigned char techInfo[500];									// Optional. Technical detail information as reported by component.
	unsigned char cleared;											// Optional. Cleared is set to true to report the clearing of a monitored situation, i.e. a 'return to normal'.
	unsigned char transactionId[37];								// Optional. If an event notification is linked to a specific transaction, this field can be used to specify its transactionId.
	unsigned int variableMonitoringId;								// Optional. Identifies the VariableMonitoring which triggered the event.
	unsigned char eventNotificationType[32];						// Required. Specifies the event notification type of the message.
	struct ComponentType component;									// Required. Component for which event is notified.
	struct VariableType variable;									// Required. Variable for which event is notified.
};

struct GetVariableDataType
{
	unsigned char attributeType[8];									// Optional. Attribute type for which value is requested. When absent, default Actual is assumed.
	struct ComponentType component;									// Required. Component for which the Variable is requested.
	struct VariableType variable;									// Required. Variable for which the attribute value is requested.
};

struct GetVariableResultType
{
	unsigned char attributeStatus[32];								// Required. Result status of getting the variable.
	unsigned char attributeType[8];									// Optional. Attribute type for which value is requested. When absent, default Actual is assumed.
	unsigned char attributeValue[2500];								// Optional. Value of requested attribute type of component- variable.
	struct ComponentType component;									// Required. Component for which the Variable is requested.
	struct VariableType variable;									// Required. Variable for which the attribute value is requested.
};

struct MessageInfoType
{
	unsigned int id;												// Required. Master resource identifier, unique within an exchange context. It is defined within the OCPP context as a positive Integer value (greater or equal to zero).
	unsigned char priority[16];										// Required. With what priority should this message be shown
	unsigned char state[16];										// Optional. During what state should this message be shown. When omitted this message should be shown in any state of the Charging Station.
	unsigned char startDateTime[28];								// Optional. From what date-time should this message be shown. If omitted: directly.
	unsigned char endDateTime[28];									// Optional. Until what date-time should this message be shown, after this date/time this message SHALL be removed.
	unsigned char transactionId[37];								// Optional. During which transaction shall this message be shown. Message SHALL be removed by the Charging Station after transaction has ended.
	struct MessageContentType message;								// Required. Contains message details for the message to be displayed on a Charging Station.
	struct ComponentType display;									// Optional. When a Charging Station has multiple Displays, this field can be used to define to which Display this message belongs.
};

struct SignedMeterValueType
{
	unsigned char signedMeterData[2500];							// Required. Base64 encoded, contains the signed data which might contain more then just the meter value. It can contain information like timestamps, reference to a customer etc.
	unsigned char signingMethod[50];								// Required. Method used to create the digital signature.
	unsigned char encodingMethod[50];								// Required. Method used to encode the meter values before applying the digital signature algorithm.
	unsigned char publicKey[2500];									// Required. Base64 encoded, sending depends on configuration variable PublicKeyWithSignedMeterValue.
};

struct UnitOfMeasureType
{
	unsigned char uint[20];											// Optional. Unit of the value. Default = "Wh" if the (default) measurand is an "Energy" type.
	unsigned short int multiplier;									// Optional. Multiplier, this value represents the exponent to base 10. I.e. multiplier 3 means 10 raised to the 3rd power. Default is 0.
};

struct SampledValueType
{
    double value;													// Required. Indicates the measured value.
	unsigned char context[32];										// Optional. Type of detail value: start, end or sample. Default = "Sample.Periodic"
	unsigned char measurand[32];									// Optional. Type of measurement. Default = "Energy.Active.Import.Register"
	unsigned char phase[8];											// Optional. Indicates how the measured value is to be interpreted.
	unsigned char location[8];										// Optional. Indicates where the measured value has been sampled. Default = "Outlet"
	struct SignedMeterValueType signedMeterValue;					// Optional. Contains the MeterValueSignature with sign/encoding method information.
	struct UnitOfMeasureType unitOfMeasure;							// Optional. Represents a UnitOfMeasure including a multiplier
};

struct MeterValueType
{
	unsigned char timestamp[28];									// Required. Timestamp for measured value(s).
	struct SampledValueType sampledValue[20];						// Required. One or more measured values
};

struct VariableMonitoringType
{
	unsigned int id;												// Required. Identifies the monitor.
	float value;													// Required. Value for threshold or delta monitoring. For Periodic or PeriodicClockAligned this is the interval in seconds.
	unsigned char type[32];											// Required. The type of this monitor, e.g. a threshold, delta or periodic monitor.
	unsigned char severity;											// Required. The severity that will be assigned to an event that is triggered by this monitor.
	unsigned char transaction;										// Required. Monitor only active when a transaction is ongoing on a component relevant to this transaction.
};

struct MonitoringDataType
{
	struct ComponentType component;									// Required. Component for which monitoring report was requested.
	struct VariableType variable;									// Required. Variable for which monitoring report was requested.
	struct VariableMonitoringType variableMonitoring[10];			// Required. List of monitors for this Component-Variable pair.
};

struct NetworkConnectionProfileType
{
	unsigned char ocppVersion[8];									// Required. Defines the OCPP version used for this communication function.
	unsigned char ocppTransport[8];									// Required. Defines the transport protocol (e.g. SOAP or JSON). Note: SOAP is not supported in OCPP 2.0, but is supported by other versions of OCPP.
	unsigned char ocppCsmsUrl[512];									// Required. URL of the CSMS(s) that this Charging Station communicates with.
	unsigned int messageTimeout;									// Required. Duration in seconds before a message send by the Charging Station via this network connection times- out. The best setting depends on the underlying network and response times of the CSMS. If you are looking for a some guideline: use 30 seconds as a starting point.
	unsigned char ocppInterface[16];								// Required. Applicable Network Interface.
	struct VPNType vpn;												// Optional. Settings to be used to set up the VPN connection
	struct APNType apn;												// Optional. Collection of configuration data needed to make a data-connection over a cellular network.
};

struct OCSPRequestDataType
{
	unsigned char hashAlgorithm[8];									// Required. Used algorithms for the hashes provided.
	unsigned char issuerNameHash[128];								// Required. hashed value of the IssuerName.
	unsigned char issuerKeyHash[128];								// Required. Hashed value of the issuers public key
	unsigned char serialNumber[40];									// Required. The serial number of the certificate.
	unsigned char responderURL[512];								// Required. This contains the responder URL (Case insensitive).
};

struct ReportDataType
{
	struct ComponentType component;									// Required. Component for which a report of Variable is requested.
	struct VariableType variable;									// Required. Variable for which report is requested.
	struct VariableAttributeType variableAttribute[4];				// Required. Attribute data of a variable.
	struct VariableCharacteristicsType variableCharacteristics;		// Optional. Fixed read-only parameters of a variable.
};

struct SetMonitoringDataType
{
	unsigned int id;												// Optional. An id SHALL only be given to replace an existing monitor. The Charging Station handles the generation of id’s for new monitors.
	float value;													// Required. Value for threshold or delta monitoring. For Periodic or PeriodicClockAligned this is the interval in seconds.
	unsigned char type[32];											// Required. The type of this monitor, e.g. a threshold, delta or periodic monitor.
	unsigned char severity;											// Required. The severity that will be assigned to an event that is triggered by this monitor.
	unsigned char transaction;										// Optional. Monitor only active when a transaction is ongoing on a component relevant to this transaction. Default = false.
	struct ComponentType component;									// Required. Component for which monitor is set.
	struct VariableType variable;									// Required. Variable for which monitor is set.
};

struct SetMonitoringResultType
{
	unsigned int id;												// Optional. Id given to the VariableMonitor by the Charging Station.
	unsigned char type[32];											// Required. The type of this monitor, e.g. a threshold, delta or periodic monitor.
	unsigned char severity;											// Required. The severity that will be assigned to an event that is triggered by this monitor.
	unsigned char status[32];										// Required. Status is OK if a value could be returned.
	struct ComponentType component;									// Required. Component for which status is returned.
	struct VariableType variable;									// Required. Variable for which status is returned.
};

struct SetVariableDataType
{
	unsigned char attributeType[8];									// Optional. Type of attribute: Actual, Target, MinSet, MaxSet. Default is Actual when omitted.
	unsigned char attributeValue[1000];								// Required. Value to be assigned to attribute of variable.
	struct ComponentType component;									// Required. The component for which the variable data is set.
	struct VariableType variable;									// Required. Specifies the that needs to be set.
};

struct SetVariableResultType
{
	unsigned char attributeType[8];									// Optional. Type of attribute: Actual, Target, MinSet, MaxSet. Default is Actual when omitted.
	unsigned char attributeStatus[32];								// Required. Result status of setting the variable.
	struct ComponentType component;									// Required. The component for which result is returned.
	struct VariableType variable;									// Required. The variable for which the result is returned.
};

struct TransactionType
{
	unsigned char transactionId[37];								// Required. This contains the Id of the transaction.
	unsigned char chargingState[16];								// Optional. Current charging state, is required when state has changed. Omitted when there is no communication between EVSE and EV, because no cable is plugged in.
	unsigned int timeSpentCharging;									// Optional. Contains the total time that energy flowed from EVSE to EV during the transaction (in seconds). Note that timeSpentCharging is smaller or equal to the duration of the transaction.
	unsigned char stoppedReason[20];								// Optional. This contains the reason why the transaction was stopped. MAY only be omitted when Reason is "Local".
	unsigned int remoteStartId;										// Optional. The ID given to remote start request (RequestStartTransactionRequest.
};

struct StatusInfoType
{
    unsigned char reasonCode[21];                                   // Required. A predefined code for the reason why thestatus is returned in this response. The string is case-insensitive.
    unsigned char additionalInfo[513];                              // Optional. Additional text to provide detailed information.
};
/*
 * =============== Message ===============
 */
struct Authorize_20
{
	struct IdTokenType idToken;										// Required. This contains the identifier that needs to be authorized.
	struct OCSPRequestDataType iso15118CertificateHashData[4];		// Optional. Contains the information needed to verify the EV Contract Certificate via OCSP.
	unsigned char Response_certificateStatus[32];					// Optional. Certificate status information. - if all certificates are valid: return 'Accepted'. - if one of the certificates was revoked, return 'CertificateRevoked'.
	struct IdTokenInfoType Response_idTokenInfo;					// Required. This contains information about authorization status, expiry and group id.
};

struct BootNotification_20
{
	unsigned char reason[20];										// Required. This contains the reason for sending this message to the CSMS.
	struct ChargingStationType chargingStation;						// Required. Identifies the Charging Station
	unsigned char Response_currentTime[28];							// Required. This contains the CSMS’s current time.
	unsigned int Response_interval;									// Required. When Status is Accepted, this contains the heartbeat interval in seconds. If the CSMS returns something other than Accepted, the value of the interval field indicates the minimum wait time before sending a next BootNotification request.
	unsigned char Response_status[16];								// Required. This contains whether the Charging Station has been registered within the CSMS.
};

struct CancelReservation_20
{
	int reservationId;												// Required. Id of the reservation to cancel.
	unsigned char Response_status[16];								// Required. This indicates the success or failure of the canceling of a reservation by CSMS.
	unsigned char guid[37];											// Save guid from server request
};

struct CertificateSigned_20
{
    unsigned char certificateChain[10001];                          // Required. Required. The signed PEM encoded X.509 certificate.This can also contain the necessary sub CA certificates.In that case, the order of the bundle should follow thecertificate chain, starting from the leaf certificate.The Configuration Variable MaxCertificateChainSize canbe used to limit the maximum size of this field.
    unsigned char certificateType[32];                              // Optional. Indicates the type of the signed certificate that is returned.
    unsigned char Response_status[16];                              // Required. Returns whether certificate signing has been accepted, otherwise rejected.
    struct StatusInfoType Response_statusInfo;                      // Optional. Detailed status information.
    unsigned char guid[37];                                         // Save guid from server request
};

struct ChangeAvailability_20
{
	unsigned char operationalStatus[16];							// Required. This contains the type of availability change that the Charging Station should perform.
	struct EVSEType evse;											// Optional. Contains Id’s to designate a specific EVSE/connector by index numbers. When omitted, the message refers to the Charging Station as a whole.
	unsigned char Response_status[16];								// Required. This indicates whether the Charging Station is able to perform the availability change.
	unsigned char guid[37];											// Save guid from server request
};

struct ClearCache_20
{
	unsigned char Response_status[16];								// Required. Accepted if the Charging Station has executed the request, otherwise rejected.
	unsigned char guid[37];											// Save guid from server request
};

struct ClearChargingProfile_20
{
	unsigned int chargingProfileId;									// Optional. The Id of the charging profile to clear.
	struct  ClearChargingProfileType chargingProfileCriteria;		// Optional. Specifies the charging profile.
	unsigned char Response_status[16];								// Required. Indicates if the Charging Station was able to execute the request.
	unsigned char guid[37];											// Save guid from server request
};

struct ClearDisplayMessage_20
{
	unsigned int id;												// Required. Id of the message that SHALL be removed from the Charging Station.
	unsigned char Response_status[16];								// Required. Returns whether the Charging Station has been able to remove the message.
	unsigned char guid[37];											// Save guid from server request
};

struct ClearedChargingLimit_20
{
	unsigned char chargingLimitSource[8];							// Required. Source of the charging limit.
	unsigned int evseId;											// Optional. EVSE Identifier.
};

struct ClearVariableMonitoring_20
{
	unsigned int id[10];										 	// Required. List of the monitors to be cleared, identified by there Id.
	struct ClearMonitoringResultType Response_clearMonitoringResult[10];// Required. List of result statuses per monitor.
	unsigned char guid[37];											// Save guid from server request
};

struct CostUpdated_20
{
	float totalCost;												// Required. Current total cost, based on the information known by the CSMS, of the transaction including taxes. In the currency configured with the configuration Variable: [Currency]
	unsigned char transactionId[37];								// Required. Transaction Id of the transaction the current cost are asked for.
	unsigned char guid[37];											// Save guid from server request
};

struct CustomerInformation_20
{
	unsigned int requestId;											// Required. The Id of the request.
	unsigned char report;											// Required. Flag indicating whether the Charging Station should return NotifyCustomerInformationRequest messages containing information about the customer referred to.
	unsigned char clear;											// Required. Flag indicating whether the Charging Station should clear all information about the customer referred to.
	unsigned char customerIdentifier[64];							// Optional. A (e.g. vendor specific) identifier of the customer this request refers to. This field contains a custom identifier other than IdToken and Certificate. One of the possible identifiers (customerIdentifier, customerIdToken or customerCertificate) should be in the request message.
	struct IdTokenType idToken;										// Optional. The IdToken of the customer this request refers to. One of the possible identifiers (customerIdentifier, customerIdToken or customerCertificate) should be in the request message.
	struct CertificateHashDataType customerCertificate;				// Optional. The Certificate of the customer this request refers to. One of the possible identifiers (customerIdentifier, customerIdToken or customerCertificate) should be in the request message.
	unsigned char Response_status[16];								// Required. Indicates whether the request was accepted.
	unsigned char guid[37];											// Save guid from server request
};

struct DataTransfer_20
{
	unsigned char messageId[50];									// Optional. May be used to indicate a specific message or implementation.
	unsigned char data[512];										// Optional. Data without specified length or format. This needs to be decided by both parties (Open to implementation).
	unsigned char vendorId[255];									// Required. This identifies the Vendor specific implementation
	unsigned char Response_status[20];								// Required. This indicates the success or failure of the data transfer.
	unsigned char Response_data[512];								// Optional. Data without specified length or format, in response to request.
	unsigned char guid[37];											// Save guid from server request
};

struct DeleteCertificate_20
{
	struct CertificateHashDataType certificateHashData;				// Required. Indicates the certificate of which deletion is requested.
	unsigned char Response_status[16];								// Required. Charging Station indicates if it can process the request.
	unsigned char guid[37];											// Save guid from server request
};

struct FirmwareStatusNotification_20
{
	unsigned char status[32];										// Required. This contains the progress status of the firmware installation.
	unsigned int requestId;											// Optional. The request id that was provided in the UpdateFirmwareRequest that started this firmware update. This field is mandatory, unless the message was triggered by a TriggerMessageRequest AND there is no firmware update ongoing.
};

struct Get15118EVCertificate_20
{
	unsigned char iso15118SchemaVersion[50];						// Required. Schema version currently used for the 15118 session between EV and Charging Station. Needed for parsing of the EXI stream by the CSMS.
	unsigned char action[16];										// Required. Defines whether certificate needs to be installed or updated.
	unsigned char exiRequest[5600];									// Required. Raw CertificateInstallationReq request from EV, Base64 encoded.
	unsigned char Response_status[16];								// Required. Indicates whether the message was processed properly.
	unsigned char Response_exiResponse[5600];						// Required. Raw CertificateInstallationRes response for the EV, Base64 encoded.
};

struct GetBaseReport_20
{
	unsigned int requestId;											// Required. The Id of the request.
	unsigned char reportBase[32];									// Required. This field specifies the report base.
	unsigned char Response_status[16];								// Required. This indicates whether the Charging Station is able to accept this request.
	unsigned char guid[37];											// Save guid from server request
};

struct GetCertificateStatus_20
{
	struct OCSPRequestDataType ocspRequestData;						// Required. Indicates the certificate of which the status is requested.
	unsigned char Response_status[16];								// Required. This indicates whether the charging station was able to retrieve the OCSP certificate status.
	unsigned char Response_ocspResult[5501];						// Optional. OCSPResponse class as defined in IETF RFC 6960. DER encoded (as defined in IETF RFC 6960), and then base64 encoded. MAY only be omitted when status is not Accepted.
	struct StatusInfoType Response_statusInfo;                      // Optional. Detailed status information.
};

struct GetChargingProfiles_20
{
	unsigned int requestId;											// Required. Reference identification that is to be used by the Charging Station in the ReportChargingProfilesRequest when provided.
	unsigned int evseId;											// Optional. For which EVSE installed charging profiles SHALL be reported. If 0, only charging profiles installed on the Charging Station itself (the grid connection) SHALL be reported. If omitted, all installed charging profiles SHALL be reported.
	struct ChargingProfileCriterionType chargingProfile;			// Required. Specifies the charging profile.
	unsigned char Response_status[16];								// Required. This indicates whether the Charging Station is able to process this request and will send ReportChargingProfilesRequest messages.
	unsigned char guid[37];											// Save guid from server request
};

struct GetCompositeSchedule_20
{
	unsigned int duration;											// Required. Length of the requested schedule in seconds.
	unsigned char chargingRateUnit[8];								// Optional. Can be used to force a power or current profile.
	unsigned int evseId;											// Required. The ID of the EVSE for which the schedule is requested. When evseid=0, the Charging Station will calculate the expected consumption for the grid connection.
	unsigned char Response_status[16];								// Required. The Charging Station will indicate if it was able to process the request
	struct CompositeScheduleType Response_schedule;					// Optional. This field contains the calculated composite schedule. It may only be omitted when this message contains status Rejected.
	unsigned char guid[37];											// Save guid from server request
};

struct GetDisplayMessages_20
{
	unsigned int id[10];											// Optional. If provided the Charging Station shall return Display Messages of the given ids. This field SHALL NOT contain more ids than set in NumberOfDisplayMessages.maxLimit
	unsigned int requestId;											// Required. The Id of this request.
	unsigned char	priority[16];									// Optional. If provided the Charging Station shall return Display Messages with the given priority only.
	unsigned char state[16];										// Optional. If provided the Charging Station shall return Display Messages with the given state only.
	unsigned char Response_status[16];								// Required. Indicates if the Charging Station has Display Messages that match the request criteria in the GetDisplayMessagesRequest
	unsigned char guid[37];											// Save guid from server request
};

struct GetInstalledCertificateIds_20
{
	unsigned char certificateType[10][32];										// Optional. Indicates the type of certificates requested. When omitted, all certificate types are requested.
	unsigned char Response_status[16];											// Required. Charging Station indicates if it can process the request.
	struct CertificateHashDataChainType Response_certificateHashDataChain[10];	// Optional. The Charging Station includes the Certificate information for each available certificate.
	unsigned char guid[37];														// Save guid from server request
};

struct GetLocalListVersion_20
{
	int Response_versionNumber;										// Required. This contains the current version number of the local authorization list in the Charging Station.
	unsigned char guid[37];											// Save guid from server request
};

struct GetLog_20
{
	unsigned char logType[16];										// Required. This contains the type of log file that the Charging Station should send.
	unsigned int requestId;											// Required. The Id of this request
	unsigned char retries;											// Optional. This specifies how many times the Charging Station must try to upload the log before giving up. If this field is not present, it is left to Charging Station to decide how many times it wants to retry.
	unsigned int retryInterval;										// Optional. The interval in seconds after which a retry may be attempted. If this field is not present, it is left to Charging Station to decide how long to wait between attempts.
	struct LogParametersType log;									// Required. This field specifies the requested log and the location to which the log should be sent.
	unsigned char Response_status[20];								// Required. This field indicates whether the Charging Station was able to accept the request.
	unsigned char Response_filename[255];							// Optional. This contains the name of the log file that will be uploaded. This field is not present when no logging information is available.
	unsigned char guid[37];											// Save guid from server request
};

struct GetMonitoringReport_20
{
	unsigned int requestId;											// Required. The Id of the request.
	unsigned char monitoringCriteria[3][32];						// Optional. This field contains criteria for components for which a monitoring report is requested
	struct ComponentVariableType componentVariable[10];				// Optional. This field specifies the components and variables for which a monitoring report is requested.
	unsigned char Response_status[20];								// Required. This field indicates whether the Charging Station was able to accept the request.
	unsigned char guid[37];											// Save guid from server request
};

struct GetReport_20
{
	unsigned int requestId;											// Required. The Id of the request.
	unsigned char componentCriteria[4][16];							// Optional. This field contains criteria for components for which a report is requested
	struct ComponentVariableType componentVariable[10];				// Optional. This field specifies the components and variables for which a report is requested.
	unsigned char Response_status[20];								// Required. This field indicates whether the Charging Station was able to accept the request.
	unsigned char guid[37];											// Save guid from server request
};

struct GetTransactionStatus_20
{
	unsigned char transactionId[37];								// Optional. The Id of the transaction for which the status is requested.
	unsigned char Response_ongoingIndicator;						// Optional. Whether the transaction is still ongoing.
	unsigned char Response_messagesInQueue;							// Required. Whether there are still message to be delivered.
	unsigned char guid[37];											// Save guid from server request
};

struct GetVariables_20
{
	struct GetVariableDataType getVariableData[CtrlrVariable_CNT];				// Required. List of requested variables.
	struct GetVariableResultType Response_getVariableResult[CtrlrVariable_CNT];	// Required. List of requested variables and their values.
	unsigned char guid[37];                                                     // Save guid from server request
};

struct Heartbeat_20
{
	unsigned char Response_currentTime[28];							// Required. Contains the current time of the CSMS.
};

struct InstallCertificate_20
{
	unsigned char certificateType[32];								// Required. Indicates the certificate type that is sent.
	unsigned char certificate[5501];								// Required. A X.509 certificate, first DER encoded into binary, and then Base64 encoded.
	unsigned char Response_status[16];								// Required. Charging Station indicates if installation was successful.
	unsigned char guid[37];											// Save guid from server request
};

struct LogStatusNotification_20
{
	unsigned char status[32];										// Required. This contains the status of the log upload.
	unsigned int requestId;											// Optional. The request id that was provided in GetLogRequest that started this log upload. This field is mandatory, unless the message was triggered by a TriggerMessageRequest AND there is no log upload ongoing.
};

struct MeterValues_20
{
	unsigned int evseId;											// Required. This contains a number (>0) designating an EVSE of the Charging Station. ‘0’ (zero) is used to designate the main power meter.
	struct MeterValueType meterValue[1];							// Required. The sampled meter values with timestamps.
};

struct NotifyChargingLimit_20
{
	unsigned int evseId;											// Optional. The charging schedule contained in this notification applies to an EVSE. evseId must be > 0.
	struct ChargingLimitType chargingLimit;							// Required. This contains the source of the charging limit and whether it is grid critical.
	struct ChargingScheduleType chargingSchedule[1];				// Optional. Contains limits for the available power or current over time, as set by the external source.
};

struct NotifyCustomerInformation_20
{
	unsigned char data[512];										// Required. (Part of) the requested data. No format specified in which the data is returned. Should be human readable.
	unsigned char tbc;												// Optional. “to be continued” indicator. Indicates whether another part of the monitoringData follows in an upcoming notifyMonitoringReportRequest message. Default value when omitted is false.
	unsigned int seqNo;												// Required. Sequence number of this message. First message starts at 0.
	unsigned char generatedAt[28];									// Required. Timestamp of the moment this message was generated at the Charging Station.
	unsigned int requestId;											// Required. The Id of the request.
};

struct NotifyDisplayMessages_20
{
	unsigned int requestId;                                         // Required. The id of the GetDisplayMessagesRequest that requested this message.
	unsigned char tbc;												// Optional. "to be continued" indicator. Indicates whether another part of the report follows in an upcoming NotifyDisplayMessagesRequest message. Default value when omitted is false.
	struct MessageInfoType messageInfo[10];							// Optional. The requested display message as configured in the Charging Station.
};

struct NotifyEVChargingNeeds_20
{
	unsigned int maxScheduleTuples;									// Optional. Contains the maximum schedule tuples the car supports per SASchedule (both Pmax and Tariff).
	unsigned int evseId;											// Required. Defines the EVSE and connector to which the EV is connected. EvseId may not be 0.
	struct ChargingNeedsType chargingNeeds;							// Required. The characteristics of the energy delivery required.
	unsigned char Response_status[16];								// Required. Returns whether the CSMS has been able to process the message successfully. It does not imply that the evChargingNeeds can be met with the current charging profile.
};

struct NotifyEVChargingSchedule_20
{
	unsigned char timeBase[28];										// Required. Periods contained in the charging profile are relative to this point in time.
	unsigned int evseId;											// Required. The charging schedule contained in this notification applies to an EVSE. EvseId must be > 0.
	struct ChargingScheduleType chargingSchedule;					// Required. Planned energy consumption of the EV over time. Always relative to timeBase.
	unsigned char Response_status[16];								// Required. Returns whether the CSMS has been able to process the message successfully. It does not imply any approval of the charging schedule.
};

struct NotifyEvent_20
{
	unsigned char generatedAt[28];									// Required. Timestamp of the moment this message was generated at the Charging Station.
	unsigned char tbc;												// Optional. “to be continued” indicator. Indicates whether another part of the report follows in an upcoming notifyEventRequest message. Default value when omitted is false.
	unsigned int seqNo;												// Required. Sequence number of this message. First message starts at 0.
	struct EventDataType eventData[10];								// Required. List of EventData.
};

struct NotifyMonitoringReport_20
{
	unsigned int requestId;											// Required. The id of the GetMonitoringRequest that requested this report.
	unsigned char tbc;												// Optional. “to be continued” indicator.
	unsigned int seqNo;												// Required. Sequence number of this message. First message starts at 0.
	unsigned char generatedAt[28];									// Required. Timestamp of the moment this message was generated at the Charging Station.
	struct MonitoringDataType monitor[10];							// Optional. List of MonitoringData containing monitoring settings.
};

struct NotifyReport_20
{
	unsigned int requestId;											// Required. The id of the GetReportRequest or GetBaseReportRequest that requested this report
	unsigned char generatedAt[28];									// Required. Timestamp of the moment this message was generated at the Charging Station.
	unsigned char tbc;												// Optional. “to be continued” indicator.
	unsigned int seqNo;												// Required. Sequence number of this message. First message starts at 0.
	struct ReportDataType reportData[10];							// Optional. List of ReportData.
};

struct PublishFirmware_20
{
	unsigned char location[512];									// Required. This contains a string containing a URI pointing to a location from which to retrieve the firmware.
	unsigned char retries;											// Optional. This specifies how many times Charging Station must try to download the firmware before giving up. If this field is not present, it is left to Charging Station to decide how many times it wants to retry.
	unsigned char checksum[32];										// Required. The MD5 checksum over the entire firmware file as a hexadecimal string of length 32.
	unsigned int requestId;											// Required. The Id of the request.
	unsigned int retryInterval;										// Optional. The interval in seconds after which a retry may be attempted. If this field is not present, it is left to Charging Station to decide how long to wait between attempts.
	unsigned char Response_status[16];								// Required. Indicates whether the request was accepted.
	unsigned char guid[37];											// Save guid from server request
};

struct PublishFirmwareStatusNotification_20
{
	unsigned char status[32];										// Required. This contains the progress status of the publishfirmware installation.
	unsigned char location[10][512];                                // Optional. Required if status is Published. Can be multiple URI’s, if the Local Controller supports e.g. HTTP, HTTPS, and FTP.
	unsigned int requestId;											// Optional. The request id that was provided in the PublishFirmwareRequest which triggered this action.
};

struct ReportChargingProfiles_20
{
	unsigned int requestId;											// Required. Id used to match the GetChargingProfilesRequest message with the resulting ReportChargingProfilesRequest messages
	unsigned char chargingLimitSource[8];							// Required. Source that has installed this charging profile.
	unsigned char tbc;												// Optional. To Be Continued. Default value when omitted: false. false indicates that there are no further messages as part of this report.
	unsigned int evseId;											// Required. The evse to which the charging profile applies. If evseId = 0, the message contains an overall limit for the Charging Station.
	struct ChargingProfileType chargingProfile[3];					// Required. The charging profile as configured in the Charging Station.
};

struct RequestStartTransaction_20
{
	unsigned int evseId;											// Optional. Number of the EVSE on which to start the transaction. EvseId SHALL be > 0
	unsigned int remoteStartId;										// Required. Id given by the server to this start request.
	struct IdTokenType idToken;										// Required. The identifier that the Charging Station must use to start a transaction.
	struct ChargingProfileType chargingProfile;						// Optional. Charging Profile to be used by the Charging Station for the requested transaction.
	struct IdTokenType groupIdToken;								// Optional. The group identifier that the Charging Station must use to start a transaction.
	unsigned char Response_status[16];								// Required. Status indicating whether the Charging Station accepts the request to start a transaction.
	unsigned char Response_transactionId[37];						// Optional. When the transaction was already started by the Charging Station before the RequestStartTransactionRequest was received, for example: cable plugged in first. This contains the transactionId of the already started transaction.
	unsigned char guid[37];											// Save guid from server request
};

struct RequestStopTransaction_20
{
	unsigned char transactionId[37];								// Required. The identifier of the transaction which the Charging Station is requested to stop.
	unsigned char Response_status[16];								// Required. Status indicating whether Charging Station accepts the request to stop a transaction.
	unsigned char guid[37];											// Save guid from server request
};

struct ReservationStatusUpdate_20
{
	int reservationId;												// Required. The ID of the reservation.
	unsigned char reservationUpdateStatus[8];						// Required. The updated reservation status.
};

struct ReserveNow_20
{
	unsigned int id;												// Required. Id of reservation.
	unsigned char expiryDateTime[28];								// Required. Date and time at which the reservation expires.
	unsigned char connectorType[16];								// Optional. This field specifies the connector type.
	unsigned int evseId;											// Optional. This contains ID of the evse to be reserved.
	struct IdTokenType idToken;										// Required. The identifier for which the reservation is made.
	struct IdTokenType groupIdToken;								// Optional. The group identifier for which the reservation is made.
	unsigned char Response_status[16];								// Required. This indicates the success or failure of the reservation.
	unsigned char guid[37];											// Save guid from server request
};

struct Reset_20
{
	unsigned char type[16];											// Required. This contains the type of reset that the Charging Station or EVSE should perform.
	unsigned int evseId;											// Optional. This contains the ID of a specific EVSE that needs to be reset, instead of the entire Charging Station.
	unsigned char Response_status[16];								// Required. This indicates whether the Charging Station is able to perform the reset.
	unsigned char guid[37];											// Save guid from server request
};

struct SecurityEventNotification_20
{
	unsigned char type[50];											// Required. Type of the security event. This value should be taken from the Security events list.
	unsigned char timestamp[28];									// Required. Date and time at which the event occurred.
	unsigned char techInfo[255];									// Optional. Additional information about the occurred security event.
};

struct SendLocalList_20
{
	unsigned int versionNumber;										// Required. In case of a full update this is the versio number of the full list. In case of a differential update it i the version number of the list after the update has bee applied.
	unsigned char updateType[32];									// Required. This contains the type of update (full or differential) of this request.
	struct AuthorizationData localAuthorizationList[500];			// Optional. This contains the Local Authorization List entries.
	unsigned char Response_status[16];								// Required. This indicates whether the Charging Station has successfully received and applied the update of the Local Authorization List.
	unsigned char guid[37];											// Save guid from server request
};

struct SetChargingProfile_20
{
	unsigned int evseId;											// Required. The EVSE to which the charging profile applies. If evseId = 0, the message contains an overall limit for the Charging Station.
	struct ChargingProfileType chargingProfile;						// Required. The charging profile to be set at the Charging Station.
	unsigned char Response_status[16];								// Required. Returns whether the Charging Station has been able to process the message successfully. This does not guarantee the schedule will be followed to the letter. There might be other constraints the Charging Station may need to take into account.
	unsigned char guid[37];											// Save guid from server request
};

struct SetDisplayMessage_20
{
	struct MessageInfoType message;									// Required. Message to be configured in the Charging Station, to be displayed.
	unsigned char Response_status[32];								// Required. This indicates whether the Charging Station is able to display the message.
	unsigned char guid[37];											// Save guid from server request
};

struct SetMonitoringBase_20
{
	unsigned char monitoringBase[16];								// Required. Specify which monitoring base will be set
	unsigned char Response_status[16];								// Required. Indicates whether the Charging Station was able to accept the request.
	unsigned char guid[37];											// Save guid from server request
};

struct SetMonitoringLevel_20
{
	unsigned int severity;											// Required. The Charging Station SHALL only report events with a severity number lower than or equal to this severity.
	unsigned char Response_status[16];         						// Required. Indicates whether the Charging Station was able to accept the request.
	unsigned char guid[37];											// Save guid from server request
};

struct SetNetworkProfile_20
{
	unsigned int configurationSlot;									// Required. Slot in which the configuration should be stored.
	struct NetworkConnectionProfileType connectionData;				// Required. Connection details.
	unsigned char Response_status[16];									// Required. Result of operation.
	unsigned char guid[37];											// Save guid from server request
};

struct SetVariableMonitoring_20
{
	struct SetMonitoringDataType setMonitoringData[10];				// Required. List of MonitoringData containing monitoring settings.
	struct SetMonitoringResultType Response_setMonitoringResult[10];// Required. List of result statuses per monitor.
	unsigned char guid[37];											// Save guid from server request
};

struct SetVariables_20
{
	struct SetVariableDataType setVariableData[CtrlrVariable_CNT];              // Required. List of Component-Variable pairs and attribute values to set.
	struct SetVariableResultType Response_setVariableResult[CtrlrVariable_CNT]; // Required. List of result statuses per Component-Variable.
	unsigned char guid[37];                                                     // Save guid from server request
};

struct SignCertificate_20
{
    unsigned char csr[5501];                                        // Required. The Charging Station SHALL send the public key in form of a Certificate Signing Request (CSR) as described in RFC 2986 [22] using the SignCertificateRequest message.
    unsigned char certificateType[32];                              // Optional. Indicates the type of certificate that is to be signed. When omitted the certificate is to be used for both the 15118 connection (if implemented) and the Charging Station to CSMS connection.
    unsigned char Response_status[16];                              // Required. Specifies whether the CSMS can process the request.
    struct StatusInfoType Response_statusInfo;                      // Optional. Detailed status information.
};

struct StatusNotification_20
{
	unsigned char timestamp[28];									// Required. The time for which the status is reported. If absent time of receipt of the message will be assumed.
	unsigned char connectorStatus[16];								// Required. This contains the current status of the Connector.
	unsigned int evseId;											// Required. The id of the EVSE to which the connector belongs for which the the status is reported.
	unsigned char connectorId;										// Required. The id of the connector within the EVSE for which the status is reported.
};

struct TransactionEvent_20
{
	unsigned char eventType[16];									// Required. This contains the type of this event. The first TransactionEvent of a transaction SHALL contain: "Started" The last TransactionEvent of a transaction SHALL contain: "Ended" All others SHALL contain: "Updated"
	unsigned char timestamp[28];									// Required. The date and time at which this transaction event occurred.
	unsigned char triggerReason[32];								// Required. Reason the Charging Station sends this message to the CSMS
	unsigned int seqNo;												// Required. Incremental sequence number, helps with determining if all messages of a transaction have been received.
	unsigned char offline;											// Optional. Indication that this transaction event happened when the Charging Station was offline. Default = false, meaning: the event occurred when the Charging Station was online.
	unsigned char numberOfPhasesUsed;								// Optional. If the Charging Station is able to report the number of phases used, then it SHALL provide it. When omitted the CSMS may be able to determine the number of phases used via device management.
	float cableMaxCurrent;											// Optional. The maximum current of the connected cable in Ampere (A).
	int reservationId;												// Optional. This contains the Id of the reservation that terminates as a result of this transaction.
	struct TransactionType transactionInfo;							// Required. Contains transaction specific information.
	struct IdTokenType idToken;										// Optional. This contains the identifier for which a transaction has to be/was started.
	struct EVSEType evse;											// Optional. This identifies which evse (and connector) of the Charging Station is used.
	struct MeterValueType meterValue[1];							// Optional. This contains the relevant meter values.
	float Response_totalCost;										// Optional. SHALL only be sent when charging has ended. Final total cost of this transaction, including taxes.
	int Response_chargingPriority;									// Optional. Priority from a business point of view. Default priority is 0,
	struct IdTokenInfoType Response_idTokenInfo;					// Optional. This contains information about authorization status, expiry and group id. Is required when the transactionEventRequest contained an idToken.
	struct MessageContentType Response_updatedPersonalMessage;		// Optional. This can contain updated personal message that can be shown to the EV Driver. This can be used to provide updated tariff information
};

struct TriggerMessage_20
{
	unsigned char requestedMessage[32];								// Required. Type of message to be triggered.
	struct EVSEType evse;											// Optional. Can be used to specifiy the EVSE and Connector if required for the message which needs to be sent.
	unsigned char Response_status[16];								// Required. Indicates whether the Charging Station will send the requested notification or not.
	unsigned char guid[37];											// Save guid from server request
};

struct UnlockConnector_20
{
	unsigned int evseId;											// Required. This contains the identifier of the EVSE for which a connector needs to be unlocked.
	unsigned char connectorId;										// Required. This contains the identifier of the connector that needs to be unlocked.
	unsigned char Response_status[32];								// Required. This indicates whether the Charging Station has unlocked the connector.
	unsigned char guid[37];											// Save guid from server request
};

struct UnpublishFirmware_20
{
	unsigned char checksum[32];										// Required. The MD5 checksum over the entire firmware file as a hexadecimal string of length 32.
	unsigned char Response_status[16];								// Required. Indicates whether the Local Controller succeeded in unpublishing the firmware.
	unsigned char guid[37];											// Save guid from server request
};

struct UpdateFirmware_20
{
	unsigned char retries;											// Optional. This specifies how many times Charging Station must try to download the firmware before giving up. If this field is not present, it is left to Charging Station to decide how many times it wants to retry.
	unsigned int retryInterval;										// Optional. The interval in seconds after which a retry may be attempted. If this field is not present, it is left to Charging Station to decide how long to wait between attempts.
	unsigned int requestId;											// Required. The Id of this request
	struct FirmwareType firmware;									// Required. Specifies the firmware to be updated on the Charging Station.
	unsigned char Response_status[32];								// Required. This field indicates whether the Charging Station was able to accept the request.
	unsigned char guid[37];											// Save guid from server request
};

struct NetworkConnectionProfile_20
{
    unsigned int slot;
    unsigned char retryCount;
    struct NetworkConnectionProfileType connectionData;
};

struct OCPP20Data
{
	unsigned char 							OcppServerURL[512];		//http: non-secure OCPP 1.5-S, https: secure OCPP 1.5-S, ws: non-secure OCPP 1.6-J, wss: secure OCPP 1.6-J"
	unsigned char 							ChargeBoxId[128];
	unsigned char 							OcppConnStatus;			//0: disconnected, 1: connected
	unsigned int 							Timeout_Secs;
	unsigned short 							Ping_Pong_Interval;
	unsigned int                            procDogTime;            // Process watch dog refresh timer
	struct ReportDataType                   ControllerComponentVariable[CtrlrVariable_CNT];
	struct NetworkConnectionProfile_20      NetworkConnectionProfile[10];

	union
	{
		//Operations Initiated by Charge Point
		unsigned char CpMsgValue[CONNECTOR_QUANTITY];
		struct
		{
			unsigned char DataTransferReq:1;
			unsigned char DataTransferConf:1;
			unsigned char ReservationStatusUpdateReq :1;
			unsigned char ReservationStatusUpdateConf :1;
			unsigned char TransactionEventReq :1;
			unsigned char TransactionEventConf :1;
			unsigned char :2;	//bit 6,7 , reserved
		} bits[CONNECTOR_QUANTITY];
	}CpMsg;

	union
	{
		//Operations Initiated by Sequence Point
		unsigned char SpMsgValue[4];
		struct
		{
			unsigned char BootNotificationReq :1;	//bit 0,
			unsigned char BootNotificationConf :1;	//bit 1,
			unsigned char AuthorizeReq :1; //bit 2,
			unsigned char AuthorizeConf :1;	//bit 3,
			unsigned char FirmwareStatusNotificationReq :1; //bit 6,
			unsigned char FirmwareStatusNotificationConf :1; //bit 7,
			unsigned char Get15118EVCertificateReq :1;
			unsigned char Get15118EVCertificateConf :1;

			unsigned char GetCertificateStatusReq :1;
			unsigned char GetCertificateStatusConf :1;
			unsigned char LogStatusNotificationReq :1;
			unsigned char LogStatusNotificationConf :1;
			unsigned char NotifyChargingLimitReq :1;
			unsigned char NotifyChargingLimitConf :1;
			unsigned char NotifyDisplayMessagesReq :1;
			unsigned char NotifyDisplayMessagesConf :1;

			unsigned char NotifyEVChargingScheduleReq :1;
			unsigned char NotifyEVChargingScheduleConf :1;
			unsigned char NotifyEventReq :1;
			unsigned char NotifyEventConf :1;
			unsigned char NotifyMonitoringReportReq :1;
			unsigned char NotifyMonitoringReportConf :1;
			unsigned char NotifyReportReq :1;
			unsigned char NotifyReportConf :1;

			unsigned char ReportChargingProfilesReq :1;
			unsigned char ReportChargingProfilesConf :1;
			unsigned char SecurityEventNotificationReq :1;
			unsigned char SecurityEventNotificationConf :1;
			unsigned char SignCertificateReq :1;
			unsigned char SignCertificateConf :1;
            unsigned char NotifyCustomerInformationReq :1;  //bit 6
            unsigned char NotifyCustomerInformationConf :1; //bit 7

		} bits;
	} SpMsg;

	union
	{
		//Operations Initiated by Central System
		unsigned char CsMsgValue[3 * (CONNECTOR_QUANTITY)];
		struct
		{
			unsigned char CancelReservationReq :1;	//bit 0,
			unsigned char CancelReservationConf :1;	//bit 1,
			unsigned char ChangeAvailabilityReq :1; //bit 2,
			unsigned char ChangeAvailabilityConf :1;	//bit 3,
			unsigned char ClearChargingProfileReq :1;	//bit 0,
			unsigned char ClearChargingProfileConf :1;	//bit 1,
			unsigned char DataTransferReq :1; //bit 2,
			unsigned char DataTransferConf :1;	//bit 3,

			unsigned char PublishFirmwareStatusNotificationReq :1;
			unsigned char PublishFirmwareStatusNotificationConf :1;
			unsigned char RequestStartTransactionReq :1;
			unsigned char RequestStartTransactionConf :1;
			unsigned char RequestStopTransactionReq :1;
			unsigned char RequestStopTransactionConf :1;
			unsigned char ReserveNowReq :1;	//bit 4,
			unsigned char ReserveNowConf :1;	//bit 5,

			unsigned char TriggerMessageReq :1;		//bit 0,
			unsigned char TriggerMessageConf :1;	//bit 1,
			unsigned char UnlockConnectorReq :1; 	//bit 2,
			unsigned char UnlockConnectorConf :1;	//bit 3,
			unsigned char :4;						//bit 6,7 , reserved

		} bits[CONNECTOR_QUANTITY];
	}CsMsg;

	union
	{
		//Operations Initiated by Main System
		unsigned char MsMsgValue[8];
		struct
		{
			//CsMsgValue[0]
			unsigned char CertificateSignedReq :1;
			unsigned char CertificateSignedConf :1;
			unsigned char ClearCacheReq :1;	//bit 2,
			unsigned char ClearCacheConf :1;	//bit 3,
			unsigned char ClearDisplayMessageReq :1;
			unsigned char ClearDisplayMessageConf :1;
			unsigned char ClearVariableMonitoringReq :1;
			unsigned char ClearVariableMonitoringConf :1;

			unsigned char CostUpdatedReq :1;
			unsigned char CostUpdatedConf :1;
			unsigned char CustomerInformationReq :1;
			unsigned char CustomerInformationConf :1;
			unsigned char DeleteCertificateReq :1;
			unsigned char DeleteCertificateConf :1;
			unsigned char GetBaseReportReq :1;
			unsigned char GetBaseReportConf :1;

			unsigned char GetChargingProfilesReq :1;
			unsigned char GetChargingProfilesConf :1;
			unsigned char GetCompositeScheduleReq :1;	//bit 4,
			unsigned char GetCompositeScheduleConf :1;	//bit 5,
			unsigned char GetDisplayMessagesReq :1;
			unsigned char GetDisplayMessagesConf :1;
			unsigned char GetInstalledCertificateIdsReq :1;
			unsigned char GetInstalledCertificateIdsConf :1;

			unsigned char GetLocalListVersionReq :1; //bit 2,
			unsigned char GetLocalListVersionConf :1;	//bit 3,
			unsigned char GetLogReq :1;
			unsigned char GetLogConf :1;
			unsigned char GetMonitoringReportReq :1;
			unsigned char GetMonitoringReportConf :1;
			unsigned char GetReportReq :1;
			unsigned char GetReportConf :1;

			unsigned char GetTransactionStatusReq :1;
			unsigned char GetTransactionStatusConf :1;
			unsigned char GetVariablesReq :1;
			unsigned char GetVariablesConf :1;
			unsigned char InstallCertificateReq :1;
			unsigned char InstallCertificateConf :1;
			unsigned char PublishFirmwareReq :1;
			unsigned char PublishFirmwareConf :1;

			unsigned char ResetReq :1; //bit 4,
			unsigned char ResetConf :1;	//bit 5,
			unsigned char SendLocalListReq :1;	//bit 6,
			unsigned char SendLocalListConf :1;	//bit 7,
			unsigned char SetChargingProfileReq :1;	//bit 6,
			unsigned char SetChargingProfileConf :1;	//bit 7,
			unsigned char SetDisplayMessageReq :1;
			unsigned char SetDisplayMessageConf :1;

			unsigned char SetMonitoringBaseReq :1;
			unsigned char SetMonitoringBaseConf :1;
			unsigned char SetMonitoringLevelReq :1;
			unsigned char SetMonitoringLevelConf :1;
			unsigned char SetNetworkProfileReq :1;
			unsigned char SetNetworkProfileConf :1;
			unsigned char SetVariableMonitoringReq :1;
			unsigned char SetVariableMonitoringConf :1;

			unsigned char SetVariablesReq :1;
			unsigned char SetVariablesConf :1;
			unsigned char UnpublishFirmwareReq :1;
			unsigned char UnpublishFirmwareConf :1;
			unsigned char UpdateFirmwareReq :1;
			unsigned char UpdateFirmwareConf :1;
            unsigned char isRemoteStartWaitReq :1;
            unsigned char :1;
		} bits;
	} MsMsg;

	union
	{
		//Operations triggered by CSU
		unsigned char CSUMsgValue[CONNECTOR_QUANTITY];
		struct
		{
			//CSUMsgValue[0]
			unsigned char ChargingProfileReq:1;	//bit 0,
			unsigned char ChargingProfileConf:1;	//bit 0,
            unsigned char ClearedChargingLimitReq :1;
            unsigned char ClearedChargingLimitConf :1;
            unsigned char NotifyEVChargingNeedsReq :1;
            unsigned char NotifyEVChargingNeedsConf :1;
            unsigned char :2;   //bit 1,2,3,4,5,6,7 , reserved
		} bits[CONNECTOR_QUANTITY];
	}CSUMsg;

	struct Authorize_20 						Authorize;
	struct BootNotification_20 					BootNotification;
	struct CancelReservation_20					CancelReservation[CONNECTOR_QUANTITY];
	struct CertificateSigned_20					CertificateSigned;
	struct ChangeAvailability_20				ChangeAvailability[CONNECTOR_QUANTITY];
	struct ClearCache_20						ClearCache;
	struct ClearChargingProfile_20				ClearChargingProfile[CONNECTOR_QUANTITY];
	struct ClearDisplayMessage_20				ClearDisplayMessage;
	struct ClearedChargingLimit_20				ClearedChargingLimit[CONNECTOR_QUANTITY];
	struct ClearVariableMonitoring_20			ClearVariableMonitoring;
	struct CostUpdated_20						CostUpdated;
	struct CustomerInformation_20				CustomerInformation;
	struct DataTransfer_20						DataTransfer[CONNECTOR_QUANTITY];
	struct DeleteCertificate_20					DeleteCertificate;
	struct FirmwareStatusNotification_20		FirmwareStatusNotification;
	struct Get15118EVCertificate_20				Get15118EVCertificate;
	struct GetBaseReport_20						GetBaseReport;
	struct GetCertificateStatus_20				GetCertificateStatus;
	struct GetChargingProfiles_20				GetChargingProfiles[CONNECTOR_QUANTITY];
	struct GetCompositeSchedule_20				GetCompositeSchedule[CONNECTOR_QUANTITY];
	struct GetDisplayMessages_20				GetDisplayMessages;
	struct GetInstalledCertificateIds_20		GetInstalledCertificateIds;
	struct GetLocalListVersion_20				GetLocalListVersion;
	struct GetLog_20							GetLog;
	struct GetMonitoringReport_20				GetMonitoringReport;
	struct GetReport_20							GetReport;
	struct GetTransactionStatus_20				GetTransactionStatus[CONNECTOR_QUANTITY];
	struct GetVariables_20						GetVariables;
	struct Heartbeat_20							Heartbeat;
	struct InstallCertificate_20				InstallCertificate;
	struct LogStatusNotification_20				LogStatusNotification;
	struct MeterValues_20						MeterValues[CONNECTOR_QUANTITY];
	struct NotifyChargingLimit_20				NotifyChargingLimit[CONNECTOR_QUANTITY];
	struct NotifyCustomerInformation_20			NotifyCustomerInformation;
	struct NotifyDisplayMessages_20				NotifyDisplayMessages;
	struct NotifyEVChargingNeeds_20				NotifyEVChargingNeeds[CONNECTOR_QUANTITY];
	struct NotifyEVChargingSchedule_20			NotifyEVChargingSchedule[CONNECTOR_QUANTITY];
	struct NotifyEvent_20						NotifyEvent;
	struct NotifyMonitoringReport_20			NotifyMonitoringReport;
	struct NotifyReport_20						NotifyReport;
	struct PublishFirmware_20					PublishFirmware;
	struct PublishFirmwareStatusNotification_20	PublishFirmwareStatusNotificatio;
	struct ReportChargingProfiles_20			ReportChargingProfiles[CONNECTOR_QUANTITY];
	struct RequestStartTransaction_20			RequestStartTransaction[CONNECTOR_QUANTITY];
	struct RequestStopTransaction_20			RequestStopTransaction[CONNECTOR_QUANTITY];
	struct ReservationStatusUpdate_20			ReservationStatusUpdate[CONNECTOR_QUANTITY];
	struct ReserveNow_20						ReserveNow[CONNECTOR_QUANTITY];
	struct Reset_20								Reset;
	struct SecurityEventNotification_20			SecurityEventNotification;
	struct SendLocalList_20						SendLocalList;
	struct SetChargingProfile_20				SetChargingProfile[CONNECTOR_QUANTITY];
	struct SetDisplayMessage_20					SetDisplayMessage;
	struct SetMonitoringBase_20					SetMonitoringBase;
	struct SetMonitoringLevel_20				SetMonitoringLevel;
	struct SetNetworkProfile_20					SetNetworkProfile;
	struct SetVariableMonitoring_20				SetVariableMonitoring;
	struct SetVariables_20						SetVariables;
	struct SignCertificate_20					SignCertificate;
	struct StatusNotification_20				StatusNotification[CONNECTOR_QUANTITY];
	struct TransactionEvent_20					TransactionEvent[CONNECTOR_QUANTITY];
	struct TriggerMessage_20					TriggerMessage;
	struct UnlockConnector_20					UnlockConnector[CONNECTOR_QUANTITY];
	struct UnpublishFirmware_20					UnpublishFirmware;
	struct UpdateFirmware_20					UpdateFirmware;
	struct ChargingProfileType                  SmartChargingProfile[CONNECTOR_QUANTITY];
	struct ChargingProfileType                  MaxChargingProfile;
	struct StructSessionTarget                  SessionTarget[CONNECTOR_QUANTITY];
};

#endif // DEFINE_H_