csu3_am335x/EVSE/Projects/AW-CCS/Apps/CCS/v2g/api/api.c

/*===========================================================================
                    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 "Module_CCS.h"
//#include "../../CsuComm.h"
#include "define_ccs.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)



/**
 *
 * @param fmt
 * @return
 */
int StoreLogV2GMsg(const char *fmt, ...)
{
	char Buf[4096+256];
	char buffer[4096];
	time_t CurrentTime;
	struct tm *tm;
	struct timeval tv;
	va_list args;

	va_start(args, fmt);
	int rc = vsnprintf(buffer, sizeof(buffer), fmt, args);
	va_end(args);

	memset(Buf,0,sizeof(Buf));
	CurrentTime = time(NULL);
	tm=localtime(&CurrentTime);
	gettimeofday(&tv, NULL); // get microseconds, 10^-6

	sprintf(Buf,"echo -n \"[%04d.%02d.%02d %02d:%02d:%02d.%03ld]%s\" >>  /Storage/SystemLog/[%04d.%02d]CCS_V2gLog",
				tm->tm_year+1900,tm->tm_mon+1,tm->tm_mday,tm->tm_hour,tm->tm_min,tm->tm_sec,(tv.tv_usec/1000),
				buffer,
				tm->tm_year+1900,tm->tm_mon+1);


	system((const char*)Buf);
	return rc;
}

/*===========================================================================
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;
	unsigned char buffer[1024]={0};

	for(i = 0; i < len; i++)
	{
		sprintf((char*)buffer, "%s%c ", buffer, (char)string[i]);
	}

	DEBUG_PRINTF_EXI_ENGINE_DETAIL("%s\n", buffer);
}

/*===========================================================================
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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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("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;
            out->Multiplier = 1;
            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;
            out->Multiplier = 1;
            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
    }

    return 0;
}

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

    return 0;
}

/*===========================================================================
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((char*)in->MeterID)<iso1MeterInfoType_MeterID_CHARACTERS_SIZE ? strlen((char*)in->MeterID) : iso1MeterInfoType_MeterID_CHARACTERS_SIZE);
	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 = 1u;
	out->SigMeterReading.bytesLen = (strlen((char*)in->SigMeterReading)<iso1MeterInfoType_SigMeterReading_BYTES_SIZE ? strlen((char*)in->SigMeterReading) : iso1MeterInfoType_SigMeterReading_BYTES_SIZE);
	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;
}



/*===========================================================================
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 =====
	if(((iso1EnergyTransferModeType)shm_msg->RequestedEnergyTransferMode != iso1EnergyTransferModeType_AC_single_phase_core) &&
	   ((iso1EnergyTransferModeType)shm_msg->RequestedEnergyTransferMode != iso1EnergyTransferModeType_AC_three_phase_core))
	{
	    //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;
	}
	else
	{
		shm_msg->AC_EVChargeParameter.EAmount.Multiplier = (int)exi->AC_EVChargeParameter.EAmount.Multiplier;
		shm_msg->AC_EVChargeParameter.EAmount.Unit = Wh_ISO15118_2014;
		shm_msg->AC_EVChargeParameter.EAmount.Value = (short) exi->AC_EVChargeParameter.EAmount.Value;

		shm_msg->AC_EVChargeParameter.EVMaxCurrent.Multiplier = (int)exi->AC_EVChargeParameter.EVMaxCurrent.Multiplier;
		shm_msg->AC_EVChargeParameter.EVMaxCurrent.Unit = A_ISO15118_2014;
		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 = A_ISO15118_2014;
		shm_msg->AC_EVChargeParameter.EVMinCurrent.Value = (short) exi->AC_EVChargeParameter.EVMinCurrent.Value;

		shm_msg->AC_EVChargeParameter.EVMaxVoltage.Multiplier = (int)exi->AC_EVChargeParameter.EVMaxVoltage.Multiplier;
		shm_msg->AC_EVChargeParameter.EVMaxVoltage.Unit = V_ISO15118_2014;
		shm_msg->AC_EVChargeParameter.EVMaxVoltage.Value = (short) exi->AC_EVChargeParameter.EVMaxVoltage.Value;

		shm_msg->AC_EVChargeParameter.DepartureTime = (unsigned int)exi->AC_EVChargeParameter.DepartureTime;
	}
}

/*===========================================================================
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;
    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;
	sys->RemainChargingDuration = 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;

	//[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))
	{
		sys->EvBatterytargetVoltage = (DIN70121PhyValDecode(shm_msg->EVTargetVoltage) + sys->EvBatteryMaxVoltage)/2;
	}
	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;
    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;
	sys->RemainChargingDuration = 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;

	//[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;
	}
	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;
	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 = 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;
    //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 +++*/
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax.Unit = iso1unitSymbolType_W;	//iso1unitSymbolType_W
    in->DC_EVSEChargeParameter.EVSEMaximumPowerLimit.Value*=10;   /*+++ 20200808, vern, lack one more 0 ---*/
    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax.Value =in->DC_EVSEChargeParameter.EVSEMaximumPowerLimit.Value;	//30000 if DW/DM product
    /*--- 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
		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->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)
{
	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 = (strlen((char*)in->EVSEID)<iso1ChargingStatusResType_EVSEID_CHARACTERS_SIZE) ? strlen((char*)in->EVSEID) : iso1ChargingStatusResType_EVSEID_CHARACTERS_SIZE;  //min length: 7, max length:37  bytes(ISO1, AC)
	for (uint8_t 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;
    unsigned char buffer[1024]={0};
    leng = exi_doc_DIN->V2G_Message.Header.SessionID.bytesLen;

    for (i = 0; i <leng ; i++)
    {
        sprintf((char*)buffer, "%s%02x ", buffer, exi_doc_DIN->V2G_Message.Header.SessionID.bytes[i]);
    }
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("SessionID (%d Bytes): %s\n", leng, buffer);
}

/*===========================================================================
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;
    unsigned char buffer[1024]={0};
    leng = exi_doc_ISO1->V2G_Message.Header.SessionID.bytesLen;

    for (i = 0; i <leng ; i++)
    {
        sprintf((char*)buffer, "%s%02x ", buffer, exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[i]);
    }
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("SessionID (%d Bytes): %s\n", leng, buffer);
}

/*===========================================================================
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;
    unsigned char buffer[1024]={0};
    leng = exi_doc_ISO2->V2G_Message.Header.SessionID.bytesLen;

    for (i = 0; i <leng ; i++)
    {
    	sprintf((char*)buffer, "%s%02x ", buffer, exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[i]);
    }
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("SessionID (%d Bytes): %s\n", leng, buffer);
}

/*===========================================================================
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("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("Protocol entry #=%d\n",(i+1));

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

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

		DEBUG_PRINTF_EXI_ENGINE_DETAIL("SchemaID: %d\n", exi_doc->supportedAppProtocolReq.AppProtocol.array[i].SchemaID);
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("Priority: %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;
    unsigned char buffer[1024]={0};
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[START] Parsing SessionSetupReq\n");

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_din_Header(exi_doc_DIN);
    for (i = 0; i < exi_doc_DIN->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen; i++)
    {
        sprintf((char*)buffer, "%s%02X ", buffer, exi_doc_DIN->V2G_Message.Body.SessionSetupReq.EVCCID.bytes[i]);
    }
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVCCID (%d Bytes): %s\n", exi_doc_DIN->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen, buffer);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing SessionSetupReq\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;
    unsigned char buffer[1024]={0};
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[START] Parsing SessionSetupReq\n");

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);
    for (i = 0; i < exi_doc_ISO1->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen; i++)
    {
        sprintf((char*)buffer, "%s%02X ", buffer, exi_doc_ISO1->V2G_Message.Body.SessionSetupReq.EVCCID.bytes[i]);
    }
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVCCID (%d Bytes): %s\n", exi_doc_ISO1->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen, buffer);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing SessionSetupReq\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;
    unsigned char buffer[1024]={0};
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[START] Parsing SessionSetupReq\n");

    //===== [Header] SessionID =====
    PRINT_V2G_MSG_iso2_Header(exi_doc_ISO2);
    for (i = 0; i < exi_doc_ISO2->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen; i++)
    {
        sprintf((char*)buffer, "%s%02X ", buffer, exi_doc_ISO2->V2G_Message.Body.SessionSetupReq.EVCCID.bytes[i]);
    }
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVCCID (%d Bytes): %s\n", exi_doc_ISO2->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen, buffer);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing SessionSetupReq\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;
    unsigned char buffer[1024]={0};
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[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;
    for (i = 0; i <leng ; i++)
    {
        sprintf((char*)buffer, "%s%02X ", buffer, exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq.ServiceScope.characters[i]);
    }
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("ServiceScope (%d Bytes, optional): %s\n", leng, buffer);

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

    }
    //DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t([0]EVCharging, [1]Internet, [2]ContractCertificate, [3]OtherCustom)\n");
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing ServiceDiscoveryReq\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;
    unsigned char buffer[1024]={0};
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[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;
    for (i = 0; i <leng ; i++)
    {
        sprintf((char*)buffer, "%s%02X ", buffer, exi_doc_ISO1->V2G_Message.Body.ServiceDiscoveryReq.ServiceScope.characters[i]);
    }
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("ServiceScope (%d Bytes, optional): %s\n", leng, buffer);

    //[BODY(2/2)] Service Category
    int cat = 0;
    cat = exi_doc_ISO1->V2G_Message.Body.ServiceDiscoveryReq.ServiceCategory;
    switch (cat)
    {
        case iso1serviceCategoryType_EVCharging:             //0
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("ServiceCategory: %d (EVCharging)\n", cat);
            break;
        }
        case iso1serviceCategoryType_Internet:               //1
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("ServiceCategory: %d (Internet: not supported)\n", cat);
            break;
        }
        case iso1serviceCategoryType_ContractCertificate:    //2
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("ServiceCategory: %d (ContractCertificate: not supported)\n", cat);
            break;
        }
        case iso1serviceCategoryType_OtherCustom:            //3
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("ServiceCategory: %d (OtherCustom: not supported)\n", cat);
            break;
        }
        default:
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("ServiceCategory: %d (Unexpected Service Category)\n", cat);
            break;
        }
    }
    //DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t([0]EVCharging, [1]Internet, [2]ContractCertificate, [3]OtherCustom)\n");
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing ServiceDiscoveryReq\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("[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;
    switch (opt)
    {
        case dinpaymentOptionType_Contract:         //0
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("SelectedPaymentOption: %d (Contract)\n", opt);
            break;
        }

        case dinpaymentOptionType_ExternalPayment:  //1
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("SelectedPaymentOption: %d (ExternalPayment)\n", opt);
            break;
        }
        default:
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("SelectedPaymentOption: %d ([Error]Unexpected SelectedPaymentOption)\n", opt);
            break;
        }
    }

    //[BODY(2/2)] SelectedServiceList
    leng = exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq.SelectedServiceList.SelectedService.arrayLen;
    for (i = 0; i< leng; i++)
    {
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("SelectedServiceList (%d items): [%d-th](ServiceID, ParameterSetID, ParameterSetID_isUsed) = {%d, %d, %d}\n",
										leng,
										(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("[END] Parsing ServicePaymentSelectionReq\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("[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;
    switch (opt)
    {
        case iso1paymentOptionType_Contract:         //0
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("SelectedPaymentOption: %d (Contract)\n", opt);
            break;
        }

        case iso1paymentOptionType_ExternalPayment:  //1
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("SelectedPaymentOption: %d (ExternalPayment)\n", opt);
            break;
        }
        default:
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("SelectedPaymentOption: %d (Unexpected SelectedPaymentOption)\n", opt);
            break;
        }
    }


    //[BODY(2/2)] SelectedServiceList
    leng = exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq.SelectedServiceList.SelectedService.arrayLen;
    for (i = 0; i< leng; i++)
    {
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("SelectedServiceList (%d items): [%d-th](ServiceID, ParameterSetID, ParameterSetID_isUsed) = {%d, %d, %d}\n",
										leng,
										(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("[END] Parsing PaymentServiceSelectionReq\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("[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("Id_isUsed: %d\n", 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("GenChallenge_isUsed: %d\n", exi_doc_DIN->V2G_Message.Body.ContractAuthenticationReq.GenChallenge_isUsed);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing ContractAuthenticationReq (%d-th)\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("[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("Id_isUsed: %d\n", 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("GenChallenge_isUsed: %d\n", exi_doc_ISO1->V2G_Message.Body.AuthorizationReq.GenChallenge_isUsed);

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing AuthorizationReq (%d-th)\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("[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;
    switch (type)
    {
        case dinEVRequestedEnergyTransferType_AC_single_phase_core:    //0,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVRequestedEnergyTransferType: %d (AC_single_phase_core)\n", type);
            break;
        }
    	case dinEVRequestedEnergyTransferType_AC_three_phase_core:     //1,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVRequestedEnergyTransferType: %d (AC_three_phase_core)\n", type);
            break;
        }
    	case dinEVRequestedEnergyTransferType_DC_core:                 //2,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVRequestedEnergyTransferType: %d (DC_core)\n", type);
            break;
        }
    	case dinEVRequestedEnergyTransferType_DC_extended:             //3,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVRequestedEnergyTransferType: %d (DC_extended)\n", type);  //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("EVRequestedEnergyTransferType: %d (DC_combo_core)\n", type);
            break;
        }
    	case dinEVRequestedEnergyTransferType_DC_unique:               //5
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVRequestedEnergyTransferType: %d (DC_unique)\n", type);
            break;
        }
    }

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

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

    if(exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter_isUsed)
    {
    	//EVMaxCurrent
		obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter.EVMaxCurrent;
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVMaxCurrent: %d (DEC)\n", GetValue_dinPhysicalValueType(obj));
		PRINT_dinPhysicalValueType_UNIT(obj);

    	//EVMinCurrent
		obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter.EVMinCurrent;
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVMinCurrent: %d (DEC)\n", GetValue_dinPhysicalValueType(obj));
		PRINT_dinPhysicalValueType_UNIT(obj);

    	//EVMaxVoltage
		obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter.EVMaxVoltage;
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVMaxVoltage: %d (DEC)\n", GetValue_dinPhysicalValueType(obj));
		PRINT_dinPhysicalValueType_UNIT(obj);

    	//EAmount
		obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter.EAmount;
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("EAmount: %d (DEC)\n", GetValue_dinPhysicalValueType(obj));
		PRINT_dinPhysicalValueType_UNIT(obj);
    }

    if(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;
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVMaximumCurrentLimit: %d (DEC)\n",  GetValue_dinPhysicalValueType(obj));
        PRINT_dinPhysicalValueType_UNIT(obj);

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

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

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

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

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

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

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing ChargeParameterDiscoveryReq (%d-th)\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("[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;
    switch (type)
    {
        case iso1EnergyTransferModeType_AC_single_phase_core:    //0,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("RequestedEnergyTransferMode: %d (AC_single_phase_core)\n", type);
            break;
        }
    	case iso1EnergyTransferModeType_AC_three_phase_core:     //1,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("RequestedEnergyTransferMode: %d (AC_three_phase_core)\n", type);
            break;
        }
    	case iso1EnergyTransferModeType_DC_core:                 //2,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("RequestedEnergyTransferMode: %d (DC_core)\n", type);
            break;
        }
    	case iso1EnergyTransferModeType_DC_extended:             //3,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("RequestedEnergyTransferMode: %d (DC_extended)\n", type);  //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("RequestedEnergyTransferMode: %d (DC_combo_core)\n", type);
            break;
        }
    	case iso1EnergyTransferModeType_DC_unique:               //5
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("RequestedEnergyTransferMode: %d (DC_unique)\n", type);
            break;
        }
    }

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

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


    if(exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter_isUsed)
    {
    	//EVMaxCurrent
		obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter.EVMaxCurrent;
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVMaxCurrent: %d (DEC)\n", GetValue_iso1PhysicalValueType(obj));
		PRINT_iso1PhysicalValueType_UNIT(obj);

    	//EVMinCurrent
		obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter.EVMinCurrent;
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVMinCurrent: %d (DEC)\n", GetValue_iso1PhysicalValueType(obj));
		PRINT_iso1PhysicalValueType_UNIT(obj);

    	//EVMaxVoltage
		obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter.EVMaxVoltage;
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVMaxVoltage: %d (DEC)\n", GetValue_iso1PhysicalValueType(obj));
		PRINT_iso1PhysicalValueType_UNIT(obj);

    	//EAmount
		obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter.EAmount;
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("EAmount: %d (DEC)\n", GetValue_iso1PhysicalValueType(obj));
		PRINT_iso1PhysicalValueType_UNIT(obj);
    }

    if(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;
        if(exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter_isUsed)PRINT_iso1DC_EVStatusType(status);

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

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

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

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

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

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

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

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing ChargeParameterDiscoveryReq (%d-th)\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("[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("[END] Parsing CableCheckReq (%d-th)\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("[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("[END] Parsing CableCheckReq (%d-th)\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("[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 =====
    struct dinPhysicalValueType *obj;
    obj = &exi_doc_DIN->V2G_Message.Body.PreChargeReq.EVTargetVoltage;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVTargetVoltage: %d (DEC)\n", GetValue_dinPhysicalValueType(obj));
    PRINT_dinPhysicalValueType_UNIT(obj);

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

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing PreChargeReq (%d-th)\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("[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 =====
    struct iso1PhysicalValueType *obj;
    obj = &exi_doc_ISO1->V2G_Message.Body.PreChargeReq.EVTargetVoltage;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVTargetVoltage: %d (DEC)\n", GetValue_iso1PhysicalValueType(obj));
    PRINT_iso1PhysicalValueType_UNIT(obj);

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

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing PreChargeReq (%d-th)\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("[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("ReadyToChargeState: %d (DEC)\n", exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.ReadyToChargeState);


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


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

    if(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("BulkChargingComplete: %d (DEC)\n", exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.BulkChargingComplete);

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

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

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing PowerDeliveryReq (%d-th)\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("[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("ChargeProgress: %d (DEC, 0:start, 1:stop, 2:re-negotiate)\n", 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("ChargingProfile_isUsed = %d (DEC)\n", exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.ChargingProfile_isUsed);


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

    if(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("BulkChargingComplete = %d (DEC)\n", exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.BulkChargingComplete);

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

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


    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing PowerDeliveryReq (%d-th)\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("[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 =====
    struct dinPhysicalValueType *obj;
    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVTargetCurrent;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVTargetCurrent: %d (DEC)\n", GetValue_dinPhysicalValueType(obj));
    PRINT_dinPhysicalValueType_UNIT(obj);


    //===== [BODY (3/10)] EVMaximumVoltageLimit =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("DC_EVChargeParameter_isUsed: %d\n", exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumVoltageLimit_isUsed);
    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumVoltageLimit;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVMaximumVoltageLimit: %d (DEC)\n", GetValue_dinPhysicalValueType(obj));
    PRINT_dinPhysicalValueType_UNIT(obj);



    //===== [BODY (4/10)] EVMaximumCurrentLimit =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("DC_EVChargeParameter_isUsed: %d\n", exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumCurrentLimit_isUsed);
    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumCurrentLimit;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVMaximumCurrentLimit: %d (DEC)\n", GetValue_dinPhysicalValueType(obj));
    PRINT_dinPhysicalValueType_UNIT(obj);


    //===== [BODY (5/10)] EVMaximumPowerLimit =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("DC_EVChargeParameter_isUsed: %d\n", exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumPowerLimit_isUsed);
    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumPowerLimit;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVMaximumPowerLimit: %d (DEC)\n", GetValue_dinPhysicalValueType(obj));
    PRINT_dinPhysicalValueType_UNIT(obj);


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


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


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

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


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

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


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

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing CurrentDemandReq (%d-th)\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("[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 =====
    struct iso1PhysicalValueType *obj;
    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVTargetCurrent;
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVTargetCurrent: %d (DEC)\n", GetValue_iso1PhysicalValueType(obj));
    PRINT_iso1PhysicalValueType_UNIT(obj);

    //===== [BODY (3/10)] EVMaximumVoltageLimit =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("DC_EVChargeParameter_isUsed: %d\n", exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumVoltageLimit_isUsed);
    if(exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumVoltageLimit_isUsed)
    {
    	obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumVoltageLimit;
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVMaximumVoltageLimit: %d (DEC)\n", GetValue_iso1PhysicalValueType(obj));
		PRINT_iso1PhysicalValueType_UNIT(obj);
    }

    //===== [BODY (4/10)] EVMaximumCurrentLimit =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("DC_EVChargeParameter_isUsed: %d\n", exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumCurrentLimit_isUsed);
    if(exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumCurrentLimit_isUsed)
    {
        obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumCurrentLimit;
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVMaximumCurrentLimit: %d (DEC)\n", GetValue_iso1PhysicalValueType(obj));
        PRINT_iso1PhysicalValueType_UNIT(obj);
    }

    //===== [BODY (5/10)] EVMaximumPowerLimit =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("DC_EVChargeParameter_isUsed: %d\n", exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumPowerLimit_isUsed);
    if(exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumPowerLimit_isUsed)
    {
        obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumPowerLimit;
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVMaximumPowerLimit: %d (DEC)\n", GetValue_iso1PhysicalValueType(obj));
        PRINT_iso1PhysicalValueType_UNIT(obj);
    }

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


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


    //===== [BODY (8/10)] RemainingTimeToFullSoC =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("DC_EVChargeParameter_isUsed: %d\n", exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToFullSoC_isUsed);
    if(exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToFullSoC_isUsed)
    {
        obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToFullSoC;
        DEBUG_PRINTF_EXI_ENGINE_DETAIL("RemainingTimeToFullSoC: %d (DEC)\n", GetValue_iso1PhysicalValueType(obj));
        PRINT_iso1PhysicalValueType_UNIT(obj);
    }


    //===== [BODY (9/10)] RemainingTimeToBulkSoC =====
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("DC_EVChargeParameter_isUsed: %d\n", exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToBulkSoC_isUsed);
    if(exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToBulkSoC_isUsed)
    {
    	obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToBulkSoC;
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("RemainingTimeToBulkSoC: %d (DEC)\n", GetValue_iso1PhysicalValueType(obj));
		PRINT_iso1PhysicalValueType_UNIT(obj);
    }

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

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("[END] Parsing CurrentDemandReq (%d-th)\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("[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("[END] Parsing ChargingStatusReq (%d-th)\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("[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("[END] Parsing WeldingDetectionReq (%d-th)\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("[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("[END] Parsing WeldingDetectionReq (%d-th)\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("[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("[END] Parsing SessionStopReq (%d-th)\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("[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("[END] Parsing SessionStopReq (%d-th)\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_SHOW == ENABLE)
	int i = 0;
	unsigned char buffer[1024] = {0};

	DEBUG_PRINTF_EXI_ENGINE_DETAIL("========== Got a new V2GTP Message ==========\n");
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("SIZE: %d (Bytes, DEC)\n", (int)stream->size);
	for (i = 0; i < stream->size; i++)
	{
		sprintf((char*)buffer, "%s%02x ", buffer, stream->data[i]);
	}
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("DATA (HEX): %s\n", buffer);

#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]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]decode_appHandExiDocument() fail\n");
			errn = -1;
		}
	}

	return errn;
}


int API_V2GMSG_EXI_Encoder_AppProtocol(struct appHandEXIDocument *exi_doc, bitstream_t *exi_packet)
{
	unsigned char buffer[1024]={0};
	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("-----  supportedAppProtocolRes [START] -----\n");
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("SIZE: %d (Bytes, DEC)\n", (int)exi_packet->size);
	for (i = 0; i < (int)exi_packet->size; i++)
	{
		sprintf((char*)buffer, "%s%02x ", buffer, exi_packet->data[i]);
	}
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("DATA (HEX): %s\n", buffer);
	DEBUG_PRINTF_EXI_ENGINE_DETAIL("-----  supportedAppProtocolRes [END] -----\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)
{
	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("[Error]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("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]decode_dinExiDocument: %d (DEC)\n", errn);
			errn = -1;
		}
	}
	else
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]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)
{
	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("[Error]payloadLengthDec = 0\n");
		errn = -1;
	}

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

		if (errn == 0)
		{
			// successfully received and parsed.
			//DEBUG_PRINTF_EXI_ENGINE_DETAIL("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]decode_iso1ExiDocument: %d (DEC)\n", errn);
			errn = -1;
		}
	}
	else
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]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)
{
	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("[Error]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("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]decode_iso2ExiDocument: %d (DEC)\n", errn);
		}
	}
	else
	{
		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[Error]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)\n");
			break;
		}
		case iso1unitSymbolType_m:      // = 1,
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: m)\n");
			break;
		}
		case iso1unitSymbolType_s:      // = 2,
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: s)\n");
			break;
		}
		case iso1unitSymbolType_A:      // = 3,
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: A)\n");
			break;
		}
		case iso1unitSymbolType_V:      // = 4,
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: V)\n");
			break;
		}
		case iso1unitSymbolType_W:      // = 5,
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: W)\n");
			break;
		}
		case iso1unitSymbolType_Wh:     // = 6
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: Wh)\n");
			break;
		}
		default:
		{
			DEBUG_PRINTF_EXI_ENGINE_DETAIL("([WARNING] unit: unexpected iso1PhysicalValueType unit)\n");
			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)\n");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_RESSTemperatureInhibit:      // = 1,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_RESSTemperatureInhibit)\n");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_EVShiftPosition:             // = 2,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_EVShiftPosition)\n");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_ChargerConnectorLockFault:   // = 3,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ChargerConnectorLockFault)\n");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_EVRESSMalfunction:           // = 4,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_EVRESSMalfunction)\n");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_ChargingCurrentdifferential: // = 5,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingCurrentdifferential)\n");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_ChargingVoltageOutOfRange:   // = 6,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingVoltageOutOfRange)\n");
            break;
        }
    	case iso1DC_EVErrorCodeType_Reserved_A:                         // = 7,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_A)\n");
            break;
        }
    	case iso1DC_EVErrorCodeType_Reserved_B:                         // = 8,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_B)\n");
            break;
        }
    	case iso1DC_EVErrorCodeType_Reserved_C:                         // = 9,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_C)\n");
            break;
        }
    	case iso1DC_EVErrorCodeType_FAILED_ChargingSystemIncompatibility:// = 10,
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingSystemIncompatibility)\n");
            break;
        }
    	case iso1DC_EVErrorCodeType_NoData:                             // = 11
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(NoData)\n");
            break;
        }
        default:
        {
            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([WARNING] Unexpected iso1 EVErrorCode)\n");
            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("DC_EVStatus:\n");
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVReady = %d (DEC)\n", status->EVReady);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVErrorCode = %d (DEC)\n", status->EVErrorCode);
    PRINT_dinDC_EVErrorCodeType(status);

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

    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVCabinConditioning = %d (DEC)\n", status->EVCabinConditioning);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVCabinConditioning_isUsed = %d (DEC)\n", status->EVCabinConditioning_isUsed);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVRESSConditioning = %d (DEC)\n", status->EVRESSConditioning);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("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("DC_EVStatus:\n");
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVReady = %d (DEC)\n", status->EVReady);
    DEBUG_PRINTF_EXI_ENGINE_DETAIL("EVErrorCode = %d (DEC)\n", status->EVErrorCode);
    PRINT_iso1DC_EVErrorCodeType(status);

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