/*===========================================================================
                    Combined Charging System (CCS): SECC
                                 api.c

                          initiated by Joseph
                           (since 2019/08/07)
=============================================================================*/
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <linux/termios.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/mman.h>
#include <linux/sockios.h>
#include <linux/socket.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <sys/timeb.h>
#include <math.h>//for pow
#include <unistd.h>
#include <linux/if_packet.h>
#include <netinet/if_ether.h>
#include <net/if.h>
#include <netinet/ether.h>
#include <linux/can.h>
#include <linux/can/raw.h>

#include "api.h"
#include "../../SeccComm.h"
//#include "../../CsuComm.h"
#include "../../define.h"
#include "../codec/EXITypes.h"

/* Activate support for DIN */
#include "../din/dinEXIDatatypes.h"
#if DEPLOY_DIN_CODEC == SUPPORT_YES
#include "../din/dinEXIDatatypesEncoder.h"
#include "../din/dinEXIDatatypesDecoder.h"
#endif /* DEPLOY_DIN_CODEC == SUPPORT_YES */

/* Activate support for XMLDSIG */
#include "../xmldsig/xmldsigEXIDatatypes.h"
#if DEPLOY_XMLDSIG_CODEC == SUPPORT_YES
#include "../xmldsig/xmldsigEXIDatatypesEncoder.h"
#include "../xmldsig/xmldsigEXIDatatypesDecoder.h"
#endif /* DEPLOY_XMLDSIG_CODEC == SUPPORT_YES */

/* Activate support for ISO1 */
#include "../iso1/iso1EXIDatatypes.h"
#if DEPLOY_ISO1_CODEC == SUPPORT_YES
#include "../iso1/iso1EXIDatatypesEncoder.h"
#include "../iso1/iso1EXIDatatypesDecoder.h"
#endif /* DEPLOY_ISO1_CODEC == SUPPORT_YES */

/* Activate support for ISO2 */
#include "../iso2/iso2EXIDatatypes.h"
#if DEPLOY_ISO2_CODEC == SUPPORT_YES
#include "../iso2/iso2EXIDatatypesEncoder.h"
#include "../iso2/iso2EXIDatatypesDecoder.h"
#endif /* DEPLOY_ISO2_CODEC == SUPPORT_YES */

#include "../transport/v2gtp.h"

extern struct SysConfigAndInfo *ShmSysConfigAndInfo;
extern struct StatusCodeData *ShmStatusCodeData;
extern struct CcsData *ShmCcsData;
extern struct InternalComm *ShmInternalComm;
//extern struct InternalCommAC *ShmInternalCommAC;

/*Preserve V2GTP Rx and Tx Buffer*/
//unsigned char V2GTP_Rx_buf[V2GTP_MSG_RX_BUFFER_SIZE];	//(64*1024)   //65,536 = 65.5KB
unsigned char V2GTP_Tx_buf[V2GTP_MSG_TX_BUFFER_SIZE];		//(64*1024)   //65,536 = 65.5KB


bitstream_t iStream;	//for V2GTP Message
struct appHandEXIDocument exiDoc;	//for decoded V2GTP messages, i.e. EXI DOC (XML)

unsigned char buf_log_exi_api[256];


/*===========================================================================
FUNCTION: printASCIIString
DESCRIPTION:
PRE-CONDITION:
INPUT:
			1. exi_doc_DIN
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
static void printASCIIString(exi_string_character_t* string, uint16_t len)
{
	unsigned int i = 0;

	for(i = 0; i < len; i++)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("%c", (char)string[i]);
	}
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n");
}

/*===========================================================================
FUNCTION: writeStringToEXIString
DESCRIPTION:
PRE-CONDITION:
INPUT:
			1. exi_doc_DIN
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
static int writeStringToEXIString(char* string, exi_string_character_t* exiString)
{
	int pos = 0;
	while(string[pos]!='\0')
	{
		exiString[pos] = string[pos];
		pos++;
	}

	return pos;
}

/*===========================================================================
FUNCTION: PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN
DESCRIPTION:
PRE-CONDITION:
INPUT:
			1. exi_doc_DIN
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
int Check_V2G_Rx_Msg_Name_din(struct dinEXIDocument *exi_doc_DIN)
{
	int errn = 0;

	//Session Setup (0a ⇄ 0b)
	if (exi_doc_DIN->V2G_Message.Body.SessionSetupReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] SessionSetupReq_isUsed: YES (0a ⇄ 0b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = SessionSetupRequest;
	}
	//Service Discovery (1a ⇄ 1b)
	else if (exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] ServiceDiscoveryReq_isUsed: YES (1a ⇄ 1b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceDiscoveryRequest;
	}
	//Service Payment Selection (2a ⇄ 2b)
	else if (exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] ServicePaymentSelectionReq_isUsed: YES (2a ⇄ 2b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceAndPaymentSelectionRequest;
	}
	//Contract Contract Authentication (Xa ⇄ Xb)
	else if (exi_doc_DIN->V2G_Message.Body.ContractAuthenticationReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] ContractAuthenticationReq_isUsed: YES (Xa ⇄ Xb)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = AuthorizationRequest;
	}
	//Charge Parameter Discovery (3a ⇄ 3b)
	else if (exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] ChargeParameterDiscoveryReq_isUsed: YES (3a ⇄ 3b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = ChargeParameterDiscoveryRequest;
	}
	//Cable Check (4a ⇄ 4b)
	else if (exi_doc_DIN->V2G_Message.Body.CableCheckReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] CableCheckReq_isUsed: YES (4a ⇄ 4b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = CableCheckRequest;
	}
	//Precharge (5a ⇄ 5b)
	else if (exi_doc_DIN->V2G_Message.Body.PreChargeReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] PreChargeReq_isUsed: YES (5a ⇄ 5b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = PreChargeRequest;
	}
	//Power Delivery (6a ⇄ 6b)
	else if (exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] PowerDeliveryReq_isUsed: YES (6a ⇄ 6b)\n");

		if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre == PreChargeRequest)
		{
			EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStart;
		}
		else
		{
			EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStop;
		}
	}
	//Current Demand (7a ⇄ 7b)
	else if (exi_doc_DIN->V2G_Message.Body.CurrentDemandReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] CurrentDemandReq_isUsed: YES (7a ⇄ 7b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = CurrentDemandRequest;
	}
	//Welding Detection (9a ⇄ 9b)
	else if (exi_doc_DIN->V2G_Message.Body.WeldingDetectionReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] WeldingDetectionReq_isUsed: YES (9a ⇄ 9b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = WeldingDetectionRequest;
	}
	//Session Stop (10a ⇄ 10b)
	else if (exi_doc_DIN->V2G_Message.Body.SessionStopReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] SessionStopReq_isUsed: YES (10a ⇄ 10b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = SessionStopRequest;
	}
	else
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]unidentified V2G_Rx_Msg\n");
		errn = -1;
	}

	//Compare with the previous Message
	if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre != EVCOMM_SYS_INFO.V2G_Rx_Msg)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[V2G_RX_MSG]%d >> %d\n",
										EVCOMM_SYS_INFO.V2G_Rx_Msg_pre,
										EVCOMM_SYS_INFO.V2G_Rx_Msg);
		EVCOMM_SYS_INFO.V2G_Rx_Msg_pre = EVCOMM_SYS_INFO.V2G_Rx_Msg;
	}

	return errn;
}

/*===========================================================================
FUNCTION: PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1
DESCRIPTION:
PRE-CONDITION:
INPUT:
			1. exi_doc_ISO1
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
int Check_V2G_Rx_Msg_Name_iso1(struct iso1EXIDocument *exi_doc_ISO1)
{
	int errn = 0;

	//Session Setup (0a ⇄ 0b)
	if (exi_doc_ISO1->V2G_Message.Body.SessionSetupReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] SessionSetupReq_isUsed: YES (0a ⇄ 0b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = SessionSetupRequest;
	}
	//Service Discovery (1a ⇄ 1b)
	else if (exi_doc_ISO1->V2G_Message.Body.ServiceDiscoveryReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] ServiceDiscoveryReq_isUsed: YES (1a ⇄ 1b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceDiscoveryRequest;
	}
	//Service Detail
	else if (exi_doc_ISO1->V2G_Message.Body.ServiceDetailReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] ServiceDetailReq_isUsed: YES\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceDetailRequest;
	}
	//Payment Service Selection (2a ⇄ 2b)
	else if (exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] PaymentServiceSelectionReq_isUsed: YES (2a ⇄ 2b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceAndPaymentSelectionRequest;
	}
	//Payment Details
	else if (exi_doc_ISO1->V2G_Message.Body.PaymentDetailsReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] PaymentDetailsReq_isUsed: YES\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = PaymentDetailsRequest;
	}
	//Authorization (Xa ⇄ Xb)
	else if (exi_doc_ISO1->V2G_Message.Body.AuthorizationReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] AuthorizationReq_isUsed: YES (Xa ⇄ Xb)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = AuthorizationRequest;
	}
	//Certificate Update
	else if (exi_doc_ISO1->V2G_Message.Body.CertificateUpdateReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] CertificateUpdateReq_isUsed: YES\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = CertificateUpdateRequest;
	}
	//Certificate Installation
	else if (exi_doc_ISO1->V2G_Message.Body.CertificateInstallationReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] CertificateInstallationReq_isUsed: YES\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = CertificateInstallationRequest;
	}
	//Charge Parameter Discovery (3a ⇄ 3b)
	else if (exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] ChargeParameterDiscoveryReq_isUsed: YES (3a ⇄ 3b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = ChargeParameterDiscoveryRequest;
	}
	//Cable Check (4a ⇄ 4b)
	else if (exi_doc_ISO1->V2G_Message.Body.CableCheckReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] CableCheckReq_isUsed: YES (4a ⇄ 4b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = CableCheckRequest;
	}
	//Precharge (5a ⇄ 5b)
	else if (exi_doc_ISO1->V2G_Message.Body.PreChargeReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] PreChargeReq_isUsed: YES (5a ⇄ 5b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = PreChargeRequest;
	}
	//Power Delivery (6a ⇄ 6b)
	else if (exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] PowerDeliveryReq_isUsed: YES (6a ⇄ 6b)\n");

		//For DC
		if (CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED)
		{
			if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre == PreChargeRequest)
			{
				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStart;
			}
			else
			{
				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStop;
			}
		}
		//For AC
		else if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
		{
			if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre == ChargeParameterDiscoveryRequest)
			{
				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStart;
			}
			else
			{
				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStop;
			}
		}
		else
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]unexpected CCS_ENERGY_TRANSFER_MODE(%d)\n", CCS_ENERGY_TRANSFER_MODE);
			errn = -2;
		}
	}
	//Current Demand (7a ⇄ 7b)
	else if (exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] CurrentDemandReq_isUsed: YES (7a ⇄ 7b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = CurrentDemandRequest;
	}
	//Charging Status
	else if (exi_doc_ISO1->V2G_Message.Body.ChargingStatusReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] ChargingStatusReq_isUsed: YES (7a ⇄ 7b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = ChargingStatusRequest;
	}
	//Metering Receipt
	else if (exi_doc_ISO1->V2G_Message.Body.MeteringReceiptReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] MeteringReceiptReq_isUsed: YES\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = MeteringReceiptRequest;
	}
	//Welding Detection (9a ⇄ 9b)
	else if (exi_doc_ISO1->V2G_Message.Body.WeldingDetectionReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] WeldingDetectionReq_isUsed: YES (9a ⇄ 9b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = WeldingDetectionRequest;
	}
	//Session Stop (10a ⇄ 10b)
	else if (exi_doc_ISO1->V2G_Message.Body.SessionStopReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] SessionStopReq_isUsed: YES (10a ⇄ 10b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = SessionStopRequest;
	}
	else
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]unidentified V2G_Rx_Msg\n");
		errn = -1;
	}

	//Compare with the previous Message
	if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre != EVCOMM_SYS_INFO.V2G_Rx_Msg)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[V2G_RX_MSG]%d >> %d\n",
										EVCOMM_SYS_INFO.V2G_Rx_Msg_pre,
										EVCOMM_SYS_INFO.V2G_Rx_Msg);
		EVCOMM_SYS_INFO.V2G_Rx_Msg_pre = EVCOMM_SYS_INFO.V2G_Rx_Msg;
	}

	return errn;
}

/*===========================================================================
FUNCTION: PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2
DESCRIPTION:
PRE-CONDITION:
INPUT:
			1. exi_doc_ISO2
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
int Check_V2G_Rx_Msg_Name_iso2(struct iso2EXIDocument *exi_doc_ISO2)
{
	int errn = 0;

	//V2GRequest_isUsed
	if (exi_doc_ISO2->V2G_Message.Body.V2GRequest_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] V2GRequest_isUsed: YES\n");
		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
	}
	//DisconnectChargingDeviceReq_isUsed
	else if (exi_doc_ISO2->V2G_Message.Body.DisconnectChargingDeviceReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] DisconnectChargingDeviceReq_isUsed: YES\n");
		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
	}
	//ConnectChargingDeviceReq_isUsed
	else if (exi_doc_ISO2->V2G_Message.Body.ConnectChargingDeviceReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] ConnectChargingDeviceReq_isUsed: YES\n");
		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
	}
	//SystemStatusReq_isUsed
	else if (exi_doc_ISO2->V2G_Message.Body.SystemStatusReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] SystemStatusReq_isUsed: YES\n");
		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
	}
	//DC_BidirectionalControlReq_isUsed
	else if (exi_doc_ISO2->V2G_Message.Body.DC_BidirectionalControlReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] DC_BidirectionalControlReq_isUsed: YES\n");
		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
	}
	//AC_BidirectionalControlReq_isUsed
	else if (exi_doc_ISO2->V2G_Message.Body.AC_BidirectionalControlReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] AC_BidirectionalControlReq_isUsed: YES\n");
		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
	}
	//VehicleCheckOutReq_isUsed
	else if (exi_doc_ISO2->V2G_Message.Body.VehicleCheckOutReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] VehicleCheckOutReq_isUsed: YES\n");
		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
	}
	//VehicleCheckInReq_isUsed
	else if (exi_doc_ISO2->V2G_Message.Body.VehicleCheckInReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] VehicleCheckInReq_isUsed: YES\n");
		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
	}
	//PowerDemandReq_isUsed
	else if (exi_doc_ISO2->V2G_Message.Body.PowerDemandReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] PowerDemandReq_isUsed: YES\n");
		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
	}
	//PairingReq_isUsed
	else if (exi_doc_ISO2->V2G_Message.Body.PairingReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] PairingReq_isUsed: YES\n");
		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
	}
	//AlignmentCheckReq_isUsed
	else if (exi_doc_ISO2->V2G_Message.Body.AlignmentCheckReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] AlignmentCheckReq_isUsed: YES\n");
		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
	}
	//FinePositioningReq_isUsed
	else if (exi_doc_ISO2->V2G_Message.Body.FinePositioningReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] FinePositioningReq_isUsed: YES\n");
		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
	}
	//FinePositioningSetupReq_isUsed
	else if (exi_doc_ISO2->V2G_Message.Body.FinePositioningSetupReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] FinePositioningSetupReq_isUsed: YES\n");
		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
	}
	//Session Setup (0a ⇄ 0b)
	else if (exi_doc_ISO2->V2G_Message.Body.SessionSetupReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] SessionSetupReq_isUsed: YES (0a ⇄ 0b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = SessionSetupRequest;
	}
	//Service Discovery (1a ⇄ 1b)
	else if (exi_doc_ISO2->V2G_Message.Body.ServiceDiscoveryReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] ServiceDiscoveryReq_isUsed: YES (1a ⇄ 1b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceDiscoveryRequest;
	}
	//Service Detail
	else if (exi_doc_ISO2->V2G_Message.Body.ServiceDetailReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] ServiceDetailReq_isUsed: YES\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceDetailRequest;
	}
	//Payment Service Selection (2a ⇄ 2b)
	else if (exi_doc_ISO2->V2G_Message.Body.PaymentServiceSelectionReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] PaymentServiceSelectionReq_isUsed: YES (2a ⇄ 2b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceAndPaymentSelectionRequest;
	}
	//Payment Details
	else if (exi_doc_ISO2->V2G_Message.Body.PaymentDetailsReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] PaymentDetailsReq_isUsed: YES\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = PaymentDetailsRequest;
	}
	//Authorization (Xa ⇄ Xb)
	else if (exi_doc_ISO2->V2G_Message.Body.AuthorizationReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] AuthorizationReq_isUsed: YES (Xa ⇄ Xb)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = AuthorizationRequest;
	}
	//Certificate Update
	else if (exi_doc_ISO2->V2G_Message.Body.CertificateUpdateReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] CertificateUpdateReq_isUsed: YES\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = CertificateUpdateRequest;
	}
	//Certificate Installation
	else if (exi_doc_ISO2->V2G_Message.Body.CertificateInstallationReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] CertificateInstallationReq_isUsed: YES\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = CertificateInstallationRequest;
	}
	//Charge Parameter Discovery (3a ⇄ 3b)
	else if (exi_doc_ISO2->V2G_Message.Body.ChargeParameterDiscoveryReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] ChargeParameterDiscoveryReq_isUsed: YES (3a ⇄ 3b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = ChargeParameterDiscoveryRequest;
	}
	//Cable Check (4a ⇄ 4b)
	else if (exi_doc_ISO2->V2G_Message.Body.CableCheckReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] CableCheckReq_isUsed: YES (4a ⇄ 4b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = CableCheckRequest;
	}
	//Precharge (5a ⇄ 5b)
	else if (exi_doc_ISO2->V2G_Message.Body.PreChargeReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] PreChargeReq_isUsed: YES (5a ⇄ 5b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = PreChargeRequest;
	}
	//Power Delivery (6a ⇄ 6b)
	else if (exi_doc_ISO2->V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] PowerDeliveryReq_isUsed: YES (6a ⇄ 6b)\n");

		//For DC
		if (CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED)
		{
			if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre == PreChargeRequest)
			{
				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStart;
			}
			else
			{
				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStop;
			}
		}
		//For AC
		else if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
		{
			if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre == ChargeParameterDiscoveryRequest)
			{
				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStart;
			}
			else
			{
				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStop;
			}
		}
		else
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]unexpected CCS_ENERGY_TRANSFER_MODE(%d)\n", CCS_ENERGY_TRANSFER_MODE);
			errn = -2;
		}
	}
	//Current Demand (7a ⇄ 7b)
	else if (exi_doc_ISO2->V2G_Message.Body.CurrentDemandReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] CurrentDemandReq_isUsed: YES (7a ⇄ 7b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = CurrentDemandRequest;
	}
	//Charging Status
	else if (exi_doc_ISO2->V2G_Message.Body.ChargingStatusReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] ChargingStatusReq_isUsed: YES (7a ⇄ 7b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = ChargingStatusRequest;
	}
	//Metering Receipt
	else if (exi_doc_ISO2->V2G_Message.Body.MeteringReceiptReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] MeteringReceiptReq_isUsed: YES\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = MeteringReceiptRequest;
	}
	//Welding Detection (9a ⇄ 9b)
	else if (exi_doc_ISO2->V2G_Message.Body.WeldingDetectionReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] WeldingDetectionReq_isUsed: YES (9a ⇄ 9b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = WeldingDetectionRequest;
	}
	//Session Stop (10a ⇄ 10b)
	else if (exi_doc_ISO2->V2G_Message.Body.SessionStopReq_isUsed == 1u)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] SessionStopReq_isUsed: YES (10a ⇄ 10b)\n");
		EVCOMM_SYS_INFO.V2G_Rx_Msg = SessionStopRequest;
	}
	else
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]unidentified V2G_Rx_Msg\n");
		errn = -1;
	}

	//Compare with the previous Message
	if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre != EVCOMM_SYS_INFO.V2G_Rx_Msg)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[V2G_RX_MSG]%d >> %d\n",
										EVCOMM_SYS_INFO.V2G_Rx_Msg_pre,
										EVCOMM_SYS_INFO.V2G_Rx_Msg);
		EVCOMM_SYS_INFO.V2G_Rx_Msg_pre = EVCOMM_SYS_INFO.V2G_Rx_Msg;
	}

	return errn;
}


/*===========================================================================
FUNCTION: SAVE_PhysicalValueType_DIN70121
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SAVE_PhysicalValueType_DIN70121(struct PhysicalValueType_DIN70121 *out, int in_value, unsigned char unit)
{
    out->Value = in_value;
    out->Unit = unit;

    switch (unit)
    {
        case H_DIN70121:
        case M_DIN70121:
        case S_DIN70121:
        case A_DIN70121:
        case V_DIN70121:
        case AH_DIN70121:
        case VA_DIN70121:
            out->Multiplier = -1;
            break;    //KW

        case W_DIN70121:
        case WH_DIN70121:
			out->Value = in_value/10;//in_value * 10;
            out->Multiplier = 3;
            break;    //KWh
    }
    //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};
}

/*===========================================================================
FUNCTION: SAVE_PhysicalValueType_ISO15118_2014
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SAVE_PhysicalValueType_ISO15118_2014(struct PhysicalValueType_ISO15118_2014 *out, int in_value, unsigned char unit)
{
    out->Value = in_value;
    out->Unit = unit;

    switch (unit)
    {
        case h_ISO15118_2014:
        case m_ISO15118_2014:
        case s_ISO15118_2014:
        case A_ISO15118_2014:
        case V_ISO15118_2014:
            out->Multiplier = -1;
            break;    //KW

        case W_ISO15118_2014:
        case Wh_ISO15118_2014:
			out->Value = in_value/10;//in_value * 10;
            out->Multiplier = 3;
            break;    //KWh
    }
    //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};
}


/*===========================================================================
FUNCTION: DIN70121PhyValDecode
DESCRIPTION:
        Output Unit: 1V, 1A, 1S, etc.
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
float DIN70121PhyValDecode(struct PhysicalValueType_DIN70121 PhysicalData)
{
    short DataValue;
    int DataMultiplier;
    float Rtn;

    DataValue = PhysicalData.Value;
    DataMultiplier = PhysicalData.Multiplier;

    switch(PhysicalData.Unit)
    {
        case H_DIN70121:
            Rtn = (DataValue * pow(10, DataMultiplier) * 60 * 60);
            return Rtn;

        case M_DIN70121:
            Rtn = (DataValue * pow(10, DataMultiplier) * 60);
            return Rtn;

        case S_DIN70121:
        case A_DIN70121:
        case V_DIN70121:
            Rtn = (DataValue * pow(10, DataMultiplier));
            return Rtn;     //S, A, V

        case AH_DIN70121:
            Rtn = (DataValue * pow(10, DataMultiplier));
            return Rtn;

        case VA_DIN70121:
        case W_DIN70121:
            Rtn = (DataValue * pow(10, DataMultiplier)) / 1000;
            return Rtn;    //kW

        case WS_DIN70121:
            Rtn = (DataValue * pow(10, DataMultiplier)) / 1000;    //[Joseph] TBD
            return Rtn;

        case WH_DIN70121:
            Rtn = (DataValue * pow(10, DataMultiplier)) / 1000;
            return Rtn;    //kWh
    }
}

/*===========================================================================
FUNCTION: ISO151182014PhyValDecode
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
float ISO151182014PhyValDecode(struct PhysicalValueType_ISO15118_2014 PhysicalData)
{
    short DataValue;
    int DataMultiplier;
    float Rtn;

    DataValue = PhysicalData.Value;
    DataMultiplier = PhysicalData.Multiplier;

    switch(PhysicalData.Unit)
    {
        case h_ISO15118_2014:
            Rtn = (DataValue * pow(10, DataMultiplier) * 60 * 60);
            return Rtn;

        case m_ISO15118_2014:
            Rtn = (DataValue * pow(10, DataMultiplier) * 60);
            return Rtn;

        case s_ISO15118_2014:
        case A_ISO15118_2014:
        case V_ISO15118_2014:
            Rtn = (DataValue * pow(10, DataMultiplier));
            return Rtn;

        case W_ISO15118_2014:
            Rtn = (DataValue * pow(10, DataMultiplier)) / 1000;
            return Rtn;    //kW

        case Wh_ISO15118_2014:
            Rtn = (DataValue * pow(10, DataMultiplier)) / 1000;
            return Rtn;    //kWh
    }
}


/*===========================================================================
FUNCTION: SHM_Read_dinPhysicalValueType
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. in
OUTPUT:
		2. out

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_dinPhysicalValueType(struct dinPhysicalValueType *out, struct PhysicalValueType_DIN70121 *in)
{
	out->Value = (short) in->Value;
	out->Multiplier = (char) in->Multiplier;
	out->Unit_isUsed = 1u;	//[CAUTION] Remember to put Uinit, since here we set it as 1 as default.
	out->Unit = (unsigned char) in->Unit;
	//	dinunitSymbolType_h = 0,
	//	dinunitSymbolType_m = 1,
	//	dinunitSymbolType_s = 2,
	//	dinunitSymbolType_A = 3,
	//	dinunitSymbolType_Ah = 4,
	//	dinunitSymbolType_V = 5,
	//	dinunitSymbolType_VA = 6,
	//	dinunitSymbolType_W = 7,
	//	dinunitSymbolType_W_s = 8,
	//	dinunitSymbolType_Wh = 9
}

/*===========================================================================
FUNCTION: SHM_Read_iso1PhysicalValueType
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. in
OUTPUT:
		2. out

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_iso1PhysicalValueType(struct iso1PhysicalValueType *out, struct PhysicalValueType_ISO15118_2014 *in)
{
	out->Value = (short) in->Value;
	out->Multiplier = (char) in->Multiplier;
	//out->Unit_isUsed = 1u;	//[CAUTION] Remember to put Uinit, since here we set it as 1 as default.
	out->Unit = (unsigned char) in->Unit;
	//iso1unitSymbolType_h = 0,
	//iso1unitSymbolType_m = 1,
	//iso1unitSymbolType_s = 2,
	//iso1unitSymbolType_A = 3,
	//iso1unitSymbolType_V = 4,
	//iso1unitSymbolType_W = 5,
	//iso1unitSymbolType_Wh = 6
}


/*===========================================================================
FUNCTION: SHM_Read_dinDC_EVSEStatusType
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. in
OUTPUT:
		2. out

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_dinDC_EVSEStatusType(struct dinDC_EVSEStatusType *out, struct DC_EVSEStatusType_DIN70121 *in)
{
	out->EVSEIsolationStatus_isUsed = 1u;
	out->EVSEIsolationStatus = (unsigned char) in->EVSEIsolationStatus;
	//	dinisolationLevelType_Invalid = 0, (default)
	//	dinisolationLevelType_Valid = 1,
	//	dinisolationLevelType_Warning = 2,
	//	dinisolationLevelType_Fault = 3

	out->EVSEStatusCode = (unsigned char) in->EVSEStatusCode;
	// dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
	// dinDC_EVSEStatusCodeType_EVSE_Ready = 1, (default)
	// dinDC_EVSEStatusCodeType_EVSE_Shutdown = 2,
	// dinDC_EVSEStatusCodeType_EVSE_UtilityInterruptEvent = 3,
	// dinDC_EVSEStatusCodeType_EVSE_IsolationMonitoringActive = 4,
	// dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown = 5,
	// dinDC_EVSEStatusCodeType_EVSE_Malfunction = 6,
	// dinDC_EVSEStatusCodeType_Reserved_8 = 7,
	// dinDC_EVSEStatusCodeType_Reserved_9 = 8,
	// dinDC_EVSEStatusCodeType_Reserved_A = 9,
	// dinDC_EVSEStatusCodeType_Reserved_B = 10,
	// dinDC_EVSEStatusCodeType_Reserved_C = 11

	out->NotificationMaxDelay = 0u;

	out->EVSENotification = (unsigned char) in->EVSENotification;
	// dinEVSENotificationType_None = 0, (default)
	// dinEVSENotificationType_StopCharging = 1,
	// dinEVSENotificationType_ReNegotiation = 2
}

/*===========================================================================
FUNCTION: SHM_Read_iso1DC_EVSEStatusType
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. in
OUTPUT:
		2. out

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_iso1DC_EVSEStatusType(struct iso1DC_EVSEStatusType *out, struct DC_EVSEStatusType_ISO15118_2014 *in)
{
	out->EVSEIsolationStatus_isUsed = 1u;
	out->EVSEIsolationStatus = (unsigned char) in->EVSEIsolationStatus;
	//iso1isolationLevelType_Invalid = 0,
	//iso1isolationLevelType_Valid = 1,
	//iso1isolationLevelType_Warning = 2,
	//iso1isolationLevelType_Fault = 3,
	//iso1isolationLevelType_No_IMD = 4

	out->EVSEStatusCode = (unsigned char) in->DC_EVSEStatusCode;
	//iso1DC_EVSEStatusCodeType_EVSE_NotReady = 0,
	//iso1DC_EVSEStatusCodeType_EVSE_Ready = 1,
	//iso1DC_EVSEStatusCodeType_EVSE_Shutdown = 2,
	//iso1DC_EVSEStatusCodeType_EVSE_UtilityInterruptEvent = 3,
	//iso1DC_EVSEStatusCodeType_EVSE_IsolationMonitoringActive = 4,
	//iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown = 5,
	//iso1DC_EVSEStatusCodeType_EVSE_Malfunction = 6,
	//iso1DC_EVSEStatusCodeType_Reserved_8 = 7,
	//iso1DC_EVSEStatusCodeType_Reserved_9 = 8,
	//iso1DC_EVSEStatusCodeType_Reserved_A = 9,
	//iso1DC_EVSEStatusCodeType_Reserved_B = 10,
	//iso1DC_EVSEStatusCodeType_Reserved_C = 11

	out->NotificationMaxDelay = 0u;

	out->EVSENotification = (unsigned char) in->EVSENotification;
	//iso1EVSENotificationType_None = 0, (default)
	//iso1EVSENotificationType_StopCharging = 1,
	//iso1EVSENotificationType_ReNegotiation = 2
}

/*===========================================================================
FUNCTION: SHM_Read_iso1AC_EVSEStatusType
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. in
OUTPUT:
		2. out

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_iso1AC_EVSEStatusType(struct iso1AC_EVSEStatusType *out, struct AC_EVSEStatusType_ISO15118_2014 *in)
{
	out->RCD = (int)in->RCD;	
	//0: no error is detected
	//1: an error is detected

	out->NotificationMaxDelay = (unsigned short)in->NotificationMaxDelay;	
	//unit: 1s
	//The time SECC expects EVCC to perform EVSENotification

	out->EVSENotification = (unsigned char)in->EVSENotification;
	//iso1EVSENotificationType_None = 0,
	//iso1EVSENotificationType_StopCharging = 1,
	//iso1EVSENotificationType_ReNegotiation = 2
}

/*===========================================================================
FUNCTION: SHM_Read_iso1MeterInfo
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. in
OUTPUT:
		2. out

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_iso1MeterInfo(struct iso1MeterInfoType *out, struct MeterInfoType_ISO15118_2014 *in)
{
	int i = 0;

	//[1/5] MeterID
	out->MeterID.charactersLen = strlen(in->MeterID);
	for (i = 0; i < out->MeterID.charactersLen; i++)
	{
		out->MeterID.characters[i] = (unsigned char)in->MeterID[i];
	}

	//[2/5] MeterReading
	out->MeterReading_isUsed = 1u;
	out->MeterReading = (unsigned long)in->MeterReading;

	//[3/5] SigMeterReading
	out->SigMeterReading_isUsed = 0u;
	/*out->SigMeterReading.bytesLen = 64;
	for (i = 0; i < out->SigMeterReading.bytesLen; i++)
	{
		out->SigMeterReading.bytes[i] = (unsigned char)in->SigMeterReading[i];
	}*/

	//[4/5] MeterStatus
	out->MeterStatus_isUsed = 1u;
	out->MeterStatus = (short)in->MeterStatus;

	//[5/5] TMeter
	out->TMeter_isUsed = 1u;
	out->TMeter = (long)in->TMeter;		//[CAUTION] data type
}

/*===========================================================================
FUNCTION: SHM_Save_din_supportedAppProtocolReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_din_supportedAppProtocolReq(struct CcsData *shm_ccs, struct appHandEXIDocument *buf, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    int j = 0;
    struct SupportedAppProtocolRequest_DIN70121 *shm_msg;
    struct appHandAnonType_supportedAppProtocolReq *exi;

    shm_msg = &shm_ccs->V2GMessage_DIN70121.SupportedAppProtocolRequest;
    exi = &buf->supportedAppProtocolReq;

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    for (i = 0; i < exi->AppProtocol.arrayLen ; i++)
    {
        //ProtocolNamespace
        shm_msg->AppProtocol[i].ProtocolNamespaceLen = (unsigned int) exi->AppProtocol.array[i].ProtocolNamespace.charactersLen;

        for (j = 0; j< shm_msg->AppProtocol[i].ProtocolNamespaceLen; j++)
        {
            shm_msg->AppProtocol[i].ProtocolNamespace[j] = (unsigned char) exi->AppProtocol.array[i].ProtocolNamespace.characters[j];
        }

        //Version (Major, Minor)
        shm_msg->AppProtocol[i].VersionNumberMajor = (unsigned int) exi->AppProtocol.array[i].VersionNumberMajor;
        shm_msg->AppProtocol[i].VersionNumberMinor = (unsigned int) exi->AppProtocol.array[i].VersionNumberMinor;

        //SchemaID
        shm_msg->AppProtocol[i].SchemaID = (unsigned char) exi->AppProtocol.array[i].SchemaID;

        //Priority
        shm_msg->AppProtocol[i].Priority = (unsigned char) exi->AppProtocol.array[i].Priority;
    }
}

/*===========================================================================
FUNCTION: SHM_Save_din_SessionSetupReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_din_SessionSetupReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct SessionSetupRequest_DIN70121 *shm_msg;
    struct dinSessionSetupReqType *exi;

    shm_msg = &shm_ccs->V2GMessage_DIN70121.SessionSetupRequest;
    exi = &exi_doc_DIN->V2G_Message.Body.SessionSetupReq;

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_din_V2GMSG_Header(buf);

	//EVCCID Length
	EVCOMM_SYS_INFO.EVCCID_length = (unsigned char)exi->EVCCID.bytesLen;
	//EVCCID
	for (i = 0; i < exi->EVCCID.bytesLen; i++)
	{
		shm_msg->EVCCID[i] = (unsigned char) exi->EVCCID.bytes[i];
		EVCOMM_SYS_INFO.EVCCID[i] = (unsigned char) exi->EVCCID.bytes[i];
	}
}

/*===========================================================================
FUNCTION: SHM_Save_iso1_SessionSetupReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_iso1_SessionSetupReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct SessionSetupRequest_ISO15118_2014 *shm_msg;
    struct iso1SessionSetupReqType *exi;

    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.SessionSetupRequest;
    exi = &exi_doc_ISO1->V2G_Message.Body.SessionSetupReq;

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_din_V2GMSG_Header(buf);

	//EVCCID Length
	EVCOMM_SYS_INFO.EVCCID_length = (unsigned char)exi->EVCCID.bytesLen;

	//EVCCID
	for (i = 0; i < exi->EVCCID.bytesLen; i++)
	{
		shm_msg->EVCCID[i] = (unsigned char) exi->EVCCID.bytes[i];
		EVCOMM_SYS_INFO.EVCCID[i] = (unsigned char) exi->EVCCID.bytes[i];
	}
}

/*===========================================================================
FUNCTION: SHM_Save_iso2_SessionSetupReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_iso2_SessionSetupReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct SessionSetupRequest_ISO15118_2018 *shm_msg;
    struct iso2SessionSetupReqType *exi;

    shm_msg = &shm_ccs->V2GMessage_ISO15118_2018.SessionSetupRequest;
    exi = &exi_doc_ISO2->V2G_Message.Body.SessionSetupReq;

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_din_V2GMSG_Header(buf);

	//EVCCID Length
	EVCOMM_SYS_INFO.EVCCID_length = (unsigned char)exi->EVCCID.bytesLen;


	//EVCCID
	for (i = 0; i < exi->EVCCID.bytesLen; i++)
	{
		shm_msg->EVCCID[i] = (unsigned char) exi->EVCCID.bytes[i];
		EVCOMM_SYS_INFO.EVCCID[i] = (unsigned char) exi->EVCCID.bytes[i];
	}
}

/*===========================================================================
FUNCTION: SHM_Save_din_ServiceDiscoveryReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_din_ServiceDiscoveryReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct ServiceDiscoveryRequest_DIN70121 *shm_msg;
    struct dinServiceDiscoveryReqType *exi;

    shm_msg = &shm_ccs->V2GMessage_DIN70121.ServiceDiscoveryRequest;
    exi = &exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq;

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_din_V2GMSG_Header(buf);

	//ServiceScope
	shm_msg->ServiceScopeLen = (unsigned int) exi->ServiceScope.charactersLen;
    for (i = 0; i <shm_msg->ServiceScopeLen ; i++)
    {
        shm_msg->ServiceScope[i] = (unsigned char) exi->ServiceScope.characters[i];
    }

    //ServiceCategory
    shm_msg->ServiceCategory = (unsigned int) exi->ServiceCategory;
}

/*===========================================================================
FUNCTION: SHM_Save_iso1_ServiceDiscoveryReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_iso1_ServiceDiscoveryReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct ServiceDiscoveryRequest_ISO15118_2014 *shm_msg;
    struct iso1ServiceDiscoveryReqType *exi;

    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.ServiceDiscoveryRequest;
    exi = &exi_doc_ISO1->V2G_Message.Body.ServiceDiscoveryReq;

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_iso1_V2GMSG_Header(buf);

	//ServiceScope
	shm_msg->ServiceScopeLen = (unsigned int) exi->ServiceScope.charactersLen;
    for (i = 0; i <shm_msg->ServiceScopeLen ; i++)
    {
        shm_msg->ServiceScope[i] = (unsigned char) exi->ServiceScope.characters[i];
    }

    //ServiceCategory
    shm_msg->ServiceCategory = (unsigned int) exi->ServiceCategory;
}


void SHM_Save_iso1_ServiceDetailReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct ServiceDetailRequest_ISO15118_2014 *shm_msg;
    struct iso1ServiceDetailReqType *exi;

    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.ServiceDetailRequest;
    exi = &exi_doc_ISO1->V2G_Message.Body.ServiceDetailReq;

	//ServiceScope
	shm_msg->ServiceID = (unsigned int) exi->ServiceID;
}


/*===========================================================================
FUNCTION: SHM_Save_din_ServiceAndPaymentSelectionReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_din_ServiceAndPaymentSelectionReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct ServiceAndPaymentSelectionRequest_DIN70121 *shm_msg;
    struct dinServicePaymentSelectionReqType *exi;

    shm_msg = &shm_ccs->V2GMessage_DIN70121.ServiceAndPaymentSelectionRequest;
    exi = &exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq;

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_din_V2GMSG_Header(buf);

	//[1/2] SelectedPaymentOption
	shm_msg->SelectedPaymentOption = (unsigned char) exi->SelectedPaymentOption;

	//[2/2] SelectedServiceList
    shm_msg->SelectedServiceList.SelectedServiceLen = (unsigned int) exi->SelectedServiceList.SelectedService.arrayLen;
    for (i = 0; i< shm_msg->SelectedServiceList.SelectedServiceLen; i++)
    {
        shm_msg->SelectedServiceList.SelectedService[i].ServiceID =
				(unsigned short) exi->SelectedServiceList.SelectedService.array[i].ServiceID;

        shm_msg->SelectedServiceList.SelectedService[i].ParameterSetID =
				(short) exi->SelectedServiceList.SelectedService.array[i].ParameterSetID;
    }
}

/*===========================================================================
FUNCTION: SHM_Save_iso1_ServiceAndPaymentSelectionReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_iso1_ServiceAndPaymentSelectionReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct ServiceAndPaymentSelectionRequest_ISO15118_2014 *shm_msg;
    struct iso1PaymentServiceSelectionReqType *exi;

    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.ServiceAndPaymentSelectionRequest;
    exi = &exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq;

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_iso1_V2GMSG_Header(buf);

	//[1/2] SelectedPaymentOption
	shm_msg->SelectedPaymentOption = (unsigned char) exi->SelectedPaymentOption;

	//[2/2] SelectedServiceList
    shm_msg->SelectedServiceList.SelectedServiceLen = (unsigned int) exi->SelectedServiceList.SelectedService.arrayLen;
    for (i = 0; i< shm_msg->SelectedServiceList.SelectedServiceLen; i++)
    {
        shm_msg->SelectedServiceList.SelectedService[i].ServiceID =
				(unsigned short) exi->SelectedServiceList.SelectedService.array[i].ServiceID;

        shm_msg->SelectedServiceList.SelectedService[i].ParameterSetID =
				(short) exi->SelectedServiceList.SelectedService.array[i].ParameterSetID;
    }
}


/*===========================================================================
FUNCTION: SHM_Save_din_ContractAuthenticationReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_din_ContractAuthenticationReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct ContractAuthenticationRequest_DIN70121 *shm_msg;
    struct dinContractAuthenticationReqType *exi;

    shm_msg = &shm_ccs->V2GMessage_DIN70121.ContractAuthenticationRequest;
    exi = &exi_doc_DIN->V2G_Message.Body.ContractAuthenticationReq;

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_din_V2GMSG_Header(buf);

	//none
}

/*===========================================================================
FUNCTION: SHM_Save_iso1_AuthorizationReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_iso1_AuthorizationReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct AuthorizationRequest_ISO15118_2014 *shm_msg;
    struct iso1AuthorizationReqType *exi;

    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.AuthorizationRequest;
    exi = &exi_doc_ISO1->V2G_Message.Body.AuthorizationReq;

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_iso1_V2GMSG_Header(buf);

	//none
}

/*===========================================================================
FUNCTION: SHM_Save_din_ChargeParameterDiscoveryReq
DESCRIPTION: Save into share memories
			(1) ShmCcsData (shm_ccs)
			(2) ShmSysConfigAndInfo (shm_sys)

PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_din_ChargeParameterDiscoveryReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct ChargeParameterDiscoveryRequest_DIN70121 *shm_msg;
    struct dinChargeParameterDiscoveryReqType *exi;
	struct ChargingInfoData *sys;

    shm_msg = &shm_ccs->V2GMessage_DIN70121.ChargeParameterDiscoveryRequest;
    exi = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq;
	sys = &shm_sys->SysInfo.CcsChargingData[0];

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_din_V2GMSG_Header(buf);

	//===== [BODY (1/9)] EVRequestedEnergyTransferType =====
	shm_msg->EVRequestedEnergyTransferType = (unsigned char) exi->EVRequestedEnergyTransferType;

	//===== [BODY (2/9)] DC_EVChargeParameter of EVChargeParameter =====
    //DC_EVStatus
    shm_msg->DC_EVChargeParameter.DC_EVStatus.EVReady = (BOOL) exi->DC_EVChargeParameter.DC_EVStatus.EVReady;
	shm_msg->DC_EVChargeParameter.DC_EVStatus.EVCabinConditioning = (BOOL) exi->DC_EVChargeParameter.DC_EVStatus.EVCabinConditioning;
	shm_msg->DC_EVChargeParameter.DC_EVStatus.EVRESSConiditioning = (BOOL) exi->DC_EVChargeParameter.DC_EVStatus.EVRESSConditioning;
	shm_msg->DC_EVChargeParameter.DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVChargeParameter.DC_EVStatus.EVErrorCode;
	shm_msg->DC_EVChargeParameter.DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVChargeParameter.DC_EVStatus.EVRESSSOC;
	sys->EvBatterySoc = (int) shm_msg->DC_EVChargeParameter.DC_EVStatus.EVRESSSOC;

    //[BODY (3/9)] EVMaximumCurrentLimit
    shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Multiplier =
			(int) exi->DC_EVChargeParameter.EVMaximumCurrentLimit.Multiplier;
	//shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Unit = (unsigned char) exi->DC_EVChargeParameter.EVMaximumCurrentLimit.Unit;
	shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Unit = A_DIN70121;
	shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Value =
			(short) exi->DC_EVChargeParameter.EVMaximumCurrentLimit.Value;
	sys->EvBatteryMaxCurrent = DIN70121PhyValDecode(shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit);

    //[BODY (4/9)] EVMaximumPowerLimit
	shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Multiplier =
			(int) exi->DC_EVChargeParameter.EVMaximumPowerLimit.Multiplier;
	//shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Unit = (unsigned char) exi->DC_EVChargeParameter.EVMaximumPowerLimit.Unit;
	shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Unit = W_DIN70121;
	shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Value =
			(short) exi->DC_EVChargeParameter.EVMaximumPowerLimit.Value;
	sys->EvBatteryMaxPower = DIN70121PhyValDecode(shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit);

    //[BODY (5/9)] EVMaximumVoltageLimit
	shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Multiplier =
			(int) exi->DC_EVChargeParameter.EVMaximumVoltageLimit.Multiplier;
	//shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Unit = (unsigned char) exi->DC_EVChargeParameter.EVMaximumVoltageLimit.Unit;
	shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Unit = V_DIN70121;
	shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Value =
			(short) exi->DC_EVChargeParameter.EVMaximumVoltageLimit.Value;
	sys->EvBatteryMaxVoltage = DIN70121PhyValDecode(shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit);

    //[BODY (6/9)] EVEnergyCapacity
	shm_msg->DC_EVChargeParameter.EVEnergyCapacity.Multiplier =
			(int) exi->DC_EVChargeParameter.EVEnergyCapacity.Multiplier;
	shm_msg->DC_EVChargeParameter.EVEnergyCapacity.Unit = WH_DIN70121;
	shm_msg->DC_EVChargeParameter.EVEnergyCapacity.Value =
			(short) exi->DC_EVChargeParameter.EVEnergyCapacity.Value;
	sys->EvBatteryCapacity = DIN70121PhyValDecode(shm_msg->DC_EVChargeParameter.EVEnergyCapacity);

    //[BODY (7/9)] EVEnergyRequest
	shm_msg->DC_EVChargeParameter.EVEnergyRequest.Multiplier =
			(int) exi->DC_EVChargeParameter.EVEnergyRequest.Multiplier;
	shm_msg->DC_EVChargeParameter.EVEnergyRequest.Unit = WH_DIN70121;
	shm_msg->DC_EVChargeParameter.EVEnergyRequest.Value =
			(short) exi->DC_EVChargeParameter.EVEnergyRequest.Value;
	sys->EvBatteryEngergyRequest = DIN70121PhyValDecode(shm_msg->DC_EVChargeParameter.EVEnergyRequest);

    //[BODY (8/9)] FullSOC
	if (exi->DC_EVChargeParameter.FullSOC_isUsed != 0 && exi->DC_EVChargeParameter.FullSOC != 0)
	{
		shm_msg->DC_EVChargeParameter.FullSOC = (unsigned char) exi->DC_EVChargeParameter.FullSOC;
	}
	else
	{
		shm_msg->DC_EVChargeParameter.FullSOC = (unsigned char) exi->DC_EVChargeParameter.BulkSOC;
	}

    //[BODY (9/9)] BulkSOC
    shm_msg->DC_EVChargeParameter.BulkSOC = (unsigned char) exi->DC_EVChargeParameter.BulkSOC;
}

/*===========================================================================
FUNCTION: SHM_Save_iso1_ChargeParameterDiscoveryReq
DESCRIPTION: Save into share memories
			(1) ShmCcsData (shm_ccs)
			(2) ShmSysConfigAndInfo (shm_sys)

PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_iso1_ChargeParameterDiscoveryReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct ChargeParameterDiscoveryRequest_ISO15118_2014 *shm_msg;
    struct iso1ChargeParameterDiscoveryReqType *exi;
	struct ChargingInfoData *sys;

    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest;
    exi = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq;
	sys = &shm_sys->SysInfo.CcsChargingData[0];

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_iso1_V2GMSG_Header(buf);

	//===== [BODY (1/9)] EVRequestedEnergyTransferType =====
	shm_msg->RequestedEnergyTransferMode = (unsigned char) exi->RequestedEnergyTransferMode;

	//===== [BODY (2/9)] DC_EVChargeParameter of EVChargeParameter =====
	//AC_EVChargeParameter
	if(exi->RequestedEnergyTransferMode <= 1)//0 for 1P, 1 for 3P
	{	
		if(exi->AC_EVChargeParameter.DepartureTime_isUsed != 0)
		 	shm_msg->AC_EVChargeParameter.DepartureTime =  exi->AC_EVChargeParameter.DepartureTime;
		 
		 shm_msg->AC_EVChargeParameter.EAmount.Multiplier =  (int) exi->AC_EVChargeParameter.EAmount.Multiplier;
		 shm_msg->AC_EVChargeParameter.EAmount.Unit = exi->AC_EVChargeParameter.EAmount.Unit;
		 shm_msg->AC_EVChargeParameter.EAmount.Value = (short)exi->AC_EVChargeParameter.EAmount.Value;
	 
		 shm_msg->AC_EVChargeParameter.EVMaxVoltage.Multiplier =  (int) exi->AC_EVChargeParameter.EVMaxVoltage.Multiplier;
		 shm_msg->AC_EVChargeParameter.EVMaxVoltage.Unit = exi->AC_EVChargeParameter.EVMaxVoltage.Unit;
		 shm_msg->AC_EVChargeParameter.EVMaxVoltage.Value = (short)exi->AC_EVChargeParameter.EVMaxVoltage.Value;
	 
		 shm_msg->AC_EVChargeParameter.EVMaxCurrent.Multiplier =  (int) exi->AC_EVChargeParameter.EVMaxCurrent.Multiplier;
		 shm_msg->AC_EVChargeParameter.EVMaxCurrent.Unit = exi->AC_EVChargeParameter.EVMaxCurrent.Unit;
		 shm_msg->AC_EVChargeParameter.EVMaxCurrent.Value = (short)exi->AC_EVChargeParameter.EVMaxCurrent.Value;
		 
		 shm_msg->AC_EVChargeParameter.EVMinCurrent.Multiplier =  (int) exi->AC_EVChargeParameter.EVMinCurrent.Multiplier;
		 shm_msg->AC_EVChargeParameter.EVMinCurrent.Unit = exi->AC_EVChargeParameter.EVMinCurrent.Unit;
		 shm_msg->AC_EVChargeParameter.EVMinCurrent.Value = (short)exi->AC_EVChargeParameter.EVMinCurrent.Value;
	 
	}
	else
	{	
	    //DC_EVStatus
	    shm_msg->DC_EVChargeParameter.DC_EVStatus.EVReady = (BOOL) exi->DC_EVChargeParameter.DC_EVStatus.EVReady;
		shm_msg->DC_EVChargeParameter.DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVChargeParameter.DC_EVStatus.EVErrorCode;
		shm_msg->DC_EVChargeParameter.DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVChargeParameter.DC_EVStatus.EVRESSSOC;
		sys->EvBatterySoc = (int) shm_msg->DC_EVChargeParameter.DC_EVStatus.EVRESSSOC;

	    //[BODY (3/9)] EVMaximumCurrentLimit
	    shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Multiplier =
				(int) exi->DC_EVChargeParameter.EVMaximumCurrentLimit.Multiplier;
		//shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Unit = (unsigned char) exi->DC_EVChargeParameter.EVMaximumCurrentLimit.Unit;
		shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Unit = A_ISO15118_2014;
		shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Value =
				(short) exi->DC_EVChargeParameter.EVMaximumCurrentLimit.Value;
		sys->EvBatteryMaxCurrent = ISO151182014PhyValDecode(shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit);

	    //[BODY (4/9)] EVMaximumPowerLimit
		shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Multiplier =
				(int) exi->DC_EVChargeParameter.EVMaximumPowerLimit.Multiplier;
		//shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Unit = (unsigned char) exi->DC_EVChargeParameter.EVMaximumPowerLimit.Unit;
		shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Unit = W_ISO15118_2014;
		shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Value =
				(short) exi->DC_EVChargeParameter.EVMaximumPowerLimit.Value;
		sys->EvBatteryMaxPower = ISO151182014PhyValDecode(shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit);

	    //[BODY (5/9)] EVMaximumVoltageLimit
		shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Multiplier =
				(int) exi->DC_EVChargeParameter.EVMaximumVoltageLimit.Multiplier;
		//shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Unit = (unsigned char) exi->DC_EVChargeParameter.EVMaximumVoltageLimit.Unit;
		shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Unit = V_ISO15118_2014;
		shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Value =
				(short) exi->DC_EVChargeParameter.EVMaximumVoltageLimit.Value;
		sys->EvBatteryMaxVoltage = ISO151182014PhyValDecode(shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit);

	    //[BODY (6/9)] EVEnergyCapacity
		shm_msg->DC_EVChargeParameter.EVEnergyCapacity.Multiplier =
				(int) exi->DC_EVChargeParameter.EVEnergyCapacity.Multiplier;
		shm_msg->DC_EVChargeParameter.EVEnergyCapacity.Unit = Wh_ISO15118_2014;
		shm_msg->DC_EVChargeParameter.EVEnergyCapacity.Value =
				(short) exi->DC_EVChargeParameter.EVEnergyCapacity.Value;
		sys->EvBatteryCapacity = ISO151182014PhyValDecode(shm_msg->DC_EVChargeParameter.EVEnergyCapacity);

	    //[BODY (7/9)] EVEnergyRequest
		shm_msg->DC_EVChargeParameter.EVEnergyRequest.Multiplier =
				(int) exi->DC_EVChargeParameter.EVEnergyRequest.Multiplier;
		shm_msg->DC_EVChargeParameter.EVEnergyRequest.Unit = Wh_ISO15118_2014;
		shm_msg->DC_EVChargeParameter.EVEnergyRequest.Value =
				(short) exi->DC_EVChargeParameter.EVEnergyRequest.Value;
		sys->EvBatteryEngergyRequest = ISO151182014PhyValDecode(shm_msg->DC_EVChargeParameter.EVEnergyRequest);

	    //[BODY (8/9)] FullSOC
		if (exi->DC_EVChargeParameter.FullSOC_isUsed != 0 && exi->DC_EVChargeParameter.FullSOC != 0)
		{
			shm_msg->DC_EVChargeParameter.FullSOC = (unsigned char) exi->DC_EVChargeParameter.FullSOC;
		}
		else
		{
			shm_msg->DC_EVChargeParameter.FullSOC = (unsigned char) exi->DC_EVChargeParameter.BulkSOC;
		}

	    //[BODY (9/9)] BulkSOC
	    shm_msg->DC_EVChargeParameter.BulkSOC = (unsigned char) exi->DC_EVChargeParameter.BulkSOC;
	  }
}


/*===========================================================================
FUNCTION: SHM_Save_din_CableCheckReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_din_CableCheckReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    struct CableCheckRequest_DIN70121 *shm_msg;
    struct dinCableCheckReqType *exi;
	struct ChargingInfoData *sys;

    shm_msg = &shm_ccs->V2GMessage_DIN70121.CableCheckRequest;
    exi = &exi_doc_DIN->V2G_Message.Body.CableCheckReq;
	sys = &shm_sys->SysInfo.CcsChargingData[0];

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_din_V2GMSG_Header(buf);


	//===== [BODY (1/1)] DC_EVStatus =====
    //DC_EVStatus
    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
	shm_msg->DC_EVStatus.EVCabinConditioning = (BOOL) exi->DC_EVStatus.EVCabinConditioning;
	shm_msg->DC_EVStatus.EVRESSConiditioning = (BOOL) exi->DC_EVStatus.EVRESSConditioning;
	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;

	//Check for EVReady
	//if (shm_msg->DC_EVStatus.EVReady == TRUE && shm_msg->DC_EVStatus.EVErrorCode == NO_ERROR)
	//{
		//sys->ConnectorLocked = TRUE;    //Inicating EVSE that the CCS Connector is Locked.
	//}
}

/*===========================================================================
FUNCTION: SHM_Save_iso1_CableCheckReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_iso1_CableCheckReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    struct CableCheckRequest_ISO15118_2014 *shm_msg;
    struct iso1CableCheckReqType *exi;
	struct ChargingInfoData *sys;

    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.CableCheckRequest;
    exi = &exi_doc_ISO1->V2G_Message.Body.CableCheckReq;
	sys = &shm_sys->SysInfo.CcsChargingData[0];

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_iso1_V2GMSG_Header(buf);


	//===== [BODY (1/1)] DC_EVStatus =====
    //DC_EVStatus
    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;

	//Check for EVReady
	//if (shm_msg->DC_EVStatus.EVReady == TRUE && shm_msg->DC_EVStatus.EVErrorCode == NO_ERROR)
	//{
		//sys->ConnectorLocked = TRUE;    //Inicating EVSE that the CCS Connector is Locked.
	//}
}


/*===========================================================================
FUNCTION: SHM_Save_din_PreChargeReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_din_PreChargeReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    struct PreChargeRequest_DIN70121 *shm_msg;
    struct dinPreChargeReqType *exi;
	struct ChargingInfoData *sys;

    shm_msg = &shm_ccs->V2GMessage_DIN70121.PreChargeRequest;
    exi = &exi_doc_DIN->V2G_Message.Body.PreChargeReq;
	sys = &shm_sys->SysInfo.CcsChargingData[0];

	shm_msg->cnt++;

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_din_V2GMSG_Header(buf);


	//===== [BODY (1/3)] DC_EVStatus =====
    //DC_EVStatus
    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
	shm_msg->DC_EVStatus.EVCabinConditioning = (BOOL) exi->DC_EVStatus.EVCabinConditioning;
	shm_msg->DC_EVStatus.EVRESSConiditioning = (BOOL) exi->DC_EVStatus.EVRESSConditioning;
	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;

	//[BODY (2/3)] EVTargetVoltage
    shm_msg->EVTargetVoltage.Multiplier = (int) exi->EVTargetVoltage.Multiplier;
	//shm_msg->EVTargetVoltage.Unit = (unsigned char) exi->EVTargetVoltage.Unit;
	shm_msg->EVTargetVoltage.Unit = V_DIN70121;
	shm_msg->EVTargetVoltage.Value = (short) exi->EVTargetVoltage.Value;
	if ((sys->EVSEPrechargeStatus == EVSE_STATUS_NOT_READY_FOR_PRECHARGE) || (shm_msg->cnt <= 2)) //0
	{
		sys->EvBatterytargetVoltage = 0;	//0V, in order to avoid of turning off relay when D+/D- owns voltage.
	}
	else if (sys->EVSEPrechargeStatus == EVSE_STATUS_READY_FOR_PRECHARGE) //2
	{
		sys->EvBatterytargetVoltage = DIN70121PhyValDecode(shm_msg->EVTargetVoltage);
		//sys->EvBatterytargetVoltage = DIN70121PhyValDecode(shm_msg->EVTargetVoltage) + 5;	//for test, add 10V
	}

	//[BODY (3/3)] EVTargetCurrent
    shm_msg->EVTargetCurrent.Multiplier = (int) exi->EVTargetCurrent.Multiplier;
	//shm_msg->EVTargetCurrent.Unit = (unsigned char) exi->EVTargetCurrent.Unit;
	shm_msg->EVTargetCurrent.Unit = A_DIN70121;
	shm_msg->EVTargetCurrent.Value = (short) exi->EVTargetCurrent.Value;
	if (sys->EVSEPrechargeStatus == EVSE_STATUS_READY_FOR_PRECHARGE) //2
	{
		//sys->EvBatteryMaxCurrent = DIN70121PhyValDecode(shm_msg->EVTargetCurrent);
		sys->EvBatterytargetCurrent = PRECHARGE_TARGET_CURRENT;	//for EVSE (default: 2A)
	}
	else
	{
		sys->EvBatterytargetCurrent = 0;	//0A
	}
	//printf("\n\n[%d-th]sys-EvBatterytargetVoltage = %.02f (ori = %d)\n\n", cnt, sys->EvBatterytargetVoltage, shm_msg->EVTargetVoltage.Value);
}

/*===========================================================================
FUNCTION: SHM_Save_iso1_PreChargeReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_iso1_PreChargeReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    struct PreChargeRequest_ISO15118_2014 *shm_msg;
    struct iso1PreChargeReqType *exi;
	struct ChargingInfoData *sys;

    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.PreChargeRequest;
    exi = &exi_doc_ISO1->V2G_Message.Body.PreChargeReq;
	sys = &shm_sys->SysInfo.CcsChargingData[0];

	shm_msg->cnt++;

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_iso1_V2GMSG_Header(buf);


	//===== [BODY (1/3)] DC_EVStatus =====
    //DC_EVStatus
    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;

	//[BODY (2/3)] EVTargetVoltage
    shm_msg->EVTargetVoltage.Multiplier = (int) exi->EVTargetVoltage.Multiplier;
	//shm_msg->EVTargetVoltage.Unit = (unsigned char) exi->EVTargetVoltage.Unit;
	shm_msg->EVTargetVoltage.Unit = V_ISO15118_2014;
	shm_msg->EVTargetVoltage.Value = (short) exi->EVTargetVoltage.Value;
	if ((sys->EVSEPrechargeStatus == EVSE_STATUS_NOT_READY_FOR_PRECHARGE) || (shm_msg->cnt <= 2)) //0
	{
		sys->EvBatterytargetVoltage = 0;	//0V, in order to avoid of turning off relay when D+/D- owns voltage.
	}
	else if (sys->EVSEPrechargeStatus == EVSE_STATUS_READY_FOR_PRECHARGE) //2
	{
		sys->EvBatterytargetVoltage = ISO151182014PhyValDecode(shm_msg->EVTargetVoltage);
	}

	//[BODY (3/3)] EVTargetCurrent
    shm_msg->EVTargetCurrent.Multiplier = (int) exi->EVTargetCurrent.Multiplier;
	//shm_msg->EVTargetCurrent.Unit = (unsigned char) exi->EVTargetCurrent.Unit;
	shm_msg->EVTargetCurrent.Unit = A_ISO15118_2014;
	shm_msg->EVTargetCurrent.Value = (short) exi->EVTargetCurrent.Value;
	if (sys->EVSEPrechargeStatus == EVSE_STATUS_READY_FOR_PRECHARGE) //2
	{
		//sys->EvBatteryMaxCurrent = ISO151182014PhyValDecode(shm_msg->EVTargetCurrent);
		sys->EvBatterytargetCurrent = PRECHARGE_TARGET_CURRENT;	//for EVSE (default: 2A)
	}
	else
	{
		sys->EvBatterytargetCurrent = 0;	//0A
	}
	//printf("\n\n[%d-th]sys-EvBatterytargetVoltage = %.02f (ori = %d)\n\n", cnt, sys->EvBatterytargetVoltage, shm_msg->EVTargetVoltage.Value);
}


/*===========================================================================
FUNCTION: SHM_Save_din_PowerDeliveryReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_din_PowerDeliveryReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct PowerDeliveryRequest_DIN70121 *shm_msg;
    struct dinPowerDeliveryReqType *exi;
	struct ChargingInfoData *sys;

    shm_msg = &shm_ccs->V2GMessage_DIN70121.PowerDeliveryRequest;
    exi = &exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq;
	sys = &shm_sys->SysInfo.CcsChargingData[0];

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_din_V2GMSG_Header(buf);


	//[BODY (1/3)] ReadyToChargeState
	shm_msg->ReadyToChargeState = (BOOL) exi->ReadyToChargeState;

	//[BODY (2/3)] ChargingProfile

	//[BODY (3/3)] DC_EVPowerDeliveryParameters
	//DC_EVStatus
	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVReady = (BOOL) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVReady;
	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVCabinConditioning = (BOOL) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVCabinConditioning;
	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSConiditioning = (BOOL) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSConditioning;
	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode;
	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSSOC;
	sys->EvBatterySoc = (int) shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSSOC;

	//BulkChargingComplete
	shm_msg->DC_EVPowerDeliveryParameter.BulkChargingComplete = (BOOL) exi->DC_EVPowerDeliveryParameter.BulkChargingComplete;

	//ChargingComplete
	shm_msg->DC_EVPowerDeliveryParameter.ChargingComplete = (BOOL) exi->DC_EVPowerDeliveryParameter.ChargingComplete;
}

/*===========================================================================
FUNCTION: SHM_Save_iso1_PowerDeliveryReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_iso1_PowerDeliveryReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct PowerDeliveryRequest_ISO15118_2014 *shm_msg;
    struct iso1PowerDeliveryReqType *exi;
	struct ChargingInfoData *sys;

    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.PowerDeliveryRequest;
    exi = &exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq;
	sys = &shm_sys->SysInfo.CcsChargingData[0];

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_iso1_V2GMSG_Header(buf);


	//[BODY (1/3)] ChargeProgress
	shm_msg->ChargeProgress = (BOOL) exi->ChargeProgress;

	//[BODY (2/3)] ChargingProfile

	//[BODY (3/3)] DC_EVPowerDeliveryParameters
	//DC_EVStatus
	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVReady = (BOOL) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVReady;
	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode;
	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSSOC;
	sys->EvBatterySoc = (int) shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSSOC;

	//BulkChargingComplete
	shm_msg->DC_EVPowerDeliveryParameter.BulkChargingComplete = (BOOL) exi->DC_EVPowerDeliveryParameter.BulkChargingComplete;

	//ChargingComplete
	shm_msg->DC_EVPowerDeliveryParameter.ChargingComplete = (BOOL) exi->DC_EVPowerDeliveryParameter.ChargingComplete;
}


/*===========================================================================
FUNCTION: SHM_Save_din_CurrentDemandReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_din_CurrentDemandReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0, TimeToFull=0, TimeToBulk=0;
    struct CurrentDemandRequest_DIN70121 *shm_msg;
    struct dinCurrentDemandReqType *exi;
	struct ChargingInfoData *sys;

    shm_msg = &shm_ccs->V2GMessage_DIN70121.CurrentDemandRequest;
    exi = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq;
	sys = &shm_sys->SysInfo.CcsChargingData[0];

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_din_V2GMSG_Header(buf);

    //[BODY (1/10)] DC_EVStatus
    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
	shm_msg->DC_EVStatus.EVCabinConditioning = (BOOL) exi->DC_EVStatus.EVCabinConditioning;
	shm_msg->DC_EVStatus.EVRESSConiditioning = (BOOL) exi->DC_EVStatus.EVRESSConditioning;
	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;

    //[BODY (2/10)] EVTargetCurrent
    shm_msg->EVTargetCurrent.Multiplier = (int) exi->EVTargetCurrent.Multiplier;
	//shm_msg->EVTargetCurrent.Unit = (unsigned char) exi->EVTargetCurrent.Unit;
	shm_msg->EVTargetCurrent.Unit = A_DIN70121;
	shm_msg->EVTargetCurrent.Value = (short) exi->EVTargetCurrent.Value;
	if (sys->EVSEPrechargeStatus == EVSE_STATUS_READY_FOR_ENERGY_TRANSFER) //3 (Precharge Relay OFF, DC+ Relay ON)
	{
		sys->EvBatterytargetCurrent = DIN70121PhyValDecode(shm_msg->EVTargetCurrent);

		#if MANUAL_SET_EV_TARGET_FUNCTION == ENABLE
		sys->EvBatterytargetCurrent = SUDO_EV_TARGET_CURRENT; //60A, for test;
		#endif
	}
	else if (sys->EVSEPrechargeStatus == EVSE_STATUS_READY_FOR_PRECHARGE) //2 (Precharge Relay ON, DC+ Relay OFF)
	{
		//sys->EvBatterytargetCurrent = PRECHARGE_TARGET_CURRENT;	//2A, unit: 1A
		sys->EvBatterytargetCurrent = DIN70121PhyValDecode(shm_msg->EVTargetCurrent);
	}
	else	//0 (Precharge Relay is still under preparing, not ON, yet.)
	{
		//sys->EvBatterytargetCurrent = 0;	//0A
		sys->EvBatterytargetCurrent = DIN70121PhyValDecode(shm_msg->EVTargetCurrent);
	}

	//[BODY (3/10)] EVMaximumVoltageLimit
    shm_msg->EVMaximumVoltageLimit.Multiplier = (int) exi->EVMaximumVoltageLimit.Multiplier;
	//shm_msg->EVMaximumVoltageLimit.Unit = (unsigned char) exi->EVMaximumVoltageLimit.Unit;
	shm_msg->EVMaximumVoltageLimit.Unit = V_DIN70121;
	shm_msg->EVMaximumVoltageLimit.Value = (short) exi->EVMaximumVoltageLimit.Value;
	if (shm_msg->EVMaximumVoltageLimit.Value != 0 && exi->EVMaximumVoltageLimit_isUsed == 1u)	//Gridwiz EVCC Emulator will not send EVMaximumVoltageLimit in CurrentDemandReq
	{
		sys->EvBatteryMaxVoltage = DIN70121PhyValDecode(shm_msg->EVMaximumVoltageLimit);
	}

	//[BODY (4/10)] EVMaximumCurrentLimit
    shm_msg->EVMaximumCurrentLimit.Multiplier = (int) exi->EVMaximumCurrentLimit.Multiplier;
	//shm_msg->EVMaximumCurrentLimit.Unit = (unsigned char) exi->EVMaximumCurrentLimit.Unit;
	shm_msg->EVMaximumCurrentLimit.Unit = A_DIN70121;
	shm_msg->EVMaximumCurrentLimit.Value = (short) exi->EVMaximumCurrentLimit.Value;
	sys->EvBatteryMaxCurrent = DIN70121PhyValDecode(shm_msg->EVMaximumCurrentLimit);

	//[BODY (5/10)] EVMaximumPowerLimit
    shm_msg->EVMaximumPowerLimit.Multiplier = (int) exi->EVMaximumPowerLimit.Multiplier;
	//shm_msg->EVMaximumPowerLimit.Unit = (unsigned char) exi->EVMaximumPowerLimit.Unit;
	shm_msg->EVMaximumPowerLimit.Unit = W_DIN70121;
	shm_msg->EVMaximumPowerLimit.Value = (short) exi->EVMaximumPowerLimit.Value;
	sys->EvBatteryMaxPower = DIN70121PhyValDecode(shm_msg->EVMaximumPowerLimit);

    //[BODY (6/10)] BulkChargingComplete
	shm_msg->BulkChargingComplete = (BOOL) exi->BulkChargingComplete;

    //[BODY (7/10)] ChargingComplete
    shm_msg->ChargingComplete = (BOOL) exi->ChargingComplete;

	//[BODY (8/10)] RemainingTimeToFullSoC
	shm_msg->RemainingTimeToFullSoC.Multiplier = (int) exi->RemainingTimeToFullSoC.Multiplier;
	shm_msg->RemainingTimeToFullSoC.Unit = (unsigned char) exi->RemainingTimeToFullSoC.Unit;
	shm_msg->RemainingTimeToFullSoC.Value = (short) exi->RemainingTimeToFullSoC.Value;
	TimeToFull = DIN70121PhyValDecode(shm_msg->RemainingTimeToFullSoC);

	//[BODY (9/10)] RemainingTimeToBulkSoC
	shm_msg->RemainingTimeToBulkSoC.Multiplier = (int) exi->RemainingTimeToBulkSoC.Multiplier;
	shm_msg->RemainingTimeToBulkSoC.Unit = (unsigned char) exi->RemainingTimeToBulkSoC.Unit;
	shm_msg->RemainingTimeToBulkSoC.Value = (short) exi->RemainingTimeToBulkSoC.Value;
	TimeToBulk =  DIN70121PhyValDecode(shm_msg->RemainingTimeToBulkSoC);

	if(TimeToFull > 0)
		sys->RemainChargingDuration = TimeToFull;
	else if(TimeToBulk > 0)
		sys->RemainChargingDuration = TimeToBulk;
	else
	{
		sys->RemainChargingDuration=0;		
	}	
	
	//[BODY (10/10)] EVTargetVoltage
	shm_msg->EVTargetVoltage.Multiplier = (int) exi->EVTargetVoltage.Multiplier;
	//shm_msg->EVTargetVoltage.Unit = (unsigned char) exi->EVTargetVoltage.Unit;
	shm_msg->EVTargetVoltage.Unit = V_DIN70121;
	shm_msg->EVTargetVoltage.Value = (short) exi->EVTargetVoltage.Value;
	if((shm_msg->EVTargetVoltage.Value != 0) && (sys->EvBatteryMaxVoltage != 0))
	{
		/*+++ vern, itme 5 in V0.24.S0, +++*/
		//sys->EvBatterytargetVoltage = (DIN70121PhyValDecode(shm_msg->EVTargetVoltage) + sys->EvBatteryMaxVoltage)/2;
		if((DIN70121PhyValDecode(shm_msg->EVTargetVoltage)+10)>=sys->EvBatteryMaxVoltage)
			sys->EvBatterytargetVoltage = (DIN70121PhyValDecode(shm_msg->EVTargetVoltage) + sys->EvBatteryMaxVoltage)/2;
		else
			sys->EvBatterytargetVoltage =  DIN70121PhyValDecode(shm_msg->EVTargetVoltage)+10;
		/*--- vern, itme 5 in V0.24.S0, ---*/	
	}
	else
	{
		sys->EvBatterytargetVoltage = DIN70121PhyValDecode(shm_msg->EVTargetVoltage);
	}

	#if MANUAL_SET_EV_TARGET_FUNCTION == ENABLE
	sys->EvBatterytargetVoltage = SUDO_EV_TARGET_VOLTAGE;	//for test (500V, unit: 1V)
	#endif
}

/*===========================================================================
FUNCTION: SHM_Save_iso1_CurrentDemandReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_iso1_CurrentDemandReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0, TimeToFull=0, TimeToBulk=0;
    struct CurrentDemandRequest_ISO15118_2014 *shm_msg;
    struct iso1CurrentDemandReqType *exi;
	struct ChargingInfoData *sys;

    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.CurrentDemandRequest;
    exi = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq;
	sys = &shm_sys->SysInfo.CcsChargingData[0];

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_iso1_V2GMSG_Header(buf);

    //[BODY (1/10)] DC_EVStatus
    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;

    //[BODY (2/10)] EVTargetCurrent
    shm_msg->EVTargetCurrent.Multiplier = (int) exi->EVTargetCurrent.Multiplier;
	//shm_msg->EVTargetCurrent.Unit = (unsigned char) exi->EVTargetCurrent.Unit;
	shm_msg->EVTargetCurrent.Unit = A_ISO15118_2014;
	shm_msg->EVTargetCurrent.Value = (short) exi->EVTargetCurrent.Value;
	if (sys->EVSEPrechargeStatus == EVSE_STATUS_READY_FOR_ENERGY_TRANSFER) //3 (Precharge Relay OFF, DC+ Relay ON)
	{
		sys->EvBatterytargetCurrent = ISO151182014PhyValDecode(shm_msg->EVTargetCurrent);

		#if MANUAL_SET_EV_TARGET_FUNCTION == ENABLE
		sys->EvBatterytargetCurrent = SUDO_EV_TARGET_CURRENT; //60A, for test;
		#endif
	}
	else if (sys->EVSEPrechargeStatus == EVSE_STATUS_READY_FOR_PRECHARGE) //2 (Precharge Relay ON, DC+ Relay OFF)
	{
		//sys->EvBatterytargetCurrent = PRECHARGE_TARGET_CURRENT;	//2A, unit: 1A
		sys->EvBatterytargetCurrent = ISO151182014PhyValDecode(shm_msg->EVTargetCurrent);
	}
	else	//0 (Precharge Relay is still under preparing, not ON, yet.)
	{
		//sys->EvBatterytargetCurrent = 0;	//0A
		sys->EvBatterytargetCurrent = ISO151182014PhyValDecode(shm_msg->EVTargetCurrent);
	}

	//[BODY (3/10)] EVMaximumVoltageLimit
    shm_msg->EVMaximumVoltageLimit.Multiplier = (int) exi->EVMaximumVoltageLimit.Multiplier;
	//shm_msg->EVMaximumVoltageLimit.Unit = (unsigned char) exi->EVMaximumVoltageLimit.Unit;
	shm_msg->EVMaximumVoltageLimit.Unit = V_ISO15118_2014;
	shm_msg->EVMaximumVoltageLimit.Value = (short) exi->EVMaximumVoltageLimit.Value;
	if (shm_msg->EVMaximumVoltageLimit.Value != 0 && exi->EVMaximumVoltageLimit_isUsed == 1u)	//Gridwiz EVCC Emulator will not send EVMaximumVoltageLimit in CurrentDemandReq
	{
		sys->EvBatteryMaxVoltage = ISO151182014PhyValDecode(shm_msg->EVMaximumVoltageLimit);
	}
	/*
	printf("[SeccComm] <V_ev_max> = %d, %d, %.02f\n",
			exi->EVMaximumVoltageLimit.Value,
			shm_msg->EVMaximumVoltageLimit.Value,
			sys->EvBatteryMaxVoltage
		  );
	*/

	//[BODY (4/10)] EVMaximumCurrentLimit
    shm_msg->EVMaximumCurrentLimit.Multiplier = (int) exi->EVMaximumCurrentLimit.Multiplier;
	//shm_msg->EVMaximumCurrentLimit.Unit = (unsigned char) exi->EVMaximumCurrentLimit.Unit;
	shm_msg->EVMaximumCurrentLimit.Unit = A_ISO15118_2014;
	shm_msg->EVMaximumCurrentLimit.Value = (short) exi->EVMaximumCurrentLimit.Value;
	sys->EvBatteryMaxCurrent = ISO151182014PhyValDecode(shm_msg->EVMaximumCurrentLimit);

	//[BODY (5/10)] EVMaximumPowerLimit
    shm_msg->EVMaximumPowerLimit.Multiplier = (int) exi->EVMaximumPowerLimit.Multiplier;
	//shm_msg->EVMaximumPowerLimit.Unit = (unsigned char) exi->EVMaximumPowerLimit.Unit;
	shm_msg->EVMaximumPowerLimit.Unit = W_ISO15118_2014;
	shm_msg->EVMaximumPowerLimit.Value = (short) exi->EVMaximumPowerLimit.Value;
	sys->EvBatteryMaxPower = ISO151182014PhyValDecode(shm_msg->EVMaximumPowerLimit);

    //[BODY (6/10)] BulkChargingComplete
	shm_msg->BulkChargingComplete = (BOOL) exi->BulkChargingComplete;

    //[BODY (7/10)] ChargingComplete
    shm_msg->ChargingComplete = (BOOL) exi->ChargingComplete;

	//[BODY (8/10)] RemainingTimeToFullSoC
	shm_msg->RemainingTimeToFullSoC.Multiplier = (int) exi->RemainingTimeToFullSoC.Multiplier;
	shm_msg->RemainingTimeToFullSoC.Unit = (unsigned char) exi->RemainingTimeToFullSoC.Unit;
	shm_msg->RemainingTimeToFullSoC.Value = (short) exi->RemainingTimeToFullSoC.Value;
	TimeToFull = ISO151182014PhyValDecode(shm_msg->RemainingTimeToFullSoC);

	//[BODY (9/10)] RemainingTimeToBulkSoC
	shm_msg->RemainingTimeToBulkSoC.Multiplier = (int) exi->RemainingTimeToBulkSoC.Multiplier;
	shm_msg->RemainingTimeToBulkSoC.Unit = (unsigned char) exi->RemainingTimeToBulkSoC.Unit;
	shm_msg->RemainingTimeToBulkSoC.Value = (short) exi->RemainingTimeToBulkSoC.Value;
	TimeToBulk = ISO151182014PhyValDecode(shm_msg->RemainingTimeToBulkSoC);
	
	if(TimeToFull > 0)
		sys->RemainChargingDuration = TimeToFull;
	else if(TimeToBulk > 0)
		sys->RemainChargingDuration = TimeToBulk;
	else
	{
		sys->RemainChargingDuration=0;		
	}	

	//[BODY (10/10)] EVTargetVoltage
	shm_msg->EVTargetVoltage.Multiplier = (int) exi->EVTargetVoltage.Multiplier;
	//shm_msg->EVTargetVoltage.Unit = (unsigned char) exi->EVTargetVoltage.Unit;
	shm_msg->EVTargetVoltage.Unit = V_ISO15118_2014;
	shm_msg->EVTargetVoltage.Value = (short) exi->EVTargetVoltage.Value;
	if((shm_msg->EVTargetVoltage.Value != 0) && (sys->EvBatteryMaxVoltage != 0))
	{
		//sys->EvBatterytargetVoltage = (ISO151182014PhyValDecode(shm_msg->EVTargetVoltage) + sys->EvBatteryMaxVoltage)/2;
		/*+++ vern, itme 5 in V0.24.S0, +++*/
		//sys->EvBatterytargetVoltage = (DIN70121PhyValDecode(shm_msg->EVTargetVoltage) + sys->EvBatteryMaxVoltage)/2;
		if((ISO151182014PhyValDecode(shm_msg->EVTargetVoltage)+10)>=sys->EvBatteryMaxVoltage)
			sys->EvBatterytargetVoltage = (ISO151182014PhyValDecode(shm_msg->EVTargetVoltage) + sys->EvBatteryMaxVoltage)/2;
		else
			sys->EvBatterytargetVoltage =  ISO151182014PhyValDecode(shm_msg->EVTargetVoltage)+10;
		/*--- vern, itme 5 in V0.24.S0, ---*/	
	}
	else
	{
		sys->EvBatterytargetVoltage = ISO151182014PhyValDecode(shm_msg->EVTargetVoltage);
	}

	/*
	printf("[SeccComm] <V_ev_target> = %d, %d, %.02f\n",
			exi->EVTargetVoltage.Value,
			shm_msg->EVTargetVoltage.Value,
			sys->EvBatterytargetVoltage
		  );
	*/

	#if MANUAL_SET_EV_TARGET_FUNCTION == ENABLE
	sys->EvBatterytargetVoltage = SUDO_EV_TARGET_VOLTAGE;	//for test (500V, unit: 1V)
	#endif
}


/*===========================================================================
FUNCTION: SHM_Save_iso1_ChargingStatusReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_iso1_ChargingStatusReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
{
	//no content for ISO1
}

/*===========================================================================
FUNCTION: SHM_Save_din_WeldingDetectionReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_din_WeldingDetectionReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct WeldingDetectionRequest_DIN70121 *shm_msg;
    struct dinWeldingDetectionReqType *exi;
	struct ChargingInfoData *sys;

    shm_msg = &shm_ccs->V2GMessage_DIN70121.WeldingDetectionRequest;
    exi = &exi_doc_DIN->V2G_Message.Body.WeldingDetectionReq;
	sys = &shm_sys->SysInfo.CcsChargingData[0];

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_din_V2GMSG_Header(buf);


	//===== [BODY (1/3)] DC_EVStatus =====
    //DC_EVStatus
    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
	shm_msg->DC_EVStatus.EVCabinConditioning = (BOOL) exi->DC_EVStatus.EVCabinConditioning;
	shm_msg->DC_EVStatus.EVRESSConiditioning = (BOOL) exi->DC_EVStatus.EVRESSConditioning;
	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;
}

/*===========================================================================
FUNCTION: SHM_Save_iso1_WeldingDetectionReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_iso1_WeldingDetectionReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
    int i = 0;
    struct WeldingDetectionRequest_ISO15118_2014 *shm_msg;
    struct iso1WeldingDetectionReqType *exi;
	struct ChargingInfoData *sys;

    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.WeldingDetectionRequest;
    exi = &exi_doc_ISO1->V2G_Message.Body.WeldingDetectionReq;
	sys = &shm_sys->SysInfo.CcsChargingData[0];

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_iso1_V2GMSG_Header(buf);


	//===== [BODY (1/3)] DC_EVStatus =====
    //DC_EVStatus
    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;
}


/*===========================================================================
FUNCTION: SHM_Save_din_SessionStopReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_din_SessionStopReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
	/*
    int i = 0;
    struct SessionStopRequest_DIN70121 *shm_msg;
    struct dinSessionStopReqType *exi;

    shm_msg = &shm_ccs->V2GMessage_DIN70121.SessionStopRequest;
    exi = &exi_doc_DIN->V2G_Message.Body.SessionStopReq;
	*/

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_din_V2GMSG_Header(buf);

	//null
}

/*===========================================================================
FUNCTION: SHM_Save_iso1_SessionStopReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void SHM_Save_iso1_SessionStopReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
{
    // ======== [STEP 1/3] Initialize ========
	/*
    int i = 0;
    struct SessionStopRequest_ISO15118_2014 *shm_msg;
    struct iso1SessionStopReqType *exi;

    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.SessionStopRequest;
    exi = &exi_doc_ISO1->V2G_Message.Body.SessionStopReq;
	*/

    // ======== [STEP 2/3] Update Flags ========

    // ======== [STEP 3/3] Transfer Data ========
    //SHM_Save_iso1_V2GMSG_Header(buf);

	//null
}


/*===========================================================================
FUNCTION: SHM_Read_din_SessionSetupRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_DIN

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_din_SessionSetupRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
{
	int i = 0;
	struct dinSessionSetupResType *out;
	struct SessionSetupResponse_DIN70121 *in;

	out = &exi_doc_DIN->V2G_Message.Body.SessionSetupRes;
	in = &shm_ccs->V2GMessage_DIN70121.SessionSetupResponse;

	exi_doc_DIN->V2G_Message.Body.SessionSetupRes_isUsed = 1u;

	// ====== [BODY (1/3) ResponseCode ======
	out->ResponseCode = in->ResponseCode;

	// ====== [BODY (2/3) EVSEID ======
	out->EVSEID.bytesLen = 32;  //max = 32  bytes(DIN), all zero
	for (i = 0; i< 32; i++)
	{
		out->EVSEID.bytes[i] = (unsigned char) in->EVSEID[i];
	}

	// ====== [BODY (3/3) DateTimeNow ======
	out->DateTimeNow_isUsed = 1u;
	out->DateTimeNow = (int64_t) in->EVSETimeStamp;   //Format: Unix Time Stamp
}

/*===========================================================================
FUNCTION: SHM_Read_din_ContractAuthenticationRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_DIN

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_din_ContractAuthenticationRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
{
	struct dinContractAuthenticationResType *out;
	struct ContractAuthenticationResponse_DIN70121 *in;

	out = &exi_doc_DIN->V2G_Message.Body.ContractAuthenticationRes;
	in = &shm_ccs->V2GMessage_DIN70121.ContractAuthenticationResponse;

	//[BODY (2/2)] EVSEProcessing
	out->EVSEProcessing = (BOOL)in->EVSEProcessing; //0(Finished) or 1(Ongoing)
}


/*===========================================================================
FUNCTION: SHM_Read_din_ChargeParameterDiscoveryRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_DIN

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_din_ChargeParameterDiscoveryRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
{
	struct dinChargeParameterDiscoveryResType *out;
	struct ChargeParameterDiscoveryResponse_DIN70121 *in;

	out = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryRes;
	in = &shm_ccs->V2GMessage_DIN70121.ChargeParameterDiscoveryResponse;

	//Initialize
	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
	init_dinChargeParameterDiscoveryResType(out);
	exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryRes_isUsed = 1u;

	//----- [BODY (1/5)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;

    //----- [BODY (2/5)] EVSEProcessing -----
    out->EVSEProcessing = (BOOL) in->EVSEProcessing;
    // 	dinEVSEProcessingType_Finished = 0,
    //	dinEVSEProcessingType_Ongoing = 1

    //----- [BODY (3/5)] SAScheduleList of SASchedules -----
	//[Joseph] Here keep constant values and not copy from share memory, yet.
    out->SAScheduleList_isUsed = 1u;
    struct dinSAScheduleListType *list;
    list = &out->SAScheduleList;
    //
    list->SAScheduleTuple.arrayLen = 1;
    list->SAScheduleTuple.array[0].SAScheduleTupleID = 0;
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleID = 0;
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.arrayLen = 1;
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval_isUsed = 1u;
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.start = 0;
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.duration = 86400;	//24Hrs at least, unit:second
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.duration_isUsed = 1u;
     /*+++ 20200808, vern, add Pmax parameters in chargeParameters discovery +++*/
    //in->DC_EVSEChargeParameter.EVSEMaximumPowerLimit.Value*=10;
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax = in->DC_EVSEChargeParameter.EVSEMaximumPowerLimit.Value;
       /*--- 20200808, vern, add Pmax parameters in chargeParameters discovery ---*/
    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval_isUsed = 1u;
    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval = 600;
    //list->SAScheduleTuple.array[0].SalesTariff.xxx
    //list->SAScheduleTuple.array[0].SalesTariff_isUsed = 0u;


    //-----  [BODY (4/5)] AC_EVSEChargeParameter of EVSEChargeParameter -----
    //ignore, since DIN doesn't support AC

    //----- [BODY (5/5)] DC_EVSEChargeParameter of EVSEChargeParameter -----
    out->DC_EVSEChargeParameter_isUsed = 1u;
    struct dinDC_EVSEChargeParameterType *out_dc_para;
	struct DC_EVSEChargeParameterType_DIN70121 *in_dc_para;
    out_dc_para = &out->DC_EVSEChargeParameter;
	in_dc_para = &in->DC_EVSEChargeParameter;

    //DC_EVSEStatus
	out_dc_para->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
	SHM_Read_dinDC_EVSEStatusType(&out_dc_para->DC_EVSEStatus, &in_dc_para->DC_EVSEStatus);

    //EVSEMaximumCurrentLimit
	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEMaximumCurrentLimit, &in_dc_para->EVSEMaximumCurrentLimit);

    //EVSEMaximumPowerLimit
	out_dc_para->EVSEMaximumPowerLimit_isUsed = 1u;
	
	//in_dc_para->EVSEMaximumPowerLimit.Value=360;
	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEMaximumPowerLimit, &in_dc_para->EVSEMaximumPowerLimit);

    //EVSEMaximumVoltageLimit
	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEMaximumVoltageLimit, &in_dc_para->EVSEMaximumVoltageLimit);

    //EVSEMinimumVoltageLimit
	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEMinimumVoltageLimit, &in_dc_para->EVSEMinimumVoltageLimit);


    //EVSEMinimumCurrentLimit
	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEMinimumCurrentLimit, &in_dc_para->EVSEMinimumCurrentLimit);

    //EVSECurrentRegulationTolerance_isUsed
    out_dc_para->EVSECurrentRegulationTolerance_isUsed = 1u;
    //EVSECurrentRegulationTolerance
	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSECurrentRegulationTolerance, &in_dc_para->EVSECurrentRegulationTolerance);

    //EVSEEnergyToBeDelivered_isUsed
    out_dc_para->EVSEEnergyToBeDelivered_isUsed = 0u;
	//EVSEEnergyToBeDelivered (optional)
    //SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEEnergyToBeDelivered, &in_dc_para->EVSEEnergyToBeDelivered);

    //EVSEPeakCurrentRipple
	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEPeakCurrentRipple, &in_dc_para->EVSEPeakCurrentRipple);
}

/*===========================================================================
FUNCTION: SHM_Read_iso1_ChargeParameterDiscoveryRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_ISO1

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_iso1_ChargeParameterDiscoveryRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
{
	struct iso1ChargeParameterDiscoveryResType *out;
	struct ChargeParameterDiscoveryResponse_ISO15118_2014 *in;

	out = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryRes;
	in = &shm_ccs->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryResponse;

	//Initialize
	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
	init_iso1ChargeParameterDiscoveryResType(out);
	exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryRes_isUsed = 1u;

	//----- [BODY (1/5)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;

    //----- [BODY (2/5)] EVSEProcessing -----
    out->EVSEProcessing = (BOOL) in->EVSEProcessing;
    // 	iso1EVSEProcessingType_Finished = 0,
    //	iso1EVSEProcessingType_Ongoing = 1

    //----- [BODY (3/5)] SAScheduleList of SASchedules -----
	//[Joseph] Here keep constant values and not copy from share memory, yet.
    out->SAScheduleList_isUsed = 1u;
    struct iso1SAScheduleListType *list;
    list = &out->SAScheduleList;
    //
    list->SAScheduleTuple.arrayLen = 1;
    list->SAScheduleTuple.array[0].SAScheduleTupleID = 1;
    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleID = 0;
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.arrayLen = 1;
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval_isUsed = 1u;
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.start = 0;
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.duration = 86400;	//24Hrs at least, unit:second
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.duration_isUsed = 1u;
    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval_isUsed = 1u;
    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval = 86400;
    /*+++ 20200808, vern, add Pmax parameters in chargeParameters discovery +++*/
   // in->DC_EVSEChargeParameter.EVSEMaximumPowerLimit.Value*=10;   /*+++ 20200808, vern, lack one more 0 ---*/
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax.Unit = iso1unitSymbolType_W;	//iso1unitSymbolType_W
    #if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) | (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax.Multiplier = 0;	//w
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax.Value =((unsigned int)in->AC_EVSEChargeParameter.EVSEMaxCurrent.Value*(unsigned int)in->AC_EVSEChargeParameter.EVSENominalVoltage.Value)/100;	
    #else
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax.Multiplier = 3;	//kw
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax.Value =in->DC_EVSEChargeParameter.EVSEMaximumPowerLimit.Value;	//30000 if DW/DM product
    #endif
    /*--- 20200808, vern, add Pmax parameters in chargeParameters discovery ---*/
    //list->SAScheduleTuple.array[0].SalesTariff.xxx
    //list->SAScheduleTuple.array[0].SalesTariff_isUsed = 0u;


	//-----  [BODY (4/5)] AC/DC EVSEChargeParameter -----
	#if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) | (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
	{
		//-----  [BODY (4/5)] AC_EVSEChargeParameter -----
		out->AC_EVSEChargeParameter_isUsed = 1u;
		struct iso1AC_EVSEChargeParameterType *out_ac_para;
		struct AC_EVSEChargeParameterType_ISO15118_2014 *in_ac_para;
		out_ac_para = &out->AC_EVSEChargeParameter;
		in_ac_para = &in->AC_EVSEChargeParameter;

		//[1/3] AC_EVSEStatus
		SHM_Read_iso1AC_EVSEStatusType(&out_ac_para->AC_EVSEStatus, &in_ac_para->AC_EVSEStatus);

		//[2/3] EVSENominalVoltage
		SHM_Read_iso1PhysicalValueType(&out_ac_para->EVSENominalVoltage, &in_ac_para->EVSENominalVoltage);

		//[3/3] EVSEMaxCurrent
		SHM_Read_iso1PhysicalValueType(&out_ac_para->EVSEMaxCurrent, &in_ac_para->EVSEMaxCurrent);
	}
	#else //CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED
	{
		//----- [BODY (5/5)] DC_EVSEChargeParameter -----
		out->DC_EVSEChargeParameter_isUsed = 1u;
		struct iso1DC_EVSEChargeParameterType *out_dc_para;
		struct DC_EVSEChargeParameterType_ISO15118_2014 *in_dc_para;
		out_dc_para = &out->DC_EVSEChargeParameter;
		in_dc_para = &in->DC_EVSEChargeParameter;

		//DC_EVSEStatus
		out_dc_para->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
		SHM_Read_iso1DC_EVSEStatusType(&out_dc_para->DC_EVSEStatus, &in_dc_para->DC_EVSEStatus);

		//EVSEMaximumCurrentLimit
		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEMaximumCurrentLimit, &in_dc_para->EVSEMaximumCurrentLimit);

		//EVSEMaximumPowerLimit
		//in_dc_para->EVSEMaximumPowerLimit.Value=360;
		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEMaximumPowerLimit, &in_dc_para->EVSEMaximumPowerLimit);
		
		//EVSEMaximumVoltageLimit
		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEMaximumVoltageLimit, &in_dc_para->EVSEMaximumVoltageLimit);

		//EVSEMinimumVoltageLimit
		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEMinimumVoltageLimit, &in_dc_para->EVSEMinimumVoltageLimit);


		//EVSEMinimumCurrentLimit
		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEMinimumCurrentLimit, &in_dc_para->EVSEMinimumCurrentLimit);

		//EVSECurrentRegulationTolerance_isUsed
		out_dc_para->EVSECurrentRegulationTolerance_isUsed = 1u;
		//EVSECurrentRegulationTolerance
		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSECurrentRegulationTolerance, &in_dc_para->EVSECurrentRegulationTolerance);

		//EVSEEnergyToBeDelivered_isUsed
		out_dc_para->EVSEEnergyToBeDelivered_isUsed = 0u;
		//EVSEEnergyToBeDelivered (optional)
		//SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEEnergyToBeDelivered, &in_dc_para->EVSEEnergyToBeDelivered);

		//EVSEPeakCurrentRipple
		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEPeakCurrentRipple, &in_dc_para->EVSEPeakCurrentRipple);
	}
	#endif
}


/*===========================================================================
FUNCTION: SHM_Read_din_CableCheckRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_DIN

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_din_CableCheckRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
{
	struct dinCableCheckResType *out;
	struct CableCheckResponse_DIN70121 *in;

	out = &exi_doc_DIN->V2G_Message.Body.CableCheckRes;
	in = &shm_ccs->V2GMessage_DIN70121.CableCheckResponse;

	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
    init_dinCableCheckResType(out);
	exi_doc_DIN->V2G_Message.Body.CableCheckRes_isUsed = 1u;

	//----- [BODY (1/3)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;

    //----- [BODY (2/3)] EVSEProcessing -----
	out->EVSEProcessing = (BOOL) in->EVSEProcessing;
    // 	dinEVSEProcessingType_Finished = 0,
    //	dinEVSEProcessingType_Ongoing = 1

    //----- [BODY (3/3)] DC_EVSEStatus -----
	SHM_Read_dinDC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
}

/*===========================================================================
FUNCTION: SHM_Read_iso1_CableCheckRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_ISO1

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_iso1_CableCheckRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
{
	struct iso1CableCheckResType *out;
	struct CableCheckResponse_ISO15118_2014 *in;

	out = &exi_doc_ISO1->V2G_Message.Body.CableCheckRes;
	in = &shm_ccs->V2GMessage_ISO15118_2014.CableCheckResponse;

	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
    init_iso1CableCheckResType(out);
	exi_doc_ISO1->V2G_Message.Body.CableCheckRes_isUsed = 1u;

	//----- [BODY (1/3)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;

    //----- [BODY (2/3)] EVSEProcessing -----
	out->EVSEProcessing = (BOOL) in->EVSEProcessing;
    // 	iso1EVSEProcessingType_Finished = 0,
    //	iso1EVSEProcessingType_Ongoing = 1

    //----- [BODY (3/3)] DC_EVSEStatus -----
	SHM_Read_iso1DC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
}


/*===========================================================================
FUNCTION: SHM_Read_din_PreChargeRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_DIN

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_din_PreChargeRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
{
	struct dinPreChargeResType *out;
	struct PreChargeResponse_DIN70121 *in;

	out = &exi_doc_DIN->V2G_Message.Body.PreChargeRes;
	in = &shm_ccs->V2GMessage_DIN70121.PreChargeResponse;
	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
    init_dinPreChargeResType(&exi_doc_DIN->V2G_Message.Body.PreChargeRes);
	exi_doc_DIN->V2G_Message.Body.PreChargeRes_isUsed = 1u;


	//----- [BODY (1/3)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;


    //----- [BODY (2/3)] EVSEPresentVoltage -----
	SHM_Read_dinPhysicalValueType(&out->EVSEPresentVoltage, &in->EVSEPresentVoltage);
    //	dinunitSymbolType_h = 0,
    //	dinunitSymbolType_m = 1,
    //	dinunitSymbolType_s = 2,
    //	dinunitSymbolType_A = 3,
    //	dinunitSymbolType_Ah = 4,
    //	dinunitSymbolType_V = 5,
    //	dinunitSymbolType_VA = 6,
    //	dinunitSymbolType_W = 7,
    //	dinunitSymbolType_W_s = 8,
    //	dinunitSymbolType_Wh = 9


    //----- [BODY (3/3)] DC_EVSEStatus -----
	SHM_Read_dinDC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
}

/*===========================================================================
FUNCTION: SHM_Read_iso1_PreChargeRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_ISO1

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_iso1_PreChargeRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
{
	struct iso1PreChargeResType *out;
	struct PreChargeResponse_ISO15118_2014 *in;

	out = &exi_doc_ISO1->V2G_Message.Body.PreChargeRes;
	in = &shm_ccs->V2GMessage_ISO15118_2014.PreChargeResponse;
	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
    init_iso1PreChargeResType(&exi_doc_ISO1->V2G_Message.Body.PreChargeRes);
	exi_doc_ISO1->V2G_Message.Body.PreChargeRes_isUsed = 1u;


	//----- [BODY (1/3)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;


    //----- [BODY (2/3)] EVSEPresentVoltage -----
	SHM_Read_iso1PhysicalValueType(&out->EVSEPresentVoltage, &in->EVSEPresentVoltage);
	//iso1unitSymbolType_h = 0,
	//iso1unitSymbolType_m = 1,
	//iso1unitSymbolType_s = 2,
	//iso1unitSymbolType_A = 3,
	//iso1unitSymbolType_V = 4,
	//iso1unitSymbolType_W = 5,
	//iso1unitSymbolType_Wh = 6


    //----- [BODY (3/3)] DC_EVSEStatus -----
	SHM_Read_iso1DC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
}


/*===========================================================================
FUNCTION: SHM_Read_din_PowerDeliveryRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_DIN

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_din_PowerDeliveryRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
{
	struct dinPowerDeliveryResType *out;
	struct PowerDeliveryResponse_DIN70121 *in;
	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
	init_dinPowerDeliveryResType(&exi_doc_DIN->V2G_Message.Body.PowerDeliveryRes);

	out = &exi_doc_DIN->V2G_Message.Body.PowerDeliveryRes;
	in = &shm_ccs->V2GMessage_DIN70121.PowerDeliveryResponse;
	exi_doc_DIN->V2G_Message.Body.PowerDeliveryRes_isUsed = 1u;

	//----- [BODY (1/3)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;


    //----- [BODY (2/3)] AC_EVSEStatus -----
    //ignore, since DIN 70121 doesn't support AC, yet.


    //----- [BODY (2/3)] DC_EVSEStatus -----
	out->DC_EVSEStatus_isUsed = 1u;
	SHM_Read_dinDC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
}

/*===========================================================================
FUNCTION: SHM_Read_iso1_PowerDeliveryRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_ISO1

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_iso1_PowerDeliveryRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
{
	struct iso1PowerDeliveryResType *out;
	struct PowerDeliveryResponse_ISO15118_2014 *in;
	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
	init_iso1PowerDeliveryResType(&exi_doc_ISO1->V2G_Message.Body.PowerDeliveryRes);

	out = &exi_doc_ISO1->V2G_Message.Body.PowerDeliveryRes;
	in = &shm_ccs->V2GMessage_ISO15118_2014.PowerDeliveryResponse;
	exi_doc_ISO1->V2G_Message.Body.PowerDeliveryRes_isUsed = 1u;

	//----- [BODY (1/3)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;


    //----- [BODY (2/3)] AC_EVSEStatus -----
    //ignore, since our ISO1 70121 doesn't support AC, yet.


    //----- [BODY (2/3)] DC_EVSEStatus -----
	#if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) | (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
	{
		out->DC_EVSEStatus_isUsed = 0u;
		out->AC_EVSEStatus_isUsed = 1u;
		SHM_Read_iso1AC_EVSEStatusType(&out->AC_EVSEStatus, &in->AC_EVSEStatus);
	}
	#else //CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED
	{
		out->DC_EVSEStatus_isUsed = 1u;
		SHM_Read_iso1DC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
	}
	#endif
}


/*===========================================================================
FUNCTION: SHM_Read_din_CurrentDemandRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_DIN

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_din_CurrentDemandRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
{
	struct dinCurrentDemandResType *out;
	struct CurrentDemandResponse_DIN70121 *in;
	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
	init_dinCurrentDemandResType(&exi_doc_DIN->V2G_Message.Body.CurrentDemandRes);

	out = &exi_doc_DIN->V2G_Message.Body.CurrentDemandRes;
	in = &shm_ccs->V2GMessage_DIN70121.CurrentDemandResponse;
	exi_doc_DIN->V2G_Message.Body.CurrentDemandRes_isUsed = 1u;


	//----- [BODY (1/10)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;

    //----- [BODY (2/10)] DC_EVSEStatus -----
    SHM_Read_dinDC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);

    //----- [BODY (3/10)] EVSEPresentVoltage -----
	SHM_Read_dinPhysicalValueType(&out->EVSEPresentVoltage, &in->EVSEPresentVoltage);


    //----- [BODY (4/10)] EVSEPresentCurrent -----
	SHM_Read_dinPhysicalValueType(&out->EVSEPresentCurrent, &in->EVSEPresentCurrent);


    //----- [BODY (5/10)] EVSECurrentLimitAchieved -----
    out->EVSECurrentLimitAchieved = in->EVSECurrentLimitAchieved;

    //----- [BODY (6/10)] EVSEVoltageLimitAchieved -----
    out->EVSEVoltageLimitAchieved = in->EVSEVoltageLimitAchieved;

    //----- [BODY (7/10)] EVSEPowerLimitAchieved -----
    out->EVSEPowerLimitAchieved = in->EVSEPowerLimitAchieved;

    //----- [BODY (8/10)] EVSEMaximumVoltageLimit -----
    out->EVSEMaximumVoltageLimit_isUsed = 1u;
	SHM_Read_dinPhysicalValueType(&out->EVSEMaximumVoltageLimit, &in->EVSEMaximumVoltageLimit);

    //----- [BODY (9/10)] EVSEMaximumCurrentLimit -----
    out->EVSEMaximumCurrentLimit_isUsed = 1u;
	SHM_Read_dinPhysicalValueType(&out->EVSEMaximumCurrentLimit, &in->EVSEMaximumCurrentLimit);

    //----- [BODY (10/10)] EVSEMaximumPowerLimit -----
    out->EVSEMaximumPowerLimit_isUsed = 1u;
	SHM_Read_dinPhysicalValueType(&out->EVSEMaximumPowerLimit, &in->EVSEMaximumPowerLimit);
}

/*===========================================================================
FUNCTION: SHM_Read_iso1_CurrentDemandRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_ISO1

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_iso1_CurrentDemandRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
{
	struct iso1CurrentDemandResType *out;
	struct CurrentDemandResponse_ISO15118_2014 *in;
	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
	init_iso1CurrentDemandResType(&exi_doc_ISO1->V2G_Message.Body.CurrentDemandRes);

	out = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandRes;
	in = &shm_ccs->V2GMessage_ISO15118_2014.CurrentDemandResponse;
	exi_doc_ISO1->V2G_Message.Body.CurrentDemandRes_isUsed = 1u;

	//vern, fill up necessary 
	 out->EVSEID.charactersLen=7;
	 out->EVSEID.characters[0]='Z';
	 out->EVSEID.characters[1]='Z';
	 out->EVSEID.characters[2]='0';
	 out->EVSEID.characters[3]='0';
	 out->EVSEID.characters[4]='0';
	 out->EVSEID.characters[5]='0';
	 out->EVSEID.characters[6]='0';
	out->SAScheduleTupleID=1;
	out->MeterInfo_isUsed=0u;
	out->ReceiptRequired_isUsed=0u;
	//----- [BODY (1/10)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;

    //----- [BODY (2/10)] DC_EVSEStatus -----
    SHM_Read_iso1DC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);

    //----- [BODY (3/10)] EVSEPresentVoltage -----
	SHM_Read_iso1PhysicalValueType(&out->EVSEPresentVoltage, &in->EVSEPresentVoltage);


    //----- [BODY (4/10)] EVSEPresentCurrent -----
	SHM_Read_iso1PhysicalValueType(&out->EVSEPresentCurrent, &in->EVSEPresentCurrent);


    //----- [BODY (5/10)] EVSECurrentLimitAchieved -----
    out->EVSECurrentLimitAchieved = in->EVSECurrentLimitAchieved;

    //----- [BODY (6/10)] EVSEVoltageLimitAchieved -----
    out->EVSEVoltageLimitAchieved = in->EVSEVoltageLimitAchieved;

    //----- [BODY (7/10)] EVSEPowerLimitAchieved -----
    out->EVSEPowerLimitAchieved = in->EVSEPowerLimitAchieved;

    //----- [BODY (8/10)] EVSEMaximumVoltageLimit -----
    out->EVSEMaximumVoltageLimit_isUsed = 1u;
	SHM_Read_iso1PhysicalValueType(&out->EVSEMaximumVoltageLimit, &in->EVSEMaximumVoltageLimit);

    //----- [BODY (9/10)] EVSEMaximumCurrentLimit -----
    out->EVSEMaximumCurrentLimit_isUsed = 1u;
	SHM_Read_iso1PhysicalValueType(&out->EVSEMaximumCurrentLimit, &in->EVSEMaximumCurrentLimit);

    //----- [BODY (10/10)] EVSEMaximumPowerLimit -----
    out->EVSEMaximumPowerLimit_isUsed = 1u;
	SHM_Read_iso1PhysicalValueType(&out->EVSEMaximumPowerLimit, &in->EVSEMaximumPowerLimit);
}

/*===========================================================================
FUNCTION: SHM_Read_iso1_ChargingStatusRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_ISO1

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_iso1_ChargingStatusRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
{
	int i = 0;
	struct iso1ChargingStatusResType *out;
	struct ChargingStatusResponse_ISO15118_2014 *in;
	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
	init_iso1ChargingStatusResType(&exi_doc_ISO1->V2G_Message.Body.ChargingStatusRes);

	out = &exi_doc_ISO1->V2G_Message.Body.ChargingStatusRes;
	in = &shm_ccs->V2GMessage_ISO15118_2014.ChargingStatusResponse;
	exi_doc_ISO1->V2G_Message.Body.ChargingStatusRes_isUsed = 1u;


	//----- [BODY (1/10)] ResponseCode -----
    out->ResponseCode = (unsigned char)in->ResponseCode;

    //----- [BODY (2/10)] AC_EVSEStatus -----
    SHM_Read_iso1AC_EVSEStatusType(&out->AC_EVSEStatus, &in->AC_EVSEStatus);

    //----- [BODY (3/10)] EVSEMaxCurrent -----
	out->EVSEMaxCurrent_isUsed = 1u;
	SHM_Read_iso1PhysicalValueType(&out->EVSEMaxCurrent, &in->EVSEMaxCurrent);

    //----- [BODY (4/10)] SAScheduleTupleID -----
	out->SAScheduleTupleID = (unsigned char)in->SAScheduleTupleID;	//[CAUTION] data type

    //----- [BODY (5/10)] EVSEID -----
	out->EVSEID.charactersLen = 37;  //min length: 7, max length:37  bytes(ISO1, AC)
	for (i = 0; i< out->EVSEID.charactersLen; i++)
	{
		out->EVSEID.characters[i] = (unsigned char)in->EVSEID[i];
	}

    //----- [BODY (6/10)] MeterInfo -----
    out->MeterInfo_isUsed = 1u;
	SHM_Read_iso1MeterInfo(&out->MeterInfo, &in->MeterInfo);

    //----- [BODY (7/10)] ReceiptRequired -----
    out->ReceiptRequired_isUsed = 1u;
	out->ReceiptRequired = (int)in->ReceiptRequired;
}

/*===========================================================================
FUNCTION: SHM_Read_din_WeldingDetectionRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_DIN

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_din_WeldingDetectionRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
{
	struct dinWeldingDetectionResType *out;
	struct WeldingDetectionResponse_DIN70121 *in;
	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
	init_dinWeldingDetectionResType(&exi_doc_DIN->V2G_Message.Body.WeldingDetectionRes);


	out = &exi_doc_DIN->V2G_Message.Body.WeldingDetectionRes;
	in = &shm_ccs->V2GMessage_DIN70121.WeldingDetectionResponse;
	exi_doc_DIN->V2G_Message.Body.WeldingDetectionRes_isUsed = 1u;


	//----- [BODY (1/3)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;


    //----- [BODY (2/3)] EVSEPresentVoltage -----
	SHM_Read_dinPhysicalValueType(&out->EVSEPresentVoltage, &in->EVSEPresentVoltage);


    //----- [BODY (3/3)] DC_EVSEStatus -----
    SHM_Read_dinDC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
}

/*===========================================================================
FUNCTION: SHM_Read_iso1_WeldingDetectionRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_ISO1

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_iso1_WeldingDetectionRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
{
	struct iso1WeldingDetectionResType *out;
	struct WeldingDetectionResponse_ISO15118_2014 *in;
	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
	init_iso1WeldingDetectionResType(&exi_doc_ISO1->V2G_Message.Body.WeldingDetectionRes);


	out = &exi_doc_ISO1->V2G_Message.Body.WeldingDetectionRes;
	in = &shm_ccs->V2GMessage_ISO15118_2014.WeldingDetectionResponse;
	exi_doc_ISO1->V2G_Message.Body.WeldingDetectionRes_isUsed = 1u;


	//----- [BODY (1/3)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;


    //----- [BODY (2/3)] EVSEPresentVoltage -----
	SHM_Read_iso1PhysicalValueType(&out->EVSEPresentVoltage, &in->EVSEPresentVoltage);


    //----- [BODY (3/3)] DC_EVSEStatus -----
    SHM_Read_iso1DC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
}


/*===========================================================================
FUNCTION: SHM_Read_din_SessionStopRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_DIN

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_din_SessionStopRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
{
	struct dinSessionStopResType *out;
	struct SessionStopResponse_DIN70121 *in;
	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
	init_dinSessionStopResType(&exi_doc_DIN->V2G_Message.Body.SessionStopRes);

	out = &exi_doc_DIN->V2G_Message.Body.SessionStopRes;
	in = &shm_ccs->V2GMessage_DIN70121.SessionStopResponse;
	exi_doc_DIN->V2G_Message.Body.SessionStopRes_isUsed = 1u;


	//----- [BODY (1/3)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;
}

/*===========================================================================
FUNCTION: SHM_Read_iso1_SessionStopRes
DESCRIPTION:
PRE-CONDITION:
INPUT:
		1. shm_ccs
OUTPUT:
		2. exi_doc_ISO1

GLOBAL VARIABLES:
=============================================================================*/
void SHM_Read_iso1_SessionStopRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
{
	struct iso1SessionStopResType *out;
	struct SessionStopResponse_ISO15118_2014 *in;
	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
	init_iso1SessionStopResType(&exi_doc_ISO1->V2G_Message.Body.SessionStopRes);

	out = &exi_doc_ISO1->V2G_Message.Body.SessionStopRes;
	in = &shm_ccs->V2GMessage_ISO15118_2014.SessionStopResponse;
	exi_doc_ISO1->V2G_Message.Body.SessionStopRes_isUsed = 1u;


	//----- [BODY (1/3)] ResponseCode -----
    out->ResponseCode = (unsigned char) in->ResponseCode;
}


/*===========================================================================
FUNCTION: PRINT_V2G_MSG_din_Header
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_V2G_MSG_din_Header(struct dinEXIDocument *exi_doc_DIN)
{
    int i = 0;
    int leng = 0;
    leng = exi_doc_DIN->V2G_Message.Header.SessionID.bytesLen;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\t SessionID (%d Bytes) = ", leng);
    for (i = 0; i <leng ; i++)
    {
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_DIN->V2G_Message.Header.SessionID.bytes[i]);
    }
}

/*===========================================================================
FUNCTION: PRINT_V2G_MSG_iso1_Header
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_V2G_MSG_iso1_Header(struct iso1EXIDocument *exi_doc_ISO1)
{
    int i = 0;
    int leng = 0;
    leng = exi_doc_ISO1->V2G_Message.Header.SessionID.bytesLen;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\t SessionID (%d Bytes) = ", leng);
    for (i = 0; i <leng ; i++)
    {
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[i]);
    }
}

/*===========================================================================
FUNCTION: PRINT_V2G_MSG_iso1_Header
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_V2G_MSG_iso2_Header(struct iso2EXIDocument *exi_doc_ISO2)
{
    int i = 0;
    int leng = 0;
    leng = exi_doc_ISO2->V2G_Message.Header.SessionID.bytesLen;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\t SessionID (%d Bytes) = ", leng);
    for (i = 0; i <leng ; i++)
    {
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[i]);
    }
}

/*===========================================================================
FUNCTION: DEBUG_PRINT_EXI_MSG_supportedAppProtocolReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_supportedAppProtocolReq(struct appHandEXIDocument *exi_doc)
{
	int i = 0;

	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n EVSE side: List of application handshake protocols of the EV \n");

	for(i = 0; i < exi_doc->supportedAppProtocolReq.AppProtocol.arrayLen; i++)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("\tProtocol entry #=%d\n",(i+1));

		DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\tProtocolNamespace=");
		printASCIIString(
			exi_doc->supportedAppProtocolReq.AppProtocol.array[i].ProtocolNamespace.characters,
			exi_doc->supportedAppProtocolReq.AppProtocol.array[i].ProtocolNamespace.charactersLen
			);

		DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\tVersion=%d.%d\n",
			exi_doc->supportedAppProtocolReq.AppProtocol.array[i].VersionNumberMajor,
			exi_doc->supportedAppProtocolReq.AppProtocol.array[i].VersionNumberMinor);

		DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\tSchemaID=%d\n", exi_doc->supportedAppProtocolReq.AppProtocol.array[i].SchemaID);

		DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\tPriority=%d\n", exi_doc->supportedAppProtocolReq.AppProtocol.array[i].Priority);
	}

}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_DIN_SessionSetupReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_DIN_SessionSetupReq(struct dinEXIDocument *exi_doc_DIN)
{
    int i = 0;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing SessionSetupReq ⨀⨀⨀⨀⨀⬇\n");

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_din_Header(exi_doc_DIN);

	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tEVCCID (%d Bytes) = ", exi_doc_DIN->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen);
    for (i = 0; i < exi_doc_DIN->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen; i++)
    {
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_DIN->V2G_Message.Body.SessionSetupReq.EVCCID.bytes[i]);
    }
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing SessionSetupReq ⨂⨂⨂⨂⨂⬆\n\n");
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_ISO1_SessionSetupReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_ISO1_SessionSetupReq(struct iso1EXIDocument *exi_doc_ISO1)
{
    int i = 0;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing SessionSetupReq ⨀⨀⨀⨀⨀⬇\n");

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);

	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tEVCCID (%d Bytes) = ", exi_doc_ISO1->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen);
    for (i = 0; i < exi_doc_ISO1->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen; i++)
    {
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_ISO1->V2G_Message.Body.SessionSetupReq.EVCCID.bytes[i]);
    }
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing SessionSetupReq ⨂⨂⨂⨂⨂⬆\n\n");
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_ISO2_SessionSetupReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_ISO2_SessionSetupReq(struct iso2EXIDocument *exi_doc_ISO2)
{
    int i = 0;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing SessionSetupReq ⨀⨀⨀⨀⨀⬇\n");

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso2_Header(exi_doc_ISO2);

	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tEVCCID (%d Bytes) = ", exi_doc_ISO2->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen);
    for (i = 0; i < exi_doc_ISO2->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen; i++)
    {
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_ISO2->V2G_Message.Body.SessionSetupReq.EVCCID.bytes[i]);
    }
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing SessionSetupReq ⨂⨂⨂⨂⨂⬆\n\n");
}


/*===========================================================================
FUNCTION: PRINT_XML_DOC_DIN_ServiceDiscoveryReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_DIN_ServiceDiscoveryReq(struct dinEXIDocument *exi_doc_DIN)
{
    int i = 0;
    int leng = 0;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ServiceDiscoveryReq ⨀⨀⨀⨀⨀⬇\n");

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_din_Header(exi_doc_DIN);

    //[BODY(1/2)] Service Scope
    leng = exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq.ServiceScope.charactersLen;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t ServiceScope (%d Bytes, optional) = ", leng);
    for (i = 0; i <leng ; i++)
    {
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq.ServiceScope.characters[i]);
    }

    //[BODY(2/2)] Service Category
    int cat = 0;
    cat = exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq.ServiceCategory;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t ServiceCategory = %d ", cat);
    switch (cat)
    {
        case dinserviceCategoryType_EVCharging:             //0
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(EVCharging)");
            break;
        }
        case dinserviceCategoryType_Internet:               //1
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Internet: not supported)");
            break;
        }
        case dinserviceCategoryType_ContractCertificate:    //2
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ContractCertificate: not supported)");
            break;
        }
        case dinserviceCategoryType_OtherCustom:            //3
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(OtherCustom: not supported)");
            break;
        }
        default:
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([ERROR] Unexpected Service Category: %d)", cat);
            break;
        }

    }
    //DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t([0]EVCharging, [1]Internet, [2]ContractCertificate, [3]OtherCustom)\n");
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ServiceDiscoveryReq ⨂⨂⨂⨂⨂⬆\n\n");
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_ISO1_ServiceDiscoveryReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_ISO1_ServiceDiscoveryReq(struct iso1EXIDocument *exi_doc_ISO1)
{
    int i = 0;
    int leng = 0;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ServiceDiscoveryReq ⨀⨀⨀⨀⨀⬇\n");

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);

    //[BODY(1/2)] Service Scope
    leng = exi_doc_ISO1->V2G_Message.Body.ServiceDiscoveryReq.ServiceScope.charactersLen;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t ServiceScope (%d Bytes, optional) = ", leng);
    for (i = 0; i <leng ; i++)
    {
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_ISO1->V2G_Message.Body.ServiceDiscoveryReq.ServiceScope.characters[i]);
    }

    //[BODY(2/2)] Service Category
    int cat = 0;
    cat = exi_doc_ISO1->V2G_Message.Body.ServiceDiscoveryReq.ServiceCategory;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t ServiceCategory = %d ", cat);
    switch (cat)
    {
        case iso1serviceCategoryType_EVCharging:             //0
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(EVCharging)");
            break;
        }
        case iso1serviceCategoryType_Internet:               //1
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Internet: not supported)");
            break;
        }
        case iso1serviceCategoryType_ContractCertificate:    //2
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ContractCertificate: not supported)");
            break;
        }
        case iso1serviceCategoryType_OtherCustom:            //3
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(OtherCustom: not supported)");
            break;
        }
        default:
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([ERROR] Unexpected Service Category)");
            break;
        }

    }
    //DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t([0]EVCharging, [1]Internet, [2]ContractCertificate, [3]OtherCustom)\n");
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ServiceDiscoveryReq ⨂⨂⨂⨂⨂⬆\n\n");
}


/*===========================================================================
FUNCTION: PRINT_XML_DOC_DIN_ServiceAndPaymentSelectionReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_DIN_ServiceAndPaymentSelectionReq(struct dinEXIDocument *exi_doc_DIN)
{
    int i = 0;
    int leng = 0;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ServicePaymentSelectionReq ⨀⨀⨀⨀⨀⬇\n");

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_din_Header(exi_doc_DIN);


    //[BODY(1/2)] SelectedPaymentOption
    int opt = 0;
    opt = exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq.SelectedPaymentOption;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tSelectedPaymentOption = %d ", opt);
    switch (opt)
    {
        case dinpaymentOptionType_Contract:         //0
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Contract)");
            break;
        }

        case dinpaymentOptionType_ExternalPayment:  //1
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ExternalPayment)");
            break;
        }
        default:
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([ERROR] Unexpected SelectedPaymentOption)\n");
            break;
        }
    }


    //[BODY(2/2)] SelectedServiceList
    leng = exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq.SelectedServiceList.SelectedService.arrayLen;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tSelectedServiceList (%d items) = \n", leng);
    for (i = 0; i< leng; i++)
    {
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\t\t [%d-th](ServiceID, ParameterSetID, ParameterSetID_isUsed) = {%d, %d, %d}\n",
            (i+1),
            exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq.SelectedServiceList.SelectedService.array[i].ServiceID,
            exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq.SelectedServiceList.SelectedService.array[i].ParameterSetID,
            exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq.SelectedServiceList.SelectedService.array[i].ParameterSetID_isUsed);
    }
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ServicePaymentSelectionReq ⨂⨂⨂⨂⨂⬆\n\n");
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_ISO1_ServiceAndPaymentSelectionReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_ISO1_ServiceAndPaymentSelectionReq(struct iso1EXIDocument *exi_doc_ISO1)
{
    int i = 0;
    int leng = 0;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing PaymentServiceSelectionReq ⨀⨀⨀⨀⨀⬇\n");

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);


    //[BODY(1/2)] SelectedPaymentOption
    int opt = 0;
    opt = exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq.SelectedPaymentOption;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tSelectedPaymentOption = %d ", opt);
    switch (opt)
    {
        case iso1paymentOptionType_Contract:         //0
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Contract)");
            break;
        }

        case iso1paymentOptionType_ExternalPayment:  //1
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ExternalPayment)");
            break;
        }
        default:
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([ERROR] Unexpected SelectedPaymentOption)\n");
            break;
        }
    }


    //[BODY(2/2)] SelectedServiceList
    leng = exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq.SelectedServiceList.SelectedService.arrayLen;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tSelectedServiceList (%d items) = \n", leng);
    for (i = 0; i< leng; i++)
    {
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\t\t [%d-th](ServiceID, ParameterSetID, ParameterSetID_isUsed) = {%d, %d, %d}\n",
            (i+1),
            exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq.SelectedServiceList.SelectedService.array[i].ServiceID,
            exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq.SelectedServiceList.SelectedService.array[i].ParameterSetID,
            exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq.SelectedServiceList.SelectedService.array[i].ParameterSetID_isUsed);
    }
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing PaymentServiceSelectionReq ⨂⨂⨂⨂⨂⬆\n\n");
}


/*===========================================================================
FUNCTION: PRINT_XML_DOC_DIN_ContractAuthenticationReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_DIN_ContractAuthenticationReq(struct dinEXIDocument *exi_doc_DIN)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ContractAuthenticationReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_din_Header(exi_doc_DIN);


    //[BODY(1/2)] Id
    //[Joseph, To-Do, not full implemented, yet]
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t Id_isUsed = %d ",
        exi_doc_DIN->V2G_Message.Body.ContractAuthenticationReq.Id_isUsed);


    //[BODY(2/2)] GenChallenge
    //[Joseph, To-Do, not full implemented, yet]
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t GenChallenge_isUsed = %d ",
        exi_doc_DIN->V2G_Message.Body.ContractAuthenticationReq.GenChallenge_isUsed);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ContractAuthenticationReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_ISO1_AuthorizationReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_ISO1_AuthorizationReq(struct iso1EXIDocument *exi_doc_ISO1)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing AuthorizationReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);


    //[BODY(1/2)] Id
    //[Joseph, To-Do, not full implemented, yet]
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t Id_isUsed = %d ",
        exi_doc_ISO1->V2G_Message.Body.AuthorizationReq.Id_isUsed);


    //[BODY(2/2)] GenChallenge
    //[Joseph, To-Do, not full implemented, yet]
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t GenChallenge_isUsed = %d ",
        exi_doc_ISO1->V2G_Message.Body.AuthorizationReq.GenChallenge_isUsed);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing AuthorizationReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}


/*===========================================================================
FUNCTION: PRINT_XML_DOC_DIN_ChargeParameterDiscoveryReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_DIN_ChargeParameterDiscoveryReq(struct dinEXIDocument *exi_doc_DIN)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ChargeParameterDiscoveryReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_din_Header(exi_doc_DIN);

    //===== [BODY (1/3)] EVRequestedEnergyTransferType =====
    int type = 0;
    type = exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.EVRequestedEnergyTransferType;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVRequestedEnergyTransferType = %d ", type);
    switch (type)
    {
        case dinEVRequestedEnergyTransferType_AC_single_phase_core:    //0,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(AC_single_phase_core)\n");
            break;
        }
    	case dinEVRequestedEnergyTransferType_AC_three_phase_core:     //1,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(AC_three_phase_core)\n");
            break;
        }
    	case dinEVRequestedEnergyTransferType_DC_core:                 //2,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_core)\n");
            break;
        }
    	case dinEVRequestedEnergyTransferType_DC_extended:             //3,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_extended)\n");  //expected
            //[Joseph, To-Do]
            //If this parameter is different from previous message,
            //a warning should be noted.
            break;
        }
    	case dinEVRequestedEnergyTransferType_DC_combo_core:           //4,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_combo_core)\n");
            break;
        }
    	case dinEVRequestedEnergyTransferType_DC_unique:               //5
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_unique)\n");
            break;
        }
    }

    //===== [BODY (2/3)] AC_EVChargeParameter of EVChargeParameter =====
    //ignored, since DIN doesn't support AC.
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t AC_EVChargeParameter_isUsed = %d ",
            exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter_isUsed);

    //===== [BODY (3/3)] DC_EVChargeParameter of EVChargeParameter =====
    int value = 0;
    struct dinPhysicalValueType *obj;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
            exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter_isUsed);

    //DC_EVStatus
    struct dinDC_EVStatusType *status;
    status = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.DC_EVStatus;
    PRINT_dinDC_EVStatusType(status);

    //EVMaximumCurrentLimit
    obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVMaximumCurrentLimit;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumCurrentLimit = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);

    //EVMaximumPowerLimit
    obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVMaximumPowerLimit;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumPowerLimit = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);

    //EVMaximumVoltageLimit
    obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVMaximumVoltageLimit;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumVoltageLimit = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);

    //EVEnergyCapacity
    obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVEnergyCapacity;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVEnergyCapacity = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);

    //EVEnergyRequest
    obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVEnergyRequest;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVEnergyRequest = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);

    //FullSOC
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t FullSOC = %d \% (DEC)",
            exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.FullSOC);

    //BulkSOC
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkSOC = %d \% (DEC)",
            exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.BulkSOC);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ChargeParameterDiscoveryReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_ISO1_ChargeParameterDiscoveryReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_ISO1_ChargeParameterDiscoveryReq(struct iso1EXIDocument *exi_doc_ISO1)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ChargeParameterDiscoveryReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);

    //===== [BODY (1/3)] RequestedEnergyTransferMode =====
    int type = 0;
    type = exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.RequestedEnergyTransferMode;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t RequestedEnergyTransferMode = %d ", type);
    switch (type)
    {
        case iso1EnergyTransferModeType_AC_single_phase_core:    //0,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(AC_single_phase_core)\n");
            break;
        }
    	case iso1EnergyTransferModeType_AC_three_phase_core:     //1,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(AC_three_phase_core)\n");
            break;
        }
    	case iso1EnergyTransferModeType_DC_core:                 //2,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_core)\n");
            break;
        }
    	case iso1EnergyTransferModeType_DC_extended:             //3,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_extended)\n");  //expected
            //[Joseph, To-Do]
            //If this parameter is different from previous message,
            //a warning should be noted.
            break;
        }
    	case iso1EnergyTransferModeType_DC_combo_core:           //4,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_combo_core)\n");
            break;
        }
    	case iso1EnergyTransferModeType_DC_unique:               //5
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_unique)\n");
            break;
        }
    }

    //===== [BODY (2/3)] AC_EVChargeParameter of EVChargeParameter =====
    //ignored, since our ISO1 doesn't support AC.
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t AC_EVChargeParameter_isUsed = %d ",
            exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter_isUsed);

    //===== [BODY (3/3)] DC_EVChargeParameter of EVChargeParameter =====
    int value = 0;
    struct iso1PhysicalValueType *obj;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
            exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter_isUsed);

    //DC_EVStatus
    struct iso1DC_EVStatusType *status;
    status = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.DC_EVStatus;
    PRINT_iso1DC_EVStatusType(status);

    //EVMaximumCurrentLimit
    obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVMaximumCurrentLimit;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumCurrentLimit = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);

    //EVMaximumPowerLimit
    obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVMaximumPowerLimit;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumPowerLimit = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);

    //EVMaximumVoltageLimit
    obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVMaximumVoltageLimit;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumVoltageLimit = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);

    //EVEnergyCapacity
    obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVEnergyCapacity;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVEnergyCapacity = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);

    //EVEnergyRequest
    obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVEnergyRequest;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVEnergyRequest = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);

    //FullSOC
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t FullSOC = %d \% (DEC)",
            exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.FullSOC);

    //BulkSOC
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkSOC = %d \% (DEC)",
            exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.BulkSOC);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ChargeParameterDiscoveryReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}


/*===========================================================================
FUNCTION: PRINT_XML_DOC_DIN_CableCheckReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_DIN_CableCheckReq(struct dinEXIDocument *exi_doc_DIN)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing CableCheckReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_din_Header(exi_doc_DIN);

    //===== [BODY (1/1)] DC_EVStatus =====
    struct dinDC_EVStatusType *status;
    status = &exi_doc_DIN->V2G_Message.Body.CableCheckReq.DC_EVStatus;
    PRINT_dinDC_EVStatusType(status);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing CableCheckReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_ISO1_CableCheckReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_ISO1_CableCheckReq(struct iso1EXIDocument *exi_doc_ISO1)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing CableCheckReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);

    //===== [BODY (1/1)] DC_EVStatus =====
    struct iso1DC_EVStatusType *status;
    status = &exi_doc_ISO1->V2G_Message.Body.CableCheckReq.DC_EVStatus;
    PRINT_iso1DC_EVStatusType(status);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing CableCheckReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_DIN_PreChargeReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_DIN_PreChargeReq(struct dinEXIDocument *exi_doc_DIN)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing PreChargeReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_din_Header(exi_doc_DIN);

    //===== [BODY (1/3)] DC_EVStatus =====
    struct dinDC_EVStatusType *status;
    status = &exi_doc_DIN->V2G_Message.Body.PreChargeReq.DC_EVStatus;
    PRINT_dinDC_EVStatusType(status);

    //===== [BODY (2/3)] EVTargetVoltage =====
    int value = 0;
    struct dinPhysicalValueType *obj;
    obj = &exi_doc_DIN->V2G_Message.Body.PreChargeReq.EVTargetVoltage;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetVoltage = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);

    //===== [BODY (3/3)] EVTargetCurrent =====
    obj = &exi_doc_DIN->V2G_Message.Body.PreChargeReq.EVTargetCurrent;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetCurrent = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing PreChargeReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}


/*===========================================================================
FUNCTION: PRINT_XML_DOC_ISO1_PreChargeReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_ISO1_PreChargeReq(struct iso1EXIDocument *exi_doc_ISO1)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing PreChargeReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);

    //===== [BODY (1/3)] DC_EVStatus =====
    struct iso1DC_EVStatusType *status;
    status = &exi_doc_ISO1->V2G_Message.Body.PreChargeReq.DC_EVStatus;
    PRINT_iso1DC_EVStatusType(status);

    //===== [BODY (2/3)] EVTargetVoltage =====
    int value = 0;
    struct iso1PhysicalValueType *obj;
    obj = &exi_doc_ISO1->V2G_Message.Body.PreChargeReq.EVTargetVoltage;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetVoltage = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);

    //===== [BODY (3/3)] EVTargetCurrent =====
    obj = &exi_doc_ISO1->V2G_Message.Body.PreChargeReq.EVTargetCurrent;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetCurrent = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing PreChargeReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}


/*===========================================================================
FUNCTION: PRINT_XML_DOC_DIN_PowerDeliveryReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_DIN_PowerDeliveryReq(struct dinEXIDocument *exi_doc_DIN)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing PowerDeliveryReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_din_Header(exi_doc_DIN);


    //===== [BODY (1/3)] ReadyToChargeState =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ReadyToChargeState = %d (DEC)",
            exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.ReadyToChargeState);


    //===== [BODY (2/3)] ChargingProfile =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargingProfile_isUsed = %d (DEC)",
            exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.ChargingProfile_isUsed);


    //===== [BODY (3/3)] DC_EVPowerDeliveryParameter =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVPowerDeliveryParameter_isUsed = %d (DEC)",
            exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter_isUsed);

    //DC_EVStatus
    struct dinDC_EVStatusType *status;
    status = &exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.DC_EVStatus;
    PRINT_dinDC_EVStatusType(status);

    //BulkChargingComplete
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete = %d (DEC)",
            exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.BulkChargingComplete);

    //BulkChargingComplete_isUsed
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete_isUsed = %d (DEC)",
            exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.BulkChargingComplete_isUsed);

    //ChargingComplete
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargingComplete = %d (DEC)",
            exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.ChargingComplete);


    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing PowerDeliveryReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_ISO1_PowerDeliveryReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_ISO1_PowerDeliveryReq(struct iso1EXIDocument *exi_doc_ISO1)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing PowerDeliveryReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);


    //===== [BODY (1/3)] ChargeProgress =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargeProgress = %d (DEC, 0:start, 1:stop, 2:renegotiate)",
            exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.ChargeProgress);
	//iso1chargeProgressType_Start = 0,
	//iso1chargeProgressType_Stop = 1,
	//iso1chargeProgressType_Renegotiate = 2


    //===== [BODY (2/3)] ChargingProfile =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargingProfile_isUsed = %d (DEC)",
            exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.ChargingProfile_isUsed);


    //===== [BODY (3/3)] DC_EVPowerDeliveryParameter =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVPowerDeliveryParameter_isUsed = %d (DEC)",
            exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter_isUsed);

    //DC_EVStatus
    struct iso1DC_EVStatusType *status;
    status = &exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.DC_EVStatus;
    PRINT_iso1DC_EVStatusType(status);

    //BulkChargingComplete
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete = %d (DEC)",
            exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.BulkChargingComplete);

    //BulkChargingComplete_isUsed
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete_isUsed = %d (DEC)",
            exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.BulkChargingComplete_isUsed);

    //ChargingComplete
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargingComplete = %d (DEC)",
            exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.ChargingComplete);


    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing PowerDeliveryReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}


/*===========================================================================
FUNCTION: PRINT_XML_DOC_DIN_CurrentDemandReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_DIN_CurrentDemandReq(struct dinEXIDocument *exi_doc_DIN)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing CurrentDemandReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_din_Header(exi_doc_DIN);

    //===== [BODY (1/10)] DC_EVStatus =====
    struct dinDC_EVStatusType *status;
    status = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.DC_EVStatus;
    PRINT_dinDC_EVStatusType(status);


    //===== [BODY (2/10)] EVTargetCurrent =====
    int value = 0;
    struct dinPhysicalValueType *obj;
    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVTargetCurrent;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetCurrent = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);


    //===== [BODY (3/10)] EVMaximumVoltageLimit =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumVoltageLimit_isUsed);

    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumVoltageLimit;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumVoltageLimit = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);



    //===== [BODY (4/10)] EVMaximumCurrentLimit =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumCurrentLimit_isUsed);

    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumCurrentLimit;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumCurrentLimit = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);


    //===== [BODY (5/10)] EVMaximumPowerLimit =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumPowerLimit_isUsed);

    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumPowerLimit;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumPowerLimit = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);


    //===== [BODY (6/10)] BulkChargingComplete =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete_isUsed = %d \n",
            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.BulkChargingComplete_isUsed);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete = %d \n",
            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.BulkChargingComplete);


    //===== [BODY (7/10)] ChargingComplete =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargingComplete = %d \n",
            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.ChargingComplete);


    //===== [BODY (8/10)] RemainingTimeToFullSoC =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.RemainingTimeToFullSoC_isUsed);

    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.RemainingTimeToFullSoC;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t RemainingTimeToFullSoC = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);


    //===== [BODY (9/10)] RemainingTimeToBulkSoC =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.RemainingTimeToBulkSoC_isUsed);

    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.RemainingTimeToBulkSoC;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t RemainingTimeToBulkSoC = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);


    //===== [BODY (10/10)] EVTargetVoltage =====
    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVTargetVoltage;
    value = GetValue_dinPhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetVoltage = %d (DEC) ", value);
    PRINT_dinPhysicalValueType_UNIT(obj);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing CurrentDemandReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_ISO1_CurrentDemandReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_ISO1_CurrentDemandReq(struct iso1EXIDocument *exi_doc_ISO1)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing CurrentDemandReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);

    //===== [BODY (1/10)] DC_EVStatus =====
    struct iso1DC_EVStatusType *status;
    status = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.DC_EVStatus;
    PRINT_iso1DC_EVStatusType(status);


    //===== [BODY (2/10)] EVTargetCurrent =====
    int value = 0;
    struct iso1PhysicalValueType *obj;
    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVTargetCurrent;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetCurrent = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);


    //===== [BODY (3/10)] EVMaximumVoltageLimit =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumVoltageLimit_isUsed);

    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumVoltageLimit;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumVoltageLimit = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);



    //===== [BODY (4/10)] EVMaximumCurrentLimit =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumCurrentLimit_isUsed);

    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumCurrentLimit;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumCurrentLimit = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);


    //===== [BODY (5/10)] EVMaximumPowerLimit =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumPowerLimit_isUsed);

    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumPowerLimit;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumPowerLimit = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);


    //===== [BODY (6/10)] BulkChargingComplete =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete_isUsed = %d \n",
            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.BulkChargingComplete_isUsed);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete = %d \n",
            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.BulkChargingComplete);


    //===== [BODY (7/10)] ChargingComplete =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargingComplete = %d \n",
            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.ChargingComplete);


    //===== [BODY (8/10)] RemainingTimeToFullSoC =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToFullSoC_isUsed);

    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToFullSoC;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t RemainingTimeToFullSoC = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);


    //===== [BODY (9/10)] RemainingTimeToBulkSoC =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToBulkSoC_isUsed);

    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToBulkSoC;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t RemainingTimeToBulkSoC = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);


    //===== [BODY (10/10)] EVTargetVoltage =====
    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVTargetVoltage;
    value = GetValue_iso1PhysicalValueType(obj);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetVoltage = %d (DEC) ", value);
    PRINT_iso1PhysicalValueType_UNIT(obj);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing CurrentDemandReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_ISO1_ChargingStatusReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_ISO1_ChargingStatusReq(struct iso1EXIDocument *exi_doc_ISO1)
{
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ChargingStatusReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);

    //===== [BODY (0/0)] =====
	//ISO1: no content
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t no content (ISO1)");

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ChargingStatusReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_DIN_WeldingDetectionReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_DIN_WeldingDetectionReq(struct dinEXIDocument *exi_doc_DIN)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing WeldingDetectionReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_din_Header(exi_doc_DIN);

    //===== [BODY (1/3)] DC_EVStatus =====
    struct dinDC_EVStatusType *status;
    status = &exi_doc_DIN->V2G_Message.Body.WeldingDetectionReq.DC_EVStatus;
    PRINT_dinDC_EVStatusType(status);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing WeldingDetectionReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_ISO1_WeldingDetectionReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_ISO1_WeldingDetectionReq(struct iso1EXIDocument *exi_doc_ISO1)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing WeldingDetectionReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);

    //===== [BODY (1/3)] DC_EVStatus =====
    struct iso1DC_EVStatusType *status;
    status = &exi_doc_ISO1->V2G_Message.Body.WeldingDetectionReq.DC_EVStatus;
    PRINT_iso1DC_EVStatusType(status);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing WeldingDetectionReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_DIN_SessionStopReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_DIN_SessionStopReq(struct dinEXIDocument *exi_doc_DIN)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing SessionStopReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_din_Header(exi_doc_DIN);

    //===== [BODY (0/0)] noContent =====


    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing SessionStopReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}

/*===========================================================================
FUNCTION: PRINT_XML_DOC_ISO1_SessionStopReq
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_XML_DOC_ISO1_SessionStopReq(struct iso1EXIDocument *exi_doc_ISO1)
{
    int i = 0;
    static int cnt = 0;
    cnt++;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing SessionStopReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);

    //===== [BODY (0/0)] noContent =====


    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing SessionStopReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
}


/*===========================================================================
FUNCTION: PRINT_V2GTP_STREAM
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_V2GTP_STREAM(bitstream_t *stream)
{
	#if (DEBUG_PRINTF_EXI_ENGINE_DETAIL_SHOW == ENABLE)
	int i = 0;


	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n ----- Got a new V2GTP Message -----\n\n");
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t SIZE: %d (Bytes, DEC)\n", (int)stream->size);
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t HEADER (HEX): ");
	for (i = 0; i < stream->size; i++)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", stream->data[i]);
		if (i == (V2GTP_HEADER_LENGTH - 1))
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t EXI (HEX): ");
		}
	}
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n");
	#endif
}


/*===========================================================================
FUNCTION: API_V2GMSG_EXI_Decoder_AppProtocol
DESCRIPTION:
PRE-CONDITION:
        1. #define EXI_STREAM    BYTE_ARRAY

INPUT:
        1. V2GTP_msg
        2. V2GTP_msg_length

OUTPUT:
        1. ccs_handshake       	//Share Memory
        2. V2gFlowStatus   //Status Flag

GLOBAL VARIABLES:
		1. iStream
		2. exiDoc
=============================================================================*/
int API_V2GMSG_EXI_Decoder_AppProtocol(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct appHandEXIDocument *exiDoc_handshake)
{
	int errn = 0;
	size_t pos = 0;
	uint32_t payloadLengthDec = 0;

	//Initialize iStream
	iStream.size = V2GTP_msg_length;	//V2GTP_MSG_RX_BUFFER_SIZE;	//64*1024 = 65,536
	iStream.pos = &pos;
	iStream.data = V2GTP_msg;

	//Initialize exiDoc
	init_appHandEXIDocument(exiDoc_handshake);

	//Print the original EXI message
	PRINT_V2GTP_STREAM(&iStream);

	//STEP 1: Parsing Header
	errn = read_v2gtpHeader(iStream.data, &payloadLengthDec);

	//TC_SECC_VTB_V2GTPSessionSetup_004
	if (payloadLengthDec == 0)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_AppProtocol]payloadLengthDec = 0\n");
		errn = -1;
	}

	if (errn == 0)
	{
		//STEP 2: Parsing Payload EXI Message
		*iStream.pos = V2GTP_HEADER_LENGTH;
		errn = decode_appHandExiDocument(&iStream, exiDoc_handshake);
		if(errn == 0)
		{
			//Print the decoded XML Document
			PRINT_XML_DOC_supportedAppProtocolReq(exiDoc_handshake);

			//errn = SupportedAppProtocolRequest;	//17 (define.h)
		}
		else
		{
			/* an error occured */
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_AppProtocol]decode_appHandExiDocument()\n");
			errn = -1;
		}
	}

	return errn;
}


int API_V2GMSG_EXI_Encoder_AppProtocol(struct appHandEXIDocument *exi_doc, bitstream_t *exi_packet)
{
	int i = 0;
	int errn = 0;
	size_t pos = 0;
	exi_packet->pos = &pos;
	//*exi_packet->pos = 0;
	exi_packet->size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
	exi_packet->data = V2GTP_Tx_buf;

	*exi_packet->pos = V2GTP_HEADER_LENGTH;
	if( (errn = encode_appHandExiDocument(exi_packet, exi_doc)) == 0)
	{
		errn = write_v2gtpHeader(exi_packet->data, (*exi_packet->pos) - V2GTP_HEADER_LENGTH, V2GTP_EXI_TYPE);
		//*exi_packet.pos = total length of the encoded V2GMSG.
		//V2GTP_HEADER_LENGTH = 8 Bytes
	}
	exi_packet->size = *exi_packet->pos;	//total length of the encoded V2GMSG.


	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n -----  supportedAppProtocolRes [START] -----\n\n");
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t SIZE: %d (Bytes, DEC)\n", (int)exi_packet->size);
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t HEADER (HEX): ");
	for (i = 0; i < (int)exi_packet->size; i++)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_packet->data[i]);
		if (i == (V2GTP_HEADER_LENGTH - 1)) DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t EXI (HEX): ");
	}
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n -----  supportedAppProtocolRes [END] -----\n\n");


	return errn;
}


/*===========================================================================
FUNCTION: API_V2GMSG_EXI_Decoder_DIN
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
int API_V2GMSG_EXI_Decoder_DIN(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct dinEXIDocument *exi_doc_DIN)
{
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("API_V2GMSG_EXI_Decoder_DIN(): Entered!\n");

	int errn = 0;
	size_t pos = 0;
	uint32_t payloadLengthDec = 0;

	//Initialize iStream
	iStream.size = V2GTP_msg_length;	//V2GTP_MSG_RX_BUFFER_SIZE;	//64*1024 = 65,536
	iStream.pos = &pos;
	iStream.data = V2GTP_msg;

	iStream.buffer = 0;
	iStream.capacity = 0;

	//Print the original EXI message
	PRINT_V2GTP_STREAM(&iStream);

	//STEP 1: Parsing Header
	errn = read_v2gtpHeader(iStream.data, &payloadLengthDec);

	//TC_SECC_VTB_V2GTPSessionSetup_004
	if (payloadLengthDec == 0)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][Error][API_V2GMSG_EXI_Decoder_DIN]payloadLengthDec = 0\n");
		errn = -1;
	}

	if (errn == 0)
	{
		//STEP 2: Parsing Payload EXI Message
		*iStream.pos = V2GTP_HEADER_LENGTH;
		errn = decode_dinExiDocument(&iStream, exi_doc_DIN);
		//The "eventcode" inside this function could present which kind of message it is.

		if (errn == 0)
		{
			// successfully received and parsed.
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][API_V2GMSG_EXI_Decoder_DIN] decode_dinExiDocument: %d (DEC) => OK!\n", errn);
			errn = Check_V2G_Rx_Msg_Name_din(exi_doc_DIN);
			if (errn < 0)
			{
				DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]Check_V2G_Rx_Msg_Name_din: fail\n");
			}
		}
		else
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_DIN] decode_dinExiDocument: %d (DEC)\n", errn);
			errn = -1;
		}
	}
	else
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_DIN] read_v2gtpHeader: %d (DEC)\n", errn);
	}
	return errn;
}

/*===========================================================================
FUNCTION: API_V2GMSG_EXI_Decoder_ISO1
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
int API_V2GMSG_EXI_Decoder_ISO1(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct iso1EXIDocument *exi_doc_ISO1)
{
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("[API_V2GMSG_EXI_Decoder_ISO1] Entered!\n");

	int errn = 0;
	size_t pos = 0;
	uint32_t payloadLengthDec = 0;

	//Initialize iStream
	iStream.size = V2GTP_msg_length;	//V2GTP_MSG_RX_BUFFER_SIZE;	//64*1024 = 65,536
	iStream.pos = &pos;
	iStream.data = V2GTP_msg;

	iStream.buffer = 0;
	iStream.capacity = 0;

	//Print the original EXI message
	PRINT_V2GTP_STREAM(&iStream);

	//STEP 1: Parsing Header
	errn = read_v2gtpHeader(iStream.data, &payloadLengthDec);

	//TC_SECC_VTB_V2GTPSessionSetup_004
	if (payloadLengthDec == 0)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][API_V2GMSG_EXI_Decoder_ISO1]payloadLengthDec = 0");
		errn = -1;
	}

	if (errn == 0)
	{
		//STEP 2: Parsing Payload EXI Message
		*iStream.pos = V2GTP_HEADER_LENGTH;
		errn = decode_iso1ExiDocument(&iStream, exi_doc_ISO1);
		//The "eventcode" inside this function could present which kind of message it is.

		if (errn == 0)
		{
			// successfully received and parsed.
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][API_V2GMSG_EXI_Decoder_ISO1] decode_iso1ExiDocument: %d (DEC) => OK!\n", errn);
			errn = Check_V2G_Rx_Msg_Name_iso1(exi_doc_ISO1);
			if (errn < 0)
			{
				DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]Check_V2G_Rx_Msg_Name_din: fail\n");
			}
		}
		else
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_ISO1] decode_iso1ExiDocument: %d (DEC)\n", errn);
			errn = -1;
		}
	}
	else
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_ISO1] read_v2gtpHeader: %d (DEC)\n", errn);
	}
	return errn;
}

/*===========================================================================
FUNCTION: API_V2GMSG_EXI_Decoder_ISO2
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
int API_V2GMSG_EXI_Decoder_ISO2(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct iso2EXIDocument *exi_doc_ISO2)
{
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("[API_V2GMSG_EXI_Decoder_ISO2] Entered!\n");

	int errn = 0;
	size_t pos = 0;
	uint32_t payloadLengthDec = 0;

	//Initialize iStream
	iStream.size = V2GTP_msg_length;	//V2GTP_MSG_RX_BUFFER_SIZE;	//64*1024 = 65,536
	iStream.pos = &pos;
	iStream.data = V2GTP_msg;

	iStream.buffer = 0;
	iStream.capacity = 0;

	//Print the original EXI message
	PRINT_V2GTP_STREAM(&iStream);

	//STEP 1: Parsing Header
	errn = read_v2gtpHeader(iStream.data, &payloadLengthDec);

	//TC_SECC_VTB_V2GTPSessionSetup_004
	if (payloadLengthDec == 0)
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][API_V2GMSG_EXI_Decoder_ISO2]payloadLengthDec = 0\n");
		errn = -1;
	}

	if (errn == 0)
	{
		//STEP 2: Parsing Payload EXI Message
		*iStream.pos = V2GTP_HEADER_LENGTH;
		errn = decode_iso2ExiDocument(&iStream, exi_doc_ISO2);
		//The "eventcode" inside this function could present which kind of message it is.

		if (errn == 0)
		{
			// successfully received and parsed.
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][API_V2GMSG_EXI_Decoder_ISO2] decode_iso2ExiDocument: %d (DEC) => OK!\n", errn);
			errn = Check_V2G_Rx_Msg_Name_iso2(exi_doc_ISO2);
			if (errn < 0)
			{
				DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]Check_V2G_Rx_Msg_Name_din: fail\n");
			}
		}
		else
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_ISO2] decode_iso2ExiDocument: %d (DEC)\n", errn);
		}
	}
	else
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_ISO2] read_v2gtpHeader: %d (DEC)\n", errn);
	}
	return errn;
}


/*===========================================================================
FUNCTION: PRINT_dinPhysicalValueType_UNIT
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_dinPhysicalValueType_UNIT(struct dinPhysicalValueType *obj)
{
    if (obj->Unit_isUsed == TRUE)
    {
        switch (obj->Unit)
        {
            case dinunitSymbolType_h:      // = 0,
            {
                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: h)");
                break;
            }
        	case dinunitSymbolType_m:      // = 1,
            {
                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: m)");
                break;
            }
        	case dinunitSymbolType_s:      // = 2,
            {
                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: s)");
                break;
            }
        	case dinunitSymbolType_A:      // = 3,
            {
                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: A)");
                break;
            }
        	case dinunitSymbolType_Ah:     // = 4,
            {
                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: Ah)");
                break;
            }
        	case dinunitSymbolType_V:      // = 5,
            {
                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: V)");
                break;
            }
        	case dinunitSymbolType_VA:     // = 6,
            {
                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: VA)");
                break;
            }
        	case dinunitSymbolType_W:      // = 7,
            {
                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: W)");
                break;
            }
        	case dinunitSymbolType_W_s:    // = 8,
            {
                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: W_s)");
                break;
            }
        	case dinunitSymbolType_Wh:     // = 9
            {
                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: Wh)");
                break;
            }
            default:
            {
                DEBUG_PRINTF_EXI_ENGINE_DETAIL("([WARNING] unit: unexpected dinPhysicalValueType unit)");
                break;
            }
        }
    }
    else
    {
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: null)");
    }
}

/*===========================================================================
FUNCTION: PRINT_iso1PhysicalValueType_UNIT
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_iso1PhysicalValueType_UNIT(struct iso1PhysicalValueType *obj)
{
	switch (obj->Unit)
	{
		case iso1unitSymbolType_h:      // = 0,
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: h)");
			break;
		}
		case iso1unitSymbolType_m:      // = 1,
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: m)");
			break;
		}
		case iso1unitSymbolType_s:      // = 2,
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: s)");
			break;
		}
		case iso1unitSymbolType_A:      // = 3,
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: A)");
			break;
		}
		case iso1unitSymbolType_V:      // = 4,
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: V)");
			break;
		}
		case iso1unitSymbolType_W:      // = 5,
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: W)");
			break;
		}
		case iso1unitSymbolType_Wh:     // = 6
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: Wh)");
			break;
		}
		default:
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("([WARNING] unit: unexpected iso1PhysicalValueType unit)");
			break;
		}
	}
}

/*===========================================================================
FUNCTION: GetValue_dinPhysicalValueType
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
int GetValue_dinPhysicalValueType(struct dinPhysicalValueType *obj)
{
    int result;
    result = (obj->Value) * pow(10, obj->Multiplier);
    return result;
}

/*===========================================================================
FUNCTION: GetValue_iso1PhysicalValueType
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
int GetValue_iso1PhysicalValueType(struct iso1PhysicalValueType *obj)
{
    int result;
    result = (obj->Value) * pow(10, obj->Multiplier);
    return result;
}

/*===========================================================================
FUNCTION: PRINT_dinDC_EVErrorCodeType
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_dinDC_EVErrorCodeType(struct dinDC_EVStatusType *status)
{
    switch (status->EVErrorCode)
    {
        case dinDC_EVErrorCodeType_NO_ERROR:                           // = 0,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(NO_ERROR)");
            break;
        }
    	case dinDC_EVErrorCodeType_FAILED_RESSTemperatureInhibit:      // = 1,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_RESSTemperatureInhibit)");
            break;
        }
    	case dinDC_EVErrorCodeType_FAILED_EVShiftPosition:             // = 2,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_EVShiftPosition)");
            break;
        }
    	case dinDC_EVErrorCodeType_FAILED_ChargerConnectorLockFault:   // = 3,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ChargerConnectorLockFault)");
            break;
        }
    	case dinDC_EVErrorCodeType_FAILED_EVRESSMalfunction:           // = 4,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_EVRESSMalfunction)");
            break;
        }
    	case dinDC_EVErrorCodeType_FAILED_ChargingCurrentdifferential: // = 5,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingCurrentdifferential)");
            break;
        }
    	case dinDC_EVErrorCodeType_FAILED_ChargingVoltageOutOfRange:   // = 6,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingVoltageOutOfRange)");
            break;
        }
    	case dinDC_EVErrorCodeType_Reserved_A:                         // = 7,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_A)");
            break;
        }
    	case dinDC_EVErrorCodeType_Reserved_B:                         // = 8,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_B)");
            break;
        }
    	case dinDC_EVErrorCodeType_Reserved_C:                         // = 9,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_C)");
            break;
        }
    	case dinDC_EVErrorCodeType_FAILED_ChargingSystemIncompatibility:// = 10,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingSystemIncompatibility)");
            break;
        }
    	case dinDC_EVErrorCodeType_NoData:                             // = 11
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(NoData)");
            break;
        }
        default:
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([WARNING] Unexpected din EVErrorCode)");
            break;
        }
    }
}

/*===========================================================================
FUNCTION: PRINT_iso1DC_EVErrorCodeType
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_iso1DC_EVErrorCodeType(struct iso1DC_EVStatusType *status)
{
    switch (status->EVErrorCode)
    {
        case iso1DC_EVErrorCodeType_NO_ERROR:                           // = 0,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(NO_ERROR)");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_RESSTemperatureInhibit:      // = 1,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_RESSTemperatureInhibit)");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_EVShiftPosition:             // = 2,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_EVShiftPosition)");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_ChargerConnectorLockFault:   // = 3,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ChargerConnectorLockFault)");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_EVRESSMalfunction:           // = 4,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_EVRESSMalfunction)");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_ChargingCurrentdifferential: // = 5,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingCurrentdifferential)");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_ChargingVoltageOutOfRange:   // = 6,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingVoltageOutOfRange)");
            break;
        }
    	case iso1DC_EVErrorCodeType_Reserved_A:                         // = 7,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_A)");
            break;
        }
    	case iso1DC_EVErrorCodeType_Reserved_B:                         // = 8,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_B)");
            break;
        }
    	case iso1DC_EVErrorCodeType_Reserved_C:                         // = 9,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_C)");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_ChargingSystemIncompatibility:// = 10,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingSystemIncompatibility)");
            break;
        }
    	case iso1DC_EVErrorCodeType_NoData:                             // = 11
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(NoData)");
            break;
        }
        default:
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([WARNING] Unexpected iso1 EVErrorCode)");
            break;
        }
    }
}


/*===========================================================================
FUNCTION: PRINT_dinDC_EVStatusType
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_dinDC_EVStatusType(struct dinDC_EVStatusType *status)
{
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVStatus:");
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVReady = %d (DEC) ", status->EVReady);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVErrorCode = %d (DEC) ", status->EVErrorCode);
    PRINT_dinDC_EVErrorCodeType(status);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVRESSSOC = %d \%(DEC) \n", status->EVRESSSOC);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVCabinConditioning = %d (DEC) ", status->EVCabinConditioning);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVCabinConditioning_isUsed = %d (DEC) ", status->EVCabinConditioning_isUsed);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVRESSConditioning = %d (DEC) ", status->EVRESSConditioning);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVRESSConditioning_isUsed = %d (DEC) \n", status->EVRESSConditioning_isUsed);
}

/*===========================================================================
FUNCTION: PRINT_iso1DC_EVStatusType
DESCRIPTION:
PRE-CONDITION:
INPUT:
OUTPUT:
GLOBAL VARIABLES:
=============================================================================*/
void PRINT_iso1DC_EVStatusType(struct iso1DC_EVStatusType *status)
{
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVStatus:");
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVReady = %d (DEC) ", status->EVReady);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVErrorCode = %d (DEC) ", status->EVErrorCode);
    PRINT_iso1DC_EVErrorCodeType(status);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVRESSSOC = %d \%(DEC) \n", status->EVRESSSOC);
}