2020.08.09 / Folus Wen

Actions:
1. define.h add OCPP 2.0 share memory structure.

Files:
1. As follow commit history

Image version: D0.00.XX.XXXX.XX
Image checksum: XXXXXXXX

Hardware PWB P/N : XXXXXXX
Hardware Version : XXXXXXX

EVSE/Projects/define.h

@@ -3981,6 +3981,1436 @@ struct OCPP16Data
 		struct StructChargingProfile		    SmartChargingProfile[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];		
 };
 
+
+/**************************************************************************************/
+/************************* OCPP 2.0 Share memory **************************************/
+/**************************************************************************************/
+/*
+ * =============== 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[36];						// 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[36];									// 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[36];									// 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 CertificateHashDataType
+{
+	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.
+};
+
+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 SalesTariffType salesTariff;								// Optional. Sales tariff associated with this charging schedule.
+};
+
+struct ChargingProfileType
+{
+	unsigned short 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[36];								// 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[36];								// 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 FirmwareType
+{
+	unsigned char location[512];									// Required. URI defining the origin of the firmware.
+	unsigned char retrieveDateTime[28];								// Required. Date and time at which the firmware shall be retrieved.
+	unsigned char installDateTime[28];								// Optional. Date and time at which the firmware shall be installed.
+	unsigned char signingCertificate[5500];							// Optional. Certificate with which the firmware was signed. X.509 certificate, first DER encoded into binary, and then Base64 encoded.
+	unsigned char signature[800];									// Optional. Base64 encoded firmware signature.
+};
+
+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 LogParametersType
+{
+	unsigned char remoteLocation[512];								// Required. The URL of the location at the remote system where the log should be stored.
+	unsigned char oldestTimestamp[28];								// Optional. This contains the date and time of the oldest logging information to include in the diagnostics.
+	unsigned char latestTimestamp[28];								// Optional. This contains the date and time of the latest logging information to include in the diagnostics.
+};
+
+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[36];								// 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
+{
+	float 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 meterValue[10];							// 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[36];								// 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.
+};
+
+/*
+ * =============== 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.
+};
+
+struct CertificateSigned_20
+{
+	unsigned char certificate[10][5500];							// Required. The signed X.509 certificate, first DER encoded into binary, and then Base64 encoded. This can also contain the necessary sub CA certificates. In that case, the order should follow the certificate chain, starting from the leaf certificate.
+	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 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.
+};
+
+struct ClearCache_20
+{
+	unsigned char Response_status[16];								// Required. Accepted if the Charging Station has executed the request, otherwise rejected.
+};
+
+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.
+};
+
+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.
+};
+
+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.
+};
+
+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[36];								// Required. Transaction Id of the transaction the current cost are asked for.
+};
+
+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.
+};
+
+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.
+};
+
+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.
+};
+
+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.
+};
+
+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[5500];						// 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 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.
+};
+
+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.
+};
+
+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
+};
+
+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.
+};
+
+struct GetLocalListVersion_20
+{
+	int Response_versionNumber;										// Required. This contains the current version number of the local authorization list in the Charging Station.
+};
+
+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.
+};
+
+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.
+};
+
+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.
+};
+
+struct GetTransactionStatus_20
+{
+	unsigned char transactionId[36];								// 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.
+};
+
+struct GetVariables_20
+{
+	struct GetVariableDataType getVariableData[10];					// Required. List of requested variables.
+	struct GetVariableResultType Response_getVariableResult[10];	// Required. List of requested variables and their values.
+};
+
+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[5500];								// 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.
+};
+
+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[10];							// 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[10];				// 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 NotifyDisplayMessages;								// 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 status[16];										// Required. Indicates whether the request was accepted.
+};
+
+struct PublishFirmwareStatusNotification_20
+{
+	unsigned char status[32];										// Required. This contains the progress status of the publishfirmware installation.
+	unsigned char location[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[10];					// 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[36];						// 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.
+};
+
+struct RequestStopTransaction_20
+{
+	unsigned char transactionId[36];								// 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.
+};
+
+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.
+};
+
+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.
+};
+
+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.
+};
+
+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.
+};
+
+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.
+};
+
+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.
+};
+
+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.
+};
+
+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.
+};
+
+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.
+};
+
+struct SetVariables_20
+{
+	struct SetVariableDataType setVariableData[10];					// Required. List of Component-Variable pairs and attribute values to set.
+	struct SetVariableResultType Response_setVariableResult[10];	// Required. List of result statuses per Component-Variable.
+};
+
+struct SignCertificate_20
+{
+	unsigned char csr[5500];										// 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 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[10];							// 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.
+};
+
+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.
+};
+
+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.
+};
+
+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.
+};
+
+/*
+ *  =============== Controller component ===============
+ */
+enum OCPPCommCtrlrVariable
+{
+	OCPPCommCtrlr_ActiveNetworkProfile=0,
+	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
+};
+
+enum DeviceDataCtrlrVariable
+{
+	DeviceDataCtrlr_GetReport_ItemsPerMessage=0,
+	DeviceDataCtrlr_GetVariables_ItemsPerMessage,
+	DeviceDataCtrlr_GetReport_BytesPerMessage,
+	DeviceDataCtrlr_GetVariables_BytesPerMessage,
+	DeviceDataCtrlr_ConfigurationValueSize,
+	DeviceDataCtrlr_ReportingValueSize,
+	DeviceDataCtrlr_SetVariables_ItemsPerMessage,
+	DeviceDataCtrlr_SetVariables_BytesPerMessage
+};
+
+enum ClockCtrlrVariable
+{
+	ClockCtrlr_DateTime=0,
+	ClockCtrlr_NtpSource,
+	ClockCtrlr_NtpServerUri,
+	ClockCtrlr_TimeOffset,
+	ClockCtrlr_NextTimeOffsetTransitionDateTime,
+	ClockCtrlr_NextTransition_TimeOffset,
+	ClockCtrlr_TimeSource,
+	ClockCtrlr_TimeZone
+};
+
+enum SecurityCtrlrVariable
+{
+	SecurityCtrlr_BasicAuthPassword=0,
+	SecurityCtrlr_Identity,
+	SecurityCtrlr_OrganizationName,
+	SecurityCtrlr_CertificateEntries,
+	SecurityCtrlr_SecurityProfile,
+	SecurityCtrlr_AdditionalRootCertificateCheck
+};
+
+enum AuthCtrlrVariable
+{
+	AuthCtrlr_Enabled=0,
+	AuthCtrlr_AdditionalInfoItemsPerMessage,
+	AuthCtrlr_OfflineTxForUnknownIdEnabled,
+	AuthCtrlr_AuthorizeRemoteStart,
+	AuthCtrlr_LocalAuthorizeOffline,
+	AuthCtrlr_LocalPreAuthorize,
+	AuthCtrlr_MasterPassGroupId
+};
+
+enum AuthCacheCtrlrVariable
+{
+	AuthCacheCtrlr_Enabled=0,
+	AuthCacheCtrlr_Available,
+	AuthCacheCtrlr_LifeTime,
+	AuthCacheCtrlr_Storage,
+	AuthCacheCtrlr_Policy
+};
+
+enum LocalAuthListCtrlrVariable
+{
+	LocalAuthListCtrlr_Enabled=0,
+	LocalAuthListCtrlr_Entries,
+	LocalAuthListCtrlr_Available,
+	LocalAuthListCtrlr_ItemsPerMessage,
+	LocalAuthListCtrlr_BytesPerMessage,
+	LocalAuthListCtrlr_Storage
+};
+
+enum TxCtrlrVariable
+{
+	TxCtrlr_ChargingBeforeAcceptedEnabled=0,
+	TxCtrlr_EVConnectionTimeOut,
+	TxCtrlr_StopTxOnEVSideDisconnect,
+	TxCtrlr_TxBeforeAcceptedEnabled,
+	TxCtrlr_TxStartPoint,
+	TxCtrlr_TxStopPoint,
+	TxCtrlr_MaxEnergyOnInvalidId,
+	TxCtrlr_StopTxOnInvalidId
+};
+
+enum SampledDataCtrlrVariable
+{
+	SampledDataCtrlr_Enabled=0,
+	SampledDataCtrlr_Available,
+	SampledDataCtrlr_SignReadings,
+	SampledDataCtrlr_TxEndedMeasurands,
+	SampledDataCtrlr_TxEndedInterval,
+	SampledDataCtrlr_TxStartedMeasurands,
+	SampledDataCtrlr_TxUpdatedMeasurands,
+	SampledDataCtrlr_TxUpdatedInterval
+};
+
+enum AlignedDataCtrlrVariable
+{
+	AlignedDataCtrlr_Enabled=0,
+	AlignedDataCtrlr_Available,
+	AlignedDataCtrlr_Measurands,
+	AlignedDataCtrlr_Interval,
+	AlignedDataCtrlr_SendDuringIdle,
+	AlignedDataCtrlr_SignReadings,
+	AlignedDataCtrlr_TxEndedMeasurands,
+	AlignedDataCtrlr_TxEndedInterval
+};
+
+enum ReservationCtrlrVariable
+{
+	ReservationCtrlr_Enabled=0,
+	ReservationCtrlr_Available,
+	ReservationCtrlr_NonEvseSpecific
+};
+
+enum SmartChargingCtrlrVariable
+{
+	SmartChargingCtrlr_Enabled=0,
+	SmartChargingCtrlr_Available,
+	SmartChargingCtrlr_ACPhaseSwitchingSupported,
+	SmartChargingCtrlr_ProfileStackLevel,
+	SmartChargingCtrlr_RateUnit,
+	SmartChargingCtrlr_PeriodsPerSchedule,
+	SmartChargingCtrlr_ExternalControlSignalsEnabled,
+	SmartChargingCtrlr_NotifyChargingLimitWithSchedules,
+	SmartChargingCtrlr_Phases3to1,
+	SmartChargingCtrlr_Entries,
+	SmartChargingCtrlr_LimitChangeSignificance
+};
+
+enum TariffCostCtrlrVariable
+{
+	Tariff_Enabled=0,
+	Tariff_Available,
+	Tariff_TariffFallbackMessage,
+	Cost_Enabled,
+	Cost_Available,
+	Cost_TotalCostFallbackMessage,
+	Cost_Currency
+};
+
+enum MonitoringCtrlrVariable
+{
+	MonitoringCtrlr_Enabled=0,
+	MonitoringCtrlr_Available,
+	MonitoringCtrlr_ClearVariableMonitoring_ItemsPerMessage,
+	MonitoringCtrlr_SetVariableMonitoring_ItemsPerMessage,
+	MonitoringCtrlr_ClearVariableMonitoring_BytesPerMessage,
+	MonitoringCtrlr_SetVariableMonitoring_BytesPerMessage,
+	MonitoringCtrlr_OfflineQueuingSeverity
+};
+
+enum DisplayMessageCtrlrVariable
+{
+	DisplayMessageCtrlr_Enabled=0,
+	DisplayMessageCtrlr_Available,
+	DisplayMessageCtrlr_DisplayMessages,
+	DisplayMessageCtrlr_SupportedFormats,
+	DisplayMessageCtrlr_SupportedPriorities
+};
+
+enum CustomizationCtrlrVariable
+{
+	CustomizationCtrlr_CustomImplementationEnabled=0
+};
+
+enum ChargingStationVariable
+{
+	ChargingStation_Available=0,
+	ChargingStation_AvailabilityState,
+	ChargingStation_SupplyPhases
+};
+
+enum EVSEVariable
+{
+	EVSE_Available=0,
+	EVSE_AvailabilityState,
+	EVSE_SupplyPhases,
+	EVSE_Power
+};
+
+enum ConnectorVariable
+{
+	Connector_Available=0,
+	Connector_ConnectorType,
+	Connector_SupplyPhases
+};
+
+struct OCPP20ControllerConponent
+{
+	struct ReportDataType OCPPCommCtrlr[14];
+	struct ReportDataType DeviceDataCtrlr[6];
+	struct ReportDataType ClockCtrlr[8];
+	struct ReportDataType SecurityCtrlr[6];
+	struct ReportDataType AuthCtrlr[7];
+	struct ReportDataType AuthCacheCtrlr[5];
+	struct ReportDataType LocalAuthListCtrlr[6];
+	struct ReportDataType TxCtrlr[8];
+	struct ReportDataType SampledDataCtrlr[8];
+	struct ReportDataType AlignedDataCtrlr[8];
+	struct ReportDataType ReservationCtrlr[3];
+	struct ReportDataType SmartChargingCtrlr[11];
+	struct ReportDataType TariffCostCtrlr[7];
+	struct ReportDataType MonitoringCtrlr[7];
+	struct ReportDataType DisplayMessageCtrlr[5];
+	struct ReportDataType CustomizationCtrlr[1];
+	struct ReportDataType ChargingStation[3];
+	struct ReportDataType EVSE[4];
+	struct ReportDataType Connector[4];
+};
+
+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;
+	struct OCPP20ControllerConponent 		ControllerComponent;
+
+	union
+	{
+		//Operations Initiated by Charge Point
+		unsigned char CpMsgValue[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY + AC_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[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY + AC_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 NotifyEVChargingNeedsReq :1;
+			unsigned char NotifyEVChargingNeedsConf :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;
+
+		} bits;
+	} SpMsg;
+
+	union
+	{
+		//Operations Initiated by Central System
+		unsigned char CsMsgValue[3 * (CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY + AC_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[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY + AC_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 ClearedChargingLimitReq :1;
+			unsigned char ClearedChargingLimitConf :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;	//bit 6,
+			unsigned char UpdateFirmwareConf :1;	//bit 7,
+		} bits;
+	} MsMsg;
+
+	union
+	{
+		//Operations triggered by CSU
+		unsigned char CSUMsgValue[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY + AC_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[CHAdeMO_QUANTITY + CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	}CSUMsg;
+
+	struct Authorize_20 						Authorize;
+	struct BootNotification_20 					BootNotification;
+	struct CancelReservation_20					CancelReservation[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct CertificateSigned_20					CertificateSigned;
+	struct ChangeAvailability_20				ChangeAvailability[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct ClearCache_20						ClearCache;
+	struct ClearChargingProfile_20				ClearChargingProfile[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct ClearDisplayMessage_20				ClearDisplayMessage;
+	struct ClearedChargingLimit_20				ClearedChargingLimit[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct ClearVariableMonitoring_20			ClearVariableMonitoring;
+	struct CostUpdated_20						CostUpdated;
+	struct CustomerInformation_20				CustomerInformation;
+	struct DataTransfer_20						DataTransfer[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_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[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct GetCompositeSchedule_20				GetCompositeSchedule[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_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[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct GetVariables_20						GetVariables;
+	struct Heartbeat_20							Heartbeat;
+	struct InstallCertificate_20				InstallCertificate;
+	struct LogStatusNotification_20				LogStatusNotification;
+	struct MeterValues_20						MeterValues[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct NotifyChargingLimit_20				NotifyChargingLimit[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct NotifyCustomerInformation_20			NotifyCustomerInformation;
+	struct NotifyDisplayMessages_20				NotifyDisplayMessages;
+	struct NotifyEVChargingNeeds_20				NotifyEVChargingNeeds[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct NotifyEVChargingSchedule_20			NotifyEVChargingSchedule[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_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[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct RequestStartTransaction_20			RequestStartTransaction[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct RequestStopTransaction_20			RequestStopTransaction[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct ReservationStatusUpdate_20			ReservationStatusUpdate[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct ReserveNow_20						ReserveNow[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct Reset_20								Reset;
+	struct SecurityEventNotification_20			SecurityEventNotification;
+	struct SendLocalList_20						SendLocalList;
+	struct SetChargingProfile_20				SetChargingProfile[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_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[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct TransactionEvent_20					TransactionEvent[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct TriggerMessage_20					TriggerMessage;
+	struct UnlockConnector_20					UnlockConnector[CHAdeMO_QUANTITY+ CCS_QUANTITY + GB_QUANTITY + AC_QUANTITY];
+	struct UnpublishFirmware_20					UnpublishFirmware;
+	struct UpdateFirmware_20					UpdateFirmware;
+};
+
 #endif // DEFINE_H_