2022.01.10 / Vern

    Actions:
    1. enable iso 15118

    Files:
    1. Apps/main.*
	Apps/Makefile
	Apps/CCS/*
	GPL/Makefile

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

    Hardware PWB P/N : XXXXXXX
    Hardware Version : XXXXXXX

EVSE/GPL/Makefile

@@ -45,6 +45,7 @@ Openssl:
 	cd openssl-1.0.2g;make install 
 	cp -f -r openssl-1.0.2g/release/lib/* ../rootfs/lib/
 	cp -f -r openssl-1.0.2g/release/bin/* ../rootfs/bin/
+	cp -f -r openssl-1.0.2g/release/include/* ../rootfs/include/
 
 pppd :
 	echo "pppd"

EVSE/Projects/AW-CCS/Apps/CCS/CsuComm.c

@@ -0,0 +1,3685 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                 CsuComm.c
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+#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 <linux/can.h>
+#include <linux/can/raw.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/time.h>
+#include <sys/timeb.h>
+#include <math.h>//for pow
+#include <net/if.h>
+#include <unistd.h>
+#include "define.h"
+#include "CsuComm.h"
+#include "SeccComm.h"
+#include "exi_engine/api/api.h"
+#ifdef AWCCS
+#include "../main.h"
+#endif
+
+struct SysConfigAndInfo             *ShmSysConfigAndInfo;
+struct StatusCodeData               *ShmStatusCodeData;
+struct CcsData                      *ShmCcsData;
+struct InternalComm                 *ShmInternalComm;
+//struct InternalCommAC               *ShmInternalCommAC;
+#ifdef AWCCS
+struct Charger							*ShmCharger;
+#endif
+
+pid_t PID_CAN_Rx_Task;
+pid_t PID_CsuComm_Error_Monitor_Task;
+int FD_CAN_Socket;
+unsigned char buf_log_csucomm[SIZE_OF_LOG_BUFFER];
+unsigned char buf_log_csucomm_fork1[SIZE_OF_LOG_BUFFER];
+unsigned char buf_log_csucomm_fork2[SIZE_OF_LOG_BUFFER];
+
+/*===========================================================================
+FUNCTION: GetSysTime()
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PrintTimeStamp()
+{
+    //static time_t CurrentTime;
+    //static struct tm *tm;
+    static struct timeval tv;
+    //CurrentTime = time(NULL);
+    //tm = localtime(&CurrentTime);
+    gettimeofday(&tv, NULL); // get microseconds, 10^-6
+    //printf("[%02d:%02d:%02d.%06d]",
+    //        tm->tm_hour, tm->tm_min, tm->tm_sec, tv.tv_usec);
+    DEBUG_PRINTF_CSUCOMM_DETAIL("[%05d.%06d]", tv.tv_sec, tv.tv_usec);
+}
+
+/*===========================================================================
+FUNCTION: Check_V2G_Flow_Status
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned char Check_V2G_Flow_Status()
+{
+    unsigned char result = 0;
+
+    switch (ShmCcsData->CommProtocol)
+    {
+        case V2GT_MSG_PROTOCOL_DIN70121:        //0
+        {
+            result = ShmCcsData->V2GMessage_DIN70121.PresentMsgFlowStatus;
+            break;
+        }
+
+        case V2GT_MSG_PROTOCOL_ISO15118_2014:   //1
+        {
+            result = ShmCcsData->V2GMessage_ISO15118_2014.PresentMsgFlowStatus;
+            break;
+        }
+
+        case V2GT_MSG_PROTOCOL_ISO15118_2018:   //2
+        {
+            result = ShmCcsData->V2GMessage_ISO15118_2018.PresentMsgFlowStatus;
+            break;
+        }
+
+        default:
+            break;
+    }
+    return result;
+}
+
+
+/*===========================================================================
+FUNCTION: StoreLogMsg
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+#if SAVE_SYS_LOG_MSG_CSUCOMM_SWITCH == ENABLE
+int StoreLogMsg2(unsigned char *DataString)
+{
+    static unsigned char Buf[256*2];
+    static time_t CurrentTime;
+    static struct tm *tm;
+    static struct timeval tv;
+
+    memset(Buf, 0, sizeof(Buf));
+    CurrentTime = time(NULL);
+    tm = localtime(&CurrentTime);
+    gettimeofday(&tv, NULL); // get microseconds, 10^-6
+	#ifdef AWCCS
+    sprintf(Buf, "echo \"[%04d%02d%02d: %02d:%02d:%02d.%06d][CsuComm][%d][%02d]%s\" >> /Storage/SystemLog/[%04d.%02d]CCS-SystemLog",
+            tm->tm_year + 1900,
+            tm->tm_mon + 1,
+            tm->tm_mday,
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            EVCOMM_SYS_INFO.CpState,
+            Check_V2G_Flow_Status(),
+            DataString,
+            tm->tm_year + 1900,
+            tm->tm_mon + 1);
+    #else
+    sprintf(Buf, "echo \"[%04d%02d%02d: %02d:%02d:%02d.%06d][CsuComm][%d][%02d]%s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog",
+            tm->tm_year + 1900,
+            tm->tm_mon + 1,
+            tm->tm_mday,
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            EVCOMM_SYS_INFO.CpState,
+            Check_V2G_Flow_Status(),
+            DataString,
+            tm->tm_year + 1900,
+            tm->tm_mon + 1);
+    #endif        
+    system(Buf);
+
+    DEBUG_PRINTF_CSUCOMM_SYSTEM_LOG("[%02d:%02d:%02d.%06d][CsuComm][%d][%02d]%s \n",
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            EVCOMM_SYS_INFO.CpState,
+            Check_V2G_Flow_Status(),
+            DataString);
+
+    //Reset the buf_log_csucomm Buffer, i.e. DataString
+    memset(buf_log_csucomm, 0, SIZE_OF_LOG_BUFFER);
+}
+#endif
+
+/*===========================================================================
+FUNCTION: Array_Check_All_Zero
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+    result:
+    (1) TRUE: all zero
+    (2) FALSE: not all zero
+GLOBAL VARIABLES:
+=============================================================================*/
+int Array_Check_All_Zero(unsigned char *ptr, int size)
+{
+    int result = TRUE;
+    int i = 0;
+
+    for (i = 0; i < size; i++)
+    {
+        if (ptr[i] != 0)
+        {
+            result = FALSE;
+            break;
+        }
+    }
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: Array_Compare_Identity
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+    result = FALSE (not identical)
+    result = TRUE  (identical)
+GLOBAL VARIABLES:
+=============================================================================*/
+int Array_Compare_Identity(unsigned char *ptrA, unsigned char *ptrB, int size)
+{
+    int result = TRUE;
+    int i = 0;
+
+    for (i = 0; i < size; i++)
+    {
+        if (ptrA[i] != ptrB[i])
+        {
+            result = FALSE;
+
+            #if 0
+            sprintf(buf_log_evcomm,
+                    "[Array_Compare_Identity]%02X%02X%02X%02X%02X%02X,%02X%02X%02X%02X%02X%02X(%d)\n",
+                    ptrA[0], ptrA[1], ptrA[2], ptrA[3], ptrA[4], ptrA[5],
+                    ptrB[0], ptrB[1], ptrB[2], ptrB[3], ptrB[4], ptrB[5],
+                    result);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            #endif
+            break;
+        }
+    }
+    return result;
+}
+
+
+/*===========================================================================
+FUNCTION: CAN_Tx_MSG
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int CAN_Tx_MSG(int Fd, unsigned int MsgId, unsigned char SlaveAddress, unsigned char DataLength, unsigned char *SendData)
+{
+    struct can_frame frame;
+    unsigned int tmp = 0;
+    int nbytes = 0;
+    int i = 0;
+
+    //Protection: To avoid unexpected length for CAN bus payload.
+    if (DataLength > 8)
+    {
+        DataLength = 8;
+    }
+
+    memset(&frame, 0, sizeof(struct can_frame));
+    frame.can_id = 0x80000000 | CAN_SEND_DIRECTION | MsgId | SlaveAddress;  //0x80000000: extension ID format
+    frame.can_dlc = DataLength;
+    memcpy(frame.data, SendData, DataLength);
+    nbytes = write(Fd, &frame, sizeof(struct can_frame));
+
+    #if 0
+    DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][CAN_Tx_MSG] <%X> ", frame.can_id);
+    for (i = 0; i < frame.can_dlc; i++)
+    {
+        DEBUG_PRINTF_CSUCOMM_DETAIL("%02X ", frame.data[i]);
+    }
+    DEBUG_PRINTF_CSUCOMM_DETAIL("(%d Bytes)\n", frame.can_dlc);
+    #endif
+
+    return nbytes;
+}
+
+
+/*===========================================================================
+FUNCTION: Sniffer_Candump
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+    0: accept
+   -1: invalid
+GLOBAL VARIABLES:
+=============================================================================*/
+int Sniffer_Candump(char cmd)
+{
+    #if (CANDUMP_PACKETS_SNIFFER_SWITCH == ENABLE)
+    if (cmd == ENABLE)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("[candump]init");
+        system("cd /mnt/;rm -rf candump/");
+        system("cd /mnt/;mkdir candump");
+        SAVE_SYS_LOG_MSG_CSUCOMM("[candump]on");
+        system("cd /mnt/candump;candump -l can0 &");
+        return 0;
+    }
+    else if (cmd == DISABLE)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("[candump]off");
+        system("killall candump");
+
+        SAVE_SYS_LOG_MSG_CSUCOMM("[candump]save");
+        system("cd /;cp -rfv /mnt/candump /Storage/SystemLog/");
+        return 0;
+    }
+    else
+    {
+        sprintf(buf_log_csucomm, "[candump]unexpected cmd(%d)", cmd);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        return -1;
+    }
+    #endif
+}
+
+/*===========================================================================
+FUNCTION: Checksum_Generator
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned char Checksum_Generator(unsigned int StartAdress, unsigned int length, unsigned char Data[])
+{
+	unsigned char checksum = 0x00;
+
+	for(unsigned int i = 0; i < length; i++)
+	{
+		//DEBUG_INFO("value = %x \n", Data[StartAdress + i]);
+		checksum ^= Data[StartAdress + i];
+		//DEBUG_INFO("checksum = %x \n", checksum);
+	}
+	return checksum;
+}
+
+
+/*===========================================================================
+FUNCTION: CRC32_Generator
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned int CRC32_Generator(unsigned char *data, unsigned int length)
+{
+    unsigned char i;
+    unsigned int cnt = 0;
+    unsigned int crc = 0xffffffff;  // Initial value
+    while(length--)
+    {
+    	if(cnt > 33 && cnt < 48)
+        {
+    		data++;
+    	}
+        else
+        {
+    		crc ^= *data++;         // crc ^= *data; data++;
+			for (i = 0; i < 8; ++i)
+			{
+				if (crc & 1)
+				{
+                    crc = (crc >> 1) ^ 0xEDB88320;// 0xEDB88320= reverse 0x04C11DB7
+                }
+				else
+				{
+                    crc = (crc >> 1);
+                }
+			}
+    	}
+    	cnt++;
+    }
+    return ~crc;
+}
+
+/*===========================================================================
+FUNCTION: Get_GPIO_Value
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Get_GPIO_Value(unsigned int gpio)
+{
+    int fd;
+    char buf[32];
+    char ch;
+
+    snprintf(buf, sizeof(buf), GPIO_SYS_DIR"/gpio%d/value", gpio);
+
+    fd = open(buf, O_RDONLY);
+
+    if (fd < 0)
+    {
+        perror("gpio/get-value");
+        return fd;
+    }
+
+    read(fd, &ch, 1);
+    close(fd);
+
+    if (ch != '0')
+    {
+        return 1;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+
+/*===========================================================================
+FUNCTION: DiffTimeb
+DESCRIPTION:
+    1. Data structure of timeb.h
+       The <sys/timeb.h> header defines the timeb structure that includes at least the following members:
+       - time_t          time      the seconds portion of the current time
+       - unsigned short  millitm   the milliseconds portion of the current time
+       - short           timezone  the local timezone in minutes west of Greenwich
+       - short           dstflag   TRUE if Daylight Savings Time is in effect
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+double DiffTimeb(struct timeb ST, struct timeb ET)
+{
+    //return milli-second
+    double StartTime, EndTime;
+    double t_diff;
+
+    StartTime = ((double)ST.time)*1000 + (double)ST.millitm;
+    EndTime = ((double)ET.time)*1000 + (double)ET.millitm;
+    t_diff = EndTime - StartTime;
+
+    //printf("%.02lf - %.02lf = %.02lf\n", EndTime, StartTime, t_diff);
+
+    if (t_diff < 0)
+    {
+        #if 0
+        if (t_diff < -1000)   //1000ms
+        {
+            sprintf(buf_log_csucomm,
+                    "[Warning]StartTime(%.02lf) > EndTime(%.02lf), d(%.02lf)",
+                    StartTime,
+                    EndTime,
+                    t_diff);
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        }
+        #endif
+
+        return -1;
+    }
+    return t_diff;
+}
+
+/*===========================================================================
+FUNCTION: DiffTimeb_CsuComm_fork1
+DESCRIPTION:
+    1. fork1
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+double DiffTimeb_CsuComm_fork1(struct timeb ST, struct timeb ET)
+{
+    //return milli-second
+    double StartTime, EndTime;
+    double t_diff;
+
+    StartTime = ((double)ST.time)*1000 + (double)ST.millitm;
+    EndTime = ((double)ET.time)*1000 + (double)ET.millitm;
+    t_diff = EndTime - StartTime;
+
+    if (t_diff < 0)
+    {
+        #if 0
+        if (t_diff < -1000)   //1000ms
+        {
+            sprintf(buf_log_csucomm_fork1,
+                    "[fork1][Warning]StartTime(%.02lf) > EndTime(%.02lf), d(%.02lf)",
+                    StartTime,
+                    EndTime,
+                    t_diff);
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm_fork1);
+        }
+        #endif
+
+        return -1;
+    }
+    return t_diff;
+}
+
+
+/*===========================================================================
+FUNCTION: ShareMemory_Init
+DESCRIPTION
+        Initialize all share memories.
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int ShareMemory_Init()
+{
+    int MeterSMId;
+    
+    #ifdef AWCCS
+    //[1/5] create ShmSysConfigAndInfo
+    if((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo),  IPC_CREAT | 0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmget ShmSysConfigAndInfo NG");
+        return 0;
+    }
+    else if((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmat ShmSysConfigAndInfo NG");
+        return 0;
+    }
+	 memset(ShmSysConfigAndInfo, 0, sizeof(struct SysConfigAndInfo));
+	 
+    //[2/5] create ShmStatusCodeData
+    if((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  IPC_CREAT |0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmget ShmStatusCodeData NG");
+        return 0;
+    }
+    else if((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmat ShmStatusCodeData NG");
+        return 0;
+    }
+	memset(ShmStatusCodeData, 0, sizeof(struct StatusCodeData));
+	
+    //[3/5] create ShmCcsData
+    if((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData),  IPC_CREAT |0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmget ShmCcsData NG");
+        return 0;
+    }
+    else if((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmat ShmCcsData NG");
+        return 0;
+    }
+	memset(ShmCcsData, 0, sizeof(struct CcsData));
+	
+    //[4/5] create ShmInternalComm
+    if((MeterSMId = shmget(ShmInternalCommKey, sizeof(struct InternalComm),  IPC_CREAT | 0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmget ShmInternalComm NG");
+        return 0;
+    }
+    else if((ShmInternalComm = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmat ShmInternalComm NG");
+        return 0;
+    }
+   memset(ShmInternalComm, 0, sizeof(struct InternalComm));
+	#if 0
+    //[5/5] create ShmInternalCommAC
+    if((MeterSMId = shmget(ShmInternalCommACKey, sizeof(struct InternalCommAC),  IPC_CREAT | 0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmget ShmInternalCommAC NG");
+        return 0;
+    }
+    else if((ShmInternalCommAC = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmat ShmInternalCommAC NG");
+        return 0;
+    }
+    //memset(ShmInternalCommAC, 0, sizeof(struct InternalCommAC));
+    #endif
+   
+    //creat ShmCharger
+   	if ((MeterSMId = shmget(ShmChargerKey, sizeof(struct Charger),  0777)) < 0)
+    {
+   		SAVE_SYS_LOG_MSG_CSUCOMM("shmget ShmCharger NG\n");
+   		return 0;
+	}
+    else if ((ShmCharger = shmat(MeterSMId, NULL, 0)) == (void *) -1)
+    {
+    	SAVE_SYS_LOG_MSG_CSUCOMM("shmat ShmCharger NG\n");
+    	return 0;
+   	}
+   	
+   	#else
+   	  //[1/5] create ShmSysConfigAndInfo
+    if((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo),   0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmget ShmSysConfigAndInfo NG");
+        return 0;
+    }
+    else if((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmat ShmSysConfigAndInfo NG");
+        return 0;
+    }
+    //[2/5] create ShmStatusCodeData
+    if((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmget ShmStatusCodeData NG");
+        return 0;
+    }
+    else if((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmat ShmStatusCodeData NG");
+        return 0;
+    }
+
+    //[3/5] create ShmCcsData
+    if((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData),  0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmget ShmCcsData NG");
+        return 0;
+    }
+    else if((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmat ShmCcsData NG");
+        return 0;
+    }
+    //[4/5] create ShmInternalComm
+    if((MeterSMId = shmget(ShmInternalCommKey, sizeof(struct InternalComm),   0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmget ShmInternalComm NG");
+        return 0;
+    }
+    else if((ShmInternalComm = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("ShareMemory_Init:shmat ShmInternalComm NG");
+        return 0;
+    }
+    //memset(ShmInternalComm, 0, sizeof(struct InternalComm));
+   	#endif
+    return 1;
+}
+
+/*===========================================================================
+FUNCTION: CANBus_Init
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int CANBus_Init()
+{
+    int s0, nbytes;
+    struct timeval tv;
+    struct ifreq ifr0;
+    struct sockaddr_can addr0;
+
+    system("/sbin/ip link set can0 type can bitrate 500000 restart-ms 100");
+    system("/sbin/ip link set can0 up");
+
+    s0 = socket(PF_CAN, SOCK_RAW, CAN_RAW);
+    if (s0 < 0) //added by Joseph (not full implemented)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("[ERROR] Fail on initializing CAN Bus socket");
+    }
+
+    tv.tv_sec = 0;
+    tv.tv_usec = 10000;
+
+    if(setsockopt(s0, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct timeval)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("CANBus_Init:Set SO_RCVTIMEO NG");
+    }
+
+    nbytes = 40960;
+
+    if(setsockopt(s0, SOL_SOCKET,  SO_RCVBUF, &nbytes, sizeof(int)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("CANBus_Init:Set SO_RCVBUF NG");
+    }
+
+    nbytes = 40960;
+
+    if(setsockopt(s0, SOL_SOCKET, SO_SNDBUF, &nbytes, sizeof(int)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("CANBus_Init:Set SO_SNDBUF NG");
+    }
+
+    strcpy(ifr0.ifr_name, "can0" );
+    ioctl(s0, SIOCGIFINDEX, &ifr0); /* ifr.ifr_ifindex gets filled with that device's index */
+    addr0.can_family = AF_CAN;
+    addr0.can_ifindex = ifr0.ifr_ifindex;
+    bind(s0, (struct sockaddr *)&addr0, sizeof(addr0));
+    return s0;
+}
+
+
+/*===========================================================================
+FUNCTION: Update_EVSE_INFO_to_SHMs
+DESCRIPTION:
+        Updating all corresponding content in each Share Memory.
+        1. I_now
+        2. V_now
+        3. P_now
+        4. I_max
+        5. V_max
+        6. P_max
+
+PRE-CONDITION:
+INPUT:
+        1. ShmInternalComm
+OUTPUT:
+        1. ShmCcsData
+            * PreChargeResponse
+            * CurrentDemandResponse
+            * WeldingDetectionResponse
+
+        2. ShmSysConfigAndInfo
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void Update_EVSE_INFO_to_SHMs()
+{
+    int I_now = 0;  //0.1A
+    int V_now = 0;  //0.1V
+    int P_now = 0;  //0.1KW
+
+    int I_max = 0;  //0.1A
+    int V_max = 0;  //0.1V
+    int P_max = 0;  //0.1KW
+
+    //[CAUTION] Re-initializing process is necessary. (to-be implemented)
+    //----------[1/7] Permission --------
+    if (ShmInternalComm->ChargingPermission_new != ShmInternalComm->ChargingPermission)
+    {
+        sprintf(buf_log_csucomm, "Permission: %d >> %d",
+                ShmInternalComm->ChargingPermission,
+                ShmInternalComm->ChargingPermission_new
+               );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->ChargingPermission_pre = ShmInternalComm->ChargingPermission;
+        ShmInternalComm->ChargingPermission = ShmInternalComm->ChargingPermission_new;
+    }
+
+    // -------- [3/7] V_now --------
+    V_now = ShmInternalComm->PresentChargingVoltage;
+    EVCOMM_SYS_INFO.PresentChargingVoltage = V_now / 10.0; //1V
+    if (ShmInternalComm->PresentChargingVoltage_pre != ShmInternalComm->PresentChargingVoltage)
+    {
+        if (abs(ShmInternalComm->PresentChargingVoltage_pre - ShmInternalComm->PresentChargingVoltage) > 10) //10:1V
+        {
+            unsigned char state = 0;
+            state = Check_V2G_Flow_Status();
+
+            if(state == CableCheckRequest    || state == CableCheckResponse ||      //37, 38
+               state == PreChargeRequest     || state == PreChargeResponse  ||      //39, 40
+               state == CurrentDemandRequest || state == CurrentDemandResponse)     //45, 46
+            {
+                if ((ShmInternalComm->PresentChargingVoltage <= 600) ||  //600:60V
+                    (ShmInternalComm->PresentChargingVoltage >= 1500)    //1500:150V
+                   )
+                {
+                    sprintf(buf_log_csucomm, "V_now(EVSE): %d >> %d (0.1V, DEC)",
+                            ShmInternalComm->PresentChargingVoltage_pre,
+                            ShmInternalComm->PresentChargingVoltage
+                          );
+                    SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+                }
+            }
+            else
+            {
+                sprintf(buf_log_csucomm, "V_now(EVSE): %d >> %d (0.1V, DEC)",
+                        ShmInternalComm->PresentChargingVoltage_pre,
+                        ShmInternalComm->PresentChargingVoltage
+                      );
+                SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+            }
+        }
+        ShmInternalComm->PresentChargingVoltage_pre = ShmInternalComm->PresentChargingVoltage;
+    }
+
+ // -------- [2/7] I_now --------
+    I_now = ShmInternalComm->PresentChargingCurrent;
+    EVCOMM_SYS_INFO.PresentChargingCurrent = I_now / 10.0; //1A
+    if (ShmInternalComm->PresentChargingCurrent_pre != ShmInternalComm->PresentChargingCurrent)
+    {
+        if ((abs(ShmInternalComm->PresentChargingCurrent_pre - ShmInternalComm->PresentChargingCurrent) > 20)&&
+            (ShmInternalComm->PresentChargingVoltage >= 100))  
+        {
+            //memset(buf_log_csucomm, 0, sizeof(buf_log_csucomm));
+            sprintf(buf_log_csucomm, "I_now(EVSE): %d >> %d (0.1A, DEC)",
+                    ShmInternalComm->PresentChargingCurrent_pre,
+                    ShmInternalComm->PresentChargingCurrent
+                   );
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        }
+
+        ShmInternalComm->PresentChargingCurrent_pre = ShmInternalComm->PresentChargingCurrent;
+    }
+
+    // -------- [4/7] P_now --------
+    ShmInternalComm->PresentChargingPower = (int)(((I_now/10) * (V_now/10)) / 100);  //0.1KW
+    P_now = ShmInternalComm->PresentChargingPower;
+    EVCOMM_SYS_INFO.PresentChargingPower = P_now * 10.0;   //1KW
+    if (ShmInternalComm->PresentChargingPower_pre != ShmInternalComm->PresentChargingPower)
+    {
+        sprintf(buf_log_csucomm, "P_now(EVSE): %d >> %d (0.1KW, DEC)",
+                ShmInternalComm->PresentChargingPower_pre,
+                ShmInternalComm->PresentChargingPower);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->PresentChargingPower_pre = ShmInternalComm->PresentChargingPower;
+    }
+
+    // -------- [5/7] I_max --------
+    I_max = ShmInternalComm->AvailableChargingCurrent;
+    EVCOMM_SYS_INFO.AvailableChargingCurrent = I_max / 10.0;   //1A
+    if (ShmInternalComm->AvailableChargingCurrent_pre != ShmInternalComm->AvailableChargingCurrent)
+    {
+        sprintf(buf_log_csucomm, "I_max(EVSE): %d >> %d (0.1A, DEC)",
+                ShmInternalComm->AvailableChargingCurrent_pre,
+                ShmInternalComm->AvailableChargingCurrent);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AvailableChargingCurrent_pre = ShmInternalComm->AvailableChargingCurrent;
+    }
+
+    // -------- [6/7] V_max --------
+    V_max = ShmInternalComm->MaximumChargingVoltage;
+    EVCOMM_SYS_INFO.MaximumChargingVoltage = V_max / 10.0;   //1V
+    if (ShmInternalComm->MaximumChargingVoltage_pre != ShmInternalComm->MaximumChargingVoltage)
+    {
+        sprintf(buf_log_csucomm, "V_max(EVSE): %d >> %d (0.1V, DEC)",
+                ShmInternalComm->MaximumChargingVoltage_pre,
+                ShmInternalComm->MaximumChargingVoltage
+              );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->MaximumChargingVoltage_pre = ShmInternalComm->MaximumChargingVoltage;
+    }
+
+    // -------- [7/7] P_max --------
+    P_max = ShmInternalComm->AvailableChargingPower;
+    EVCOMM_SYS_INFO.AvailableChargingPower = P_max / 10.0;   //1KW
+    if (ShmInternalComm->AvailableChargingPower_pre != ShmInternalComm->AvailableChargingPower)
+    {
+        sprintf(buf_log_csucomm, "P_max(EVSE): %d >> %d (0.1KW, DEC)",
+                ShmInternalComm->AvailableChargingPower_pre,
+                ShmInternalComm->AvailableChargingPower);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AvailableChargingPower_pre = ShmInternalComm->AvailableChargingPower;
+    }
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_EVBoardStatusRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_EVBoardStatusRes(int Fd)
+{
+    int nbytes;
+    unsigned char Buffer[8];
+
+    memset(Buffer, 0, sizeof(Buffer));
+
+    Buffer[0] = ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].ConnectorPlugIn;
+
+    Buffer[1] = ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].CpState;
+
+    /*
+    if(strlen(ShmStatusCodeData->PresentStatusCode[0]) > 0)
+    {
+        memcpy(Buffer + 2, ShmStatusCodeData->PresentStatusCode[0], 6);
+    }
+    */
+    Buffer[2] = ShmStatusCodeData->PresentStatusCode[0][0];
+    Buffer[3] = ShmStatusCodeData->PresentStatusCode[0][1];
+    Buffer[4] = ShmStatusCodeData->PresentStatusCode[0][2];
+    Buffer[5] = ShmStatusCodeData->PresentStatusCode[0][3];
+    Buffer[6] = ShmStatusCodeData->PresentStatusCode[0][4];
+    Buffer[7] = ShmStatusCodeData->PresentStatusCode[0][5];
+
+    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_EV_BOARD_STATUS, ShmInternalComm->SlaveAddress, 8, Buffer);
+
+    CSUCOMMDC_TASK_FLAG.Send_EVBoardStatus = FALSE;
+
+    return nbytes;
+}
+
+/*===========================================================================
+FUNCTION: Proc_AddressAssignRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_AddressAssignRes(int Fd)
+{
+
+}
+
+/*===========================================================================
+FUNCTION: Proc_AddressAssignReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_AddressAssignReq(struct can_frame *frame)
+{
+    //[CAUTION] There should not be such message ID here.
+    //          A warning alarm should be recorded.
+    DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][Proc_AddressAssignReq] Unexpected message of address assignment from CSU.\n");
+
+    ShmInternalComm->SlaveAddress = frame->can_id & 0x000000FF;
+    CSUCOMMDC_TASK_FLAG.Got_AssignedAddress = TRUE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_GetFirmwareVersionRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_GetFirmwareVersionRes(int Fd)
+{
+    int i = 0, j = 0, nbytes = 0;
+    unsigned char str[FIRMWARE_VERSION_LENGTH + 1];
+    unsigned char buf[FIRMWARE_VERSION_LENGTH];
+
+    memset(buf, 0, sizeof(buf));
+    strcpy(str, FIRMWARE_VERSION);
+
+    for(i = 0; i < FIRMWARE_VERSION_LENGTH + 3; i++)
+    {
+        if (str[i] != '_')
+        {
+            buf[j] = str[i];
+            j++;
+        }
+    }
+
+    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_GET_FW_VERSION, ShmInternalComm->SlaveAddress, FIRMWARE_VERSION_LENGTH, buf);
+
+    CSUCOMMDC_TASK_FLAG.Got_FWVersionReq = FALSE;
+
+    return nbytes;
+}
+
+/*===========================================================================
+FUNCTION: Proc_GetFirmwareVersionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_GetFirmwareVersionReq(struct can_frame *frame)
+{
+    CSUCOMMDC_TASK_FLAG.Got_FWVersionReq = TRUE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_HardwareVersionRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_HardwareVersionRes(int Fd)
+{
+    int i = 0, nbytes = 0;
+    unsigned char str[HARDWARE_VERSION_LENGTH + 1];
+    unsigned char buf[HARDWARE_VERSION_LENGTH];
+
+    memset(buf, 0, sizeof(buf));
+    strcpy(str, HARDWARE_VERSION);
+
+    for(i = 0; i < HARDWARE_VERSION_LENGTH; i++)
+    {
+        buf[i] = str[i];
+    }
+
+    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_GET_HW_VERSION, ShmInternalComm->SlaveAddress, HARDWARE_VERSION_LENGTH, buf);
+
+    CSUCOMMDC_TASK_FLAG.Got_HWVersionReq = FALSE;
+
+    return nbytes;
+}
+
+/*===========================================================================
+FUNCTION: Proc_HardwareVersionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_HardwareVersionReq(struct can_frame *frame)
+{
+    CSUCOMMDC_TASK_FLAG.Got_HWVersionReq = TRUE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_GetMiscellaneousInfoRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_GetMiscellaneousInfoRes(int Fd)
+{
+    //DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][Proc_GetMiscellaneousInfoRes] To-be implemented.\n");
+    int nbytes;
+    unsigned char Buffer[8];
+    unsigned short TmpValue;
+
+    memset(Buffer, 0, sizeof(Buffer));
+
+    Buffer[0] = ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].ConnectorLocked;
+    Buffer[1] =ShmSysConfigAndInfo->SysInfo.CcsConnectorTemp&0xFF;
+    Buffer[2] =(ShmSysConfigAndInfo->SysInfo.CcsConnectorTemp>>8)&0xFF;
+    Buffer[3] = (unsigned char)(ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].CpVoltage * 10);
+    Buffer[4] = ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].CpState;
+    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_GET_MISC_INFO, ShmInternalComm->SlaveAddress, 7, Buffer);
+    CSUCOMMDC_TASK_FLAG.Got_MiscellaneousInfoReq = FALSE;
+    return nbytes;
+}
+
+/*===========================================================================
+FUNCTION: Proc_GetMiscellaneousInfoReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_GetMiscellaneousInfoReq(struct can_frame *frame)
+{
+    CSUCOMMDC_TASK_FLAG.Got_MiscellaneousInfoReq = TRUE;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_ChargingPermissionRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_ChargingPermissionRes(int Fd)
+{
+    //Save into ShmCcsData
+
+    //[1/2] Updating Parameters
+    Update_EVSE_INFO_to_SHMs();
+
+    //[2/2] Check if SECC is in the End_Process or Initial stage
+    if ((EVCOMM_SYS_INFO.End_Process_inused == TRUE) ||
+        (EVCOMM_SYS_INFO.QCA7K_SetKeyDone == FALSE))
+    {
+        if (ShmInternalComm->ChargingPermission == TRUE)
+        {
+            //Update_ShmStatusCode(); //[To-Do] to be implemented
+            //CCS_SECC_Not_Ready_For_Charging (023891)
+            ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+            ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+            ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+            ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+            ShmStatusCodeData->PresentStatusCode[0][4] = 9;
+            ShmStatusCodeData->PresentStatusCode[0][5] = 1;
+            CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+            //This Stop command will be delivered to CSU once SECC receives
+            //one permission as TRUE command.
+        }
+    }
+
+    CSUCOMMDC_TASK_FLAG.Got_ChargingPermission = FALSE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_ChargingPermissionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_ChargingPermissionReq(struct can_frame *frame)
+{
+    ShmInternalComm->ChargingPermission_new = frame->data[0];
+
+    ShmInternalComm->AvailableChargingPower = (unsigned int) ((frame->data[2] << 8) | frame->data[1]);
+    ShmInternalComm->AvailableChargingCurrent = (unsigned int) ((frame->data[4] << 8) | frame->data[3]);
+    ShmInternalComm->MaximumChargingVoltage = (unsigned int) ((frame->data[6] << 8) | frame->data[5]);
+    ShmInternalComm->MaximumAllowedChargingTime = frame->data[7]; //0: unlimited, 0x01: 1 minutes ~ 0xFF: 255 minutes, resolution: 1 minute
+
+    DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][CAN_Rx]\n\
+            \t - AvailableChargingPower   = (%d, %02X, %02X)\n\
+            \t - AvailableChargingCurrent = (%d, %02X, %02X)\n\
+            \t - MaximumChargingVoltage   = (%d, %02X, %02X)\n",
+            ShmInternalComm->AvailableChargingPower,    frame->data[2], frame->data[1],
+            ShmInternalComm->AvailableChargingCurrent,  frame->data[4], frame->data[3],
+            ShmInternalComm->MaximumChargingVoltage,    frame->data[6], frame->data[5]
+          );
+
+    //Update Flag
+    CSUCOMMDC_TASK_FLAG.Got_ChargingPermission = TRUE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_EVSEOutputStatusUpdateRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_EVSEOutputStatusUpdateRes(int Fd)
+{
+    Update_EVSE_INFO_to_SHMs();
+
+    //Update Flag
+    CSUCOMMDC_TASK_FLAG.Got_EVSEOutputStatus = FALSE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_EVSEOutputStatusUpdateReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_EVSEOutputStatusUpdateReq(struct can_frame *frame)
+{
+    if(ShmInternalComm->SlaveAddress == 1)
+    {
+        ShmInternalComm->PresentChargingVoltage = ((unsigned int)frame->data[1] << 8 | frame->data[0]);
+        ShmInternalComm->PresentChargingCurrent = ((unsigned int)frame->data[3] << 8 | frame->data[2]);
+    }
+    else
+    {
+        ShmInternalComm->PresentChargingVoltage = ((unsigned int)frame->data[5] << 8 | frame->data[4]);
+        ShmInternalComm->PresentChargingCurrent = ((unsigned int)frame->data[7] << 8 | frame->data[6]);
+    }
+
+    //Update Flag
+    CSUCOMMDC_TASK_FLAG.Got_EVSEOutputStatus = TRUE;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_EVSECapacityUpdateRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_EVSECapacityUpdateRes(int Fd)
+{
+    Update_EVSE_INFO_to_SHMs();
+
+    CSUCOMMDC_TASK_FLAG.Got_EnergyCapacity = FALSE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_EVSECapacityUpdateReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_EVSECapacityUpdateReq(struct can_frame *frame)
+{
+    if(ShmInternalComm->SlaveAddress == 1)
+    {
+        ShmInternalComm->AvailableChargingPower = ((unsigned int)frame->data[1] << 8 | frame->data[0]);
+        ShmInternalComm->AvailableChargingCurrent = ((unsigned int)frame->data[3] << 8 | frame->data[2]);
+    }
+    else
+    {
+        ShmInternalComm->AvailableChargingPower = ((unsigned int)frame->data[5] << 8 | frame->data[4]);
+        ShmInternalComm->AvailableChargingCurrent = ((unsigned int)frame->data[7] << 8 | frame->data[6]);
+    }
+
+    //Update Flag
+    CSUCOMMDC_TASK_FLAG.Got_EnergyCapacity = TRUE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_GetEVTargetRes
+DESCRIPTION:
+    #define CAN_CMD_GET_EV_TARGET_INFO                  0x00000900
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_GetEVTargetRes(int Fd)
+{
+    //DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][Proc_GetEVTargetRes] To-be implemented.\n");
+
+    int nbytes;
+    unsigned char Buffer[8];
+    unsigned short TmpValue;
+
+    static struct ChargingInfoData *sys;
+
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    memset(Buffer, 0, sizeof(Buffer));
+
+    Buffer[0] = Check_V2G_Flow_Status();
+
+    //[1/4] SOC
+    if (sys->EvBatterySoc_pre != sys->EvBatterySoc)
+    {
+        //memset(buf_log_csucomm, 0, sizeof(buf_log_csucomm));
+        sprintf(buf_log_csucomm, "SOC = %d >> %d",
+                sys->EvBatterySoc_pre,
+                sys->EvBatterySoc
+               );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        sys->EvBatterySoc_pre = sys->EvBatterySoc;
+    }
+    Buffer[1] = sys->EvBatterySoc;
+
+    //printf("[CsuComm] V_ev_target = %.02f\n", sys->EvBatterytargetVoltage);
+
+    //[2/4] EV Target Voltage
+    if (sys->EvBatterytargetVoltage_pre != sys->EvBatterytargetVoltage)
+    {
+        //memset(buf_log_csucomm, 0, sizeof(buf_log_csucomm));
+        sprintf(buf_log_csucomm, "V_target = %.02f >> %.02f (1V, DEC)",
+                sys->EvBatterytargetVoltage_pre,
+                sys->EvBatterytargetVoltage
+               );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        sys->EvBatterytargetVoltage_pre = sys->EvBatterytargetVoltage;
+    }
+    TmpValue = (unsigned short) (sys->EvBatterytargetVoltage * 10);
+    memcpy(Buffer + 2, &TmpValue, 2);
+
+
+
+    //[3/4] EV Target Current
+    if (sys->EvBatterytargetCurrent_pre != sys->EvBatterytargetCurrent)
+    {
+        //memset(buf_log_csucomm, 0, sizeof(buf_log_csucomm));
+        sprintf(buf_log_csucomm, "I_target = %.02f >> %.02f (1A, DEC)",
+                sys->EvBatterytargetCurrent_pre,
+                sys->EvBatterytargetCurrent
+               );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        sys->EvBatterytargetCurrent_pre = sys->EvBatterytargetCurrent;
+    }
+    TmpValue = (unsigned short) (sys->EvBatterytargetCurrent * 10);
+    memcpy(Buffer + 4, &TmpValue, 2);
+
+
+    //[4/4] Remaining Time
+    TmpValue = (unsigned short) sys->RemainChargingDuration;
+    memcpy(Buffer + 6, &TmpValue, 2);
+
+    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_GET_EV_TARGET_INFO, ShmInternalComm->SlaveAddress, 8, Buffer);
+
+    CSUCOMMDC_TASK_FLAG.Got_EVTargetReq = FALSE;
+
+    return nbytes;
+}
+
+/*===========================================================================
+FUNCTION: Proc_GetEVTargetReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_GetEVTargetReq(struct can_frame *frame)
+{
+    CSUCOMMDC_TASK_FLAG.Got_EVTargetReq = TRUE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_GetEVBatteryInfoRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_GetEVBatteryInfoRes(int Fd)
+{
+    int nbytes;
+    unsigned char Buffer[8];
+    unsigned short TmpValue;
+
+    memset(Buffer, 0, sizeof(Buffer));
+
+    //[To-Do] Adding the consideration of ISO15118_2018
+    if((ShmCcsData->CommProtocol == V2GT_MSG_PROTOCOL_ISO15118_2014) &&
+       (ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.RequestedEnergyTransferMode <= 1))
+    {
+        Buffer[0] = 1;//AC
+    }
+    else
+    {
+        Buffer[0] = 0;//DC
+    }
+
+    if(ShmCcsData->CommProtocol == V2GT_MSG_PROTOCOL_DIN70121)
+    {
+        //DIN70121
+        TmpValue = DIN70121PhyValDecode(ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.EVEnergyCapacity) * 10;
+        memcpy(Buffer + 1, &TmpValue, 2);
+        TmpValue = DIN70121PhyValDecode(ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.EVMaximumVoltageLimit) * 10;
+        memcpy(Buffer + 3, &TmpValue, 2);
+        TmpValue = DIN70121PhyValDecode(ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.EVMaximumCurrentLimit) * 10;
+        memcpy(Buffer + 5, &TmpValue, 2);
+    }
+    else if(ShmCcsData->CommProtocol == V2GT_MSG_PROTOCOL_ISO15118_2014)
+    {
+        //ISO15118_2014
+        if(Buffer[0] == 0)
+        {
+            //DC
+            TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.EVEnergyCapacity) * 10;
+            memcpy(Buffer + 1, &TmpValue, 2);
+            TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.EVMaximumVoltageLimit) * 10;
+            memcpy(Buffer + 3, &TmpValue, 2);
+            TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.EVMaximumCurrentLimit) * 10;
+            memcpy(Buffer + 5, &TmpValue, 2);
+        }
+        else
+        {
+            //AC
+            TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.AC_EVChargeParameter.EAmount) * 10;
+            memcpy(Buffer + 1, &TmpValue, 2);
+            TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.AC_EVChargeParameter.EVMaxVoltage) * 10;
+            memcpy(Buffer + 3, &TmpValue, 2);
+            TmpValue = ISO151182014PhyValDecode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.AC_EVChargeParameter.EVMaxCurrent) * 10;
+            memcpy(Buffer + 5, &TmpValue, 2);
+        }
+    }
+    else if(ShmCcsData->CommProtocol == V2GT_MSG_PROTOCOL_ISO15118_2018)
+    {
+        //to be implemented
+    }
+
+    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_GET_EV_BATTERY_INFO, ShmInternalComm->SlaveAddress, 7, Buffer);
+
+    CSUCOMMDC_TASK_FLAG.Got_EVBatteryInfoReq = FALSE;
+
+    return nbytes;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_GetEVBatteryInfoReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_GetEVBatteryInfoReq()
+{
+    CSUCOMMDC_TASK_FLAG.Got_EVBatteryInfoReq = TRUE;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_IsolationStatusAnnounceRes
+DESCRIPTION:
+- ShmInternalComm->IsolationStatus:
+    GFD_Invalid       0     //ongoing
+    GFD_Valid         1
+    GFD_Warning       2
+    GFD_Fault         3
+    GFD_No_IMD        4     //for ISO 15118
+
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_IsolationStatusAnnounceRes(int Fd)
+{
+    DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][Proc_IsolationStatusAnnounceRes] %d (DEC, 0:ongoing, 1:valid, 2:warning/fault)\n",
+                                ShmInternalComm->IsolationStatus);
+
+    if (ShmInternalComm->IsolationStatus_pre != ShmInternalComm->IsolationStatus)
+    {
+        //memset(buf_log_csucomm, 0, sizeof(buf_log_csucomm));
+        sprintf(buf_log_csucomm, "Isolation: %d >> %d",
+                ShmInternalComm->IsolationStatus_pre,
+                ShmInternalComm->IsolationStatus);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->IsolationStatus_pre = ShmInternalComm->IsolationStatus;
+    }
+
+    //DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;    //0 (default)
+    //	dinisolationLevelType_Invalid = 0,
+    //	dinisolationLevelType_Valid = 1, (default)
+    //	dinisolationLevelType_Warning = 2,
+    //	dinisolationLevelType_Fault = 3
+
+
+    CSUCOMMDC_TASK_FLAG.Got_IsolationStatus = FALSE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_IsolationStatusAnnounceReq
+DESCRIPTION:
+    - BYTE[0]:
+        GFD_Invalid       0     //ongoing
+        GFD_Valid         1
+        GFD_Warning       2
+        GFD_Fault         3
+        GFD_No_IMD        4     //for ISO 15118
+
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_IsolationStatusAnnounceReq(struct can_frame *frame)
+{
+    unsigned char gfd_rx = 0;
+    gfd_rx = (unsigned char) frame->data[0];
+
+    if (gfd_rx >= GFD_Invalid && gfd_rx <= GFD_No_IMD)
+    {
+        //Transfer Parameter
+        if (gfd_rx == GFD_Warning)
+        {
+            gfd_rx = GFD_Fault;
+        }
+        else if (gfd_rx == GFD_Fault)
+        {
+            gfd_rx = GFD_Warning;
+        }
+        else
+        {
+            //no modification.
+        }
+
+        ShmInternalComm->IsolationStatus = gfd_rx;
+        EVCOMM_SYS_INFO.IsolationStatus = ShmInternalComm->IsolationStatus;
+
+        CSUCOMMDC_TASK_FLAG.Got_IsolationStatus = TRUE;
+    }
+    else
+    {
+        sprintf(buf_log_csucomm,
+                "[WARNING]unexpected isolation status(%d)",
+                frame->data[0]);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+    }
+}
+
+/*===========================================================================
+FUNCTION: Proc_CCSConnectorTypeSetRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_CCSConnectorTypeSetRes(int Fd)
+{
+    DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][Proc_CCSConnectorTypeSetRes] To-be implemented. (checking for PP or not)\n");
+    CSUCOMMDC_TASK_FLAG.Got_CCSConnectorReq = FALSE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_CCSConnectorTypeSetReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_CCSConnectorTypeSetReq(struct can_frame *frame)
+{
+    ShmInternalComm->CCSConnectorType = (unsigned char) frame->data[0];//0x00 : CCS1, 0x01 : CCS2
+    CSUCOMMDC_TASK_FLAG.Got_CCSConnectorReq = TRUE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_RTCSetRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_RTCSetRes(int Fd)
+{
+    int nbytes;
+    unsigned char Buffer[1];
+
+    memset(Buffer, 0, sizeof(Buffer));
+
+    if (ShmInternalComm->RTC != 0)
+    {
+        //[CAUTION] updating RTC time only in IDLE mode
+        //ShmInternalComm->RTC = 1575461829;
+        sprintf(buf_log_csucomm, "[Proc_RTCSetRes] Got RTC Message: %lu (DEC)", ShmInternalComm->RTC);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        system("date");
+        SAVE_SYS_LOG_MSG_CSUCOMM("[Proc_RTCSetRes] RTC is updating...");
+        #if 1
+        time_t rtc_new;
+        rtc_new = ShmInternalComm->RTC; //Epoch time
+        stime(&rtc_new);
+        ftime(&ShmInternalComm->Start_Time);
+        ftime(&ShmInternalComm->End_Time);
+        ftime(&ShmInternalComm->CAN_Rx_Timer_Start);
+        ftime(&ShmInternalComm->CAN_Rx_Timer_End);
+        #else   //verified ok
+        char buf[64];
+        sprintf(buf, "date +%%s -s @%u", ShmInternalComm->RTC);
+        system(buf);
+        ftime(&ShmInternalComm->Start_Time);
+        ftime(&ShmInternalComm->End_Time);
+        ftime(&ShmInternalComm->CAN_Rx_Timer_Start);
+        ftime(&ShmInternalComm->CAN_Rx_Timer_End);
+        #endif
+        system("date");
+        SAVE_SYS_LOG_MSG_CSUCOMM("[Proc_RTCSetRes] RTC is updated.\n");
+        Buffer[0] = 1;  //Accept
+    }
+    else
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("[Proc_RTCSetRes] Reject.\n");
+        Buffer[0] = 0; //Reject
+    }
+
+    CSUCOMMDC_TASK_FLAG.Got_RTC = FALSE;
+
+    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_RTC_INFO, ShmInternalComm->SlaveAddress, 1, Buffer);
+    return nbytes;
+}
+
+/*===========================================================================
+FUNCTION: Proc_RTCSetReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+        1. Epoch time
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_RTCSetReq(struct can_frame *frame)
+{
+    //STEP 1: If the RTC time from CSU is older than CCS default time, ignore it.
+    //(The RTC time of CSU might not be updated.)
+    long int rtc_tmp = 0;
+    memcpy(&rtc_tmp, &frame->data[0], 4);  //Epoch time
+    if (rtc_tmp < RTC_DEFAULT_TIME)
+    {
+        sprintf(buf_log_csucomm,
+                "[WARNING] RTC time from CSU(%lu) is older than CCS(%lu): ignored",
+                rtc_tmp,
+                RTC_DEFAULT_TIME);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        return;
+    }
+
+    //STEP 2: Checking System State and Update RTC
+    if (Check_V2G_Flow_Status() == IDLE &&
+        ShmInternalComm->DownloadImageInfo.active == FALSE &&
+        EVCOMM_SYS_INFO.End_Process_inused == FALSE)
+    {
+        #if 1
+        //4-Byte EPOCH TIME: CAN: BYTE_TIME[0] BYTE_TIME[1] BYTE_TIME[2] BYTE_TIME[3]
+        memcpy(&ShmInternalComm->RTC, &frame->data[0], 4);  //Epoch time
+        #else
+        //4-Byte EPOCH TIME: CAN: BYTE_TIME[3] BYTE_TIME[2] BYTE_TIME[1] BYTE_TIME[0]
+        unsigned char rtc[4], tmp;
+        memcpy(&rtc[0], &frame->data[0], 4);
+        tmp = rtc[0];
+        rtc[0] = rtc[3];
+        rtc[3] = tmp;
+        tmp = rtc[1];
+        rtc[1] = rtc[2];
+        rtc[2] = tmp;
+        memcpy(&ShmInternalComm->RTC, &rtc[0], 4);  //Epoch time
+        #endif
+    }
+    else
+    {
+        ShmInternalComm->RTC = 0;
+    }
+    //printf("\n%X  %X  %X  %X (%X)\n", frame->data[0], frame->data[1], frame->data[2], frame->data[3], ShmInternalComm->RTC);
+    CSUCOMMDC_TASK_FLAG.Got_RTC = TRUE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_EVSEPrechargeInfoUpdateRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_EVSEPrechargeInfoUpdateRes(int Fd)
+{
+    DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][Proc_EVSEPrechargeInfoUpdateRes]\n");
+
+    int nbytes;
+    unsigned char Buffer[8];
+    unsigned short TmpValue;
+
+    memset(Buffer, 0, sizeof(Buffer));
+
+    //Buffer[0] = TRUE;
+    Buffer[0] = ShmInternalComm->EVSEPrechargeStatus;
+
+    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_EVSE_PRECHARGE_INFO, ShmInternalComm->SlaveAddress, 1, Buffer);
+
+    CSUCOMMDC_TASK_FLAG.Got_EVSE_Precharge_Info = FALSE;
+
+    return nbytes;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_EVSEPrechargeInfoUpdateReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_EVSEPrechargeInfoUpdateReq(struct can_frame *frame)
+{
+    static struct ChargingInfoData *sys;
+
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    ShmInternalComm->EVSEPrechargeStatus = frame->data[0];
+    sys->EVSEPrechargeStatus = ShmInternalComm->EVSEPrechargeStatus;
+
+    if (sys->EVSEPrechargeStatus_pre != sys->EVSEPrechargeStatus)
+    {
+        //memset(buf_log_csucomm, 0, sizeof(buf_log_csucomm));
+        sprintf(buf_log_csucomm, "Precharge Status: %d >> %d",
+                    sys->EVSEPrechargeStatus_pre,
+                    sys->EVSEPrechargeStatus
+               );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        sys->EVSEPrechargeStatus_pre = sys->EVSEPrechargeStatus;
+    }
+
+    CSUCOMMDC_TASK_FLAG.Got_EVSE_Precharge_Info = TRUE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_EVCCIDRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_EVCCIDRes(int Fd)
+{
+    DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][Proc_EVCCIDRes]\n");
+
+    int i = 0;
+    int nbytes = 0;
+    unsigned char Buffer[8];
+
+	/*+++ 20200707, vern, reduce 8 digital MAC from BMW i3 +++*/
+	memset(Buffer, 0, sizeof(Buffer));
+	
+	if(EVCOMM_SYS_INFO.EVCCID_length>=8)
+	{
+		EVCOMM_SYS_INFO.EVCCID_length=8;
+		if((EVCOMM_SYS_INFO.EVCCID[0]==0)&&(EVCOMM_SYS_INFO.EVCCID[1]==0))
+			memcpy(EVCOMM_SYS_INFO.EVCCID,EVCOMM_SYS_INFO.EVCCID+2,6);
+		EVCOMM_SYS_INFO.EVCCID_length=6;
+	}
+
+	memcpy(Buffer,EVCOMM_SYS_INFO.EVCCID,EVCOMM_SYS_INFO.EVCCID_length);
+	/*--- 20200707, vern, reduce 8 digital MAC from BMW i3 ---*/
+    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_EVCCID_REQUEST, ShmInternalComm->SlaveAddress, EVCOMM_SYS_INFO.EVCCID_length, Buffer);
+
+    CSUCOMMDC_TASK_FLAG.Got_EVCCID_Req = FALSE;
+
+    return nbytes;
+}
+
+/*===========================================================================
+FUNCTION: Proc_EVCCIDReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_EVCCIDReq(struct can_frame *frame)
+{
+    CSUCOMMDC_TASK_FLAG.Got_EVCCID_Req = TRUE;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_EVStopRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_EVStopRes(int Fd)
+{
+    int nbytes;
+    unsigned char Buffer[8];
+
+    memset(Buffer, 0, sizeof(Buffer));
+
+    /*
+    if(strlen(ShmStatusCodeData->PresentStatusCode[0]) > 0)
+    {
+        memcpy(Buffer + 2, ShmStatusCodeData->PresentStatusCode[0], 6);
+    }
+    */
+    Buffer[1] = ShmStatusCodeData->PresentStatusCode[0][0];
+    Buffer[2] = ShmStatusCodeData->PresentStatusCode[0][1];
+    Buffer[3] = ShmStatusCodeData->PresentStatusCode[0][2];
+    Buffer[4] = ShmStatusCodeData->PresentStatusCode[0][3];
+    Buffer[5] = ShmStatusCodeData->PresentStatusCode[0][4];
+    Buffer[6] = ShmStatusCodeData->PresentStatusCode[0][5];
+    
+    if(( Buffer[1]== 0)&&( Buffer[2]== 2)&&( Buffer[3]== 3)&&( Buffer[4]== 9)&&( Buffer[5]== 7)&&( Buffer[6]== 9))
+    	CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = FALSE;
+   else
+   	CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+   	
+    if (CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency == TRUE)
+    {
+        Buffer[0] = EV_EMERGENCY_STOP;  //2
+    }
+    else
+    {
+        Buffer[0] = EV_NORMAL_STOP;     //1
+    }
+    
+    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_EV_STOP_EVENT, ShmInternalComm->SlaveAddress, 7, Buffer);
+    //system("echo 1000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle"); //for test only
+
+    //system("echo 0 > /sys/class/gpio/gpio89/value");    //for test
+
+    SAVE_SYS_LOG_MSG_CSUCOMM("[Proc_EVStopRes] Sending STOP Command to CSU");
+
+    CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = FALSE;
+    CSUCOMMDC_TASK_FLAG.Send_EVStopReq = FALSE;
+
+    return nbytes;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_EVSEStopRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_EVSEStopRes(int Fd)
+{
+    if (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown &&
+        EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown)
+    {
+        //The above considtion will let this debug message to print once
+        //even though the CSU sends several continuous stop commands.
+        sprintf(buf_log_csucomm,
+                "[Proc_EVSEStopRes] CSU Requests for STOP (Stop by EVSE: %d)",
+                ShmInternalComm->EVSEStopChargingReq.type);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        //Once the stop command is received by CCS, this CAN message cannot
+        //resume it back to normal state unless the End_Process is completed.
+        if (ShmInternalComm->EVSEStopChargingReq.type == 1)
+        {
+            EVCOMM_SYS_INFO.DC_EVSEStatus = EVSE_Shutdown;
+        }
+        else if (ShmInternalComm->EVSEStopChargingReq.type == 2)
+        {
+            EVCOMM_SYS_INFO.DC_EVSEStatus = EVSE_EmergencyShutdown;
+        }
+        else
+        {
+            EVCOMM_SYS_INFO.DC_EVSEStatus = EVSE_Ready;
+        }
+    }
+
+    CSUCOMMDC_TASK_FLAG.Got_EVSEStopReq = FALSE;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_EVSEStopReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_EVSEStopReq(struct can_frame *frame)
+{
+    ShmInternalComm->EVSEStopChargingReq.type = frame->data[0];
+    memcpy(&ShmInternalComm->EVSEStopChargingReq.alarmcode, &frame->data[1], 6);
+
+    CSUCOMMDC_TASK_FLAG.Got_EVSEStopReq = TRUE;
+}
+
+/*===========================================================================
+FUNCTION: Check_DwnldImgParameter
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+        1. Parameter Validation (0: invalid, 1: valid)
+        2. final_canmsg_size
+        3. total_can_packets
+GLOBAL VARIABLES:
+=============================================================================*/
+int Check_DwnldImgParameter()
+{
+    int image_size = 0; //unit: byte
+    int total_can_packets = 0;
+    unsigned char block_quantity = 0;
+    unsigned char block_size_KByte = 0;   //unit: Kbytes
+    unsigned char final_canmsg_size = 0;    //1~7
+
+    image_size = ShmInternalComm->DownloadImageInfo.image_size;
+    block_quantity = ShmInternalComm->DownloadImageInfo.block_quantity;
+    block_size_KByte = ShmInternalComm->DownloadImageInfo.block_size_KByte;
+
+    //Step 1: Caculate final_canmsg_size and total_can_packets
+    final_canmsg_size = image_size % 8; //8: max of CAN bus payload
+    total_can_packets = image_size / 8;
+
+    if (final_canmsg_size != 0)
+    {
+        total_can_packets += 1;
+    }
+
+    ShmInternalComm->DownloadImageInfo.final_canmsg_size = final_canmsg_size;
+    ShmInternalComm->DownloadImageInfo.total_can_packets = total_can_packets;
+
+    DEBUG_PRINTF_CSUCOMM_DETAIL("[Check_DwnldImgParameter]\n");
+    DEBUG_PRINTF_CSUCOMM_DETAIL("\t - final_canmsg_size = %d (DEC)\n\
+                                 \t - total_can_packets = %d (DEC)\n\n",
+                                 ShmInternalComm->DownloadImageInfo.final_canmsg_size,
+                                 ShmInternalComm->DownloadImageInfo.total_can_packets
+                               );
+
+
+    //Step 2: Check Parameter Validation
+    //if ((block_quantity * block_size_KByte * 1024) > image_size)
+    //[CAUTION] To increase type ID, please modify this condition.
+    if (ShmInternalComm->DownloadImageInfo.type <= IMAGE_TYPE_USER_CONFIGURATION)
+    {
+        return TRUE;
+    }
+    else
+    {
+        sprintf(buf_log_csucomm,
+                "[Check_DwnldImgParameter] type(%d) is not allowed, yet.",
+                ShmInternalComm->DownloadImageInfo.type
+               );
+        SAVE_SYS_LOG_MSG_CSUCOMM("buf_log_csucomm");
+        return FALSE;
+    }
+}
+
+/*===========================================================================
+FUNCTION: Proc_DownloadImageRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_DownloadImageRes(int Fd)
+{
+    int nbytes;
+    unsigned char Buffer[1];
+    memset(Buffer, 0, sizeof(Buffer));
+
+    if (ShmInternalComm->DownloadImageInfo.active == TRUE)
+    {
+        //[VITAL] Closing unneccesary task to supoort rapid CAN data receving..
+        SAVE_SYS_LOG_MSG_CSUCOMM("[Proc_DownloadImageRes] closing SeccComm...");
+        system("killall SeccComm");
+
+        system("rm -f /Storage/tmp");
+        system("touch /Storage/tmp");
+
+        #if (FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == DISABLE)
+        {
+            SAVE_SYS_LOG_MSG_CSUCOMM("[Proc_DownloadImageRes]sync...");
+            system("sync");
+        }
+        #endif
+
+        Buffer[0] = 1; //Accept
+    }
+    else
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("[Proc_DownloadImageRes] Fail");
+        Buffer[0] = 0; //Reject
+        //[To-be-implemented][TBD] Sending alarm code or not?
+    }
+
+    DEBUG_PRINTF_CSUCOMM_DETAIL("[Proc_DownloadImageRes] %d (DEC)\n", Buffer[0]);
+
+    CSUCOMMDC_TASK_FLAG.Got_DownloadImageReq = FALSE;
+
+    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_DOWNLOAD_REQUEST, ShmInternalComm->SlaveAddress, 1, Buffer);
+    return nbytes;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_DownloadImageReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_DownloadImageReq(struct can_frame *frame)
+{
+    if (Check_V2G_Flow_Status() == IDLE)
+    {
+        ShmInternalComm->DownloadImageInfo.type = frame->data[0];
+        memcpy(&ShmInternalComm->DownloadImageInfo.image_size, &frame->data[1], 4);
+        ShmInternalComm->DownloadImageInfo.image_size_received = 0;
+        ShmInternalComm->DownloadImageInfo.block_quantity = frame->data[5];
+        ShmInternalComm->DownloadImageInfo.block_sequence_number = 0;
+        ShmInternalComm->DownloadImageInfo.block_size_KByte = frame->data[6];
+        ShmInternalComm->DownloadImageInfo.block_sequence_number = 0;
+        ShmInternalComm->DownloadImageInfo.block_checksum = 0;
+        ShmInternalComm->DownloadImageInfo.total_can_packets = 0;
+        ShmInternalComm->DownloadImageInfo.image_rx_cnt = 0;
+        ShmInternalComm->DownloadImageInfo.downlaod_percentage = 0;
+        ShmInternalComm->DownloadImageInfo.downlaod_percentage_pre = 0;
+
+        ShmInternalComm->DownloadImageInfo.active = FALSE;
+        if (ShmInternalComm->DownloadImageInfo.image_size == 0)
+        {
+            SAVE_SYS_LOG_MSG_CSUCOMM("[Proc_DownloadImageReq][Warning] image_size cannot be 0\n");
+        }
+        else if (ShmInternalComm->DownloadImageInfo.block_quantity == 0)
+        {
+            SAVE_SYS_LOG_MSG_CSUCOMM("[Proc_DownloadImageReq][Warning] block_quantity cannot be 0\n");
+        }
+        else if (ShmInternalComm->DownloadImageInfo.block_size_KByte == 0)
+        {
+            SAVE_SYS_LOG_MSG_CSUCOMM("[Proc_DownloadImageReq][Warning] block_size_KByte cannot be 0\n");
+        }
+        else if (Check_DwnldImgParameter() == FALSE)
+        {
+            sprintf(buf_log_csucomm, "[Proc_DownloadImageReq][Warning] nonlogical image_size(%d bytes, DEC), block_quantity(%d, DEC), block_size_KByte(%d, DEC)\n",
+                    ShmInternalComm->DownloadImageInfo.image_size,
+                    ShmInternalComm->DownloadImageInfo.block_quantity,
+                    ShmInternalComm->DownloadImageInfo.block_size_KByte
+                   );
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        }
+        else
+        {
+            ShmInternalComm->DownloadImageInfo.active = TRUE;
+        }
+    }
+    else
+    {
+        ShmInternalComm->DownloadImageInfo.active = FALSE;
+        sprintf(buf_log_csucomm,
+                "[Proc_BlockTransferStartReq] PresentMsgFlowStatus (%d, DEC) is not in IDLE\n",
+                Check_V2G_Flow_Status()
+               );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+    }
+    SAVE_SYS_LOG_MSG_CSUCOMM("[Proc_DownloadImageReq] Got Request from CSU\n");
+    sprintf(buf_log_csucomm, "\t - type = %d (DEC)\n\
+                              \t - image size = %d (DEC, bytes)\n\
+                              \t - block quantity = %d (DEC)\n\
+                              \t - block size = %d (DEC, KBytes)\n\n",
+                              ShmInternalComm->DownloadImageInfo.type,
+                              ShmInternalComm->DownloadImageInfo.image_size,
+                              ShmInternalComm->DownloadImageInfo.block_quantity,
+                              ShmInternalComm->DownloadImageInfo.block_size_KByte
+                             );
+    SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+    CSUCOMMDC_TASK_FLAG.Got_DownloadImageReq = TRUE;
+}
+
+
+
+/*===========================================================================
+FUNCTION: Proc_BlockTransferStartRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_BlockTransferStartRes(int Fd)
+{
+    int nbytes;
+    unsigned char Buffer[1];
+    memset(Buffer, 0, sizeof(Buffer));
+
+    if (ShmInternalComm->DownloadImageInfo.active == TRUE)
+    {
+        Buffer[0] = 1; //Accept
+    }
+    else
+    {
+        fclose(ShmInternalComm->DownloadImageInfo.file);
+        Buffer[0] = 0; //Reject
+        //[To-be-implemented][TBD] Sending alarm code or not?
+    }
+
+    DEBUG_PRINTF_CSUCOMM_DETAIL("[Proc_BlockTransferStartRes] %d (DEC)\n", Buffer[0]);
+
+    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_START_BLOCK_TRANSFER, ShmInternalComm->SlaveAddress, 1, Buffer);
+    CSUCOMMDC_TASK_FLAG.Got_BlockTransferStartReq = FALSE;
+    return nbytes;
+}
+
+/*===========================================================================
+FUNCTION: Proc_BlockTransferStartReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_BlockTransferStartReq(struct can_frame *frame)
+{
+    if (Check_V2G_Flow_Status() == IDLE)
+    {
+        ShmInternalComm->DownloadImageInfo.block_sequence_number += 1;  //1~255
+
+        //Check the valid range (1 ~ 255)
+        if (frame->data[0] >= 1 &&
+            frame->data[0] <= 255 &&
+            ShmInternalComm->DownloadImageInfo.block_sequence_number == frame->data[0] &&
+            ShmInternalComm->DownloadImageInfo.block_sequence_number >= 1 &&
+            ShmInternalComm->DownloadImageInfo.block_sequence_number <= 255
+           )
+        {
+            ShmInternalComm->DownloadImageInfo.active = TRUE;
+        }
+        else
+        {
+            sprintf(buf_log_csucomm, "[Proc_BlockTransferStartReq][Warning] Unexpected block_sequence_number (%d, %d, DEC)\n",
+                     frame->data[0],
+                     ShmInternalComm->DownloadImageInfo.block_sequence_number
+                   );
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+            ShmInternalComm->DownloadImageInfo.active = FALSE;
+        }
+
+        ShmInternalComm->DownloadImageInfo.block_checksum = frame->data[1];
+    }
+    else
+    {
+        ShmInternalComm->DownloadImageInfo.active = FALSE;
+        sprintf(buf_log_csucomm,
+                "[Proc_BlockTransferStartReq] PresentMsgFlowStatus (%d, DEC) is not in IDLE\n",
+                Check_V2G_Flow_Status()
+               );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+    }
+    DEBUG_PRINTF_CSUCOMM_DETAIL("\n[Proc_BlockTransferStartReq] Got Request from CSU\n");
+    sprintf(buf_log_csucomm, "\t - block_sequence_number = %d (DEC)\n\
+                              \t - block_checksum = %02X (HEX, bytes)\n\n",
+                              ShmInternalComm->DownloadImageInfo.block_sequence_number,
+                              ShmInternalComm->DownloadImageInfo.block_checksum
+            );
+    DEBUG_PRINTF_CSUCOMM_DETAIL(buf_log_csucomm);
+
+    CSUCOMMDC_TASK_FLAG.Got_BlockTransferStartReq = TRUE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_DataTransferRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_DataTransferRes(int Fd)
+{
+    //DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][Proc_DataTransferRes]\n");
+
+    //[To-be-implemented] Check Block Checksum, if fail, we should use this response to ask CSU to resend this block again.
+
+    CSUCOMMDC_TASK_FLAG.Got_DataTransferReq = FALSE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_DataTransferReq
+DESCRIPTION:
+PRE-CONDITION:
+        1. The time interval between each CAN data should be 3ms at least to
+           avoid data loss.
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_DataTransferReq(struct can_frame *frame)
+{
+    if (Check_V2G_Flow_Status() == IDLE &&
+        ShmInternalComm->DownloadImageInfo.active == 1)
+    {
+        if ((ShmInternalComm->DownloadImageInfo.image_rx_cnt + frame->can_dlc) <= ShmInternalComm->DownloadImageInfo.image_size)
+        {
+            //Saving Data
+            FILE *file;
+            file = fopen("/Storage/tmp", "ab+");
+
+            int rlen = 0;
+            DEBUG_PRINTF_CSUCOMM_DETAIL("[Proc_DataTransferReq] saving data... (%d bytes, DEC)\n", frame->can_dlc);
+            //rlen = fwrite(&frame->data[0], sizeof(unsigned char), frame->can_dlc, ShmInternalComm->DownloadImageInfo.file);
+            rlen = fwrite(&frame->data[0], sizeof(unsigned char), frame->can_dlc, file);
+
+            if (rlen == frame->can_dlc)
+            {
+                fflush(ShmInternalComm->DownloadImageInfo.file);
+                DEBUG_PRINTF_CSUCOMM_DETAIL("[Proc_DataTransferReq] fwrite: OK (rlen = %d)\n", rlen);
+                ShmInternalComm->DownloadImageInfo.image_rx_cnt += frame->can_dlc;
+            }
+            else
+            {
+                DEBUG_PRINTF_CSUCOMM_DETAIL("[Proc_DataTransferReq] fwrite: FAIL (rlen = %d)\n", rlen);
+                ShmInternalComm->DownloadImageInfo.active = FALSE;
+            }
+            fflush(file);
+            fclose(file);
+            DEBUG_PRINTF_CSUCOMM_DETAIL("\n", ShmInternalComm->DownloadImageInfo.image_rx_cnt);
+
+            //Caculating the Download Percentage
+            ShmInternalComm->DownloadImageInfo.downlaod_percentage = (ShmInternalComm->DownloadImageInfo.image_rx_cnt*100)/ShmInternalComm->DownloadImageInfo.image_size;
+            if (ShmInternalComm->DownloadImageInfo.downlaod_percentage != ShmInternalComm->DownloadImageInfo.downlaod_percentage_pre)
+            {
+                sprintf(buf_log_csucomm,
+                        "[Proc_DataTransferReq] rx: %d\% (%d of %d bytes)\n", //showing the downlaod percentage
+                        ShmInternalComm->DownloadImageInfo.downlaod_percentage,
+                        ShmInternalComm->DownloadImageInfo.image_rx_cnt,
+                        ShmInternalComm->DownloadImageInfo.image_size
+                       );
+                SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+                ShmInternalComm->DownloadImageInfo.downlaod_percentage_pre = ShmInternalComm->DownloadImageInfo.downlaod_percentage;
+            }
+        }
+        else
+        {
+            ShmInternalComm->DownloadImageInfo.active = FALSE;
+            SAVE_SYS_LOG_MSG_CSUCOMM("[Proc_BlockTransferStartReq] unexpected extra packets\n");
+        }
+    }
+    else
+    {
+        ShmInternalComm->DownloadImageInfo.active = FALSE;
+        sprintf(buf_log_csucomm, "[Proc_BlockTransferStartReq] PresentMsgFlowStatus (%d, DEC) \
+                 is not in IDLE or active flag (%d, DEC) is canceled\n",
+                Check_V2G_Flow_Status(),
+                ShmInternalComm->DownloadImageInfo.active
+               );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        //Sending Stop Request to CSU to abort Data Transfer
+        //CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        //[To-be-implemented] Adding corresponding alarm code
+
+    }
+    CSUCOMMDC_TASK_FLAG.Got_DataTransferReq = TRUE;
+}
+
+/*===========================================================================
+FUNCTION: Proc_DownloadFinishRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_DownloadFinishRes(int Fd)
+{
+    int nbytes;
+    unsigned char Buffer[1];
+    memset(Buffer, 0, sizeof(Buffer));
+
+    //Step 1: Protection for receiving Firmware Update Req in non-IDLE mode
+    if (Check_V2G_Flow_Status() != IDLE)
+    {
+        if (CSUCOMMDC_TASK_FLAG.FW_Update_Task_inused == FALSE)
+        {
+            SAVE_SYS_LOG_MSG_CSUCOMM("[Warning]FW update Req: ignored (only for idle mode)");
+            Buffer[0] = FAIL;
+            nbytes = CAN_Tx_MSG(Fd, CAN_CMD_DOWNLOAD_FINISH, ShmInternalComm->SlaveAddress, 1, Buffer);
+            if (nbytes > 0)
+            {
+                sprintf(buf_log_csucomm, "[Proc_DownloadFinishRes]Tx:ok(%d)", Buffer[0]);
+                SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+            }
+            else
+            {
+                sprintf(buf_log_csucomm, "[Proc_DownloadFinishRes]Tx:fail(%d)", nbytes);
+                SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+            }
+            return FAIL;
+        }
+        else if (CSUCOMMDC_TASK_FLAG.FW_Update_Task_inused == TRUE)
+        {
+            SAVE_SYS_LOG_MSG_CSUCOMM("[Warning]FW update Req: ignored (in used, already)");
+            //not sending response message, since it stands for end of update process.
+            return FAIL;
+        }
+        else
+        {
+            sprintf(buf_log_csucomm,
+                    "[Warning]unexpected FW_Update_Task_inused value(%d)",
+                    CSUCOMMDC_TASK_FLAG.FW_Update_Task_inused
+                    );
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+            return FAIL;
+        }
+    }
+
+    //Step 2: Execute the FW update task
+    if (CSUCOMMDC_TASK_FLAG.FW_Update_Task_inused == FALSE)
+    {
+        CSUCOMMDC_TASK_FLAG.FW_Update_Task_inused = TRUE;
+        //[VITAL] Closing unneccesary task to supoort rapid CAN data receving..
+        SAVE_SYS_LOG_MSG_CSUCOMM("[Proc_DownloadFinishRes] closing SeccComm...");
+        system("killall SeccComm");
+        system("cd /root;./FWUpdate -w &");
+    }
+
+    //Step 3:Sending Response message with result once FW update is done.
+    if (CSUCOMMDC_TASK_FLAG.FW_Update_Done == TRUE)
+    {
+        if (CSUCOMMDC_TASK_FLAG.FW_Update_result == PASS)
+        {
+            Buffer[0] = PASS;
+        }
+        else
+        {
+            Buffer[0] = FAIL;
+        }
+        nbytes = CAN_Tx_MSG(Fd, CAN_CMD_DOWNLOAD_FINISH, ShmInternalComm->SlaveAddress, 1, Buffer);
+        if (nbytes > 0)
+        {
+            sprintf(buf_log_csucomm, "[Proc_DownloadFinishRes]Tx:ok(%d)", Buffer[0]);
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        }
+        else
+        {
+            sprintf(buf_log_csucomm, "[Proc_DownloadFinishRes]Tx:fail(%d)", nbytes);
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        }
+        sleep(2);
+        //system("killall FWUpdate");
+        CSUCOMMDC_TASK_FLAG.Got_DownloadFinishReq = FALSE;
+        return nbytes;
+    }
+}
+
+/*===========================================================================
+FUNCTION: Proc_DownloadFinishReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Proc_DownloadFinishReq(struct can_frame *frame)
+{
+    CSUCOMMDC_TASK_FLAG.Got_DownloadFinishReq = TRUE;
+}
+
+
+/*===========================================================================
+FUNCTION: PRINT_CAN_FRAME
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_CAN_FRAME(struct can_frame *frame)
+{
+    if (frame->can_dlc != 0)
+    {
+        int i = 0;
+        DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm] Got CAN Message: \n\
+                \t - Length: %d (Bytes, DEC)\n\
+                \t - ID: %08X\n\
+                \t - Payload: ",
+                frame->can_dlc,
+                frame->can_id
+                );
+        for (i = 0; i< frame->can_dlc; i++)
+        {
+            DEBUG_PRINTF_CSUCOMM_DETAIL("%02X ", frame->data[i]);
+        }
+        DEBUG_PRINTF_CSUCOMM_DETAIL("\n");
+    }
+}
+
+/*===========================================================================
+FUNCTION: CANRxTimeoutDetector
+DESCRIPTION:
+    1. fork1
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int CANRxTimeoutHandler()
+{
+    #if (CAN_RX_TIMEOUT_MECHANISM == ENABLE)
+    //#if 1
+    if (CSUCOMMDC_TASK_FLAG.matched == TRUE &&
+        CSUCOMMDC_TASK_FLAG.CAN_Rx_Timeout == FALSE)
+    {
+        long int time_diff = 0;
+        ftime(&ShmInternalComm->CAN_Rx_Timer_End);
+        time_diff = DiffTimeb_CsuComm_fork1(ShmInternalComm->CAN_Rx_Timer_Start, ShmInternalComm->CAN_Rx_Timer_End);
+
+        if(time_diff >= CSUCOMM_CAN_RX_TIMEOUT)   //5 sec
+        {
+            sprintf(buf_log_csucomm_fork1,
+                    "[fork1][Rx]CAN timeout(%ld of %dms) => reboot",
+                    time_diff,
+                    CSUCOMM_CAN_RX_TIMEOUT
+                   );
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm_fork1);
+
+            //Reboot the CCS Board
+            //Update_ShmStatusCode();
+            //CCS module communication fail (012248)
+            ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+            ShmStatusCodeData->PresentStatusCode[0][1] = 1;
+            ShmStatusCodeData->PresentStatusCode[0][2] = 2;
+            ShmStatusCodeData->PresentStatusCode[0][3] = 2;
+            ShmStatusCodeData->PresentStatusCode[0][4] = 4;
+            ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+            CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+            CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+            CSUCOMMDC_TASK_FLAG.CAN_Rx_Timeout = TRUE;
+            Reboot_Process();
+        }
+    }
+    #endif
+}
+
+/*===========================================================================
+FUNCTION: FWUpdateRebootDetector
+DESCRIPTION:
+    1. fork2
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+/*int FWUpdateRebootHandler()
+{
+    if (CSUCOMMDC_TASK_FLAG.FW_Update_Done == TRUE &&
+        CSUCOMMDC_TASK_FLAG.Got_DownloadFinishReq == FALSE &&
+        CSUCOMMDC_TASK_FLAG.FW_Update_Reboot_inused == FALSE)   //wait for CAN Res msg to be sent.
+    {
+        CSUCOMMDC_TASK_FLAG.FW_Update_Reboot_inused = TRUE;
+        sprintf(buf_log_csucomm_fork1,
+                "[fork1]FW Update Done(%d) => End_Process",
+                CSUCOMMDC_TASK_FLAG.Got_DownloadFinishReq);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_csucomm_fork1);
+        Reboot_Process();
+    }
+}*/
+
+/*===========================================================================
+FUNCTION: Error_Monitor_CsuComm
+DESCRIPTION:
+    1. fork1
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Error_Monitor_CsuComm()
+{
+    pid_t tmp = 0;
+
+    if(PID_CsuComm_Error_Monitor_Task == 0)
+    {
+        tmp = fork();   //fork1
+
+        if(tmp > 0)
+        {
+            PID_CsuComm_Error_Monitor_Task = tmp;
+
+            sprintf(buf_log_csucomm_fork1,
+                    "[fork2][Error_Monitor]created(%d)",
+                    PID_CsuComm_Error_Monitor_Task);
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm_fork1);
+
+            #if 0
+            unsigned char buf[64];
+            memset(buf, 0, sizeof(buf));
+            sprintf(buf, "renice -20 -p %d", tmp);
+            system(buf);
+            #endif
+
+            return;
+        }
+    }
+
+    while(1)
+    {
+        //CAN comm. Timeout Detector
+        CANRxTimeoutHandler();
+
+        //Check for FW Update Reboot Request
+       // FWUpdateRebootHandler();
+    }
+}
+
+
+/*===========================================================================
+FUNCTION: CAN_Rx
+DESCRIPTION:
+        1. fork2
+        2. Receiving Task (indivitual process)
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void CAN_Rx(int fd)
+{
+    pid_t tmp = 0;
+    struct can_frame frame;
+    int nbytes;
+
+    if(PID_CAN_Rx_Task == 0)
+    {
+        tmp = fork();   //fork2
+
+        if(tmp > 0)
+        {
+            PID_CAN_Rx_Task = tmp;
+
+            sprintf(buf_log_csucomm_fork2,
+                    "[fork2][Error_Monitor]created(%d)",
+                    PID_CAN_Rx_Task);
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm_fork2);
+
+            #if 0
+            unsigned char buf[64];
+            memset(buf, 0, sizeof(buf));
+            sprintf(buf, "renice -20 -p %d", tmp);
+            system(buf);
+            #endif
+
+            return;
+        }
+    }
+
+    ftime(&ShmInternalComm->CAN_Rx_Timer_Start);    //ID is matched
+
+    while(1)    //Process after Matched
+    {
+        memset(&frame, 0, sizeof(struct can_frame));
+        nbytes = read(fd, &frame, sizeof(struct can_frame));
+
+        //For Test (Print Rx Messages)
+        //PRINT_CAN_FRAME(&frame);
+
+        //Filtering for legal CAN Rx Message
+        if((frame.can_id == 0) ||                   //Null CAN ID
+           ((frame.can_id & 0x08000000) == 1) ||    //Direction
+           (((frame.can_id & 0x000000FF) != ShmInternalComm->SlaveAddress) && ((frame.can_id & 0x000000FF) != 0)))  //allow its SlaveAddress and Broadcasting Packetes (ID = 0x00)
+        {
+            continue;
+        }
+
+        //--------------------- Legal CAN Rx Message Zone ----------------------
+        //CAN comm. Timeout Detector
+        ftime(&ShmInternalComm->CAN_Rx_Timer_Start);
+
+        //Extracting and Parsing Legal CAN Message ID (1-Byte)
+        switch(frame.can_id & 0x0000FF00)
+        {
+            case CAN_CMD_ADDRESS_ASSIGN:            //0x00000200
+            {
+                Proc_AddressAssignReq(&frame);
+                break;
+            }
+
+            case CAN_CMD_GET_FW_VERSION:            //0x00000400
+            {
+                Proc_GetFirmwareVersionReq(&frame);
+                break;
+            }
+
+            case CAN_CMD_GET_HW_VERSION:            //0x00000500
+            {
+                Proc_HardwareVersionReq(&frame);
+                break;
+            }
+
+            case CAN_CMD_CHARGING_PERMISSION:       //0x00000600
+            {
+                Proc_ChargingPermissionReq(&frame);
+                break;
+            }
+
+            case CAN_CMD_EVSE_OUTPUT_STATUS_ANNOUNCEMENT:      //0x00000700
+            {
+                Proc_EVSEOutputStatusUpdateReq(&frame);
+                break;
+            }
+
+            case CAN_CMD_EVSE_CAPACITY_ANNOUNCEMENT:   //0x00000800
+            {
+                Proc_EVSECapacityUpdateReq(&frame);
+                break;
+            }
+
+            case CAN_CMD_GET_EV_TARGET_INFO:    //0x00000900
+            {
+                Proc_GetEVTargetReq(&frame);
+                break;
+            }
+
+            case CAN_CMD_GET_EV_BATTERY_INFO:       //0x00000A00
+            {
+                Proc_GetEVBatteryInfoReq(&frame);
+                break;
+            }
+
+            case CAN_CMD_EVSE_STOP_EVENT:       //0x00000C00
+            {
+                Proc_EVSEStopReq(&frame);
+                break;
+            }
+
+            case CAN_CMD_GET_MISC_INFO:         //0x00000D00
+            {
+                Proc_GetMiscellaneousInfoReq(&frame);
+                break;
+            }
+
+            case CAN_CMD_DOWNLOAD_REQUEST:      //0x00000E00
+            {
+                //Proc_DownloadImageReq(&frame);
+                break;
+            }
+
+            case CAN_CMD_START_BLOCK_TRANSFER:  //0x00000F00
+            {
+                //Proc_BlockTransferStartReq(&frame);
+                break;
+            }
+
+            case CAN_CMD_DATA_TRANSFER:         //0x00001000
+            {
+                //Proc_DataTransferReq(&frame);
+                break;
+            }
+
+            case CAN_CMD_DOWNLOAD_FINISH:       //0x00001100
+            {
+                Proc_DownloadFinishReq(&frame);
+                break;
+            }
+            case CAN_CMD_ISOLATION_STATUS:           //0x00001200
+            {
+                Proc_IsolationStatusAnnounceReq(&frame);
+                break;
+            }
+            case CAN_CMD_CCS_CONNECTOR_INFO:         //0x00001300
+            {
+                Proc_CCSConnectorTypeSetReq(&frame);
+                break;
+            }
+            case CAN_CMD_RTC_INFO:                   //0x00001400
+            {
+                Proc_RTCSetReq(&frame);
+                break;
+            }
+            case CAN_CMD_EVSE_PRECHARGE_INFO:       //0x00001500
+            {
+                Proc_EVSEPrechargeInfoUpdateReq(&frame);
+                break;
+            }
+            case CAN_CMD_EVCCID_REQUEST:
+            {
+                Proc_EVCCIDReq(&frame);
+                break;
+            }
+            default:
+            {
+                sprintf(buf_log_csucomm_fork2,
+                        "[fork2][ERROR]Unexpected CAN Command ID: %d (DEC)",
+                        (frame.can_id & 0x0000FF00));
+                SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm_fork2);
+                break;
+            }
+        }
+    }
+}
+
+
+/*===========================================================================
+FUNCTION: Eth0_PortSetting
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Eth0_PortSetting_Add(unsigned char addr)
+{
+    SAVE_SYS_LOG_MSG_CSUCOMM("[Eth0_PortSetting_Add]start");
+
+    unsigned char cmd[128];
+    if ((addr >= 1) && (addr <= 20))
+    {
+        addr = 20 + addr;
+
+        //Step 0: shutdown eth0
+        #if 0
+        SAVE_SYS_LOG_MSG_CSUCOMM("[Eth0_PortSetting][eth0:0]down");
+        system("/sbin/ifconfig eth0:0 down");
+        sleep(1);
+        #endif
+
+        //Step 1: IP setting
+        sprintf(buf_log_csucomm,
+                "[Eth0_PortSetting_Add][eth0:0]IP >> 192.168.0.%d(up))",
+                addr);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        sprintf(cmd, "/sbin/ifconfig eth0:0 192.168.0.%d netmask 255.255.255.0 up", addr);
+        system(cmd);
+        memset(cmd, 0, sizeof(cmd));
+        sleep(1);
+
+        sprintf(buf_log_csucomm,
+                "[Eth0_PortSetting_Add][eth0:0]done",
+                addr);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        return PASS;
+    }
+    else
+    {
+        sprintf(buf_log_csucomm,
+                "[Eth0_PortSetting_Add][Error]addr(%d) is out of range(1~20)",
+                addr);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        return FAIL;
+    }
+}
+
+/*===========================================================================
+FUNCTION: Reboot_Process
+DESCRIPTION:
+    1. fork1
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Reboot_Process()
+{
+    if (CSUCOMMDC_TASK_FLAG.Reboot_Process_inused == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("[Reboot_Process]entered");
+        CSUCOMMDC_TASK_FLAG.Reboot_Process_inused = TRUE;
+
+        #if (FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == DISABLE)
+        {
+            SAVE_SYS_LOG_MSG_CSUCOMM("[Reboot_Process]sync...");
+            system("sync");
+        }
+        #endif
+        system("sleep 2");
+        system("cd /root;./reboot.sh");
+    }
+}
+
+/*===========================================================================
+FUNCTION: CsuCommAC_GetCcsFirmwareVersion
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int CsuCommAC_GetCcsFirmwareVersion(unsigned char *buf)
+{
+    int i = 0, j = 0, err = PASS, leng = 0;
+    unsigned char str[FIRMWARE_VERSION_LENGTH + 1];
+
+    memset(buf, 0, sizeof(buf));
+    strcpy(str, FIRMWARE_VERSION);
+    leng = FIRMWARE_VERSION_LENGTH + 3;
+
+    if (sizeof(buf) < leng)
+    {
+        SAVE_SYS_LOG_MSG_CSUCOMM("[WARNING][CsuCommAC_GetCcsFirmwareVersion]ver size: too long");
+        leng = sizeof(buf);
+    }
+
+    for(i = 0; i < leng; i++)
+    {
+        if (str[i] != '_')
+        {
+            buf[j] = str[i];
+            j++;
+        }
+    }
+
+    return err;
+}
+
+/*===========================================================================
+FUNCTION: CsuCommAC_Init
+DESCRIPTION:
+    1. Set CCS FW Version
+    
+PRE-CONDITION:
+    1. Share Memory should be initialized in advance.
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+/*int CsuCommAC_Init()
+{
+    int err = PASS;
+
+    CsuCommAC_GetCcsFirmwareVersion(CSUCOMMAC_SHM.CCSLibRev);
+    memset(CSUCOMMAC_SHM.EVCCID, 0, sizeof(CSUCOMMAC_SHM.EVCCID));
+    CSUCOMMAC_SHM.PresentMsgFlowStatus = IDLE;
+    CSUCOMMAC_SHM.ConnectorLockerStatus = FALSE;
+    CSUCOMMAC_SHM.ConnectorTemperature1 = 0;
+    CSUCOMMAC_SHM.ConnectorTemperature2 = 0;
+    CSUCOMMAC_SHM.TotalBatteryCapacity = 0;
+    CSUCOMMAC_SHM.BatteryMaximumVoltage = 0;
+    CSUCOMMAC_SHM.BatteryMaximumCurrent = 0;
+    CSUCOMMAC_SHM.CCSAlarmStatusCode = 0;
+    CSUCOMMAC_SHM.PaymentOption = 0;
+    CSUCOMMAC_SHM.EVSEMaxCurrent = 0;
+    CSUCOMMAC_SHM.EVSEMinCurrent = 0;
+    CSUCOMMAC_SHM.EVOperation = 0;
+    CSUCOMMAC_SHM.EVChargeProgress = 0;
+    CSUCOMMAC_SHM.CpSetPWMDuty = 0;
+    CSUCOMMAC_SHM.CpSetStateE = 0;
+    CSUCOMMAC_SHM.CcsHeartBeat = 0;
+
+    return err;
+}*/
+
+/*===========================================================================
+FUNCTION: CsuCommAC_HeartBeat_Handler
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+/*int CsuCommAC_HeartBeat_Handler()
+{
+    static unsigned int tmp = 0;
+
+    if (tmp == 0)
+    {
+        tmp = time(NULL);
+    }
+    else 
+    {
+        if ((time(NULL) - tmp) >= 1)    //1 sec
+        {
+            CSUCOMMAC_SHM.CcsHeartBeat++;
+            tmp = 0;
+
+            //sprintf(buf_log_csucomm, "[CcsHeartBeat]%d", CSUCOMMAC_SHM.CcsHeartBeat);
+            //SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+            if (CSUCOMMAC_SHM.CcsHeartBeat >= 60)    //timeout: 60 sec
+            {
+                sprintf(buf_log_csucomm, 
+                        "[WARNING]CSU Comm: Fail(%d)", 
+                        CSUCOMMAC_SHM.CcsHeartBeat);
+                SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+                //[To-Do] Reboot or Send Error Code (TBD)
+            }
+        }
+    }
+}*/
+
+/*===========================================================================
+FUNCTION: CsuCommAC_SHM_Rx_Update
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+#ifdef AWCCS
+int CsuCommAC_SHM_Rx_Update()
+{
+	int gun_index=0;
+    //[CAUTION] Re-initializing process is necessary. (to-be implemented)
+   ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus=Check_V2G_Flow_Status();
+   ShmCharger->gun_info[gun_index].acCcsInfo.EVChargeProgress = ShmCcsData->V2GMessage_ISO15118_2014.PowerDeliveryRequest.ChargeProgress;
+   ShmCharger->gun_info[gun_index].acCcsInfo.CpSetPWMDuty=ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].CpDuty;
+    //----------[1] Permission --------
+   // ShmInternalComm->ChargingPermission_new = (unsigned char) CSUCOMMAC_SHM.ChargingPermission;
+    ShmInternalComm->ChargingPermission_new=ShmCharger->gun_info[gun_index].acCcsInfo.ChargingPermission;
+    if (ShmInternalComm->ChargingPermission_new != ShmInternalComm->ChargingPermission)
+    {
+        sprintf(buf_log_csucomm, "Permission: %d >> %d",
+                ShmInternalComm->ChargingPermission,
+                ShmInternalComm->ChargingPermission_new
+               );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->ChargingPermission_pre = ShmInternalComm->ChargingPermission;
+        ShmInternalComm->ChargingPermission = ShmInternalComm->ChargingPermission_new;
+    }
+
+	#if 1
+    // -------- [2] CpPresentPWMDuty --------
+    ShmInternalComm->AC_CpPresentPWMDuty = ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current;       //unit: 1 sec.
+    if (ShmInternalComm->AC_CpPresentPWMDuty_pre != ShmInternalComm->AC_CpPresentPWMDuty)
+    {
+        sprintf(buf_log_csucomm, "CP Duty(real): %d >> %d (1\%)",
+                ShmInternalComm->AC_CpPresentPWMDuty_pre,
+                ShmInternalComm->AC_CpPresentPWMDuty
+                );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AC_CpPresentPWMDuty_pre = ShmInternalComm->AC_CpPresentPWMDuty;
+    }
+	#endif
+	
+    // -------- [3] CpPresentState --------
+    //ShmInternalComm->AC_CpPresentState = CSUCOMMAC_SHM.CpPresentState;       //unit: 1 sec.
+    ShmInternalComm->AC_CpPresentState=ShmCharger->gun_info[gun_index].acCcsInfo.CpPresentState;
+    if (ShmInternalComm->AC_CpPresentState_pre != ShmInternalComm->AC_CpPresentState)
+    {
+        sprintf(buf_log_csucomm, "CP State: %d >> %d",
+                ShmInternalComm->AC_CpPresentState_pre,
+                ShmInternalComm->AC_CpPresentState
+                );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AC_CpPresentState_pre = ShmInternalComm->AC_CpPresentState;
+    }
+
+    #if 0
+    // -------- [4] ChargingRemainTime --------
+    ShmInternalComm->AC_ChargingRemainTime = CSUCOMMAC_SHM.ChargingRemainTime;       //unit: 1 sec.
+    if (ShmInternalComm->AC_ChargingRemainTime_pre != ShmInternalComm->AC_ChargingRemainTime)
+    {
+        sprintf(buf_log_csucomm, "ChargingRemainTime: %d >> %d (1 sec)",
+                ShmInternalComm->AC_ChargingRemainTime_pre,
+                ShmInternalComm->AC_ChargingRemainTime
+                );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AC_ChargingRemainTime_pre = ShmInternalComm->AC_ChargingRemainTime;
+    }
+	#endif
+    // -------- [5] CSUAlarmStatusCode --------
+    //ShmInternalComm->AC_CSUAlarmStatusCode = CSUCOMMAC_SHM.CSUAlarmStatusCode;
+   ShmInternalComm->AC_CSUAlarmStatusCode =  ShmCharger->gun_info[gun_index].acCcsInfo.CSUAlarmStatusCode;
+    if (ShmInternalComm->AC_CSUAlarmStatusCode_pre != ShmInternalComm->AC_CSUAlarmStatusCode)
+    {
+        sprintf(buf_log_csucomm, "CSUAlarmStatusCode: %X >> %X (1V)",
+                ShmInternalComm->AC_CSUAlarmStatusCode_pre,
+                ShmInternalComm->AC_CSUAlarmStatusCode
+                );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AC_CSUAlarmStatusCode_pre = ShmInternalComm->AC_CSUAlarmStatusCode;
+    }
+
+    // -------- [6] MeterReadingValue --------
+   // ShmInternalComm->AC_MeterReadingValue = CSUCOMMAC_SHM.MeterReadingValue;       //unit: 1WH
+   ShmInternalComm->AC_MeterReadingValue=((float)ShmCharger->gun_info[gun_index].powerConsumptionTotal.power_consumption/10.0);
+  /*  if (ShmInternalComm->AC_MeterReadingValue_pre != ShmInternalComm->AC_MeterReadingValue)
+    {
+        sprintf(buf_log_csucomm, "MeterReadingValue(Power): %.02f >> %.02f (1V)",
+                ShmInternalComm->AC_MeterReadingValue_pre,
+                ShmInternalComm->AC_MeterReadingValue
+                );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AC_MeterReadingValue_pre = ShmInternalComm->AC_MeterReadingValue;
+    }*/
+
+    // -------- [7] CpPositiveVoltage --------
+    //ShmInternalComm->AC_CpPositiveVoltage = CSUCOMMAC_SHM.CpPositiveVoltage;       //unit: 1V
+    ShmInternalComm->AC_CpPositiveVoltage=ShmCharger->gun_info[gun_index].acCcsInfo.CpPositiveVoltage;
+       //the modification message will be logged via Check_CP_State_Update_fork1() in SeccComm task.
+    if (abs(ShmInternalComm->AC_CpPositiveVoltage_pre - ShmInternalComm->AC_CpPositiveVoltage)>=0.5)
+    {
+        sprintf(buf_log_csucomm, "CP_P_V: %.02f >> %.02f (1V)",
+                ShmInternalComm->AC_CpPositiveVoltage_pre,
+                ShmInternalComm->AC_CpPositiveVoltage
+                );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AC_CpPositiveVoltage_pre = ShmInternalComm->AC_CpPositiveVoltage;
+    }
+
+
+    // -------- [8] CpNegativeVoltage --------
+    //ShmInternalComm->AC_CpNegativeVoltage = CSUCOMMAC_SHM.CpNegativeVoltage;       //unit: 1V
+    ShmInternalComm->AC_CpNegativeVoltage = ShmCharger->gun_info[gun_index].acCcsInfo.CpNegativeVoltage;   //unit: 1V
+    if (abs(ShmInternalComm->AC_CpNegativeVoltage_pre - ShmInternalComm->AC_CpNegativeVoltage>=0.5))
+    {
+        sprintf(buf_log_csucomm, "CP_N_V: - %.02f >> - %.02f (1V)",
+                ShmInternalComm->AC_CpNegativeVoltage_pre,
+                ShmInternalComm->AC_CpNegativeVoltage
+                );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AC_CpNegativeVoltage_pre = ShmInternalComm->AC_CpNegativeVoltage;
+    }
+
+    // -------- [9] I_now: EVSEPresentCurrent[3] --------
+   // memcpy(ShmInternalComm->AC_EVSEPresentCurrent, CSUCOMMAC_SHM.EVSEPresentCurrent, 3);         //unit: 1A
+    //EVCOMM_SYS_INFO.PresentChargingCurrent = ShmInternalComm->AC_EVSEPresentCurrent[0];   //unit: 1A (using phase L)
+    //ShmInternalComm->PresentChargingCurrent = (int)(ShmInternalComm->AC_EVSEPresentCurrent[0] * 10); //unit: 0.1A
+    EVCOMM_SYS_INFO.PresentChargingCurrent = (float)ShmCharger->gun_info[gun_index].outputCurrent.L1N_L12[0];   //unit: 1A (using phase L)
+    ShmInternalComm->PresentChargingCurrent = (float)ShmCharger->gun_info[gun_index].outputCurrent.L1N_L12[0] * 10;
+    ShmInternalComm->AC_EVSEPresentCurrent[0] = (float)ShmCharger->gun_info[gun_index].outputCurrent.L1N_L12[0]; //L1
+    ShmInternalComm->AC_EVSEPresentCurrent[1] = (float)ShmCharger->gun_info[gun_index].outputCurrent.L2N_L23[0]; //L2
+    ShmInternalComm->AC_EVSEPresentCurrent[2] = (float)ShmCharger->gun_info[gun_index].outputCurrent.L3N_L31[0]; //L3
+    if ((ShmInternalComm->AC_EVSEPresentCurrent[0] != ShmInternalComm->AC_EVSEPresentCurrent[0]) ||
+        (ShmInternalComm->AC_EVSEPresentCurrent[1] != ShmInternalComm->AC_EVSEPresentCurrent[1]) ||
+        (ShmInternalComm->AC_EVSEPresentCurrent[2] != ShmInternalComm->AC_EVSEPresentCurrent[2])
+       )
+    {
+        if ((abs(ShmInternalComm->AC_EVSEPresentCurrent_pre[0] - ShmInternalComm->AC_EVSEPresentCurrent[0]) > 10) || //10/;1A
+            (abs(ShmInternalComm->AC_EVSEPresentCurrent_pre[1] - ShmInternalComm->AC_EVSEPresentCurrent[1]) > 10) || //10/;1A
+            (abs(ShmInternalComm->AC_EVSEPresentCurrent_pre[2] - ShmInternalComm->AC_EVSEPresentCurrent[2]) > 10)    //10/;1A
+           )
+        {
+            sprintf(buf_log_csucomm, "I_now(EVSE): (%.02f,%.02f,%.02f) >> (%.02f,%.02f,%.02f) (1A)",
+                    ShmInternalComm->AC_EVSEPresentCurrent_pre[0],
+                    ShmInternalComm->AC_EVSEPresentCurrent_pre[1],
+                    ShmInternalComm->AC_EVSEPresentCurrent_pre[2],
+                    ShmInternalComm->AC_EVSEPresentCurrent[0],
+                    ShmInternalComm->AC_EVSEPresentCurrent[1],
+                    ShmInternalComm->AC_EVSEPresentCurrent[2]
+                   );
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        }
+
+        ShmInternalComm->PresentChargingCurrent_pre = ShmInternalComm->PresentChargingCurrent;
+        memcpy(ShmInternalComm->AC_EVSEPresentCurrent_pre, ShmInternalComm->AC_EVSEPresentCurrent, sizeof(ShmInternalComm->AC_EVSEPresentCurrent));
+    }
+
+    //-------- [10] OutputRelayStatus --------
+    //ShmInternalComm->AC_OutputRelayStatus = CSUCOMMAC_SHM.OutputRelayStatus;    //bool
+    ShmInternalComm->AC_OutputRelayStatus= ShmCharger->gun_info[gun_index].acCcsInfo.OutputRelayStatus;
+    if (ShmInternalComm->AC_OutputRelayStatus_pre != ShmInternalComm->AC_OutputRelayStatus)
+    {
+        sprintf(buf_log_csucomm, "RelayON: %d >> %d",
+                ShmInternalComm->AC_OutputRelayStatus_pre,
+                ShmInternalComm->AC_OutputRelayStatus
+                );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        ShmInternalComm->AC_OutputRelayStatus_pre = ShmInternalComm->AC_OutputRelayStatus;
+    }
+	
+    // -------- [11] GridVoltage (EVSENominalVoltage) --------
+    //EVCOMM_SYS_INFO.AC_EVSENominalVoltage = CSUCOMMAC_SHM.GridVoltage[0];        //unit: 1V
+    //memcpy(ShmInternalComm->AC_GridVoltage, CSUCOMMAC_SHM.GridVoltage, 3);       //unit: 1V
+    EVCOMM_SYS_INFO.AC_EVSENominalVoltage =  ShmCharger->gun_info[gun_index].acCcsInfo.GridVoltage[0] ;  
+    ShmInternalComm->AC_GridVoltage[0]=ShmCharger->gun_info[gun_index].acCcsInfo.GridVoltage[0];
+	ShmInternalComm->AC_GridVoltage[1]=ShmCharger->gun_info[gun_index].acCcsInfo.GridVoltage[1] ;
+	ShmInternalComm->AC_GridVoltage[2]=ShmCharger->gun_info[gun_index].acCcsInfo.GridVoltage[2] ;
+    if ((abs(ShmInternalComm->AC_GridVoltage_pre[0] - ShmInternalComm->AC_GridVoltage[0])>=10) ||
+        (abs(ShmInternalComm->AC_GridVoltage_pre[0] - ShmInternalComm->AC_GridVoltage[0])>=10) ||
+        (abs(ShmInternalComm->AC_GridVoltage_pre[0] - ShmInternalComm->AC_GridVoltage[0])>=10) 
+       )
+    {
+        sprintf(buf_log_csucomm, "V_grid: (%.02f,%.02f,%.02f) >> (%.02f,%.02f,%.02f) (1V)",
+                ShmInternalComm->AC_GridVoltage_pre[0],
+                ShmInternalComm->AC_GridVoltage_pre[1],
+                ShmInternalComm->AC_GridVoltage_pre[2],
+                ShmInternalComm->AC_GridVoltage[0],
+                ShmInternalComm->AC_GridVoltage[1],
+                ShmInternalComm->AC_GridVoltage[2]
+                );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        memcpy(ShmInternalComm->AC_GridVoltage_pre, ShmInternalComm->AC_GridVoltage, sizeof(ShmInternalComm->AC_GridVoltage));
+    }
+
+    // -------- [12] V_now --------
+    if (ShmInternalComm->AC_OutputRelayStatus == ENABLE)
+    {
+        EVCOMM_SYS_INFO.PresentChargingVoltage = ShmInternalComm->AC_GridVoltage[0]; //unit: 1V (using phase 1)
+        ShmInternalComm->PresentChargingVoltage = (int)(ShmInternalComm->AC_GridVoltage[0] * 10); //unit: 0.1V (using phase 1)
+    }
+    else 
+    {
+        EVCOMM_SYS_INFO.PresentChargingVoltage = 0;
+        ShmInternalComm->PresentChargingVoltage = 0;
+    }
+    
+    if (ShmInternalComm->PresentChargingVoltage_pre != ShmInternalComm->PresentChargingVoltage)
+    {
+        if (abs(ShmInternalComm->PresentChargingVoltage_pre - ShmInternalComm->PresentChargingVoltage) >= 10) //10:1V
+        {
+
+            sprintf(buf_log_csucomm, "V_now(EVSE): %d >> %d (0.1V, DEC)",
+                    ShmInternalComm->PresentChargingVoltage_pre,
+                    ShmInternalComm->PresentChargingVoltage
+                    );
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        }
+        ShmInternalComm->PresentChargingVoltage_pre = ShmInternalComm->PresentChargingVoltage;
+    }
+
+
+    // -------- [13] P_now --------
+    EVCOMM_SYS_INFO.PresentChargingPower = (EVCOMM_SYS_INFO.PresentChargingVoltage * EVCOMM_SYS_INFO.PresentChargingCurrent)/1000;   //1KW
+    ShmInternalComm->PresentChargingPower = (int)(EVCOMM_SYS_INFO.PresentChargingPower * 10); //0.1KW
+    if (ShmInternalComm->PresentChargingPower_pre != ShmInternalComm->PresentChargingPower)
+    {
+        sprintf(buf_log_csucomm, "P_now(EVSE): %d >> %d (0.1KW)",
+                ShmInternalComm->PresentChargingPower_pre,
+                ShmInternalComm->PresentChargingPower);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->PresentChargingPower_pre = ShmInternalComm->PresentChargingPower;
+    }
+
+    // -------- [14] I_max (EVSE)--------
+    //EVCOMM_SYS_INFO.AvailableChargingCurrent = CSUCOMMAC_SHM.EVSEMaxCurrent; //unit: 1A
+    //ShmInternalComm->AvailableChargingCurrent = (int)(CSUCOMMAC_SHM.EVSEMaxCurrent *10); //unit: 0.1A
+    EVCOMM_SYS_INFO.AvailableChargingCurrent = ShmCharger->gun_info[gun_index].targetCurrent;; //unit: 1A
+    ShmInternalComm->AvailableChargingCurrent = (int)(ShmCharger->gun_info[gun_index].targetCurrent*10); //unit: 0.1A
+    ShmInternalComm->AC_EVSEMaxCurrent=ShmCharger->gun_info[gun_index].primaryMcuState.rating_current;
+    if (ShmInternalComm->AvailableChargingCurrent_pre != ShmInternalComm->AvailableChargingCurrent)
+    {
+        sprintf(buf_log_csucomm, "I_max(EVSE): %d >> %d (0.1A)",
+                ShmInternalComm->AvailableChargingCurrent_pre,
+                ShmInternalComm->AvailableChargingCurrent);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AvailableChargingCurrent_pre = ShmInternalComm->AvailableChargingCurrent;
+    }
+	#if 0
+    // -------- [15] I_min (EVSE)--------
+    ShmInternalComm->AC_EVSEMinCurrent = CSUCOMMAC_SHM.EVSEMinCurrent; //unit: 1A
+    if (ShmInternalComm->AC_EVSEMinCurrent_pre != ShmInternalComm->AC_EVSEMinCurrent)
+    {
+        sprintf(buf_log_csucomm, "I_min(EVSE): %.02f >> %.02f (1A)",
+                ShmInternalComm->AC_EVSEMinCurrent_pre,
+                ShmInternalComm->AC_EVSEMinCurrent);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AC_EVSEMinCurrent_pre = ShmInternalComm->AC_EVSEMinCurrent;
+    }
+	
+    // -------- [16] V_max --------
+    //EVCOMM_SYS_INFO.MaximumChargingVoltage = CSUCOMMAC_SHM.GridVoltage[0]; //unit: 1V (using phase 1)
+    //ShmInternalComm->MaximumChargingVoltage = (int)(CSUCOMMAC_SHM.GridVoltage[0] * 10); //unit: 0.1V (using phase 1)
+    EVCOMM_SYS_INFO.MaximumChargingVoltage =ShmCharger->gun_info[gun_index].acCcsInfo.GridVoltage[0]; //unit: 1V (using phase 1)
+    ShmInternalComm->MaximumChargingVoltage = (int)(ShmCharger->gun_info[gun_index].acCcsInfo.GridVoltage[0]* 10); //unit: 0.1V (using phase 1)
+    if (ShmInternalComm->MaximumChargingVoltage_pre != ShmInternalComm->MaximumChargingVoltage)
+    {
+        sprintf(buf_log_csucomm, "V_max(EVSE): %d >> %d (0.1V, DEC)",
+                ShmInternalComm->MaximumChargingVoltage_pre,
+                ShmInternalComm->MaximumChargingVoltage
+              );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->MaximumChargingVoltage_pre = ShmInternalComm->MaximumChargingVoltage;
+    }
+	
+    // -------- [17] P_max --------
+    ShmInternalComm->AC_AvailableChargingPower = CSUCOMMAC_SHM.AvailableChargingPower; //unit: 1KW
+    EVCOMM_SYS_INFO.AvailableChargingPower = ShmInternalComm->AC_AvailableChargingPower;   //1KW
+    ShmInternalComm->AvailableChargingPower = (int)(ShmInternalComm->AC_AvailableChargingPower * 10);  //unit: 0.1KW
+    if (ShmInternalComm->AvailableChargingPower_pre != ShmInternalComm->AvailableChargingPower)
+    {
+        sprintf(buf_log_csucomm, "P_max(EVSE): %d >> %d (0.1KW)",
+                ShmInternalComm->AvailableChargingPower_pre,
+                ShmInternalComm->AvailableChargingPower);
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AvailableChargingPower_pre = ShmInternalComm->AvailableChargingPower;
+    }
+	
+    // -------- [18] EVSEID[40] --------
+    memcpy(ShmInternalComm->AC_EVSEID, CSUCOMMAC_SHM.EVSEID, 40);
+    if (Array_Compare_Identity(ShmInternalComm->AC_EVSEID, CSUCOMMAC_SHM.EVSEID, 40) == FALSE)
+    {
+        sprintf(buf_log_csucomm, "EVSEID: [%02X %02X %02X %02X %02X %02X...] >> [%02X %02X %02X %02X %02X %02X...]",
+                ShmInternalComm->AC_EVSEID_pre[0],
+                ShmInternalComm->AC_EVSEID_pre[1],
+                ShmInternalComm->AC_EVSEID_pre[2],
+                ShmInternalComm->AC_EVSEID_pre[3],
+                ShmInternalComm->AC_EVSEID_pre[4],
+                ShmInternalComm->AC_EVSEID_pre[5],
+                ShmInternalComm->AC_EVSEID[0],
+                ShmInternalComm->AC_EVSEID[1],
+                ShmInternalComm->AC_EVSEID[2],
+                ShmInternalComm->AC_EVSEID[3],
+                ShmInternalComm->AC_EVSEID[4],
+                ShmInternalComm->AC_EVSEID[5]
+                );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        memcpy(ShmInternalComm->AC_EVSEID_pre, ShmInternalComm->AC_EVSEID, 40);
+    }
+	#endif
+	
+    // -------- [19] MeterID[32] --------
+    if(strlen(ShmInternalComm->AC_MeterID)<=1)
+    {	
+	  //  memcpy(ShmInternalComm->AC_MeterID, CSUCOMMAC_SHM.MeterID, 32);
+	    memset(ShmInternalComm->AC_MeterID, 0, sizeof(ShmInternalComm->AC_MeterID));
+	    sprintf(ShmInternalComm->AC_MeterID,"%s_%s",ShmCharger->evseId.model_name,ShmCharger->evseId.serial_number);
+	   /* if (Array_Compare_Identity(ShmInternalComm->AC_MeterID, CSUCOMMAC_SHM.MeterID, 32) == FALSE)
+	    {
+	        sprintf(buf_log_csucomm, "MeterID: [%02X %02X %02X %02X %02X %02X...] >> [%02X %02X %02X %02X %02X %02X...]",
+	                ShmInternalComm->AC_MeterID_pre[0],
+	                ShmInternalComm->AC_MeterID_pre[1],
+	                ShmInternalComm->AC_MeterID_pre[2],
+	                ShmInternalComm->AC_MeterID_pre[3],
+	                ShmInternalComm->AC_MeterID_pre[4],
+	                ShmInternalComm->AC_MeterID_pre[5],
+	                ShmInternalComm->AC_MeterID[0],
+	                ShmInternalComm->AC_MeterID[1],
+	                ShmInternalComm->AC_MeterID[2],
+	                ShmInternalComm->AC_MeterID[3],
+	                ShmInternalComm->AC_MeterID[4],
+	                ShmInternalComm->AC_MeterID[5]
+	                );
+	        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+	
+	        memcpy(ShmInternalComm->AC_MeterID_pre, ShmInternalComm->AC_MeterID_pre, 32);
+	    }*/
+	}
+
+    // -------- [20] EVSEModelName[32] --------
+    if(strlen(ShmInternalComm->AC_EVSEModelName)<=1)
+    {	
+	  //  memcpy(ShmInternalComm->AC_EVSEModelName, CSUCOMMAC_SHM.EVSEModelName, 32);
+	    memset(ShmInternalComm->AC_EVSEModelName, 0, sizeof(ShmInternalComm->AC_EVSEModelName));
+	    strcpy(ShmInternalComm->AC_EVSEModelName,ShmCharger->evseId.model_name);
+	  /*  if (Array_Compare_Identity(ShmInternalComm->AC_EVSEModelName, CSUCOMMAC_SHM.EVSEModelName, 32) == FALSE)
+	    {
+	        sprintf(buf_log_csucomm, "EVSEModelName: [%02X %02X %02X %02X %02X %02X...] >> [%02X %02X %02X %02X %02X %02X...]",
+	                ShmInternalComm->AC_EVSEModelName_pre[0],
+	                ShmInternalComm->AC_EVSEModelName_pre[1],
+	                ShmInternalComm->AC_EVSEModelName_pre[2],
+	                ShmInternalComm->AC_EVSEModelName_pre[3],
+	                ShmInternalComm->AC_EVSEModelName_pre[4],
+	                ShmInternalComm->AC_EVSEModelName_pre[5],
+	                ShmInternalComm->AC_EVSEModelName[0],
+	                ShmInternalComm->AC_EVSEModelName[1],
+	                ShmInternalComm->AC_EVSEModelName[2],
+	                ShmInternalComm->AC_EVSEModelName[3],
+	                ShmInternalComm->AC_EVSEModelName[4],
+	                ShmInternalComm->AC_EVSEModelName[5]
+	                );
+	        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+	
+	        memcpy(ShmInternalComm->AC_EVSEModelName_pre, ShmInternalComm->AC_EVSEModelName_pre, 32);
+	    }*/
+	}
+	#if 0
+    // -------- [21] BatteryChargeType --------
+    ShmInternalComm->AC_BatteryChargeType = CSUCOMMAC_SHM.BatteryChargeType;
+    if (ShmInternalComm->AC_BatteryChargeType_pre != ShmInternalComm->AC_BatteryChargeType)
+    {
+        sprintf(buf_log_csucomm, "BatteryChargeType: %d >> %d",
+                ShmInternalComm->AC_BatteryChargeType_pre,
+                ShmInternalComm->AC_BatteryChargeType
+                );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AC_BatteryChargeType_pre = ShmInternalComm->AC_BatteryChargeType;
+    }
+	#endif
+    // -------- [21] RcdStatus --------
+    //ShmInternalComm->AC_RcdStatus = CSUCOMMAC_SHM.RcdStatus;
+    ShmInternalComm->AC_RcdStatus=ShmCharger->gun_info[gun_index].otherAlarmCode.isACLeakage;
+    if (ShmInternalComm->AC_RcdStatus_pre != ShmInternalComm->AC_RcdStatus)
+    {
+        sprintf(buf_log_csucomm, "RCDStatus: %d >> %d",
+                ShmInternalComm->AC_RcdStatus_pre,
+                ShmInternalComm->AC_RcdStatus
+                );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AC_RcdStatus_pre = ShmInternalComm->AC_RcdStatus;
+    }
+
+	#if 0
+    // -------- [22] EVSENotification --------
+    ShmInternalComm->AC_EVSENotification = CSUCOMMAC_SHM.EVSENotification;
+    if (ShmInternalComm->AC_EVSENotification_pre != ShmInternalComm->AC_EVSENotification)
+    {
+        sprintf(buf_log_csucomm, "AC_EVSENotification: %d >> %d",
+                ShmInternalComm->AC_EVSENotification_pre,
+                ShmInternalComm->AC_EVSENotification
+                );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+
+        ShmInternalComm->AC_EVSENotification_pre = ShmInternalComm->AC_EVSENotification;
+    }
+	#endif
+}
+#endif
+
+/*===========================================================================
+FUNCTION: CsuCommAC_Error_Monitor
+DESCRIPTION:
+    1. fork1
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+/*void CsuCommAC_Error_Monitor()
+{
+    pid_t tmp = 0;
+
+    if(PID_CsuComm_Error_Monitor_Task == 0)
+    {
+        tmp = fork();   //fork1
+
+        if(tmp > 0)
+        {
+            PID_CsuComm_Error_Monitor_Task = tmp;
+
+            sprintf(buf_log_csucomm_fork1,
+                    "[fork2][Error_Monitor]created(%d)",
+                    PID_CsuComm_Error_Monitor_Task);
+            SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm_fork1);
+
+            #if 0
+            unsigned char buf[64];
+            memset(buf, 0, sizeof(buf));
+            sprintf(buf, "renice -20 -p %d", tmp);
+            system(buf);
+            #endif
+
+            return;
+        }
+    }
+
+    while(1)
+    {
+        CsuCommAC_HeartBeat_Handler();  //timeout: 60s
+    }   
+}*/
+
+
+/*===========================================================================
+FUNCTION: CsuCommAC_Proc
+DESCRIPTION:
+PRE-CONDITION:
+    1. Share Memory should be initialized in advance.
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+#ifdef AWCCS
+int CsuCommAC_Proc()
+{
+    //CsuCommAC_Init();
+    //CsuCommAC_Error_Monitor();  //fork1
+
+    while(1)
+    {
+        CsuCommAC_SHM_Rx_Update();
+    }
+}
+#endif
+void CheckID()
+{
+	unsigned char BoardId;
+	unsigned char buf[64];
+	
+	BoardId=(Get_GPIO_Value(GPIO_2_23_AM_IO_1) + 1) & 0x000000FF;//auto detect GPIO
+	if(ShmInternalComm->SlaveAddress == BoardId)
+		return;
+		
+	memset(buf,0,sizeof(buf));
+     	sprintf(buf,"SlaveAddress from %d to %d\n",ShmInternalComm->SlaveAddress,BoardId);
+     	ShmInternalComm->SlaveAddress = BoardId;
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf);
+        CSUCOMMDC_TASK_FLAG.matched = TRUE;
+        
+        //Changing the eth0 to 192.168.1.20 + ID
+        #if (DYNAMIC_ETH0_IP_MECHANISM == ENABLE)
+        Eth0_PortSetting_Add(ShmInternalComm->SlaveAddress);
+        #endif
+}
+
+/*===========================================================================
+FUNCTION: main
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+        1. PID_CAN_Rx_Task
+=============================================================================*/
+int main(int argc, char *argv[])
+{
+    // ======== [STEP 1/5] Initialize Share Memory ========
+    if(ShareMemory_Init() == 0)
+    {
+
+        SAVE_SYS_LOG_MSG_CSUCOMM("[main]ShareMemory_Init NG");
+
+
+        if(ShmStatusCodeData != NULL)
+        {
+            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory = 1;
+        }
+        sleep(5);
+        return 0;
+    }
+
+    #if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
+    {
+        sprintf(buf_log_csucomm, 
+                "========= CCS: AC (%d)=========",
+                CCS_ENERGY_TRANSFER_MODE
+               );
+        SAVE_SYS_LOG_MSG_CSUCOMM(buf_log_csucomm);
+        CsuCommAC_Proc();
+        
+        while (1)
+        {
+            //null
+        }
+    }
+    #endif
+
+    int FD_CAN_Socket;  //Socket File Descriptor
+    struct can_frame frame;
+    unsigned int value_random;
+    unsigned char can_tx_payload[8];
+
+    // ======== [STEP 2/5] Initialize CAN BUS ========
+    FD_CAN_Socket = CANBus_Init();
+    ShmInternalComm->FD_CAN_Socket = FD_CAN_Socket;
+    PID_CAN_Rx_Task = 0;
+
+    ShmInternalComm->SlaveAddress = 0xFF;   //unmatched
+    CSUCOMMDC_TASK_FLAG.matched = FALSE;
+
+    //Sniffering CAN packets
+    Sniffer_Candump(ENABLE);
+
+    Error_Monitor_CsuComm();    //fork1
+
+#if 0 //disable ID assignmemt 
+	ftime(&ShmInternalComm->Start_Time);
+        srandom(ShmInternalComm->Start_Time.millitm);
+        value_random = random();
+        value_random &= 0xFFFFFF00;
+        value_random |= 0x000000CC; //adding a specific header for identification of CCS.
+    // ======== [STEP 3/5] Request for A Slave Address ========
+    while(ShmInternalComm->SlaveAddress == 0xFF)
+    {
+        ftime(&ShmInternalComm->Start_Time);
+      //  srandom(ShmInternalComm->Start_Time.millitm);
+     //  value_random = random();
+     //   value_random &= 0xFFFFFF00;
+      //  value_random |= 0x000000CC; //adding a specific header for identification of CCS.
+        DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][main] value_random = %08X (4 Bytes, HEX)\n", value_random);
+
+        memset(can_tx_payload, 0, sizeof(can_tx_payload));
+        memcpy(can_tx_payload, &value_random, sizeof(int));
+
+        //for test
+        #if (CAN_RAMDOM_MATCHING_ID_MECHANISM == DISABLE)
+        value_random = 0xC3B2A1CC;
+        memset(can_tx_payload, 0, sizeof(can_tx_payload));
+        memcpy(can_tx_payload, &value_random, sizeof(int));
+        //can_tx_payload[0] = 0xA1;
+        //can_tx_payload[1] = 0xB2;
+        //can_tx_payload[2] = 0xC3;
+        //can_tx_payload[3] = 0xD4;
+        DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][main] replaced random number = %02X %02X %02X %02X (4 Bytes, HEX)\n",
+                can_tx_payload[0],
+                can_tx_payload[1],
+                can_tx_payload[2],
+                can_tx_payload[3],
+                can_tx_payload[4]);
+        #endif
+
+        can_tx_payload[4] = Get_GPIO_Value(GPIO_2_23_AM_IO_1) + 1;   //auto detect GPIO
+        //can_tx_payload[4] = 0x01;   //(to be implemented: auto detect GPIO)
+        //0x01:connector 1
+        //0x02:connector 2
+
+        CAN_Tx_MSG(FD_CAN_Socket, CAN_CMD_ADDRESS_REQUEST, ShmInternalComm->SlaveAddress, 5, can_tx_payload);
+	ftime(&ShmInternalComm->End_Time);
+        //Here is the process after sending the CAN message (t = 0   to   t = 100ms)
+        while(DiffTimeb(ShmInternalComm->Start_Time, ShmInternalComm->End_Time) < 1000)//resend interval: 1000ms
+        {
+            unsigned int value_random_return = 0; //4 Bytes
+          
+            memset(&frame, 0, sizeof(struct can_frame));
+            read(FD_CAN_Socket, &frame, sizeof(struct can_frame));
+	    ftime(&ShmInternalComm->End_Time);
+            PRINT_CAN_FRAME(&frame);
+
+            if( (frame.can_id == 0) ||          //all zero
+                (frame.can_id & 0x08000000) ||  //to avoid incoreect DIRECTION bit
+                ((frame.can_id & 0x0000FF00) != CAN_CMD_ADDRESS_ASSIGN) ||  //the 1st command ID from Master should be 0x02
+                (frame.can_dlc != 5))           //payload length should be only 5 bytes.
+            {
+                continue;
+            }
+
+            memcpy(&value_random_return, frame.data, sizeof(int));    //only copy the previous 4 bytes
+
+            DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][main] ori = %X, return = %X (HEX)\n", value_random, value_random_return);
+
+            if(value_random_return == value_random)
+            {
+                //Getting a legal Slave Address, successfully.
+                ShmInternalComm->SlaveAddress = frame.can_id & 0x000000FF;
+                CSUCOMMDC_TASK_FLAG.matched = TRUE;
+                #if (SAVE_SYS_LOG_MSG_CSUCOMM_SWITCH == ENABLE)
+                {
+                    SAVE_SYS_LOG_MSG_CSUCOMM("Matched");
+                }
+                #endif
+                DEBUG_PRINTF_CSUCOMM_DETAIL("[CsuComm][main] ShmInternalComm->SlaveAddres = %02X (1 Byte, HEX)\t(Matched NOW.)\n", ShmInternalComm->SlaveAddress);
+
+                //Changing the eth0 to 192.168.1.20 + ID
+                #if (DYNAMIC_ETH0_IP_MECHANISM == ENABLE)
+                Eth0_PortSetting_Add(ShmInternalComm->SlaveAddress);
+                #endif
+
+                break;
+            }
+        }
+    }
+#else    
+	sleep(5);
+	CheckID();
+#endif
+    // ======== [STEP 4/5] CAN RX  ========
+    CAN_Rx(FD_CAN_Socket);  //precondition: matched already
+    //Here is a indivitual process/task which is dealing with all CAN message and commands.
+
+    // ======== [STEP 5/5] CAN TX  ========
+    //main loop
+    ftime(&ShmInternalComm->Start_Time);
+
+    while(1)
+    {
+/*
+        //CAN_CMD_ADDRESS_REQUEST              0x00000100
+        if (CSUCOMMDC_TASK_FLAG.matched == TRUE)
+        {
+            //Proc_Match(FD_CAN_Socket);
+            //CSUCOMMDC_TASK_FLAG.matched = FALSE;
+        }
+
+        //CAN_CMD_ADDRESS_ASSIGN               0x00000200
+        if (CSUCOMMDC_TASK_FLAG.Got_AssignedAddress == TRUE)
+        {
+            //Proc_AddressAssignRes(FD_CAN_Socket);
+            CSUCOMMDC_TASK_FLAG.Got_AssignedAddress = FALSE;
+        }
+*/
+        //======================================================================
+
+        // CAN_CMD_EV_BOARD_STATUS         0x00000300
+        ftime(&ShmInternalComm->End_Time);
+        if(DiffTimeb(ShmInternalComm->Start_Time, ShmInternalComm->End_Time) >= 1000)   //ori = 1000ms
+        {
+            //Interval = 1000ms
+            CSUCOMMDC_TASK_FLAG.Send_EVBoardStatus = TRUE;
+            CheckID();
+        }
+
+        if (CSUCOMMDC_TASK_FLAG.Send_EVBoardStatus == TRUE)
+        {
+            //Tx Interval = 1000ms
+            Proc_EVBoardStatusRes(FD_CAN_Socket);
+            ftime(&ShmInternalComm->Start_Time);
+        }
+
+        // CAN_CMD_GET_FW_VERSION               0x00000400
+        if(CSUCOMMDC_TASK_FLAG.Got_FWVersionReq == TRUE)
+        {
+            Proc_GetFirmwareVersionRes(FD_CAN_Socket);
+        }
+
+        // CAN_CMD_GET_HW_VERSION               0x00000500
+        if(CSUCOMMDC_TASK_FLAG.Got_HWVersionReq == TRUE)
+        {
+            Proc_HardwareVersionRes(FD_CAN_Socket);
+        }
+
+         //CAN_CMD_CHARGING_PERMISSION          0x00000600
+        if (CSUCOMMDC_TASK_FLAG.Got_ChargingPermission == TRUE)
+        {
+            Proc_ChargingPermissionRes(FD_CAN_Socket);     //need real-time response
+        }
+
+        // CAN_CMD_EVSE_OUTPUT_STATUS_ANNOUNCEMENT       0x00000700
+        if(CSUCOMMDC_TASK_FLAG.Got_EVSEOutputStatus == TRUE)
+        {
+            Proc_EVSEOutputStatusUpdateRes(FD_CAN_Socket);     //need real-time response
+        }
+
+        // CAN_CMD_EVSE_CAPACITY_ANNOUNCEMENT     0x00000800
+        if (CSUCOMMDC_TASK_FLAG.Got_EnergyCapacity == TRUE)
+        {
+            Proc_EVSECapacityUpdateRes(FD_CAN_Socket);         //need real-time response
+        }
+
+        // CAN_CMD_GET_EV_TARGET_INFO      0x00000900
+        if(CSUCOMMDC_TASK_FLAG.Got_EVTargetReq == TRUE)
+        {
+            Proc_GetEVTargetRes(FD_CAN_Socket);
+        }
+
+        // CAN_CMD_GET_EV_BATTERY_INFO         0x00000A00
+        if(CSUCOMMDC_TASK_FLAG.Got_EVBatteryInfoReq == TRUE)
+        {
+            Proc_GetEVBatteryInfoRes(FD_CAN_Socket);
+        }
+
+        //#define CAN_CMD_EV_STOP_EVENT        0x00000B00
+        if (CSUCOMMDC_TASK_FLAG.Send_EVStopReq == TRUE) //The Request is from SeccComm
+        {
+            Proc_EVStopRes(FD_CAN_Socket);
+        }
+
+        //#define CAN_CMD_EVSE_STOP_EVENT      0x00000C00
+        if (CSUCOMMDC_TASK_FLAG.Got_EVSEStopReq == TRUE)
+        {
+            Proc_EVSEStopRes(FD_CAN_Socket);
+        }
+
+        //#define CAN_CMD_GET_MISC_INFO        0x00000D00
+        if(CSUCOMMDC_TASK_FLAG.Got_MiscellaneousInfoReq == TRUE)
+        {
+            Proc_GetMiscellaneousInfoRes(FD_CAN_Socket);
+        }
+
+        //#define CAN_CMD_DOWNLOAD_REQUEST     0x00000E00
+        if (CSUCOMMDC_TASK_FLAG.Got_DownloadImageReq == TRUE)
+        {
+            Proc_DownloadImageRes(FD_CAN_Socket);
+
+        }
+
+        //#define CAN_CMD_START_BLOCK_TRANSFER 0x00000F00
+        if (CSUCOMMDC_TASK_FLAG.Got_BlockTransferStartReq == TRUE)
+        {
+            Proc_BlockTransferStartRes(FD_CAN_Socket);
+
+        }
+
+        // CAN_CMD_DATA_TRANSFER               0x00001000
+        if(CSUCOMMDC_TASK_FLAG.Got_DataTransferReq == TRUE)
+        {
+            Proc_DataTransferRes(FD_CAN_Socket);
+
+        }
+
+        //CAN_CMD_DOWNLOAD_FINISH              0x00001100
+        if (CSUCOMMDC_TASK_FLAG.Got_DownloadFinishReq == TRUE)
+        {
+            Proc_DownloadFinishRes(FD_CAN_Socket);
+
+        }
+
+        // CAN_CMD_ISOLATION_STATUS            0x00001200
+        if (CSUCOMMDC_TASK_FLAG.Got_IsolationStatus == TRUE)
+        {
+            Proc_IsolationStatusAnnounceRes(FD_CAN_Socket);
+
+        }
+
+        // CAN_CMD_CCS_CONNECTOR_INFO          0x00001300
+        if (CSUCOMMDC_TASK_FLAG.Got_CCSConnectorReq == TRUE)
+        {
+            Proc_CCSConnectorTypeSetRes(FD_CAN_Socket);   //to-do
+
+        }
+
+        // CAN_CMD_RTC_INFO                    0x00001400
+        if (CSUCOMMDC_TASK_FLAG.Got_RTC == TRUE)
+        {
+            Proc_RTCSetRes(FD_CAN_Socket);   //to-do
+
+        }
+
+        //CAN_CMD_EVSE_PRECHARGE_INFO       //0x00001500
+        if (CSUCOMMDC_TASK_FLAG.Got_EVSE_Precharge_Info == TRUE)
+        {
+            Proc_EVSEPrechargeInfoUpdateRes(FD_CAN_Socket);
+        }
+
+        //CAN_CMD_EVCCID_REQUEST            //0x00001600
+        if (CSUCOMMDC_TASK_FLAG.Got_EVCCID_Req == TRUE)
+        {
+            Proc_EVCCIDRes(FD_CAN_Socket);
+        }
+    }
+
+EndProcess:
+    if(PID_CAN_Rx_Task > 0)
+    {
+        char Buf[32];
+        memset(Buf, 0, 32);
+        sprintf(Buf, "kill %d", PID_CAN_Rx_Task);
+        system(Buf);
+    }
+
+    close(FD_CAN_Socket);
+    system("/sbin/ip link set can0 down");
+    system("/sbin/ip link set can0 type can bitrate 500000 restart-ms 100");
+    system("/sbin/ip link set can0 up");
+    system("/sbin/ip link set can0 down");
+    system("killall CsuComm");
+}

EVSE/Projects/AW-CCS/Apps/CCS/CsuComm.h

@@ -0,0 +1,105 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                 CsuComm.h
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+#if FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == ENABLE
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_CSUCOMM_SWITCH         ENABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_CSUCOMM_SHOW               DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_CSUCOMM_BRIEF_SHOW         DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_CSUCOMM_DETAIL_SHOW        DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_CSUCOMM_SYSTEM_LOG_SHOW    DISABLE      //ENABLE, DISABLE
+#else   //debug mode
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_CSUCOMM_SWITCH         ENABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_CSUCOMM_SHOW               ENABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_CSUCOMM_BRIEF_SHOW         DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_CSUCOMM_DETAIL_SHOW        DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_CSUCOMM_SYSTEM_LOG_SHOW    ENABLE      //ENABLE, DISABLE
+#endif
+
+
+#define CSUCOMM_CAN_RX_TIMEOUT                  5000        //5s, unit: ms
+
+#define CSUCOMM_OPERATION_MODE_SIMULATION       1
+#define CSUCOMM_OPERATION_MODE_NORMAL           2
+
+#define CSUCOMM_OPERATION_MODE                  CSUCOMM_OPERATION_MODE_NORMAL
+
+
+//Protocol format : Dir
+#define CAN_SEND_DIRECTION                          0x08000000
+#define CAN_RECV_DIRECTION                          0x00000000
+
+//Protocol format : Message ID
+#define CAN_CMD_ADDRESS_REQUEST                     0x00000100
+#define CAN_CMD_ADDRESS_ASSIGN                      0x00000200
+#define CAN_CMD_EV_BOARD_STATUS                     0x00000300
+#define CAN_CMD_GET_FW_VERSION                      0x00000400
+#define CAN_CMD_GET_HW_VERSION                      0x00000500
+#define CAN_CMD_CHARGING_PERMISSION                 0x00000600
+#define CAN_CMD_EVSE_OUTPUT_STATUS_ANNOUNCEMENT     0x00000700
+#define CAN_CMD_EVSE_CAPACITY_ANNOUNCEMENT          0x00000800
+#define CAN_CMD_GET_EV_TARGET_INFO                  0x00000900
+#define CAN_CMD_GET_EV_BATTERY_INFO                 0x00000A00
+#define CAN_CMD_EV_STOP_EVENT                       0x00000B00
+#define CAN_CMD_EVSE_STOP_EVENT                     0x00000C00
+#define CAN_CMD_GET_MISC_INFO                       0x00000D00
+#define CAN_CMD_DOWNLOAD_REQUEST                    0x00000E00
+#define CAN_CMD_START_BLOCK_TRANSFER                0x00000F00
+#define CAN_CMD_DATA_TRANSFER                       0x00001000
+#define CAN_CMD_DOWNLOAD_FINISH                     0x00001100
+#define CAN_CMD_ISOLATION_STATUS                    0x00001200
+#define CAN_CMD_CCS_CONNECTOR_INFO                  0x00001300
+#define CAN_CMD_RTC_INFO                            0x00001400
+#define CAN_CMD_EVSE_PRECHARGE_INFO                 0x00001500
+#define CAN_CMD_EVCCID_REQUEST                      0x00001600
+#define CAN_CMD_PCBA_TEST                           0x0000AA00
+
+void PRINT_CAN_FRAME(struct can_frame *frame);
+int Proc_EVSEPrechargeInfoUpdateRes(int Fd);
+void Proc_EVSEPrechargeInfoUpdateReq(struct can_frame *frame);
+int Reboot_Process();
+void Error_Monitor_CsuComm();
+
+//System Log
+#if SAVE_SYS_LOG_MSG_CSUCOMM_SWITCH == ENABLE
+    #define SAVE_SYS_LOG_MSG_CSUCOMM     StoreLogMsg2
+#else
+    #define SAVE_SYS_LOG_MSG_CSUCOMM(...)
+#endif
+
+//Debug Message
+#if DEBUG_PRINTF_CSUCOMM_SHOW == ENABLE
+    //Brief Messages
+    #if DEBUG_PRINTF_CSUCOMM_BRIEF_SHOW == ENABLE
+        #define DEBUG_PRINTF_CSUCOMM_BRIEF      printf
+    #else
+        #define DEBUG_PRINTF_CSUCOMM_BRIEF(...)
+    #endif
+
+    //Detail Messages
+    #if DEBUG_PRINTF_CSUCOMM_DETAIL_SHOW == ENABLE
+        #define DEBUG_PRINTF_CSUCOMM_DETAIL     printf
+    #else
+        #define DEBUG_PRINTF_CSUCOMM_DETAIL(...)
+    #endif
+
+    //System Log Messages
+    #if DEBUG_PRINTF_CSUCOMM_SYSTEM_LOG_SHOW == ENABLE
+        #define DEBUG_PRINTF_CSUCOMM_SYSTEM_LOG    printf
+    #else
+        #define DEBUG_PRINTF_CSUCOMM_SYSTEM_LOG(...)
+    #endif
+#else
+    #define DEBUG_PRINTF_CSUCOMM_BRIEF(...)
+    #define DEBUG_PRINTF_CSUCOMM_DETAIL(...)
+    #define DEBUG_PRINTF_CSUCOMM_SYSTEM_LOG(...)
+#endif

EVSE/Projects/AW-CCS/Apps/CCS/CsuCommAC.h

@@ -0,0 +1,465 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                 CsuCommAC.h
+
+                             initiated by Joseph
+                              (since 2020/06/10)
+=============================================================================
+Merged from:
+- GIT Server: https://git.phihong.com.tw:30000/System_Integration/CSU3_AM335x/commits/AW-CCS
+- VERSION SHA: de7e1da3b9d219fbb8babf12d305e9423f1e8d94
+- VERSION Date: 2020-06-12
+=============================================================================*/
+
+typedef struct Verion
+{
+	char Version_FW[32];
+	char Version_HW[32];
+}Ver;
+
+typedef struct PRESENTINPUTVOLTAGE
+{
+	unsigned char inputType;	// 0x00: Line to Line       0x01: Line to Neutral
+	double L1N_L12;
+	double L2N_L23;
+	double L3N_L31;
+}PresentInputVoltage;
+
+typedef struct PRESENTOUTPUTVOLTAGE
+{
+	double behindFuse_Voltage_C1;
+	double behindRelay_Voltage_C1;
+	double behindFuse_Voltage_C2;
+	double behindRelay_Voltage_C2;
+}PresentOutputVoltage;
+
+typedef struct FANSPEED
+{
+	unsigned short int speed[4];
+}FanSpeed;
+
+typedef struct TEMPERATURE
+{
+	unsigned char point[8];
+}Temperature;
+
+typedef struct AUXPOWER
+{
+	unsigned char voltage[8];
+}AuxPower;
+
+typedef struct RELAY
+{
+	unsigned char relay_status[2][8];
+}Relay;
+
+typedef struct GFD
+{
+	unsigned short int adc_value_positive[2];
+	unsigned short int adc_value_negative[2];
+}Gfd;
+
+typedef struct GPIO_IN
+{
+	unsigned char AC_Connector;
+	unsigned char AC_MainBreaker;
+	unsigned char SPD;
+	unsigned char Door_Open;
+	unsigned char GFD[2];
+	unsigned char Button[2];
+	unsigned char Button_Emergency;
+}Gpio_in;
+
+typedef struct GPIO_OUT
+{
+	unsigned char AC_Connector;
+	unsigned char Button_LED[2];
+	unsigned char System_LED[4];
+}Gpio_out;
+
+typedef struct ALARM_LOG
+{
+	unsigned char logArea;
+	unsigned int alarmIndex;
+	unsigned char log[8];
+}Alarm_Log;
+
+typedef struct BLE_CONFIG_DATA
+{
+	unsigned char isLogin:1;
+	unsigned char isRequestStart:1;
+	unsigned char isRequestStop:1;
+}Ble_Config_Data;
+
+typedef struct BLE_LONGIN_CENTRAL_ID
+{
+	unsigned char id[32];
+}Ble_Login_Central_Id;
+
+typedef struct RTC
+{
+	unsigned short int year;
+	unsigned char month;
+	unsigned char day;
+	unsigned char hour;
+	unsigned char min;
+	unsigned char sec;
+}Rtc;
+
+typedef struct PRESENTOUTPUTCURRENT
+{
+	double L1N_L12[2];
+	double L2N_L23[2];
+	double L3N_L31[2];
+}Presentoutputcurrent;
+
+typedef struct AC_PRIMARY_MCU
+{
+	unsigned char cp_state;
+	unsigned int  current_limit;
+	float cp_voltage_positive;
+	float cp_voltage_negtive;
+	unsigned char locker_state;
+	unsigned char relay_state;
+	unsigned char shutter_state;
+	unsigned char meter_state;
+	unsigned char pp_state;
+	unsigned char rating_current;
+	unsigned char rotatory_switch;
+	Relay	relayState;
+}Ac_Primary_Mcu;
+
+typedef struct AC_PRIMARY_MCU_ALARM
+{
+	union
+	{
+		unsigned long InputAlarmCode;
+		struct
+		{
+			unsigned long OVP_L1:1;
+			unsigned long UVP_L1:1;
+			unsigned long OCP_L1:1;
+			unsigned long OTP:1;
+			unsigned long gmi_fault:1;
+			unsigned long cp_fault:1;
+			unsigned long ac_leak:1;
+			unsigned long dc_leak:1;
+			unsigned long mcu_selftest_fail:1;
+			unsigned long handshaking_timeout:1;
+			unsigned long emergency_stop:1;
+			unsigned long relay_welding:1;
+			unsigned long leak_module_fail:1;
+			unsigned long shutter_fault:1;
+			unsigned long locker_fault:1;
+			unsigned long power_drop:1;
+			unsigned long rotate_switch_fault:1;
+			unsigned long short_circuit_L1:1;
+			unsigned long relay_drive_fault:1;
+			unsigned long comm_timeout:1;
+			unsigned long OVP_L2:1;
+			unsigned long UVP_L2:1;
+			unsigned long OCP_L2:1;
+			unsigned long OVP_L3:1;
+			unsigned long UVP_L3:1;
+			unsigned long OCP_L3:1;	
+			unsigned long short_circuit_L2:1;
+			unsigned long short_circuit_L3:1;			
+		}bits;
+	};
+}Ac_Primary_Mcu_Alarm;
+
+typedef struct AC_PRIMARY_MCU_LED
+{
+	unsigned char mode;
+	unsigned long alarm_code;
+}Ac_Primary_Mcu_Led;
+
+typedef struct EVSE_ID
+{
+	unsigned char model_name[14];
+	unsigned char serial_number[12];
+}Evse_Id;
+
+typedef struct AC_PRIMARY_MCU_CP_PWM_DUTY
+{
+	unsigned int max_current;
+}Ac_Primary_Mcu_Cp_Pwm_Duty;
+
+typedef struct LEGACY_REQUEST
+{
+	unsigned char isLegacyRequest:1;
+	uint8_t isRelayOn:1;
+}Legacy_Request;
+
+typedef struct POWER_CONSUMPTION
+{
+	uint32_t power_consumption;
+	uint32_t power_consumption_at_start;
+
+}Power_Consumption;
+
+typedef struct MCU_OP_FLAG
+{
+	unsigned char isSetModePass:1;
+	unsigned char isSetSerialNumberPass:1;
+	unsigned char isSetModelNamePass:1;
+	unsigned char isReadFwVerPass:1;
+	unsigned char isMcuUpgradeReq:1;
+	unsigned char isSetCpPwmDuty:1;
+}Mcu_Op_Flag;
+
+typedef struct SYSTEM_ALARM_CODE
+{
+	unsigned long SystemAlarmCode;
+
+}System_Alarm_Code;
+
+typedef struct OTHER_ALARM_CODE
+{
+	unsigned long isHandshakingTimeOut:1;
+	unsigned long isDcLeakage:1;
+	unsigned long isACLeakage:1;
+}Other_Alarm_Code;
+
+typedef struct PILOT_VOLTAGE
+{
+	float PilotVoltagePositive;
+	float PilotVoltageNegative;
+
+}Pilot_Voltage;
+
+typedef struct FW_UPGRADE_INFO
+{
+	int fwType;
+	char modelName[17];
+	char location[384];
+}Fw_Upgrade_Info;
+
+typedef struct GUN_PLUGIN_TIMES
+{
+	uint32_t GunPluginTimes;
+
+}Gun_Plugin_Times;
+
+typedef struct MCU_RESET_REQUEST
+{
+	unsigned char isMcuResetRequest:1;
+}Mcu_Reset_Request;
+
+typedef struct TIMEOUT_SPEC
+{
+	int Setting_Timeout_Spec;
+	int Present_Timeout_Spec;
+}Timeout_Spec;
+
+typedef struct SET_BREATHE_LED_TIMING
+{
+	uint16_t set_Led_Action_Connected_Fade_In;
+	uint16_t set_Led_Action_Connected_Fade_Out;
+	uint16_t set_Led_Action_Authed_Fade_In;
+	uint16_t set_Led_Action_Authed_Fade_Out;
+	uint16_t Set_Led_Action_Chaging_Fade_In;
+	uint16_t set_Led_Action_Chaging_Fade_Out;
+}Set_Breathe_Led_Timing;
+
+typedef struct SET_LED_BRIGHTNESS
+{
+	uint8_t sector_1;	// 0~1 AM and 1~2 AM
+	uint8_t sector_2;	// 2~3 AM and 3~4 AM
+	uint8_t sector_3;	// 4~5 AM and 5~6 AM
+	uint8_t sector_4;	// 6~7 AM and 7~8 AM
+	uint8_t sector_5;	// 8~9 AM and 9~10 AM
+	uint8_t sector_6;	// 10~11 AM and 11~12 AM
+	uint8_t sector_7;	// 12~13 PM and 13~14 PM
+	uint8_t sector_8;	// 14~15 PM and 15~16 PM
+	uint8_t sector_9;	// 16~17 PM and 17~18 PM
+	uint8_t sector_10;	// 18~19 PM and 19~20 PM
+	uint8_t sector_11;	// 20~21 PM and 21~22 PM
+	uint8_t sector_12;	// 22~23 PM and 23~24 PM
+}Set_Led_Brightness;
+
+typedef struct CCS_INFO
+{
+	uint8_t		BatteryChargeType;				/*0x00: AC charging, 0x01: DC charging*/
+	uint8_t 	PresentMsgFlowStatus;   
+												/*  ISO15118_2018
+												0: Idle(wait B2 state), 
+												1: CM_SLAC_PARM.REQ, 
+												2: CM_SLAC_PARM.CNF, 
+												3: CM_START_ATTEN_CHAR.IND
+												4: CM_MNBC_SOUND.IND, 
+												5: CM_ATTEN_CHAR.IND, 
+												6: CM_ATTEN_CHAR.RSP, 
+												7: CM_VALIDATE.REQ
+												8: CM_VALIDATE.CNF, 
+												9: CM_SLAC_MATCH.REQ, 
+												10: CM_SLAC_MATCH.CNF, 
+												11: CM_AMP_MAP.REQ
+												12: CM_AMP_MAP.CNF, 
+												13: SLACC/SDP/TCP connection,
+												16: SupportedAppProtocolRequest, 
+												17: SupportedAppProtocolResponse, 
+												18: SessionSetupRequest
+												19: SessionSetupResponse, 
+												20: ServiceDiscoveryRequest, 
+												21: ServiceDiscoveryResponse
+												22: ServiceDetailRequest, 
+												23: ServiceDetailResponse
+												24:ServiceAndPaymentSelectionRequest/ServiceSelectionRequest, 
+												25: ServiceAndPaymentSelectionResponse/ServiceSelectionResponse
+												26: PaymentDetailsRequest/IdentificationDetailsRequest;, 
+												27: PaymentDetailsResponse/IdentificationDetailsResponse,
+												28: AuthorizationRequest, 
+												29: AuthorizationResponse,
+												30: CertificateUpdateRequest, 
+												31: CertificateUpdateResponse, 
+												32:CertificateInstallationRequest, 
+												33: CertificateInstallationResponse
+												34: ChargeParameterDiscoveryRequest, 
+												35: ChargeParameterDiscoveryResponse
+												36: CableCheckRequest, 
+												37: CableCheckResponse, 
+												38: PreChargeRequest, 
+												39: PreChargeResponse
+												40: PowerDeliveryRequest start, 
+												41: PowerDeliveryResponse start, 
+												42: ChargingStatusRequest, 
+												43: ChargingStatusResponse
+												44:CurrentDemandRequest, 
+												45:CurrentDemandResponse, 
+												46:MeteringReceiptRequest, 
+												47: MeteringReceiptResponse
+												48: PowerDeliveryRequest end, 
+												49: PowerDeliveryRequest end, 
+												50: WeldingDetectionRequest, 
+												51: WeldingDetectionResponse,
+												52: SessionStopRequest, 
+												53: SessionStopResponse
+												253: Performance Timeout, 
+												254: Sequence Timeout, 
+												255: Fault
+												*/
+
+	float 		ConnectorTemperature1;			/*unit: 1°C*/
+	float 		ConnectorTemperature2;			/*unit: 1°C*/
+	uint16_t	ChargingRemainTime;				/*0x0000: 0 sec ~ 0xFFFF: 65535 sec, unit: 1 second*/
+	float		TotalBatteryCapacity;			/*unit: Wh*/
+	float		BatteryMaximumVoltage;			/*unit: 1 volt*/
+	float		BatteryMaximumCurrent;			/*unit: 1 amp*/
+	uint8_t		EVCCID[8];
+	uint8_t		EVSEID[40];
+	uint8_t		CCSLibRev[32];
+	uint8_t		EVSEModelName[32];
+	uint32_t	CSUAlarmStatusCode;
+	uint16_t	CCSAlarmStatusCode;
+	uint8_t		PaymentOption;					/* 0x00 EIM, 0x01 Pnc */
+	float		EVSEMaxCurrent;					/*unit: 1 amp*/
+	float		EVSEMinCurrent;					/*unit: 1 amp*/
+	float		GridVoltage[3];				    /*unit: 1 volt*/
+	uint8_t		MeterID[32];					/*unit: 1 amp*/
+	float		MeterReadingValue;				/*unit: 1Wh*/
+	uint8_t		EVOperation;					/*0:Charge, 1:Discharge*/
+	uint8_t		EVChargeProgress;				/*0: Stop
+													1: Start
+													2: Renegotiate
+													3: Standby */
+	uint8_t		CpSetPWMDuty;					/*unit: 1%
+													0: 0%
+													5: 5%
+													100: 100%*/
+	uint8_t		CpSetStateE;					/*0:disable, 1:enable*/
+	uint8_t		CpPresentPWMDuty;				/*unit:1%*/
+	uint8_t		CpPresentState;					/*1: A (12V, no PWM)
+													2: B1 (9V, no PWM)
+													3: B2 (9V, with PWM)
+													4: C (6V, with PWM)
+													5: D (3V, with PWM)
+													6: E (0V, no PWM)
+													7: F (-12V, no PWM)
+													8: G (>12V)
+													9: H  (<12V)*/
+	float		CpPositiveVoltage;				/*uint: 1V*/
+	float		CpNegativeVoltage;				/*uint: 1V*/
+	uint32_t	CcsHeartBeat;					/*unit: 1*/
+	float 		EVSEPresentCurrent[3];			//unit: 1A
+	float 		AvailableChargingPower;			//1KW
+	uint8_t		EVSENotification;				//0:none, 1:StopCharging, 2:RenNgotiation
+	uint16_t 	ChargingPermission:1;				/*0x00: Not ready yet, stay in idle mode or go into terminating process.
+												  0x01: start charging process*/
+	uint16_t 	ConnectorLockerStatus:1;			/*0x00: released
+												  0x01: locked*/	
+												 
+	uint16_t	RcdStatus:1;					/* 0x00 no error
+												   0x01 an error */
+	uint16_t	OutputRelayStatus:1;			/*0: OFF
+												1: ON*/
+	uint16_t	TempFlag4:1;
+	uint16_t	TempFlag5:1;
+	uint16_t	TempFlag6:1;
+	uint16_t	TempFlag7:1;
+	uint16_t	TempFlag8:1;
+	uint16_t	TempFlag9:1;
+	uint16_t	TempFlag10:1;
+	uint16_t	TempFlag11:1;
+	uint16_t	TempFlag12:1;
+	uint16_t	TempFlag13:1;
+	uint16_t	TempFlag14:1;
+	uint16_t	TempFlag15:1;
+	
+}Ac_Ccs_Info;
+
+typedef struct GUN_INFO
+{
+	Ver 											ver;
+	PresentInputVoltage 							inputVoltage;
+	Presentoutputcurrent							outputCurrent;
+	Temperature 									temperature;
+	Ble_Config_Data									bleConfigData;
+	Ble_Login_Central_Id							bleLoginCentralId;
+	Rtc												rtc;
+	Ac_Primary_Mcu									primaryMcuState;
+	Ac_Primary_Mcu_Alarm							primaryMcuAlarm;
+	Ac_Primary_Mcu_Led								primaryMcuLed;
+	Mcu_Op_Flag										mcuFlag;
+	Power_Consumption								powerConsumption;
+	Legacy_Request									legacyRequest;
+	System_Alarm_Code								systemAlarmCode;
+	Ac_Primary_Mcu_Cp_Pwm_Duty						primaryMcuCp_Pwn_Duty;
+	Other_Alarm_Code								otherAlarmCode;
+	Pilot_Voltage									PilotVoltage;
+	Gun_Plugin_Times								gunPluginTimes;
+	Mcu_Reset_Request								mcuResetRequest;
+	Set_Breathe_Led_Timing							setBreatheLedTiming;
+	Set_Led_Brightness								setLedBrightness;
+	Ac_Ccs_Info										acCcsInfo;
+	uint8_t											ccsHandshakeState;
+	uint8_t											PreviousEVChargeProgress;	
+	uint8_t											chargingMode;
+	uint16_t										targetCurrent;
+	
+	uint16_t										isAuthPassEnd:1;
+	uint16_t										rfidReq:1;
+	uint16_t										isGunPlugged:1;
+	uint16_t										isInitialPass:1;
+	uint16_t										isSetBreatheLedTiming:1;
+	uint16_t										isSetLedBrightness:1;
+	uint16_t										isUnlockerConnetor:1;
+	uint16_t										isOperactive:1;
+	uint16_t										isCCSWaitChangeDuty:1;
+	uint16_t										isCCSStartTransation:1;
+}Gun_Info;
+
+//struct Charger
+struct InternalCommAC
+{
+	Ver 					ver;
+	Evse_Id					evseId;
+	Gun_Info 				gun_info[2];
+	Fw_Upgrade_Info			fwUpgradeInfo;
+	Timeout_Spec			timeoutSpec;
+	
+	uint8_t					gun_selectd;
+	uint8_t	 				speaker_type;
+	uint8_t					isSpeakerOn:1;
+	uint8_t		 			isUpdateSuccess:1;
+};

EVSE/Projects/AW-CCS/Apps/CCS/EvComm.c

@@ -0,0 +1,1668 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                 EVComm.c
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+   =============================================================================*/
+#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 "define.h"
+#include "EvComm.h"
+#include "NidNmk.h"
+#include "EvComm.h"
+
+#define Debug
+
+struct SysConfigAndInfo         *ShmSysConfigAndInfo;
+struct StatusCodeData           *ShmStatusCodeData;
+struct CcsData              	*ShmCcsData;
+struct InternalComm         	*ShmInternalComm;
+
+pid_t PilotDetectionPid;
+enum MsgFlowStatus V2gFlowStatus;
+int RawSock,UdpSock,TcpSock;
+unsigned char                   *RecvBuffer,*SendBuffer;
+int RecvBufferSize=64*1024;
+int SendBufferSize=64*1024;
+unsigned short Aag[64];
+struct MmeHeader SendMmePacket;
+int SendMmePacketSize;
+unsigned char CsuMac[6],QcaMac[6],EvMac[6],SlacRunId[8];
+struct sockaddr_ll DestSocketAddress;
+struct ifreq Req;
+unsigned int PwmStartTime;
+struct timeb SeqStartTime,SeqEndTime;
+unsigned char AagGroupsNum, MnbcSoundNum,AttenProfileNum;
+unsigned char NewNmkKey[16],Nid[7];
+
+
+#ifdef SystemLogMessage
+int StoreLogMsg(unsigned char *DataString)
+{
+    unsigned char Buf[256];
+    time_t CurrentTime;
+    struct tm *tm;
+
+    memset(Buf,0,sizeof(Buf));
+    CurrentTime = time(NULL);
+    tm=localtime(&CurrentTime);
+    sprintf(Buf,"echo \"%04d.%02d.%02d %02d:%02d:%02d - %s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog",
+            tm->tm_year+1900,
+			tm->tm_mon+1,
+			tm->tm_mday,
+			tm->tm_hour,
+			tm->tm_min,
+			tm->tm_sec,
+            DataString,
+            tm->tm_year+1900,
+			tm->tm_mon+1
+		   );
+    system(Buf);
+    #ifdef Debug
+    printf("%s \n",DataString);
+    #endif
+}
+#endif
+
+int DiffTimeb(struct timeb ST, struct timeb ET)
+{
+    //return milli-second
+    unsigned int StartTime,StopTime;
+
+    StartTime=(unsigned int)ST.time;
+    StopTime=(unsigned int)ET.time;
+    return (StopTime-StartTime)*1000+ET.millitm-ST.millitm;
+}
+
+int CreatShareMemory()
+{
+    int MeterSMId;
+
+    //creat ShmSysConfigAndInfo
+    if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo), IPC_CREAT | 0777)) < 0)
+    {
+        #ifdef SystemLogMessage
+        StoreLogMsg("[main]CreatShareMemory:shmget ShmSysConfigAndInfo NG");
+        #endif
+        return 0;
+    }
+    else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
+    {
+        #ifdef SystemLogMessage
+        StoreLogMsg("[main]CreatShareMemory:shmat ShmSysConfigAndInfo NG");
+        #endif
+        return 0;
+    }
+    memset(ShmSysConfigAndInfo,0,sizeof(struct SysConfigAndInfo));
+    //creat ShmStatusCodeData
+    if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData), IPC_CREAT | 0777)) < 0)
+    {
+        #ifdef SystemLogMessage
+        StoreLogMsg("[main]CreatShareMemory:shmget ShmStatusCodeData NG");
+        #endif
+        return 0;
+    }
+    else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
+    {
+        #ifdef SystemLogMessage
+        StoreLogMsg("[main]CreatShareMemory:shmat ShmStatusCodeData NG");
+        #endif
+        return 0;
+    }
+    memset(ShmStatusCodeData,0,sizeof(struct StatusCodeData));
+    //creat ShmCcsData
+    if ((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData), IPC_CREAT | 0777)) < 0)
+    {
+        #ifdef SystemLogMessage
+        StoreLogMsg("[main]CreatShareMemory:shmget ShmCcsData NG");
+        #endif
+        return 0;
+    }
+    else if ((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
+    {
+        #ifdef SystemLogMessage
+        StoreLogMsg("[main]CreatShareMemory:shmat ShmCcsData NG");
+        #endif
+        return 0;
+    }
+    memset(ShmCcsData,0,sizeof(struct CcsData));
+    return 1;
+}
+
+int InitShareMemory()
+{
+    int MeterSMId;
+
+    //creat ShmSysConfigAndInfo
+    if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo),  0777)) < 0)
+    {
+        #ifdef SystemLogMessage
+        StoreLogMsg("[EvComm]InitShareMemory:shmget ShmSysConfigAndInfo NG");
+        #endif
+        return 0;
+    }
+    else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
+    {
+        #ifdef SystemLogMessage
+        StoreLogMsg("[EvComm]InitShareMemory:shmat ShmSysConfigAndInfo NG");
+        #endif
+        return 0;
+    }
+    //creat ShmStatusCodeData
+    if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  0777)) < 0)
+    {
+        #ifdef SystemLogMessage
+        StoreLogMsg("[EvComm]InitShareMemory:shmget ShmStatusCodeData NG");
+        #endif
+        return 0;
+    }
+    else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
+    {
+            #ifdef SystemLogMessage
+        StoreLogMsg("[EvComm]InitShareMemory:shmat ShmStatusCodeData NG");
+        #endif
+        return 0;
+    }
+
+    //creat ShmCcsData
+    if ((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData),  0777)) < 0)
+    {
+        #ifdef SystemLogMessage
+        StoreLogMsg("[EvComm]InitShareMemory:shmget ShmCcsData NG");
+        #endif
+        return 0;
+    }
+    else if ((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
+    {
+            #ifdef SystemLogMessage
+        StoreLogMsg("[EvComm]InitShareMemory:shmat ShmCcsData NG");
+        #endif
+        return 0;
+    }
+
+    //creat ShmInternalComm
+    if ((MeterSMId = shmget(ShmInternalCommKey, sizeof(struct InternalComm),   0777)) < 0)
+    {
+        #ifdef SystemLogMessage
+        StoreLogMsg("[EvComm]InitShareMemory:shmget ShmInternalComm NG");
+        #endif
+        return 0;
+    }
+    else if ((ShmInternalComm = shmat(MeterSMId, NULL, 0)) == (void *) -1)
+    {
+        #ifdef SystemLogMessage
+        StoreLogMsg("[EvComm]InitShareMemory:shmat ShmInternalComm NG");
+        #endif
+        return 0;
+    }
+
+    return 1;
+}
+
+int GetEthMac(unsigned char *Eth, unsigned char *mac)
+{
+    //Parameters:MAC,IP,Mask,Gateway
+    int fd,rd=0;
+    unsigned char addr[18], Buffer[128];
+
+    memset(Buffer,0,sizeof(Buffer));
+    sprintf(Buffer,"cat /sys/class/net/%s/address > /mnt/GetEthInfo",Eth);
+    system(Buffer);
+    fd = open("/mnt/GetEthInfo", O_RDONLY);
+    if(fd<0)
+    {
+        system("rm -f /mnt/GetEthInfo");
+        #ifdef SystemLogMessage
+        StoreLogMsg("[EvComm]GetEthMac: MAC Address open error");
+        #endif
+        return 0;
+    }
+    memset(mac,0,6);
+    memset(addr,0,sizeof(addr));
+    rd=read(fd,addr,17);
+    close(fd);
+    system("rm -f /mnt/GetEthInfo");
+    sscanf(addr, "%02x:%02x:%02x:%02x:%02x:%02x", &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5]);
+    return 1;
+}
+
+float ReadAdcVolt(unsigned char AdcChannel)
+{
+    //AIN0=CCS GUN Temp 1
+    //AIN1=CCS GUN Temp 2
+    //AIN2=CCS_Proximity/2
+    //AIN3=pilot voltage
+    FILE *fp;
+    unsigned char str[64];
+    unsigned char AdcValue[8];
+
+    if(AdcChannel>7)
+        return -1;
+    memset(str,0,sizeof(str));
+    memset(AdcValue,0,sizeof(AdcValue));
+    sprintf(str,"cat /sys/bus/iio/devices/iio\\:device0/in_voltage%d_raw",AdcChannel);
+    fp=popen(str, "r");
+    if(fgets(AdcValue,sizeof(AdcValue),fp)==NULL)
+    {
+        pclose(fp);
+        return -1;
+    }
+    pclose(fp);
+    //Vin =  Vref *D / (2^n - 1)
+    return ((float)1.8*(float)atoi(AdcValue))/4095;
+}
+
+void Qca7kPowerReset()
+{
+    system("echo 1 > /sys/class/gpio/gpio88/value");
+    usleep(500000);
+    system("echo 0 > /sys/class/gpio/gpio88/value");
+}
+
+void SwitchCpStateE(unsigned char OnOff)
+{
+    //OnOff=1 => switch State to E
+    //OnOff=0 => return noraml
+    if(OnOff==0)
+        system("echo 0 > /sys/class/gpio/gpio86/value");
+    else
+        system("echo 1 > /sys/class/gpio/gpio86/value");
+}
+
+int OutputCpPwmDuty(unsigned char Duty)
+{
+    unsigned char str[128];
+    int DutyInNanoSec;
+
+    if((Duty<0)||(Duty>100))
+        return -1;
+
+    memset(str,0,sizeof(str));
+    DutyInNanoSec=10000*Duty;
+    sprintf(str,"echo %d > /sys/class/pwm/pwmchip0/pwm0/duty_cycle",DutyInNanoSec);//nanoseconds
+    system(str);
+    ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotDuty=Duty;
+    return 0;
+}
+
+int ConnectorPlugIn()
+{
+    //return 0 => unplug
+    //return 1 => plug-in
+    float TmpProximity;
+    unsigned char Rtn=0;
+
+    if(((FirmwareVersion&0x0000FF00)>>8)==0x01)
+    {
+        //UL version: judge with CP and proximity
+        TmpProximity=ReadAdcVolt(2);
+        if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState>=2)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState<=5)&&
+           (TmpProximity>=0.4)&&(TmpProximity<=0.9))
+        {
+            Rtn=1;
+        }
+    }
+    else
+    {
+        //CE version: judge with CP only
+        if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState>=2)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState<=5))
+            Rtn=1;
+    }
+    ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].ConnectorPlugIn=Rtn;
+    return Rtn;
+}
+
+void PilotDetection()
+{
+    pid_t tmp=0;
+    struct timeb StartTime,EndTime;
+    unsigned char CpState[3],count;
+    float TmpVolt;
+
+    if(PilotDetectionPid==0)
+    {
+        tmp=fork();
+        if(tmp>0)
+        {
+            PilotDetectionPid=tmp;
+            {
+                unsigned char buf[64];
+                memset(buf,0,sizeof(buf));
+                sprintf(buf,"renice -20 -p %d",tmp);
+                system(buf);
+            }
+            return;
+        }
+    }
+
+    while(1)
+    {
+        //ADC_Voltage = (1+RE62/RE63)*0.9 - (RE62/RE63)*Pilot_Voltage,  RE62/RE63=0.06
+        //=>Pilot_Voltage=(0.954-ADC_Voltage)/0.06
+        //ftime(&StartTime);
+        TmpVolt=0;
+        for(count=0; count<3; count++)
+        {
+            TmpVolt+=(0.954-ReadAdcVolt(3))/0.06;
+        }
+        TmpVolt/=3;
+        ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotVoltage=TmpVolt;
+        if(TmpVolt>=13.5)
+        {
+            //Pilot Error
+            if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState==1)&&(TmpVolt<13.75))
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=1;
+            else
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=8;
+        }
+        else if((TmpVolt>=10.5)&&(TmpVolt<13.5))
+        {
+            //State A
+            if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState>=2)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState<=3)&&(TmpVolt<10.75))
+            {
+                if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotDuty>=5)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotDuty<100))
+                    ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=3;
+                else
+                    ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=2;
+            }
+            else if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState==8)&&(TmpVolt>=13.25))
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=8;
+            else
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=1;
+        }
+        else if((TmpVolt>=7.5)&&(TmpVolt<10.5))
+        {
+            //State B
+            if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState==4)&&(TmpVolt<7.75))
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=4;
+            else if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState==1)&&(TmpVolt>=10.25))
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=1;
+            else
+            {
+                if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotDuty>=5)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotDuty<100))
+                    ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=3;
+                else
+                    ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=2;
+            }
+        }
+        else if((TmpVolt>=4.5)&&(TmpVolt<7.5))
+        {
+            //State C
+            if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState==5)&&(TmpVolt<4.75))
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=5;
+            else if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState>=2)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState<=3)&&(TmpVolt>=7.25))
+            {
+                if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotDuty>=5)&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotDuty<100))
+                    ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=3;
+                else
+                    ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=2;
+            }
+            else
+            {
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=4;
+            }
+        }
+        else if((TmpVolt>=1.5)&&(TmpVolt<4.5))
+        {
+            //State D
+            if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState==6)&&(TmpVolt<1.75))
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=6;
+            else if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState==4)&&(TmpVolt>=4.25))
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=4;
+            else
+            {
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=5;
+            }
+        }
+        else if((TmpVolt>= -1.5)&&(TmpVolt<1.5))
+        {
+            //State E
+            if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState==8)&&(TmpVolt< -1.25))
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=8;
+            else if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState==5)&&(TmpVolt>=1.25))
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=5;
+            else
+            {
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=6;
+            }
+        }
+        else if((TmpVolt>= -13.5)&&(TmpVolt< -10.5))
+        {
+            //State F
+            if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState==8)&&(TmpVolt>= -10.75))
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=8;
+            else
+            {
+                ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState=7;
+            }
+        }
+        //ftime(&EndTime);
+        //printf("duration:%d\n", DiffTimeb(StartTime, EndTime));
+    }//while
+}
+
+int MmeProcess(unsigned char *Buffer, int DataLength)
+{
+    //struct ethhdr	*EthPacket;
+    struct MmeHeader    *MmePacket;
+    int Rtn;
+    static unsigned char counter;
+
+    MmePacket = (struct MmeHeader *)Buffer;
+
+    #ifdef Debug
+    printf("\n\n***********************************\n");
+    printf("***** Received MME Packet *****\n");
+    printf("***********************************\n");
+    printf("DataLength=%d\n",DataLength);
+    printf("ODA: %02x:%02x:%02x:%02x:%02x:%02x\n",
+           MmePacket->ODA[0],MmePacket->ODA[1],MmePacket->ODA[2],MmePacket->ODA[3],MmePacket->ODA[4],MmePacket->ODA[5]);
+    printf("OSA: %02x:%02x:%02x:%02x:%02x:%02x\n",
+           MmePacket->OSA[0],MmePacket->OSA[1],MmePacket->OSA[2],MmePacket->OSA[3],MmePacket->OSA[4],MmePacket->OSA[5]);
+    printf("MTYPE: 0x%x\n", htons(MmePacket->MTYPE));
+    printf("MMV: 0x%x\n", MmePacket->MMV);
+    printf("MMTYPE: 0x%x\n", MmePacket->MMTYPE);
+    printf("FMI 0x%x, 0x%x\n", MmePacket->FMI[0],MmePacket->FMI[1]);
+    #endif
+
+    //check if the destination address is broadcast or EVSE itself, it can be ignore if not belong to itself.
+    switch(MmePacket->MMTYPE)
+    {
+	    case MMTYPE_CM_SET_KEY_CNF:
+		{
+	        #ifdef Debug
+	        printf("--- MMTYPE_CM_SET_KEY_CNF ---\n");
+	        printf("Result: 0x%x\n", MmePacket->MMENTRY[0]);
+	        #endif
+	        V2gFlowStatus=CM_SET_KEY_CNF;
+	        break;
+		}
+
+	    case MMTYPE_CM_SLAC_PARM_REQ:
+		{
+	        #ifdef Debug
+	        printf("--- MMTYPE_CM_SLAC_PARM_REQ ---\n");
+	        printf("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
+	        printf("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
+	        printf("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	               MmePacket->MMENTRY[2],MmePacket->MMENTRY[3],MmePacket->MMENTRY[4],MmePacket->MMENTRY[5],MmePacket->MMENTRY[6],
+	               MmePacket->MMENTRY[7],MmePacket->MMENTRY[8],MmePacket->MMENTRY[9]);
+	        printf("CipherSuiteSetSize: 0x%x\n", MmePacket->MMENTRY[10]);
+	        printf("CipherSuite [1]: 0x%x,0x%x\n", MmePacket->MMENTRY[11], MmePacket->MMENTRY[12]);
+	        #endif
+	        V2gFlowStatus=CM_SLAC_PARM_REQ;
+	        memcpy(EvMac,MmePacket->OSA,sizeof(EvMac));
+	        memcpy(DestSocketAddress.sll_addr,MmePacket->OSA,sizeof(EvMac));
+	        memcpy(SlacRunId,MmePacket->MMENTRY+2,sizeof(SlacRunId));
+	        memset(&SendMmePacket,0,sizeof(struct MmeHeader));
+	        memcpy(SendMmePacket.ODA,MmePacket->OSA,6);
+	        memcpy(SendMmePacket.OSA,CsuMac,6);
+	        SendMmePacket.MTYPE=htons(EtherType_HomePlug);
+	        SendMmePacket.MMV=MmePacket->MMV;
+	        SendMmePacket.MMTYPE=MMTYPE_CM_SLAC_PARM_CNF;
+	        SendMmePacket.FMI[0]=SendMmePacket.FMI[1]=0;
+	        SendMmePacketSize=0;
+	        memset(SendMmePacket.MMENTRY,0xFF,6);       //Fixed value indicating that M-Sounds to be sent as Ethernet broadcast
+	        SendMmePacketSize+=6;
+	        SendMmePacket.MMENTRY[SendMmePacketSize++]=C_EV_match_MNBC;
+	        SendMmePacket.MMENTRY[SendMmePacketSize++]=TT_EVSE_match_MNBC;
+	        SendMmePacket.MMENTRY[SendMmePacketSize++]=0x01;        //Fixed value indicating ��Other GP station��, 0x00 �V HLE of the STA, 0x01 �V Another GP STA, 0x02 �V 0xFF �V Reserved
+	        memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,EvMac,6);
+	        SendMmePacketSize+=6;
+	        SendMmePacket.MMENTRY[SendMmePacketSize++]=0;           //Fixed value indicating ��PEVEVSEMatching��
+	        SendMmePacket.MMENTRY[SendMmePacketSize++]=0;           //Fixed value indicating ��No Security��
+	        memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,SlacRunId,sizeof(SlacRunId));
+	        SendMmePacketSize+=sizeof(SlacRunId);
+	        SendMmePacketSize+=19;      //the size before MMENTRY
+	        #ifdef Debug
+	        printf("\n\n***** Response MME Packet *****\n");
+	        printf("SendMmePacket.ODA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+	               SendMmePacket.ODA[0],SendMmePacket.ODA[1],SendMmePacket.ODA[2],SendMmePacket.ODA[3],SendMmePacket.ODA[4],SendMmePacket.ODA[5]);
+	        printf("SendMmePacket.OSA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+	               SendMmePacket.OSA[0],SendMmePacket.OSA[1],SendMmePacket.OSA[2],SendMmePacket.OSA[3],SendMmePacket.OSA[4],SendMmePacket.OSA[5]);
+	        printf("MTYPE: 0x%x\n", htons(SendMmePacket.MTYPE));
+	        printf("MMV: 0x%x\n", SendMmePacket.MMV);
+	        printf("MMTYPE: 0x%x\n", SendMmePacket.MMTYPE);
+	        printf("FMI 0x%x, 0x%x\n", SendMmePacket.FMI[0],SendMmePacket.FMI[1]);
+	        printf("--- CM_SLAC_PARM_CNF ---\n");
+	        printf("M-SOUND_TARGET: %02x:%02x:%02x:%02x:%02x:%02x\n",
+	               SendMmePacket.MMENTRY[0],SendMmePacket.MMENTRY[1],SendMmePacket.MMENTRY[2],SendMmePacket.MMENTRY[3],
+	               SendMmePacket.MMENTRY[4],SendMmePacket.MMENTRY[5]);
+	        printf("NUM_SOUNDS: 0x%x\n", SendMmePacket.MMENTRY[6]);
+	        printf("Time_Out: 0x%x\n", SendMmePacket.MMENTRY[7]);
+	        printf("RESP_TYPE: 0x%x\n", SendMmePacket.MMENTRY[8]);
+	        printf("M-FORWARDING_STA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+	               SendMmePacket.MMENTRY[9],SendMmePacket.MMENTRY[10],SendMmePacket.MMENTRY[11],SendMmePacket.MMENTRY[12],
+	               SendMmePacket.MMENTRY[13],SendMmePacket.MMENTRY[14]);
+	        printf("APPLICATION_TYPE: 0x%x\n", SendMmePacket.MMENTRY[15]);
+	        printf("SECURITY_TYPE: 0x%x\n", SendMmePacket.MMENTRY[16]);
+	        printf("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	               SendMmePacket.MMENTRY[17],SendMmePacket.MMENTRY[18],SendMmePacket.MMENTRY[19],SendMmePacket.MMENTRY[20],
+	               SendMmePacket.MMENTRY[21],SendMmePacket.MMENTRY[22],SendMmePacket.MMENTRY[23],SendMmePacket.MMENTRY[24]);
+	        #endif
+	        V2gFlowStatus=CM_SLAC_PARM_CONF;
+	        Rtn=sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+	        #ifdef Debug
+	        printf("SendMmePacketSize=%d,Rtn=%d\n",SendMmePacketSize,Rtn);
+	        #endif
+	        ftime(&SeqStartTime);
+	        counter=0;
+	        break;
+		}
+
+	    case MMTYPE_CM_START_ATTEN_CHAR_IND:
+		{
+	        #ifdef Debug
+	        printf("--- MMTYPE_CM_START_ATTEN_CHAR_IND (counter : %d/3 ) ---\n",counter+1);
+	        printf("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
+	        printf("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
+	        printf("NUM_SOUNDS: 0x%x\n", MmePacket->MMENTRY[2]);
+	        printf("Time_Out 0x%x\n", MmePacket->MMENTRY[3]);
+	        printf("RESP_TYPE 0x%x\n", MmePacket->MMENTRY[4]);    //Fixed value (0x01) indicating ��other Green PHY station��
+	        printf("FORWARDING_STA: %02x:%02x:%02x:%02x:%02x:%02x\n",
+	               MmePacket->MMENTRY[5],MmePacket->MMENTRY[6],MmePacket->MMENTRY[7],MmePacket->MMENTRY[8],
+	               MmePacket->MMENTRY[9],MmePacket->MMENTRY[10]);
+	        printf("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	               MmePacket->MMENTRY[11],MmePacket->MMENTRY[12],MmePacket->MMENTRY[13],MmePacket->MMENTRY[14],
+	               MmePacket->MMENTRY[15],MmePacket->MMENTRY[16],MmePacket->MMENTRY[17],MmePacket->MMENTRY[18]);
+	            #endif
+	        MnbcSoundNum=MmePacket->MMENTRY[2];
+	        V2gFlowStatus=CM_START_ATTEN_CHAR_IND;
+	        counter++;
+	        if(counter==1)
+	        {
+	            memset(Aag,0,sizeof(Aag));
+	            AttenProfileNum=0;
+	            ftime(&SeqStartTime);       //start TT_EVSE_match_MNBC
+	        }
+	        else if(counter>=3)
+	        {
+	            counter=0;
+	        }
+	        break;
+		}
+
+	    case MMTYPE_CM_MNBC_SOUND_IND:
+		{
+	        if(V2gFlowStatus>=CM_ATTEN_CHAR_IND)
+	            break;
+	        #ifdef Debug
+	        printf("--- MMTYPE_CM_MNBC_SOUND_IND (counter : %d/%d) ---\n",counter+1,MnbcSoundNum);
+	        printf("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
+	        printf("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
+	        printf("SenderID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	               MmePacket->MMENTRY[2],MmePacket->MMENTRY[3],MmePacket->MMENTRY[4],MmePacket->MMENTRY[5],
+	               MmePacket->MMENTRY[6],MmePacket->MMENTRY[7],MmePacket->MMENTRY[8],MmePacket->MMENTRY[9],
+	               MmePacket->MMENTRY[10],MmePacket->MMENTRY[11],MmePacket->MMENTRY[12],MmePacket->MMENTRY[13],
+	               MmePacket->MMENTRY[14],MmePacket->MMENTRY[15],MmePacket->MMENTRY[16],MmePacket->MMENTRY[17],
+	               MmePacket->MMENTRY[18]);
+	        printf("Cnt: 0x%x\n", MmePacket->MMENTRY[19]);
+	        printf("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	               MmePacket->MMENTRY[20],MmePacket->MMENTRY[21],MmePacket->MMENTRY[22],MmePacket->MMENTRY[23],
+	               MmePacket->MMENTRY[24],MmePacket->MMENTRY[25],MmePacket->MMENTRY[26],MmePacket->MMENTRY[27]);
+	        printf("RSVD: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	               MmePacket->MMENTRY[28],MmePacket->MMENTRY[29],MmePacket->MMENTRY[30],MmePacket->MMENTRY[31],
+	               MmePacket->MMENTRY[32],MmePacket->MMENTRY[33],MmePacket->MMENTRY[34],MmePacket->MMENTRY[35]);
+	        printf("Rnd: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	               MmePacket->MMENTRY[36],MmePacket->MMENTRY[37],MmePacket->MMENTRY[38],MmePacket->MMENTRY[39],
+	               MmePacket->MMENTRY[40],MmePacket->MMENTRY[41],MmePacket->MMENTRY[42],MmePacket->MMENTRY[43],
+	               MmePacket->MMENTRY[44],MmePacket->MMENTRY[45],MmePacket->MMENTRY[46],MmePacket->MMENTRY[47],
+	               MmePacket->MMENTRY[48],MmePacket->MMENTRY[49],MmePacket->MMENTRY[50],MmePacket->MMENTRY[51]);
+	        #endif
+	        V2gFlowStatus=CM_MNBC_SOUND_IND;
+	        counter++;
+	        break;
+		}
+
+	    case MMTYPE_CM_ATTEN_PROFILE_IND:
+		{
+	        if(V2gFlowStatus>=CM_ATTEN_CHAR_IND)
+	        {
+				break;
+			}
+
+	        #ifdef Debug
+	        printf("--- MMTYPE_CM_ATTEN_PROFILE_IND (counter : %d/%d) ---\n",counter,MnbcSoundNum);
+	        printf("EV MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
+	               MmePacket->MMENTRY[0],MmePacket->MMENTRY[1],MmePacket->MMENTRY[2],MmePacket->MMENTRY[3],
+	               MmePacket->MMENTRY[4],MmePacket->MMENTRY[5]);
+	        printf("NumGroups: 0x%x\n", MmePacket->MMENTRY[6]);
+	        printf("RSVD: 0x%x\n", MmePacket->MMENTRY[7]);
+	        printf("AAG: \n");
+	        for(Rtn=0; Rtn<MmePacket->MMENTRY[6]; Rtn++)
+	            printf("%02x, ",MmePacket->MMENTRY[8+Rtn]);
+	        printf("\n");
+	            #endif
+	        AagGroupsNum=MmePacket->MMENTRY[6];
+	        for(Rtn=0; Rtn<MmePacket->MMENTRY[6]; Rtn++)
+	            Aag[Rtn]+=MmePacket->MMENTRY[8+Rtn];
+	        AttenProfileNum++;
+	        V2gFlowStatus=CM_MNBC_SOUND_IND;
+	        break;
+		}
+
+	    case MMTYPE_CM_ATTN_CHAR_RSP:
+		{
+	        #ifdef Debug
+	        printf("--- MMTYPE_CM_ATTN_CHAR_RSP ---\n");
+	        printf("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
+	        printf("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
+	        printf("SOURCE_ADDRESS: %02x:%02x:%02x:%02x:%02x:%02x\n",
+	               MmePacket->MMENTRY[2],MmePacket->MMENTRY[3],MmePacket->MMENTRY[4],MmePacket->MMENTRY[5],
+	               MmePacket->MMENTRY[6],MmePacket->MMENTRY[7]);
+	        printf("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	               MmePacket->MMENTRY[8],MmePacket->MMENTRY[9],MmePacket->MMENTRY[10],MmePacket->MMENTRY[11],
+	               MmePacket->MMENTRY[12],MmePacket->MMENTRY[13],MmePacket->MMENTRY[14],MmePacket->MMENTRY[15]);
+	        printf("SOURCE_ID: \n");
+	        for(Rtn=0; Rtn<17; Rtn++)
+	            printf("%02x, ",MmePacket->MMENTRY[16+Rtn]);
+	        printf("\n");
+	        printf("RESP_ID: \n");
+	        for(Rtn=0; Rtn<17; Rtn++)
+	            printf("%02x, ",MmePacket->MMENTRY[33+Rtn]);
+	        printf("\n");
+	        printf("Result: 0x%x\n", MmePacket->MMENTRY[50]);    //Fixed value of 0x00 indicates a successful SLAC process
+	            #endif
+	        V2gFlowStatus=CM_ATTEN_CHAR_RSP;
+	        ftime(&SeqStartTime);
+	        break;
+		}
+
+	    case MMTYPE_CM_VALIDATE_REQ:
+		{
+	        #ifdef Debug
+	        printf("--- MMTYPE_CM_VALIDATE_REQ ---\n");
+	        printf("Signal Type: 0x%x\n", MmePacket->MMENTRY[0]);    //Fixed value (0x00) to indicate ��PEV S2 toggles on control pilot line��
+	        printf("Timer: 0x%x\n", MmePacket->MMENTRY[1]);    //Fixed value In the first VALIDATE Request-Response exchange, the Timer field shall be set to zero.
+	        printf("Result: 0x%x\n", MmePacket->MMENTRY[2]);    //Fixed value In the first VALIDATE Request-Response exchange, the Result field shall be set to 0x01 = ��ready��.
+	        #endif
+	        counter=0;
+
+	        for(Rtn=0; Rtn<6; Rtn++)
+	        {
+	            if(MmePacket->ODA[Rtn]!=CsuMac[Rtn])
+	            {
+	                counter=1;
+	                break;
+	            }
+	        }
+
+	        memset(&SendMmePacket,0,sizeof(struct MmeHeader));
+	        memcpy(SendMmePacket.ODA,EvMac,6);
+	        memcpy(SendMmePacket.OSA,CsuMac,6);
+	        SendMmePacket.MTYPE=htons(EtherType_HomePlug);
+	        SendMmePacket.MMV=0x01;
+	        SendMmePacket.MMTYPE=MMTYPE_CM_VALIDATE_CNF;
+	        SendMmePacket.FMI[0]=SendMmePacket.FMI[1]=0;
+	        SendMmePacketSize=0;
+	        if(counter==0)
+	        {
+	            //First MMTYPE_CM_VALIDATE_REQ because Unicast
+	            SendMmePacket.MMENTRY[SendMmePacketSize++]=0;    //Fixed value to indicate ��PEV S2 toggles on control pilot line��
+	            SendMmePacket.MMENTRY[SendMmePacketSize++]=0;    //Fixed value In the first VALIDATE Request-Response exchange, the ToggleNum field shall be set to zero.
+	                #ifdef SupportBcbToggle
+	            SendMmePacket.MMENTRY[SendMmePacketSize++]=1;    //0x01 = Ready
+	                #else
+	            SendMmePacket.MMENTRY[SendMmePacketSize++]=4;    //0x04 = Not Required
+	                #endif
+	        }
+	        else
+	        {
+	            //second MMTYPE_CM_VALIDATE_REQ because Broadcast
+	            unsigned char PreStatus=3,ToggleNum=0;
+	            ftime(&SeqStartTime);
+	            while(1)
+	            {
+	                ftime(&SeqEndTime);
+	                if((ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].PilotState==4)&&(PreStatus==3))
+	                {
+	                    ToggleNum++;
+	                    PreStatus=4;
+	                }
+	                else
+	                {
+	                    PreStatus=3;
+	                }
+	                if(DiffTimeb(SeqStartTime, SeqEndTime)>=(SendMmePacket.MMENTRY[1]*100+100))
+	                {
+	                    SendMmePacket.MMENTRY[SendMmePacketSize++]=0;    //Fixed value to indicate ��PEV S2 toggles on control pilot line��
+	                    SendMmePacket.MMENTRY[SendMmePacketSize++]= ToggleNum;
+	                        #ifdef SupportBcbToggle
+	                    SendMmePacket.MMENTRY[SendMmePacketSize++]=2;    //0x02 = Success
+	                        #else
+	                    SendMmePacket.MMENTRY[SendMmePacketSize++]=4;    //0x04 = Not Required
+	                        #endif
+	                    break;
+	                }
+	            }
+	        }
+	        SendMmePacketSize+=19;      //the size before MMENTRY
+	        sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+	        V2gFlowStatus=CM_VALIDATE_CNF;
+	        ftime(&SeqStartTime);
+	        break;
+		}
+
+	    case MMTYPE_CM_SLAC_MATCH_REQ:
+		{
+	        #ifdef Debug
+	        printf("--- MMTYPE_CM_SLAC_MATCH_REQ ---\n");
+	        printf("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
+	        printf("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
+	        printf("MVFLength: 0x%x, 0x%x\n", MmePacket->MMENTRY[2],MmePacket->MMENTRY[3]);    //Fixed value (0x3E) for matching
+	        printf("PEV ID: \n");
+	        for(Rtn=0; Rtn<17; Rtn++)
+	            printf("%02x, ",MmePacket->MMENTRY[4+Rtn]);
+	        printf("\n");
+	        printf("PEV MAC: \n");
+	        for(Rtn=0; Rtn<6; Rtn++)
+	            printf("%02x, ",MmePacket->MMENTRY[21+Rtn]);
+	        printf("\n");
+	        printf("EVSE ID: \n");
+	        for(Rtn=0; Rtn<17; Rtn++)
+	            printf("%02x, ",MmePacket->MMENTRY[27+Rtn]);
+	        printf("\n");
+	        printf("EVSE MAC: \n");
+	        for(Rtn=0; Rtn<6; Rtn++)
+	            printf("%02x, ",MmePacket->MMENTRY[44+Rtn]);
+	        printf("\n");
+	        printf("RunID: \n");
+	        for(Rtn=0; Rtn<8; Rtn++)
+	            printf("%02x, ",MmePacket->MMENTRY[50+Rtn]);
+	        printf("\n");
+	        printf("RSVD: \n");
+	        for(Rtn=0; Rtn<8; Rtn++)
+	            printf("%02x, ",MmePacket->MMENTRY[58+Rtn]);
+	        printf("\n");
+	            #endif
+	        V2gFlowStatus=CM_SLAC_MATCH_REQ;
+	        memset(&SendMmePacket,0,sizeof(struct MmeHeader));
+	        memcpy(SendMmePacket.ODA,MmePacket->OSA,6);
+	        memcpy(SendMmePacket.OSA,CsuMac,6);
+	        SendMmePacket.MTYPE=htons(EtherType_HomePlug);
+	        SendMmePacket.MMV=MmePacket->MMV;
+	        SendMmePacket.MMTYPE=MMTYPE_CM_SLAC_MATCH_CNF;
+	        SendMmePacket.FMI[0]=SendMmePacket.FMI[1]=0;
+	        SendMmePacketSize=0;
+	        SendMmePacket.MMENTRY[SendMmePacketSize++]=0x00;    //Fixed value (0x00) indicating ��PEV-EVSE matching��
+	        SendMmePacket.MMENTRY[SendMmePacketSize++]=0x00;    //Fixed value (0x00) indicating ��No Security��
+	        SendMmePacket.MMENTRY[SendMmePacketSize++]=0x00;    //Fixed value (0x0056) for matching
+	        SendMmePacket.MMENTRY[SendMmePacketSize++]=0x56;    //Fixed value (0x0056) for matching
+	        memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,17);    //PEV ID
+	        SendMmePacketSize+=17;
+	        memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,EvMac,6);
+	        SendMmePacketSize+=6;
+	        memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,17);    //EVSE ID
+	        SendMmePacketSize+=17;
+	        memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,CsuMac,6);
+	        SendMmePacketSize+=6;
+	        memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,SlacRunId,sizeof(SlacRunId));
+	        SendMmePacketSize+=sizeof(SlacRunId);
+	        memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,8);    //RSVD
+	        SendMmePacketSize+=8;
+	        memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,Nid,sizeof(Nid));
+	        SendMmePacketSize+=sizeof(Nid);
+	        SendMmePacket.MMENTRY[SendMmePacketSize++]=0x00;    //RSVD
+	        memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,NewNmkKey,sizeof(NewNmkKey));
+	        SendMmePacketSize+=sizeof(NewNmkKey);
+	        SendMmePacketSize+=19;      //the size before MMENTRY
+	            #ifdef Debug
+	        printf("\n\n***** Response MME Packet *****\n");
+	        printf("SendMmePacket.ODA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+	               SendMmePacket.ODA[0],SendMmePacket.ODA[1],SendMmePacket.ODA[2],SendMmePacket.ODA[3],SendMmePacket.ODA[4],SendMmePacket.ODA[5]);
+	        printf("SendMmePacket.OSA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+	               SendMmePacket.OSA[0],SendMmePacket.OSA[1],SendMmePacket.OSA[2],SendMmePacket.OSA[3],SendMmePacket.OSA[4],SendMmePacket.OSA[5]);
+	        printf("MTYPE: 0x%x\n", htons(SendMmePacket.MTYPE));
+	        printf("MMV: 0x%x\n", SendMmePacket.MMV);
+	        printf("MMTYPE: 0x%x\n", SendMmePacket.MMTYPE);
+	        printf("FMI 0x%x, 0x%x\n", SendMmePacket.FMI[0],SendMmePacket.FMI[1]);
+	        printf("--- CM_SLAC_MATCH_CNF ---\n");
+	        printf("APPLICATION_TYPE: 0x%x\n", SendMmePacket.MMENTRY[0]);
+	        printf("SECURITY_TYPE: 0x%x\n", SendMmePacket.MMENTRY[1]);
+	        printf("MVFLength: 0x%x, 0x%x\n", SendMmePacket.MMENTRY[2],SendMmePacket.MMENTRY[3]);
+	        printf("PEV ID: \n");
+	        for(Rtn=0; Rtn<17; Rtn++)
+	            printf("%02x, ",SendMmePacket.MMENTRY[4+Rtn]);
+	        printf("\n");
+	        printf("PEV MAC: \n");
+	        for(Rtn=0; Rtn<6; Rtn++)
+	            printf("%02x, ",SendMmePacket.MMENTRY[21+Rtn]);
+	        printf("\n");
+	        printf("EVSE ID: \n");
+	        for(Rtn=0; Rtn<17; Rtn++)
+	            printf("%02x, ",SendMmePacket.MMENTRY[27+Rtn]);
+	        printf("\n");
+	        printf("EVSE MAC: \n");
+	        for(Rtn=0; Rtn<6; Rtn++)
+	            printf("%02x, ",SendMmePacket.MMENTRY[44+Rtn]);
+	        printf("\n");
+	        printf("RunID: \n");
+	        for(Rtn=0; Rtn<8; Rtn++)
+	            printf("%02x, ",SendMmePacket.MMENTRY[50+Rtn]);
+	        printf("\n");
+	        printf("RSVD: \n");
+	        for(Rtn=0; Rtn<8; Rtn++)
+	            printf("%02x, ",SendMmePacket.MMENTRY[58+Rtn]);
+	        printf("\n");
+	        printf("NID: \n");
+	        for(Rtn=0; Rtn<7; Rtn++)
+	            printf("%02x, ",SendMmePacket.MMENTRY[66+Rtn]);
+	        printf("\n");
+	        printf("RSVD: 0x%x\n", SendMmePacket.MMENTRY[73]);
+	        printf("NMK: \n");
+	        for(Rtn=0; Rtn<16; Rtn++)
+	            printf("%02x, ",SendMmePacket.MMENTRY[74+Rtn]);
+	        printf("\n");
+	            #endif
+	        V2gFlowStatus=CM_SLAC_MATCH_CNF;
+	        Rtn=sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+	            #ifdef Debug
+	        printf("SendMmePacketSize=%d,Rtn=%d\n",SendMmePacketSize,Rtn);
+	            #endif
+	        ftime(&SeqStartTime);
+	        break;
+		}
+
+	    case MMTYPE_VENDOR_VS_HOST_ACTION:
+	    {
+	        struct QcaVendorMmeHeader *RecvPacket;
+	        RecvPacket = (struct QcaVendorMmeHeader *)Buffer;
+	        //#ifdef Debug
+	        printf("--- MMTYPE_VENDOR_VS_HOST_ACTION ---\n");
+	        //#endif
+	        switch (RecvPacket->MBODY[0])
+	        {
+		        case 0x00:
+		            //Loader (Device Softloader or Bootloader) ready
+		            printf("QCA7K: Loader Ready\n");
+		            break;
+
+		        case 0x01:
+		            //Firmware Upgrade Ready
+		            printf("QCA7K: Firmware Upgrade Ready\n");
+		            break;
+
+		        case 0x02:
+		            //PIB Update Ready
+		            printf("QCA7K: PIB Update Ready\n");
+		            break;
+
+		        case 0x03:
+		            //Firmware Upgrade and PIB Update ready
+		            printf("QCA7K: Firmware Upgrade and PIB Update ready\n");
+		            break;
+
+		        case 0x04:
+		            //Loader (Bootloader) ready to receive SDRAM configuration.
+		            printf("QCA7K: Loader ready to receive SDRAM configuration\n");
+		            break;
+
+		        case 0x05:
+		            //Reset to Factory Defaults.
+		            printf("QCA7K: Reset to Factory Defaults\n");
+		            break;
+
+		        default:
+		            //Reserved
+		            printf("QCA7K: Reserved\n");
+		            break;
+	        }
+			break;
+	    }
+
+	    case MMTYPE_VENDOR_ATTEN_CHAR:
+		{
+	        #ifdef Debug
+	        printf("--- MMTYPE_VENDOR_ATTEN_CHAR ---\n");
+	        #endif
+	        break;
+		}
+
+	    case MMTYPE_VENDOR_VS_NW_INFO_CNF:
+		{
+	        memcpy(QcaMac,MmePacket->OSA,6);
+	            #ifdef Debug
+	        printf("--- MMTYPE_VENDOR_VS_NW_INFO_CNF ---\n");
+	        printf("QcaMac: %02x:%02x:%02x:%02x:%02x:%02x\n",
+	               QcaMac[0],QcaMac[1],QcaMac[2],QcaMac[3],QcaMac[4],QcaMac[5]);
+	            #endif
+	        V2gFlowStatus=CM_SET_KEY_REQ;
+		}
+
+	    default:
+		{
+	        break;
+		}
+    }
+}
+
+int SendSetKey()
+{
+    int i = 0;
+    unsigned char nRandValue = 0x0;
+    unsigned char ConstString[16]="PhihongKey000000";
+
+    memset(&SendMmePacket,0,sizeof(struct MmeHeader));
+    memcpy(SendMmePacket.ODA,QcaMac,6);
+    memcpy(SendMmePacket.OSA,CsuMac,6);
+    SendMmePacket.MTYPE=htons(EtherType_HomePlug);
+    SendMmePacket.MMV=0x01;
+    SendMmePacket.MMTYPE=MMTYPE_CM_SET_KEY_REQ;
+    SendMmePacket.FMI[0]=SendMmePacket.FMI[1]=0;
+    SendMmePacketSize=0;
+    SendMmePacket.MMENTRY[SendMmePacketSize++]=0x01;//Fixed value (0x01) to indicate ��NMK��
+    memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,4);//My Nonce, Fixed value(0x00000000), encrypted payload not used
+    SendMmePacketSize+=4;
+    memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,4);//Your Nonce, Fixed value(0x00000000), encrypted payload not used
+    SendMmePacketSize+=4;
+    SendMmePacket.MMENTRY[SendMmePacketSize++]=0x04;//PID, Fixed value (0x04) to indicate ��HLE protocol��
+    memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,2);//PRN, Fixed value(0x00), encrypted payload not used
+    SendMmePacketSize+=2;
+    SendMmePacket.MMENTRY[SendMmePacketSize++]=0x00;//PMN, Fixed value(0x00) encrypted payload not used
+    SendMmePacket.MMENTRY[SendMmePacketSize++]=0x01;//CCo Capablility
+    srand(time(NULL));
+    for(i=10; i<16; i++)
+    {
+        nRandValue = (rand()%62)+1;
+        if((nRandValue>=0)&&(nRandValue<=9))  // 0 ~ 9
+            ConstString[i]= nRandValue + 0x30;
+        else if((nRandValue>=10)&&(nRandValue<=35)) // A ~ Z
+            ConstString[i]= nRandValue -10 + 0x41;
+        else if((nRandValue>=36)&&(nRandValue<=61)) // a ~ z
+            ConstString[i]= nRandValue -37 + 0x61;
+        else
+            ConstString[i]= 0x30;
+    }
+    memset(NewNmkKey,0,sizeof(NewNmkKey));
+    memset(Nid,0,sizeof(Nid));
+    HPAVKeyNMK(NewNmkKey,ConstString);
+    HPAVKeyNID(Nid,NewNmkKey,DEFAULT_LEVEL);
+    memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,Nid,sizeof(Nid));    //NID, 54 LSBs contain the NID 2 MSBs = 0b00
+    SendMmePacketSize+=sizeof(Nid);
+    SendMmePacket.MMENTRY[SendMmePacketSize++]=0x01;//NewEKS,Fixed value (0x01)to indicate ��NMK��
+    memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,NewNmkKey,sizeof(NewNmkKey));//NewKey
+    SendMmePacketSize+=sizeof(NewNmkKey);
+    SendMmePacketSize+=19;  //the size before MMENTRY
+    V2gFlowStatus=CM_SET_KEY_REQ;
+    i=sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+    #ifdef Debug
+    printf("SendSetKey: send size =%d\n",i);
+    #endif
+
+}
+
+int GetQca7kMac()
+{
+    int i = 0;
+    struct QcaVendorMmeHeader SendPacket;
+
+    memset(&SendPacket,0,sizeof(struct QcaVendorMmeHeader));
+    memset(SendPacket.ODA, 0xFF, 6);
+    memcpy(SendPacket.OSA,CsuMac,6);
+    SendPacket.MTYPE=htons(EtherType_HomePlug);
+    SendPacket.MMV=0x00;
+    SendPacket.MMTYPE=MMTYPE_VENDOR_VS_NW_INFO;
+    SendPacket.OUI[0]=0x00;
+    SendPacket.OUI[1]=0xB0;
+    SendPacket.OUI[2]=0x52;
+
+    i=sendto(RawSock, &SendPacket, 20, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+    #ifdef Debug
+    printf("GetQca7kMac: send size =%d\n",i);
+    #endif
+}
+
+int SlacComm()
+{
+    int packet_size,count;
+    static unsigned int STime;
+
+    if(RawSock>=0)
+    {
+        memset(RecvBuffer,0,RecvBufferSize);
+        packet_size = recvfrom(RawSock, RecvBuffer, RecvBufferSize, 0, NULL, NULL);
+        if(packet_size>0)
+        {
+            /*#ifdef Debug
+               printf("Raw Data: ");
+               for(count=0;count<packet_size;count++)
+                printf("0x%x, ",RecvBuffer[count]);
+               printf("\n");
+             #endif*/
+            MmeProcess(RecvBuffer, packet_size);
+        }
+    }
+    switch(V2gFlowStatus)
+    {
+	    case Idle:
+		{
+	        if(RawSock<0)
+	        {
+	            struct timeval tv;
+	            RawSock= socket(PF_PACKET, SOCK_RAW, htons(EtherType_HomePlug));
+	                #ifdef Debug
+	            printf("RawSock=%d\n",RawSock);
+	                #endif
+	            if(RawSock == -1)
+	            {
+
+	                    #ifdef SystemLogMessage
+	                StoreLogMsg("[EvComm]SlacComm:Failed to create socke");
+	                    #endif
+	                V2gFlowStatus=Other_Fault;
+	                return -1;
+	            }
+	            setsockopt(RawSock, SOL_SOCKET, SO_BINDTODEVICE,QcaInterface, 4);
+	            /*tv.tv_sec = 0;
+	               tv.tv_usec = 10000;
+	               if (setsockopt(RawSock, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct	timeval)) < 0)
+	               {
+	             #ifdef SystemLogMessage
+	               StoreLogMsg("[EvComm]SlacComm:Set SO_RCVTIMEO NG");
+	             #endif
+	               V2gFlowStatus=Other_Fault;
+	               return -1;
+	               }*/
+	            memset(&Req, 0, sizeof(struct ifreq));
+	            strcpy( (char*)Req.ifr_name, QcaInterface);
+	            if (ioctl(RawSock, SIOCGIFINDEX, &Req) < 0)
+	            {
+	                        #ifdef SystemLogMessage
+	                StoreLogMsg("[EvComm]SlacComm: ioctl NG");
+	                    #endif
+	                V2gFlowStatus=Other_Fault;
+	                return -1;
+	            }
+	            memset( &DestSocketAddress, 0, sizeof(struct sockaddr_ll) );
+	            DestSocketAddress.sll_ifindex = Req.ifr_ifindex;
+	            DestSocketAddress.sll_halen = ETH_ALEN;
+	            //Get QCA7K MAC address
+	            GetQca7kMac();
+	            PwmStartTime=0;
+	            count=0;
+	            STime=time(NULL);
+	        }
+	        else
+	        {
+	            if((time(NULL)-STime)>=3)
+	            {
+	                if((count++) >=3)
+	                    V2gFlowStatus=Sequence_Timeout;
+	                else
+	                {
+	                    GetQca7kMac();
+	                    STime=time(NULL);
+	                }
+	            }
+	        }
+	        break;
+		}
+
+	    case CM_SET_KEY_REQ:
+		{
+	        //CM_SET_KEY_REQ
+	        SendSetKey();
+	        break;
+		}
+
+	    case CM_SET_KEY_CNF:
+		{
+	        OutputCpPwmDuty(5);
+	        if(PwmStartTime<=0)
+	            PwmStartTime=time(NULL);
+	        else
+	        {
+	            if((time(NULL)-PwmStartTime)>TT_EVSE_SLAC_init)
+	            {
+	                    #ifdef SystemLogMessage
+	                StoreLogMsg("[EvComm]SlacComm: Wait CM_SLAC_PARM_REQ Timeout - TT_EVSE_SLAC_init ");
+	                    #endif
+	                V2gFlowStatus=Sequence_Timeout;
+	                return -1;
+	            }
+	        }
+	        break;
+		}
+
+	    case CM_SLAC_PARM_CONF:
+		{
+	        ftime(&SeqEndTime);
+	        if(DiffTimeb(SeqStartTime, SeqEndTime)>TT_match_sequence)
+	        {
+	                #ifdef SystemLogMessage
+	            StoreLogMsg("[EvComm]SlacComm: Wait CM_START_ATTEN_CHAR_IND Timeout - TT_match_sequence ");
+	                #endif
+	            V2gFlowStatus=Sequence_Timeout;
+	            return -1;
+	        }
+	        break;
+		}
+
+	    case CM_START_ATTEN_CHAR_IND:
+		{
+	        ftime(&SeqEndTime);
+	        if(DiffTimeb(SeqStartTime, SeqEndTime)>(3*TP_EV_batch_msg_interval))    //one more time interval for tolerance
+	        {
+	                #ifdef SystemLogMessage
+	            StoreLogMsg("[EvComm]SlacComm: Wait CM_MNBC_SOUND_IND Timeout - 3*TP_EV_batch_msg_interval ");
+	                #endif
+	            V2gFlowStatus=Sequence_Timeout;
+	            return -1;
+	        }
+	        break;
+		}
+
+	    case CM_MNBC_SOUND_IND:
+		{
+	        ftime(&SeqEndTime);
+	        if(DiffTimeb(SeqStartTime, SeqEndTime)>(TT_EVSE_match_MNBC*100)||(AttenProfileNum>=MnbcSoundNum))
+	        {
+	            memset(&SendMmePacket,0,sizeof(struct MmeHeader));
+	            memcpy(SendMmePacket.ODA,EvMac,6);
+	            memcpy(SendMmePacket.OSA,CsuMac,6);
+	            SendMmePacket.MTYPE=htons(EtherType_HomePlug);
+	            SendMmePacket.MMV=0x01;
+	            SendMmePacket.MMTYPE=MMTYPE_CM_ATTN_CHAR_IND;
+	            SendMmePacket.FMI[0]=SendMmePacket.FMI[1]=0;
+	            SendMmePacketSize=0;
+	            SendMmePacket.MMENTRY[SendMmePacketSize++]=0;    //APPLICATION_TYPE,  Fixed value indicating ��PEVEVSE matching��
+	            SendMmePacket.MMENTRY[SendMmePacketSize++]=0;    //SECURITY_TYPE, Fixed value indicating ��No Security��
+	            memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,EvMac,6);    //SOURCE_ADDRESS, MAC address of the EV Host
+	            SendMmePacketSize+=6;
+	            memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,SlacRunId,sizeof(SlacRunId));
+	            SendMmePacketSize+=sizeof(SlacRunId);
+	            memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,17);    //SOURCE_ID
+	            SendMmePacketSize+=17;
+	            memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,17);    //RESP_ID
+	            SendMmePacketSize+=17;
+	            SendMmePacket.MMENTRY[SendMmePacketSize++]=AttenProfileNum;    //NumSounds
+	            SendMmePacket.MMENTRY[SendMmePacketSize++]=AagGroupsNum;    //NumGroups
+	            for(count=0; count<AagGroupsNum; count++)
+	            {
+	                unsigned char TmpAag;
+	                TmpAag=((Aag[count]/AttenProfileNum)&0xFF);
+	                if(TmpAag>=39)
+	                {
+						/*
+						// [To-do] If this statement is enabled, SLAC will fail due to timeout.
+	                    #ifdef SystemLogMessage
+	                    {
+	                        unsigned char TmpBuf[64];
+	                        memset(TmpBuf,0,sizeof(TmpBuf));
+	                        sprintf(TmpBuf,"[EvComm]SlacComm: bad Aag[%d]=%d",count,TmpAag);
+	                        StoreLogMsg(TmpBuf);
+	                    }
+	                    #endif
+						*/
+	                    TmpAag=37;
+	                }
+	                SendMmePacket.MMENTRY[SendMmePacketSize++]=TmpAag;
+	            }
+	            SendMmePacketSize+=19;      //the size before MMENTRY
+	                #ifdef Debug
+	            printf("\n\n***** Send MME Packet *****\n");
+	            printf("SendMmePacket.ODA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+	                   SendMmePacket.ODA[0],SendMmePacket.ODA[1],SendMmePacket.ODA[2],SendMmePacket.ODA[3],SendMmePacket.ODA[4],SendMmePacket.ODA[5]);
+	            printf("SendMmePacket.OSA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+	                   SendMmePacket.OSA[0],SendMmePacket.OSA[1],SendMmePacket.OSA[2],SendMmePacket.OSA[3],SendMmePacket.OSA[4],SendMmePacket.OSA[5]);
+	            printf("MTYPE: 0x%x\n", htons(SendMmePacket.MTYPE));
+	            printf("MMV: 0x%x\n", SendMmePacket.MMV);
+	            printf("MMTYPE: 0x%x\n", SendMmePacket.MMTYPE);
+	            printf("FMI 0x%x, 0x%x\n", SendMmePacket.FMI[0],SendMmePacket.FMI[1]);
+	            printf("--- CM_ATTEN_CHAR_IND ---\n");
+	            printf("APPLICATION_TYPE: 0x%x\n", SendMmePacket.MMENTRY[0]);
+	            printf("SECURITY_TYPE: 0x%x\n", SendMmePacket.MMENTRY[1]);
+	            printf("SOURCE_ADDRESS: %02x:%02x:%02x:%02x:%02x:%02x\n",
+	                   SendMmePacket.MMENTRY[2],SendMmePacket.MMENTRY[3],SendMmePacket.MMENTRY[4],SendMmePacket.MMENTRY[5],
+	                   SendMmePacket.MMENTRY[6],SendMmePacket.MMENTRY[7]);
+	            printf("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	                   SendMmePacket.MMENTRY[8],SendMmePacket.MMENTRY[9],SendMmePacket.MMENTRY[10],SendMmePacket.MMENTRY[11],
+	                   SendMmePacket.MMENTRY[12],SendMmePacket.MMENTRY[13],SendMmePacket.MMENTRY[14],SendMmePacket.MMENTRY[15]);
+	            printf("SOURCE_ID: \n");
+	            for(count=0; count<17; count++)
+	                printf("%02x, ",SendMmePacket.MMENTRY[16+count]);
+	            printf("\n");
+	            printf("RESP_ID: \n");
+	            for(count=0; count<17; count++)
+	                printf("%02x, ",SendMmePacket.MMENTRY[33+count]);
+	            printf("\n");
+	            printf("NumSounds: 0x%x\n", SendMmePacket.MMENTRY[50]);
+	            printf("ATTEN_PROFILE: \n");
+	            for(count=0; count<AagGroupsNum; count++)
+	                printf("%02x, ",SendMmePacket.MMENTRY[51+count]);
+	            printf("\n");
+	                #endif
+	            V2gFlowStatus=CM_ATTEN_CHAR_IND;
+	            count=sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+	                #ifdef Debug
+	            printf("SendMmePacketSize=%d,Rtn=%d\n",SendMmePacketSize,count);
+	                #endif
+	            ftime(&SeqStartTime);
+	        }
+	        break;
+		}
+
+	    case CM_ATTEN_CHAR_IND:
+		{
+	        ftime(&SeqEndTime);
+	        //if(DiffTimeb(SeqStartTime, SeqEndTime)>TT_match_response)
+	        if(DiffTimeb(SeqStartTime, SeqEndTime)>TT_match_response*2)     //extended to 400ms due to the response of CM_ATTEN_CHAR.RSP of some EVCC is slower than 200ms.
+	        {
+	                #ifdef SystemLogMessage
+	            StoreLogMsg("[EvComm]SlacComm: Wait CM_ATTEN_CHAR_RSP Timeout - TT_match_response ");
+	                #endif
+	            V2gFlowStatus=Sequence_Timeout;
+	            return -1;
+	        }
+	        break;
+		}
+
+	    case CM_ATTEN_CHAR_RSP:
+		{
+	        ftime(&SeqEndTime);
+	        if(DiffTimeb(SeqStartTime, SeqEndTime)>TT_EVSE_match_session)
+	        {
+	                #ifdef SystemLogMessage
+	            StoreLogMsg("[EvComm]SlacComm: Wait CM_VALIDATE_REQ or CM_SLAC_MATCH_REQ Timeout - TT_EVSE_match_session ");
+	                #endif
+	            V2gFlowStatus=Sequence_Timeout;
+	            return -1;
+	        }
+	        break;
+		}
+
+	    case CM_VALIDATE_CNF:
+		{
+	        ftime(&SeqEndTime);
+	        if(DiffTimeb(SeqStartTime, SeqEndTime)>TT_match_sequence)
+	        {
+	                #ifdef SystemLogMessage
+	            StoreLogMsg("[EvComm]SlacComm: Wait CM_VALIDATE_CNF or CM_SLAC_MATCH_REQ Timeout - TT_match_sequence ");
+	                #endif
+	            V2gFlowStatus=Sequence_Timeout;
+	            return -1;
+	        }
+	        break;
+		}
+
+	    case CM_SLAC_MATCH_CNF:
+		{
+	        if(UdpSock>0)
+	        {
+	            close(UdpSock);
+	            UdpSock=-1;
+	        }
+	        if(TcpSock>0)
+	        {
+	            close(TcpSock);
+	            TcpSock=-1;
+	        }
+	        ftime(&SeqStartTime);
+	        V2gFlowStatus=SLACC_SDP_UDP_Connection;
+	        break;
+		}
+
+		defaudlt:
+		{
+		    break;
+		}
+    }
+    return 0;
+}
+
+int V2gMsgProcess(unsigned char *Buffer, int DataLength)
+{
+    struct V2gtpHeader *RecvHeader;
+    unsigned char *PayloadData;
+
+    RecvHeader= (struct V2gtpHeader *) Buffer;
+
+    #ifdef Debug
+    printf("\n\n***********************************\n");
+    printf("***** Received V2G Packet *****\n");
+    printf("***********************************\n");
+    printf("ProtocolVersion=%d\n",RecvHeader->ProtocolVersion);
+    printf("InverseProtocolVersion=0x%x\n",RecvHeader->InverseProtocolVersion);
+    printf("PayloadType=0x%x\n",htons(RecvHeader->PayloadType));
+    printf("PayloadLength=0x%x\n",htonl(RecvHeader->PayloadLength));
+    #endif
+
+    if(htons(RecvHeader->PayloadType)!=V2GTP_PAYLOAD_TYPE_EXI_MSG)
+    {
+        #ifdef SystemLogMessage
+        StoreLogMsg("[EvComm]V2gMsgProcess: Wrong Payload Type");
+        #endif
+        return 0;
+    }
+    //EXI decode
+    //process received message and change status flag
+
+}
+
+int V2gComm(int AcceptFd)
+{
+    int packet_size,count;
+
+    memset(RecvBuffer,0,RecvBufferSize);
+    packet_size=recv(AcceptFd, RecvBuffer, RecvBufferSize, 0);
+    if(packet_size>0)
+    {
+        /*#ifdef Debug
+           printf("V2gComm Data: ");
+           for(count=0;count<packet_size;count++)
+            printf("0x%x, ",RecvBuffer[count]);
+           printf("\n");
+         #endif*/
+        V2gMsgProcess(RecvBuffer, packet_size);
+    }
+    //following are the response message handling according to status flag
+    switch(V2gFlowStatus)
+    {
+	    case SupportedAppProtocolRequest:
+	        break;
+	    default:
+	        break;
+    }
+    return 0;
+}
+
+int SdpUdpConnected()
+{
+    int packet_size,Rtn;
+    struct sockaddr_in6 ServerAddr,ClientAddr;
+    struct V2gtpHeader *RecvHeader;
+    unsigned char *PayloadData;
+
+    if(UdpSock<=0)
+    {
+        if ((UdpSock = socket(AF_INET6, SOCK_DGRAM, 0)) <0)
+        {
+                    #ifdef SystemLogMessage
+            StoreLogMsg("[EvComm]SdpUdpConnected: Fail to open UdpSock");
+            #endif
+            return 0;
+        }
+        memset(&ServerAddr,0, sizeof(struct sockaddr_in));
+        ServerAddr.sin6_family = AF_INET6;
+        ServerAddr.sin6_addr=in6addr_any;
+        ServerAddr.sin6_port = htons(SdpUdpServerPort);
+        if(bind(UdpSock, (struct sockaddr *)&ServerAddr, sizeof(struct sockaddr_in6)) <0)
+        {
+                    #ifdef SystemLogMessage
+            StoreLogMsg("[EvComm]SdpUdpConnected: Fail to bind UdpSock");
+            #endif
+            close(UdpSock);
+            UdpSock=-1;
+            return 0;
+        }
+            #ifdef Debug
+        printf("UdpSock=%d\n",UdpSock);
+            #endif
+    }
+    memset(RecvBuffer,0,RecvBufferSize);
+    memset(&ClientAddr,0, sizeof(struct sockaddr_in));
+    Rtn=sizeof(struct sockaddr_in6);
+    packet_size = recvfrom(UdpSock, RecvBuffer, RecvBufferSize, MSG_DONTWAIT, (struct sockaddr *)&ClientAddr, &Rtn);
+    #ifdef Debug
+    printf("packet_size=%d\n",packet_size);
+        #endif
+    if(packet_size>0)
+    {
+        RecvHeader= (struct V2gtpHeader *) RecvBuffer;
+        PayloadData=RecvBuffer+sizeof(struct V2gtpHeader);
+        #ifdef Debug
+        printf("\n\n***********************************\n");
+        printf("***** Received SDP Packet *****\n");
+        printf("***********************************\n");
+        printf("ClientAddress=");
+        for(Rtn=0; Rtn<16; Rtn+=2)
+            printf("%02x%02x:",ClientAddr.sin6_addr.s6_addr[Rtn],ClientAddr.sin6_addr.s6_addr[Rtn+1]);
+        printf("\n");
+        printf("ClientPort=%d\n",ClientAddr.sin6_port);
+        printf("ProtocolVersion=%d\n",RecvHeader->ProtocolVersion);
+        printf("InverseProtocolVersion=0x%x\n",RecvHeader->InverseProtocolVersion);
+        printf("PayloadType=0x%x\n",htons(RecvHeader->PayloadType));
+        printf("PayloadLength=0x%x\n",htonl(RecvHeader->PayloadLength));
+        #endif
+        if((RecvHeader->ProtocolVersion==0x01)&&(RecvHeader->InverseProtocolVersion==0xFE)&&(htons(RecvHeader->PayloadType)==V2GTP_PAYLOAD_TYPE_SDP_REQUEST))
+        {
+            #ifdef Debug
+            printf("Security=0x%x\n",*(PayloadData+0));
+            printf("TransportProtocol=0x%x\n",*(PayloadData+1));
+            #endif
+            RecvHeader->PayloadType=htons(V2GTP_PAYLOAD_TYPE_SDP_RESPONSE);
+            RecvHeader->PayloadLength=htonl(20);    //Fixed Length=20
+            memset(PayloadData,0,20);
+            // MAC address[0:2] + FFFE + MAC address[3:5]
+            PayloadData[0]=(IPV6_LINK_LOCAL_PREFIX>>8)&0xFF;
+            PayloadData[1]=IPV6_LINK_LOCAL_PREFIX&0xFF;
+            PayloadData[8]=CsuMac[0];
+            PayloadData[8]^=0x02;// bit 1 should complemented.
+            PayloadData[9]=CsuMac[1];
+            PayloadData[10]=CsuMac[2];
+            PayloadData[11]=0xFF;
+            PayloadData[12]=0xFE;
+            PayloadData[13] =CsuMac[3];
+            PayloadData[14]=CsuMac[4];
+            PayloadData[15]=CsuMac[5];
+            //TCP port
+            PayloadData[16]=(SdpTcpServerPort>>8)&0xFF;
+            PayloadData[17]=SdpTcpServerPort&0xFF;
+            PayloadData[18]=SDP_PAYLOAD_SECURITY_NONE;      //Security
+            PayloadData[19]=SDP_PAYLOAD_TRANS_PROTOCOL_TCP; //Transport protocol
+            Rtn=sendto(UdpSock, RecvBuffer, sizeof(struct V2gtpHeader)+htonl(RecvHeader->PayloadLength), 0, (struct sockaddr *)&ClientAddr, sizeof(struct sockaddr_in6));
+            #ifdef Debug
+            printf("\n\n***** Response SDP Packet *****\n");
+            printf("Send size=%d\n",Rtn);
+            printf("Destination Address=");
+            for(Rtn=0; Rtn<16; Rtn++)
+                printf("%02x, ",ClientAddr.sin6_addr.s6_addr[Rtn]);
+            printf("\n");
+            printf("Destination Port=%d\n",ClientAddr.sin6_port);
+            printf("ProtocolVersion=%d\n",RecvHeader->ProtocolVersion);
+            printf("InverseProtocolVersion=0x%x\n",RecvHeader->InverseProtocolVersion);
+            printf("PayloadType=0x%x\n",htons(RecvHeader->PayloadType));
+            printf("PayloadLength=0x%x\n",htonl(RecvHeader->PayloadLength));
+            printf("SECC Ipv6 Address=");
+            for(Rtn=0; Rtn<16; Rtn++)
+                printf("%02x:",PayloadData[Rtn]);
+            printf("\n");
+            printf("SECC Port=%d\n",(PayloadData[16]<<8|PayloadData[17]));
+            printf("Security=0x%x\n",PayloadData[19]);
+            printf("TransportProtocol=0x%x\n",PayloadData[20]);
+            #endif
+            if(Rtn>0)
+                return 1;
+        }
+    }
+    return 0;
+}
+
+int V2gTcpConnected()
+{
+    int packet_size,Rtn,AcceptFd;
+    struct sockaddr_in6 ServerAddr,ClientAddr;
+
+    if(TcpSock<=0)
+    {
+        if ((TcpSock = socket(PF_INET6, SOCK_STREAM, 0)) <0)
+        {
+                    #ifdef SystemLogMessage
+            StoreLogMsg("[EvComm]V2gTcpConnected: Fail to open TcpSock");
+            #endif
+            return 0;
+        }
+        fcntl(TcpSock, F_SETFL, O_NONBLOCK);    //set to O_NONBLOCK
+        memset(&ServerAddr,0, sizeof(struct sockaddr_in));
+        ServerAddr.sin6_family = PF_INET6;
+        ServerAddr.sin6_addr=in6addr_any;
+        ServerAddr.sin6_port = htons(SdpTcpServerPort);
+        if(bind(TcpSock, (struct sockaddr *)&ServerAddr, sizeof(struct sockaddr_in6)) <0)
+        {
+                    #ifdef SystemLogMessage
+            StoreLogMsg("[EvComm]V2gTcpConnected: Fail to bind TcpSock");
+            #endif
+            close(TcpSock);
+            TcpSock=-1;
+            return 0;
+        }
+        if(listen(TcpSock, 1) == -1)     //only accept one connection
+        {
+                #ifdef SystemLogMessage
+            StoreLogMsg("[EvComm]V2gTcpConnected: Fail to listen TcpSock");
+            #endif
+            close(TcpSock);
+            TcpSock=-1;
+            return 0;
+        }
+            #ifdef Debug
+        printf("TcpSock=%d\n",TcpSock);
+            #endif
+    }
+    Rtn=sizeof(struct sockaddr_in6);
+    if((AcceptFd=accept(TcpSock,(struct sockaddr *)&ClientAddr,&Rtn))==-1)
+    {
+        #ifdef Debug
+        printf("Wait TCP connection\n");
+        #endif
+        return 0;
+    }
+    #ifdef Debug
+    printf("Accept one TCP connection:\n");
+    printf("AcceptFd=%d\n",AcceptFd);
+    printf("ClientAddress=");
+    for(Rtn=0; Rtn<16; Rtn+=2)
+        printf("%02x%02x:",ClientAddr.sin6_addr.s6_addr[Rtn],ClientAddr.sin6_addr.s6_addr[Rtn+1]);
+    printf("\n");
+    printf("ClientPort=%d\n",ClientAddr.sin6_port);
+    #endif
+    return AcceptFd;
+}
+
+int main(int argc,char *argv[])
+{
+    unsigned char Rtn;
+    int TcpAcceptFd;
+    //Initialization
+    InitShareMemory();
+    //start to detect pilot state
+    PilotDetectionPid=0;
+    PilotDetection();
+    //Init communication parameters
+    GetEthMac(QcaInterface, CsuMac);
+    RecvBuffer=(unsigned char *)malloc(RecvBufferSize);
+    memset(RecvBuffer,0,RecvBufferSize);
+    SendBuffer=(unsigned char *)malloc(SendBufferSize);
+    memset(SendBuffer,0,SendBufferSize);
+    if(RawSock>0)
+        close(RawSock);
+    if(UdpSock>0)
+        close(UdpSock);
+    if(TcpSock>0)
+        close(TcpSock);
+    RawSock=UdpSock=TcpSock=-1;
+    V2gFlowStatus=0;
+    AttenProfileNum=0;
+    while(1)
+    {
+        #ifdef Debug
+        printf("V2gFlowStatus=%d\n",V2gFlowStatus);
+        #endif
+        //if((ShmInternalComm->ChargingPermission==0x01)&&(ConnectorPlugIn()==1))
+        if(1)
+        {
+            if(V2gFlowStatus<SLACC_SDP_UDP_Connection)
+                SlacComm();
+            else if(V2gFlowStatus==SLACC_SDP_UDP_Connection)
+            {
+                if(SdpUdpConnected()==1)
+                {
+                    V2gFlowStatus=SLACC_SDP_TCP_Connection;
+                    continue;
+                }
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime)>TT_match_join)
+                {
+                    #ifdef SystemLogMessage
+                    StoreLogMsg("[EvComm]main: Wait SLACC_SDP_UDP_Connection Timeout - TT_match_join ");
+                    #endif
+                    V2gFlowStatus=Sequence_Timeout;
+                }
+            }
+            else if(V2gFlowStatus==SLACC_SDP_TCP_Connection)
+            {
+                if((TcpAcceptFd=V2gTcpConnected())>0)
+                {
+                    V2gFlowStatus=SupportedAppProtocolRequest;
+                    continue;
+                }
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime)>TT_match_join)
+                {
+                    #ifdef SystemLogMessage
+                    StoreLogMsg("[EvComm]main: Wait SLACC_SDP_TCP_Connection Timeout - TT_match_join ");
+                    #endif
+                    V2gFlowStatus=Sequence_Timeout;
+                }
+            }
+            else if(V2gFlowStatus<Performance_Timeout)
+                V2gComm(TcpAcceptFd);
+        }
+        if(V2gFlowStatus>=Performance_Timeout)
+        {
+            //Normal Stop
+            //alarm and duty to 100%
+            OutputCpPwmDuty(100);
+            goto ReSet;
+        }
+        /*else if((ConnectorPlugIn()==0)&&(V2gFlowStatus>Idle))
+           {
+            //Emergency stop
+            OutputCpPwmDuty(100);
+            goto ReSet;
+           }*/
+        continue;
+
+ReSet:
+        if(RawSock>0)
+            close(RawSock);
+        if(UdpSock>0)
+            close(UdpSock);
+        if(TcpSock>0)
+        {
+            close(TcpSock);
+            close(TcpAcceptFd);
+        }
+        RawSock=UdpSock=TcpSock=TcpAcceptFd=-1;
+        V2gFlowStatus=0;
+        while(1)
+        {
+            //wait for CSU configrm
+        }
+    }//main while
+}

EVSE/Projects/AW-CCS/Apps/CCS/EvComm.h

@@ -0,0 +1,109 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                EVComm.h
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+   =============================================================================*/
+
+#ifndef EVCOMM_H_
+#define EVCOMM_H_
+
+
+#define QcaInterface                        "eth0"
+#define SupportBcbToggle
+#define SdpUdpServerPort                    15118
+#define SdpTcpServerPort                    59438   //49152-65535
+#define IPV6_LINK_LOCAL_PREFIX              0xFE80
+
+/***********************************************/
+/*********** Ethernet Type ********************/
+/**********************************************/
+#define EtherType_HomePlug                  0x88E1
+
+/***********************************************/
+/*** MMTYPE (Management Message Type) **/
+/**********************************************/
+#define MMTYPE_CM_SET_KEY_REQ               0x6008
+#define MMTYPE_CM_SET_KEY_CNF               0x6009
+#define MMTYPE_CM_SLAC_PARM_REQ             0x6064
+#define MMTYPE_CM_SLAC_PARM_CNF             0x6065
+#define MMTYPE_CM_START_ATTEN_CHAR_IND      0x606A
+#define MMTYPE_CM_MNBC_SOUND_IND            0x6076
+#define MMTYPE_CM_ATTN_CHAR_IND             0x606E
+#define MMTYPE_CM_ATTN_CHAR_RSP             0x606F
+#define MMTYPE_CM_VALIDATE_REQ              0x6078
+#define MMTYPE_CM_VALIDATE_CNF              0x6079
+#define MMTYPE_CM_SLAC_MATCH_REQ            0x607C
+#define MMTYPE_CM_SLAC_MATCH_CNF            0x607D
+#define MMTYPE_CM_ATTEN_PROFILE_IND         0x6086
+//following are the vendor specific type
+#define MMTYPE_VENDOR_VS_HOST_ACTION        0xA062      //Embedded Host Action Requested Indication MME
+#define MMTYPE_VENDOR_ATTEN_CHAR            0xA14E      //Attenuation Characteristics MME (VS_ATTEN_CHAR)
+#define MMTYPE_VENDOR_VS_NW_INFO            0xA038      //Network Info MME
+#define MMTYPE_VENDOR_VS_NW_INFO_CNF        0xA039      //Network Info MME
+
+/***********************************************/
+/************** V2GTP Payload Type ************/
+/**********************************************/
+#define V2GTP_PAYLOAD_TYPE_SDP_REQUEST      0x9000      //SDP request message
+#define V2GTP_PAYLOAD_TYPE_SDP_RESPONSE     0x9001      //SDP response message
+#define V2GTP_PAYLOAD_TYPE_EXI_MSG          0x8001      //EXI encoded V2G Message
+//Payload
+#define SDP_PAYLOAD_SECURITY_TLS            0x00            //0x00 = secured with TLS
+#define SDP_PAYLOAD_SECURITY_NONE           0x10            //0x10 = No transport layer security
+#define SDP_PAYLOAD_TRANS_PROTOCOL_TCP      0x00            //0x00= TCP
+#define SDP_PAYLOAD_TRANS_PROTOCOL_UDP      0x10            //0x10 = reserved for UDP
+/***********************************************/
+/****** Timing and constant values **********/
+/*********** [2015] ISO 15118_3 ***************/
+/**********************************************/
+#define C_EV_match_MNBC                     0x0A
+#define TT_EVSE_SLAC_init                   50          //unit: sec.
+#define TT_match_sequence                   400         //unit: ms
+#define TT_EVSE_match_MNBC                  6           //unit: 100ms
+#define TP_match_response                   100         //unit: ms, General performance time for a response to a request
+#define TT_match_response                   200         //unit: ms, Time that the EV/EVSE shall wait for a response from the EVSE/EV
+#define TP_EV_batch_msg_interval            50          //unit: ms
+#define TT_EVSE_match_session               10000       //unit: ms
+#define TT_match_join                       12000       //unit: ms
+/***********************************************/
+/*************** Structure *********************/
+/**********************************************/
+struct MmeHeader
+{
+    unsigned char ODA[6];       //Original Destination Address
+    unsigned char OSA[6];           //Original source Address
+    //unsigned int VLAN Tag;        //IEEE802.1Q VLAN Tag (optional)
+    unsigned short MTYPE;           //Ethernet Type for HomePlug, should be 0x88E1
+    unsigned char MMV;          //Management Message Version
+    unsigned short MMTYPE;      //Management Message Type
+    unsigned char FMI[2];           //Fragmentation Management Information, Fragmentation Message Sequence Number
+    unsigned char MMENTRY[256]; //Management Message Entry Data
+} __attribute__((packed));
+
+//Qualcomm Atheros Vendor Specific MME Format
+struct QcaVendorMmeHeader
+{
+    unsigned char ODA[6];       //Original Destination Address
+    unsigned char OSA[6];           //Original source Address
+    //unsigned int VLAN Tag;        //IEEE802.1Q VLAN Tag (optional)
+    unsigned short MTYPE;           //Ethernet Type for HomePlug, should be 0x88E1
+    unsigned char MMV;          //Management Message Version
+    unsigned short MMTYPE;      //Management Message Type
+    unsigned char OUI[3];           //Fragmentation Management Information, Fragmentation Message Sequence Number
+    unsigned char MBODY[1024];  //Management Message Entry Data
+} __attribute__((packed));
+
+struct V2gtpHeader
+{
+    unsigned char ProtocolVersion;          //0x01: V2GTP version 1, 0x00, 0x02-0xFF reserved
+    unsigned char InverseProtocolVersion;   //Equals the <Protocol_Version> XOR 0xFF, 0xFE: V2GTP Version 1
+    unsigned short PayloadType;             //0x8001:	EXI encoded V2G Message,
+    //0x9000:	SDP request message,
+    //0x9001:	SDP response message,
+    //0xA000 - 0xFFFF:	Manufacturer specific use
+    unsigned int PayloadLength;         //excluding the generic V2GTP header byte
+} __attribute__((packed));
+
+#endif

EVSE/Projects/AW-CCS/Apps/CCS/EventLogging.c

@@ -0,0 +1,508 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                             EventLogging.c
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+#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 "define.h"
+#include "EventLogging.h"
+
+//#define Debug
+
+struct SysConfigAndInfo         *ShmSysConfigAndInfo;
+struct StatusCodeData           *ShmStatusCodeData;
+unsigned char buf_log_eventlogging[SIZE_OF_LOG_BUFFER];
+
+/**************************************************************************************/
+/**************************Alarm Share memory**************************************/
+/***************************************************************************************
+	Status Code	A			B				C									D	E	F
+				0: Issue		1: From EVSE 		1: Fault (unrecoverable)					001 ~ 999 serial number
+			    								e.g., hardware broken, system latch
+				1: Recovered	2: From EV		2: Alarm (recoverable)
+			   								e.g., OTP, OVP
+							3: From Backend	3: Information
+			  								e.g., swipe card to stop charging
+
+according to XXX.Revxx
+***************************************************************************************/
+/**************************************************************************************/
+char FaultStatusCode[32][6]=
+{
+	"011001",	//CHAdeMO output fuse blew
+	"011002",	//CCS output fuse blew
+	"011003",	//GB output fuse blew
+	"011004",	//RCD/CCID self-test fail
+	"011005",	//AC input contactor 1 welding
+	"011006",	//AC input contactor 1 driving fault
+	"011007",	//AC input contactor 2 welding
+	"011008",	//AC input contactor 2 driving fault
+	"011009",	//AC output relay welding
+	"011010",	//AC output relay  driving fault
+	"011011",	//CHAdeMO output relay welding
+	"011012",	//CHAdeMO output relay driving fault
+	"011013",	//CCS output relay welding
+	"011014",	//CCS output relay driving fault
+	"011015",	//GB output relay welding
+	"011016",	//GB output relay driving fault
+	"011017",	//AC connector temperature sensor broken
+	"011018",	//CHAdeMO connector temperature sensor broken
+	"011019",	//CCS connector temperature sensor broken
+	"011020",	//GB connector temperature sensor broken
+	"011021",	//WiFi module broken
+	"011022",	//3G/4G module broken
+	"011023",	//Aux. power module broken
+	"011024",	//Relay control module /smart box broken
+	"011025",	//CHAdeMO connector lock fail
+	"011026",	//GB connector lock fail
+	"011027",	//AC connector lock fail
+	"011028",	//CHAdeMO module broken
+	"011029",	//CCS module broken
+	"011030",	//GBT module broken
+	"011031",	//PSU module broken
+	"011032"	//Reserved
+};
+
+char AlarmStatusCode[64][6]=
+{
+	"012200",	//System L1 input OVP
+	"012201",	//System L2 input OVP
+	"012202",	//System L3 input OVP
+	"012203",	//System L1 input UVP
+	"012204",	//System L2 input UVP
+	"012205",	//System L3 input UVP
+	"012206",	//PSU L1 input OVP
+	"012207",	//PSU L2 input OVP
+	"012208",	//PSU L3 input OVP
+	"012209",	//PSU L1 input UVP
+	"012210",	//PSU L2 input UVP
+	"012211",	//PSU L3 input UVP
+	"012212",	//System L1 input drop
+	"012213",	//System L2 input drop
+	"012214",	//System L3 input drop
+	"012215",	//System AC output OVP
+	"012216",	//System AC output OCP
+	"012217",	//System CHAdeMO output OVP
+	"012218",	//System CHAdeMO output OCP
+	"012219",	//System CCS output OVP
+	"012220",	//System CCS output OCP
+	"012221",	//System GB output OVP
+	"012222",	//System GB output OCP
+	"012223",	//System ambient/inlet OTP
+	"012224",	//System critical point OTP
+	"012225",	//PSU ambient/inlet OTP
+	"012226",	//PSU critical point OTP
+	"012227",	//Aux. power module OTP
+	"012228",	//Relay board/smart box OTP
+	"012229",	//CHAdeMO connector OTP
+	"012230",	//CCS connector OTP
+	"012231",	//GB connector OTP
+	"012232",	//AC connector OTP
+	"012233",	//RCD/CCID trip
+	"012234",	//CHAdeMO GFD trip
+	"012235",	//CCS GFD trip
+	"012236",	//GB GFD trip
+	"012237",	//SPD trip
+	"012238",	//Main power breaker trip
+	"012239",	//Aux. power breaker trip
+	"012240",	//PSU communication fail
+	"012241",	//WiFi module communication fail
+	"012242",	//3G/4G module communication fail
+	"012243",	//RFID module communication fail
+	"012244",	//Bluetooth module communication fail
+	"012245",	//LCM module communication fail
+	"012246",	//Aux. power module communication fail
+	"012247",	//Relay control boaed/smart box communication fail
+	"012248",	//CCS module communication fail
+	"012249",	//CHAdeMO module communication fail
+	"012250",	//GBT module communication fail
+	"012251",	//Emergency stop
+	"012252",	//Door open
+	"012253",	//System fan decay
+	"012254",	//Fail to create share memory
+	"012255",	//CSU initialization failed
+	"012256",	//Reserved
+	"012257",	//Reserved
+	"012258",	//Reserved
+	"012259",	//Reserved
+	"012260",	//Reserved
+	"012261",	//Reserved
+	"012262",	//Reserved
+	"012263"	//Reserved
+};
+
+char InfoStatusCode[64][6]=
+{
+	//Information comes from EVSE
+	"013600",	//Normal stop charging by user
+	"013601",	//Charging Time's up
+	"013602",	//Replace system air filter
+	"013603",	//Reach to CHAdeMO max. plugging times.
+	"013604",	//Reach to CCS max. plugging times.
+	"013605",	//Reach to GB max. plugging times.
+	"013606",	//Reach to AC max. plugging times.
+	"013607",	//CSU fimrware update fail
+	"013608",	//CHAdeMO Module fimrware update fail
+	"013609",	//CCS Module fimrware update fail
+	"013610",	//GB Module fimrware update fail
+	"013611",	//Aux. power module fimrware update fail
+	"013612",	//Relay control module fimrware update fail
+	"013613",	//LCM module fimrware update fail
+	"013614",	//Bluetooth module fimrware update fail
+	"013615",	//WiFi module fimrware update fail
+	"013616",	//3G/4G module fimrware update fail
+	"013617",	//SMR fimrware update fail
+	"013618",	//RFID module fimrware update fail
+	"013619",	//configured by USB flash drive
+	"013620",	//configured by backend
+	"013621",	//configured by webpage
+	"013622",	//disconnected from Internet through Ethernet
+	"013623",	//disconnected from Internet through WiFi
+	"013624",	//disconnected from Internet through 3G/4G
+	"013625",	//disconnected from AP through WiFi
+	"013626",	//disconnected from APN through 3G/4G
+	"013627",	//Reserved
+	"013628",	//Reserved
+	"013629",	//Reserved
+	"013630",	//Reserved
+	"013631",	//Reserved
+	//Information comes from EV
+	"023700",	//CHAdeMO EV communication Fail
+	"023701",	//CCS EV communication Fail
+	"023702",	//GB EV communication Fail
+	"023703",	//AC: pilot fault
+	"023704",	//CHAdeMO:  battery malfunction
+	"023705",	//CHAdeMO:  no charging permission
+	"023706",	//CHAdeMO:  battery incompatibility
+	"023707",	//CHAdeMO:  battery OVP
+	"023708",	//CHAdeMO:  battery UVP
+	"023709",	//CHAdeMO:  battery OTP
+	"023710",	//CHAdeMO:  battery current difference
+	"023711",	//CHAdeMO:  battery voltage difference
+	"023712",	//CHAdeMO:  shift position
+	"023713",	//CHAdeMO:  battery other fault
+	"023714",	//CHAdeMO:  charging system error
+	"023715",	//CHAdeMO:  EV normal stop
+	"023716",	//Reserved
+	"023717",	//Reserved
+	"023718",	//Reserved
+	"023719",	//Reserved
+	"023720",	//Reserved
+	"023721",	//Reserved
+	"023722",	//Reserved
+	"023723",	//Reserved
+	 //Information comes from Backend
+	"033900",	//disconnected from backend through Ethernet
+	"033901",	//disconnected from backend through WiFi
+	"033902",	//disconnected from backend through 3G/4G
+	"033903",	//Remote start charging by backend
+	"033904",	//Remote stop charging by backend
+	"033905",	//Remote reset by backend
+	"033906",	//Reserved
+	"033907",	//Reserved
+};
+
+/*===========================================================================
+FUNCTION: StoreLogMsg
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+#if SAVE_SYS_LOG_MSG_EVENTLOG_SWITCH == ENABLE
+int StoreLogMsg(unsigned char *DataString)
+{
+    static unsigned char Buf[1024];
+    static time_t CurrentTime;
+    static struct tm *tm;
+    static struct timeval tv;
+
+    memset(Buf, 0, sizeof(Buf));
+    CurrentTime = time(NULL);
+    tm = localtime(&CurrentTime);
+    gettimeofday(&tv, NULL); // get microseconds, 10^-6
+
+    sprintf(Buf, "echo \"[%04d%02d%02d: %02d:%02d:%02d.%06d][EventLogging]%s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog",
+            tm->tm_year + 1900,
+            tm->tm_mon + 1,
+            tm->tm_mday,
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            DataString,
+            tm->tm_year + 1900,
+            tm->tm_mon + 1);
+    system(Buf);
+
+    DEBUG_PRINTF_EVENTLOG_SYSTEM_LOG("[%02d:%02d:%02d.%06d][EventLogging]%s \n",
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            DataString);
+
+    //Reset the buf_log_eventlogging Buffer, i.e. DataString
+    memset(buf_log_eventlogging, 0, SIZE_OF_LOG_BUFFER);
+}
+#endif
+
+int StoreEventLogMsg(unsigned char *EventCodeString)
+{
+    unsigned char Buf[256];
+    time_t CurrentTime;
+    struct tm *tm;
+
+    memset(Buf, 0, sizeof(Buf));
+    CurrentTime = time(NULL);
+    tm = localtime(&CurrentTime);
+    sprintf(Buf, "echo \"%04d.%02d.%02d %02d:%02d:%02d - %s\" >> /Storage/EventLog/[%04d.%02d]EventLog",
+            tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec,
+            EventCodeString,
+            tm->tm_year + 1900, tm->tm_mon + 1);
+    system(Buf);
+
+    DEBUG_PRINTF_EVENTLOG_DETAIL("%s \n", Buf);
+}
+
+double DiffTimeb(struct timeb ST, struct timeb ET)
+{
+	//return milli-second
+    double StartTime, EndTime;
+    double t_diff;
+
+    StartTime = ((double)ST.time)*1000 + (double)ST.millitm;
+    EndTime = ((double)ET.time)*1000 + (double)ET.millitm;
+    t_diff = EndTime - StartTime;
+
+    //printf("%.02lf - %.02lf = %.02lf\n", EndTime, StartTime, t_diff);
+
+    if (t_diff < 0)
+    {
+        #if 0
+        if (t_diff < -1000)   //1000ms
+        {
+            sprintf(buf_log_eventlogging,
+                    "[Warning]StartTime(%.02lf) > EndTime(%.02lf), d(%.02lf)",
+                    StartTime,
+                    EndTime,
+                    t_diff);
+            SAVE_SYS_LOG_MSG_EVENTLOG(buf_log_eventlogging);
+        }
+        #endif
+
+        return -1;
+    }
+    return t_diff;
+}
+
+/**************************************************************************************/
+/**************************Init all share memory *********************************/
+/**************************************************************************************/
+int ShareMemory_Init()
+{
+    int MeterSMId;
+
+    //create ShmSysConfigAndInfo
+    if((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo),  0777)) < 0)
+    {
+        StoreLogMsg("[EventLogging]ShareMemory_Init:shmget ShmSysConfigAndInfo NG");
+
+        return 0;
+    }
+    else if((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        StoreLogMsg("[EventLogging]ShareMemory_Init:shmat ShmSysConfigAndInfo NG");
+
+        return 0;
+    }
+
+    //create ShmStatusCodeData
+    if((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  0777)) < 0)
+    {
+        StoreLogMsg("[EventLogging]ShareMemory_Init:shmget ShmStatusCodeData NG");
+
+        return 0;
+    }
+    else if((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        StoreLogMsg("[EventLogging]ShareMemory_Init:shmat ShmStatusCodeData NG");
+
+        return 0;
+    }
+
+    return 1;
+}
+
+void FlashPresentStatusCode(unsigned char *NewCode)
+{
+    unsigned char CodeIndex, SaveIndex = 0;
+    unsigned char StatusCodeTmp[10][6];
+
+    memset(StatusCodeTmp, 0, sizeof(StatusCodeTmp));
+
+    for(CodeIndex = 0; CodeIndex < (sizeof(ShmStatusCodeData->PresentStatusCode) / 6); CodeIndex++)
+    {
+        if(strlen(ShmStatusCodeData->PresentStatusCode[CodeIndex]) <= 0)
+        {
+            memcpy(StatusCodeTmp[SaveIndex++], NewCode, 6);
+            memset(ShmStatusCodeData->PresentStatusCode, 0, sizeof(ShmStatusCodeData->PresentStatusCode));
+            memcpy(ShmStatusCodeData->PresentStatusCode, StatusCodeTmp, sizeof(StatusCodeTmp));
+            return;
+        }
+        else if(strstr(ShmStatusCodeData->PresentStatusCode[CodeIndex], NewCode + 1) != NULL)
+        {
+            if((CodeIndex + 1) < 10)
+            {
+                memcpy(StatusCodeTmp[SaveIndex], ShmStatusCodeData->PresentStatusCode[CodeIndex + 1], (9 - CodeIndex) * 6);
+            }
+
+            memset(ShmStatusCodeData->PresentStatusCode, 0, sizeof(ShmStatusCodeData->PresentStatusCode));
+            memcpy(ShmStatusCodeData->PresentStatusCode, StatusCodeTmp, sizeof(StatusCodeTmp));
+            return;
+        }
+        else
+        {
+            memcpy(StatusCodeTmp[SaveIndex++], ShmStatusCodeData->PresentStatusCode[CodeIndex], 6);
+        }
+    }
+}
+
+int main(int argc, char *argv[])
+{
+    int ByteCount, BitCount;
+    unsigned char tmp, EventCodeTmp[7];
+
+    //Initialization
+    if(ShareMemory_Init() == 0)
+    {
+        StoreLogMsg("[EventLogging]main:ShareMemory_Init NG");
+
+        if(ShmStatusCodeData != NULL)
+        {
+            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory = 1;
+        }
+
+        sleep(5);
+        return 0;
+    }
+
+    while(1)
+    {
+        //check Fault Status
+        for(ByteCount = 0; ByteCount < 4; ByteCount++)
+        {
+            if(ShmStatusCodeData->FaultCode.FaultEvents.FaultVal[ByteCount] != ShmStatusCodeData->FaultCode.PreviousFaultVal[ByteCount])
+            {
+                tmp = ShmStatusCodeData->FaultCode.FaultEvents.FaultVal[ByteCount]; //prevent be modified during following process
+
+                for(BitCount = 0; BitCount < 8; BitCount++)
+                {
+                    if(((tmp >> BitCount) & 0x01) != ((ShmStatusCodeData->FaultCode.PreviousFaultVal[ByteCount] >> BitCount) & 0x01))
+                    {
+                        memset(EventCodeTmp, 0, sizeof(EventCodeTmp));
+                        memcpy(EventCodeTmp, FaultStatusCode[ByteCount * 8 + BitCount], sizeof(EventCodeTmp) - 1);
+
+                        if(((tmp >> BitCount) & 0x01) == 0)//Recovered
+                        {
+                            EventCodeTmp[0] = 1;
+                            ShmStatusCodeData->FaultCode.PreviousFaultVal[ByteCount] &= (0 << BitCount);
+                        }
+                        else
+                        {
+                            ShmStatusCodeData->FaultCode.PreviousFaultVal[ByteCount] |= (1 << BitCount);
+                        }
+
+                        FlashPresentStatusCode(EventCodeTmp);
+                        StoreEventLogMsg(EventCodeTmp);
+                    }
+                }
+            }
+        }
+
+        //check Alarm Status
+        for(ByteCount = 0; ByteCount < 8; ByteCount++)
+        {
+            if(ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[ByteCount] != ShmStatusCodeData->AlarmCode.PreviousAlarmVal[ByteCount])
+            {
+                tmp = ShmStatusCodeData->AlarmCode.AlarmEvents.AlarmVal[ByteCount]; //prevent be modified during following process
+
+                for(BitCount = 0; BitCount < 8; BitCount++)
+                {
+                    if(((tmp >> BitCount) & 0x01) != ((ShmStatusCodeData->AlarmCode.PreviousAlarmVal[ByteCount] >> BitCount) & 0x01))
+                    {
+                        memset(EventCodeTmp, 0, sizeof(EventCodeTmp));
+                        memcpy(EventCodeTmp, AlarmStatusCode[ByteCount * 8 + BitCount], sizeof(EventCodeTmp) - 1);
+
+                        if(((tmp >> BitCount) & 0x01) == 0)//Recovered
+                        {
+                            EventCodeTmp[0] = 1;
+                            ShmStatusCodeData->AlarmCode.PreviousAlarmVal[ByteCount] &= (0 << BitCount);
+                        }
+                        else
+                        {
+                            ShmStatusCodeData->AlarmCode.PreviousAlarmVal[ByteCount] |= (1 << BitCount);
+
+                        }
+
+                        FlashPresentStatusCode(EventCodeTmp);
+                        StoreEventLogMsg(EventCodeTmp);
+                    }
+                }
+            }
+        }
+
+        //check Info Status
+        for(ByteCount = 0; ByteCount < 8; ByteCount++)
+        {
+            if(ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[ByteCount] != ShmStatusCodeData->InfoCode.PreviousInfoVal[ByteCount])
+            {
+                tmp = ShmStatusCodeData->InfoCode.InfoEvents.InfoVal[ByteCount]; //prevent be modified during following process
+
+                for(BitCount = 0; BitCount < 8; BitCount++)
+                {
+                    if(((tmp >> BitCount) & 0x01) != ((ShmStatusCodeData->InfoCode.PreviousInfoVal[ByteCount] >> BitCount) & 0x01))
+                    {
+                        memset(EventCodeTmp, 0, sizeof(EventCodeTmp));
+                        memcpy(EventCodeTmp, InfoStatusCode[ByteCount * 8 + BitCount], sizeof(EventCodeTmp) - 1);
+
+                        if(((tmp >> BitCount) & 0x01) == 0)//Recovered
+                        {
+                            EventCodeTmp[0] = 1;
+                            ShmStatusCodeData->InfoCode.PreviousInfoVal[ByteCount] &= (0 << BitCount);
+                        }
+                        else
+                        {
+                            ShmStatusCodeData->InfoCode.PreviousInfoVal[ByteCount] |= (1 << BitCount);
+                        }
+
+                        FlashPresentStatusCode(EventCodeTmp);
+                        StoreEventLogMsg(EventCodeTmp);
+                    }
+                }
+            }
+        }
+    }//main while loop
+
+}

EVSE/Projects/AW-CCS/Apps/CCS/EventLogging.h

@@ -0,0 +1,62 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                             EventLogging.h
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+
+#if FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == ENABLE
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_EVENTLOG_SWITCH         ENABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_EVENTLOG_SHOW               DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_EVENTLOG_BRIEF_SHOW         DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_EVENTLOG_DETAIL_SHOW        DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_EVENTLOG_SYSTEM_LOG_SHOW    DISABLE      //ENABLE, DISABLE
+#else //debug mode
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_EVENTLOG_SWITCH         ENABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_EVENTLOG_SHOW               ENABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_EVENTLOG_BRIEF_SHOW         DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_EVENTLOG_DETAIL_SHOW        DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_EVENTLOG_SYSTEM_LOG_SHOW    ENABLE      //ENABLE, DISABLE
+#endif
+
+//System Log
+#if SAVE_SYS_LOG_MSG_EVENTLOG_SWITCH == ENABLE
+    #define SAVE_SYS_LOG_MSG_EVENTLOG     StoreLogMsg
+#else
+    #define SAVE_SYS_LOG_MSG_EVENTLOG(...)
+#endif
+
+//Debug Message
+#if DEBUG_PRINTF_EVENTLOG_SHOW == ENABLE
+    //Brief Messages
+    #if DEBUG_PRINTF_EVENTLOG_BRIEF_SHOW == ENABLE
+        #define DEBUG_PRINTF_EVENTLOG_BRIEF      printf
+    #else
+        #define DEBUG_PRINTF_EVENTLOG_BRIEF(...)
+    #endif
+
+    //Detail Messages
+    #if DEBUG_PRINTF_EVENTLOG_DETAIL_SHOW == ENABLE
+        #define DEBUG_PRINTF_EVENTLOG_DETAIL     printf
+    #else
+        #define DEBUG_PRINTF_EVENTLOG_DETAIL(...)
+    #endif
+
+    //System Log Messages
+    #if DEBUG_PRINTF_EVENTLOG_SYSTEM_LOG_SHOW == ENABLE
+        #define DEBUG_PRINTF_EVENTLOG_SYSTEM_LOG    printf
+    #else
+        #define DEBUG_PRINTF_EVENTLOG_SYSTEM_LOG(...)
+    #endif
+#else
+    #define DEBUG_PRINTF_EVENTLOG_BRIEF(...)
+    #define DEBUG_PRINTF_EVENTLOG_DETAIL(...)
+    #define DEBUG_PRINTF_EVENTLOG_SYSTEM_LOG(...)
+#endif

EVSE/Projects/AW-CCS/Apps/CCS/FWMaker.c

@@ -0,0 +1,185 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                 FWMaker.c
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <string.h>
+#include <net/if.h> /*struct ifreq*/
+#include <linux/sockios.h> /*SIOCGIFINDEX*/
+#include <linux/socket.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/timeb.h>
+#include <fcntl.h>
+#include <sys/mman.h>
+#include "FWMaker.h"
+
+unsigned char buf_log_fwmaker[SIZE_OF_LOG_BUFFER];
+
+/*===========================================================================
+FUNCTION: StoreLogMsg
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+#if SAVE_SYS_LOG_MSG_FWMAKER_SWITCH == ENABLE
+int StoreLogMsg(unsigned char *DataString)
+{
+    static unsigned char Buf[1024];
+    static time_t CurrentTime;
+    static struct tm *tm;
+    static struct timeval tv;
+
+    memset(Buf, 0, sizeof(Buf));
+    CurrentTime = time(NULL);
+    tm = localtime(&CurrentTime);
+    gettimeofday(&tv, NULL); // get microseconds, 10^-6
+
+    sprintf(Buf, "echo \"[%04d%02d%02d: %02d:%02d:%02d.%06d][FWMaker]%s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog",
+            tm->tm_year + 1900,
+            tm->tm_mon + 1,
+            tm->tm_mday,
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            DataString,
+            tm->tm_year + 1900,
+            tm->tm_mon + 1);
+    system(Buf);
+
+    DEBUG_PRINTF_FWMAKER_SYSTEM_LOG("[%02d:%02d:%02d.%06d][FWMaker]%s \n",
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            DataString);
+
+    //Reset the buf_log_fwmaker Buffer, i.e. DataString
+    memset(buf_log_fwmaker, 0, SIZE_OF_LOG_BUFFER);
+}
+#endif
+
+//./FWMaker 172.16.24.126
+int main(int argc, char *argv[])
+{
+    unsigned char *MemBuf, *MemBuf2, buf[64];
+    int fd, rd = 0, wrd = 0, tmp = 0, rd2 = 0;
+    unsigned int CheckSum = 0;
+
+    memset(buf, 0, 64);
+    sprintf(buf, "tftp -gr uImage -l /mnt/uImage %s", argv[1]);
+    system(buf);
+    memset(buf, 0, 64);
+    sprintf(buf, "tftp -gr rootfs_nor.img -l /mnt/rootfs_nor.img %s", argv[1]);
+    system(buf);
+
+    if((MemBuf = malloc(0x100000D)) == NULL)
+    {
+        DEBUG_PRINTF_FWMAKER_DETAIL("Allocate MemBuf memory error\n");
+        return 0;
+    }
+
+    memset(MemBuf, 0xff, 0x100000D);
+    fd = open("/mnt/uImage", O_RDWR);
+
+    if(fd > 0)
+    {
+        if((rd = read(fd, MemBuf, 0x100000D)) <= 0)
+        {
+            DEBUG_PRINTF_FWMAKER_DETAIL("/mnt/uImage read Error\n");
+            free(MemBuf);
+            close(fd);
+            return 0;
+        }
+
+        close(fd);
+
+        for(tmp = 0; tmp < rd; tmp++)
+        {
+            CheckSum += MemBuf[tmp];
+        }
+
+        strncpy(MemBuf + rd, "DELTADCOK", 9);
+        *(MemBuf + rd + 9) = CheckSum >> 24;
+        *(MemBuf + rd + 10) = CheckSum >> 16;
+        *(MemBuf + rd + 11) = CheckSum >> 8;
+        *(MemBuf + rd + 12) = CheckSum;
+        // memcpy(MemBuf+rd+9,&CheckSum,4);
+        fd = open("/mnt/DcoKImage", O_CREAT | O_RDWR);
+        wrd = write(fd, MemBuf, rd + 13);
+
+        if(wrd != (rd + 13))
+        {
+            DEBUG_PRINTF_FWMAKER_DETAIL("write error wrd=0x%x, rd=0x%x\n", wrd, rd + 13);
+        }
+        else
+        {
+            DEBUG_PRINTF_FWMAKER_DETAIL("/mnt/DcoKImage OK\n");
+        }
+
+    }
+    else
+    {
+        free(MemBuf);
+        DEBUG_PRINTF_FWMAKER_DETAIL("/mnt/uImage open Error\n");
+        return 0;
+    }
+
+
+    memset(MemBuf, 0xff, 0x100000D);
+    CheckSum = rd = 0;
+    fd = open("/mnt/rootfs_nor.img", O_RDWR);
+
+    if(fd > 0)
+    {
+        if((rd = read(fd, MemBuf, 0x100000D)) <= 0)
+        {
+            DEBUG_PRINTF_FWMAKER_DETAIL("/mnt/rootfs_nor.img read Error\n");
+            free(MemBuf);
+            close(fd);
+            return 0;
+        }
+
+        close(fd);
+
+        for(tmp = 0; tmp < rd; tmp++)
+        {
+            CheckSum += MemBuf[tmp];
+        }
+
+        strncpy(MemBuf + rd, "DELTADCOF", 9);
+        *(MemBuf + rd + 9) = CheckSum >> 24;
+        *(MemBuf + rd + 10) = CheckSum >> 16;
+        *(MemBuf + rd + 11) = CheckSum >> 8;
+        *(MemBuf + rd + 12) = CheckSum;
+        //memcpy(MemBuf+rd+9,&CheckSum,4);
+        fd = open("/mnt/DcoFImage", O_CREAT | O_RDWR);
+        wrd = write(fd, MemBuf, rd + 13);
+
+        if(wrd != (rd + 13))
+        {
+            DEBUG_PRINTF_FWMAKER_DETAIL("write error wrd=0x%x, rd=0x%x\n", wrd, rd + 13);
+        }
+        else
+        {
+            DEBUG_PRINTF_FWMAKER_DETAIL("/mnt/DcoFImage OK\n");
+        }
+    }
+    else
+    {
+        free(MemBuf);
+        DEBUG_PRINTF_FWMAKER_DETAIL("/mnt/rootfs_nor.img open Error\n");
+        return 0;
+    }
+
+}

EVSE/Projects/AW-CCS/Apps/CCS/FWMaker.h

@@ -0,0 +1,61 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                 FWMaker.h
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+#if FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == ENABLE
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_FWMAKER_SWITCH         ENABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_FWMAKER_SHOW               DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FWMAKER_BRIEF_SHOW         DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FWMAKER_DETAIL_SHOW        DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FWMAKER_SYSTEM_LOG_SHOW    DISABLE      //ENABLE, DISABLE
+#else   //debug mode
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_FWMAKER_SWITCH         ENABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_FWMAKER_SHOW               ENABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FWMAKER_BRIEF_SHOW         ENABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FWMAKER_DETAIL_SHOW        ENABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FWMAKER_SYSTEM_LOG_SHOW    ENABLE      //ENABLE, DISABLE
+#endif
+
+//System Log
+#if SAVE_SYS_LOG_MSG_FWMAKER_SWITCH == ENABLE
+    #define SAVE_SYS_LOG_MSG_FWMAKER     StoreLogMsg
+#else
+    #define SAVE_SYS_LOG_MSG_FWMAKER(...)
+#endif
+
+//Debug Message
+#if DEBUG_PRINTF_FWMAKER_SHOW == ENABLE
+    //Brief Messages
+    #if DEBUG_PRINTF_FWMAKER_BRIEF_SHOW == ENABLE
+        #define DEBUG_PRINTF_FWMAKER_BRIEF      printf
+    #else
+        #define DEBUG_PRINTF_FWMAKER_BRIEF(...)
+    #endif
+
+    //Detail Messages
+    #if DEBUG_PRINTF_FWMAKER_DETAIL_SHOW == ENABLE
+        #define DEBUG_PRINTF_FWMAKER_DETAIL     printf
+    #else
+        #define DEBUG_PRINTF_FWMAKER_DETAIL(...)
+    #endif
+
+    //System Log Messages
+    #if DEBUG_PRINTF_FWMAKER_SYSTEM_LOG_SHOW == ENABLE
+        #define DEBUG_PRINTF_FWMAKER_SYSTEM_LOG    printf
+    #else
+        #define DEBUG_PRINTF_FWMAKER_SYSTEM_LOG(...)
+    #endif
+#else
+    #define DEBUG_PRINTF_FWMAKER_BRIEF(...)
+    #define DEBUG_PRINTF_FWMAKER_DETAIL(...)
+    #define DEBUG_PRINTF_FWMAKER_SYSTEM_LOG(...)
+#endif

EVSE/Projects/AW-CCS/Apps/CCS/FWUpdate.c

@@ -0,0 +1,1390 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                              FWUpdate.c
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+#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 "define.h"
+#include "FWUpdate.h"
+#include <unistd.h>
+
+struct SysConfigAndInfo             *ShmSysConfigAndInfo;
+struct StatusCodeData               *ShmStatusCodeData;
+struct CcsData                      *ShmCcsData;
+struct InternalComm               *ShmInternalComm;
+//struct InternalCommAC               *ShmInternalCommAC;
+
+unsigned char buf_log_fwupdate[SIZE_OF_LOG_BUFFER];
+
+/*===========================================================================
+FUNCTION: Check_V2G_Flow_Status
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned char Check_V2G_Flow_Status()
+{
+    unsigned char result = 0;
+
+    switch (ShmCcsData->CommProtocol)
+    {
+        case V2GT_MSG_PROTOCOL_DIN70121:        //0
+        {
+            result = ShmCcsData->V2GMessage_DIN70121.PresentMsgFlowStatus;
+            break;
+        }
+
+        case V2GT_MSG_PROTOCOL_ISO15118_2014:   //1
+        {
+            result = ShmCcsData->V2GMessage_ISO15118_2014.PresentMsgFlowStatus;
+            break;
+        }
+
+        case V2GT_MSG_PROTOCOL_ISO15118_2018:   //2
+        {
+            result = ShmCcsData->V2GMessage_ISO15118_2018.PresentMsgFlowStatus;
+            break;
+        }
+
+        default:
+            break;
+    }
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: StoreLogMsg
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+#if SAVE_SYS_LOG_MSG_FWUPDATE_SWITCH == ENABLE
+int StoreLogMsg(unsigned char *DataString)
+{
+    static unsigned char Buf[1024];
+    static time_t CurrentTime;
+    static struct tm *tm;
+    static struct timeval tv;
+
+    memset(Buf, 0, sizeof(Buf));
+    CurrentTime = time(NULL);
+    tm = localtime(&CurrentTime);
+    gettimeofday(&tv, NULL); // get microseconds, 10^-6
+
+    sprintf(Buf, "echo \"[%04d%02d%02d: %02d:%02d:%02d.%06d][FWUpdate][%d][%02d]%s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog",
+            tm->tm_year + 1900,
+            tm->tm_mon + 1,
+            tm->tm_mday,
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            EVCOMM_SYS_INFO.CpState,
+            Check_V2G_Flow_Status(),
+            DataString,
+            tm->tm_year + 1900,
+            tm->tm_mon + 1);
+    system(Buf);
+
+    DEBUG_PRINTF_FWUPDATE_SYSTEM_LOG("[%02d:%02d:%02d.%06d][FWUpdate][%d][%02d]%s \n",
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            EVCOMM_SYS_INFO.CpState,
+            Check_V2G_Flow_Status(),
+            DataString);
+
+    //Reset the buf_log_fwupdate Buffer, i.e. DataString
+    memset(buf_log_fwupdate, 0, SIZE_OF_LOG_BUFFER);
+}
+#endif
+
+/*===========================================================================
+FUNCTION: fsize
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned long fsize(char* filename)
+{
+    SAVE_SYS_LOG_MSG_FWUPDATE("[fsize]image size: caculating...");
+    unsigned long length = 0;
+    FILE *file;
+
+    file = fopen(filename, "rb");
+    if (file == NULL)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[fsize]fopen: fail");
+        return 0;
+    }
+    else
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[fsize]fopen: OK");
+        fseek(file, 0, SEEK_END);
+        length = (unsigned long) ftell(file);
+    }
+    fclose(file);
+    sprintf(buf_log_fwupdate, "[fsize]image size: %ld bytes", length);
+    SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+    return length;
+}
+
+/*===========================================================================
+FUNCTION: crc32
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+uint32_t crc32(uint8_t *data, unsigned int length)
+{
+    SAVE_SYS_LOG_MSG_FWUPDATE("[crc32]ongoing...");
+    uint8_t i;
+    uint32_t cnt = 0;
+    uint32_t crc = 0xffffffff;  // Initial value
+    while(length--)
+    {
+    	if(cnt > 33 && cnt < 48)
+        {
+    		data++;
+    	}
+        else
+        {
+    		crc ^= *data++;         // crc ^= *data; data++;
+			for (i = 0; i < 8; ++i)
+			{
+				if (crc & 1)
+					crc = (crc >> 1) ^ 0xEDB88320;// 0xEDB88320= reverse 0x04C11DB7
+				else
+					crc = (crc >> 1);
+			}
+    	}
+    	cnt++;
+    }
+    return ~crc;
+}
+
+/*===========================================================================
+FUNCTION: ShareMemory_Init
+DESCRIPTION
+        Initialize all share memories.
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int ShareMemory_Init()
+{
+    int MeterSMId;
+
+    //[1/5] create ShmSysConfigAndInfo
+    if((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo),  0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("ShareMemory_Init:shmget ShmSysConfigAndInfo NG");
+        return 0;
+    }
+    else if((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("ShareMemory_Init:shmat ShmSysConfigAndInfo NG");
+        return 0;
+    }
+
+    //[2/5] create ShmStatusCodeData
+    if((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("ShareMemory_Init:shmget ShmStatusCodeData NG");
+        return 0;
+    }
+    else if((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("ShareMemory_Init:shmat ShmStatusCodeData NG");
+        return 0;
+    }
+
+    //[3/5] create ShmCcsData
+    if((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData),  0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("ShareMemory_Init:shmget ShmCcsData NG");
+        return 0;
+    }
+    else if((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("ShareMemory_Init:shmat ShmCcsData NG");
+        return 0;
+    }
+
+    //[4/5] create ShmInternalComm
+    if((MeterSMId = shmget(ShmInternalCommKey, sizeof(struct InternalComm),  IPC_CREAT | 0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("ShareMemory_Init:shmget ShmInternalComm NG");
+        return 0;
+    }
+    else if((ShmInternalComm = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("ShareMemory_Init:shmat ShmInternalComm NG");
+        return 0;
+    }
+	#if 0
+    //[5/5] create ShmInternalCommAC
+    if((MeterSMId = shmget(ShmInternalCommACKey, sizeof(struct InternalCommAC),  IPC_CREAT | 0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("ShareMemory_Init:shmget ShmInternalCommAC NG");
+        return 0;
+    }
+    else if((ShmInternalCommAC = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("ShareMemory_Init:shmat ShmInternalCommAC NG");
+        return 0;
+    }
+	#endif
+    return 1;
+}
+
+/*===========================================================================
+FUNCTION: Update_MLO
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned char Update_MLO()
+{
+    SAVE_SYS_LOG_MSG_FWUPDATE("-------- [MLO]start --------");
+
+    unsigned char result = PASS;
+    long int MaxLen = 48*1024*1024;
+    unsigned long file_length = 0;
+    unsigned char *ptr = malloc(MaxLen);
+
+    if(ptr == NULL)
+    {
+        return FAIL;
+    }
+
+    memset(ptr, 0, MaxLen);
+
+    file_length = fsize("/root/MLO");
+
+    int fd = 0;
+    int wrd = 0;
+    FILE *file;
+    fd = open("/dev/mtdblock0", O_RDWR);
+    file = fopen("/root/MLO", "rb");
+
+    if (fd < 0)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[MLO]Can not open mtdblock0\n");
+        free(ptr);
+        return FAIL;
+    }
+    else if (file == NULL)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[MLO]Can not open or find the downloaded image file\n");
+        free(ptr);
+        return FAIL;
+    }
+    else
+    {
+        //[VITAL] Closing unneccesary task to supoort rapid CAN data receving..
+        SAVE_SYS_LOG_MSG_FWUPDATE("[MLO] closing SeccComm...");
+        system("killall SeccComm");
+
+        // Write image to flash
+        SAVE_SYS_LOG_MSG_FWUPDATE("[MLO]Writing image to mtdblock0...");
+        fread(ptr, sizeof(unsigned char), file_length, file);
+        wrd = write(fd, ptr, file_length);
+
+        close(fd);
+        fclose(file);
+        sprintf(buf_log_fwupdate, "[MLO]mtdblock0 - written length: %d bytes\n", wrd);
+        SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+
+        if(wrd != file_length)
+        {
+            free(ptr);
+            return FAIL;
+        }
+    }
+    free(ptr);
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: IMAGE_TYPE_BOOTLOADER_UBOOT
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned char Update_uboot()
+{
+    SAVE_SYS_LOG_MSG_FWUPDATE("-------- [uboot]start --------");
+
+    unsigned char result = PASS;
+    long int MaxLen = 48*1024*1024;
+    unsigned long file_length = 0;
+    unsigned char *ptr = malloc(MaxLen);
+
+    if(ptr == NULL)
+    {
+        return FAIL;
+    }
+
+    memset(ptr, 0, MaxLen);
+
+    file_length = fsize("/root/u-boot.img");
+
+    int fd = 0;
+    int wrd = 0;
+    FILE *file;
+    fd = open("/dev/mtdblock1", O_RDWR);
+    file = fopen("/root/u-boot.img", "rb");
+    if (fd < 0)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[uboot]Can not open mtdblock1\n");
+        free(ptr);
+        return FAIL;
+    }
+    else if (file == NULL)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[uboot]Can not open the downloaded image file\n");
+        free(ptr);
+        return FAIL;
+    }
+    else
+    {
+        //[VITAL] Closing unneccesary task to supoort rapid CAN data receving..
+        SAVE_SYS_LOG_MSG_FWUPDATE("[uboot] closing SeccComm...");
+        system("killall SeccComm");
+
+        // Write image to flash
+        SAVE_SYS_LOG_MSG_FWUPDATE("[uboot]Writing image to mtdblock1...");
+     //   fread(ptr, sizeof(unsigned char), file_length, file);
+      
+        //wrd = write(fd, ptr, file_length);
+
+        close(fd);
+        fclose(file);
+                
+        system("/bin/flash_erase /dev/mtd1 0 2");
+	system("/usr/sbin/nandwrite -p /dev/mtd1 /root/u-boot.img");
+	system("/bin/flash_erase /dev/mtd3 0 2");
+	system("/usr/sbin/nandwrite -p /dev/mtd3 /root/u-boot.img");
+
+        
+        sprintf(buf_log_fwupdate, "[uboot]mtdblock1 - written length: %d bytes\n", wrd);
+        SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+#if 0
+        if(wrd != file_length)
+        {
+            free(ptr);
+            return FAIL;
+        }
+        else
+        {
+            // Open flash target mtdblock
+            fd = open("/dev/mtdblock3", O_RDWR);
+            if (fd < 0)
+            {
+                SAVE_SYS_LOG_MSG_FWUPDATE("[uboot]Can not open mtdblock3\n");
+                free(ptr);
+                return FAIL;
+            }
+            else if (file == NULL)
+            {
+                SAVE_SYS_LOG_MSG_FWUPDATE("[uboot]Can not open the downloaded image file\n");
+                free(ptr);
+                return FAIL;
+            }
+            else
+            {
+                // Write image to flash
+                SAVE_SYS_LOG_MSG_FWUPDATE("[uboot]Writing image to mtdblock3...");
+                wrd = write(fd, ptr, file_length);
+
+                close(fd);
+                sprintf(buf_log_fwupdate, "[uboot]mtdblock3 - written length: %d bytes\n", wrd);
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+
+                if(wrd != file_length)
+                {
+                    free(ptr);
+                    return FAIL;
+                }
+            }
+        }
+#endif    
+    }
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: Update_DTB
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned char Update_DTB()
+{
+    SAVE_SYS_LOG_MSG_FWUPDATE("-------- [DTB]start --------");
+
+    unsigned char result = PASS;
+    long int MaxLen = 48*1024*1024;
+    unsigned long file_length = 0;
+    unsigned char *ptr = malloc(MaxLen);
+
+    if(ptr == NULL)
+    {
+        return FAIL;
+    }
+
+    memset(ptr, 0, MaxLen);
+
+    file_length = fsize("/root/am335x-evm.dtb");
+
+    int fd = 0;
+    int wrd = 0;
+    FILE *file;
+    fd = open("/dev/mtdblock4", O_RDWR);
+    file = fopen("/root/am335x-evm.dtb", "rb");
+    if (fd < 0)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[DTB]Can not open mtdblock4\n");
+        free(ptr);
+        return FAIL;
+    }
+    else if (file == NULL)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[DTB]Can not open the downloaded image file\n");
+        free(ptr);
+        return FAIL;
+    }
+    else
+    {
+        //[VITAL] Closing unneccesary task to supoort rapid CAN data receving..
+        SAVE_SYS_LOG_MSG_FWUPDATE("[DTB] closing SeccComm...");
+        system("killall SeccComm");
+
+        // Write image to flash
+        SAVE_SYS_LOG_MSG_FWUPDATE("[DTB]Writing image to mtdblock4...");
+      //  fread(ptr, sizeof(unsigned char), file_length, file);
+      //  wrd = write(fd, ptr, file_length);
+
+        close(fd);
+        fclose(file);
+        
+        system("/bin/flash_erase /dev/mtd4 0 1");
+	system("/usr/sbin/nandwrite -p /dev/mtd4 /root/am335x-evm.dtb");
+
+	system("/bin/flash_erase /dev/mtd5 0 1");
+	system("/usr/sbin/nandwrite -p /dev/mtd5 /root/am335x-evm.dtb");
+        
+        
+        sprintf(buf_log_fwupdate, "[DTB]mtdblock4 - written length: %d bytes\n", wrd);
+        SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+#if 0
+        if(wrd != file_length)
+        {
+            free(ptr);
+            return FAIL;
+        }
+        else
+        {
+            // Open flash target mtdblock
+            fd = open("/dev/mtdblock5", O_RDWR);
+            if (fd < 0)
+            {
+                SAVE_SYS_LOG_MSG_FWUPDATE("[DTB]Can not open mtdblock5");
+                free(ptr);
+                return FAIL;
+            }
+            else
+            {
+                // Write image to flash
+                SAVE_SYS_LOG_MSG_FWUPDATE("[DTB]Writing image to mtdblock5...");
+                wrd=write(fd, ptr, file_length);
+                close(fd);
+                sprintf(buf_log_fwupdate, "[DTB]mtdblock5 - written length: %d bytes\n", wrd);
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+                if(wrd != file_length)
+                {
+                    free(ptr);
+                    return FAIL;
+                }
+            }
+        }
+#endif        
+    }
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: Update_zImage
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned char Update_zImage()
+{
+    SAVE_SYS_LOG_MSG_FWUPDATE("-------- [zImage]start --------");
+
+    unsigned char result = PASS;
+    long int MaxLen = 48*1024*1024;
+    unsigned long file_length = 0;
+    unsigned char *ptr = malloc(MaxLen);
+
+    if(ptr == NULL)
+    {
+        return FAIL;
+    }
+
+    memset(ptr, 0, MaxLen);
+
+    file_length = fsize("/root/zImage");
+
+    int fd = 0;
+    int wrd = 0;
+    FILE *file;
+    fd = open("/dev/mtdblock6", O_RDWR);
+    file = fopen("/root/zImage", "rb");
+    if (fd < 0)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[zImage]Can not open mtdblock6\n");
+        free(ptr);
+        return FAIL;
+    }
+    else if (file == NULL)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[zImage]Can not open the downloaded image file\n");
+        free(ptr);
+        return FAIL;
+    }
+    else
+    {
+        //[VITAL] Closing unneccesary task to supoort rapid CAN data receving..
+        SAVE_SYS_LOG_MSG_FWUPDATE("[zImage] closing SeccComm...");
+        system("killall SeccComm");
+
+        // Write image to flash
+        SAVE_SYS_LOG_MSG_FWUPDATE("[zImage]Writing image to mtdblock6...");
+      //  fread(ptr, sizeof(unsigned char), file_length, file);
+       // wrd = write(fd, ptr, file_length);
+
+        close(fd);
+        fclose(file);
+        
+	
+	system("/bin/flash_erase /dev/mtd6 0 20");
+	system("/usr/sbin/nandwrite -p /dev/mtd6 /root/zImage");
+
+	system("/bin/flash_erase /dev/mtd7 0 20");
+	system("/usr/sbin/nandwrite -p /dev/mtd7 /root/zImage");
+        
+        sprintf(buf_log_fwupdate, "[zImage]mtdblock6 - written length: %d bytes\n", wrd);
+        SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+#if 0
+        if(wrd != file_length)
+        {
+            free(ptr);
+            return FAIL;
+        }
+        else
+        {
+            // Open flash target mtdblock
+            fd = open("/dev/mtdblock7", O_RDWR);
+            if (fd < 0)
+            {
+                SAVE_SYS_LOG_MSG_FWUPDATE("[zImage]Can not open mtdblock7");
+                free(ptr);
+                return FAIL;
+            }
+            else
+            {
+                // Write image to flash
+                SAVE_SYS_LOG_MSG_FWUPDATE("[zImage]Writing image to mtdblock7...");
+                wrd = write(fd, ptr, file_length);
+                close(fd);
+                sprintf(buf_log_fwupdate, "[zImage]mtdblock7 - written length: %d bytes\n", wrd);
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+                if(wrd != file_length)
+                {
+                    free(ptr);
+                    return FAIL;
+                }
+            }
+        }
+#endif        
+    }
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: Update_ramdisk
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned char Update_ramdisk()
+{
+    SAVE_SYS_LOG_MSG_FWUPDATE("-------- [ramdisk]start --------");
+
+    unsigned char result = PASS;
+    long int MaxLen = 48*1024*1024;
+    unsigned long file_length = 0;
+    unsigned char *ptr = malloc(MaxLen);
+
+    if(ptr == NULL)
+    {
+        return FAIL;
+    }
+
+    memset(ptr, 0, MaxLen);
+
+    file_length = fsize("/root/ramdisk.gz");
+
+    int fd = 0;
+    int wrd = 0;
+    FILE *file;
+    fd = open("/dev/mtdblock8", O_RDWR);
+    file = fopen("/root/ramdisk.gz", "rb");
+    if(fd < 0)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[ramdisk]UpdateRootfs NG - can not open rootfs\n");
+        return FAIL;
+    }
+    else if (file == NULL)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[ramdisk]Can not open the downloaded image file\n");
+        return FAIL;
+    }
+    else
+    {
+        //[VITAL] Closing unneccesary task to supoort rapid CAN data receving..
+        SAVE_SYS_LOG_MSG_FWUPDATE("[ramdisk] closing SeccComm...");
+        system("killall SeccComm");
+
+        SAVE_SYS_LOG_MSG_FWUPDATE("[ramdisk]Writing image to mtdblock8...");
+        //fread(ptr, sizeof(unsigned char), file_length, file);
+        //wrd = write(fd, ptr, file_length);
+        close(fd);
+        fclose(file);
+        
+
+       system("/bin/flash_erase /dev/mtd8 0 96");
+       system("/usr/sbin/nandwrite -p /dev/mtd8 /root/ramdisk.gz");
+
+       system("/bin/flash_erase /dev/mtd9 0 96");
+       system("/usr/sbin/nandwrite -p /dev/mtd9 /root/ramdisk.gz");
+                                	
+                                	
+        sprintf(buf_log_fwupdate, "[ramdisk]mtdblock8 - written length: %d bytes\n", wrd);
+        SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+#if 0      
+        if(wrd != file_length)
+        {
+            free(ptr);
+            return FAIL;
+        }
+        else
+        {
+            fd = open("/dev/mtdblock9", O_RDWR);
+            if(fd < 0)
+            {
+                SAVE_SYS_LOG_MSG_FWUPDATE("[ramdisk]UpdateRootfs NG - can not open rootfs");
+                free(ptr);
+                return FAIL;
+            }
+
+            SAVE_SYS_LOG_MSG_FWUPDATE("[ramdisk]Writing image to mtdblock9...");
+            wrd = write(fd, ptr, file_length);
+
+            close(fd);
+            sprintf(buf_log_fwupdate, "[ramdisk]mtdblock9 - written length: %d bytes\n", wrd);
+            SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+
+            if(wrd != file_length)
+            {
+                free(ptr);
+                return FAIL;
+            }
+            else
+            {
+                //result = PASS;
+                SAVE_SYS_LOG_MSG_FWUPDATE("[ramdisk]deleting Storage-root files.\n");
+                system("cd /Storage;rm -rf root/*");
+
+                #if (FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == DISABLE)
+                {
+                    SAVE_SYS_LOG_MSG_FWUPDATE("[ramdisk]sync...");
+                    system("sync");
+                }
+                #endif
+            }
+        }
+#endif        
+    }
+    return result;
+}
+
+
+/*===========================================================================
+FUNCTION: Update_user_config
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned char Update_user_config()
+{
+    SAVE_SYS_LOG_MSG_FWUPDATE("-------- [user_config]start --------");
+
+    unsigned char result = PASS;
+    long int MaxLen = 48*1024*1024;
+    unsigned long file_length = 0;
+    unsigned char *ptr = malloc(MaxLen);
+
+    if(ptr == NULL)
+    {
+        return FAIL;
+    }
+
+    memset(ptr, 0, MaxLen);
+
+    file_length = fsize("/root/FactoryConfig.bin");
+
+    // Open flash target mtdblock
+    int fd = 0;
+    int wrd = 0;
+    FILE *file;
+    fd = open("/dev/mtdblock10", O_RDWR);
+    file = fopen("/root/FactoryConfig.bin", "rb");
+    if (fd < 0)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[user_config]Can not open mtdblock10\n");
+        free(ptr);
+        return FAIL;
+    }
+    else if (file == NULL)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[user_config]Can not open the downloaded image file\n");
+        free(ptr);
+        return FAIL;
+    }
+    else
+    {
+        //[VITAL] Closing unneccesary task to supoort rapid CAN data receving..
+        SAVE_SYS_LOG_MSG_FWUPDATE("[user_config] closing SeccComm...");
+        system("killall SeccComm");
+
+        // Write image to flash
+        SAVE_SYS_LOG_MSG_FWUPDATE("[user_config]Writing image to mtdblock10...");
+      //  fread(ptr, sizeof(unsigned char), file_length, file);
+        //wrd = write(fd, ptr, file_length);
+        close(fd);
+        fclose(file);
+        system("/bin/flash_erase /dev/mtd10 0 12");
+	system("/usr/sbin/nandwrite -p /dev/mtd10 /root/FactoryConfig.bin");
+
+	system("/bin/flash_erase /dev/mtd11 0 12");
+	system("/usr/sbin/nandwrite -p /dev/mtd11 /root/FactoryConfig.bin");
+									
+        sprintf(buf_log_fwupdate,
+                "[user_config]mtdblock10 - written length: %d bytes\n",
+                wrd);
+        SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+#if 0      
+        if(wrd != file_length)
+        {
+            free(ptr);
+            return FAIL;
+        }
+        else
+        {
+            // Open flash target mtdblock
+            fd = open("/dev/mtdblock11", O_RDWR);
+            if (fd < 0)
+            {
+                SAVE_SYS_LOG_MSG_FWUPDATE("[user_config]Can not open mtdblock11");
+                free(ptr);
+                return FAIL;
+            }
+            else
+            {
+                // Write image to flash
+                SAVE_SYS_LOG_MSG_FWUPDATE("[user_config]Writing image to mtdblock11...");
+                wrd = write(fd, ptr, file_length);
+                close(fd);
+                sprintf(buf_log_fwupdate,
+                        "[user_config]mtdblock11 - written length: %d bytes\n",
+                        wrd);
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+                if(wrd != file_length)
+                {
+                    free(ptr);
+                    return FAIL;
+                }
+            }
+        }
+#endif        
+    }
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: Update_root_app
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned char Update_root_app()
+{
+    SAVE_SYS_LOG_MSG_FWUPDATE("-------- [root_app]start --------");
+
+    unsigned char result = 0;
+
+    //STEP 1: Unzip tmp (.tar.gz) (also checking the file completion)
+    system("tar -C /Storage/ -zxvf /Storage/tmp");   //.tar.gz
+    //[zip command] tar -zcvf tmp image/
+
+    //STEP 2: Checking File Existance (to-be enhanced)
+    FILE *file;
+    file = fopen("/root/ramdisk_app_type_5.tar.gz", "rb");
+    if (file == NULL)
+    {
+        result = 0;  //Failed on update
+        SAVE_SYS_LOG_MSG_FWUPDATE("[root_app]checking downloaded file: FAIL");
+        system("rm -rf /Storage/image/");
+        return 0;
+    }
+    else
+    {
+        fclose(file);
+        SAVE_SYS_LOG_MSG_FWUPDATE("[root_app]checking downloaded file: OK");
+        SAVE_SYS_LOG_MSG_FWUPDATE("[root_app]updtating...");
+        system("cp -rfv /Storage/image/* /Storage/root/");
+        system("rm -rf /Storage/image/");
+
+        #if (FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == DISABLE)
+        {
+            SAVE_SYS_LOG_MSG_FWUPDATE("[root_app]sync...");
+            system("sync");
+        }
+        #endif
+
+        SAVE_SYS_LOG_MSG_FWUPDATE("[root_app]update: done");
+        result = 1; //Successful on update
+    }
+    return result;
+}
+
+
+/*===========================================================================
+FUNCTION: Update_ALL
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Update_ALL()
+{
+    char result;
+
+    result = FAIL;
+
+    //[VITAL] Closing unneccesary task to supoort rapid CAN data receving..
+    SAVE_SYS_LOG_MSG_FWUPDATE("[Update_ALL] closing SeccComm...");
+    system("killall SeccComm");
+
+    if (Update_MLO() == FAIL)
+    {
+         SAVE_SYS_LOG_MSG_FWUPDATE("[Update]MLO: fail");
+    }
+    else if (Update_uboot() == FAIL)
+    {
+         SAVE_SYS_LOG_MSG_FWUPDATE("[Update]MLO: fail");
+    }
+    else if (Update_DTB() == FAIL)
+    {
+         SAVE_SYS_LOG_MSG_FWUPDATE("[Update]DTB: fail");
+    }
+    else if (Update_zImage() == FAIL)
+    {
+         SAVE_SYS_LOG_MSG_FWUPDATE("[Update]zImage: fail");
+    }
+    else if (Update_ramdisk() == FAIL)
+    {
+         SAVE_SYS_LOG_MSG_FWUPDATE("[Update]ramdisk: fail");
+    }
+    /*
+    else if (Update_user_config() == FAIL)
+    {
+         SAVE_SYS_LOG_MSG_FWUPDATE("[Update]configuration: fail");
+    }
+    */
+    //else if (Update_root_app() == FAIL)
+    //{
+    //}
+    else
+    {
+        result = PASS;
+    }
+
+    SAVE_SYS_LOG_MSG_FWUPDATE("-------------[FW Update Summary]-----------");
+    if (result == FAIL)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[ALL]Fail");
+        CSUCOMMDC_TASK_FLAG.FW_Update_result = FAIL;
+    }
+    else if (result == PASS)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[ALL]Pass");
+        CSUCOMMDC_TASK_FLAG.FW_Update_result = PASS;
+    }
+    else
+    {
+        CSUCOMMDC_TASK_FLAG.FW_Update_result = FAIL;
+        sprintf(buf_log_fwupdate, "[ALL]unexpected response content (0x%X)", result);
+        SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+    }
+    CSUCOMMDC_TASK_FLAG.FW_Update_Done = TRUE;    //sending CAN Res msg to CSU and reboot
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: FWImage_HeaderParser
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int FWImage_HeaderParser(struct FwImageDataType *image)
+{
+    SAVE_SYS_LOG_MSG_FWUPDATE("[HeaderParser]starting...");
+
+    //Step 0: Initialize
+    unsigned char result = 0;
+    long int MaxLen = 48*1024*1024;
+    unsigned char *ptr = malloc(MaxLen);
+    if(ptr == NULL)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[HeaderParser]malloc: fail");
+        free(ptr);
+        return FAIL;
+    }
+    else
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[HeaderParser]malloc: OK");
+    }
+
+    memset(ptr, 0, MaxLen);
+
+    FILE *file;
+    file = fopen(image->path, "rb");
+    if (file == NULL)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[HeaderParser]fopen: fail");
+        free(ptr);
+        return FAIL;
+    }
+    else
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[HeaderParser]fopen: OK");
+    }
+    fread(ptr, sizeof(unsigned char), image->size, file);
+    fclose(file);
+
+    //Step 1: Check FW Image Type
+    image->type = (((unsigned int)ptr[16])<<24 | ((unsigned int)ptr[17])<<16 | ((unsigned int)ptr[18])<<8 | ((unsigned int)ptr[19]));
+
+    if (image->type != FW_IMAGE_TYPE_CCS_DTB &&
+        image->type != FW_IMAGE_TYPE_CCS_UBOOT &&
+        image->type != FW_IMAGE_TYPE_CCS_ZIMAGE &&
+        image->type != FW_IMAGE_TYPE_CCS_RAMDISK)
+    {
+        sprintf(buf_log_fwupdate,
+                "[HeaderParser]incorrect type (0x%X)",
+                image->type);
+        SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+        free(ptr);
+        return FAIL;
+    }
+
+    //Step 2: Check FW Image Length
+    unsigned long size_header = 0;
+    size_header = (((unsigned int)ptr[20])<<24 | ((unsigned int)ptr[21])<<16 | ((unsigned int)ptr[22])<<8 | ((unsigned int)ptr[23]));
+    if(image->size != (size_header + 48))
+    {
+        sprintf(buf_log_fwupdate,
+                "[HeaderParser]image length is not matched (header = %d, calculated = %d, bytes)",
+                size_header,
+                image->size);
+        SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+        free(ptr);
+        return FAIL;
+    }
+
+    //Step 3: Check CRC
+    unsigned int crc_cal = 0;
+    image->crc = ((unsigned int)ptr[34])<<24 | ((unsigned int)ptr[35])<<16 | ((unsigned int)ptr[36])<<8 | ((unsigned int)ptr[37]);
+    crc_cal = crc32(ptr, image->size);
+    if(image->crc != crc_cal)
+    {
+        sprintf(buf_log_fwupdate,
+                "[HeaderParser]CRC error (header = 0x%X, calculated = 0x%X)",
+                image->crc,
+                crc_cal);
+        SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+        free(ptr);
+        return FAIL;
+    }
+    else
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[HeaderParser]CRC: OK");
+    }
+    free(ptr);
+    return PASS;
+}
+
+/*===========================================================================
+FUNCTION: FWImage_Normalize
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int FWImage_Normalize(struct FwImageDataType *image)
+{
+    //Step 0: Initialize
+    unsigned char result = 0;
+    long int MaxLen = 48*1024*1024;
+    unsigned char *ptr = malloc(MaxLen);
+    if(ptr == NULL)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[Normalize] malloc fail");
+        free(ptr);
+        return FAIL;
+    }
+
+    memset(ptr, 0, MaxLen);
+
+    FILE *file;
+    file = fopen(image->path, "rb");
+    if (file == NULL)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[Normalize] fopen fail");
+        free(ptr);
+        return FAIL;
+    }
+    fread(ptr, sizeof(unsigned char), image->size, file);
+    fclose(file);
+
+    //Step 1: Delete the original image
+    char buf[64];
+    memset(buf, 0, 64);
+    sprintf(buf, "rm -rf %s", image->path);
+    system(buf);
+
+    //Step 2: Remove header and create a renamed image accoring to its firmware type
+    struct FwImageDataType image_new;
+    switch (image->type)
+    {
+        case FW_IMAGE_TYPE_CCS_UBOOT:       //0x10000007
+        {
+            sprintf(image_new.path, "/root/u-boot.img");
+            break;
+        }
+        case FW_IMAGE_TYPE_CCS_DTB:         //0x10000008
+        {
+            sprintf(image_new.path, "/root/am335x-evm.dtb");
+            break;
+        }
+        case FW_IMAGE_TYPE_CCS_ZIMAGE:      //0x10000009
+        {
+            sprintf(image_new.path, "/root/zImage");
+            break;
+        }
+        case FW_IMAGE_TYPE_CCS_RAMDISK:     //0x1000000A
+        {
+            sprintf(image_new.path, "/root/ramdisk.gz");
+            break;
+        }
+        default:
+        {
+            break;
+        }
+    }
+
+    memset(buf, 0, 64);
+    sprintf(buf, "rm -rf %s", image_new.path);
+    system(buf);
+
+    SAVE_SYS_LOG_MSG_FWUPDATE("[Normalize]creating new image: ongoing...");
+    image_new.size = image->size - 48;
+    file = fopen(image_new.path, "wb+");
+    fwrite(&ptr[48], image_new.size, 1, file); //48: header size
+    fclose(file);
+    free(ptr);
+    SAVE_SYS_LOG_MSG_FWUPDATE("[Normalize]creating new image: done");
+    return PASS;
+}
+
+/*===========================================================================
+FUNCTION: FWImage_Init
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+    1. image file name: "ccs.image"
+OUTPUT:
+    1. type: FW image type
+       - 0:          file is not exist or error occours
+       - 0x10000007: FW_IMAGE_TYPE_CCS_UBOOT
+       - 0x10000008: FW_IMAGE_TYPE_CCS_DTB
+       - 0x10000009: FW_IMAGE_TYPE_CCS_ZIMAGE
+       - 0x1000000A: FW_IMAGE_TYPE_CCS_RAMDISK
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned int FWImage_Init()
+{
+    struct FwImageDataType image;
+    sprintf(image.path, "/root/ccs.image");
+
+    //STEP 1: Check if image exist?
+    image.size = fsize(image.path);
+    if (image.size == 0)
+    {
+        SAVE_SYS_LOG_MSG_FWUPDATE("[Init][Error]image does not exist.");
+        return FAIL;    //FAIL: 0
+    }
+
+    //STEP 2: Check FW image type = ?
+    if (FWImage_HeaderParser(&image) != PASS)
+    {
+        return FAIL;    //FAIL: 0
+    }
+
+    //STEP 4: Remove header and rename the image file accoring to its firmware type
+    if (FWImage_Normalize(&image) != PASS)
+    {
+        return FAIL;    //FAIL: 0
+    }
+
+    //Step 5: return result
+    return image.type;
+}
+
+/*===========================================================================
+FUNCTION: Update_viaWebService
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Update_viaWebService()
+{
+    SAVE_SYS_LOG_MSG_FWUPDATE("-------- [viaWebService]start --------");
+
+    unsigned char result = FAIL;
+    unsigned int type = 0;
+    type = FWImage_Init();
+
+    switch (type)
+    {
+        case FW_IMAGE_TYPE_CCS_UBOOT:
+        {
+            result = Update_uboot();
+            break;
+        }
+        case FW_IMAGE_TYPE_CCS_DTB:
+        {
+            result = Update_DTB();
+            break;
+        }
+        case FW_IMAGE_TYPE_CCS_ZIMAGE:
+        {
+            result = Update_zImage();
+            break;
+        }
+        case FW_IMAGE_TYPE_CCS_RAMDISK:
+        {
+            result = Update_ramdisk();
+            break;
+        }
+        default:
+        {
+            result = FAIL;
+            sprintf(buf_log_fwupdate,
+                    "[Error]undefined FW image type or file not exist.(0x%X)",
+                    type
+                    );
+            SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+            break;
+        }
+    }
+
+    if (result == PASS)
+    {
+        CSUCOMMDC_TASK_FLAG.FW_Update_result = PASS;
+    }
+    else
+    {
+        CSUCOMMDC_TASK_FLAG.FW_Update_result = FAIL;
+    }
+    CSUCOMMDC_TASK_FLAG.FW_Update_Done = TRUE; //sending CAN Res msg to CSU and reboot
+}
+
+/*===========================================================================
+FUNCTION: main
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int main(int argc, char *argv[])
+{
+    // ======== [STEP 1/5] Initialize Share Memory ========
+    if(ShareMemory_Init() == 0)
+    {
+
+        SAVE_SYS_LOG_MSG_FWUPDATE("[main]ShareMemory_Init NG");
+
+
+        if(ShmStatusCodeData != NULL)
+        {
+            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory = 1;
+        }
+        sleep(5);
+        return 0;
+    }
+
+    //Arguments Parsing for Commands
+    if (argv[1][0] == '-' )
+    {
+        switch (argv[1][1])
+        {
+            case 'h':   //help
+            {
+                sprintf(buf_log_fwupdate,
+                        " ================= [HELP] CCS FW Update ==============");
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+
+                sprintf(buf_log_fwupdate,
+                        " -h \t :help");
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+
+                sprintf(buf_log_fwupdate,
+                        " -w \t :image update from WebService (with header, named as ccs.image)");
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+
+                sprintf(buf_log_fwupdate,
+                        " -a \t :full images update \t(no header, named as original names)");
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+
+                sprintf(buf_log_fwupdate,
+                        " -m \t :MLO update \t\t(no header, named as MLO)");
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+
+                sprintf(buf_log_fwupdate,
+                        " -u \t :uboot update \t\t(no header, named as u-boot.img)");
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+
+                sprintf(buf_log_fwupdate,
+                        " -d \t :dtb update \t\t(no header, named as am335x-evm.dtb)");
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+
+                sprintf(buf_log_fwupdate,
+                        " -z \t :zImage update \t(no header, named as zImage)");
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+
+                sprintf(buf_log_fwupdate,
+                        " -r \t :ramdisk update \t(no header, named as ramdisk.gz)");
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+
+                break;
+            }
+            case 'w':   //image update from WebService
+            {
+                Update_viaWebService();
+                break;
+            }
+            case 'a':   //all image update
+            {
+                Update_ALL();
+                break;
+            }
+            case 'm':   //MLO update
+            {
+                Update_MLO();
+                break;
+            }
+            case 'u':   //uboot update
+            {
+                Update_uboot();
+                break;
+            }
+            case 'd':   //dtb update
+            {
+                Update_DTB();
+                break;
+            }
+            case 'z':   //zImage update
+            {
+                Update_zImage();
+                break;
+            }
+            case 'r':   //ramdisk update
+            {
+                Update_ramdisk();
+                break;
+            }
+            default:
+            {
+                sprintf(buf_log_fwupdate, "Unknown option -%c\n\n", argv[1][1]);
+                SAVE_SYS_LOG_MSG_FWUPDATE(buf_log_fwupdate);
+                break;
+            }
+        }
+    }
+}

EVSE/Projects/AW-CCS/Apps/CCS/FWUpdate.h

@@ -0,0 +1,75 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                              FWUpdate.h
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+#if FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == ENABLE
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_FWUPDATE_SWITCH         ENABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_FWUPDATE_SHOW               ENABLE       //ENABLE, DISABLE
+#define DEBUG_PRINTF_FWUPDATE_BRIEF_SHOW         DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FWUPDATE_DETAIL_SHOW        DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FWUPDATE_SYSTEM_LOG_SHOW    ENABLE       //ENABLE, DISABLE
+#else //debug mode
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_FWUPDATE_SWITCH         ENABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_FWUPDATE_SHOW               ENABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FWUPDATE_BRIEF_SHOW         ENABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FWUPDATE_DETAIL_SHOW        ENABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FWUPDATE_SYSTEM_LOG_SHOW    ENABLE      //ENABLE, DISABLE
+#endif
+
+
+#define FW_IMAGE_TYPE_CCS_UBOOT    0x10000007  //CCS board bootloader (uboot)
+#define FW_IMAGE_TYPE_CCS_DTB      0x10000008  //CCS board kernel configuration (dtb)
+#define FW_IMAGE_TYPE_CCS_ZIMAGE   0x10000009  //CCS board kernel image (zImage)
+#define FW_IMAGE_TYPE_CCS_RAMDISK  0x1000000A  //CCS board file system (ramdisk.gz)
+
+struct FwImageDataType
+{
+    char path[64];
+    unsigned long size; //unit: byte
+    unsigned int type;  //4 bytes
+    unsigned int crc;
+};
+
+//System Log
+#if SAVE_SYS_LOG_MSG_FWUPDATE_SWITCH == ENABLE
+    #define SAVE_SYS_LOG_MSG_FWUPDATE     StoreLogMsg
+#else
+    #define SAVE_SYS_LOG_MSG_FWUPDATE(...)
+#endif
+
+//Debug Message
+#if DEBUG_PRINTF_FWUPDATE_SHOW == ENABLE
+    //Brief Messages
+    #if DEBUG_PRINTF_FWUPDATE_BRIEF_SHOW == ENABLE
+        #define DEBUG_PRINTF_FWUPDATE_BRIEF      printf
+    #else
+        #define DEBUG_PRINTF_FWUPDATE_BRIEF(...)
+    #endif
+
+    //Detail Messages
+    #if DEBUG_PRINTF_FWUPDATE_DETAIL_SHOW == ENABLE
+        #define DEBUG_PRINTF_FWUPDATE_DETAIL     printf
+    #else
+        #define DEBUG_PRINTF_FWUPDATE_DETAIL(...)
+    #endif
+
+    //System Log Messages
+    #if DEBUG_PRINTF_FWUPDATE_SYSTEM_LOG_SHOW == ENABLE
+        #define DEBUG_PRINTF_FWUPDATE_SYSTEM_LOG    printf
+    #else
+        #define DEBUG_PRINTF_FWUPDATE_SYSTEM_LOG(...)
+    #endif
+#else
+    #define DEBUG_PRINTF_FWUPDATE_BRIEF(...)
+    #define DEBUG_PRINTF_FWUPDATE_DETAIL(...)
+    #define DEBUG_PRINTF_FWUPDATE_SYSTEM_LOG(...)
+#endif

EVSE/Projects/AW-CCS/Apps/CCS/FactoryConfig.c

@@ -0,0 +1,211 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                            FactoryConfig.c
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+#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 "define.h"
+#include "FactoryConfig.h"
+
+unsigned char buf_log_factoryconfig[SIZE_OF_LOG_BUFFER];
+
+/*===========================================================================
+FUNCTION: StoreLogMsg
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+#if SAVE_SYS_LOG_MSG_FACTORY_CONFIG_SWITCH == ENABLE
+int StoreLogMsg(unsigned char *DataString)
+{
+    static unsigned char Buf[1024];
+    static time_t CurrentTime;
+    static struct tm *tm;
+    static struct timeval tv;
+
+    memset(Buf, 0, sizeof(Buf));
+    CurrentTime = time(NULL);
+    tm = localtime(&CurrentTime);
+    gettimeofday(&tv, NULL); // get microseconds, 10^-6
+
+    sprintf(Buf, "echo \"[%04d%02d%02d: %02d:%02d:%02d.%06d][FactoryConfig]%s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog",
+            tm->tm_year + 1900,
+            tm->tm_mon + 1,
+            tm->tm_mday,
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            DataString,
+            tm->tm_year + 1900,
+            tm->tm_mon + 1);
+    system(Buf);
+
+    DEBUG_PRINTF_FACTORY_CONFIG_SYSTEM_LOG("[%02d:%02d:%02d.%06d][FactoryConfig]%s \n",
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            DataString);
+
+    //Reset the buf_log_factoryconfig Buffer, i.e. DataString
+    memset(buf_log_factoryconfig, 0, SIZE_OF_LOG_BUFFER);
+}
+#endif
+
+
+/**************************************************************************************/
+/************This task will create Factory default confgiuration file *****************/
+/***********and store it into mtdblock 10,11,12                               ****************/
+/**************************************************************************************/
+
+int main(int argc, char *argv[])
+{
+    struct SysConfigData SysConfig;
+    unsigned int i, Chk;
+    unsigned char *ptr;
+    int fd, wrd;
+
+    ptr = malloc(sizeof(struct SysConfigData));
+
+    if(ptr == NULL)
+    {
+        SAVE_SYS_LOG_MSG_FACTORY_CONFIG("[FactoryConfig]main: malloc for SysConfigData NG");
+        return 0;
+    }
+
+    memset(ptr, 0, sizeof(struct SysConfigData));
+    memset(&SysConfig, 0, sizeof(struct SysConfigData));
+
+    //Set default configuration
+    strcpy(SysConfig.Eth0Interface.EthIpAddress, "192.168.0.11");
+    strcpy(SysConfig.Eth0Interface.EthSubmaskAddress, "255.255.255.0");
+    strcpy(SysConfig.Eth0Interface.EthGatewayAddress, "192.168.0.1");
+    strcpy(SysConfig.Eth1Interface.EthIpAddress, "192.168.0.20");
+    strcpy(SysConfig.Eth1Interface.EthSubmaskAddress, "255.255.255.0");
+    strcpy(SysConfig.Eth1Interface.EthGatewayAddress, "192.168.0.1");
+    SysConfig.BackendConnTimeout = 300; //300 seconds
+
+    //copy default configuration to pointer
+    memcpy(ptr, &SysConfig, sizeof(struct SysConfigData));
+
+    //calculate CRC
+    Chk = 0;
+
+    for(i = 0; i < (sizeof(struct SysConfigData) - 4); i++)
+    {
+        Chk += *(ptr + i);
+    }
+
+    SysConfig.Checksum = Chk;
+
+    fd = open("/mnt/FactoryDefaultConfig.bin", O_RDWR | O_CREAT);
+
+    if(fd < 0)
+    {
+        SAVE_SYS_LOG_MSG_FACTORY_CONFIG("[FactoryConfig]main: open /mnt/FactoryDefaultConfig.bin NG");
+
+        free(ptr);
+        return 0;
+    }
+
+    wrd = write(fd, &SysConfig, sizeof(struct SysConfigData));
+    close(fd);
+
+    if(wrd != (sizeof(struct SysConfigData)))
+    {
+        SAVE_SYS_LOG_MSG_FACTORY_CONFIG("[FactoryConfig]main: write /mnt/FactoryDefaultConfig.bin NG");
+
+        free(ptr);
+        return 0;
+    }
+
+    fd = open("/dev/mtdblock12", O_RDWR);
+
+    if(fd < 0)
+    {
+        SAVE_SYS_LOG_MSG_FACTORY_CONFIG("[FactoryConfig]main: open /dev/mtdblock12 NG");
+
+        free(ptr);
+        return 0;
+    }
+
+    wrd = write(fd, &SysConfig, sizeof(struct SysConfigData));
+    close(fd);
+
+    if(wrd != (sizeof(struct SysConfigData)))
+    {
+        SAVE_SYS_LOG_MSG_FACTORY_CONFIG("[FactoryConfig]main: write /dev/mtdblock12 NG");
+
+        free(ptr);
+        return 0;
+    }
+
+    fd = open("/dev/mtdblock11", O_RDWR);
+
+    if(fd < 0)
+    {
+        SAVE_SYS_LOG_MSG_FACTORY_CONFIG("[FactoryConfig]main: open /dev/mtdblock11 NG");
+
+        free(ptr);
+        return 0;
+    }
+
+    wrd = write(fd, &SysConfig, sizeof(struct SysConfigData));
+    close(fd);
+
+    if(wrd != (sizeof(struct SysConfigData)))
+    {
+        SAVE_SYS_LOG_MSG_FACTORY_CONFIG("[FactoryConfig]main: write /dev/mtdblock11 NG");
+
+        free(ptr);
+        return 0;
+    }
+
+    fd = open("/dev/mtdblock10", O_RDWR);
+
+    if(fd < 0)
+    {
+        SAVE_SYS_LOG_MSG_FACTORY_CONFIG("[FactoryConfig]main: open /dev/mtdblock10 NG");
+
+        free(ptr);
+        return 0;
+    }
+
+    wrd = write(fd, &SysConfig, sizeof(struct SysConfigData));
+    close(fd);
+
+    if(wrd != (sizeof(struct SysConfigData)))
+    {
+        SAVE_SYS_LOG_MSG_FACTORY_CONFIG("[FactoryConfig]main: write /dev/mtdblock10 NG");
+
+        free(ptr);
+        return 0;
+    }
+
+    free(ptr);
+
+    SAVE_SYS_LOG_MSG_FACTORY_CONFIG("[FactoryConfig]main: FactoryConfig OK");
+}

EVSE/Projects/AW-CCS/Apps/CCS/FactoryConfig.h

@@ -0,0 +1,61 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                            FactoryConfig.h
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+#if FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == ENABLE
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_FACTORY_CONFIG_SWITCH         ENABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_FACTORY_CONFIG_SHOW               DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FACTORY_CONFIG_BRIEF_SHOW         DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FACTORY_CONFIG_DETAIL_SHOW        DISABLE     //ENABLE, DISABLE
+#define DEBUG_PRINTF_FACTORY_CONFIG_SYSTEM_LOG_SHOW    DISABLE      //ENABLE, DISABLE
+#else //debug mode
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_FACTORY_CONFIG_SWITCH         ENABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_FACTORY_CONFIG_SHOW               ENABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FACTORY_CONFIG_BRIEF_SHOW         ENABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_FACTORY_CONFIG_DETAIL_SHOW        DISABLE     //ENABLE, DISABLE
+#define DEBUG_PRINTF_FACTORY_CONFIG_SYSTEM_LOG_SHOW    ENABLE      //ENABLE, DISABLE
+#endif
+
+//System Log
+#if SAVE_SYS_LOG_MSG_FACTORY_CONFIG_SWITCH == ENABLE
+    #define SAVE_SYS_LOG_MSG_FACTORY_CONFIG     StoreLogMsg
+#else
+    #define SAVE_SYS_LOG_MSG_FACTORY_CONFIG(...)
+#endif
+
+//Debug Message
+#if DEBUG_PRINTF_FACTORY_CONFIG_SHOW == ENABLE
+    //Brief Messages
+    #if DEBUG_PRINTF_FACTORY_CONFIG_BRIEF_SHOW == ENABLE
+        #define DEBUG_PRINTF_FACTORY_CONFIG_BRIEF      printf
+    #else
+        #define DEBUG_PRINTF_FACTORY_CONFIG_BRIEF(...)
+    #endif
+
+    //Detail Messages
+    #if DEBUG_PRINTF_FACTORY_CONFIG_DETAIL_SHOW == ENABLE
+        #define DEBUG_PRINTF_FACTORY_CONFIG_DETAIL     printf
+    #else
+        #define DEBUG_PRINTF_FACTORY_CONFIG_DETAIL(...)
+    #endif
+
+    //System Log Messages
+    #if DEBUG_PRINTF_FACTORY_CONFIG_SYSTEM_LOG_SHOW == ENABLE
+        #define DEBUG_PRINTF_FACTORY_CONFIG_SYSTEM_LOG    printf
+    #else
+        #define DEBUG_PRINTF_FACTORY_CONFIG_SYSTEM_LOG(...)
+    #endif
+#else
+    #define DEBUG_PRINTF_FACTORY_CONFIG_BRIEF(...)
+    #define DEBUG_PRINTF_FACTORY_CONFIG_DETAIL(...)
+    #define DEBUG_PRINTF_FACTORY_CONFIG_SYSTEM_LOG(...)
+#endif

EVSE/Projects/AW-CCS/Apps/CCS/Makefile

@@ -0,0 +1,144 @@
+#===========================================================================
+#                    Combined Charging System (CCS): SECC
+#                                 Makefile
+
+#                        initiated by Vern, Joseph
+#                           (since 2019/07/19)
+#=============================================================================
+	
+ifeq ($(CCSType),AWCCS)
+-include ../../../../../Rules.make
+export PATH=/bin:/sbin:/usr/bin:$(SDK_PATH_TARGET)/usr/bin:$PATH
+SSL_PATH= ../../../../GPL/openssl-1.0.2g/
+CFLAGS=-I$(SSL_PATH)include -L$(SSL_PATH)lib/ -lcrypto -lssl
+else
+-include ../Rules.make
+export PATH=/bin:/sbin:/usr/bin:$(SDK_PATH_TARGET)/usr/bin:$PATH
+SSL_PATH= ../../../GPL/openssl-1.0.2g/
+CFLAGS=-I$(SSL_PATH)include -L$(SSL_PATH)lib/ -lcrypto -lssl
+endif
+
+EXI_ENGINE =	exi_engine/api/api.c \
+				exi_engine/appHandshake/appHandEXIDatatypes.c \
+				exi_engine/appHandshake/appHandEXIDatatypesDecoder.c \
+				exi_engine/appHandshake/appHandEXIDatatypesEncoder.c \
+				exi_engine/codec/BitInputStream.c \
+				exi_engine/codec/BitOutputStream.c \
+				exi_engine/codec/ByteStream.c \
+				exi_engine/codec/DecoderChannel.c \
+				exi_engine/codec/EncoderChannel.c \
+				exi_engine/codec/EXIHeaderDecoder.c \
+				exi_engine/codec/EXIHeaderEncoder.c \
+				exi_engine/codec/MethodsBag.c \
+				exi_engine/din/dinEXIDatatypes.c \
+				exi_engine/din/dinEXIDatatypesDecoder.c \
+				exi_engine/din/dinEXIDatatypesEncoder.c \
+				exi_engine/iso1/iso1EXIDatatypes.c \
+				exi_engine/iso1/iso1EXIDatatypesDecoder.c \
+				exi_engine/iso1/iso1EXIDatatypesEncoder.c \
+				exi_engine/iso2/iso2EXIDatatypes.c \
+				exi_engine/iso2/iso2EXIDatatypesDecoder.c \
+				exi_engine/iso2/iso2EXIDatatypesEncoder.c \
+				exi_engine/transport/v2gtp.c \
+				exi_engine/xmldsig/xmldsigEXIDatatypes.c \
+				exi_engine/xmldsig/xmldsigEXIDatatypesDecoder.c \
+				exi_engine/xmldsig/xmldsigEXIDatatypesEncoder.c
+
+all: init secc
+ifeq ($(CCSType),AWCCS)
+secc:  CsuCommTask SeccCommTask 
+else
+secc: MainTask SeccCommTask CsuCommTask FactoryConfigTask FWUpdateTask PCBATesterTask
+endif
+
+evcc: MainTask EvccCommTask CsuCommTask FactoryConfigTask FWUpdateTask PCBATesterTask
+#secc: MainTask CsuCommTask FactoryConfigTask SeccCommTask FWUpdateTask FWMakerTask EventLoggingTask
+
+MainTask:
+	rm -f main
+	$(CC) main.c -lm -o main
+	cp -f main ../Images/root
+	rm -f main
+
+CsuCommTask:
+ifeq ($(CCSType),AWCCS)
+	rm -f CsuComm
+	@echo "=============== Make AC CsuCommTask==========================="
+	$(CC) -D $(CCSType) CsuComm.c ${EXI_ENGINE} -lm -o CsuComm
+	cp -f CsuComm ../../Images/root
+else
+	@echo "=============== Make DC CsuCommTask==========================="
+	rm -f CsuComm
+	$(CC) CsuComm.c ${EXI_ENGINE} -lm -o CsuComm
+	cp -f CsuComm ../Images/root
+endif
+#	rm -f CsuComm
+
+SeccCommTask:
+	rm -f SeccComm
+ifeq ($(CCSType),AWCCS)
+	@echo "=============== Make AC SeccCommTask==========================="
+	$(CC) -D $(CCSType) SeccComm.c NidNmk.c ${EXI_ENGINE} -lm -o SeccComm $(CFLAGS)
+	cp -f SeccComm ../../Images/root
+	cp -f cacert.pem ../../Images/root
+	cp -f cakey.pem ../../Images/root
+else
+	@echo "=============== Make DC SeccCommTask==========================="
+	$(CC) SeccComm.c NidNmk.c ${EXI_ENGINE} -lm -o SeccComm $(CFLAGS)
+	cp -f SeccComm ../Images/root
+	cp -f cacert.pem ../Images/root
+	cp -f cakey.pem ../Images/root
+endif
+#	rm -f SeccComm
+
+FactoryConfigTask:
+	rm -f FactoryConfig
+	$(CC) FactoryConfig.c -o FactoryConfig
+	cp -f FactoryConfig ../Images/root
+	rm -f FactoryConfig
+	
+EvccCommTask:
+	rm -f EvccComm
+	$(CC) EvccComm.c NidNmk.c ${EXI_ENGINE} -lm -o EvccComm
+	cp -f EvccComm ../Images/root
+	rm -f EvccComm
+
+FWUpdateTask:
+	rm -f FWUpdate
+	$(CC) FWUpdate.c -o FWUpdate
+	cp -f FWUpdate ../Images/root
+	rm -f FWUpdate
+
+EventLoggingTask:
+	rm -f EventLogging
+	$(CC) EventLogging.c -o EventLogging
+	cp -f EventLogging ../Images/root
+	rm -f EventLogging
+
+FWMakerTask:
+	rm -f FWMaker
+	$(CC) FWMaker.c -o FWMaker
+	cp -f FWMaker ../Images/root
+	rm -f FWMaker
+
+PCBATesterTask:
+	rm -f PCBATester
+	$(CC) PCBATester.c -lm -o PCBATester
+	cp -f PCBATester ../Images/root
+	rm -f PCBATester
+
+init:
+	rm -rfv ../Images/root
+	mkdir -p ../Images/root
+#	cp -rfv ../Images/boot/reset_soft.sh ../Images/root/
+#	cp -rfv ../Images/boot/stop.sh ../Images/root/
+#	cp -rfv ../Images/boot/reboot.sh ../Images/root/
+
+zip:
+	mkdir -p ./image/
+	cp -rfv ../Images/root/* ./image/
+	tar -zcvf ramdisk_app_type_5.tar.gz image/
+	cp -rfv ramdisk_app_type_5.tar.gz ../Images/
+	mv -f ramdisk_app_type_5.tar.gz ../Images/
+	rm -rf image/
+	wc -c ../Images/ramdisk_app_type_5.tar.gz

EVSE/Projects/AW-CCS/Apps/CCS/Module_CCS.c

@@ -1,14548 +0,0 @@
-/*
- * Module_CCS.c
- *
- *  Created on: 2020/03/16
- *      Author: foluswen
- */
-#include "Module_CCS.h"
-#include "define_ccs.h"
-#include "main.h"
-
-enum MsgFlowStatus V2gFlowStatus;
-
-struct SysConfigAndInfo *ShmSysConfigAndInfo;
-struct StatusCodeData *ShmStatusCodeData;
-struct CcsData *ShmCcsData;
-struct InternalComm *ShmInternalComm;
-struct Charger *ShmCharger;
-
-struct V2G_OBJECT
-{
-	struct appHandEXIDocument appHandshake;
-	struct dinEXIDocument DIN;
-	struct iso1EXIDocument ISO1;
-	struct iso2EXIDocument ISO2;
-}v2gObject;
-
-struct V2G_BUFFER
-{
-	unsigned char rx[V2GTP_MSG_RX_BUFFER_SIZE];
-	unsigned char tx[V2GTP_MSG_TX_BUFFER_SIZE];
-}v2gBuffer;
-
-struct SOCKET_HANDLE
-{
-	int Raw;
-	int Udp;
-	int Tcp;
-	int TcpAccept;
-}socketFd;
-
-struct PID_T
-{
-	pid_t CP_Detection;
-	pid_t PP_Detection;
-	pid_t Error_Monitor;
-}pid;
-
-struct MAC
-{
-	unsigned char eth0[6];
-	unsigned char eth1[6];
-	unsigned char qca[6];
-	unsigned char evcc[6];
-}macAddr;
-
-struct QCA_INFO
-{
-	struct MmeHeader SendMmePacket;
-	struct sockaddr_ll DestSocketAddress;
-
-	int SendMmePacketSize;
-	unsigned char SlacRunId[8];
-	struct ifreq Req;
-	unsigned char AagGroupsNum;
-	unsigned char MnbcSoundNum;
-	unsigned char AttenProfileCnt;
-	unsigned char NewNmkKey[16];
-	unsigned char Nid[7];
-}qcaInfo;
-
-struct TIMER
-{
-	unsigned int PwmStart;
-	struct timeb SeqStart;
-	struct timeb SeqEnd;
-}timerStart;
-
-
-/**
- *
- * @param statusCode
- * @param statusName
- * @return
- */
-uint8_t get_V2G_Status_Name(uint8_t statusCode, char *statusName)
-{
-	int result = PASS;
-
-	switch(statusCode)
-	{
-		case IDLE:
-			sprintf(statusName, "IDLE");
-			break;
-		case CM_SLAC_PARM_REQ:
-			sprintf(statusName, "CM_SLAC_PARM_REQ");
-			break;
-		case CM_SLAC_PARM_CONF:
-			sprintf(statusName, "CM_SLAC_PARM_CONF");
-			break;
-		case CM_START_ATTEN_CHAR_IND:
-			sprintf(statusName, "CM_START_ATTEN_CHAR_IND");
-			break;
-		case CM_MNBC_SOUND_IND:
-			sprintf(statusName, "CM_MNBC_SOUND_IND");
-			break;
-		case CM_ATTEN_CHAR_IND:
-			sprintf(statusName, "CM_ATTEN_CHAR_IND");
-			break;
-		case CM_ATTEN_CHAR_RSP:
-			sprintf(statusName, "CM_ATTEN_CHAR_RSP");
-			break;
-		case CM_VALIDATE_REQ:
-			sprintf(statusName, "CM_VALIDATE_REQ");
-			break;
-		case CM_VALIDATE_CNF:
-			sprintf(statusName, "CM_VALIDATE_CNF");
-			break;
-		case CM_SLAC_MATCH_REQ:
-			sprintf(statusName, "CM_SLAC_MATCH_REQ");
-			break;
-		case CM_SLAC_MATCH_CNF:
-			sprintf(statusName, "CM_SLAC_MATCH_CNF");
-			break;
-		case CM_AMP_MAP_REQ:
-			sprintf(statusName, "CM_AMP_MAP_REQ");
-			break;
-		case CM_AMP_MAP_CNF:
-			sprintf(statusName, "CM_AMP_MAP_CNF");
-			break;
-		case CM_SET_KEY_REQ:
-			sprintf(statusName, "CM_SET_KEY_REQ");
-			break;
-		case CM_SET_KEY_CNF:
-			sprintf(statusName, "CM_SET_KEY_CNF");
-			break;
-		case SLACC_SDP_UDP_Connection:
-			sprintf(statusName, "SLACC_SDP_UDP_Connection");
-			break;
-		case SLACC_SDP_TCP_Connection:
-			sprintf(statusName, "SLACC_SDP_TCP_Connection");
-			break;
-		case SupportedAppProtocolRequest:
-			sprintf(statusName, "SupportedAppProtocolReq");
-			break;
-		case SupportedAppProtocolResponse:
-			sprintf(statusName, "SupportedAppProtocolRes");
-			break;
-		case SessionSetupRequest:
-			sprintf(statusName, "SessionSetupReq");
-			break;
-		case SessionSetupResponse:
-			sprintf(statusName, "UnSessionSetupResknown");
-			break;
-		case ServiceDiscoveryRequest:
-			sprintf(statusName, "ServiceDiscoveryReq");
-			break;
-		case ServiceDiscoveryResponse:
-			sprintf(statusName, "ServiceDiscoveryRes");
-			break;
-		case ServiceDetailRequest:
-			sprintf(statusName, "ServiceDetailReq");
-			break;
-		case ServiceDetailResponse:
-			sprintf(statusName, "ServiceDetailRes");
-			break;
-		case ServiceAndPaymentSelectionRequest:
-			sprintf(statusName, "ServiceAndPaymentSelectionReq");
-			break;
-		case ServiceAndPaymentSelectionResponse:
-			sprintf(statusName, "ServiceAndPaymentSelectionRes");
-			break;
-		case PaymentDetailsRequest:
-			sprintf(statusName, "PaymentDetailsReq");
-			break;
-		case PaymentDetailsResponse:
-			sprintf(statusName, "PaymentDetailsRes");
-			break;
-		case AuthorizationRequest:
-			sprintf(statusName, "AuthorizationReq");
-			break;
-		case AuthorizationResponse:
-			sprintf(statusName, "AuthorizationRes");
-			break;
-		case CertificateUpdateRequest:
-			sprintf(statusName, "CertificateUpdateReq");
-			break;
-		case CertificateUpdateResponse:
-			sprintf(statusName, "CertificateUpdateRes");
-			break;
-		case CertificateInstallationRequest:
-			sprintf(statusName, "CertificateInstallationReq");
-			break;
-		case CertificateInstallationResponse:
-			sprintf(statusName, "CertificateInstallationRes");
-			break;
-		case ChargeParameterDiscoveryRequest:
-			sprintf(statusName, "ChargeParameterDiscoveryReq");
-			break;
-		case ChargeParameterDiscoveryResponse:
-			sprintf(statusName, "ChargeParameterDiscoveryRes");
-			break;
-		case CableCheckRequest:
-			sprintf(statusName, "CableCheckReq");
-			break;
-		case CableCheckResponse:
-			sprintf(statusName, "CableCheckRes");
-			break;
-		case PreChargeRequest:
-			sprintf(statusName, "PreChargeReq");
-			break;
-		case PreChargeResponse:
-			sprintf(statusName, "PreChargeRes");
-			break;
-		case PowerDeliveryRequestStart:
-			sprintf(statusName, "PowerDeliveryReqStart");
-			break;
-		case PowerDeliveryResponsetStart:
-			sprintf(statusName, "PowerDeliveryResStart");
-			break;
-		case ChargingStatusRequest:
-			sprintf(statusName, "ChargingStatusReq");
-			break;
-		case ChargingStatusResponse:
-			sprintf(statusName, "ChargingStatusRes");
-			break;
-		case CurrentDemandRequest:
-			sprintf(statusName, "CurrentDemandReq");
-			break;
-		case CurrentDemandResponse:
-			sprintf(statusName, "CurrentDemandRes");
-			break;
-		case MeteringReceiptRequest:
-			sprintf(statusName, "MeteringReceiptReq");
-			break;
-		case MeteringReceiptResponse:
-			sprintf(statusName, "MeteringReceiptRes");
-			break;
-		case PowerDeliveryRequestStop:
-			sprintf(statusName, "PowerDeliveryReqStop");
-			break;
-		case PowerDeliveryResponseStop:
-			sprintf(statusName, "PowerDeliveryResStop");
-			break;
-		case WeldingDetectionRequest:
-			sprintf(statusName, "WeldingDetectionReq");
-			break;
-		case WeldingDetectionResponse:
-			sprintf(statusName, "WeldingDetectionRes");
-			break;
-		case SessionStopRequest:
-			sprintf(statusName, "SessionStopReq");
-			break;
-		case SessionStopResponse:
-			sprintf(statusName, "SessionStopRes");
-			break;
-		case Performance_Timeout:
-			sprintf(statusName, "Performance_Timeout");
-			break;
-		case Sequence_Timeout:
-			sprintf(statusName, "Sequence_Timeout");
-			break;
-		case Other_Fault:
-			sprintf(statusName, "Other_Fault");
-			break;
-		default:
-			sprintf(statusName, "Unknown");
-			result = FAIL;
-			break;
-	}
-
-	return result;
-}
-
-/**
- *
- * @return
- */
-unsigned char Get_V2G_Status()
-{
-    unsigned char result = 0;
-
-    switch (ShmCcsData->CommProtocol)
-    {
-        case V2GT_MSG_PROTOCOL_DIN70121:        //0
-        {
-            result = ShmCcsData->V2GMessage_DIN70121.PresentMsgFlowStatus;
-            break;
-        }
-
-        case V2GT_MSG_PROTOCOL_ISO15118_2014:   //1
-        {
-            result = ShmCcsData->V2GMessage_ISO15118_2014.PresentMsgFlowStatus;
-            break;
-        }
-
-        case V2GT_MSG_PROTOCOL_ISO15118_2018:   //2
-        {
-            result = ShmCcsData->V2GMessage_ISO15118_2018.PresentMsgFlowStatus;
-            break;
-        }
-
-        default:
-            break;
-    }
-
-    return result;
-}
-
-/**
- *
- * @return
- */
-unsigned char Get_V2G_Status_pre()
-{
-    unsigned char result = 0;
-
-    switch (ShmCcsData->CommProtocol)
-    {
-        case V2GT_MSG_PROTOCOL_DIN70121:        //0
-        {
-            result = ShmCcsData->V2GMessage_DIN70121.PresentMsgFlowStatus_pre;
-            break;
-        }
-
-        case V2GT_MSG_PROTOCOL_ISO15118_2014:   //1
-        {
-            result = ShmCcsData->V2GMessage_ISO15118_2014.PresentMsgFlowStatus_pre;
-            break;
-        }
-
-        case V2GT_MSG_PROTOCOL_ISO15118_2018:   //2
-        {
-            result = ShmCcsData->V2GMessage_ISO15118_2018.PresentMsgFlowStatus_pre;
-            break;
-        }
-
-        default:
-            break;
-    }
-    return result;
-}
-
-/**
- *
- * @param Fd
- * @param MsgId
- * @param SlaveAddress
- * @param DataLength
- * @param SendData
- * @return
- */
-int CAN_Tx_MSG(int Fd, unsigned int MsgId, unsigned char SlaveAddress, unsigned char DataLength, unsigned char *SendData)
-{
-#if 0
-    struct can_frame frame;
-    struct timeb StartTime, EndTime;
-    unsigned int tmp = 0;
-    int nbytes = 0;
-    int i = 0;
-
-    //Protection: To avoid unexpected length for CAN bus payload.
-    if (DataLength > 8)
-    {
-        DataLength = 8;
-    }
-
-    memset(&frame, 0, sizeof(struct can_frame));
-    frame.can_id = 0x80000000 | CAN_SEND_DIRECTION | MsgId | SlaveAddress;  //0x80000000: extension ID format
-    frame.can_dlc = DataLength;
-    memcpy(frame.data, SendData, DataLength);
-    nbytes = write(Fd, &frame, sizeof(struct can_frame));
-
-    return nbytes;
-#else
-    return -1;
-#endif
-}
-
-/**
- *
- * @param Fd
- * @return
- */
-int Proc_EVStopRes(int Fd)
-{
-    int nbytes;
-    unsigned char Buffer[8];
-
-    memset(Buffer, 0, sizeof(Buffer));
-    if (CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency == TRUE)
-    {
-        Buffer[0] = EV_EMERGENCY_STOP;  //2
-    }
-    else
-    {
-        Buffer[0] = EV_NORMAL_STOP;     //1
-    }
-
-    Buffer[1] = ShmStatusCodeData->PresentStatusCode[0][0];
-    Buffer[2] = ShmStatusCodeData->PresentStatusCode[0][1];
-    Buffer[3] = ShmStatusCodeData->PresentStatusCode[0][2];
-    Buffer[4] = ShmStatusCodeData->PresentStatusCode[0][3];
-    Buffer[5] = ShmStatusCodeData->PresentStatusCode[0][4];
-    Buffer[6] = ShmStatusCodeData->PresentStatusCode[0][5];
-
-
-    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_EV_STOP_EVENT, ShmInternalComm->SlaveAddress, 7, Buffer);
-    //system("echo 1000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle"); //for test only
-    //system("echo 0 > /sys/class/gpio/gpio89/value");    //for test
-
-    DEBUG_INFO("Sending STOP Command to CSU\n");
-
-    CSUCOMMDC_TASK_FLAG.Send_EVStopReq = FALSE;
-
-    return nbytes;
-}
-
-/**
- *
- * @param cmd
- * @return
- */
-int Sniffer_Candump(char cmd)
-{
-#if (CANDUMP_PACKETS_SNIFFER_SWITCH == ENABLE)
-    if (cmd == ENABLE)
-    {
-        DEBUG_INFO("Candump init\n");
-        system("cd /mnt/;rm -rf candump/");
-        system("cd /mnt/;mkdir candump");
-        DEBUG_INFO("Candump on\n");
-        system("cd /mnt/candump;candump -l can0 &");
-        return 0;
-    }
-    else if (cmd == DISABLE)
-    {
-        DEBUG_INFO("Candump off\n");
-        system("killall candump");
-
-        DEBUG_INFO("Candump save\n");
-        system("cd /;cp -rfv /mnt/candump /Storage/SystemLog/");
-        return 0;
-    }
-    else
-    {
-        DEBUG_INFO("Candump unexpected cmd(%d)\n", cmd);
-        return -1;
-    }
-#endif
-
-    return 0;
-}
-
-/**
- *
- * @param cmd
- * @return
- */
-int Sniffer_Tcpdump(char cmd)
-{
-    #if (TCPDUMP_PACKETS_SNIFFER_SWITCH == ENABLE)
-    if (cmd == ENABLE)
-    {
-        DEBUG_INFO("Tcpdump init...\n");
-        system("cd /mnt/;rm -rf tcpdump/");
-        system("cd /mnt/;mkdir tcpdump");
-
-        unsigned char cmdBuf[256];
-        time_t CurrentTime;
-        struct tm *tm;
-        struct timeval tv;
-
-        memset(cmdBuf, 0, sizeof(cmdBuf));
-        CurrentTime = time(NULL);
-        tm = localtime(&CurrentTime);
-        gettimeofday(&tv, NULL); // get microseconds, 10^-6
-        sprintf((char*)cmdBuf, "tcpdump -i eth1 -p \"udp or ether proto 0x88e1\" -w /mnt/tcpdump/[%04d.%02d]CCS_SlacPackets_%02X%02X%02X%02X%02X%02X%02X%02X.log &",
-								(tm->tm_year+1900),
-								(tm->tm_mon+1),
-								EVCOMM_SYS_INFO.SessionID[0],
-								EVCOMM_SYS_INFO.SessionID[1],
-								EVCOMM_SYS_INFO.SessionID[2],
-								EVCOMM_SYS_INFO.SessionID[3],
-								EVCOMM_SYS_INFO.SessionID[4],
-								EVCOMM_SYS_INFO.SessionID[5],
-								EVCOMM_SYS_INFO.SessionID[6],
-								EVCOMM_SYS_INFO.SessionID[7]);
-        DEBUG_INFO("Tcpdump on\n");
-        system((char*)cmdBuf);
-
-        return 0;
-    }
-    else if (cmd == DISABLE)
-    {
-        DEBUG_INFO("Tcpdump off\n");
-        system("killall tcpdump");
-        for(int idx=2;idx>0;idx--)
-        {
-			DEBUG_INFO("Tcpdump wait: %ds\n", idx);
-			sleep(1);
-        }
-        DEBUG_INFO("Tcpdump save\n");
-        system("cd /;cp -rfv /mnt/tcpdump/* /Storage/SystemLog/");
-        system("cd /mnt/;rm -rf tcpdump/");
-        return 0;
-    }
-    else
-    {
-        DEBUG_INFO("Tcpdump unexpected cmd(%d)\n", cmd);
-
-        return -1;
-    }
-    #endif
-
-    return 0;
-}
-/**
- *
- * @param state_new
- * @return
- */
-int Update_V2G_Status(unsigned int state_new)
-{
-    unsigned char state_now;
-    char nameNow[64], nameNew[64];
-
-    state_now = Get_V2G_Status();
-    get_V2G_Status_Name(state_now, nameNow);
-    get_V2G_Status_Name(state_new, nameNew);
-
-    if (EVCOMM_SYS_INFO.End_Process_inused == TRUE ||
-        CSUCOMMDC_TASK_FLAG.FW_Update_Task_inused == TRUE)
-    {
-        if (state_now != Performance_Timeout &&     //253
-            state_now != Sequence_Timeout &&        //254
-            state_now != Other_Fault)               //255
-        {
-        	DEBUG_WARN("state-%s(%d) change: ignored (End_Process_inused:%d, FW_Update_Task_inused:%d)\n",
-						nameNew, state_new,
-						EVCOMM_SYS_INFO.End_Process_inused,
-						CSUCOMMDC_TASK_FLAG.FW_Update_Task_inused);
-            return -1;
-        }
-    }
-    if (state_now != state_new)
-    {
-        //Step 1: Check if Error Occours
-        if (state_now == Performance_Timeout ||     //253
-            state_now == Sequence_Timeout ||        //254
-            state_now == Other_Fault)               //255
-        {
-            if (state_new != IDLE)
-            {
-                if (EVCOMM_SYS_INFO.State_Change_Ignored_Notice == FALSE)
-                {
-                    EVCOMM_SYS_INFO.State_Change_Ignored_Notice = TRUE;
-                    DEBUG_WARN("state-%s(%d) change: ignored(now in error state-%s(%d))\n", nameNow, state_new, nameNew, state_now);
-                }
-                return -1;
-            }
-        }
-
-        //Updating the state formally.
-        DEBUG_INFO("%s(%02d) > %s(%02d)\n", nameNow, state_now, nameNew, state_new);
-
-        V2gFlowStatus = state_new;
-        state_now = state_new;
-
-        switch (ShmCcsData->CommProtocol)
-        {
-            case V2GT_MSG_PROTOCOL_DIN70121:        //0
-            {
-                ShmCcsData->V2GMessage_DIN70121.PresentMsgFlowStatus_pre = ShmCcsData->V2GMessage_DIN70121.PresentMsgFlowStatus;
-                ShmCcsData->V2GMessage_DIN70121.PresentMsgFlowStatus = V2gFlowStatus;
-                break;
-            }
-
-            case V2GT_MSG_PROTOCOL_ISO15118_2014:   //1
-            {
-                ShmCcsData->V2GMessage_ISO15118_2014.PresentMsgFlowStatus_pre = ShmCcsData->V2GMessage_ISO15118_2014.PresentMsgFlowStatus;
-                ShmCcsData->V2GMessage_ISO15118_2014.PresentMsgFlowStatus = V2gFlowStatus;
-                break;
-            }
-
-            case V2GT_MSG_PROTOCOL_ISO15118_2018:   //2
-            {
-                ShmCcsData->V2GMessage_ISO15118_2018.PresentMsgFlowStatus_pre = ShmCcsData->V2GMessage_ISO15118_2018.PresentMsgFlowStatus;
-                ShmCcsData->V2GMessage_ISO15118_2018.PresentMsgFlowStatus = V2gFlowStatus;
-                break;
-            }
-
-            default:
-                break;
-        }
-    }
-
-    return 0;
-}
-
-/**
- *
- * @param ST
- * @param ET
- * @return
- */
-
-double DiffTimeb(struct timeb ST, struct timeb ET)
-{
-    //return milli-second
-    double StartTime, EndTime;
-    double t_diff;
-
-    StartTime = ((double)ST.time)*1000 + (double)ST.millitm;
-    EndTime = ((double)ET.time)*1000 + (double)ET.millitm;
-    t_diff = EndTime - StartTime;
-
-    if (t_diff < 0)
-    {
-        return -1;
-    }
-    return t_diff;
-}
-
-
-/**
- *
- * @param ST
- * @param ET
- * @return
- */
-double DiffTimeb_fork1_Error_Monitor(struct timeb ST, struct timeb ET)
-{
-    //return milli-second
-    static double StartTime, EndTime;
-    static double t_diff;
-
-    StartTime = ((double)ST.time)*1000 + (double)ST.millitm;
-    EndTime = ((double)ET.time)*1000 + (double)ET.millitm;
-    t_diff = EndTime - StartTime;
-
-    if (t_diff < 0)
-    {
-        return -1;
-    }
-    return t_diff;
-}
-
-
-/**
- *
- * @param ST
- * @param ET
- * @return
- */
-double DiffTimeb_fork2_Error_Monitor(struct timeb ST, struct timeb ET)
-{
-    //return milli-second
-    static double StartTime, EndTime;
-    static double t_diff;
-
-    StartTime = ((double)ST.time)*1000 + (double)ST.millitm;
-    EndTime = ((double)ET.time)*1000 + (double)ET.millitm;
-    t_diff = EndTime - StartTime;
-
-    if (t_diff < 0)
-    {
-        return -1;
-    }
-    return t_diff;
-}
-
-/**
- *
- * @return
- */
-int ShareMemory_Init()
-{
-    int MeterSMId;
-
-    //create ShmSysConfigAndInfo
-    if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo), IPC_CREAT | 0777)) < 0)
-    {
-    	DEBUG_ERROR("ShareMemory_Init:shmget ShmSysConfigAndInfo NG\n");
-        return 0;
-    }
-    else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
-    {
-    	DEBUG_ERROR("ShareMemory_Init:shmat ShmSysConfigAndInfo NG\n");
-        return 0;
-    }
-
-    //create ShmStatusCodeData
-    if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  IPC_CREAT | 0777)) < 0)
-    {
-    	DEBUG_ERROR("ShareMemory_Init:shmget ShmStatusCodeData NG\n");
-        return 0;
-    }
-    else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
-    {
-    	DEBUG_ERROR("ShareMemory_Init:shmat ShmStatusCodeData NG\n");
-        return 0;
-    }
-
-    //create ShmCcsData
-    if ((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData),  IPC_CREAT | 0777)) < 0)
-    {
-    	DEBUG_ERROR("ShareMemory_Init:shmget ShmCcsData NG\n");
-        return 0;
-    }
-    else if ((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
-    {
-    	DEBUG_ERROR("ShareMemory_Init:shmat ShmCcsData NG\n");
-        return 0;
-    }
-
-    //create ShmInternalComm
-    if ((MeterSMId = shmget(ShmInternalCommKey, sizeof(struct InternalComm),   IPC_CREAT | 0777)) < 0)
-    {
-    	DEBUG_ERROR("ShareMemory_Init:shmget ShmInternalComm NG\n");
-        return 0;
-    }
-    else if ((ShmInternalComm = shmat(MeterSMId, NULL, 0)) == (void *) -1)
-    {
-    	DEBUG_ERROR("ShareMemory_Init:shmat ShmInternalComm NG\n");
-        return 0;
-    }
-
-    //Initial ShmCharger
-	if ((MeterSMId = shmget(ShmChargerKey, sizeof(struct Charger), 0777)) < 0)
-	{
-		DEBUG_ERROR("shmget ShmChargerKey NG\n");
-		return 0;
-	}
-	else if ((ShmCharger = shmat(MeterSMId, NULL, 0)) == (void *) -1)
-	{
-		DEBUG_ERROR("shmat ShmChargerKey NG\n");
-		return 0;
-	}
-
-    //[To-Do] The initialization here is reduntant and should be removed partially.
-    //SHM_Init_supportedAppProtocolRes(ShmCcsData);
-    //SHM_Init_din_SessionSetupRes(ShmCcsData);
-    //SHM_Init_din_ServiceDiscoveryRes(ShmCcsData);
-    //SHM_Init_din_ServiceAndPaymentSelectionRes(ShmCcsData);
-    //SHM_Init_din_ContractAuthenticationRes(ShmCcsData);
-    SHM_Init_din_ChargeParameterDiscoveryRes(ShmCcsData);
-    SHM_Init_din_CableCheckRes(ShmCcsData);
-    SHM_Init_din_PreChargeRes(ShmCcsData);
-    SHM_Init_din_PowerDeliveryRes(ShmCcsData);
-    SHM_Init_din_CurrentDemandRes(ShmCcsData);
-    SHM_Init_din_WeldingDetectionRes(ShmCcsData);
-    SHM_Init_din_SessionStopRes(ShmCcsData);
-
-    return 1;
-}
-
-/**
- *  1. Accessing current CsuMac address, if Eth = eth1
-    2. The address of eth1(for QCA7000) is a random number, which will be modified
-       after each time of booting up system.
- * @param Eth
- * @param mac
- * @return
- */
-int GetEthMac(unsigned char *Eth, unsigned char *mac)
-{
-    //Parameters:MAC,IP,Mask,Gateway
-    int fd;
-    unsigned char addr[18], Buffer[128];
-
-    memset(Buffer, 0, sizeof(Buffer));
-    sprintf((char*)Buffer, "cat /sys/class/net/%s/address > /mnt/GetEthInfo", Eth);    //CsuMac (Eth = eth1)
-    system((char*)Buffer);
-    fd = open("/mnt/GetEthInfo", O_RDONLY);
-    if(fd < 0)
-    {
-        system("rm -f /mnt/GetEthInfo");
-        DEBUG_ERROR("GetEthMac: MAC Address open error\n");
-        return 0;
-    }
-    memset(mac, 0, 6);
-    memset(addr, 0, sizeof(addr));
-    read(fd, addr, 17);
-    close(fd);
-    system("rm -f /mnt/GetEthInfo");
-    sscanf((char*)addr, "%02x:%02x:%02x:%02x:%02x:%02x", (uint32_t *)&mac[0], (uint32_t *)&mac[1], (uint32_t *)&mac[2], (uint32_t *)&mac[3], (uint32_t *)&mac[4], (uint32_t *)&mac[5]);    //CsuMac (Eth = eth1)
-    DEBUG_INFO("EVSE MAC address(%s): %02X:%02X:%02X:%02X:%02X:%02X\n", Eth, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
-    return 1;
-}
-
-/**
- *
- * @param AdcChannel
- * @return
- */
-float ReadAdcVolt(unsigned char AdcChannel)
-{
-    //AIN0=CCS GUN Temp 1
-    //AIN1=CCS GUN Temp 2
-    //AIN2=CCS_Proximity/2
-    //AIN3=pilot voltage
-#if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
-	return 0;
-#else
-	if(AdcChannel == 3)
-	{
-		int fd,count,AvgTimes;
-		unsigned char SampleBuf[4];
-		float TmpVolt, MinSample, AvgSample = 0;
-
-		fd = open("/sys/bus/iio/devices/iio\\:device0/in_voltage3_raw", O_RDONLY);
-        if(fd > 0)
-        {
-            //system("echo 1 > /sys/class/gpio/gpio89/value");    //for test
-            for(AvgTimes = 0; AvgTimes < 3; AvgTimes++) //period = 60~91 ms(renice -10, , CurrentDemand()) /*+++ 20200909, vern, extend detection time for interference ---*/
-            {
-                count = 0;
-                MinSample = 2306;
-                //system("echo 1 > /sys/class/gpio/gpio89/value");    //for test
-                while(count < 40)  //period = 21~42ms (renice -10, CurrentDemand()) /*+++ 20200909, vern, extend detection time for interference ---*/
-                {
-                    //re-sampling period = 3~13ms (renice -10, SLAC())
-                    //system("echo 1 > /sys/class/gpio/gpio89/value");    //for test
-                    read(fd, SampleBuf, 4); //period = 3.2~10ms (renice -10, SLAC())
-                    //system("echo 0 > /sys/class/gpio/gpio89/value");    //for test
-                    TmpVolt = atoi((char*)SampleBuf);
-
-                    if((TmpVolt < 2306) && (TmpVolt > 0))//positive voltage
-                    {
-                        if(TmpVolt < MinSample)
-                        {
-                            MinSample = TmpVolt;
-                        }
-                        count++;
-                    }
-                    lseek(fd, 0, SEEK_SET);
-                }
-                //system("echo 0 > /sys/class/gpio/gpio89/value");    //for test
-                AvgSample += MinSample;
-            }
-            AvgSample /= AvgTimes;
-            close(fd);
-            //system("echo 0 > /sys/class/gpio/gpio89/value");    //for test
-            return ((0.954-(1.8*AvgSample/4095))/0.06);
-        }
-		else
-		{
-			return -1;
-		}
-	}
-	else
-	{
-		FILE *fp;
-		unsigned char str[64];
-		unsigned char AdcValue[8];
-
-		if(AdcChannel > 7)
-		{
-		    return -1;
-		}
-
-		memset(str,0,sizeof(str));
-		memset(AdcValue,0,sizeof(AdcValue));
-		sprintf((char*)str, "cat /sys/bus/iio/devices/iio\\:device0/in_voltage%d_raw", AdcChannel);
-		fp=popen((char*)str, "r");
-		if(fgets((char*)AdcValue,sizeof(AdcValue),fp) == NULL)
-		{
-		    pclose(fp);
-		    return -1;
-		}
-		pclose(fp);
-		//Vin =  Vref *D / (2^n - 1)
-		return ((float)1.8*(float)atoi((char*)AdcValue))/4095;
-	}
-#endif
-
-}
-
-/**
- *
- * @return
- */
-float ReadAdcVolt_PP_fork3()
-{
-#if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
-	return 0;
-#else
-    int fd, AvgTimes;
-    unsigned char SampleBuf[4];
-    float TmpVolt = 0;
-    float AvgSample = 0;
-    float V_pp = 0;
-
-    fd = open("/sys/bus/iio/devices/iio\\:device0/in_voltage2_raw", O_RDONLY); //PP
-    if(fd > 0)
-    {
-        for(AvgTimes = 0; AvgTimes < 5; AvgTimes++) //get 5 samples
-        {
-            read(fd, SampleBuf, 4);
-            TmpVolt = atoi((char*)SampleBuf);
-            lseek(fd, 0, SEEK_SET);
-
-            AvgSample += TmpVolt;
-        }
-        close(fd);
-        AvgSample /= AvgTimes;
-        V_pp = (3.6*AvgSample)/4095;    //PP
-
-        usleep(20000);  //20ms
-
-        return V_pp;
-    }
-    else
-    {
-        return -1;
-    }
-#endif
-}
-
-/**
- *
- */
-void Qca7kPowerReset()
-{
-	DEBUG_INFO("QCA7000 reset...\n");
-	system("ifconfig eth1 down");
-	usleep(500000);
-    system("echo 0 > /sys/class/gpio/gpio115/value");
-    usleep(500000);
-    system("echo 1 > /sys/class/gpio/gpio115/value");
-    usleep(500000);
-    system("ifconfig eth1 up");
-    usleep(500000);
-}
-
-/**
- *
- * @param OnOff
- * @return
- */
-int SwitchCpStateE(unsigned char OnOff)
-{
-	/*
-	 *	TODO: Request CP change to state E
-	 */
-    if((OnOff != ENABLE) && (OnOff != DISABLE))
-    {
-        return -1;
-    }
-
-    struct ChargingInfoData *ccs;
-    ccs = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    ccs->SwitchCpStateE_status = OnOff;
-
-    //OnOff = 1 => switch State to E
-    //OnOff = 0 => return noraml
-    #if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
-    {
-        if(OnOff == DISABLE)
-        {
-            //DEBUG_INFO("SwitchCpStateE: released\n");
-            CSUCOMMAC_SHM.CpSetStateE = DISABLE;
-        }
-        else
-        {
-            OutputCpPwmDuty(100); //set CP duty as 100, firstly.
-            CSUCOMMAC_SHM.CpSetStateE = ENABLE;
-            //DEBUG_INFO("SwitchCpStateE: enabled!\n");
-        }
-    }
-    #else //CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED
-    {
-        if(OnOff == DISABLE)
-        {
-            //DEBUG_INFO("SwitchCpStateE: released\n");
-            system("echo 0 > /sys/class/gpio/gpio86/value");
-        }
-        else
-        {
-            OutputCpPwmDuty(100); //set CP duty as 100, firstly.
-            system("echo 1 > /sys/class/gpio/gpio86/value");
-            //DEBUG_INFO("SwitchCpStateE: enabled!\n");
-        }
-    }
-    #endif
-
-    if (ccs->SwitchCpStateE_status_pre != ccs->SwitchCpStateE_status)
-    {
-        DEBUG_INFO("SwitchCpStateE: %d >> %d\n",
-								ccs->SwitchCpStateE_status_pre,
-								ccs->SwitchCpStateE_status);
-        ccs->SwitchCpStateE_status_pre = ccs->SwitchCpStateE_status;
-    }
-
-    return 0;
-}
-
-/**
- *
- * @param Duty
- * @return
- */
-int OutputCpPwmDuty(unsigned char Duty)
-{
-#if ((CCS_ENERGY_TRANSFER_MODE != MODE_AC_SINGLE_PHASE_CORE) && (CCS_ENERGY_TRANSFER_MODE != MODE_AC_THREE_PHASE_CORE))
-	char cmdBuf[1024];
-    int DutyInNanoSec;
-#endif
-    struct ChargingInfoData *ccs;
-    ccs = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    if((Duty < 0)||(Duty > 100))
-    {
-        return -1;
-    }
-
-#if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
-    {
-        CSUCOMMAC_SHM.CpSetPWMDuty = Duty;
-    }
-#else //CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED
-    {
-        DutyInNanoSec = 10000 * Duty;
-        sprintf((char*)cmdBuf, "echo %d > /sys/class/pwm/pwmchip0/pwm0/duty_cycle", DutyInNanoSec);//nanoseconds
-        system((char*)cmdBuf);
-    }
-#endif
-
-    ccs->CpDuty = Duty;
-
-    //CP Duty
-    if (ccs->CpDuty != ccs->CpDuty_pre)
-    {
-        DEBUG_INFO("CP Duty: %d%% >> %d%%\n", ccs->CpDuty_pre, ccs->CpDuty);
-
-        ccs->CpDuty_pre = ccs->CpDuty;
-    }
-
-    return 0;
-}
-
-/**
- *
- * @param ccs
- */
-//#if DEBUG_INFO_SWITCH == ENABLE
-void Check_Plugin_Status_Update(struct ChargingInfoData *ccs)
-{
-    if (ccs->ConnectorPlugIn != ccs->ConnectorPlugIn_new)
-    {
-        DEBUG_INFO("[fork1]Plugin: %d >> %d (CP=%.2fV, PP=%.2fV)\n",
-								ccs->ConnectorPlugIn,
-								ccs->ConnectorPlugIn_new,
-								ccs->CpVoltage,
-								ccs->PpVoltage);
-
-        ccs->ConnectorPlugIn_pre = ccs->ConnectorPlugIn;
-        ccs->ConnectorPlugIn = ccs->ConnectorPlugIn_new;
-        //ccs->CpVoltage_pre = ccs->CpVoltage;
-    }
-}
-//#endif
-
-/**
- *
- * @return
- */
-int CheckConnectorPlugIn()
-{
-	/*
-	 *	TODO: Return connector status depedon CP
-	 */
-
-    static struct ChargingInfoData *ccs;
-    ccs = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-#if (CP_PROTECTION_MECHANISM == ENABLE)
-    return (int)ccs->ConnectorPlugIn;
-#else
-    return TRUE;
-#endif
-}
-
-/**
- *
- * @param ccs
- * @return
- */
-int Check_CP_State_Error(struct ChargingInfoData *ccs)
-{
-#if (CP_PROTECTION_MECHANISM == DISABLE)
-    {
-        return -1;
-    }
-#endif
-
-    unsigned char state = 0;
-#if ((CCS_ENERGY_TRANSFER_MODE != MODE_AC_SINGLE_PHASE_CORE) && (CCS_ENERGY_TRANSFER_MODE != MODE_AC_THREE_PHASE_CORE))
-    double time_diff = 0;
-#endif
-    state = Get_V2G_Status();
-
-    //SLAC, SLAAC, SDP, ..., ChargeParameterDiscovery
-    if (state >= CM_SLAC_PARM_CONF &&   //by considering 15118(SLAC first)
-        state < ChargeParameterDiscoveryRequest &&
-        state != IDLE &&
-        state != CM_SET_KEY_REQ &&
-        state != CM_SET_KEY_CNF &&
-        state != CM_VALIDATE_REQ &&
-        state != CM_VALIDATE_CNF)
-    {
-        #if (SLAC_FIRST_RESPONSE_METHOD == SET_5_PWM_ONCE_GET_PERMISSION_IN_AUTHORIZATIONRES)
-        {
-#ifdef TEST_WITH_ETH0
-        	if((ShmCcsData->EnergyTransferMode == MODE_DC_EXTENDED) && ((ccs->CpState != CCS_CP_STATE_B1) && (ccs->CpState != CCS_CP_STATE_B2)))
-#else
-            if((ccs->CpState != CCS_CP_STATE_B1) && (ccs->CpState != CCS_CP_STATE_B2))
-#endif
-            {
-                if (ccs->CpState_err == FALSE)
-                {
-                    DEBUG_ERROR("[fork1][CP]before CPD\n");    //CPD: ChargeParameterDiscoveryRequest
-                    //CPD: ChargeParameterDiscovery
-                }
-                ccs->CpState_err = TRUE;
-            }
-        }
-        #else
-        {
-            if(ccs->CpState != CCS_CP_STATE_B2)
-            {
-                if (ccs->CpState_err == FALSE)
-                {
-                	DEBUG_ERROR("[fork1][CP]]before CPD\n");    //CPD: ChargeParameterDiscoveryRequest
-                    //CPD: ChargeParameterDiscovery
-                }
-                ccs->CpState_err = TRUE;
-            }
-        }
-        #endif
-    }
-
-    #if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
-    {
-        //ChargeParameterDiscovery
-        if(state >= ChargeParameterDiscoveryRequest &&        //35
-           state <= ChargeParameterDiscoveryResponse)         //36
-        {
-#ifdef TEST_WITH_ETH0
-        	if((ccs->CpState != CCS_CP_STATE_B2) && ((ShmCcsData->EnergyTransferMode != MODE_DC_EXTENDED) && (ccs->CpState != CCS_CP_STATE_C)))
-#else
-            if(ccs->CpState != CCS_CP_STATE_B2)
-#endif
-            {
-                if (ccs->CpState_err == FALSE)
-                {
-                	DEBUG_ERROR("[fork1][CP]]CPD\n");
-                    //PRC: Precharge
-                    //CUD: CurrentDemand
-                }
-                ccs->CpState_err = TRUE;
-            }
-        }
-
-        //ChargingStatus
-        if(state >= ChargingStatusRequest &&        //43
-           state <= ChargingStatusResponse)         //44
-        {
-            if((ccs->CpState != CCS_CP_STATE_B2) && (ccs->CpState != CCS_CP_STATE_C) && (ccs->CpState != CCS_CP_STATE_D))
-            {
-                if (ccs->CpState_err == FALSE)
-                {
-                	DEBUG_ERROR("[fork1][CP]CGS\n");
-                    //PRC: Precharge
-                    //CUD: CurrentDemand
-                }
-                ccs->CpState_err = TRUE;
-            }
-        }
-    }
-    #else //CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED
-    {
-        //ChargeParameterDiscovery, CableCheck
-        if (state >= ChargeParameterDiscoveryRequest &&     //35
-            state <= CableCheckResponse)                    //38
-        {
-            if(ccs->CableCheckPreCountDownDone == FALSE &&
-            state >= CableCheckRequest)
-            {
-                ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
-                time_diff = DiffTimeb_fork1_Error_Monitor(EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_Start, EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
-                if(time_diff >= V2G_SECC_CP_Timeout_CableCheck)   //2 sec
-                {
-                    DEBUG_INFO("[fork1][CP]check C(4),D(5): ON (%.02lf of %dms)\n", time_diff, V2G_SECC_CP_Timeout_CableCheck);
-                    ccs->CableCheckPreCountDownDone = TRUE;
-                }
-            }
-
-            if(ccs->CableCheckPreCountDownDone == TRUE)
-            {
-                if(ccs->CpState != CCS_CP_STATE_C && ccs->CpState != CCS_CP_STATE_D)
-                {
-                    if (ccs->CpState_err == FALSE)
-                    {
-                    	DEBUG_ERROR("[fork1][CP]]CPD and CCK (after CNT)\n");
-                        //CPD: ChargeParameterDiscovery
-                        //CCK: CableCheck
-                        //CNT: count down
-                    }
-                    ccs->CpState_err = TRUE;
-                }
-            }
-            else
-            {
-                if((ccs->CpState != CCS_CP_STATE_B2) && (ccs->CpState != CCS_CP_STATE_C) && (ccs->CpState != CCS_CP_STATE_D))
-                {
-                    if (ccs->CpState_err == FALSE)
-                    {
-                    	DEBUG_ERROR("[fork1][CP]CPD and CCK (before CNT)\n");
-                        //CPD: ChargeParameterDiscovery
-                        //CCK: CableCheck
-                        //CNT: count down
-                    }
-                    ccs->CpState_err = TRUE;
-                }
-            }
-        }
-
-        //Precharge, CurrentDemand
-        if(state >= PreChargeRequest &&      //39
-        state <= CurrentDemandResponse)   //46
-        {
-            if((ccs->CpState != CCS_CP_STATE_C) && (ccs->CpState != CCS_CP_STATE_D))
-            {
-                if (ccs->CpState_err == FALSE)
-                {
-                	DEBUG_ERROR("[fork1][CP]PRC and CUD\n");
-                    //PRC: Precharge
-                    //CUD: CurrentDemand
-                }
-                ccs->CpState_err = TRUE;
-            }
-        }
-    }
-    #endif
-
-    if(ccs->CpState_err == TRUE && ccs->CpState_err_logged == FALSE)
-    {
-        OutputCpPwmDuty(100);
-        //system("echo 1 > /sys/class/gpio/gpio89/value");    //for test
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_CP_State_Error (023889)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-
-        Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
-        DEBUG_ERROR("[fork1]CP(%d) Error in state %d(%d)\n", ccs->CpState, state, ccs->CableCheckPreCountDownDone);
-        ccs->CpState_err_logged = TRUE;
-    }
-    return 0;
-}
-
-/**
- *
- * @param ccs
- */
-void Check_CP_State_Update(struct ChargingInfoData *ccs)
-{
-    //CP State
-    if (ccs->CpState != ccs->CpState_pre)
-    {
-        DEBUG_INFO("[fork1]CP State: %d >> %d (%.2fV)\n",
-								ccs->CpState_pre,
-								ccs->CpState,
-								ccs->CpVoltage);
-
-        ccs->CpState_pre = ccs->CpState;
-    }
-}
-
-/**
- *
- */
-void CP_Detection()
-{
-    pid_t tmp = 0;
-#if ((CCS_ENERGY_TRANSFER_MODE != MODE_AC_SINGLE_PHASE_CORE) && (CCS_ENERGY_TRANSFER_MODE != MODE_AC_THREE_PHASE_CORE))
-    unsigned char Statetmp;
-    float TotalTmpVolt;
-#endif
-    struct ChargingInfoData *ccs;
-
-    ccs = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    if(pid.CP_Detection == 0)
-    {
-        tmp = fork();
-        if(tmp > 0)
-        {
-        	pid.CP_Detection = tmp;
-
-            #if 1
-            unsigned char buf[64];
-            memset(buf, 0, sizeof(buf));
-            //sprintf((char*)buf, "renice -20 -p %d", tmp);
-            sprintf((char*)buf, "renice -10 -p %d", tmp);
-            system((char*)buf);
-            #endif
-
-            return;
-        }
-    }
-
-    while(1)
-    {
-        //ADC_Voltage = (1+RE62/RE63)*0.9 - (RE62/RE63)*Pilot_Voltage,  RE62/RE63=0.06
-        //=>Pilot_Voltage=(0.954-ADC_Voltage)/0.06
-
-        #if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
-        {
-            ccs->CpVoltage = ShmInternalComm->AC_CpPositiveVoltage;
-            ccs->CpState = ShmInternalComm->AC_CpPresentState;
-        }
-        #else //CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED
-        {
-            TotalTmpVolt = ReadAdcVolt(3);
-
-            ccs->CpVoltage = TotalTmpVolt;
-
-            if (ccs->CpVoltage_pre != ccs->CpVoltage)
-            {
-                ccs->CpVoltage_pre = ccs->CpVoltage;
-            }
-
-            //printf("TotalTmpVolt = %.02f\n", TotalTmpVolt);
-
-            //If CP voltage is higer than 13.5V
-            if(TotalTmpVolt >= 13.5)
-            {
-                //Pilot Error
-                if((ccs->CpState == CCS_CP_STATE_A) &&
-                (TotalTmpVolt < 13.75))
-                {
-                    //V_cp = 13.5 ~ 13.75
-                    Statetmp = 1;
-                }
-                else
-                {
-                    //V_cp = 13.5 ~
-                    Statetmp = 8;
-                }
-            }
-            else if((TotalTmpVolt >= 10.5) && (TotalTmpVolt < 13.5)) //V_cp = 10.5 ~ 13.5
-            {
-                //State A (12V)
-                if((ccs->CpState >= CCS_CP_STATE_B1) &&
-                (ccs->CpState <= CCS_CP_STATE_B2) &&
-                (TotalTmpVolt < 10.75))
-                {
-                    if((ccs->CpDuty >= 5) &&
-                    (ccs->CpDuty < 100))
-                    {
-                        Statetmp = 3;
-                    }
-                    else
-                    {
-                        Statetmp = 2;
-                    }
-                }
-                else if((ccs->CpState == CCS_CP_STATE_G) &&
-                        (TotalTmpVolt >= 13.25))
-                {
-                    Statetmp = 8;
-                }
-                else
-                {
-                    Statetmp = 1;
-                }
-            }
-            else if((TotalTmpVolt >= 7.5) && (TotalTmpVolt < 10.5))
-            {
-                //State B (9V)
-                if((ccs->CpState == CCS_CP_STATE_C) && (TotalTmpVolt < 7.75))
-                {
-                    Statetmp = 4;
-                }
-                else if((ccs->CpState == CCS_CP_STATE_A) && (TotalTmpVolt >= 10.25))
-                {
-                    Statetmp = 1;
-                }
-                else
-                {
-                    if((ccs->CpDuty >= 5) && (ccs->CpDuty < 100))
-                    {
-                        Statetmp = 3;
-                    }
-                    else
-                    {
-                        Statetmp = 2;
-                    }
-                }
-            }
-            else if((TotalTmpVolt >= 4.5) && (TotalTmpVolt < 7.5))
-            {
-                //State C (6V)
-                if((ccs->CpState == CCS_CP_STATE_D) && (TotalTmpVolt < 4.75))
-                {
-                    Statetmp = 5;
-                }
-                else if((ccs->CpState >= CCS_CP_STATE_B1) && (ccs->CpState <= CCS_CP_STATE_B2) && (TotalTmpVolt >= 7.25))
-                {
-                    if((ccs->CpDuty >= 5)&&(ccs->CpDuty < 100))
-                    {
-                        Statetmp = 3;
-                    }
-                    else
-                    {
-                        Statetmp = 2;
-                    }
-                }
-                else
-                {
-                    Statetmp = 4;
-                }
-            }
-            else if((TotalTmpVolt >= 1.5) && (TotalTmpVolt < 4.5))
-            {
-                //State D (3V)
-                if((ccs->CpState == CCS_CP_STATE_E)&&(TotalTmpVolt < 1.75))
-                {
-                    Statetmp = 6;
-                }
-                else if((ccs->CpState == CCS_CP_STATE_C)&&(TotalTmpVolt >= 4.25))
-                {
-                    Statetmp = 4;
-                }
-                else
-                {
-                    Statetmp = 5;
-                }
-            }
-            else if((TotalTmpVolt >= -1.5) && (TotalTmpVolt < 1.5)) //V_cp = -1.5V ~ 1.5V
-            {
-                //State E (0V)
-                if((ccs->CpState == CCS_CP_STATE_G) &&
-                (TotalTmpVolt < -1.25))
-                {
-                    Statetmp = 8;
-                }
-                else if((ccs->CpState == CCS_CP_STATE_D) &&
-                        (TotalTmpVolt >= 1.25))
-                {
-                    Statetmp = 5;
-                }
-                else
-                {
-                    Statetmp = 6;
-                }
-            }
-            else if((TotalTmpVolt >= -13.5) && (TotalTmpVolt < -10.5)) //V_cp = -10.5V ~ -13.5V
-            {
-                //State F (-12V)
-                if((ccs->CpState == CCS_CP_STATE_G) &&
-                (TotalTmpVolt >= -10.75))
-                {
-                    Statetmp = 8;
-                }
-                else
-                {
-                    Statetmp = 7;
-                }
-            }
-            else
-            {
-                //null
-            }
-
-            ccs->CpState = Statetmp;
-        }
-        #endif
-
-        Check_CP_State_Update(ccs);
-        Check_CP_State_Error(ccs);
-
-        //Updating Plugin status
-	#if (PP_PROTECTION_MECHANISM == ENABLE)
-        if((ccs->CpState >= CCS_CP_STATE_B1 ) && (ccs->CpState <= CCS_CP_STATE_D ) && (ccs->PpVoltage >= 1.0)) //PP >= 1.0V
-	#else
-        if((ccs->CpState >= CCS_CP_STATE_B1 ) && (ccs->CpState <= CCS_CP_STATE_D ))
-	#endif
-        {
-            ccs->ConnectorPlugIn_new = TRUE;
-        }
-        else
-        {
-            ccs->ConnectorPlugIn_new = FALSE;
-            OutputCpPwmDuty(100);
-        }
-
-        Check_Plugin_Status_Update(ccs);
-
-        usleep(1000);
-    }//while
-}
-
-/**
- *  1. In order to detect CP in efficient response time, we create an independent
- *     thread for this procedure.
-    2. The priority of this thread is set as the same as other tasks.
- */
-void PP_Detection()
-{
-    pid_t tmp = 0;
- //   struct timeb StartTime, EndTime;
-#if ((CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED))
-    //unsigned char Statetmp;
-#endif
-    float TotalTmpVolt;
-
-    if(pid.PP_Detection == 0)
-    {
-        tmp = fork();
-        if(tmp > 0)
-        {
-            pid.PP_Detection = tmp;
-
-            #if 0
-            unsigned char buf[64];
-            memset(buf, 0, sizeof(buf));
-            sprintf((char*)buf, "renice -20 -p %d", tmp);
-            system(buf);
-            #endif
-
-            return;
-        }
-    }
-
-    while(1)
-    {
-        TotalTmpVolt = ReadAdcVolt_PP_fork3();
-
-        EVCOMM_SYS_INFO.PpVoltage = TotalTmpVolt;
-
-        if (EVCOMM_SYS_INFO.PpVoltage_pre != EVCOMM_SYS_INFO.PpVoltage)
-        {
-            if ((EVCOMM_SYS_INFO.PpVoltage_pre < 0.5 && EVCOMM_SYS_INFO.PpVoltage >= 1.0) ||
-                 (EVCOMM_SYS_INFO.PpVoltage_pre >= 1.0 && EVCOMM_SYS_INFO.PpVoltage < 0.5))
-            {
-                DEBUG_INFO("[fork3]PP(%.2f >> %.2fV)\n", EVCOMM_SYS_INFO.PpVoltage_pre, EVCOMM_SYS_INFO.PpVoltage);
-                EVCOMM_SYS_INFO.PpVoltage_pre = EVCOMM_SYS_INFO.PpVoltage;
-            }
-        }
-
-        usleep(1000);
-    }//while
-}
-
-/**
- *
- */
-void Error_Monitor()
-{
-    pid_t tmp = 0;
-    double time_diff = 0;
-    unsigned char status = 0;
-    struct ChargingInfoData *ccs;
-    ccs = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    if(pid.Error_Monitor == 0)
-    {
-        tmp = fork();   //SeccComm fork2
-        if(tmp > 0)
-        {
-        	pid.Error_Monitor = tmp;
-
-            #if 0
-            unsigned char buf[64];
-            memset(buf, 0, sizeof(buf));
-            sprintf((char*)buf, "renice -20 -p %d", tmp);
-            system(buf);
-            #endif
-
-            return;
-        }
-    }
-
-    for(;;)
-    {
-        //Step 0
-        if (EVCOMM_SYS_INFO.End_Process_inused == TRUE)
-        {
-            //If the End_Process is in processing, disable Error_Monitor.
-            continue;
-        }
-
-        //Step1 1: Check and Response to Plugin Status
-        if(CheckConnectorPlugIn() == FALSE)
-        {
-            status = Get_V2G_Status();
-            if (status > IDLE &&
-                status < Performance_Timeout &&
-                status != CM_SET_KEY_REQ &&
-                status != CM_SET_KEY_CNF &&
-                EVCOMM_SYS_INFO.End_Process_inused == FALSE)
-            {
-			#if (CP_PROTECTION_MECHANISM == ENABLE)
-                //DEBUG_INFO("[fork2] Emergency Stop (due to Connector is plugged out during communication.)\n");
-                DEBUG_ERROR("[fork2]Plug out Error => End_Process\n");
-                //Update_ShmStatusCode(); //[To-Do] to be implemented
-                //CCS_SECC_CP_State_Error (023889)
-                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                ShmStatusCodeData->PresentStatusCode[0][4] = 8;
-                ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-                End_Process();
-			#else
-                //DEBUG_INFO("CP_PROTECTION_MECHANISM is disabled. Emergency Stop: skipped\n");
-			#endif
-            }
-        }
-
-
-        //Step 2: Check for V2G_SECC_Sequence_Timeout
-        //#if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-        status = Get_V2G_Status();
-        if (status >= SupportedAppProtocolRequest &&
-            status < SessionStopRequest)
-        {
-            ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_End);
-            time_diff = DiffTimeb_fork2_Error_Monitor(EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start, EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_End);
-            if(time_diff > V2G_SECC_Sequence_Timeout)   //60s
-            {
-            	DEBUG_ERROR("[fork2]V2G_SECC_Sequence_Timeout in state %d - (%.02lf of %d ms)\n", status, time_diff, V2G_SECC_Sequence_Timeout);
-                Update_V2G_Status(Sequence_Timeout);
-                //Update_ShmStatusCode(); //[To-Do] to be implemented
-                //CCS_SECC_TIMEOUT_V2G_Sequence_Time (023844)
-                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                ShmStatusCodeData->PresentStatusCode[0][4] = 4;
-                ShmStatusCodeData->PresentStatusCode[0][5] = 4;
-                End_Process();
-                break;
-            }
-            else if (time_diff > 4000) //4s
-            {
-                //Check for CSU command of "Stop by EVSE"
-                if (EVCOMM_SYS_INFO.DC_EVSEStatus == EVSE_Shutdown)
-                {
-                    DEBUG_INFO("[Error_Monitor]EVSE_Shutdown\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                else if (EVCOMM_SYS_INFO.DC_EVSEStatus == EVSE_EmergencyShutdown)
-                {
-                    DEBUG_INFO("[Error_Monitor]EVSE_EmergencyShutdown\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                else if (ShmInternalComm->ChargingPermission == FALSE)
-                {
-                    if (status >= ChargeParameterDiscoveryRequest)  //&& status < SessionStopRequest
-                    {
-                        DEBUG_INFO("[Error_Monitor]ChargingPermission = FALSE\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                }
-                else
-                {
-                    //null
-                }
-            }
-            else
-            {
-                //null
-            }
-        }
-
-
-        //Step 3: Check and Response to Error V2gFlowStatus
-        status = Get_V2G_Status();
-        if (status == Performance_Timeout ||
-            status == Sequence_Timeout ||
-            status == Other_Fault)
-        {
-        	//Normal Stop
-        	DEBUG_ERROR("[fork2]Timeout or Fault State(%d) => End_Process\n", status);
-            End_Process();
-        }
-
-        //Step 4: Check and Response to CP State Error
-        if(ccs->CpState_err == TRUE)
-        {
-        	DEBUG_ERROR("[fork2]CP Error => End_Process\n");
-            Update_V2G_Status(Other_Fault);
-            //Update_ShmStatusCode(); //[To-Do] to be implemented
-            //CCS_SECC_CP_State_Error (023889)
-            ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-            ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-            ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-            ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-            ShmStatusCodeData->PresentStatusCode[0][4] = 8;
-            ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-            CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-            End_Process();
-        }
-
-
-        //Step 5: Check and Response to Shutdown Commnad from CSU
-        if (EVCOMM_SYS_INFO.DC_EVSEStatus == EVSE_Shutdown ||
-            EVCOMM_SYS_INFO.DC_EVSEStatus == EVSE_EmergencyShutdown)
-        {
-            if (Get_V2G_Status() <= SLACC_SDP_TCP_Connection)
-            {
-                DEBUG_INFO("[fork2]EVSE Shutdown(%d) => End_Process\n", EVCOMM_SYS_INFO.DC_EVSEStatus);
-                Update_V2G_Status(Other_Fault);
-                End_Process();
-            }
-        }
-
-        //Step 6: Check and Response to SessionStop
-        status = Get_V2G_Status();
-        if (status == SessionStopResponse)
-        {
-            DEBUG_INFO("[fork2]SessionStopResponse => End_Process\n");
-            End_Process();
-        }
-
-        //Step 7: Check for ChargingPermission from TRUE to FALSE before V2G Messages
-        /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth),  1 for star charging (authorized)  ---*/
-        if ((ShmInternalComm->ChargingPermission == FALSE) &&
-            (ShmInternalComm->ChargingPermission_pre >= 1) &&
-            (ccs->CpState >= CCS_CP_STATE_B2) && (ccs->CpState <= CCS_CP_STATE_D))
-        {
-            if (status >= CM_SLAC_PARM_REQ &&
-                status != CM_SET_KEY_REQ &&
-                status != CM_SET_KEY_CNF &&
-                status <= SLACC_SDP_TCP_Connection)
-            {
-                DEBUG_INFO("[fork2]Permission OFF before V2G msg(%d) => End_Process\n", ShmInternalComm->ChargingPermission);
-                Update_V2G_Status(Other_Fault);
-                End_Process();
-            }
-        }
-
-        //Step 8: DC OVP Protection
-        if (CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED &&
-            status > CableCheckResponse &&
-            status <= SessionStopRequest &&
-            status != ChargingStatusRequest &&
-            status != ChargingStatusResponse &&
-            EVCOMM_SYS_INFO.EvBatteryMaxVoltage != 0)
-        {
-            //Part A: OVP Protection
-            if (EVCOMM_SYS_INFO.PresentChargingVoltage >= (EVCOMM_SYS_INFO.EvBatteryMaxVoltage * 1.02)) // 2%
-            {
-            	DEBUG_ERROR("[fork2]OVP => End_Process (%.02f > %.02f)\n",
-										EVCOMM_SYS_INFO.PresentChargingVoltage,
-										(EVCOMM_SYS_INFO.EvBatteryMaxVoltage * 1.02));
-
-                Update_V2G_Status(Other_Fault);
-                //Update_ShmStatusCode(); //[To-Do] to be implemented
-                //System CCS output OVP (012219)
-                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                ShmStatusCodeData->PresentStatusCode[0][1] = 1;
-                ShmStatusCodeData->PresentStatusCode[0][2] = 2;
-                ShmStatusCodeData->PresentStatusCode[0][3] = 2;
-                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
-                ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-                Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
-                End_Process();
-            }
-
-            //Part B: Over Voltage Request Protection
-            if (EVCOMM_SYS_INFO.EvBatterytargetVoltage >= (EVCOMM_SYS_INFO.EvBatteryMaxVoltage * 1.02))
-            {
-                DEBUG_INFO("[fork2]Over V Req => End_Process (%.02f > %.02f)\n",
-										EVCOMM_SYS_INFO.EvBatterytargetVoltage,
-										(EVCOMM_SYS_INFO.EvBatteryMaxVoltage * 1.02));
-
-                Update_V2G_Status(Other_Fault);
-                //Update_ShmStatusCode(); //[To-Do] to be implemented
-                //System CCS output OVP (012219)
-                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                ShmStatusCodeData->PresentStatusCode[0][1] = 1;
-                ShmStatusCodeData->PresentStatusCode[0][2] = 2;
-                ShmStatusCodeData->PresentStatusCode[0][3] = 2;
-                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
-                ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-                Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
-                End_Process();
-            }
-        }
-
-        //Step 9: Check 60V
-        /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
-        if (CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED &&
-            ShmInternalComm->ChargingPermission >= 1 &&
-            status < CableCheckRequest)
-        {
-            if (EVCOMM_SYS_INFO.PresentChargingVoltage >= 60)  //60V
-            {
-                DEBUG_INFO("[fork2]DC Output Voltage is over 60V => End_Process\n");
-                Update_V2G_Status(Other_Fault);
-                //Update_ShmStatusCode(); //[To-Do] to be implemented
-                //CCS_SECC_Unexpected_60V_Before_Charing_Error (023890)
-                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                ShmStatusCodeData->PresentStatusCode[0][4] = 9;
-                ShmStatusCodeData->PresentStatusCode[0][5] = 0;
-                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-                //Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
-                End_Process();
-            }
-        }
-
-        //Step 10: Check if the connector is unplug from plugin
-        if (EVCOMM_SYS_INFO.ConnectorPlugIn_pre == TRUE && EVCOMM_SYS_INFO.ConnectorPlugIn == FALSE)
-        {
-            DEBUG_INFO("[fork2]Unplug Reset => End_Process\n");
-            Update_V2G_Status(Other_Fault);
-            End_Process();
-        }
-        usleep(1000);
-    }//while
-}
-
-/**
- *
- * @return
- */
-int SendSetKey()
-{
-    unsigned char nRandValue = 0x0;
-    unsigned char ConstString[16] = "PhihongKey000000";
-
-    memset(&qcaInfo.SendMmePacket, 0, sizeof(struct MmeHeader));
-    memcpy(qcaInfo.SendMmePacket.ODA, macAddr.qca, 6);
-    memcpy(qcaInfo.SendMmePacket.OSA, macAddr.eth1, 6);
-    qcaInfo.SendMmePacket.MTYPE = htons(EtherType_HomePlug);
-    qcaInfo.SendMmePacket.MMV = 0x01;
-    qcaInfo.SendMmePacket.MMTYPE = MMTYPE_CM_SET_KEY_REQ;
-    qcaInfo.SendMmePacket.FMI[0] = qcaInfo.SendMmePacket.FMI[1] = 0;
-    qcaInfo.SendMmePacketSize = 0;
-    qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0x01;//Fixed value (0x01) to indicate ��NMK��
-    memset(qcaInfo.SendMmePacket.MMENTRY+qcaInfo.SendMmePacketSize, 0, 4);//My Nonce, Fixed value(0x00000000), encrypted payload not used
-    qcaInfo.SendMmePacketSize += 4;
-    memset(qcaInfo.SendMmePacket.MMENTRY+qcaInfo.SendMmePacketSize, 0, 4);//Your Nonce, Fixed value(0x00000000), encrypted payload not used
-    qcaInfo.SendMmePacketSize += 4;
-    qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0x04;//PID, Fixed value (0x04) to indicate ��HLE protocol��
-    memset(qcaInfo.SendMmePacket.MMENTRY+qcaInfo.SendMmePacketSize, 0, 2);//PRN, Fixed value(0x00), encrypted payload not used
-    qcaInfo.SendMmePacketSize += 2;
-    qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0x00;//PMN, Fixed value(0x00) encrypted payload not used
-    qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0x01;//CCo Capablility
-    srand(time(NULL));
-    for(int i = 10; i < 16; i++)
-    {
-        nRandValue = (rand()%62) + 1;
-        if((nRandValue>=0)&&(nRandValue<=9))  // 0 ~ 9
-        {
-            ConstString[i]= nRandValue + 0x30;
-        }
-        else if((nRandValue>=10)&&(nRandValue<=35)) // A ~ Z
-        {
-            ConstString[i]= nRandValue -10 + 0x41;
-        }
-        else if((nRandValue>=36)&&(nRandValue<=61)) // a ~ z
-        {
-            ConstString[i]= nRandValue -37 + 0x61;
-        }
-        else
-        {
-            ConstString[i]= 0x30;
-        }
-    }
-
-    memset(qcaInfo.NewNmkKey, 0, sizeof(qcaInfo.NewNmkKey));
-    memset(qcaInfo.Nid, 0, sizeof(qcaInfo.Nid));
-    HPAVKeyNMK(qcaInfo.NewNmkKey, (char*)ConstString);
-    HPAVKeyNID(qcaInfo.Nid, qcaInfo.NewNmkKey, DEFAULT_LEVEL);
-    memcpy(qcaInfo.SendMmePacket.MMENTRY+qcaInfo.SendMmePacketSize, qcaInfo.Nid, sizeof(qcaInfo.Nid));    //NID, 54 LSBs contain the NID 2 MSBs = 0b00
-    qcaInfo.SendMmePacketSize += sizeof(qcaInfo.Nid);
-    qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0x01;//NewEKS,Fixed value (0x01)to indicate ��NMK��
-    memcpy(qcaInfo.SendMmePacket.MMENTRY+qcaInfo.SendMmePacketSize, qcaInfo.NewNmkKey,sizeof(qcaInfo.NewNmkKey));//NewKey
-    qcaInfo.SendMmePacketSize += sizeof(qcaInfo.NewNmkKey);
-    qcaInfo.SendMmePacketSize += 19;  //the size before MMENTRY
-
-    DEBUG_INFO("QCA7000 [TX]CM_SET_KEY_REQ\n");
-    DEBUG_INFO("SendSetKey: send size: %d\n", sendto(socketFd.Raw, &qcaInfo.SendMmePacket, qcaInfo.SendMmePacketSize, 0, (struct sockaddr*)&qcaInfo.DestSocketAddress, sizeof(struct sockaddr_ll)));
-
-    Update_V2G_Status(CM_SET_KEY_REQ);
-
-    return 0;
-}
-
-/**
- *
- * @return
- */
-int GetQca7kMac()
-{
-    struct QcaVendorMmeHeader SendPacket;
-
-    DEBUG_INFO("Req for QCA7K MacAddr\n");
-
-    memset(&SendPacket, 0, sizeof(struct QcaVendorMmeHeader));
-    memset(SendPacket.ODA, 0xFF, 6);    //broadcast
-    memcpy(SendPacket.OSA, macAddr.eth1, 6);
-    SendPacket.MTYPE = htons(EtherType_HomePlug);
-    SendPacket.MMV = 0x00;
-    SendPacket.MMTYPE = MMTYPE_VENDOR_VS_NW_INFO;
-    SendPacket.OUI[0] = 0x00;
-    SendPacket.OUI[1] = 0xB0;
-    SendPacket.OUI[2] = 0x52;
-
-    DEBUG_INFO("GetQca7kMac: send size: %d\n", sendto(socketFd.Raw, &SendPacket, 20, 0, (struct sockaddr*)&qcaInfo.DestSocketAddress, sizeof(struct sockaddr_ll)));
-
-    return 0;
-}
-
-/**
- *
- * @param ptr
- * @param size
- * @return
- */
-int Array_Check_All_Zero(unsigned char *ptr, int size)
-{
-    int result = TRUE;
-    int i = 0;
-
-    for (i = 0; i < size; i++)
-    {
-        if (ptr[i] != 0)
-        {
-            result = FALSE;
-            break;
-        }
-    }
-    return result;
-}
-
-/**
- *
- * @param ptrA
- * @param ptrB
- * @param size
- * @return
- */
-int Array_Compare_Identity(unsigned char *ptrA, unsigned char *ptrB, int size)
-{
-    int result = TRUE;
-    int i = 0;
-
-    for (i = 0; i < size; i++)
-    {
-        if (ptrA[i] != ptrB[i])
-        {
-            result = FALSE;
-
-            #if 0
-            DEBUG_INFO("[Array_Compare_Identity]%02X%02X%02X%02X%02X%02X,%02X%02X%02X%02X%02X%02X(%d)\n",
-						ptrA[0], ptrA[1], ptrA[2], ptrA[3], ptrA[4], ptrA[5],
-						ptrB[0], ptrB[1], ptrB[2], ptrB[3], ptrB[4], ptrB[5],
-						result);
-            #endif
-            break;
-        }
-    }
-    return result;
-}
-
-/**
- *
- * @param evcc
- * @param EvMac_in
- * @return
- */
-int SLAC_DB_Search_EvMac_idx(struct EVCC_SLAC_DATA_TYPE *evcc, unsigned char *EvMac_in)
-{
-    int idx = -1;
-    int i = 0;
-
-    if (evcc->arrayLen == 0)
-    {
-        //printf("[SLAC_DB_Search_EvMac_idx]arrayLen is empty (%d)\n", evcc->arrayLen);
-        //no need to search
-    }
-    else if (evcc->arrayLen > EVCC_SLAC_DATA_ARRAY_TYPE_ARRAY_SIZE)
-    {
-        //error
-        DEBUG_ERROR("DB length(%d) > %d\n", evcc->arrayLen, EVCC_SLAC_DATA_ARRAY_TYPE_ARRAY_SIZE);
-        evcc->arrayLen = 0; //reset
-    }
-    else
-    {
-        //start searching
-        for (i = 0; i < evcc->arrayLen; i++)
-        {
-            //printf("[SLAC_DB_Search_EvMac_idx]checking DB[%d]...\n", i);
-            if (Array_Compare_Identity(evcc->array[i].EvMac, EvMac_in, SLAC_EVMAC_LENGTH) == TRUE)
-            {
-                //printf("[SLAC_DB_Search_EvMac_idx]identical at DB[%d]...\n", i);
-                idx = i;
-                break;
-            }
-        }
-    }
-
-    //printf("[SLAC_DB_Search_EvMac_idx]return = %d\n", idx);
-    return idx;
-}
-
-/**
- *
- * @param evcc
- * @param EvMac_in
- * @param RunID_in
- * @return
- */
-int SLAC_DB_Check_EvMac_RunID_Matching(struct EVCC_SLAC_DATA_TYPE *evcc, unsigned char *EvMac_in, unsigned char *RunID_in)
-{
-    int res = FALSE;
-    int idx = -1;
-
-    idx = SLAC_DB_Search_EvMac_idx(evcc, EvMac_in);
-
-    if (idx >= 0)
-    {
-        res = Array_Compare_Identity(evcc->array[idx].RunID, RunID_in, SLAC_RUNID_LENGTH);
-    }
-    else
-    {
-        //not found the EvMac data in DB
-        res = FALSE;
-    }
-
-    return res;
-}
-
-/**
- *
- * @param EvMac_in
- * @param RunID_in
- * @return
- */
-int SLAC_DB_Add(unsigned char *EvMac_in, unsigned char *RunID_in)
-{
-    int idx = -1;
-
-    //Search if this EvMac and RunID already exists
-    idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
-
-    if (idx < 0)   //not exist, yet.
-    {
-        if (SLAC_INFO.arrayLen < EVCC_SLAC_DATA_ARRAY_TYPE_ARRAY_SIZE)  //20
-        {
-            DEBUG_PRINTF_EVCOMM_DETAIL("data does not exist => added to %d-th\n", SLAC_INFO.arrayLen);
-
-            if (SLAC_INFO.arrayLen >= 0)
-            {
-                memset(&SLAC_INFO.array[SLAC_INFO.arrayLen], 0, sizeof(struct EVCC_SLAC_DATA_ARRAY_TYPE));
-                memcpy(SLAC_INFO.array[SLAC_INFO.arrayLen].EvMac, EvMac_in, SLAC_EVMAC_LENGTH);
-                memcpy(SLAC_INFO.array[SLAC_INFO.arrayLen].RunID, RunID_in, SLAC_RUNID_LENGTH);
-                idx = SLAC_INFO.arrayLen;
-                SLAC_INFO.arrayLen++;
-            }
-            else
-            {
-                DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR]arrayLen: unexpected(%d)\n", SLAC_INFO.arrayLen);
-
-                SLAC_INFO.arrayLen = 0;
-            }
-        }
-        else
-        {
-            //DB is full
-            DEBUG_PRINTF_EVCOMM_DETAIL("DB is full(%d) => bypass\n", SLAC_INFO.arrayLen);
-        }
-    }
-    else
-    {
-        #if 0
-        DEBUG_INFO("EvMac: existed (%d)\n", idx);
-        #endif
-
-        //Check RunID
-        if (Array_Compare_Identity(SLAC_INFO.array[idx].RunID, RunID_in, SLAC_RUNID_LENGTH) == TRUE)
-        {
-            //RunID is the same
-            //DEBUG_INFO("RunID: same\n");
-        }
-        else
-        {
-            DEBUG_INFO("RunID: diff\n");
-        }
-
-        //Reset all corresponding parameters
-        #if 0
-        DEBUG_INFO("EvMac: reset para(%d)\n", idx);
-        #endif
-
-        memset(&SLAC_INFO.array[idx], 0, sizeof(struct EVCC_SLAC_DATA_ARRAY_TYPE));
-        memcpy(SLAC_INFO.array[idx].EvMac, EvMac_in, SLAC_EVMAC_LENGTH);
-        memcpy(SLAC_INFO.array[idx].RunID, RunID_in, SLAC_RUNID_LENGTH);
-    }
-    return idx;
-}
-
-/**
- *
- * @return
- */
-int SLAC_DB_Reset()
-{
-    memset(&SLAC_INFO, 0, sizeof(struct EVCC_SLAC_DATA_TYPE));
-    DEBUG_INFO("DONE\n");
-
-    return 0;
-}
-
-/**
- *
- * @param Buffer
- * @param DataLength
- * @return
- */
-int MmeProcess(unsigned char *Buffer, int DataLength)
-{
-    //struct ethhdr	*EthPacket;
-    struct MmeHeader *MmePacket;
-    static unsigned char counter;
-    unsigned char state = 0;
-    unsigned char tmpBuf[2048]={0};
-    int Rtn = 0;
-    int idx = 0;
-    unsigned char *EvMac_in;
-    unsigned char *RunID_in;
-
-    MmePacket = (struct MmeHeader *)Buffer;
-    state = Get_V2G_Status();
-
-	DEBUG_PRINTF_EVCOMM_DETAIL("***********************************\n");
-	DEBUG_PRINTF_EVCOMM_DETAIL("******* Received MME Packet *******\n");
-	DEBUG_PRINTF_EVCOMM_DETAIL("***********************************\n");
-	DEBUG_PRINTF_EVCOMM_DETAIL("DataLength=%d\n",DataLength);
-	DEBUG_PRINTF_EVCOMM_DETAIL("ODA: %02x:%02x:%02x:%02x:%02x:%02x\n", //Destination MAC Address
-								MmePacket->ODA[0], MmePacket->ODA[1],
-								MmePacket->ODA[2], MmePacket->ODA[3],
-								MmePacket->ODA[4], MmePacket->ODA[5]);
-	DEBUG_PRINTF_EVCOMM_DETAIL("OSA: %02x:%02x:%02x:%02x:%02x:%02x\n", //Source MAC Address (EV MAC)
-								MmePacket->OSA[0], MmePacket->OSA[1],
-								MmePacket->OSA[2], MmePacket->OSA[3],
-								MmePacket->OSA[4], MmePacket->OSA[5]);
-	DEBUG_PRINTF_EVCOMM_DETAIL("MTYPE: 0x%x\n", htons(MmePacket->MTYPE));
-	DEBUG_PRINTF_EVCOMM_DETAIL("MMV: 0x%x\n", MmePacket->MMV);
-	DEBUG_PRINTF_EVCOMM_DETAIL("MMTYPE: 0x%x\n", MmePacket->MMTYPE);
-	DEBUG_PRINTF_EVCOMM_DETAIL("FMI 0x%x, 0x%x\n", MmePacket->FMI[0],MmePacket->FMI[1]);
-
-
-    #if (SLAC_FIRST_RESPONSE_METHOD == SET_NO_PWM_IF_NOT_GET_PERMISSION)
-    {
-        //Check CP as 5%
-        if (EVCOMM_SYS_INFO.CpState != 3 &&
-            EVCOMM_SYS_INFO.CpState != 4 &&
-            MmePacket->MMTYPE != MMTYPE_CM_SET_KEY_CNF &&
-            MmePacket->MMTYPE != MMTYPE_VENDOR_VS_HOST_ACTION &&
-            MmePacket->MMTYPE != MMTYPE_VENDOR_ATTEN_CHAR &&
-            MmePacket->MMTYPE != MMTYPE_VENDOR_VS_NW_INFO_CNF
-           )
-        {
-            //DEBUG_INFO("[SLAC]ignored(wrong CP state)\n");
-            return 0;
-        }
-    }
-    #endif
-
-    //[To-Do] Adding a pre-check filter mechanism for Source and Destination MAC Address
-
-    //check if the destination address is broadcast or EVSE itself, it can be ignore if not belong to itself.
-    switch(MmePacket->MMTYPE)
-    {
-	    case MMTYPE_CM_SET_KEY_CNF:
-		{
-	        DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_SET_KEY_CNF ---\n");
-	        DEBUG_PRINTF_EVCOMM_DETAIL("Result: 0x%02x\n", MmePacket->MMENTRY[0]);
-
-            DEBUG_INFO("CM_SET_KEY_CNF (SetKey: DONE)\n");
-            Update_V2G_Status(CM_SET_KEY_CNF);
-	        break;
-		}
-
-	    case MMTYPE_CM_SLAC_PARM_REQ:
-		{
-            //Check QCA7000 status
-            if (EVCOMM_SYS_INFO.QCA7K_SetKeyDone == FALSE)
-            {
-                //DEBUG_WARN("[SLAC][RX]CM_SLAC_PARM_REQ: ignored(QCA7K init...)\n");
-                break;
-            }
-
-            //Check error state
-            state = Get_V2G_Status();
-            if (state == Performance_Timeout ||     //253
-                state == Sequence_Timeout ||        //254
-                state == Other_Fault)               //255
-            {
-                DEBUG_WARN("CM_SLAC_PARM_REQ: ignored(in error state)\n");
-				break;
-            }
-
-            //Printing EV MAC Address
-            DEBUG_INFO("CM_SLAC_PARM_REQ\n");
-
-            //Avoid Coupled SLAC_PARM_REQ
-            if (CheckConnectorPlugIn() == FALSE)  //12V(State 1)
-            {
-                #if 0
-                DEBUG_WARN("[SLAC][RX]CM_SLAC_PARM_REQ: ignored(coupled SLAC,%d)\n", CheckConnectorPlugIn());
-                #endif
-                break;
-            }
-
-            //[TC_SECC_VTB_CmSlacParm_003] SECURITY_TYPE needs to be 0x00 (no security)
-            if (MmePacket->MMENTRY[1] != 0)
-            {
-                DEBUG_INFO("CM_SLAC_PARM_REQ: ignored(invalid SECURITY_TYPE,%d)\n", //Source MAC Address (EV MAC)
-                						MmePacket->MMENTRY[1]);
-                break;
-            }
-
-            //=================== Legal CM_SLAC_PARM_REQ Zone =================
-
-            Update_V2G_Status(CM_SLAC_PARM_REQ);
-
-            #if (SLAC_FIRST_RESPONSE_METHOD == SET_5_PWM_ONCE_RX_CM_SLAC_PARM_REQ)
-            {
-                //Once receiving CM_SLAC_PARM_REQ, set PWM as 5%
-                SwitchCpStateE(DISABLE);
-                OutputCpPwmDuty(5);
-            }
-            #endif
-
-            //Checking if this SLAC Req comes before 5% PWM (for 15118)
-            if(ShmInternalComm->ChargingPermission == FALSE)
-            {
-                //Sniffer_Tcpdump(ENABLE);
-                DEBUG_INFO("Check Permission: %d (SLAC first => START)\n", ShmInternalComm->ChargingPermission);
-            }
-
-			DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_SLAC_PARM_REQ ---\n");
-			DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
-										MmePacket->MMENTRY[2], MmePacket->MMENTRY[3],
-										MmePacket->MMENTRY[4], MmePacket->MMENTRY[5],
-										MmePacket->MMENTRY[6], MmePacket->MMENTRY[7],
-										MmePacket->MMENTRY[8], MmePacket->MMENTRY[9]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("CipherSuiteSetSize: 0x%x\n", MmePacket->MMENTRY[10]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("CipherSuite [1]: 0x%x,0x%x\n", MmePacket->MMENTRY[11], MmePacket->MMENTRY[12]);
-
-
-			//Saving each CM_SLAC_PARM_REQ data into EVCC database
-			EvMac_in = &MmePacket->OSA[0];
-			RunID_in = &MmePacket->MMENTRY[2];
-			idx = SLAC_DB_Add(EvMac_in, RunID_in); //(EvMac, RunID)
-
-			if (idx < 0)
-			{
-				DEBUG_WARN("DB is full or errors occour(%d) => ignore\n", idx);
-				break;
-			}
-
-			//Select the 1st EV MAC address
-			if (SLAC_INFO.arrayLen == 1)   //1st Req
-			{
-				DEBUG_INFO("CM_SLAC_PARM_REQ[%d](%02X:%02X:%02X:%02X:%02X:%02X, %02X%02X%02X%02X%02X%02X%02X%02X):selected\n",
-							(idx + 1),
-							MmePacket->OSA[0], MmePacket->OSA[1], MmePacket->OSA[2], MmePacket->OSA[3], MmePacket->OSA[4], MmePacket->OSA[5],
-							MmePacket->MMENTRY[2], MmePacket->MMENTRY[3], MmePacket->MMENTRY[4], MmePacket->MMENTRY[5],
-							MmePacket->MMENTRY[6], MmePacket->MMENTRY[7], MmePacket->MMENTRY[8], MmePacket->MMENTRY[9]);
-			}
-			else    //2nd Req
-			{
-				DEBUG_INFO("CM_SLAC_PARM_REQ[%d](%02X:%02X:%02X:%02X:%02X:%02X, %02X%02X%02X%02X%02X%02X%02X%02X):not selected\n",
-							(idx + 1),
-							MmePacket->OSA[0], MmePacket->OSA[1], MmePacket->OSA[2], MmePacket->OSA[3], MmePacket->OSA[4], MmePacket->OSA[5],
-							MmePacket->MMENTRY[2], MmePacket->MMENTRY[3], MmePacket->MMENTRY[4], MmePacket->MMENTRY[5],
-							MmePacket->MMENTRY[6], MmePacket->MMENTRY[7], MmePacket->MMENTRY[8], MmePacket->MMENTRY[9]);
-			}
-			memcpy(macAddr.evcc, MmePacket->OSA, sizeof(macAddr.evcc));
-			memcpy(qcaInfo.DestSocketAddress.sll_addr, MmePacket->OSA, SLAC_EVMAC_LENGTH);
-			memcpy(qcaInfo.SlacRunId, MmePacket->MMENTRY + 2, SLAC_RUNID_LENGTH);
-			memset(&qcaInfo.SendMmePacket, 0, sizeof(struct MmeHeader));
-			memcpy(qcaInfo.SendMmePacket.ODA, MmePacket->OSA, 6);
-			memcpy(qcaInfo.SendMmePacket.OSA, macAddr.eth1, 6);
-			qcaInfo.SendMmePacket.MTYPE = htons(EtherType_HomePlug);
-			qcaInfo.SendMmePacket.MMV = MmePacket->MMV;
-			qcaInfo.SendMmePacket.MMTYPE = MMTYPE_CM_SLAC_PARM_CNF;
-			qcaInfo.SendMmePacket.FMI[0] = qcaInfo.SendMmePacket.FMI[1] = 0;
-			qcaInfo.SendMmePacketSize = 0;
-			memset(qcaInfo.SendMmePacket.MMENTRY, 0xFF, 6); //M-SOUND_TARGET(6-byte:0xFFFFFFFFFFFF): Fixed value indicating that M-Sounds to be sent as Ethernet broadcast
-			qcaInfo.SendMmePacketSize += 6;
-			qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = C_EV_match_MNBC; //NUM_SOUNDS(0x0A): Number of M-Sounds to be transmitted by the EV GP Station during the SLAC process
-			qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 6; //Time_Out(0x06): unit = 100ms
-			qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0x01; //RESP_TYPE(0x01): Fixed value indicating ��Other GP station��, 0x00 �V HLE of the STA, 0x01 �V Another GP STA, 0x02 �V 0xFF �V Reserved
-			memcpy(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, SLAC_INFO.array[idx].EvMac, 6); //FORWARDING_STA(MAC Address of the EV HLE)
-			qcaInfo.SendMmePacketSize += 6;
-			qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0; //APPLICATION_TYPE(0x00): 0x00(PEV-EVSE Association), 0x01-0xFF(Reserved)
-			qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0; //SECURITY_TYPE(0x00): 0x00(No Security), 0x01(Public Key Signature), 0x02-0xFF(Reserved)
-			memcpy(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, qcaInfo.SlacRunId, SLAC_RUNID_LENGTH); //RunID (8-byte)
-			qcaInfo.SendMmePacketSize += SLAC_RUNID_LENGTH;
-			qcaInfo.SendMmePacketSize += 19;      //the size before MMENTRY
-
-			DEBUG_PRINTF_EVCOMM_DETAIL("***** Response MME Packet *****\n");
-			DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.ODA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
-										qcaInfo.SendMmePacket.ODA[0],qcaInfo.SendMmePacket.ODA[1],qcaInfo.SendMmePacket.ODA[2],qcaInfo.SendMmePacket.ODA[3],qcaInfo.SendMmePacket.ODA[4],qcaInfo.SendMmePacket.ODA[5]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.OSA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
-										qcaInfo.SendMmePacket.OSA[0],qcaInfo.SendMmePacket.OSA[1],qcaInfo.SendMmePacket.OSA[2],qcaInfo.SendMmePacket.OSA[3],qcaInfo.SendMmePacket.OSA[4],qcaInfo.SendMmePacket.OSA[5]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("MTYPE: 0x%x\n", htons(qcaInfo.SendMmePacket.MTYPE));
-			DEBUG_PRINTF_EVCOMM_DETAIL("MMV: 0x%x\n", qcaInfo.SendMmePacket.MMV);
-			DEBUG_PRINTF_EVCOMM_DETAIL("MMTYPE: 0x%x\n", qcaInfo.SendMmePacket.MMTYPE);
-			DEBUG_PRINTF_EVCOMM_DETAIL("FMI 0x%x, 0x%x\n", qcaInfo.SendMmePacket.FMI[0],qcaInfo.SendMmePacket.FMI[1]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("--- CM_SLAC_PARM_CNF ---\n");
-			DEBUG_PRINTF_EVCOMM_DETAIL("M-SOUND_TARGET: %02x:%02x:%02x:%02x:%02x:%02x\n",
-										qcaInfo.SendMmePacket.MMENTRY[0],qcaInfo.SendMmePacket.MMENTRY[1],qcaInfo.SendMmePacket.MMENTRY[2],qcaInfo.SendMmePacket.MMENTRY[3],qcaInfo.SendMmePacket.MMENTRY[4],qcaInfo.SendMmePacket.MMENTRY[5]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("NUM_SOUNDS: 0x%x\n", qcaInfo.SendMmePacket.MMENTRY[6]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("Time_Out: 0x%x\n", qcaInfo.SendMmePacket.MMENTRY[7]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("RESP_TYPE: 0x%x\n", qcaInfo.SendMmePacket.MMENTRY[8]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("M-FORWARDING_STA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
-										qcaInfo.SendMmePacket.MMENTRY[9],qcaInfo.SendMmePacket.MMENTRY[10],qcaInfo.SendMmePacket.MMENTRY[11],qcaInfo.SendMmePacket.MMENTRY[12],qcaInfo.SendMmePacket.MMENTRY[13],qcaInfo.SendMmePacket.MMENTRY[14]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", qcaInfo.SendMmePacket.MMENTRY[15]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", qcaInfo.SendMmePacket.MMENTRY[16]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
-										qcaInfo.SendMmePacket.MMENTRY[17],qcaInfo.SendMmePacket.MMENTRY[18],qcaInfo.SendMmePacket.MMENTRY[19],qcaInfo.SendMmePacket.MMENTRY[20],qcaInfo.SendMmePacket.MMENTRY[21],qcaInfo.SendMmePacket.MMENTRY[22],qcaInfo.SendMmePacket.MMENTRY[23],qcaInfo.SendMmePacket.MMENTRY[24]);
-
-			Update_V2G_Status(CM_SLAC_PARM_CONF);
-			Rtn = sendto(socketFd.Raw, &qcaInfo.SendMmePacket, qcaInfo.SendMmePacketSize, 0, (struct sockaddr*)&qcaInfo.DestSocketAddress, sizeof(struct sockaddr_ll));
-
-			DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacketSize=%d, Rtn=%d\n", qcaInfo.SendMmePacketSize,Rtn);
-
-			ftime(&timerStart.SeqStart);
-			counter = 0;
-			break;
-		}
-
-	    case MMTYPE_CM_START_ATTEN_CHAR_IND:
-		{
-            if(V2gFlowStatus >= CM_ATTEN_CHAR_IND)
-            {
-                DEBUG_INFO("CM_START_ATTEN_CHAR_IND: ignored(time up)\n");
-                break;
-            }
-
-            //Avoid Coupled CM_START_ATTEN_CHAR_IND
-            if (CheckConnectorPlugIn() == FALSE)  //12V(State 1)
-            {
-                DEBUG_INFO("CM_START_ATTEN_CHAR_IND: ignored(coupled SLAC,%d)\n", CheckConnectorPlugIn());
-                break;
-            }
-
-			DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_START_ATTEN_CHAR_IND (counter : %d/3 ) ---\n", counter);
-			DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("NUM_SOUNDS: 0x%x\n", MmePacket->MMENTRY[2]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("Time_Out 0x%x\n", MmePacket->MMENTRY[3]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("RESP_TYPE 0x%x\n", MmePacket->MMENTRY[4]);    //Fixed value (0x01) indicating ��other Green PHY station��
-			DEBUG_PRINTF_EVCOMM_DETAIL("FORWARDING_STA: %02x:%02x:%02x:%02x:%02x:%02x\n", MmePacket->MMENTRY[5],MmePacket->MMENTRY[6],MmePacket->MMENTRY[7],MmePacket->MMENTRY[8], MmePacket->MMENTRY[9],MmePacket->MMENTRY[10]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n", MmePacket->MMENTRY[11],MmePacket->MMENTRY[12],MmePacket->MMENTRY[13],MmePacket->MMENTRY[14], MmePacket->MMENTRY[15],MmePacket->MMENTRY[16],MmePacket->MMENTRY[17],MmePacket->MMENTRY[18]);
-
-			EvMac_in = &MmePacket->OSA[0];
-			RunID_in = &MmePacket->MMENTRY[11];
-			idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
-
-			if (idx >= 0)
-			{
-				Update_V2G_Status(CM_START_ATTEN_CHAR_IND);
-				counter++;
-				//[TC_SECC_VTB_AttenuationCharacterization_013]
-				if (MmePacket->MMENTRY[0] != 0) //APPLICATION_TYPE must be 0x00(EV-EVSE Matching)
-				{
-					DEBUG_INFO("[CM_START_ATTEN_CHAR_IND]APPLICATION_TYPE(%d): invalid => ignore Req\n", MmePacket->MMENTRY[0]);
-					break;
-				}
-
-				//[TC_SECC_VTB_AttenuationCharacterization_014]
-				if (MmePacket->MMENTRY[1] != 0) //SECURITY_TYPE must be 0x00(No Security)
-				{
-					DEBUG_INFO("[CM_START_ATTEN_CHAR_IND]SECURITY_TYPE(%d): invalid => ignore Req\n", MmePacket->MMENTRY[1]);
-					break;
-				}
-
-				//[TC_SECC_VTB_AttenuationCharacterization_017]
-				if (MmePacket->MMENTRY[4] != 0x01) //RESP_TYPE must be 0x01(Send to another GP STA(EV))
-				{
-					DEBUG_INFO("[CM_START_ATTEN_CHAR_IND]RESP_TYPE(%d): invalid => ignore Req\n", MmePacket->MMENTRY[4]);
-					break;
-				}
-
-				//[TC_SECC_VTB_AttenuationCharacterization_021]
-				//FORWARDING_STA: MAC Address of the EV HLE (station which the measurement results shall be sent to)
-				if (Array_Compare_Identity(EvMac_in, &MmePacket->MMENTRY[5], SLAC_EVMAC_LENGTH) == FALSE)
-				{
-					DEBUG_INFO("[CM_START_ATTEN_CHAR_IND]FORWARDING_STA(%02X:%02X:%02X:%02X:%02X:%02X): invalid => ignore Req\n",
-											MmePacket->MMENTRY[5], MmePacket->MMENTRY[6],
-											MmePacket->MMENTRY[7], MmePacket->MMENTRY[8],
-											MmePacket->MMENTRY[9], MmePacket->MMENTRY[10]);
-
-					SLAC_INFO.array[idx].StartAttenCharErr = TRUE;
-					break;
-				}
-
-				//Check RunID
-				if (SLAC_DB_Check_EvMac_RunID_Matching(&SLAC_INFO, EvMac_in, RunID_in) == TRUE)
-				{
-					SLAC_INFO.array[idx].MnbcSoundNum = MmePacket->MMENTRY[2];
-					SLAC_INFO.array[idx].StartAttenCharCnt++;
-
-					if (SLAC_INFO.array[idx].StartAttenCharCnt == 1)
-					{
-						memset(SLAC_INFO.array[idx].AAG, 0, sizeof(SLAC_INFO.array[idx].AAG));
-						SLAC_INFO.array[idx].AttenProfileCnt = 0;
-						ftime(&timerStart.SeqStart);       //start TT_EVSE_match_MNBC
-					}
-					else if (SLAC_INFO.array[idx].StartAttenCharCnt >= 3)
-					{
-						DEBUG_INFO("[CM_START_ATTEN_CHAR_IND]counter(%d): unexpected \n", SLAC_INFO.array[idx].StartAttenCharCnt);
-					}
-					else
-					{
-						//null
-					}
-				}
-				else
-				{
-					//This RunID is not matched with this EvMac,
-					//or this RunID is not found in DB.
-					DEBUG_INFO("[CM_START_ATTEN_CHAR_IND]EvMac-RunID: unmatched => ignore Req\n");
-
-					//Response: ignore
-				}
-			}
-			else
-			{
-				//this msg source is not in database
-				//ignore
-			}
-			break;
-		}
-
-	    case MMTYPE_CM_MNBC_SOUND_IND:
-		{
-	        if(V2gFlowStatus >= CM_ATTEN_CHAR_IND)
-	        {
-                DEBUG_INFO("CM_MNBC_SOUND_IND: ignored(timeup)\n");
-                break;
-            }
-
-            //Avoid Coupled CM_MNBC_SOUND_IND
-            if (CheckConnectorPlugIn() == FALSE)  //12V(State 1)
-            {
-            	DEBUG_INFO("CM_MNBC_SOUND_IND: ignored(coupled SLAC,%d)\n", CheckConnectorPlugIn());
-                break;
-            }
-
-            if(V2gFlowStatus == CM_START_ATTEN_CHAR_IND)
-            {
-            	counter = 0;
-            }
-
-			DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_MNBC_SOUND_IND (counter : %d/%d) ---\n", counter, SLAC_INFO.array[idx].MnbcSoundNum);
-			DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("SenderID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
-									   MmePacket->MMENTRY[2],MmePacket->MMENTRY[3],MmePacket->MMENTRY[4],MmePacket->MMENTRY[5],
-									   MmePacket->MMENTRY[6],MmePacket->MMENTRY[7],MmePacket->MMENTRY[8],MmePacket->MMENTRY[9],
-									   MmePacket->MMENTRY[10],MmePacket->MMENTRY[11],MmePacket->MMENTRY[12],MmePacket->MMENTRY[13],
-									   MmePacket->MMENTRY[14],MmePacket->MMENTRY[15],MmePacket->MMENTRY[16],MmePacket->MMENTRY[17],
-									   MmePacket->MMENTRY[18]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("Cnt: 0x%x\n", MmePacket->MMENTRY[19]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
-									   MmePacket->MMENTRY[20],MmePacket->MMENTRY[21],MmePacket->MMENTRY[22],MmePacket->MMENTRY[23],
-									   MmePacket->MMENTRY[24],MmePacket->MMENTRY[25],MmePacket->MMENTRY[26],MmePacket->MMENTRY[27]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("RSVD: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
-									   MmePacket->MMENTRY[28],MmePacket->MMENTRY[29],MmePacket->MMENTRY[30],MmePacket->MMENTRY[31],
-									   MmePacket->MMENTRY[32],MmePacket->MMENTRY[33],MmePacket->MMENTRY[34],MmePacket->MMENTRY[35]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("Rnd: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
-									   MmePacket->MMENTRY[36],MmePacket->MMENTRY[37],MmePacket->MMENTRY[38],MmePacket->MMENTRY[39],
-									   MmePacket->MMENTRY[40],MmePacket->MMENTRY[41],MmePacket->MMENTRY[42],MmePacket->MMENTRY[43],
-									   MmePacket->MMENTRY[44],MmePacket->MMENTRY[45],MmePacket->MMENTRY[46],MmePacket->MMENTRY[47],
-									   MmePacket->MMENTRY[48],MmePacket->MMENTRY[49],MmePacket->MMENTRY[50],MmePacket->MMENTRY[51]);
-
-			EvMac_in = &MmePacket->OSA[0];
-			RunID_in = &MmePacket->MMENTRY[20];
-			idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
-
-			if (idx >= 0)
-			{
-				Update_V2G_Status(CM_MNBC_SOUND_IND);
-				counter++;
-
-				//Check for RunID
-				if (SLAC_DB_Check_EvMac_RunID_Matching(&SLAC_INFO, EvMac_in, RunID_in) == TRUE)
-				{
-					SLAC_INFO.array[idx].MnbcSoundCnt++;
-				}
-				else
-				{
-					//RunID is not matched or does not exist.
-					DEBUG_INFO("CM_MNBC_SOUND_IND]EvMac-RunID: unmatched\n");
-				}
-			}
-			else
-			{
-				//ignore
-				DEBUG_INFO("CM_MNBC_SOUND_IND]EvMac does not exist\n");
-			}
-			break;
-		}
-
-	    case MMTYPE_CM_ATTEN_PROFILE_IND:
-		{
-	        if(V2gFlowStatus >= CM_ATTEN_CHAR_IND)
-	        {
-                DEBUG_INFO("CM_ATTEN_PROFILE_IND: ignore(timeup)\n");
-				break;
-			}
-
-			DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_ATTEN_PROFILE_IND (counter : %d/%d) ---\n", counter, SLAC_INFO.array[idx].MnbcSoundNum);
-			DEBUG_PRINTF_EVCOMM_DETAIL("EV MAC: %02x:%02x:%02x:%02x:%02x:%02x\n", MmePacket->MMENTRY[0], MmePacket->MMENTRY[1], MmePacket->MMENTRY[2], MmePacket->MMENTRY[3], MmePacket->MMENTRY[4], MmePacket->MMENTRY[5]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("NumGroups: 0x%x\n", MmePacket->MMENTRY[6]);  //NumGroups, Number of AAG Groups (ex: 0x3A = 58)
-			//NumGroups: Number of OFDM carrier groups used for the SLAC signal characterization.
-			//AAG[i]: Average Attenuation of Group i (i = 1 ~ 58)
-			DEBUG_PRINTF_EVCOMM_DETAIL("RSVD: 0x%x\n", MmePacket->MMENTRY[7]);
-
-			memset(tmpBuf, 0x00, ARRAY_SIZE(tmpBuf));
-			for(Rtn = 0; Rtn < MmePacket->MMENTRY[6]; Rtn++)
-			{
-				sprintf((char*)tmpBuf, "%s%02x,", tmpBuf, MmePacket->MMENTRY[8 + Rtn]);
-			}
-			DEBUG_PRINTF_EVCOMM_DETAIL("AAG: %s\n", tmpBuf);
-
-			EvMac_in = &MmePacket->MMENTRY[0]; //[CAUTION] The EvMac address is not &MmePacket->OSA[0]
-			//[CAUTION] There is no RunID information of CM_ATTEN_PROFILE_IND
-			//          packet, which means SECC cannot use the RunID to
-			//          distinguish those SLAC request with identical EvMac
-			//          but with different RunID.
-			idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
-
-			if (idx >= 0)
-			{
-				SLAC_INFO.array[idx].AttenProfileCnt++;
-				SLAC_INFO.array[idx].AagGroupsNum = MmePacket->MMENTRY[6];
-				////NumGroups, Number of AAG Groups (ex: 0x3A = 58)
-
-				for(Rtn = 0; Rtn < SLAC_INFO.array[idx].AagGroupsNum; Rtn++) //ex:58
-				{
-					SLAC_INFO.array[idx].AAG[Rtn] += MmePacket->MMENTRY[8 + Rtn];
-				}
-
-				Update_V2G_Status(CM_MNBC_SOUND_IND);
-				break;
-			}
-			else
-			{
-				//The EvMac is not in the database
-				//ignore
-				DEBUG_INFO("[CM_ATTEN_PROFILE_IND]EvMac(%02X%02X%02X%02X%02X%02X): not exist => ignore\n", EvMac_in[0], EvMac_in[1], EvMac_in[2], EvMac_in[3], EvMac_in[4], EvMac_in[5]);
-				break;
-			}
-		}
-
-	    case MMTYPE_CM_ATTEN_CHAR_RSP:
-		{
-			DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_ATTEN_CHAR_RSP ---\n");
-			DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("SOURCE_ADDRESS: %02x:%02x:%02x:%02x:%02x:%02x\n", MmePacket->MMENTRY[2],MmePacket->MMENTRY[3],MmePacket->MMENTRY[4],MmePacket->MMENTRY[5], MmePacket->MMENTRY[6],MmePacket->MMENTRY[7]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n", MmePacket->MMENTRY[8],MmePacket->MMENTRY[9],MmePacket->MMENTRY[10],MmePacket->MMENTRY[11], MmePacket->MMENTRY[12],MmePacket->MMENTRY[13],MmePacket->MMENTRY[14],MmePacket->MMENTRY[15]);
-
-			memset(tmpBuf, 0x00, ARRAY_SIZE(tmpBuf));
-			for(Rtn = 0; Rtn < 17; Rtn++)
-			{
-				sprintf((char*)tmpBuf, "%s%02x,", tmpBuf, MmePacket->MMENTRY[16 + Rtn]);
-			}
-			DEBUG_PRINTF_EVCOMM_DETAIL("SOURCE_ID: %s\n", tmpBuf);
-							;
-			memset(tmpBuf, 0x00, ARRAY_SIZE(tmpBuf));
-			for(Rtn = 0; Rtn < 17; Rtn++)
-			{
-				sprintf((char*)tmpBuf, "%s%02x,", tmpBuf, MmePacket->MMENTRY[33 + Rtn]);
-			}
-			DEBUG_PRINTF_EVCOMM_DETAIL("RESP_ID: %s\n", tmpBuf);
-			DEBUG_PRINTF_EVCOMM_DETAIL("Result: 0x%x\n", MmePacket->MMENTRY[50]);    //Fixed value of 0x00 indicates a successful SLAC process
-
-			//Check ODA (Destination Address)
-			if (Array_Compare_Identity(macAddr.eth1, MmePacket->ODA, SLAC_EVSE_MAC_LENGTH) == FALSE)
-			{
-				DEBUG_INFO("[CM_ATTEN_CHAR_RSP]wrong ODA: ignore\n");
-				break;
-			}
-
-			EvMac_in = &MmePacket->OSA[0];
-			RunID_in = &MmePacket->MMENTRY[8];
-			idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
-
-			//Check Parameters
-			if ((MmePacket->MMENTRY[0] != 0) ||   //[TC_SECC_VTB_AttenuationCharacterization_005] applicationType must be 0x00
-				(MmePacket->MMENTRY[1] != 0) ||   //[TC_SECC_VTB_AttenuationCharacterization_006] securityType must be 0x00
-				(SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in) < 0) || //[TC_SECC_VTB_AttenuationCharacterization_007] sourceAddress cannot not be all zero
-				(SLAC_DB_Check_EvMac_RunID_Matching(&SLAC_INFO, EvMac_in, RunID_in) == FALSE) ||    //[TC_SECC_VTB_AttenuationCharacterization_008] check for invalid runID
-				(Array_Check_All_Zero(&MmePacket->MMENTRY[16], 17) == FALSE) ||  //[TC_SECC_VTB_AttenuationCharacterization_009] SourceID(17 bytes) must be all zero.
-				(Array_Check_All_Zero(&MmePacket->MMENTRY[33], 17) == FALSE) ||  //[TC_SECC_VTB_AttenuationCharacterization_009] RESP_ID (17 bytes) must be all zero.
-				(MmePacket->MMENTRY[50] != 0)   //Result:  must be 0x00(Success)
-				)
-			{
-				EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry++;
-
-				DEBUG_WARN("[SLAC][RX]CM_ATTEN_CHAR_RSP:invalid para(%d,%d,%d,%d,%d) => %d-th retry\n",
-							MmePacket->MMENTRY[0],  //applicationType must be 0x00
-							MmePacket->MMENTRY[1],  //securityType must be 0x00
-							SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in),
-							SLAC_DB_Check_EvMac_RunID_Matching(&SLAC_INFO, EvMac_in, RunID_in),
-							MmePacket->MMENTRY[50],
-							EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry
-							);
-
-				if (EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry <= 2)   //limited to 2 retries
-				{
-					Update_V2G_Status(CM_MNBC_SOUND_IND);
-					ftime(&timerStart.SeqStart);
-					break;
-				}
-				else
-				{
-					DEBUG_ERROR("[SLAC][RX]CM_ATTEN_CHAR_RSP:invalid para => 2-retry fail => End_Process\n");
-					Update_V2G_Status(Other_Fault);
-					break;
-				}
-			}
-			else
-			{
-				//The CM_ATTEN_CHAR_IND is legal
-				SLAC_INFO.array[idx].AttenCharRspCnt++;
-
-				DEBUG_INFO("[SLAC][RX]CM_ATTEN_CHAR_RSP[%d]:%d-th\n", (idx + 1), SLAC_INFO.array[idx].AttenCharRspCnt);
-
-				EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry = 0;
-				Update_V2G_Status(CM_ATTEN_CHAR_RSP);
-				ftime(&timerStart.SeqStart);
-				break;
-			}
-		}
-
-	    case MMTYPE_CM_VALIDATE_REQ:   //BCB Toggle
-		{
-			DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_VALIDATE_REQ ---\n");
-			DEBUG_PRINTF_EVCOMM_DETAIL("Signal Type: 0x%x\n", MmePacket->MMENTRY[0]);    //Fixed value (0x00) to indicate ��PEV S2 toggles on control pilot line��
-			DEBUG_PRINTF_EVCOMM_DETAIL("Timer: 0x%x\n", MmePacket->MMENTRY[1]);    //Fixed value In the first VALIDATE Request-Response exchange, the Timer field shall be set to zero.
-			DEBUG_PRINTF_EVCOMM_DETAIL("Result: 0x%x\n", MmePacket->MMENTRY[2]);    //Fixed value In the first VALIDATE Request-Response exchange, the Result field shall be set to 0x01 = ��ready��.
-
-			counter = 0;
-
-			EvMac_in = &MmePacket->OSA[0];
-			idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
-
-			if (idx >= 0)
-			{
-				Update_V2G_Status(CM_VALIDATE_CNF);
-				SLAC_INFO.array[idx].ValidateReqCnt++;
-
-				DEBUG_INFO("[SLAC][RX]CM_VALIDATE_REQ[%d]:%d-th\n", (idx + 1), SLAC_INFO.array[idx].ValidateReqCnt);
-
-				//TODO:
-				//	1. Protection
-
-				memset(&qcaInfo.SendMmePacket, 0, sizeof(struct MmeHeader));
-				memcpy(qcaInfo.SendMmePacket.ODA, EvMac_in, SLAC_EVMAC_LENGTH);
-				memcpy(qcaInfo.SendMmePacket.OSA, macAddr.eth1, 6);
-				qcaInfo.SendMmePacket.MTYPE = htons(EtherType_HomePlug);
-				qcaInfo.SendMmePacket.MMV = 0x01;
-				qcaInfo.SendMmePacket.MMTYPE = MMTYPE_CM_VALIDATE_CNF;
-				qcaInfo.SendMmePacket.FMI[0] = qcaInfo.SendMmePacket.FMI[1] = 0;
-				qcaInfo.SendMmePacketSize = 0;
-
-				if(counter == 0)
-				{
-					//The First MMTYPE_CM_VALIDATE_REQ because Unicast
-					qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0;    //SignalType(0x00): Fixed value to indicate "EV S2 toggles on control pilot line"
-					qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0;    //ToggleNum(0x00): Fixed value. In the first VALIDATE Request-Response exchange, the ToggleNum field shall be set to zero.
-
-					#if (SUPPORT_BCB_TOGGLE_FUNCTION == ENABLE)
-						qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 1;    //0x01 = Ready
-					#else
-						qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 4;    //0x04 = Not Required
-					#endif
-				}
-				else
-				{
-					//The Second MMTYPE_CM_VALIDATE_REQ because Broadcast
-					unsigned char PreStatus = 3;
-					unsigned char ToggleNum = 0;
-					ftime(&timerStart.SeqStart);
-					while(1)
-					{
-						if((EVCOMM_SYS_INFO.CpState == 4) && (PreStatus == 3))
-						{
-							ToggleNum++;
-							PreStatus = 4;
-						}
-						else
-						{
-							PreStatus = 3;
-						}
-
-						ftime(&timerStart.SeqEnd);
-						if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) >= (qcaInfo.SendMmePacket.MMENTRY[1]*100 + 100))
-						{
-							qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0;    //Fixed value to indicate "PEV S2 toggles on control pilot line"
-							qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = ToggleNum;
-
-							#if (SUPPORT_BCB_TOGGLE_FUNCTION == ENABLE)
-							qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 2;    //0x02 = Success
-							#else
-								qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 4;    //0x04 = Not Required
-							#endif
-
-							break;
-						}
-						usleep(1000);
-					}
-				}
-				qcaInfo.SendMmePacketSize += 19;      //the size before MMENTRY
-				Rtn = sendto(socketFd.Raw, &qcaInfo.SendMmePacket, qcaInfo.SendMmePacketSize, 0, (struct sockaddr*)&qcaInfo.DestSocketAddress, sizeof(struct sockaddr_ll));
-				ftime(&timerStart.SeqStart);
-			}
-			else
-			{
-				//EvMac does not exist.
-				//ignore
-			}
-			break;
-		}
-
-	    case MMTYPE_CM_SLAC_MATCH_REQ:
-		{
-			char buf[512];
-			DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_SLAC_MATCH_REQ ---\n");
-			DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("MVFLength: 0x%x, 0x%x\n", MmePacket->MMENTRY[2],MmePacket->MMENTRY[3]);    //Fixed value (0x3E) for matching
-			memset(buf, 0x00, ARRAY_SIZE(buf));
-			for(Rtn=0; Rtn<17; Rtn++)
-			{
-				sprintf(buf, "%s%02x ", buf, MmePacket->MMENTRY[4+Rtn]);
-			}
-			DEBUG_PRINTF_EVCOMM_DETAIL("PEV ID: %s\n", buf);
-
-			memset(buf, 0x00, ARRAY_SIZE(buf));
-			for(Rtn=0; Rtn<6; Rtn++)
-			{
-				sprintf(buf, "%s%02x ", buf, MmePacket->MMENTRY[21+Rtn]);
-			}
-			DEBUG_PRINTF_EVCOMM_DETAIL("PEV MAC: %s\n", buf);
-
-			memset(buf, 0x00, ARRAY_SIZE(buf));
-			for(Rtn=0; Rtn<17; Rtn++)
-			{
-				sprintf(buf, "%s%02x ", buf, MmePacket->MMENTRY[27+Rtn]);
-			}
-			DEBUG_PRINTF_EVCOMM_DETAIL("EVSE ID: %d\n", buf);
-
-			memset(buf, 0x00, ARRAY_SIZE(buf));
-			for(Rtn=0; Rtn<6; Rtn++)
-			{
-				sprintf(buf, "%s%02x ", buf, MmePacket->MMENTRY[44+Rtn]);
-			}
-			DEBUG_PRINTF_EVCOMM_DETAIL("EVSE MAC: %s\n", buf);
-
-			memset(buf, 0x00, ARRAY_SIZE(buf));
-			for(Rtn=0; Rtn<8; Rtn++)
-			{
-				sprintf(buf, "%s%02x ", buf, MmePacket->MMENTRY[50+Rtn]);
-			}
-			DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %s\n", buf);
-
-			memset(buf, 0x00, ARRAY_SIZE(buf));
-			for(Rtn=0; Rtn<8; Rtn++)
-			{
-				sprintf(buf, "%s%02x ", buf, MmePacket->MMENTRY[58+Rtn]);
-			}
-			DEBUG_PRINTF_EVCOMM_DETAIL("RSVD: %s\n", buf);
-
-
-			//Check ODA (Destination Address)
-			if (Array_Compare_Identity(macAddr.eth1, MmePacket->ODA, SLAC_EVSE_MAC_LENGTH) == FALSE)
-			{
-				DEBUG_WARN("[CM_SLAC_MATCH_REQ]wrong ODA: ignore");
-				//break; //patch for DEKRA I2SE EVCC (another EVSE MAC Address protection comes as below.)
-			}
-
-			EvMac_in = &MmePacket->OSA[0];
-			RunID_in = &MmePacket->MMENTRY[50];
-			idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
-			if (idx >= 0)
-			{
-				Update_V2G_Status(CM_SLAC_MATCH_REQ);
-
-				SLAC_INFO.array[idx].MatchReqNum++;
-
-				DEBUG_INFO("CM_SLAC_MATCH_REQ[%d]:%d-th\n", (idx + 1), SLAC_INFO.array[idx].MatchReqNum);
-
-				//[TC_SECC_VTB_CmSlacMatch_007] APPLICATION_TYPE must be 0x00(EV-EVSE Matching)
-				//[TC_SECC_VTB_CmSlacMatch_008]
-				if (MmePacket->MMENTRY[0] != 0)
-				{
-					DEBUG_WARN("CM_SLAC_MATCH_REQ[%d]:wrong APPLICATION_TYPE(%d)\n", (idx + 1), MmePacket->MMENTRY[0]);
-					break;
-				}
-
-				//[TC_SECC_VTB_CmSlacMatch_009] SECURITY_TYPE must be 0x00(No Security)
-				//[TC_SECC_VTB_CmSlacMatch_010]
-				if (MmePacket->MMENTRY[1] != 0)
-				{
-					DEBUG_WARN("CM_SLAC_MATCH_REQ[%d]:wrong SECURITY_TYPE(%d)\n", (idx + 1), MmePacket->MMENTRY[1]);
-					break;
-				}
-
-				//[TC_SECC_VTB_CmSlacMatch_011] MVFLength must be 0x3E(MatchVarField Length)
-				//[TC_SECC_VTB_CmSlacMatch_012]
-				if (MmePacket->MMENTRY[2] != 0x3E || MmePacket->MMENTRY[3] != 0x00)
-				{
-					DEBUG_WARN("CM_SLAC_MATCH_REQ[%d]:wrong MVFLength(%d,%d)\n", (idx + 1), MmePacket->MMENTRY[2], MmePacket->MMENTRY[3]);
-					break;
-				}
-
-				//[TC_SECC_VTB_CmSlacMatch_013] EV ID (muxt be all zero)
-				//[TC_SECC_VTB_CmSlacMatch_014]
-				if (Array_Check_All_Zero(&MmePacket->MMENTRY[4], 17) == FALSE)
-				{
-					DEBUG_WARN("CM_SLAC_MATCH_REQ[%d]: wrong EV ID\n", (idx + 1));
-					break;
-				}
-
-				//[TC_SECC_VTB_CmSlacMatch_015] EV MAC
-				//[TC_SECC_VTB_CmSlacMatch_016]
-				if (Array_Compare_Identity(EvMac_in, &MmePacket->MMENTRY[21], SLAC_EVMAC_LENGTH) == FALSE)
-				{
-					DEBUG_WARN("CM_SLAC_MATCH_REQ[%d]: wrong EV MAC(%02X:%02X:%02X:%02X:%02X:%02X)\n",
-											(idx + 1),
-											MmePacket->MMENTRY[21], MmePacket->MMENTRY[22], MmePacket->MMENTRY[23],
-											MmePacket->MMENTRY[24], MmePacket->MMENTRY[25], MmePacket->MMENTRY[26]);
-					break;
-				}
-
-				//[TC_SECC_VTB_CmSlacMatch_017] EVSE ID should be all zero
-				//[TC_SECC_VTB_CmSlacMatch_018]
-				if (Array_Check_All_Zero(&MmePacket->MMENTRY[27], 17) == FALSE)
-				{
-					DEBUG_WARN("CM_SLAC_MATCH_REQ[%d]: wrong EVSE ID\n", (idx + 1));
-					break;
-				}
-
-				//[TC_SECC_VTB_CmSlacMatch_019] EVSE MAC
-				//[TC_SECC_VTB_CmSlacMatch_020]
-				if (Array_Compare_Identity(macAddr.eth1, &MmePacket->MMENTRY[44], SLAC_EVSE_MAC_LENGTH) == FALSE)
-				{
-					DEBUG_WARN("CM_SLAC_MATCH_REQ[%d]: wrong EVSE MAC(%02X:%02X:%02X:%02X:%02X:%02X)\n",
-											(idx + 1),
-											MmePacket->MMENTRY[44], MmePacket->MMENTRY[45], MmePacket->MMENTRY[46],
-											MmePacket->MMENTRY[47], MmePacket->MMENTRY[48], MmePacket->MMENTRY[49]);
-					break;
-				}
-
-				//[TC_SECC_VTB_CmSlacMatch_021]runID: Check RunID
-				//[TC_SECC_VTB_CmSlacMatch_022]
-				if (SLAC_DB_Check_EvMac_RunID_Matching(&SLAC_INFO, EvMac_in, RunID_in) == TRUE &&
-				   (idx == 0)) //only setup a successful link establishment with the first SLAC Req instance
-				{
-					memset(&qcaInfo.SendMmePacket, 0, sizeof(struct MmeHeader));
-					memcpy(qcaInfo.SendMmePacket.ODA, MmePacket->OSA, 6);
-					memcpy(qcaInfo.SendMmePacket.OSA, macAddr.eth1, 6);
-					qcaInfo.SendMmePacket.MTYPE = htons(EtherType_HomePlug);
-					qcaInfo.SendMmePacket.MMV = MmePacket->MMV;
-					qcaInfo.SendMmePacket.MMTYPE = MMTYPE_CM_SLAC_MATCH_CNF;
-					qcaInfo.SendMmePacket.FMI[0] = qcaInfo.SendMmePacket.FMI[1] = 0;
-					qcaInfo.SendMmePacketSize = 0;
-					qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0x00;    //APPLICATION_TYPE: Fixed value (0x00: EV-EVSE matching)
-					qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0x00;    //SECURITY_TYPE: Fixed value (0x00: No Security)
-					qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0x56;    //MVFLength: MatchVarField Length (Fixed value: 0x0056)
-					qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0x00;    //MVFLength: MatchVarField Length (Fixed value: 0x0056)
-					memset(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, 0, 17);         //EV ID
-					qcaInfo.SendMmePacketSize += 17;
-					memcpy(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, EvMac_in, SLAC_EVMAC_LENGTH); //EV MAC
-					qcaInfo.SendMmePacketSize += 6;
-					memset(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, 0, 17);         //EVSE ID
-					qcaInfo.SendMmePacketSize += 17;
-					memcpy(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, macAddr.eth1, 6);     //EVSE MAC
-					qcaInfo.SendMmePacketSize += 6;
-					memcpy(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, RunID_in, SLAC_RUNID_LENGTH);
-					qcaInfo.SendMmePacketSize += SLAC_RUNID_LENGTH;
-					memset(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, 0, 8);    //RSVD
-					qcaInfo.SendMmePacketSize += 8;
-					memcpy(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, qcaInfo.Nid, sizeof(qcaInfo.Nid));   //NID: Network ID given by the CCo(EVSE)
-					qcaInfo.SendMmePacketSize += sizeof(qcaInfo.Nid);                                      //NID caculated from the random NMK that will be set.
-					qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0x00;          //RSVD
-					memcpy(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, qcaInfo.NewNmkKey, sizeof(qcaInfo.NewNmkKey)); //NMK: Random value
-					qcaInfo.SendMmePacketSize += sizeof(qcaInfo.NewNmkKey);                                          //NMK: Private NMK of the EVSE (random value)
-					qcaInfo.SendMmePacketSize += 19;      //the size before MMENTRY
-
-					DEBUG_PRINTF_EVCOMM_DETAIL("***** Response MME Packet *****\n");
-					DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.ODA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
-												qcaInfo.SendMmePacket.ODA[0],qcaInfo.SendMmePacket.ODA[1],qcaInfo.SendMmePacket.ODA[2],qcaInfo.SendMmePacket.ODA[3],qcaInfo.SendMmePacket.ODA[4],qcaInfo.SendMmePacket.ODA[5]);
-					DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.OSA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
-												qcaInfo.SendMmePacket.OSA[0],qcaInfo.SendMmePacket.OSA[1],qcaInfo.SendMmePacket.OSA[2],qcaInfo.SendMmePacket.OSA[3],qcaInfo.SendMmePacket.OSA[4],qcaInfo.SendMmePacket.OSA[5]);
-					DEBUG_PRINTF_EVCOMM_DETAIL("MTYPE: 0x%x\n", htons(qcaInfo.SendMmePacket.MTYPE));
-					DEBUG_PRINTF_EVCOMM_DETAIL("MMV: 0x%x\n", qcaInfo.SendMmePacket.MMV);
-					DEBUG_PRINTF_EVCOMM_DETAIL("MMTYPE: 0x%x\n", qcaInfo.SendMmePacket.MMTYPE);
-					DEBUG_PRINTF_EVCOMM_DETAIL("FMI 0x%x, 0x%x\n", qcaInfo.SendMmePacket.FMI[0],qcaInfo.SendMmePacket.FMI[1]);
-					DEBUG_PRINTF_EVCOMM_DETAIL("--- CM_SLAC_MATCH_CNF ---\n");
-					DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", qcaInfo.SendMmePacket.MMENTRY[0]);
-					DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", qcaInfo.SendMmePacket.MMENTRY[1]);
-					DEBUG_PRINTF_EVCOMM_DETAIL("MVFLength: 0x%x, 0x%x\n", qcaInfo.SendMmePacket.MMENTRY[2],qcaInfo.SendMmePacket.MMENTRY[3]);
-
-					memset(buf, 0x00, ARRAY_SIZE(buf));
-					for(Rtn=0; Rtn<17; Rtn++)
-					{
-						sprintf(buf, "%s%02x ", buf, qcaInfo.SendMmePacket.MMENTRY[4+Rtn]);
-					}
-					DEBUG_PRINTF_EVCOMM_DETAIL("PEV ID: %d\n", buf);
-
-					memset(buf, 0x00, ARRAY_SIZE(buf));
-					for(Rtn=0; Rtn<6; Rtn++)
-					{
-						sprintf(buf, "%s%02x ", buf, qcaInfo.SendMmePacket.MMENTRY[21+Rtn]);
-					}
-					DEBUG_PRINTF_EVCOMM_DETAIL("PEV MAC: %s\n", buf);
-
-					memset(buf, 0x00, ARRAY_SIZE(buf));
-					for(Rtn=0; Rtn<17; Rtn++)
-					{
-						sprintf(buf, "%s%02x ", buf, qcaInfo.SendMmePacket.MMENTRY[27+Rtn]);
-					}
-					DEBUG_PRINTF_EVCOMM_DETAIL("EVSE ID: %s\n", buf);
-
-					memset(buf, 0x00, ARRAY_SIZE(buf));
-					for(Rtn=0; Rtn<6; Rtn++)
-					{
-						sprintf(buf, "%s%02x ", buf, qcaInfo.SendMmePacket.MMENTRY[44+Rtn]);
-					}
-					DEBUG_PRINTF_EVCOMM_DETAIL("EVSE MAC: %s\n", buf);
-
-					memset(buf, 0x00, ARRAY_SIZE(buf));
-					for(Rtn=0; Rtn<8; Rtn++)
-					{
-						sprintf(buf, "%s%02x ", buf, qcaInfo.SendMmePacket.MMENTRY[50+Rtn]);
-					}
-					DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %s\n", buf);
-
-					memset(buf, 0x00, ARRAY_SIZE(buf));
-					for(Rtn=0; Rtn<8; Rtn++)
-					{
-						sprintf(buf, "%s%02x ", buf, qcaInfo.SendMmePacket.MMENTRY[58+Rtn]);
-					}
-					DEBUG_PRINTF_EVCOMM_DETAIL("RSVD: %s\n", buf);
-
-					memset(buf, 0x00, ARRAY_SIZE(buf));
-					for(Rtn=0; Rtn<7; Rtn++)
-					{
-						sprintf(buf, "%s%02x ", buf, qcaInfo.SendMmePacket.MMENTRY[66+Rtn]);
-					}
-					DEBUG_PRINTF_EVCOMM_DETAIL("NID: %s\n", buf);
-
-					DEBUG_PRINTF_EVCOMM_DETAIL("RSVD: 0x%02x\n", qcaInfo.SendMmePacket.MMENTRY[73]);
-
-					memset(buf, 0x00, ARRAY_SIZE(buf));
-					for(Rtn=0; Rtn<16; Rtn++)
-					{
-						sprintf(buf, "%s%02x ", buf, qcaInfo.SendMmePacket.MMENTRY[74+Rtn]);
-					}
-					DEBUG_PRINTF_EVCOMM_DETAIL("NMK: \n");
-
-					Update_V2G_Status(CM_SLAC_MATCH_CNF);
-					Rtn = sendto(socketFd.Raw, &qcaInfo.SendMmePacket, qcaInfo.SendMmePacketSize, 0, (struct sockaddr*)&qcaInfo.DestSocketAddress, sizeof(struct sockaddr_ll));
-					DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacketSize=%d,Rtn=%d\n", qcaInfo.SendMmePacketSize,Rtn);
-					DEBUG_INFO( "CM_SLAC_MATCH_CNF[%d]\n", (idx + 1));
-
-					ftime(&timerStart.SeqStart);
-				}
-				else
-				{
-					//RunID does not match and it's not the first SLAC request
-					//Reset the SLAC database to embrace SLAC retry
-					DEBUG_INFO("[CM_SLAC_MATCH_REQ]No Real MATCH_REQ\n");
-					SLAC_DB_Reset();
-				}
-			}
-			else
-			{
-				//OSA(EvMac) does not exist
-			}
-			break;
-		}
-
-	    case MMTYPE_VENDOR_VS_HOST_ACTION:
-	    {
-	        struct QcaVendorMmeHeader *RecvPacket;
-	        RecvPacket = (struct QcaVendorMmeHeader *)Buffer;
-
-	        DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_VENDOR_VS_HOST_ACTION ---\n");
-
-	        switch (RecvPacket->MBODY[0])
-	        {
-		        case 0x00:
-		            //Loader (Device Softloader or Bootloader) ready
-		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: Loader Ready\n");
-		            break;
-
-		        case 0x01:
-		            //Firmware Upgrade Ready
-		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: Firmware Upgrade Ready\n");
-		            break;
-
-		        case 0x02:
-		            //PIB Update Ready
-		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: PIB Update Ready\n");
-		            break;
-
-		        case 0x03:
-		            //Firmware Upgrade and PIB Update ready
-		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: Firmware Upgrade and PIB Update ready\n");
-		            break;
-
-		        case 0x04:
-		            //Loader (Bootloader) ready to receive SDRAM configuration.
-		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: Loader ready to receive SDRAM configuration\n");
-		            break;
-
-		        case 0x05:
-		            //Reset to Factory Defaults.
-		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: Reset to Factory Defaults\n");
-		            break;
-
-		        default:
-		            //Reserved
-		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: Reserved\n");
-		            break;
-	        }
-			break;
-	    }
-
-	    case MMTYPE_VENDOR_ATTEN_CHAR:
-		{
-	        DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_VENDOR_ATTEN_CHAR ---\n");
-	        break;
-		}
-
-	    case MMTYPE_VENDOR_VS_NW_INFO_CNF:
-		{
-			// Only Set key for local QCA7000
-			if((MmePacket->OSA[0] == MmePacket->MMENTRY[12]) &&
-			   (MmePacket->OSA[1] == MmePacket->MMENTRY[13]) &&
-			   (MmePacket->OSA[2] == MmePacket->MMENTRY[14]) &&
-			   (MmePacket->OSA[3] == MmePacket->MMENTRY[15]) &&
-			   (MmePacket->OSA[4] == MmePacket->MMENTRY[16]) &&
-			   (MmePacket->OSA[5] == MmePacket->MMENTRY[17]))
-			{
-				memcpy(macAddr.qca, MmePacket->OSA, 6);
-
-				DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_VENDOR_VS_NW_INFO_CNF ---\n");
-				DEBUG_INFO("EVSE MAC address(QCA): %02X:%02X:%02X:%02X:%02X:%02X(comm:OK)\n",
-							macAddr.qca[0],  macAddr.qca[1],  macAddr.qca[2],  macAddr.qca[3],  macAddr.qca[4],  macAddr.qca[5]);
-
-				Update_V2G_Status(CM_SET_KEY_REQ);
-				ftime(&timerStart.SeqStart);
-			}
-
-            break;
-		}
-
-	    case MMTYPE_VENDOR_VS_PL_LNK_STATUS_CNF:
-		{
-			struct QcaVendorMmeHeader *RecvPacket;
-			RecvPacket = (struct QcaVendorMmeHeader *)Buffer;
-
-			if(RecvPacket->MBODY[1]==0)
-			{
-				//PLC disconnected
-				DEBUG_INFO("[MMTYPE_VENDOR_VS_PL_LNK_STATUS_CNF]Got PLC Link Status:%d\n", RecvPacket->MBODY[1]);
-				Update_V2G_Status(Other_Fault);
-			}
-			else
-				Update_V2G_Status(CM_SET_KEY_REQ);
-
-			ftime(&timerStart.SeqStart);
-			break;
-		}
-
-	    default:
-		{
-	        break;
-		}
-    }
-
-    return 0;
-}
-
-/**
- *
- * @return
- */
-int SlacComm()
-{
-    static unsigned char qca7k_comm_retry = 0;
-    double t_diff = 0;
-    int packet_size = 0;
-    int count = 0;
-    unsigned char tmpBuf[2048]={0};
-    unsigned char *EvMac_in;
-    unsigned char *RunID_in;
-    int i = 0;
-
-    if(socketFd.Raw >= 0)
-    {
-        memset(v2gBuffer.rx, 0, V2GTP_MSG_RX_BUFFER_SIZE);
-        packet_size = recvfrom(socketFd.Raw, v2gBuffer.rx, V2GTP_MSG_RX_BUFFER_SIZE, 0, NULL, NULL);
-        if(packet_size > 0)
-        {
-            MmeProcess(v2gBuffer.rx, packet_size);
-        }
-    }
-
-    switch(Get_V2G_Status())
-    {
-	    case IDLE:
-		{
-	        if(socketFd.Raw < 0)
-	        {
-	        	socketFd.Raw = socket(PF_PACKET, SOCK_RAW, htons(EtherType_HomePlug));
-                DEBUG_INFO("[RawSock]opened(%d)\n", socketFd.Raw);
-
-	            if(socketFd.Raw == -1)
-	            {
-	                DEBUG_ERROR("SlacComm:Failed to create socket\n");
-	                Update_V2G_Status(Other_Fault);
-	                return -1;
-	            }
-
-	            if (setsockopt(socketFd.Raw, SOL_SOCKET, SO_BINDTODEVICE, QcaInterface, 4) < 0)
-	            {
-                    DEBUG_ERROR("SlacComm:Set SO_BINDTODEVICE NG\n");
-                    Update_V2G_Status(Other_Fault);
-                    return -1;
-                }
-
-                struct timeval tv;
-	            tv.tv_sec = 0;
-		        tv.tv_usec = 100000;  //100ms (Rx timeout)
-	            if (setsockopt(socketFd.Raw, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct	timeval)) < 0)
-	            {
-	                DEBUG_ERROR("SlacComm:Set SO_RCVTIMEO NG\n");
-	                Update_V2G_Status(Other_Fault);
-	                return -1;
-	            }
-
-                tv.tv_usec = 100000;  //100ms (Tx timeout)
-                if (setsockopt(socketFd.Raw, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(struct	timeval)) < 0)
-	            {
-	                DEBUG_ERROR("SlacComm:Set SO_SNDTIMEO NG\n");
-	                Update_V2G_Status(Other_Fault);
-	                return -1;
-	            }
-
-	            memset(&qcaInfo.Req, 0, sizeof(struct ifreq));
-	            strcpy( (char*)qcaInfo.Req.ifr_name, QcaInterface);
-
-	            if (ioctl(socketFd.Raw, SIOCGIFINDEX, &qcaInfo.Req) < 0)
-	            {
-	                DEBUG_ERROR("SlacComm: ioctl NG\n");
-	                Update_V2G_Status(Other_Fault);
-	                return -1;
-	            }
-
-	            memset(&qcaInfo.DestSocketAddress, 0, sizeof(struct sockaddr_ll));
-	            qcaInfo.DestSocketAddress.sll_ifindex = qcaInfo.Req.ifr_ifindex;
-	            qcaInfo.DestSocketAddress.sll_halen = ETH_ALEN;
-
-	            timerStart.PwmStart = 0;
-
-                EVCOMM_SYS_INFO.QCA7K_SetKeyDone = FALSE;
-                DEBUG_INFO("QCA7000 connecting...\n");
-                //Get QCA7K MAC address
-                GetQca7kMac();
-                ftime(&timerStart.SeqStart);
-                break;
-	        }
-	        else   //RawSock: opened
-	        {
-                if(EVCOMM_SYS_INFO.QCA7K_SetKeyDone == FALSE)
-                {
-                    ftime(&timerStart.SeqEnd);
-                    t_diff = DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd);
-
-                    if (t_diff > V2G_SECC_QCA7000_GET_MAC_ADDR_REQ_RETRY_PERIOD)   //3 secs
-                    {
-                        qca7k_comm_retry++;
-                        DEBUG_INFO("Re-try connecting...(%.02lf/%dms)\n", t_diff, V2G_SECC_QCA7000_GET_MAC_ADDR_REQ_RETRY_PERIOD);
-
-                        GetQca7kMac(); //re-send req
-                        ftime(&timerStart.SeqStart);
-                        break;
-                    }
-                    else
-                    {}
-
-                    //Retry by 3 times
-                    if (qca7k_comm_retry >= 3)
-                    {
-                    	DEBUG_ERROR("Comm: fail (retry by %d times)\n", qca7k_comm_retry);
-
-                        //Update_ShmStatusCode(); //[To-Do] to be implemented
-                        //CCS_SECCC_TIMEOUT_QCA7000_COMM (023892): The firmware code of QCA7000 may not be installed, yet
-                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                        ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                        ShmStatusCodeData->PresentStatusCode[0][4] = 9;
-                        ShmStatusCodeData->PresentStatusCode[0][5] = 2;
-                        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = FALSE;
-                        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-                        Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
-
-                        Update_V2G_Status(Sequence_Timeout);
-                        qca7k_comm_retry = 0;
-                        break;
-                    }
-                }
-                else    //RawSock: opened; Set Key: DONE
-                {
-                	/*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
-                    if((CheckConnectorPlugIn() == TRUE) && (ShmInternalComm->ChargingPermission >= 1))
-                    {
-                        if(timerStart.PwmStart <= 0)
-                        {
-                            //Sniffer_Tcpdump(ENABLE);
-                            //#if (TCPDUMP_PACKETS_SNIFFER_SWITCH == ENABLE)
-                            //sleep(1);   //wait for tcpdump to be ready.
-                            //#endif
-                            SwitchCpStateE(DISABLE);
-                            OutputCpPwmDuty(5);
-                            timerStart.PwmStart = time(NULL);
-#ifdef TEST_WITH_ETH0
-                            Update_V2G_Status(SLACC_SDP_UDP_Connection);
-#endif
-                        }
-                        else
-                        {
-                            if((time(NULL) - timerStart.PwmStart) > TT_EVSE_SLAC_init)
-                            {
-                            	DEBUG_ERROR("SlacComm: Wait CM_SLAC_PARM_REQ Timeout - TT_EVSE_SLAC_init, NowTime(%ld)-timerStart.PwmStart(%d)>%d (sec)\n", time(NULL), timerStart.PwmStart, TT_EVSE_SLAC_init);
-
-                                //Update_ShmStatusCode(); //[To-Do] to be implemented
-                                //CCS_SECC_TIMEOUT_SLAC_TT_EVSE_SLAC_init (023809)
-                                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                                ShmStatusCodeData->PresentStatusCode[0][4] = 0;
-                                ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-                                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-                                Update_V2G_Status(Sequence_Timeout);
-                                timerStart.PwmStart = 0;
-                                return -1;
-                            }
-                            else
-                            {
-                                //waiting for CM_SLAC_PARM_REQ
-                            }
-                        }
-                    }
-                    else
-                    {
-                        timerStart.PwmStart = 0;
-                    }
-                }
-	        }
-	        break;
-		}
-
-	    case CM_SET_KEY_REQ:   //13
-		{
-	        //CM_SET_KEY_REQ
-            //DEBUG_INFO("QCA7000 [RX]CM_SET_KEY_REQ\n");
-            ftime(&timerStart.SeqEnd);
-            t_diff = DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd);
-            if (t_diff > V2G_SECC_QCA7000_COMM_TIMEOUT)   //10 seconds
-            {
-            	DEBUG_ERROR("QCA7000 Failed on SetKey => End_Process (%.02lf/%dms)\n", t_diff, V2G_SECC_QCA7000_COMM_TIMEOUT);
-
-                //Update_ShmStatusCode(); //[To-Do] to be implemented
-                //CCS_SECCC_TIMEOUT_QCA7000_COMM (023892): The firmware code of QCA7000 may not be installed, yet
-                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                ShmStatusCodeData->PresentStatusCode[0][4] = 9;
-                ShmStatusCodeData->PresentStatusCode[0][5] = 2;
-                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = FALSE;
-                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-
-                Update_V2G_Status(Sequence_Timeout);
-            }
-            else if (t_diff > V2G_SECC_QCA7000_SEND_SET_KEY_PERIOD)  //2 seconds
-            {
-                DEBUG_INFO("QCA7000 SetKey: proceed (%.02lf/%dms)\n", t_diff, V2G_SECC_QCA7000_SEND_SET_KEY_PERIOD);
-
-                SendSetKey();
-                ftime(&timerStart.SeqStart);
-            }
-            else
-            {
-                //null
-            }
-	        break;
-		}
-
-	    case CM_SET_KEY_CNF:   //14
-		{
-            DEBUG_INFO("Wait: plugin(%d), matached(%d), permission(%d)...\n", CheckConnectorPlugIn(), CSUCOMMDC_TASK_FLAG.matched, ShmInternalComm->ChargingPermission);
-
-            EVCOMM_SYS_INFO.QCA7K_SetKeyDone = TRUE;
-            timerStart.PwmStart = 0;
-            Update_V2G_Status(IDLE);
-	        break;
-		}
-
-	    case CM_SLAC_PARM_CONF:
-		{
-	        ftime(&timerStart.SeqEnd);
-	        if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > TT_match_sequence)
-	        {
-	        	DEBUG_ERROR("SlacComm: Wait CM_START_ATTEN_CHAR_IND Timeout - TT_match_sequence (%.02lf of %dms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), TT_match_sequence);
-
-                //Update_ShmStatusCode(); //[To-Do] to be implemented
-                //CCS_SECC_TIMEOUT_CM_START_ATTEN_CHAR_IND (023811):
-                //[Possible Reason] CCS Board image might not be updated properly. The 2nd reboot process is not finished.
-                //[Verification Method] By tying reboot command to the terminal and see if it could be executed immediately.
-                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
-                ShmStatusCodeData->PresentStatusCode[0][5] = 1;
-                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = FALSE;
-                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-
-	            Update_V2G_Status(Sequence_Timeout);
-	            return -1;
-	        }
-	        break;
-		}
-
-	    case CM_START_ATTEN_CHAR_IND:
-		{
-	        ftime(&timerStart.SeqEnd);
-	        if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > (TP_EV_batch_msg_interval))    //one more time interval for tolerance
-	        {
-	        	DEBUG_ERROR("SlacComm: Wait CM_MNBC_SOUND_IND Timeout - TP_EV_batch_msg_interval (%.02lf of %dms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), TP_EV_batch_msg_interval);
-
-                //Update_ShmStatusCode(); //[To-Do] to be implemented
-                //CCS_SECC_TIMEOUT_SLAC_CM_MNBC_SOUND_IND (023818):
-                //[Possible Reason] CCS Board image might not be updated properly. The 2nd reboot process is not finished.
-                //[Verification Method] By tying reboot command to the terminal and see if it could be executed immediately.
-                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
-                ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = FALSE;
-                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-
-	            Update_V2G_Status(Sequence_Timeout);
-	            return -1;
-	        }
-	        break;
-		}
-
-	    case CM_MNBC_SOUND_IND:
-		{
-			ftime(&timerStart.SeqEnd);
-			t_diff = DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd);
-			//printf("time:%.02lf, profilNum:%d\n",DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd),AttenProfileCnt);  //added by Vern
-			if(t_diff > TT_EVSE_match_MNBC ||
-			  (SLAC_INFO.array[0].AttenProfileCnt >= SLAC_INFO.array[0].MnbcSoundNum) ||
-			  (EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry > 0)) //TC_SECC_VTB_AttenuationCharacterization_003
-			{
-				//Wait for other SLAC Req sets
-				if ((SLAC_INFO.arrayLen >= 2) &&
-					(t_diff < TT_EVSE_match_MNBC) &&
-					(EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry == 0)) //not a retry
-				{
-					break;
-				}
-
-				//Check if it is a timeup response
-				if (t_diff > TT_EVSE_match_MNBC)
-				{
-					DEBUG_WARN("[SLAC][TX]CM_ATTEN_CHAR_IND[%d]: timeup(%.2f/%dms) => send\n", (i + 1), t_diff, TT_EVSE_match_MNBC);
-				}
-
-				//Sending all CM_ATTEN_CHAR_IND according to all corresponding SLAC Req sets
-				for (i = 0; i < SLAC_INFO.arrayLen; i++)
-				{
-					if ((SLAC_INFO.array[i].AttenProfileCnt == 0) ||
-						(SLAC_INFO.array[i].AagGroupsNum == 0) ||
-						(SLAC_INFO.array[i].StartAttenCharCnt == 0) ||
-						(SLAC_INFO.array[i].MnbcSoundNum != 10) || //received in CM_START_ATTEN_CHAR_IND
-						(SLAC_INFO.array[i].StartAttenCharErr == TRUE)
-					   )
-					{
-						//Ignoring those SLAC request sets without sending CM_MNBC_SOUND_IND(CM_ATTEN_PROFILE_IND)
-						DEBUG_WARN("[SLAC][TX]CM_ATTEN_CHAR_IND[%d]: para err(%d,%d,%d,%d,%d) => canceled\n",
-								(i + 1), SLAC_INFO.array[i].AttenProfileCnt, SLAC_INFO.array[i].AagGroupsNum, SLAC_INFO.array[i].StartAttenCharCnt, SLAC_INFO.array[i].MnbcSoundNum, SLAC_INFO.array[i].StartAttenCharErr);
-						continue;
-					}
-
-					//In CM_ATTEN_CHAR_IND retry process, here only re-send this message according to the 1st coming SLAC request
-					if ((EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry > 0) && (i != 0))
-					{
-						DEBUG_INFO("[SLAC][TX]CM_ATTEN_CHAR_IND[%d]: canceled\n", (i + 1));
-						break;
-					}
-
-					EvMac_in = SLAC_INFO.array[i].EvMac;
-					RunID_in = SLAC_INFO.array[i].RunID;
-
-					memset(&qcaInfo.SendMmePacket, 0, sizeof(struct MmeHeader));
-					memcpy(qcaInfo.SendMmePacket.ODA, EvMac_in, SLAC_EVMAC_LENGTH);
-					memcpy(qcaInfo.SendMmePacket.OSA, macAddr.eth1, 6);
-					qcaInfo.SendMmePacket.MTYPE = htons(EtherType_HomePlug);
-					qcaInfo.SendMmePacket.MMV = 0x01;
-					qcaInfo.SendMmePacket.MMTYPE = MMTYPE_CM_ATTEN_CHAR_IND;
-					qcaInfo.SendMmePacket.FMI[0] = qcaInfo.SendMmePacket.FMI[1] = 0;
-					qcaInfo.SendMmePacketSize = 0;
-					qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0;    //APPLICATION_TYPE(0x00: EV-EVSE Matching)
-					qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = 0;    //SECURITY_TYPE(0x00: No Security)
-					memcpy(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, EvMac_in, SLAC_EVMAC_LENGTH); //SOURCE_ADDRESS, MAC address of the EV Host
-					qcaInfo.SendMmePacketSize += SLAC_EVMAC_LENGTH;
-					memcpy(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, RunID_in, SLAC_RUNID_LENGTH);
-					qcaInfo.SendMmePacketSize += SLAC_RUNID_LENGTH;
-					memset(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, 0, 17); //SOURCE_ID(0x00)
-					qcaInfo.SendMmePacketSize += 17;
-					memset(qcaInfo.SendMmePacket.MMENTRY + qcaInfo.SendMmePacketSize, 0, 17); //RESP_ID(0x00)
-					qcaInfo.SendMmePacketSize += 17;
-					qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = SLAC_INFO.array[i].AttenProfileCnt; //NumSounds: Number of M-Sounds used for generation of the ATTEN_PROFILE
-					qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = SLAC_INFO.array[i].AagGroupsNum;    //NumGroups
-
-					for(count = 0; count < SLAC_INFO.array[i].AagGroupsNum; count++)
-					{
-						unsigned char TmpAag;
-						TmpAag = ((SLAC_INFO.array[i].AAG[count] / SLAC_INFO.array[i].AttenProfileCnt) & 0xFF);
-						SLAC_INFO.array[i].AAG_quality_ori += (float) TmpAag;   //original signal quality
-
-						#if (SUDO_PSD_PARAMETER_MECHANISM == ENABLE)    //default: ENABLE
-							#if 1
-							//TC_SECC_VTB_AttenuationCharacterization_019
-							TmpAag = TmpAag >> 1;   //new method proposed by Joseph (divided by 2)
-							#else
-							if(TmpAag >= 39)        //original method proposed by Vern
-							{
-								TmpAag = 37;
-							}
-							#endif
-						#endif
-						qcaInfo.SendMmePacket.MMENTRY[qcaInfo.SendMmePacketSize++] = TmpAag;
-						SLAC_INFO.array[i].AAG_quality_refined += (float) TmpAag;   //refined signal quality
-					}
-					qcaInfo.SendMmePacketSize += 19;      //the size before MMENTRY
-
-
-					DEBUG_PRINTF_EVCOMM_DETAIL("***** Send MME Packet *****\n");
-					DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.ODA: %02x:%02x:%02x:%02x:%02x:%02x:\n", qcaInfo.SendMmePacket.ODA[0],qcaInfo.SendMmePacket.ODA[1],qcaInfo.SendMmePacket.ODA[2],qcaInfo.SendMmePacket.ODA[3],qcaInfo.SendMmePacket.ODA[4],qcaInfo.SendMmePacket.ODA[5]);
-					DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.OSA: %02x:%02x:%02x:%02x:%02x:%02x:\n", qcaInfo.SendMmePacket.OSA[0],qcaInfo.SendMmePacket.OSA[1],qcaInfo.SendMmePacket.OSA[2],qcaInfo.SendMmePacket.OSA[3],qcaInfo.SendMmePacket.OSA[4],qcaInfo.SendMmePacket.OSA[5]);
-					DEBUG_PRINTF_EVCOMM_DETAIL("MTYPE: 0x%x\n", htons(qcaInfo.SendMmePacket.MTYPE));
-					DEBUG_PRINTF_EVCOMM_DETAIL("MMV: 0x%x\n", qcaInfo.SendMmePacket.MMV);
-					DEBUG_PRINTF_EVCOMM_DETAIL("MMTYPE: 0x%x\n", qcaInfo.SendMmePacket.MMTYPE);
-					DEBUG_PRINTF_EVCOMM_DETAIL("FMI 0x%x, 0x%x\n", qcaInfo.SendMmePacket.FMI[0],qcaInfo.SendMmePacket.FMI[1]);
-					DEBUG_PRINTF_EVCOMM_DETAIL("--- CM_ATTEN_CHAR_IND ---\n");
-					DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", qcaInfo.SendMmePacket.MMENTRY[0]);
-					DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", qcaInfo.SendMmePacket.MMENTRY[1]);
-					DEBUG_PRINTF_EVCOMM_DETAIL("SOURCE_ADDRESS: %02x:%02x:%02x:%02x:%02x:%02x\n", qcaInfo.SendMmePacket.MMENTRY[2],qcaInfo.SendMmePacket.MMENTRY[3],qcaInfo.SendMmePacket.MMENTRY[4],qcaInfo.SendMmePacket.MMENTRY[5],qcaInfo.SendMmePacket.MMENTRY[6],qcaInfo.SendMmePacket.MMENTRY[7]);
-					DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n", qcaInfo.SendMmePacket.MMENTRY[8],qcaInfo.SendMmePacket.MMENTRY[9],qcaInfo.SendMmePacket.MMENTRY[10],qcaInfo.SendMmePacket.MMENTRY[11],qcaInfo.SendMmePacket.MMENTRY[12],qcaInfo.SendMmePacket.MMENTRY[13],qcaInfo.SendMmePacket.MMENTRY[14],qcaInfo.SendMmePacket.MMENTRY[15]);
-
-					memset(tmpBuf, 0x00, ARRAY_SIZE(tmpBuf));
-					for(count=0; count<17; count++)
-					{
-						sprintf((char*)tmpBuf, "%s%02x,", tmpBuf, qcaInfo.SendMmePacket.MMENTRY[16+count]);
-					}
-					DEBUG_PRINTF_EVCOMM_DETAIL("SOURCE_ID: %s\n", tmpBuf);
-
-					memset(tmpBuf, 0x00, ARRAY_SIZE(tmpBuf));
-					for(count=0; count<17; count++)
-					{
-						sprintf((char*)tmpBuf, "%s%02x,", tmpBuf, qcaInfo.SendMmePacket.MMENTRY[33+count]);
-					}
-					DEBUG_PRINTF_EVCOMM_DETAIL("RESP_ID: %s\n", tmpBuf);
-
-					DEBUG_PRINTF_EVCOMM_DETAIL("NumSounds: 0x%x\n", qcaInfo.SendMmePacket.MMENTRY[50]);
-
-					memset(tmpBuf, 0x00, ARRAY_SIZE(tmpBuf));
-					for(count=0; count<qcaInfo.AagGroupsNum; count++)
-					{
-						sprintf((char*)tmpBuf, "%s%02x,", tmpBuf, qcaInfo.SendMmePacket.MMENTRY[51+count]);
-					}
-					DEBUG_PRINTF_EVCOMM_DETAIL("ATTEN_PROFILE: %s\n", tmpBuf);
-
-					count = sendto(socketFd.Raw, &qcaInfo.SendMmePacket, qcaInfo.SendMmePacketSize, 0, (struct sockaddr*)&qcaInfo.DestSocketAddress, sizeof(struct sockaddr_ll));
-
-					SLAC_INFO.array[i].AAG_quality_ori /= SLAC_INFO.array[i].AagGroupsNum;
-					SLAC_INFO.array[i].AAG_quality_refined /= SLAC_INFO.array[i].AagGroupsNum;
-
-					//Print log if this CM_ATTEN_CHAR_IND belongs to RETRY Tx message.
-					if (EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry > 0)
-					{
-						DEBUG_INFO("[SLAC][TX]CM_ATTEN_CHAR_IND[%d]: %d-th resend (Q=%.2f/%.2f)(%d/%d)\n",
-																														(i + 1),
-																														EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry,
-																														SLAC_INFO.array[i].AAG_quality_refined,
-																														SLAC_INFO.array[i].AAG_quality_ori,
-																														SLAC_INFO.array[i].AttenProfileCnt,
-																														SLAC_INFO.array[i].MnbcSoundNum);
-					}
-					else if (EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry == 0)
-					{
-						DEBUG_INFO("[SLAC][TX]CM_ATTEN_CHAR_IND[%d]: Q=%.2f/%.2f(%d/%d)\n",
-																										(i + 1),
-																										SLAC_INFO.array[i].AAG_quality_refined,
-																										SLAC_INFO.array[i].AAG_quality_ori,
-																										SLAC_INFO.array[i].AttenProfileCnt,
-																										SLAC_INFO.array[i].MnbcSoundNum);
-					}
-					else
-					{
-						DEBUG_INFO("[SLAC][TX]CM_ATTEN_CHAR_IND[%d]: unexpected CM_ATTEN_CHAR_IND_retry(%d))\n", i, EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry);
-					}
-
-					DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacketSize=%d,Rtn=%d\n", qcaInfo.SendMmePacketSize, count);
-				} //end of for loop
-
-				Update_V2G_Status(CM_ATTEN_CHAR_IND);
-				ftime(&timerStart.SeqStart);
-			}
-			break;
-		}
-
-	    case CM_ATTEN_CHAR_IND:
-		{
-	        ftime(&timerStart.SeqEnd);
-	        //if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd)>TT_match_response)
-	        if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > TT_match_response)     //extended to 400ms due to the response of CM_ATTEN_CHAR.RSP of some EVCC is slower than 200ms.
-	        {
-	        	DEBUG_ERROR("SlacComm: Wait CM_ATTEN_CHAR_RSP Timeout - TT_match_response (%.02lf of %dms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), TT_match_response);
-
-                //Update_ShmStatusCode(); //[To-Do] to be implemented
-                //CCS_SECC_TIMEOUT_SLAC_CM_ATTEN_CHAR_RSP (023814):
-                //[Possible Reason] Frequent on BMW i3, need to drive the EV a bit.
-                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
-                ShmStatusCodeData->PresentStatusCode[0][5] = 4;
-                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = FALSE;
-                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-
-	            Update_V2G_Status(Sequence_Timeout);
-	            return -1;
-	        }
-	        break;
-		}
-
-	    case CM_ATTEN_CHAR_RSP:
-		{
-	        ftime(&timerStart.SeqEnd);
-	        if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > TT_EVSE_match_session)
-	        {
-	        	DEBUG_ERROR("SlacComm: Wait CM_VALIDATE_REQ_1ST or CM_SLAC_MATCH_REQ Timeout - TT_EVSE_match_session (%.02lf of %dms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), TT_EVSE_match_session);
-
-                //Update_ShmStatusCode(); //[To-Do] to be implemented
-                //CCS_SECC_TIMEOUT_SLAC_CM_VALIDATE_REQ_1ST__CM_SLAC_MATCH_REQ (023815):
-                //[Possible Reason] Frequent on BMW i3, need to drive the EV a bit.
-                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
-                ShmStatusCodeData->PresentStatusCode[0][5] = 5;
-                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = FALSE;
-                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-
-	            Update_V2G_Status(Sequence_Timeout);
-	            return -1;
-	        }
-	        break;
-		}
-
-	    case CM_VALIDATE_CNF:
-		{
-	        ftime(&timerStart.SeqEnd);
-	        if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > TT_match_sequence)
-	        {
-	        	DEBUG_ERROR("SlacComm: Wait CM_VALIDATE_REQ_2ND or CM_SLAC_MATCH_REQ Timeout - TT_match_sequence (%.02lf of %dms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), TT_match_sequence);
-
-                //Update_ShmStatusCode(); //[To-Do] to be implemented
-                //CCS_SECC_TIMEOUT_SLAC_CM_VALIDATE_REQ_2ND__CM_SLAC_MATCH_REQ (023819):
-                //[Possible Reason] Frequent on BMW i3, need to drive the EV a bit.
-                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
-                ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = FALSE;
-                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-
-	            Update_V2G_Status(Sequence_Timeout);
-	            return -1;
-	        }
-	        break;
-		}
-
-	    case CM_SLAC_MATCH_CNF:
-		{
-	        if(socketFd.Udp > 0)
-	        {
-	            close(socketFd.Udp);
-	            socketFd.Udp = -1;
-	        }
-	        if(socketFd.Tcp > 0)
-	        {
-	            close(socketFd.Tcp);
-	            socketFd.Tcp = -1;
-	        }
-	        ftime(&timerStart.SeqStart);
-            V2gTcpConnected();
-            Update_V2G_Status(SLACC_SDP_UDP_Connection);
-            DEBUG_INFO("SLAAC, SDP, UDP: connecting...\n");
-	        break;
-		}
-
-		default:
-		{
-		    break;
-		}
-    }
-    return 0;
-}
-
-/**
-*	1. Decode the V2GTP messages inside "msg" and save the decoded
-   	   messages in v2gObject.DIN, v2gObject.ISO1, and v2gObject.ISO2,
-   	   respectively.
-
-	2. After decoding, V2gMsg_Process() could then use
-	   v2gObject.DIN, v2gObject.ISO1, or v2gObject.ISO2
-   to deal with the corresponding Response messages, respectively.
- * @param msg
- * @param msg_length
- * @param v2g_state
- * @return
- */
-int V2gMsgDecoder(unsigned char *msg, unsigned int msg_length, unsigned int v2g_state)
-{
-    int errn = 0;
-
-    //Checking the minimum Header size requirement
-    if(msg_length < V2GTP_MSG_HEADER_LENGTH)   //The minimum requirement should be 8-byte header.
-    {
-        errn = -1;
-        return errn;
-    }
-
-    //Decode the 1st V2GMSG: AppProtocol
-    if(v2g_state == SupportedAppProtocolRequest)   //17
-    {
-        if ((errn = API_V2GMSG_EXI_Decoder_AppProtocol(msg, msg_length, &v2gObject.appHandshake)) < 0)
-        {
-            DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR = %d (DEC)]V2gMsgDecoder: SupportedAppProtocolRequest()\n", errn);
-        }
-        else    //decoded successfully.
-        {
-            //PRINT_XML_DOC_supportedAppProtocolReq(&v2gObject.appHandshake);
-        }
-    }
-    //Decode the subsequent V2GMSG (DIN 70121, ISO 15118-2, ISO 15118-20)
-    else if(v2g_state > SupportedAppProtocolRequest && v2g_state <= SessionStopResponse)
-    {
-        //Decoding according to its own protocol
-        switch (ShmCcsData->CommProtocol)
-        {
-            case V2GT_MSG_PROTOCOL_DIN70121:        //0
-            {
-                //DIN
-                if((errn = API_V2GMSG_EXI_Decoder_DIN(msg, msg_length, &v2gObject.DIN)) < 0)
-                {
-                	DEBUG_INFO("[ERROR = %d (DEC)]V2gMsgDecoder: API_V2GMSG_EXI_Decoder_DIN()\n", errn);
-                }
-                break;
-            }
-
-            case V2GT_MSG_PROTOCOL_ISO15118_2014:   //1
-            {
-                //ISO1
-                if((errn = API_V2GMSG_EXI_Decoder_ISO1(msg, msg_length, &v2gObject.ISO1)) < 0)
-                {
-                	DEBUG_INFO("[ERROR = %d (DEC)]V2gMsgDecoder: API_V2GMSG_EXI_Decoder_ISO1()\n", errn);
-                }
-                break;
-            }
-
-            case V2GT_MSG_PROTOCOL_ISO15118_2018:   //2
-            {
-                //ISO2
-                if((errn = API_V2GMSG_EXI_Decoder_ISO2(msg, msg_length, &v2gObject.ISO2)) < 0)
-                {
-                	DEBUG_INFO("[ERROR = %d (DEC)]V2gMsgDecoder: API_V2GMSG_EXI_Decoder_ISO2()\n", errn);
-                }
-                break;
-            }
-
-            default:
-                break;
-        }
-    }
-    else
-    {
-        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR = %d (DEC)]V2gMsgDecoder: Unexpected v2g_state\n", errn);
-        errn = -1;
-    }
-    return errn;
-}
-
-/**
- *
- * @param v2g_tx_stream
- * @param v2gObject
- * @return
- */
-int encode_din_V2GTP_stream(bitstream_t *v2g_tx_stream, struct dinEXIDocument *v2gObject)
-{
-    int errn = 0;
-    *v2g_tx_stream->pos = V2GTP_HEADER_LENGTH;
-
-    errn = encode_dinExiDocument(v2g_tx_stream, v2gObject);
-    if (errn == 0)
-    {
-        //successfully encoded
-        errn = write_v2gtpHeader(v2g_tx_stream->data, (*v2g_tx_stream->pos) - V2GTP_HEADER_LENGTH, V2GTP_EXI_TYPE);
-        v2g_tx_stream->size = *v2g_tx_stream->pos;	//total length of the encoded V2GMSG.
-
-        if (errn != 0)
-        {
-            DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm]write_v2gtpHeader(): %d (DEC)\n", errn);
-        }
-    }
-    else
-    {
-        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm]encode_dinExiDocument(): %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param v2g_tx_stream
- * @param v2gObject
- * @return
- */
-int encode_iso1_V2GTP_stream(bitstream_t *v2g_tx_stream, struct iso1EXIDocument *v2gObject)
-{
-    int errn = 0;
-    *v2g_tx_stream->pos = V2GTP_HEADER_LENGTH;
-
-    errn = encode_iso1ExiDocument(v2g_tx_stream, v2gObject);
-    if (errn == 0)
-    {
-        //successfully encoded
-        errn = write_v2gtpHeader(v2g_tx_stream->data, (*v2g_tx_stream->pos) - V2GTP_HEADER_LENGTH, V2GTP_EXI_TYPE);
-        v2g_tx_stream->size = *v2g_tx_stream->pos;	//total length of the encoded V2GMSG.
-
-        if (errn != 0)
-        {
-            DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm]write_v2gtpHeader(): %d (DEC)\n", errn);
-        }
-    }
-    else
-    {
-        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm]encode_iso1ExiDocument(): %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param v2g_tx_stream
- * @param v2gObject
- * @return
- */
-int encode_iso2_V2GTP_stream(bitstream_t *v2g_tx_stream, struct iso2EXIDocument *v2gObject)
-{
-    int errn = 0;
-    *v2g_tx_stream->pos = V2GTP_HEADER_LENGTH;
-
-    errn = encode_iso2ExiDocument(v2g_tx_stream, v2gObject);
-    if (errn == 0)
-    {
-        //successfully encoded
-        errn = write_v2gtpHeader(v2g_tx_stream->data, (*v2g_tx_stream->pos) - V2GTP_HEADER_LENGTH, V2GTP_EXI_TYPE);
-        v2g_tx_stream->size = *v2g_tx_stream->pos;	//total length of the encoded V2GMSG.
-
-        if (errn != 0)
-        {
-            DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm]write_v2gtpHeader(): %d (DEC)\n", errn);
-        }
-    }
-    else
-    {
-        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm]encode_iso2ExiDocument(): %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-
-/**
- *
- * @param AcceptFd
- * @param v2g_tx_stream
- * @param v2gObject
- * @return
- */
-int send_encoded_din_V2GTP_Stream(int AcceptFd, bitstream_t *v2g_tx_stream, struct dinEXIDocument *v2gObject)
-{
-    int errn = 0;
-
-    // STEP 1: =========== Encoding into EXI and Composing into V2GTP Stream ==========
-    errn = encode_din_V2GTP_stream(v2g_tx_stream, v2gObject);
-
-    // STEP 2: =========== Send Response Packet  ===========
-    int rtn = 0;
-    rtn = send(AcceptFd, v2g_tx_stream->data, v2g_tx_stream->size, 0);
-
-	if (rtn == v2g_tx_stream->size)
-    {
-        /*
-        DEBUG_PRINTF_EVCOMM_DETAIL("Response Message is sent ( %d / %d ). (Bytes, DEC): OK\n",
-                rtn, v2g_tx_stream->size);
-        */
-
-        //Reset all EXI doc Req/Res _isUsed Flags after each Res Tx
-
-    }
-    else if (rtn >= 0)
-    {
-        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR]Incomplete Tx ( %d / %d ). (Bytes, DEC): FAIL\n", rtn, v2g_tx_stream->size);
-    }
-    else
-    {
-        errn = rtn;
-        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR]send(): %d (DEC)\n", errn);
-    }
-
-    //STEP 3: ========= Reset V2G MSG Flags ==========
-    init_dinBodyType(&v2gObject->V2G_Message.Body);
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @param v2g_tx_stream
- * @param v2gObject
- * @return
- */
-int send_encoded_iso1_V2GTP_Stream(int AcceptFd, bitstream_t *v2g_tx_stream, struct iso1EXIDocument *v2gObject)
-{
-    int errn = 0;
-
-    // STEP 1: =========== Encoding into EXI and Composing into V2GTP Stream ==========
-    errn = encode_iso1_V2GTP_stream(v2g_tx_stream, v2gObject);
-
-    // STEP 2: =========== Send Response Packet  ===========
-    int rtn = 0;
-    rtn = send(AcceptFd, v2g_tx_stream->data, v2g_tx_stream->size, 0);
-
-	if (rtn == v2g_tx_stream->size)
-    {
-        //DEBUG_PRINTF_EVCOMM_DETAIL("Response message sent (%d/%d)(Bytes, DEC): OK\n", rtn, v2g_tx_stream->size);
-
-        //Reset all EXI doc Req/Res _isUsed Flags after each Res Tx
-
-    }
-    else if (rtn >= 0)
-    {
-        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR]Incomplete Tx (%d/%d)(Bytes, DEC): FAIL\n", rtn, v2g_tx_stream->size);
-    }
-    else
-    {
-        errn = rtn;
-        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR]send(): %d(DEC)\n", errn);
-    }
-
-    //STEP 3: ========= Reset V2G MSG Flags ==========
-    init_iso1BodyType(&v2gObject->V2G_Message.Body);
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @param v2g_tx_stream
- * @param v2gObject
- * @return
- */
-int send_encoded_iso2_V2GTP_Stream(int AcceptFd, bitstream_t *v2g_tx_stream, struct iso2EXIDocument *v2gObject)
-{
-    int errn = 0;
-
-    // STEP 1: =========== Encoding into EXI and Composing into V2GTP Stream ==========
-    errn = encode_iso2_V2GTP_stream(v2g_tx_stream, v2gObject);
-
-    // STEP 2: =========== Send Response Packet  ===========
-    int rtn = 0;
-    rtn = send(AcceptFd, v2g_tx_stream->data, v2g_tx_stream->size, 0);
-
-	if (rtn == v2g_tx_stream->size)
-    {
-        /*
-        DEBUG_PRINTF_EVCOMM_DETAIL("Response Message is sent ( %d / %d ). (Bytes, DEC): OK\n",
-                rtn, v2g_tx_stream->size);
-        */
-
-        //Reset all EXI doc Req/Res _isUsed Flags after each Res Tx
-
-    }
-    else if (rtn >= 0)
-    {
-        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR]Incomplete Tx ( %d / %d ). (Bytes, DEC): FAIL\n",
-                                    rtn, v2g_tx_stream->size);
-    }
-    else
-    {
-        errn = rtn;
-        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR]send(): %d (DEC)\n", errn);
-    }
-
-    //STEP 3: ========= Reset V2G MSG Flags ==========
-    init_iso2BodyType(&v2gObject->V2G_Message.Body);
-    return errn;
-}
-
-/**
- *
- * @param exi_doc_DIN
- * @return
- */
-int Check_din_V2G_Rx_MSG_SessionID(struct dinEXIDocument *exi_doc_DIN)
-{
-    int i = 0;
-    int leng = 0;
-    int errn = 0;
-    leng = exi_doc_DIN->V2G_Message.Header.SessionID.bytesLen;
-
-    //Step 1: Check SessionID Length
-    if (leng != 8)  //8-byte
-    {
-    	DEBUG_ERROR("SessionID: incorrect length(%d)\n", leng);
-        errn = -1;
-    }
-    else
-    {
-        //Step 2-1: Check SessionID content
-        for (i = 0; i < leng; i++)
-        {
-            if (exi_doc_DIN->V2G_Message.Header.SessionID.bytes[i] != EVCOMM_SYS_INFO.SessionID[i])
-            {
-                errn = -2;
-                break;
-            }
-        }
-    }
-
-    //Step 2-2: Print Incorrect ID
-    if (errn == -2) //incorrect ID
-    {
-    	DEBUG_ERROR("SessionID: incorrect ID(RX:%02X%02X%02X%02X%02X%02X%02X%02X, ORI:%02X%02X%02X%02X%02X%02X%02X%02X)\n",
-					exi_doc_DIN->V2G_Message.Header.SessionID.bytes[0],
-					exi_doc_DIN->V2G_Message.Header.SessionID.bytes[1],
-					exi_doc_DIN->V2G_Message.Header.SessionID.bytes[2],
-					exi_doc_DIN->V2G_Message.Header.SessionID.bytes[3],
-					exi_doc_DIN->V2G_Message.Header.SessionID.bytes[4],
-					exi_doc_DIN->V2G_Message.Header.SessionID.bytes[5],
-					exi_doc_DIN->V2G_Message.Header.SessionID.bytes[6],
-					exi_doc_DIN->V2G_Message.Header.SessionID.bytes[7],
-					EVCOMM_SYS_INFO.SessionID[0],
-					EVCOMM_SYS_INFO.SessionID[1],
-					EVCOMM_SYS_INFO.SessionID[2],
-					EVCOMM_SYS_INFO.SessionID[3],
-					EVCOMM_SYS_INFO.SessionID[4],
-					EVCOMM_SYS_INFO.SessionID[5],
-					EVCOMM_SYS_INFO.SessionID[6],
-					EVCOMM_SYS_INFO.SessionID[7]);
-    }
-
-    //Step 3: Correct SessionID for Res Message
-    if (errn != 0)
-    {
-        exi_doc_DIN->V2G_Message.Header.SessionID.bytesLen = 8;
-        memset(exi_doc_DIN->V2G_Message.Header.SessionID.bytes, 0, 8);
-        memcpy(exi_doc_DIN->V2G_Message.Header.SessionID.bytes, EVCOMM_SYS_INFO.SessionID, 8);
-    }
-
-    return errn;
-}
-
-/**
- *
- * @param exi_doc_ISO1
- * @return
- */
-int Check_iso1_V2G_Rx_MSG_SessionID(struct iso1EXIDocument *exi_doc_ISO1)
-{
-    int i = 0;
-    int leng = 0;
-    int errn = 0;
-    leng = exi_doc_ISO1->V2G_Message.Header.SessionID.bytesLen;
-
-    //Step 1: Check SessionID Length
-    if (leng != 8)  //8-byte
-    {
-        DEBUG_ERROR("SessionID: incorrect length(%d)\n", leng);
-        errn = -1;
-    }
-    else
-    {
-        //Step 2-1: Check SessionID content
-        for (i = 0; i < leng; i++)
-        {
-            if (exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[i] != EVCOMM_SYS_INFO.SessionID[i])
-            {
-                errn = -2;
-                break;
-            }
-        }
-    }
-
-    //Step 2-2: Print Incorrect ID
-    if (errn == -2) //incorrect ID
-    {
-    	DEBUG_ERROR("SessionID: incorrect ID (RX:%02X%02X%02X%02X%02X%02X%02X%02X, ORI:%02X%02X%02X%02X%02X%02X%02X%02X)\n",
-					exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[0],
-					exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[1],
-					exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[2],
-					exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[3],
-					exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[4],
-					exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[5],
-					exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[6],
-					exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[7],
-					EVCOMM_SYS_INFO.SessionID[0],
-					EVCOMM_SYS_INFO.SessionID[1],
-					EVCOMM_SYS_INFO.SessionID[2],
-					EVCOMM_SYS_INFO.SessionID[3],
-					EVCOMM_SYS_INFO.SessionID[4],
-					EVCOMM_SYS_INFO.SessionID[5],
-					EVCOMM_SYS_INFO.SessionID[6],
-					EVCOMM_SYS_INFO.SessionID[7]);
-    }
-
-    //Step 3: Correct SessionID for Res Message
-    if (errn != 0)
-    {
-        exi_doc_ISO1->V2G_Message.Header.SessionID.bytesLen = 8;
-        memset(exi_doc_ISO1->V2G_Message.Header.SessionID.bytes, 0, 8);
-        memcpy(exi_doc_ISO1->V2G_Message.Header.SessionID.bytes, EVCOMM_SYS_INFO.SessionID, 8);
-    }
-
-    return errn;
-}
-
-/**
- *
- * @param exi_doc_ISO2
- * @return
- */
-int Check_iso2_V2G_Rx_MSG_SessionID(struct iso2EXIDocument *exi_doc_ISO2)
-{
-    int i = 0;
-    int leng = 0;
-    int errn = 0;
-    leng = exi_doc_ISO2->V2G_Message.Header.SessionID.bytesLen;
-
-    //Step 1: Check SessionID Length
-    if (leng != 8)  //8-byte
-    {
-    	DEBUG_ERROR("SessionID: incorrect length(%d)\n", leng);
-        errn = -1;
-    }
-    else
-    {
-        //Step 2-1: Check SessionID content
-        for (i = 0; i < leng; i++)
-        {
-            if (exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[i] != EVCOMM_SYS_INFO.SessionID[i])
-            {
-                errn = -2;
-                break;
-            }
-        }
-    }
-
-    //Step 2-2: Print Incorrect ID
-    if (errn == -2) //incorrect ID
-    {
-    	DEBUG_ERROR("SessionID: incorrect ID(RX:%02X%02X%02X%02X%02X%02X%02X%02X, ORI:%02X%02X%02X%02X%02X%02X%02X%02X)\n",
-					exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[0],
-					exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[1],
-					exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[2],
-					exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[3],
-					exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[4],
-					exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[5],
-					exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[6],
-					exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[7],
-					EVCOMM_SYS_INFO.SessionID[0],
-					EVCOMM_SYS_INFO.SessionID[1],
-					EVCOMM_SYS_INFO.SessionID[2],
-					EVCOMM_SYS_INFO.SessionID[3],
-					EVCOMM_SYS_INFO.SessionID[4],
-					EVCOMM_SYS_INFO.SessionID[5],
-					EVCOMM_SYS_INFO.SessionID[6],
-					EVCOMM_SYS_INFO.SessionID[7]);
-    }
-
-    //Step 3: Correct SessionID for Res Message
-    if (errn != 0)
-    {
-        exi_doc_ISO2->V2G_Message.Header.SessionID.bytesLen = 8;
-        memset(exi_doc_ISO2->V2G_Message.Header.SessionID.bytes, 0, 8);
-        memcpy(exi_doc_ISO2->V2G_Message.Header.SessionID.bytes, EVCOMM_SYS_INFO.SessionID, 8);
-    }
-
-    return errn;
-}
-
-/**
-*   1. Get the SchemaID accroding to the input target
-        *V2GT_MSG_PROTOCOL_DIN70121: choose DIN 70121
-        *V2GT_MSG_PROTOCOL_ISO15118_2014: choose ISO 15118-2 (ed1)
-        *V2GT_MSG_PROTOCOL_ISO15118_2018: choose ISO 15118-20 (ed2)
-        *V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY: choose the one with the highest priority
-
-    2. [To-do] Checking Major and Minor version
-    3. The parsing method will not support those private protocols,
-       such as "usr:tesla...," since "tesla" is 5 bytes but "din" and "iso" are 3 bytes.
-
-    4. [To-do] If the target is selected as DIN," but there is no DIN.
-               However, if EV and EVSE all support ISO, how to use ISO instead?
- * @param target
- * @return
- */
-int GetSchemaID_of_Protocol(unsigned char target)
-{
-    int i = 0;
-    int ii = 0;
-    int id = 0;
-    unsigned char pri = 20; //priority = 1(highest)~20(lowerest)
-    char num[10];
-
-    //Choose the 1st protocol as default.
-    id = -1;
-    ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_DIN70121;
-    for(i = 0; i < CCS_HANDSHAKE_PROTOCOLS.arrayLen; i++)
-    {
-        //Checking for <ProtocolNamespace>urn:din:70121:2012:MsgDef</ProtocolNamespace>
-        //[To-Do] Ignoring the priority from EV and force DIN 70121 as our only option. (for temp)
-
-        //[CAUTION] The parsing method will not support those private protocols, such as "usr:tesla..."
-        num[0] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[8];
-        num[1] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[9];
-        num[2] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[10];
-        num[3] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[11];
-        num[4] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[12];
-        num[5] = '\0';
-
-        if (atoi(num) == 70121)
-        {
-        	DEBUG_INFO("support(%d/%d): DIN 70121(%d:v%d.%d;id=%d,pri=%d)\n",
-						(i+1),
-						CCS_HANDSHAKE_PROTOCOLS.arrayLen,
-						atoi(num),
-						CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
-						CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
-						CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
-						CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
-
-            if (target == V2GT_MSG_PROTOCOL_DIN70121)
-            {
-            	DEBUG_INFO("select(%d/%d): DIN 70121(%d:v%d.%d;id=%d,pri=%d)\n",
-							(i+1),
-							CCS_HANDSHAKE_PROTOCOLS.arrayLen,
-							atoi(num),
-							CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
-							CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
-							CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
-							CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
-
-                if (CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor == DIN_SPEC_70121_2012_VersionNumberMajor)
-                {
-                    if (CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor == DIN_SPEC_70121_2012_VersionNumberMinor)
-                    {
-                        EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_OK_SuccessfulNegotiation;
-                    }
-                    else
-                    {   //[TC_SECC_VTB_SupportedAppProtocol_005]
-                        EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_OK_SuccessfulNegotiationWithMinorDeviation;
-                    }
-                    id = CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID;
-                    ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_DIN70121;
-                    return id;
-                }
-                else
-                {
-                    //keep looking for the suitable protocol
-                }
-            }
-            else if (target == V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY)
-            {
-                if (pri > CCS_HANDSHAKE_PROTOCOLS.array[i].Priority)
-                {
-                    ii = i;
-                    id = CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID;
-                    pri = CCS_HANDSHAKE_PROTOCOLS.array[i].Priority;
-                    ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_DIN70121;
-                }
-                else
-                {
-                    //not using this SchemaID, and keep looking for that SchemaID with higer priority
-                }
-            }
-            else
-            {
-                //null
-            }
-        }
-        else if (atoi(num) == 15118)
-        {
-            //urn:din:70121:2012:MsgDef
-            //urn:iso:15118:2:2013:MsgDef
-            memset(num, 0, sizeof(num));
-            num[0] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[16];
-            num[1] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[17];
-            num[2] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[18];
-            num[3] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[19];
-            num[4] = '\0';
-
-            if (atoi(num) < 2018 && atoi(num) >= 2010)
-            {
-            	DEBUG_INFO("support(%d/%d): ISO 15118-2(ed1,%d:v%d.%d;id=%d,pri=%d)\n",
-							(i+1),
-							CCS_HANDSHAKE_PROTOCOLS.arrayLen,
-							atoi(num),
-							CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
-							CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
-							CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
-							CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
-
-                if (target == V2GT_MSG_PROTOCOL_ISO15118_2014)
-                {
-                	DEBUG_INFO("select(%d/%d): ISO 15118-2,ed1(%d:v%d.%d;id=%d,pri=%d)\n",
-								(i+1),
-								CCS_HANDSHAKE_PROTOCOLS.arrayLen,
-								atoi(num),
-								CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
-								CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
-								CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
-								CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
-
-                    if (CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor == ISO1_15118_2013_VersionNumberMajor)
-                    {
-                        if (CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor == ISO1_15118_2013_VersionNumberMinor)
-                        {
-                            EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_OK_SuccessfulNegotiation;
-                        }
-                        else
-                        {
-                            EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_OK_SuccessfulNegotiationWithMinorDeviation;
-                        }
-                        id = CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID;
-                        ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_ISO15118_2014;
-                        return id;
-                    }
-                    else
-                    {
-                        //keep looking for the suitable protocol
-                    }
-                }
-                else if (target == V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY)
-                {
-                    if (pri > CCS_HANDSHAKE_PROTOCOLS.array[i].Priority)
-                    {
-                        ii = i;
-                        id = CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID;
-                        pri = CCS_HANDSHAKE_PROTOCOLS.array[i].Priority;
-                        ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_ISO15118_2014;
-                    }
-                    else
-                    {
-                        //not using this SchemaID, and keep looking for that SchemaID with higer priority
-                    }
-                }
-                else
-                {
-                    //null
-                }
-            }
-            else if (atoi(num) >= 2018 && atoi(num) <= 2100)    // >= 2018
-            {
-            	DEBUG_INFO("support(%d/%d): ISO 15118-20(ed2,%d:v%d.%d;id=%d,pri=%d)\n",
-							(i+1),
-							CCS_HANDSHAKE_PROTOCOLS.arrayLen,
-							atoi(num),
-							CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
-							CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
-							CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
-							CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
-
-                if (target == V2GT_MSG_PROTOCOL_ISO15118_2018)
-                {
-                	DEBUG_INFO("select(%d/%d): ISO 15118-20,ed2(%d:v%d.%d;id=%d,pri=%d)\n",
-								(i+1),
-								CCS_HANDSHAKE_PROTOCOLS.arrayLen,
-								atoi(num),
-								CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
-								CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
-								CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
-								CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
-
-                    if (CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor == ISO2_15118_2018_VersionNumberMajor)
-                    {
-                        if (CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor == ISO2_15118_2018_VersionNumberMinor)
-                        {
-                            EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_OK_SuccessfulNegotiation;
-                        }
-                        else
-                        {
-                            EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_OK_SuccessfulNegotiationWithMinorDeviation;
-                        }
-                        id = CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID;
-                        ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_ISO15118_2018;
-                        return id;
-                    }
-                    else
-                    {
-                        //keep looking for the suitable protocol
-                    }
-                }
-                else if (target == V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY)
-                {
-                    if (pri > CCS_HANDSHAKE_PROTOCOLS.array[i].Priority)
-                    {
-                        ii = i;
-                        id = CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID;
-                        pri = CCS_HANDSHAKE_PROTOCOLS.array[i].Priority;
-                        ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_ISO15118_2018;
-                    }
-                    else
-                    {
-                        //not using this SchemaID, and keep looking for that SchemaID with higer priority
-                    }
-                }
-                else
-                {
-                    //null
-                }
-            }
-            else
-            {
-                //Unexpected Year
-            	DEBUG_INFO("unsupport(%d/%d): ISO 15118-X(unexpected year:%d,v%d.%d),id=%d,pri=%d\n",
-							(i+1),
-							CCS_HANDSHAKE_PROTOCOLS.arrayLen,
-							atoi(num),
-							CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
-							CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
-							CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
-							CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
-            }
-        }
-        else
-        {
-        	DEBUG_INFO("unsupport protocol(%d/%d)(%d:v%d.%d;id=%d,pri=%d)\n",
-						(i+1),
-						CCS_HANDSHAKE_PROTOCOLS.arrayLen,
-						atoi(num),
-						CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
-						CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
-						CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
-						CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
-        }
-    }
-
-    //The final result of highest priority protocol
-    DEBUG_INFO("select(%d/%d): pro=%d(0:DIN,1:ISO1,2:ISO2);id=%d,pri=%d\n",
-				(ii+1),
-				CCS_HANDSHAKE_PROTOCOLS.arrayLen,
-				ShmCcsData->CommProtocol,
-				id,
-				pri);
-
-    if (id < 0)
-    {
-        EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_Failed_NoNegotiation;
-    }
-
-    return id;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_supportedAppProtocolRes(int AcceptFd)
-{
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct ChargingInfoData *sys;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    //STEP 1: =========== Setting the Response Message ===========
-	init_appHandEXIDocument(&v2gObject.appHandshake);
-    v2gObject.appHandshake.supportedAppProtocolRes.ResponseCode = appHandresponseCodeType_OK_SuccessfulNegotiation;
-	v2gObject.appHandshake.supportedAppProtocolRes_isUsed = 1u;
-
-    //select the 1st one as the default
-    v2gObject.appHandshake.supportedAppProtocolRes.SchemaID = CCS_HANDSHAKE_PROTOCOLS.array[0].SchemaID;
-    v2gObject.appHandshake.supportedAppProtocolRes.SchemaID_isUsed = 1u;
-    int id = 0;
-    /*+++ 20200808, vern, support both DIN and ISO +++*/
-    //id = GetSchemaID_of_Protocol(V2GT_MSG_PROTOCOL_PREFERENCE); //output: EVCOMM_SYS_INFO.SupportedAppProtocol_result
-    id = GetSchemaID_of_Protocol(V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY); //output: EVCOMM_SYS_INFO.SupportedAppProtocol_result
-    /*--- 20200808, vern, support both DIN and ISO ---*/
-    v2gObject.appHandshake.supportedAppProtocolRes.ResponseCode = EVCOMM_SYS_INFO.SupportedAppProtocol_result;   //updating the response code
-    if (id < 0)
-    {
-    	DEBUG_ERROR("No available CCS protocol (id = %d, preference = %d)\n", id, V2GT_MSG_PROTOCOL_PREFERENCE);
-    }
-    else
-    {
-        //selected SchemaID
-        v2gObject.appHandshake.supportedAppProtocolRes.SchemaID = (unsigned char) id;
-    }
-
-
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        DEBUG_INFO("EVSE_Shutdown => End_Process\n");
-        v2gObject.appHandshake.supportedAppProtocolRes.ResponseCode = appHandresponseCodeType_Failed_NoNegotiation;
-        errn = -1;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        DEBUG_INFO("EVSE_EmergencyShutdown => End_Process\n");
-        v2gObject.appHandshake.supportedAppProtocolRes.ResponseCode = appHandresponseCodeType_Failed_NoNegotiation;
-        errn = -1;
-    }
-    else
-    {
-        //null
-    }
-
-    //Check for Permission Changing from TRUE to FALSE
-    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
-    if (ShmInternalComm->ChargingPermission_pre >= 1 &&
-        ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("[DIN][supportedAppProtocolRes]Permission OFF\n");
-        v2gObject.appHandshake.supportedAppProtocolRes.ResponseCode = appHandresponseCodeType_Failed_NoNegotiation;
-        //errn = -1;
-    }
-
-    #if (CP_PROTECTION_MECHANISM == ENABLE)
-    {
-        #if (SLAC_FIRST_RESPONSE_METHOD == SET_5_PWM_ONCE_GET_PERMISSION_IN_AUTHORIZATIONRES)
-        {
-            //Detect for CP State should be 9V with 5% PWM or 100%PWM (State B1, B2)
-            if (sys->CpState != 2 && sys->CpState != 3)  //State B1, B2
-            {
-                v2gObject.appHandshake.supportedAppProtocolRes.ResponseCode = appHandresponseCodeType_Failed_NoNegotiation;
-                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-                Update_V2G_Status(Other_Fault);
-                DEBUG_INFO("Emergency Stop by CP Error (%d, %.02f V)\n",
-										sys->CpState,
-										sys->CpVoltage);
-            }
-        }
-        #else
-        {
-            //Detect for CP State should be 9V (State B)
-            if (sys->CpState != 3)  //B2
-            {
-                v2gObject.appHandshake.supportedAppProtocolRes.ResponseCode = appHandresponseCodeType_Failed_NoNegotiation;
-                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-                Update_V2G_Status(Other_Fault);
-                DEBUG_INFO("Emergency Stop by CP Error (%d, %.02f V)\n",
-										sys->CpState,
-										sys->CpVoltage);
-            }
-        }
-        #endif
-    }
-    #endif
-
-
-    //STEP 2: =========== Encode into EXI ===========
-    if ((errn = API_V2GMSG_EXI_Encoder_AppProtocol(&v2gObject.appHandshake, &v2g_tx_stream)) !=0)
-    {
-        DEBUG_PRINTF_EVCOMM_DETAIL("[Error]API_V2GMSG_EXI_Encoder_AppProtocol\n");
-        return errn;
-    }
-
-    //STEP 3: =========== Send Response Packet ===========
-    int Rtn = 0;
-	Rtn = send(AcceptFd, v2g_tx_stream.data, v2g_tx_stream.size, 0);
-    //Rtn = send(6, v2g_tx_stream.data, v2g_tx_stream.size, 0);
-
-    DEBUG_PRINTF_EVCOMM_DETAIL("Send V2GTP Packet Size = %d, Rtn = %d (Bytes, DEC)\n", v2g_tx_stream.size, Rtn);
-
-    if (Rtn < 0)
-    {
-        return Rtn;
-    }
-
-    //STEP 4: =========== Save into Share Memory =========
-	//[ To-Do] Adding a mechanism to choose DIN 70121 as our 1st priority. (for multiple protocols)
-
-    //STEP 5: =========== Updating the Flow State Flag =========
-    if (id < 0)
-    {
-        errn = -1;
-    }
-
-    //STEP 6: ===========  Reset Flags ============
-    //Reset all EXI doc Req/Res _isUsed Flags after each Res Tx
-    init_appHandEXIDocument(&v2gObject.appHandshake);
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_supportedAppProtocolReq(int AcceptFd)
-{
-    //[ To-Do] analysis on Req message and choose the prefered protocol
-    //Default: DIN 70121 (find SchemaID)
-    int errn = 0;
-
-    DEBUG_INFO("Request in.\n");
-    SHM_Save_din_supportedAppProtocolReq(ShmCcsData, &v2gObject.appHandshake, ShmSysConfigAndInfo);
-
-    errn = Proc_supportedAppProtocolRes(AcceptFd);
-    if (errn == 0)
-    {
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-        DEBUG_ERROR("Proc_supportedAppProtocolRes(): %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_SessionSetupRes(int AcceptFd)
-{
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct ChargingInfoData *sys;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-
-    init_dinBodyType(&v2gObject.DIN.V2G_Message.Body);
-    init_dinSessionSetupResType(&v2gObject.DIN.V2G_Message.Body.SessionSetupRes);
-
-
-    // ====== [BODY (1/2) ResponseCode ======
-    v2gObject.DIN.V2G_Message.Body.SessionSetupRes_isUsed = 1u;
-    v2gObject.DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = dinresponseCodeType_OK_NewSessionEstablished;
-
-
-    //[HEADER] Assign Res SessionID
-    v2gObject.DIN.V2G_Message.Header.SessionID.bytesLen = 8;
-    memset(v2gObject.DIN.V2G_Message.Header.SessionID.bytes, 0, 8);
-    memcpy(v2gObject.DIN.V2G_Message.Header.SessionID.bytes, EVCOMM_SYS_INFO.SessionID, 8);
-
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        v2gObject.DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = dinresponseCodeType_FAILED_SequenceError;
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //#if PARAMETER_NORMAL_MODE == ENABLE
-    //SHM_Read_din_V2GMSG_Header(&v2gObject.DIN, ShmCcsData);
-    //#endif
-
-
-    //Detect for CP State should be 9V (State B)
-    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
-    {
-	#if CP_PROTECTION_MECHANISM == ENABLE
-        v2gObject.DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = dinresponseCodeType_FAILED;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-
-        DEBUG_INFO("Emergency Stop by CP Error (%d)\n", sys->CpState);
-	#else
-        DEBUG_INFO("Emergency Stop by CP Error (%d): ignored\n", sys->CpState);
-	#endif
-    }
-
-    //Check for shutdown commands from EVSE(DC Main Board)
-    if (sys->DC_EVSEStatus == EVSE_Shutdown ||
-        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        v2gObject.DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = dinresponseCodeType_FAILED;
-        DEBUG_INFO("Stop by EVSE(%d:normal, %d:emergency): (%d)\n", EVSE_Shutdown, EVSE_EmergencyShutdown, sys->DC_EVSEStatus);
-        errn = -1;
-    }
-
-    //Check for Permission Changing from TRUE to FALSE
-    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
-    if (ShmInternalComm->ChargingPermission_pre >= 1 &&
-        ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("[DIN]Permission OFF");
-        v2gObject.DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = dinresponseCodeType_FAILED;
-        errn = -1;
-    }
-
-    // ====== [BODY (2/3) EVSEID ======
-    //EVSEID = all zero
-    memset(v2gObject.DIN.V2G_Message.Body.SessionSetupRes.EVSEID.bytes, 0, sizeof(v2gObject.DIN.V2G_Message.Body.SessionSetupRes.EVSEID.bytes));
-    //vern, should be encode  by SN
-    v2gObject.DIN.V2G_Message.Body.SessionSetupRes.EVSEID.bytesLen = 1;  //max: DIN = 32, ISO1/ISO2 = 37 bytes
-
-    // ====== [BODY (3/3) DateTimeNow ======
-    v2gObject.DIN.V2G_Message.Body.SessionSetupRes.DateTimeNow_isUsed = 1u;
-    v2gObject.DIN.V2G_Message.Body.SessionSetupRes.DateTimeNow = (int64_t)time(NULL);   //[Joseph] Format: Unix Time Stamp
-
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    ///////////SHM_Read_din_SessionSetupRes(&v2gObject.DIN, ShmCcsData);
-    #endif
-
-    // ============ Encode and Send Response Message ===========
-    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.DIN) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    return errn;
-
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_SessionSetupRes(int AcceptFd)
-{
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct ChargingInfoData *sys;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-
-    init_iso1BodyType(&v2gObject.ISO1.V2G_Message.Body);
-    init_iso1SessionSetupResType(&v2gObject.ISO1.V2G_Message.Body.SessionSetupRes);
-
-    // ====== [BODY (1/2) ResponseCode ======
-    v2gObject.ISO1.V2G_Message.Body.SessionSetupRes_isUsed = 1u;
-    v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_OK_NewSessionEstablished;
-
-
-    //[HEADER] Assign Res SessionID
-    v2gObject.ISO1.V2G_Message.Header.SessionID.bytesLen = 8;
-    memset(v2gObject.ISO1.V2G_Message.Header.SessionID.bytes, 0, 8);
-    memcpy(v2gObject.ISO1.V2G_Message.Header.SessionID.bytes, EVCOMM_SYS_INFO.SessionID, 8);
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //#if PARAMETER_NORMAL_MODE == ENABLE
-    //SHM_Read_iso1_V2GMSG_Header(&v2gObject.ISO1, ShmCcsData);
-    //#endif
-
-    //Detect for CP State should be 9V (State B)
-    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
-    {
-	#if CP_PROTECTION_MECHANISM == ENABLE
-        v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_FAILED;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-
-        DEBUG_INFO("Emergency Stop by CP Error (%d)\n", sys->CpState);
-	#else
-        DEBUG_INFO("Emergency Stop by CP Error (%d): ignored\n", sys->CpState);
-	#endif
-    }
-
-    //Check for shutdown commands from EVSE(DC Main Board)
-    if (sys->DC_EVSEStatus == EVSE_Shutdown ||
-        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_FAILED;
-        DEBUG_INFO("Stop by EVSE(%d:normal, %d:emergency): (%d)\n",
-								EVSE_Shutdown,
-								EVSE_EmergencyShutdown,
-								sys->DC_EVSEStatus);
-        errn = -1;
-    }
-
-    //Check for Permission Changing from TRUE to FALSE
-    if (ShmInternalComm->ChargingPermission_pre == TRUE &&
-        ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("Permission OFF\n");
-        v2gObject.DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_FAILED;
-        errn = -1;
-    }
-
-    // ====== [BODY (2/3) EVSEID ======
-    //EVSEID = all zero
-    memset(v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters, 0, sizeof(v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters));
-    /*+++ 20200808, vern, set default EVSEID +++*/
-    //vern, should be encoded  by SN
-    v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[0]='Z';
-    v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[1]='Z';
-    v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[2]='0';
-    v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[3]='0';
-    v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[4]='0';
-    v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[5]='0';
-    v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[6]='0';
-    v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.charactersLen = 7;  //max: DIN = 32, ISO1/ISO2 = 37 bytes
-    /*--- 20200808, vern, set default EVSEID ---*/
-
-    // ====== [BODY (3/3) DateTimeNow ======
-    v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.EVSETimeStamp_isUsed = 1u;
-    v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.EVSETimeStamp = (int64_t)time(NULL);   //[Joseph] Format: Unix Time Stamp
-
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    ///////////SHM_Read_iso1_SessionSetupRes(&v2gObject.ISO1, ShmCcsData);
-    #endif
-
-
-    // ============ Encode and Send Response Message ===========
-    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO1) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    return errn;
-
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso2_SessionSetupRes(int AcceptFd)
-{
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct ChargingInfoData *sys;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-
-    init_iso2BodyType(&v2gObject.ISO2.V2G_Message.Body);
-    init_iso2SessionSetupResType(&v2gObject.ISO2.V2G_Message.Body.SessionSetupRes);
-
-    // ====== [BODY (1/2) ResponseCode ======
-    v2gObject.ISO2.V2G_Message.Body.SessionSetupRes_isUsed = 1u;
-    v2gObject.ISO2.V2G_Message.Body.SessionSetupRes.ResponseCode = iso2responseCodeType_OK_NewSessionEstablished;
-
-
-    //[HEADER] Assign Res SessionID
-    v2gObject.ISO2.V2G_Message.Header.SessionID.bytesLen = 8;
-    memset(v2gObject.ISO2.V2G_Message.Header.SessionID.bytes, 0, 8);
-    memcpy(v2gObject.ISO2.V2G_Message.Header.SessionID.bytes, EVCOMM_SYS_INFO.SessionID, 8);
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        v2gObject.ISO1.V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //#if PARAMETER_NORMAL_MODE == ENABLE
-    //SHM_Read_iso2_V2GMSG_Header(&v2gObject.ISO2, ShmCcsData);
-    //#endif
-
-    //Detect for CP State should be 9V (State B)
-    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
-    {
-	#if CP_PROTECTION_MECHANISM == ENABLE
-        v2gObject.ISO2.V2G_Message.Body.SessionSetupRes.ResponseCode = iso2responseCodeType_FAILED;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-
-        DEBUG_INFO("Emergency Stop by CP Error (%d)\n", sys->CpState);
-	#else
-        DEBUG_INFO("Emergency Stop by CP Error (%d): ignored\n", sys->CpState);
-	#endif
-    }
-
-    //Check for shutdown commands from EVSE(DC Main Board)
-    if (sys->DC_EVSEStatus == EVSE_Shutdown ||
-        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        v2gObject.ISO2.V2G_Message.Body.SessionSetupRes.ResponseCode = iso2responseCodeType_FAILED;
-        DEBUG_INFO("Stop by EVSE(%d:normal, %d:emergency): (%d)\n",
-								EVSE_Shutdown,
-								EVSE_EmergencyShutdown,
-								sys->DC_EVSEStatus);
-        errn = -1;
-    }
-
-    //Check for Permission Changing from TRUE to FALSE
-    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
-    if (ShmInternalComm->ChargingPermission_pre >= 1 &&
-        ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("Permission OFF\n");
-        v2gObject.DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = iso2responseCodeType_FAILED;
-        errn = -1;
-    }
-
-    // ====== [BODY (2/3) EVSEID ======
-    //EVSEID = all zero
-    memset(v2gObject.ISO2.V2G_Message.Body.SessionSetupRes.EVSEID.characters, 0, sizeof(v2gObject.ISO2.V2G_Message.Body.SessionSetupRes.EVSEID.characters));
-    v2gObject.ISO2.V2G_Message.Body.SessionSetupRes.EVSEID.charactersLen = 15;  //max: DIN = 32, ISO1/ISO2 = 37 bytes
-
-    // ====== [BODY (3/3) DateTimeNow ======
-    v2gObject.ISO2.V2G_Message.Body.SessionSetupRes.EVSETimeStamp_isUsed = 1u;
-    v2gObject.ISO2.V2G_Message.Body.SessionSetupRes.EVSETimeStamp = (int64_t)time(NULL);   //[Joseph] Format: Unix Time Stamp
-
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    ///////////SHM_Read_iso2_SessionSetupRes(&v2gObject.ISO2, ShmCcsData);
-    #endif
-
-
-    // ============ Encode and Send Response Message ===========
-    if (send_encoded_iso2_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO2) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    return errn;
-
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_SessionSetupReq(int AcceptFd)
-{
-    int errn = 0;
-
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_DIN_SessionSetupReq(&v2gObject.DIN);
-
-    //Save into Share Memory
-    SHM_Save_din_SessionSetupReq(ShmCcsData, &v2gObject.DIN, ShmSysConfigAndInfo);
-
-    errn = Proc_din_SessionSetupRes(AcceptFd);
-    if (errn == 0)
-    {
-    	//successfully send response.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_din_SessionSetupRes(): %d (DEC)\n", errn);
-    }
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_SessionSetupReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO1_SessionSetupReq(&v2gObject.ISO1);
-
-    //Save into Share Memory
-    SHM_Save_iso1_SessionSetupReq(ShmCcsData, &v2gObject.ISO1, ShmSysConfigAndInfo);
-
-    errn = Proc_iso1_SessionSetupRes(AcceptFd);
-    if (errn == 0)
-    {
-        //successfully send response.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso1_SessionSetupRes(): %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso2_SessionSetupReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO2_SessionSetupReq(&v2gObject.ISO2);
-
-    //Save into Share Memory
-    SHM_Save_iso2_SessionSetupReq(ShmCcsData, &v2gObject.ISO2, ShmSysConfigAndInfo);
-
-    errn = Proc_iso2_SessionSetupRes(AcceptFd);
-    if (errn == 0)
-    {
-        //successfully send response.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso2_SessionSetupRes(): %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_ServiceDiscoveryRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    struct ChargingInfoData *sys;
-    //struct ServiceDiscoveryRequest_DIN70121 *req;
-    struct ServiceDiscoveryResponse_DIN70121 *res;
-
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-    //req = &ShmCcsData->V2GMessage_DIN70121.ServiceDiscoveryRequest;
-    res = &ShmCcsData->V2GMessage_DIN70121.ServiceDiscoveryResponse;
-
-
-    init_dinBodyType(&v2gObject.DIN.V2G_Message.Body);
-    init_dinServiceDiscoveryResType(&v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes);
-
-    //[1/4] Response Code
-    v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes_isUsed = 1u;
-    v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = dinresponseCodeType_OK;
-
-    //[HEADER] Check Req SessionID
-    if (Check_din_V2G_Rx_MSG_SessionID(&v2gObject.DIN) < 0)
-    {
-        v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-
-    //Detect for CP State should be 9V (State B)
-    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
-    {
-	#if CP_PROTECTION_MECHANISM == ENABLE
-        v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode =  dinresponseCodeType_FAILED;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-	    errn = -1;
-	    DEBUG_INFO("Emergency Stop by CP Error (%d)\n", sys->CpState);
-	#else
-	    DEBUG_INFO("Emergency Stop by CP Error (%d): ignored\n", sys->CpState);
-	#endif
-    }
-
-    if (sys->DC_EVSEStatus == EVSE_Shutdown ||
-        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = dinresponseCodeType_FAILED;
-        DEBUG_INFO("shutdown by EVSE\n");
-        errn = -1;
-    }
-
-    //Check for Permission Changing from TRUE to FALSE
-    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
-    if (ShmInternalComm->ChargingPermission_pre >= 1 &&
-        ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("[DIN]Permission OFF\n");
-        v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = dinresponseCodeType_FAILED;
-        errn = -1;
-    }
-
-    //[2/4] PaymentOptions
-    v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes.PaymentOptions.PaymentOption.arrayLen = 1u;
-    v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes.PaymentOptions.PaymentOption.array[0] = dinpaymentOptionType_ExternalPayment; //1
-
-    //[3/4] Charge Service
-    res->ChargeService_DIN70121.Services.ServiceTag.ServiceID = 1;
-    v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceTag.ServiceID = (unsigned short) res->ChargeService_DIN70121.Services.ServiceTag.ServiceID;
-    v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceTag.ServiceCategory = dinserviceCategoryType_EVCharging;
-    v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.FreeService = 1; //[Joseph] for test
-    v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.EnergyTransferType = dinEVSESupportedEnergyTransferType_DC_extended;
-
-    //[4/4] Service List (null, not be uesed for now.)
-    //#if PARAMETER_NORMAL_MODE == ENABLE
-    ///////////////SHM_Read_din_ServiceDiscoveryRes(&v2gObject.DIN, ShmCcsData);
-    //#endif
-
-    // ============ Encode and Send Response Message ===========
-    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.DIN) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_ServiceDiscoveryRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    struct ChargingInfoData *sys;
-    //struct ServiceDiscoveryRequest_ISO15118_2014 *req;
-    struct ServiceDiscoveryResponse_ISO15118_2014 *res;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-    //req = &ShmCcsData->V2GMessage_ISO15118_2014.ServiceDiscoveryRequest;
-    res = &ShmCcsData->V2GMessage_ISO15118_2014.ServiceDiscoveryResponse;
-
-    init_iso1BodyType(&v2gObject.ISO1.V2G_Message.Body);
-    init_iso1ServiceDiscoveryResType(&v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes);
-
-    //[1/4] Response Code
-    v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes_isUsed = 1u;
-    v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso1responseCodeType_OK;
-
-
-    //[HEADER] Check Req SessionID
-    if (Check_iso1_V2G_Rx_MSG_SessionID(&v2gObject.ISO1) < 0)
-    {
-        v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-
-    //Detect for CP State should be 9V (State B)
-    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
-    {
-	#if CP_PROTECTION_MECHANISM == ENABLE
-        v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso1responseCodeType_FAILED;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-        DEBUG_INFO("Emergency Stop by CP Error (%d)\n", sys->CpState);
-	#else
-        DEBUG_INFO("Emergency Stop by CP Error (%d): ignored", sys->CpState);
-	#endif
-    }
-
-    if (sys->DC_EVSEStatus == EVSE_Shutdown ||
-        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso1responseCodeType_FAILED;
-        DEBUG_INFO("shutdown by EVSE\n");
-        errn = -1;
-    }
-
-    //Check for Permission Changing from TRUE to FALSE
-    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
-    if (ShmInternalComm->ChargingPermission_pre >= 1 &&
-        ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("Permission OFF\n");
-        v2gObject.DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso1responseCodeType_FAILED;
-        errn = -1;
-    }
-
-    //[2/4] PaymentOptionList
-    v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.PaymentOptionList.PaymentOption.arrayLen = 1u;
-    v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.PaymentOptionList.PaymentOption.array[0] = iso1paymentOptionType_ExternalPayment; //1
-
-    //[3/4] Charge Service
-    res->ChargeService.Services.ServiceID = 1;
-    v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceID = (unsigned short) res->ChargeService.Services.ServiceID;
-    //v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceName_isUsed = 1;   //new in ISO1, not be used, yet.
-    //v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceName.charactersLen = xxx;
-    //v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceName.characters[i] = xxx;
-    v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceCategory = iso1serviceCategoryType_EVCharging;
-    v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.FreeService = 1; //[Joseph] for test
-    v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.SupportedEnergyTransferMode.EnergyTransferMode.arrayLen = 1u;    // max = 6
-
-    switch (ShmCcsData->EnergyTransferMode)
-    {
-        case DC_extended:
-        {
-            v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.SupportedEnergyTransferMode.EnergyTransferMode.array[0] = iso1EnergyTransferModeType_DC_extended;
-            break;
-        }
-
-        case AC_single_phase_core:
-        {
-            v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.SupportedEnergyTransferMode.EnergyTransferMode.array[0] = iso1EnergyTransferModeType_AC_single_phase_core;
-            break;
-        }
-
-        case AC_three_phase_core:
-        {
-            v2gObject.ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.SupportedEnergyTransferMode.EnergyTransferMode.array[0] = iso1EnergyTransferModeType_AC_three_phase_core;
-            break;
-        }
-
-        default:
-        {
-        	DEBUG_WARN("unexpected EnergyTransferMode(%d)\n", ShmCcsData->EnergyTransferMode);
-            break;
-        }
-    }
-
-
-    //[4/4] Service List (null, not be uesed for now.)
-    //#if PARAMETER_NORMAL_MODE == ENABLE
-    ///////////////SHM_Read_iso1_ServiceDiscoveryRes(&v2gObject.ISO1, ShmCcsData);
-    //#endif
-
-
-    // ============ Encode and Send Response Message ===========
-    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO1) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_ServiceDiscoveryReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_DIN_ServiceDiscoveryReq(&v2gObject.DIN);
-
-    //Save into Share Memory
-    SHM_Save_din_ServiceDiscoveryReq(ShmCcsData, &v2gObject.DIN, ShmSysConfigAndInfo);
-
-    errn = Proc_din_ServiceDiscoveryRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_din_ServiceDiscoveryRes(): %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_ServiceDiscoveryReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO1_ServiceDiscoveryReq(&v2gObject.ISO1);
-
-    //Save into Share Memory
-    SHM_Save_iso1_ServiceDiscoveryReq(ShmCcsData, &v2gObject.ISO1, ShmSysConfigAndInfo);
-
-    errn = Proc_iso1_ServiceDiscoveryRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso1_ServiceDiscoveryRes(): %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_ServiceAndPaymentSelectionRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    struct ServiceAndPaymentSelectionRequest_DIN70121 *req;
-    //struct ServiceAndPaymentSelectionResponse_DIN70121 *res;
-    struct ServiceDiscoveryResponse_DIN70121 *sd_res;
-    struct ChargingInfoData *sys;
-
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    req = &ShmCcsData->V2GMessage_DIN70121.ServiceAndPaymentSelectionRequest;
-    //res = &ShmCcsData->V2GMessage_DIN70121.ServiceAndPaymentSelectionResponse;
-    sd_res = &ShmCcsData->V2GMessage_DIN70121.ServiceDiscoveryResponse;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-
-    init_dinBodyType(&v2gObject.DIN.V2G_Message.Body);
-    init_dinServicePaymentSelectionResType(&v2gObject.DIN.V2G_Message.Body.ServicePaymentSelectionRes);
-
-    //[1/1] Response Code
-    v2gObject.DIN.V2G_Message.Body.ServicePaymentSelectionRes_isUsed = 1u;
-    v2gObject.DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_OK;
-
-
-    //[HEADER] Check Req SessionID
-    if (Check_din_V2G_Rx_MSG_SessionID(&v2gObject.DIN) < 0)
-    {
-        v2gObject.DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        v2gObject.DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //Check for SelectedPaymentOption (TC_SECC_VTB_ServicePaymentSelection_007)
-    if (req->SelectedPaymentOption != ExternalPayment)  //1
-    {
-        v2gObject.DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED_PaymentSelectionInvalid;
-        DEBUG_ERROR("unexpected SelectedPaymentOption(%d) => End_Process (EIM only, no PnC, yet.)\n", req->SelectedPaymentOption);
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_Payment SelectionInvalid (023762)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 6;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 2;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-    }
-
-    //Check for ServiceID (TC_SECC_VTB_ServicePaymentSelection_004)
-    if (req->SelectedServiceList.SelectedService[0].ServiceID != sd_res->ChargeService_DIN70121.Services.ServiceTag.ServiceID)
-    {
-        v2gObject.DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED_ServiceSelectionInvalid;  //8
-        DEBUG_ERROR("Wrong selected ServiceID(%d) => End_Process\n", req->SelectedServiceList.SelectedService[0].ServiceID);
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_ServiceSelectionInvalid (023764)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 6;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 4;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-    }
-
-
-    //Detect for CP State should be 9V (State B)
-    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
-    {
-	#if CP_PROTECTION_MECHANISM == ENABLE
-        v2gObject.DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-        DEBUG_INFO("Emergency Stop by CP Error (%d)\n", sys->CpState);
-	#else
-        DEBUG_INFO("Emergency Stop by CP Error (%d): ignored due to function is disabled\n", sys->CpState);
-	#endif
-    }
-
-    if (sys->DC_EVSEStatus == EVSE_Shutdown ||
-        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        DEBUG_INFO("shutdown by EVSE\n");
-        v2gObject.DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED;
-        errn = -1;
-    }
-
-    //Check for Permission Changing from TRUE to FALSE
-    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
-    if (ShmInternalComm->ChargingPermission_pre >= 1 &&
-        ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("Permission OFF\n");
-        v2gObject.DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED;
-        errn = -1;
-    }
-
-    // ============ Encode and Send Response Message ===========
-    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.DIN) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_ServiceAndPaymentSelectionRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    struct ServiceAndPaymentSelectionRequest_ISO15118_2014 *req;
-    //struct ServiceAndPaymentSelectionResponse_ISO15118_2014 *res;
-    struct ServiceDiscoveryResponse_ISO15118_2014 *sd_res;
-    static struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    req = &ShmCcsData->V2GMessage_ISO15118_2014.ServiceAndPaymentSelectionRequest;
-    //res = &ShmCcsData->V2GMessage_ISO15118_2014.ServiceAndPaymentSelectionResponse;
-    sd_res = &ShmCcsData->V2GMessage_ISO15118_2014.ServiceDiscoveryResponse;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    init_iso1BodyType(&v2gObject.ISO1.V2G_Message.Body);
-    init_iso1PaymentServiceSelectionResType(&v2gObject.ISO1.V2G_Message.Body.PaymentServiceSelectionRes);
-
-    //[1/1] Response Code
-    v2gObject.ISO1.V2G_Message.Body.PaymentServiceSelectionRes_isUsed = 1u;
-    v2gObject.ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_OK;
-
-
-    //[HEADER] Check Req SessionID
-    if (Check_iso1_V2G_Rx_MSG_SessionID(&v2gObject.ISO1) < 0)
-    {
-        v2gObject.ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        v2gObject.ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //Check for SelectedPaymentOption (TC_SECC_VTB_ServicePaymentSelection_007)
-    if (req->SelectedPaymentOption != ExternalPayment)  //1
-    {
-        v2gObject.ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED_PaymentSelectionInvalid;
-        DEBUG_ERROR("unexpected SelectedPaymentOption(%d) => End_Process (EIM only, no PnC, yet.)\n", req->SelectedPaymentOption);
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_Payment SelectionInvalid (023762)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 6;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 2;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-    }
-
-
-    //Check for ServiceID (TC_SECC_VTB_ServicePaymentSelection_004)
-    if (req->SelectedServiceList.SelectedService[0].ServiceID != sd_res->ChargeService.Services.ServiceID)
-    {
-        v2gObject.ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED_ServiceSelectionInvalid;  //8
-        DEBUG_ERROR("Wrong selected ServiceID(%d) => End_Process\n", req->SelectedServiceList.SelectedService[0].ServiceID);
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_ServiceSelectionInvalid (023764)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 6;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 4;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-    }
-
-
-    //Detect for CP State should be 9V (State B)
-    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
-    {
-        #if CP_PROTECTION_MECHANISM == ENABLE
-        v2gObject.ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-        DEBUG_INFO("Emergency Stop by CP Error (%d)\n", sys->CpState);
-        #else
-        DEBUG_INFO("Emergency Stop by CP Error (%d): ignored due to function is disabled\n", sys->CpState);
-        #endif
-    }
-
-    if (sys->DC_EVSEStatus == EVSE_Shutdown ||
-        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        DEBUG_INFO("shutdown by EVSE\n");
-        v2gObject.ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED;
-        errn = -1;
-    }
-
-    //Check for Permission Changing from TRUE to FALSE
-    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
-    if (ShmInternalComm->ChargingPermission_pre >= 1 &&
-        ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("Permission OFF\n");
-        v2gObject.ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED;
-        errn = -1;
-    }
-
-    // ============ Encode and Send Response Message ===========
-    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO1) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_ServiceAndPaymentSelectionReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-    //Print the decoded XML Document
-    PRINT_XML_DOC_DIN_ServiceAndPaymentSelectionReq(&v2gObject.DIN);
-
-    //Save into Share Memory
-    SHM_Save_din_ServiceAndPaymentSelectionReq(ShmCcsData, &v2gObject.DIN, ShmSysConfigAndInfo);
-
-    errn = Proc_din_ServiceAndPaymentSelectionRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_din_ServiceAndPaymentSelectionRes(): %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_ServiceAndPaymentSelectionReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO1_ServiceAndPaymentSelectionReq(&v2gObject.ISO1);
-
-    //Save into Share Memory
-    SHM_Save_iso1_ServiceAndPaymentSelectionReq(ShmCcsData, &v2gObject.ISO1, ShmSysConfigAndInfo);
-
-    errn = Proc_iso1_ServiceAndPaymentSelectionRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso1_ServiceAndPaymentSelectionRes(): %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_ContractAuthenticationRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct ChargingInfoData *sys;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-
-    init_dinBodyType(&v2gObject.DIN.V2G_Message.Body);
-    init_dinContractAuthenticationResType(&v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes);
-
-    v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes_isUsed = 1u;
-
-    //[BODY (1/2)] ResponseCode
-    v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_OK;
-    v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes.EVSEProcessing = dinEVSEProcessingType_Ongoing; //0
-
-
-    //[HEADER] Check Req SessionID
-    if (Check_din_V2G_Rx_MSG_SessionID(&v2gObject.DIN) < 0)
-    {
-        v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //Detect for CP State should be 9V (State B)
-    #if CP_PROTECTION_MECHANISM == ENABLE
-    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
-    {
-        v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_FAILED;
-        v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes.EVSEProcessing =  dinEVSEProcessingType_Finished;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-        DEBUG_INFO("Emergency Stop by CP Error (%d)\n", sys->CpState);
-    }
-    #endif
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_FAILED;
-        v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes.EVSEProcessing =  dinEVSEProcessingType_Finished;
-        errn = -1;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_FAILED;
-        v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes.EVSEProcessing =  dinEVSEProcessingType_Finished;
-        errn = -1;
-    }
-
-    //[BODY (2/2)] EVSEProcessing
-    if(ShmInternalComm->ChargingPermission == TRUE)
-    {
-        v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes.EVSEProcessing = dinEVSEProcessingType_Finished; //0
-        DEBUG_INFO("CSU Permission: OK\n");
-
-        #if (SLAC_FIRST_RESPONSE_METHOD == SET_5_PWM_ONCE_GET_PERMISSION_IN_AUTHORIZATIONRES)
-        {
-            //Set PWM as 5% (for SLAC first case)
-            DEBUG_INFO("Set PWM as 5%%\n");
-            SwitchCpStateE(DISABLE);
-            OutputCpPwmDuty(5);
-        }
-        #endif
-    }
-
-    //Check for Permission Changing from TRUE to FALSE
-    if (ShmInternalComm->ChargingPermission_pre == TRUE &&
-        ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("Permission OFF\n");
-        v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_FAILED;
-        v2gObject.DIN.V2G_Message.Body.ContractAuthenticationRes.EVSEProcessing =  dinEVSEProcessingType_Finished;
-        errn = -1;
-    }
-
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    ////////////SHM_Read_din_ContractAuthenticationRes(&v2gObject.DIN, ShmCcsData);
-    #endif
-
-
-    // ============ Encode and Send Response Message ===========
-    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.DIN) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_AuthorizationRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct ChargingInfoData *sys;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-
-    init_iso1BodyType(&v2gObject.ISO1.V2G_Message.Body);
-    init_iso1AuthorizationResType(&v2gObject.ISO1.V2G_Message.Body.AuthorizationRes);
-
-    v2gObject.ISO1.V2G_Message.Body.AuthorizationRes_isUsed = 1u;
-
-    //[BODY (1/2)] ResponseCode
-    v2gObject.ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = iso1responseCodeType_OK;
-    /*+++ 20200808, vern, EVSEProcessing should be waiting for Customer during authrization +++*/
-    v2gObject.ISO1.V2G_Message.Body.AuthorizationRes.EVSEProcessing = iso1EVSEProcessingType_Ongoing_WaitingForCustomerInteraction; //0
-    /*--- 20200808, vern, should be waiting for Customer during authrization ---*/
-
-    //[HEADER] Check Req SessionID
-    if (Check_iso1_V2G_Rx_MSG_SessionID(&v2gObject.ISO1) < 0)
-    {
-        v2gObject.ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        v2gObject.ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-
-    //Detect for CP State should be 9V (State B)
-    #if CP_PROTECTION_MECHANISM == ENABLE
-    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
-    {
-        v2gObject.ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = iso1responseCodeType_FAILED;
-        v2gObject.ISO1.V2G_Message.Body.AuthorizationRes.EVSEProcessing =  iso1EVSEProcessingType_Finished;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-
-        DEBUG_INFO("Emergency Stop by CP Error (%d)\n", sys->CpState);
-    }
-    #endif
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        v2gObject.ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = FAILED_ISO15118_2014;
-        v2gObject.ISO1.V2G_Message.Body.AuthorizationRes.EVSEProcessing =  iso1EVSEProcessingType_Finished;
-        errn = -1;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        v2gObject.ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = FAILED_ISO15118_2014;
-        v2gObject.ISO1.V2G_Message.Body.AuthorizationRes.EVSEProcessing =  iso1EVSEProcessingType_Finished;
-        errn = -1;
-    }
-    //[BODY (2/2)] EVSEProcessing
-    //Check for Permission from CSU
-    if(ShmInternalComm->ChargingPermission == TRUE)
-    {
-        v2gObject.ISO1.V2G_Message.Body.AuthorizationRes.EVSEProcessing = iso1EVSEProcessingType_Finished; //0
-        DEBUG_INFO("CSU Permission: OK\n");
-
-        #if (SLAC_FIRST_RESPONSE_METHOD == SET_5_PWM_ONCE_GET_PERMISSION_IN_AUTHORIZATIONRES)
-        {
-            //Set PWM as 5% (for SLAC first case)
-            DEBUG_INFO("Set PWM as 5%%\n");
-            SwitchCpStateE(DISABLE);
-            OutputCpPwmDuty(5);
-        }
-        #endif
-    }
-
-    //Check for Permission Changing from TRUE to FALSE
-    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
-    if (ShmInternalComm->ChargingPermission_pre >= 1 &&
-        ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("Permission OFF\n");
-        v2gObject.ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = FAILED_ISO15118_2014;
-        v2gObject.ISO1.V2G_Message.Body.AuthorizationRes.EVSEProcessing =  iso1EVSEProcessingType_Finished;
-        errn = -1;
-    }
-
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    ////////////SHM_Read_iso1_AuthorizationRes(&v2gObject.ISO1, ShmCcsData);
-    #endif
-
-
-    // ============ Encode and Send Response Message ===========
-    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO1) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_ContractAuthenticationReq(int AcceptFd)
-{
-    int errn = 0;
-
-    DEBUG_INFO("Request in.\n");
-
-	//Print the decoded XML Document
-	PRINT_XML_DOC_DIN_ContractAuthenticationReq(&v2gObject.DIN);
-
-	//Save into Share Memory
-	SHM_Save_din_ContractAuthenticationReq(ShmCcsData, &v2gObject.DIN, ShmSysConfigAndInfo);
-
-	errn = Proc_din_ContractAuthenticationRes(AcceptFd);
-	if (errn == 0)
-	{
-		//send response successfully.
-		DEBUG_INFO("Resonse out.\n");
-	}
-	else
-	{
-		DEBUG_ERROR("Proc_din_ContractAuthenticationRes(): %d (DEC)\n", errn);
-	}
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_AuthenticationReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO1_AuthorizationReq(&v2gObject.ISO1);
-
-    //Save into Share Memory
-    SHM_Save_iso1_AuthorizationReq(ShmCcsData, &v2gObject.ISO1, ShmSysConfigAndInfo);
-
-    errn = Proc_iso1_AuthorizationRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso1_AuthorizationRes(): %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param in
- */
-void SHM_Init_dinDC_EVSEStatusType(struct DC_EVSEStatusType_DIN70121 *in)
-{
-	in->EVSEIsolationStatus = dinisolationLevelType_Valid;
-	//	dinisolationLevelType_Invalid = 0,
-	//	dinisolationLevelType_Valid = 1, (default)
-	//	dinisolationLevelType_Warning = 2,
-	//	dinisolationLevelType_Fault = 3
-
-	in->EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
-	// 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
-
-	in->EVSENotification = dinEVSENotificationType_None;
-	// dinEVSENotificationType_None = 0, (default)
-	// dinEVSENotificationType_StopCharging = 1,
-	// dinEVSENotificationType_ReNegotiation = 2
-}
-
-/**
- *
- * @param obj
- * @param value
- * @param multiplier
- * @param unit
- */
-void SHM_Save_dinPhysicalValueType(struct PhysicalValueType_DIN70121 *obj, short value, int multiplier, unsigned char unit)
-{
-    obj->Value = value;
-    obj->Multiplier = multiplier;
-    obj->Unit =unit;
-}
-
-/**
- *
- * @param shm_ccs
- */
-void SHM_Init_din_ChargeParameterDiscoveryRes(struct CcsData *shm_ccs)
-{
-	struct ChargeParameterDiscoveryResponse_DIN70121 *in;
-
-	in = &shm_ccs->V2GMessage_DIN70121.ChargeParameterDiscoveryResponse;
-
-	//----- [BODY (1/5)] ResponseCode -----
-    in->ResponseCode = dinresponseCodeType_OK;
-
-    //----- [BODY (2/5)] EVSEProcessing -----
-    in->EVSEProcessing = dinEVSEProcessingType_Ongoing;    //0
-    // 	dinEVSEProcessingType_Finished = 0,
-    //	dinEVSEProcessingType_Ongoing = 1
-
-    //----- [BODY (3/5)] SAScheduleList of SASchedules -----
-	//be fixed in another function.
-
-    //-----  [BODY (4/5)] AC_EVSEChargeParameter of EVSEChargeParameter -----
-    //ignore, since DIN doesn't support AC
-
-    //----- [BODY (5/5)] DC_EVSEChargeParameter of EVSEChargeParameter -----
-	struct DC_EVSEChargeParameterType_DIN70121 *in_para;
-	in_para = &in->DC_EVSEChargeParameter;
-
-    //DC_EVSEStatus
-	SHM_Init_dinDC_EVSEStatusType(&in_para->DC_EVSEStatus);
-    in_para->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;
-
-    short value = 0; int multiplier = 0; unsigned char unit = 0;
-
-    //EVSEMaximumCurrentLimit
-    value = 600; multiplier = -1; unit = A_DIN70121;    //60A
-	SHM_Save_dinPhysicalValueType(&in_para->EVSEMaximumCurrentLimit, value, multiplier, unit);
-
-    //EVSEMaximumPowerLimit
-    value = 3000; multiplier = 1; unit = W_DIN70121;    //30KW
-	SHM_Save_dinPhysicalValueType(&in_para->EVSEMaximumPowerLimit, value, multiplier, unit);
-
-    //EVSEMaximumVoltageLimit
-    value = 7500; multiplier = -1; unit = V_DIN70121;   //750V
-	SHM_Save_dinPhysicalValueType(&in_para->EVSEMaximumVoltageLimit, value, multiplier, unit);
-
-    //EVSEMinimumVoltageLimit
-    value = 1500; multiplier = -1; unit = V_DIN70121;   //150V
-	SHM_Save_dinPhysicalValueType(&in_para->EVSEMinimumVoltageLimit, value, multiplier, unit);
-
-
-    //EVSEMinimumCurrentLimit
-    value = 10; multiplier = -1; unit = A_DIN70121;     //1A
-	SHM_Save_dinPhysicalValueType(&in_para->EVSEMinimumCurrentLimit, value, multiplier, unit);
-
-    //EVSECurrentRegulationTolerance
-    value = 10; multiplier = -1; unit = A_DIN70121;      //1A
-	SHM_Save_dinPhysicalValueType(&in_para->EVSECurrentRegulationTolerance, value, multiplier, unit);
-
-    //EVSEPeakCurrentRipple
-    value = 2; multiplier = -1; unit = A_DIN70121;      //0.2A
-	SHM_Save_dinPhysicalValueType(&in_para->EVSEPeakCurrentRipple, value, multiplier, unit);
-
-    //EVSEEnergyToBeDelivered (optional)
-    //SHM_Save_dinPhysicalValueType(&out_para->EVSEEnergyToBeDelivered, &in_para->EVSEEnergyToBeDelivered);
-}
-
-/**
- *
- */
-void Sudo_Parameter_din_ChargeParameterDiscoveryRes()
-{
-    init_dinBodyType(&v2gObject.DIN.V2G_Message.Body);
-    init_dinChargeParameterDiscoveryResType(&v2gObject.DIN.V2G_Message.Body.ChargeParameterDiscoveryRes);
-
-    v2gObject.DIN.V2G_Message.Body.ChargeParameterDiscoveryRes_isUsed = 1u;
-
-    //----- [BODY (1/5)] ResponseCode -----
-    struct dinChargeParameterDiscoveryResType *res;
-    res = &v2gObject.DIN.V2G_Message.Body.ChargeParameterDiscoveryRes;
-    res->ResponseCode = dinresponseCodeType_OK;
-
-    //----- [BODY (2/5)] EVSEProcessing -----
-    res->EVSEProcessing = dinEVSEProcessingType_Finished; //0
-    // 	dinEVSEProcessingType_Finished = 0,
-    //	dinEVSEProcessingType_Ongoing = 1
-
-    //----- [BODY (3/5)] SAScheduleList of SASchedules -----
-    res->SAScheduleList_isUsed = 1u;
-    struct dinSAScheduleListType *list;
-    list = &res->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 = xxx
-    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.duration_isUsed = 1u;
-    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval_isUsed = 0u;
-    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval.xxx
-    //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 -----
-    res->DC_EVSEChargeParameter_isUsed = 1u;
-    struct dinDC_EVSEChargeParameterType *para;
-    para = &res->DC_EVSEChargeParameter;
-
-    //DC_EVSEStatus
-    para->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
-    para->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;
-    //	dinisolationLevelType_Invalid = 0,
-    //	dinisolationLevelType_Valid = 1,
-    //	dinisolationLevelType_Warning = 2,
-    //	dinisolationLevelType_Fault = 3
-
-    para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
-    // dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
-    // dinDC_EVSEStatusCodeType_EVSE_Ready = 1,
-    // 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
-
-    para->DC_EVSEStatus.NotificationMaxDelay = 0u;
-
-    para->DC_EVSEStatus.EVSENotification = dinEVSENotificationType_None;
-    // dinEVSENotificationType_None = 0,
-    // dinEVSENotificationType_StopCharging = 1,
-    // dinEVSENotificationType_ReNegotiation = 2
-
-    //EVSEMaximumCurrentLimit
-    para->EVSEMaximumCurrentLimit.Value = 2400;
-    para->EVSEMaximumCurrentLimit.Multiplier = -1;
-    para->EVSEMaximumCurrentLimit.Unit_isUsed = 1u;
-    para->EVSEMaximumCurrentLimit.Unit = dinunitSymbolType_A;
-    //	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
-
-    //EVSEMaximumPowerLimit
-    para->EVSEMaximumPowerLimit.Value = 6000;
-    para->EVSEMaximumPowerLimit.Multiplier = 1;
-    para->EVSEMaximumPowerLimit.Unit_isUsed = 1u;
-    para->EVSEMaximumPowerLimit.Unit = dinunitSymbolType_W;
-
-
-    //EVSEMaximumVoltageLimit
-    para->EVSEMaximumVoltageLimit.Value = 7500;
-    para->EVSEMaximumVoltageLimit.Multiplier = -1;
-    para->EVSEMaximumVoltageLimit.Unit_isUsed = 1u;
-    para->EVSEMaximumVoltageLimit.Unit = dinunitSymbolType_V;
-
-    //EVSEMinimumVoltageLimit
-    para->EVSEMinimumVoltageLimit.Value = 1500;
-    para->EVSEMinimumVoltageLimit.Multiplier = -1;
-    para->EVSEMinimumVoltageLimit.Unit_isUsed = 1u;
-    para->EVSEMinimumVoltageLimit.Unit = dinunitSymbolType_V;
-
-
-    //EVSEMinimumCurrentLimit
-    para->EVSEMinimumCurrentLimit.Value = 20;
-    para->EVSEMinimumCurrentLimit.Multiplier = -1;
-    para->EVSEMinimumCurrentLimit.Unit_isUsed = 1u;
-    para->EVSEMinimumCurrentLimit.Unit = dinunitSymbolType_A;
-
-    //EVSECurrentRegulationTolerance_isUsed
-    para->EVSECurrentRegulationTolerance_isUsed = 1u;
-    //EVSECurrentRegulationTolerance
-    para->EVSECurrentRegulationTolerance.Value = 10;
-    para->EVSECurrentRegulationTolerance.Multiplier = -1;
-    para->EVSECurrentRegulationTolerance.Unit_isUsed = 1u;
-    para->EVSECurrentRegulationTolerance.Unit = dinunitSymbolType_A;
-
-
-    //EVSEEnergyToBeDelivered_isUsed
-    para->EVSEEnergyToBeDelivered_isUsed = 1u;
-    //EVSEPeakCurrentRipple
-    para->EVSEPeakCurrentRipple.Value = 2;
-    para->EVSEPeakCurrentRipple.Multiplier = -1;
-    para->EVSEPeakCurrentRipple.Unit_isUsed = 1u;
-    para->EVSEPeakCurrentRipple.Unit = dinunitSymbolType_A;
-
-
-    //EVSEEnergyToBeDelivered (optional)
-    /*
-    para->EVSEEnergyToBeDelivered.Value = 360;
-    para->EVSEEnergyToBeDelivered.Multiplier = 3;
-    para->EVSEEnergyToBeDelivered.Unit_isUsed = 1u;
-    para->EVSEEnergyToBeDelivered.Unit = dinunitSymbolType_Wh;
-    */
-}
-
-/**
- *
- */
-void Sudo_Parameter_iso1_ChargeParameterDiscoveryRes()
-{
-    init_iso1BodyType(&v2gObject.ISO1.V2G_Message.Body);
-    init_iso1ChargeParameterDiscoveryResType(&v2gObject.ISO1.V2G_Message.Body.ChargeParameterDiscoveryRes);
-
-    v2gObject.ISO1.V2G_Message.Body.ChargeParameterDiscoveryRes_isUsed = 1u;
-
-    //----- [BODY (1/5)] ResponseCode -----
-    struct iso1ChargeParameterDiscoveryResType *res;
-    res = &v2gObject.ISO1.V2G_Message.Body.ChargeParameterDiscoveryRes;
-    res->ResponseCode = iso1responseCodeType_OK;
-
-    //----- [BODY (2/5)] EVSEProcessing -----
-    res->EVSEProcessing = iso1EVSEProcessingType_Finished; //0
-    // 	iso1EVSEProcessingType_Finished = 0,
-    //	iso1EVSEProcessingType_Ongoing = 1
-
-    //----- [BODY (3/5)] SAScheduleList of SASchedules -----
-    res->SAScheduleList_isUsed = 1u;
-    struct iso1SAScheduleListType *list;
-    list = &res->SAScheduleList;
-    //
-    list->SAScheduleTuple.arrayLen = 1;
-    list->SAScheduleTuple.array[0].SAScheduleTupleID = 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 = xxx
-    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.duration_isUsed = 1u;
-    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval_isUsed = 0u;
-    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval.xxx
-    //list->SAScheduleTuple.array[0].SalesTariff.xxx
-    //list->SAScheduleTuple.array[0].SalesTariff_isUsed = 0u;
-
-
-    //-----  [BODY (4/5)] AC_EVSEChargeParameter of EVSEChargeParameter -----
-    //ignore, since our ISO1 doesn't support AC, yet
-
-    //----- [BODY (5/5)] DC_EVSEChargeParameter of EVSEChargeParameter -----
-    res->DC_EVSEChargeParameter_isUsed = 1u;
-    struct iso1DC_EVSEChargeParameterType *para;
-    para = &res->DC_EVSEChargeParameter;
-
-    //DC_EVSEStatus
-    para->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
-    para->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid;
-    //	iso1isolationLevelType_Invalid = 0,
-    //	iso1isolationLevelType_Valid = 1,
-    //	iso1isolationLevelType_Warning = 2,
-    //	iso1isolationLevelType_Fault = 3
-
-    para->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
-    // 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
-
-    para->DC_EVSEStatus.NotificationMaxDelay = 0u;
-
-    para->DC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
-    // iso1EVSENotificationType_None = 0,
-    // iso1EVSENotificationType_StopCharging = 1,
-    // iso1EVSENotificationType_ReNegotiation = 2
-
-    //EVSEMaximumCurrentLimit
-    para->EVSEMaximumCurrentLimit.Value = 2400;
-    para->EVSEMaximumCurrentLimit.Multiplier = -1;
-    //para->EVSEMaximumCurrentLimit.Unit_isUsed = 1u;
-    para->EVSEMaximumCurrentLimit.Unit = iso1unitSymbolType_A;
-    //iso1unitSymbolType_h = 0,
-	//iso1unitSymbolType_m = 1,
-	//iso1unitSymbolType_s = 2,
-	//iso1unitSymbolType_A = 3,
-	//iso1unitSymbolType_V = 4,
-	//iso1unitSymbolType_W = 5,
-	//iso1unitSymbolType_Wh = 6
-
-    //EVSEMaximumPowerLimit
-    para->EVSEMaximumPowerLimit.Value = 6000;
-    para->EVSEMaximumPowerLimit.Multiplier = 1;
-    //para->EVSEMaximumPowerLimit.Unit_isUsed = 1u;
-    para->EVSEMaximumPowerLimit.Unit = iso1unitSymbolType_W;
-
-
-    //EVSEMaximumVoltageLimit
-    para->EVSEMaximumVoltageLimit.Value = 7500;
-    para->EVSEMaximumVoltageLimit.Multiplier = -1;
-    //para->EVSEMaximumVoltageLimit.Unit_isUsed = 1u;
-    para->EVSEMaximumVoltageLimit.Unit = iso1unitSymbolType_V;
-
-    //EVSEMinimumVoltageLimit
-    para->EVSEMinimumVoltageLimit.Value = 1500;
-    para->EVSEMinimumVoltageLimit.Multiplier = -1;
-    //para->EVSEMinimumVoltageLimit.Unit_isUsed = 1u;
-    para->EVSEMinimumVoltageLimit.Unit = iso1unitSymbolType_V;
-
-
-    //EVSEMinimumCurrentLimit
-    para->EVSEMinimumCurrentLimit.Value = 20;
-    para->EVSEMinimumCurrentLimit.Multiplier = -1;
-    //para->EVSEMinimumCurrentLimit.Unit_isUsed = 1u;
-    para->EVSEMinimumCurrentLimit.Unit = iso1unitSymbolType_A;
-
-    //EVSECurrentRegulationTolerance_isUsed
-    para->EVSECurrentRegulationTolerance_isUsed = 1u;
-    //EVSECurrentRegulationTolerance
-    para->EVSECurrentRegulationTolerance.Value = 10;
-    para->EVSECurrentRegulationTolerance.Multiplier = -1;
-    //para->EVSECurrentRegulationTolerance.Unit_isUsed = 1u;
-    para->EVSECurrentRegulationTolerance.Unit = iso1unitSymbolType_A;
-
-
-    //EVSEEnergyToBeDelivered_isUsed
-    para->EVSEEnergyToBeDelivered_isUsed = 1u;
-    //EVSEPeakCurrentRipple
-    para->EVSEPeakCurrentRipple.Value = 2;
-    para->EVSEPeakCurrentRipple.Multiplier = -1;
-    //para->EVSEPeakCurrentRipple.Unit_isUsed = 1u;
-    para->EVSEPeakCurrentRipple.Unit = iso1unitSymbolType_A;
-
-
-    //EVSEEnergyToBeDelivered (optional)
-    /*
-    para->EVSEEnergyToBeDelivered.Value = 360;
-    para->EVSEEnergyToBeDelivered.Multiplier = 3;
-    para->EVSEEnergyToBeDelivered.Unit_isUsed = 1u;
-    para->EVSEEnergyToBeDelivered.Unit = iso1unitSymbolType_Wh;
-    */
-}
-
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_ChargeParameterDiscoveryRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    struct ChargeParameterDiscoveryResponse_DIN70121 *res;
-    struct ChargeParameterDiscoveryRequest_DIN70121 *req;
-    struct DC_EVSEChargeParameterType_DIN70121 *dc_para;
-    struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    res = &ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryResponse;
-    req = &ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryRequest;
-    dc_para = &ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryResponse.DC_EVSEChargeParameter;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    res->ResponseCode = OK_DIN70121;
-    res->EVSEProcessing =  Ongoing_DIN70121;
-    dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;    //1
-
-
-    //[HEADER] Check Req SessionID
-    if (Check_din_V2G_Rx_MSG_SessionID(&v2gObject.DIN) < 0)
-    {
-        res->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        res->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-
-    //[TC_SECC_VTB_ChargeParameterDiscovery_005]
-    if (sys->EvBatteryMaxCurrent < 0)
-    {
-    	DEBUG_ERROR("EvBatteryMaxCurrent is negative(%.02f) => End_Process\n", sys->EvBatteryMaxCurrent);
-
-        res->ResponseCode = dinresponseCodeType_FAILED_WrongChargeParameter;    //16
-        res->EVSEProcessing = Finished_DIN70121;
-        dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-        errn = -1;
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_WrongChargeParameter (023775)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 5;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-    }
-
-
-    //STEP 2: ============ Modify Parameters of ShmCcsData ============
-    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMaximumPowerLimit, (int) (sys->AvailableChargingPower * 10), W_DIN70121);
-    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMaximumCurrentLimit, (int) (sys->AvailableChargingCurrent * 10), A_DIN70121);
-    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMaximumVoltageLimit, (int) (sys->MaximumChargingVoltage * 10), V_DIN70121);
-
-    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMinimumVoltageLimit, 1500, V_DIN70121); //150V
-    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMinimumCurrentLimit, 10, A_DIN70121); //1A
-    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSECurrentRegulationTolerance, 10, A_DIN70121); //1A
-    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEPeakCurrentRipple, 2, A_DIN70121);   //0.2A
-    //SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEEnergyToBeDelivered, 0, WH_DIN70121); //optional
-
-    #if PATCH_FOR_BMW_I3_BUG_EVSEMAXIMUMVOLTAGELIMIT_599V == ENABLE
-    if (sys->EvBatteryMaxVoltage <= 500)
-    {
-        SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMaximumVoltageLimit, (int) (500 * 10), V_DIN70121);  //500V
-    }
-    #endif
-
-    //for test with Tesla Model 3, 10A
-    //SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMaximumCurrentLimit, (int) (10 * 10), A_DIN70121);   //10A, for testing with Tesla Model 3
-
-
-    //Check for EnergyTransferMode [TC_SECC_VTB_ChargeParameterDiscovery_004]
-    if (req->EVRequestedEnergyTransferType != DC_extended)
-    {
-    	DEBUG_ERROR("Wrong EVRequestedEnergyTransferType(%d,%d)\n", req->EVRequestedEnergyTransferType, dinEVSESupportedEnergyTransferType_DC_extended);
-        res->ResponseCode = FAILED_WrongEnergyTransferType_DIN70121;
-        res->EVSEProcessing = Finished_DIN70121;
-        dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-        errn = -1;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_WrongEnergyTransferMode (023774)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 4;
-    }
-
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        DEBUG_INFO("EVSE_Shutdown\n");
-        res->ResponseCode = FAILED_DIN70121;
-        res->EVSEProcessing = Finished_DIN70121;
-        dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-        errn = -1;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        DEBUG_INFO("EVSE_EmergencyShutdown\n");
-        res->ResponseCode = FAILED_DIN70121;
-        res->EVSEProcessing = Finished_DIN70121;
-        dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        errn = -1;
-    }
-
-    //Detect for CP State should be 9V (State B)
-    #if CP_PROTECTION_MECHANISM == ENABLE
-    if (sys->CpState != 3)  //State B1, B2
-    {
-        res->ResponseCode = FAILED_DIN70121;
-        dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        res->EVSEProcessing = Finished_DIN70121;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-
-        DEBUG_INFO("Emergency Stop by CP Error (%d, %.02f V)\n", sys->CpState, sys->CpVoltage);
-    }
-    #endif
-
-    //Check for Permission from CSU
-    if (ShmInternalComm->ChargingPermission == TRUE)
-    {
-        res->EVSEProcessing = Finished_DIN70121;
-    }
-
-    //Check for Permission Off
-    if (ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("Permission OFF\n");
-        res->ResponseCode = FAILED_DIN70121;
-        res->EVSEProcessing = Finished_DIN70121;
-        dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-        errn = -1;
-    }
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_din_ChargeParameterDiscoveryRes(&v2gObject.DIN, ShmCcsData);
-    #else
-    Sudo_Parameter_din_ChargeParameterDiscoveryRes();
-    #endif
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.DIN) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STPE 5: ============ Update Flags ============
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_ChargeParameterDiscoveryRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    struct ChargeParameterDiscoveryResponse_ISO15118_2014 *res;
-    struct ChargeParameterDiscoveryRequest_ISO15118_2014 *req;
-    struct DC_EVSEChargeParameterType_ISO15118_2014 *dc_para;
-    struct AC_EVSEChargeParameterType_ISO15118_2014 *ac_para;
-    struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    res = &ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryResponse;
-    req = &ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest;
-    dc_para = &ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryResponse.DC_EVSEChargeParameter;
-    ac_para = &ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryResponse.AC_EVSEChargeParameter;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    res->ResponseCode = OK_ISO15118_2014;
-    /*+++ 20200808, vern, EVSEProcessing should be on-going during ChargeParameterDiscovery +++*/
-    res->EVSEProcessing =  iso1EVSEProcessingType_Ongoing;
-    /*--- 20200808, vern, EVSEProcessing should be on-going during ChargeParameterDiscovery ---*/
-    dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;    //1
-    ac_para->AC_EVSEStatus.RCD = ShmInternalComm->AC_RcdStatus; //0:no error, 1:error
-    ac_para->AC_EVSEStatus.NotificationMaxDelay = 10;  //unit: 1s
-    ac_para->AC_EVSEStatus.EVSENotification = ShmInternalComm->AC_EVSENotification; //0:none, 1:StopCharging, 2:RenNgotiation
-
-
-    //[HEADER] Check Req SessionID
-    if (Check_iso1_V2G_Rx_MSG_SessionID(&v2gObject.ISO1) < 0)
-    {
-        res->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        res->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-
-    //[TC_SECC_VTB_ChargeParameterDiscovery_005]
-    /*+++ 20200808, vern, should check the voltage and current to see if the range of battery parameter is accepted by charger ---*/
-
-    if((ShmCcsData->EnergyTransferMode == MODE_DC_EXTENDED) && ((sys->EvBatteryMaxCurrent < 0) || (sys->EvBatteryMaxVoltage<150)))
-    {
-        DEBUG_ERROR("EvBatteryMaxCurrent is negative(%.02f) or EvBatteryMaxVoltage is under 150(%.02f)=> End_Process\n", sys->EvBatteryMaxCurrent, sys->EvBatteryMaxVoltage);
-
-        res->ResponseCode = iso1responseCodeType_FAILED_WrongChargeParameter;   //16
-        res->EVSEProcessing = Finished_ISO15118_2014;
-        dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-        ac_para->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-        errn = -1;
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_WrongChargeParameter (023775)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 5;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-    }
-
-
-    //STEP 2: ============ Modify Parameters of ShmCcsData ============
-    if(ShmCcsData->EnergyTransferMode == MODE_DC_EXTENDED)
-    {
-    	//DC
-		SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMaximumPowerLimit, (int) (sys->AvailableChargingPower * 10), W_ISO15118_2014);
-		SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMaximumCurrentLimit, (int) (sys->AvailableChargingCurrent * 10), A_ISO15118_2014);
-		SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMaximumVoltageLimit, (int) (sys->MaximumChargingVoltage * 10), V_ISO15118_2014);
-		SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMinimumVoltageLimit, 1500, V_ISO15118_2014); //150V
-		SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMinimumCurrentLimit, 10, A_ISO15118_2014); //1A
-		SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSECurrentRegulationTolerance, 10, A_ISO15118_2014); //1A
-		SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEPeakCurrentRipple, 2, A_ISO15118_2014);   //0.2A
-		//SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEEnergyToBeDelivered, 0, Wh_ISO15118_2014); //optional
-
-#if PATCH_FOR_BMW_I3_BUG_EVSEMAXIMUMVOLTAGELIMIT_599V == ENABLE
-		if (sys->EvBatteryMaxVoltage <= 500)
-		{
-			SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMaximumVoltageLimit, (int) (500 * 10), V_ISO15118_2014);  //500V
-		}
-#endif
-
-		//for test with Tesla Model 3, 10A
-	    //SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMaximumCurrentLimit, (int) (10 * 10), A_ISO15118_2014);   //10A, for testing with Tesla Model 3
-    }
-    else
-    {
-    	//AC
-    	SAVE_PhysicalValueType_ISO15118_2014(&ac_para->EVSENominalVoltage, (int) (220 * 10), V_ISO15118_2014);
-    	SAVE_PhysicalValueType_ISO15118_2014(&ac_para->EVSEMaxCurrent, (int) (sys->AvailableChargingCurrent * 10), A_ISO15118_2014);
-    }
-
-    //Check for EnergyTransferMode
-    if(req->RequestedEnergyTransferMode != ShmCcsData->EnergyTransferMode) //[CAUTION] Their table should be kept as the same.
-    {
-        DEBUG_ERROR("Unmatched RequestedEnergyTransferMode(%d,%d)\n", req->RequestedEnergyTransferMode, ShmCcsData->EnergyTransferMode);
-        res->ResponseCode = FAILED_WrongEnergyTransferMode_ISO15118_2014;
-        res->EVSEProcessing = iso1EVSEProcessingType_Finished;
-        dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-        ac_para->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-        errn = -1;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_WrongEnergyTransferMode (023774)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 4;
-    }
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        DEBUG_INFO("EVSE_Shutdown\n");
-        res->ResponseCode = FAILED_ISO15118_2014;
-        res->EVSEProcessing = iso1EVSEProcessingType_Finished;
-        dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-        ac_para->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-        errn = -1;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        DEBUG_INFO("EVSE_EmergencyShutdown\n");
-        res->ResponseCode = FAILED_ISO15118_2014;
-        res->EVSEProcessing =  iso1EVSEProcessingType_Finished;
-        dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        ac_para->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-        errn = -1;
-    }
-
-    //Detect for CP State should be 9V (State B)
-    #if CP_PROTECTION_MECHANISM == ENABLE
-    if ((sys->CpState != CCS_CP_STATE_B1) && (sys->CpState != CCS_CP_STATE_B2) && (sys->CpState != CCS_CP_STATE_C))  //State B1, B2
-    {
-        res->ResponseCode = FAILED_ISO15118_2014;
-        dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        ac_para->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-        res->EVSEProcessing = iso1EVSEProcessingType_Finished;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-
-        DEBUG_INFO("Emergency Stop by CP Error (%d, %.02f V)\n", sys->CpState, sys->CpVoltage);
-    }
-    #endif
-
-    //Check for Permission from CSU
-    if(ShmInternalComm->ChargingPermission == TRUE)
-    {
-        res->EVSEProcessing = iso1EVSEProcessingType_Finished;
-    }
-
-    //Check for Permission Off
-    if (ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("Permission OFF\n");
-        res->ResponseCode = FAILED_ISO15118_2014;
-        res->EVSEProcessing = iso1EVSEProcessingType_Finished;
-        dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-        ac_para->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-        errn = -1;
-    }
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_iso1_ChargeParameterDiscoveryRes(&v2gObject.ISO1, ShmCcsData);
-    #else
-    Sudo_Parameter_iso1_ChargeParameterDiscoveryRes();
-    #endif
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO1) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STPE 5: ============ Update Flags ============
-
-    return errn;
-}
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_ChargeParameterDiscoveryReq(int AcceptFd)
-{
-    int errn = 0;
-
-	DEBUG_INFO("Request in.\n");
-
-	//ftime(&timerStart.SeqStart);
-	//Print the decoded XML Document
-	PRINT_XML_DOC_DIN_ChargeParameterDiscoveryReq(&v2gObject.DIN);
-
-	//Save into Share Memory
-	SHM_Save_din_ChargeParameterDiscoveryReq(ShmCcsData, &v2gObject.DIN, ShmSysConfigAndInfo);
-
-	//Check for EV Error Code
-	Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.DC_EVStatus.EVErrorCode);
-
-	errn = Proc_din_ChargeParameterDiscoveryRes(AcceptFd);
-	//ftime(&timerStart.SeqEnd);
-	//DEBUG_PRINTF_EVCOMM_DETAIL("\ndelta = %.02lf ms\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd));
-	if ( errn == 0)
-	{
-		//send response successfully.
-		DEBUG_INFO("Response out.\n");
-	}
-	else
-	{
-		DEBUG_ERROR("Proc_din_ChargeParameterDiscoveryRes() fail: %d (DEC)\n",errn);
-	}
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_ChargeParameterDiscoveryReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //ftime(&timerStart.SeqStart);
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO1_ChargeParameterDiscoveryReq(&v2gObject.ISO1);
-
-    //Save into Share Memory
-    SHM_Save_iso1_ChargeParameterDiscoveryReq(ShmCcsData, &v2gObject.ISO1, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.DC_EVStatus.EVErrorCode);
-
-    errn = Proc_iso1_ChargeParameterDiscoveryRes(AcceptFd);
-    //ftime(&timerStart.SeqEnd);
-    //DEBUG_PRINTF_EVCOMM_DETAIL("\ndelta = %.02lf ms\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd));
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso1_ChargeParameterDiscoveryRes() fail: %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param shm_ccs
- */
-void SHM_Init_din_CableCheckRes(struct CcsData *shm_ccs)
-{
-	struct CableCheckResponse_DIN70121 *in;
-
-	in = &shm_ccs->V2GMessage_DIN70121.CableCheckResponse;
-
-	//----- [BODY (1/3)] ResponseCode -----
-    in->ResponseCode = dinresponseCodeType_OK;
-
-    //----- [BODY (2/3)] EVSEProcessing -----
-	//in->EVSEProcessing = dinEVSEProcessingType_Finished; //for test
-    in->EVSEProcessing = dinEVSEProcessingType_Ongoing; //default
-    // 	dinEVSEProcessingType_Finished = 0,
-    //	dinEVSEProcessingType_Ongoing = 1
-
-    //----- [BODY (3/3)] DC_EVSEStatus -----
-	SHM_Init_dinDC_EVSEStatusType(&in->DC_EVSEStatus);
-    in->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;    //0 (default)
-    //	dinisolationLevelType_Invalid = 0,
-    //	dinisolationLevelType_Valid = 1, (default)
-    //	dinisolationLevelType_Warning = 2,
-    //	dinisolationLevelType_Fault = 3
-}
-
-/**
- *
- */
-void Sudo_Parameter_din_CableCheckRes()
-{
-    init_dinBodyType(&v2gObject.DIN.V2G_Message.Body);
-    init_dinCableCheckResType(&v2gObject.DIN.V2G_Message.Body.CableCheckRes);
-
-    v2gObject.DIN.V2G_Message.Body.CableCheckRes_isUsed = 1u;
-
-    //----- [BODY (1/3)] ResponseCode -----
-    struct dinCableCheckResType *res;
-    res = &v2gObject.DIN.V2G_Message.Body.CableCheckRes;
-    res->ResponseCode = dinresponseCodeType_OK;
-
-    //----- [BODY (2/3)] EVSEProcessing -----
-    res->EVSEProcessing = dinEVSEProcessingType_Finished; //0
-    // 	dinEVSEProcessingType_Finished = 0,
-    //	dinEVSEProcessingType_Ongoing = 1
-
-    //----- [BODY (3/3)] DC_EVSEStatus -----
-    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
-    res->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;
-    //	dinisolationLevelType_Invalid = 0,
-    //	dinisolationLevelType_Valid = 1,
-    //	dinisolationLevelType_Warning = 2,
-    //	dinisolationLevelType_Fault = 3
-
-    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
-    // dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
-    // dinDC_EVSEStatusCodeType_EVSE_Ready = 1,
-    // 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
-
-    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
-
-    res->DC_EVSEStatus.EVSENotification = dinEVSENotificationType_None;
-    // dinEVSENotificationType_None = 0,
-    // dinEVSENotificationType_StopCharging = 1,
-    // dinEVSENotificationType_ReNegotiation = 2
-}
-
-/**
- *
- */
-void Sudo_Parameter_iso1_CableCheckRes()
-{
-    init_iso1BodyType(&v2gObject.ISO1.V2G_Message.Body);
-    init_iso1CableCheckResType(&v2gObject.ISO1.V2G_Message.Body.CableCheckRes);
-
-    v2gObject.ISO1.V2G_Message.Body.CableCheckRes_isUsed = 1u;
-
-    //----- [BODY (1/3)] ResponseCode -----
-    struct iso1CableCheckResType *res;
-    res = &v2gObject.ISO1.V2G_Message.Body.CableCheckRes;
-    res->ResponseCode = iso1responseCodeType_OK;
-
-    //----- [BODY (2/3)] EVSEProcessing -----
-    res->EVSEProcessing = iso1EVSEProcessingType_Finished; //0
-    //iso1EVSEProcessingType_Finished = 0,
-	//iso1EVSEProcessingType_Ongoing = 1,
-	//iso1EVSEProcessingType_Ongoing_WaitingForCustomerInteraction = 2
-
-    //----- [BODY (3/3)] DC_EVSEStatus -----
-    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
-    res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;
-    //iso1isolationLevelType_Invalid = 0,
-	//iso1isolationLevelType_Valid = 1,
-	//iso1isolationLevelType_Warning = 2,
-	//iso1isolationLevelType_Fault = 3,
-	//iso1isolationLevelType_No_IMD = 4
-
-    res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
-    //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
-
-    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
-
-    res->DC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
-    //iso1EVSENotificationType_None = 0,
-	//iso1EVSENotificationType_StopCharging = 1,
-	//iso1EVSENotificationType_ReNegotiation = 2
-}
-
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_CableCheckRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct CableCheckResponse_DIN70121 *cab;
-    static struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    cab = &ShmCcsData->V2GMessage_DIN70121.CableCheckResponse;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    cab->ResponseCode = OK_DIN70121;
-    cab->cnt++;
-
-    DEBUG_PRINTF_EVCOMM_DETAIL("CP_State = %d (%.02f V), V_now = %.02f, Isolation Status = %d, EVSEProcessing = %d\n",
-            sys->CpState,
-            sys->CpVoltage,
-            sys->PresentChargingVoltage,
-            sys->IsolationStatus,
-            cab->EVSEProcessing);
-
-    //[HEADER] Check Req SessionID
-    if (Check_din_V2G_Rx_MSG_SessionID(&v2gObject.DIN) < 0)
-    {
-        cab->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        cab->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-    if (sys->IsolationStatus == GFD_Invalid)  //0: on going
-    {
-        //For PSU
-        sys->EvBatterytargetVoltage = CABLECHECK_TARGET_VOLTAGE;	//500V	//[To-Do] this should be modified to auto decision.
-        sys->EvBatterytargetCurrent = CABLECHECK_TARGET_CURRENT;	//2A(default), unit: 1A
-
-        cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;
-        cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_IsolationMonitoringActive;    //4
-        cab->EVSEProcessing = dinEVSEProcessingType_Ongoing;
-    }
-    else if ((sys->IsolationStatus == GFD_Valid) || (sys->IsolationStatus == GFD_Warning)) //1: valid, 2: warning
-    {
-        //For PSU
-        sys->EvBatterytargetVoltage = 0;	//0V, asking PSU to discharge to 0V
-        sys->EvBatterytargetCurrent = 0;	//0A, unit: 1A
-
-        if (sys->PresentChargingVoltage < 60)  // < 60V
-        {
-        	DEBUG_INFO("[V2G][CableCheck]Pass (V_now = %.02f, Isolated = %d)\n", sys->PresentChargingVoltage, sys->IsolationStatus);
-
-            //IsolationStatus
-            if (sys->IsolationStatus == GFD_Valid)
-            {
-                cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;
-            }
-            else if (sys->IsolationStatus == GFD_Warning)
-            {
-                cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Warning;
-            }
-            else
-            {
-            	DEBUG_WARN("unexpected IsolationStatus(%d)\n", sys->IsolationStatus);
-            }
-            cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
-            cab->EVSEProcessing = dinEVSEProcessingType_Finished;
-        }
-        else
-        {
-            cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;
-            cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_IsolationMonitoringActive;
-            cab->EVSEProcessing = dinEVSEProcessingType_Ongoing;
-        }
-    }
-    else if (sys->IsolationStatus == GFD_Fault) //3: fault
-    {
-        //For PSU
-        sys->EvBatterytargetVoltage = 0;	//0V, asking PSU to discharge to 0V
-        sys->EvBatterytargetCurrent = 0;	//0A, unit: 1A
-
-        cab->ResponseCode = FAILED_DIN70121;
-        cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
-        cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_NotReady;
-        cab->EVSEProcessing = dinEVSEProcessingType_Finished;
-        DEBUG_INFO("IsolationStatus = 3 (fault)\n");
-        errn = -1;
-    }
-    else
-    {
-        //For PSU
-        sys->EvBatterytargetVoltage = 0;	//0V, asking PSU to discharge to 0V
-        sys->EvBatterytargetCurrent = 0;	//0A, unit: 1A
-
-        cab->ResponseCode = FAILED_DIN70121;
-        cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;
-        cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_NotReady;
-        cab->EVSEProcessing = dinEVSEProcessingType_Finished;
-        DEBUG_INFO("Undefined Isolation Status(%d)\n", sys->IsolationStatus);
-    }
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        cab->ResponseCode = FAILED_DIN70121;
-        cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-        cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
-        cab->EVSEProcessing = dinEVSEProcessingType_Finished;
-	    errn = -1;
-        DEBUG_INFO("EVSE_Shutdown\n");
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        cab->ResponseCode = FAILED_DIN70121;
-        cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
-        cab->EVSEProcessing = dinEVSEProcessingType_Finished;
-	    errn = -1;
-        DEBUG_INFO("EVSE_EmergencyShutdown\n");
-    }
-    else if (ShmInternalComm->ChargingPermission == FALSE)
-    {
-        cab->ResponseCode = FAILED_DIN70121;
-        cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-        cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
-        cab->EVSEProcessing = dinEVSEProcessingType_Finished;
-	    errn = -1;
-	    DEBUG_ERROR("ChargingPermission = FALSE\n");
-    }
-    else
-    {
-        //null
-    }
-
-    //Response to CP Error
-    #if CP_PROTECTION_MECHANISM == ENABLE
-    //#if 1
-    if (sys->CableCheckPreCountDownDone == TRUE)   //[To-Do] Here should be modified to 2 seconds
-    {
-        if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
-        {
-            cab->ResponseCode = FAILED_DIN70121;
-            cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-            CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-            Update_V2G_Status(Other_Fault);
-            errn = -1;
-
-            //Update_ShmStatusCode(); //[To-Do] to be implemented
-            //CCS_SECC_CP_State_Error (023889)
-            ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-            ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-            ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-            ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-            ShmStatusCodeData->PresentStatusCode[0][4] = 8;
-            ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-            CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-
-            DEBUG_INFO("Emergency Stop by CP Error (%d, %.02f V, %d)\n", sys->CpState, sys->CpVoltage, cab->cnt );
-            //cab->cnt = 0;
-        }
-    }
-    #endif
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_din_CableCheckRes(&v2gObject.DIN, ShmCcsData);
-    #else
-    Sudo_Parameter_din_CableCheckRes();
-    #endif
-
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.DIN) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-    	errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-    sys->ConnectorLocked = TRUE;    //Inicating EVSE that the CCS Connector is Locked.
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_CableCheckRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct CableCheckResponse_ISO15118_2014 *cab;
-    static struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    cab = &ShmCcsData->V2GMessage_ISO15118_2014.CableCheckResponse;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    cab->ResponseCode = OK_ISO15118_2014;
-    cab->cnt++;
-
-    DEBUG_PRINTF_EVCOMM_DETAIL("CP_State = %d (%.02f V), V_now = %.02f, Isolation Status = %d, EVSEProcessing = %d\n",
-            sys->CpState,
-            sys->CpVoltage,
-            sys->PresentChargingVoltage,
-            sys->IsolationStatus,
-            cab->EVSEProcessing);
-
-
-    //[HEADER] Check Req SessionID
-    if (Check_iso1_V2G_Rx_MSG_SessionID(&v2gObject.ISO1) < 0)
-    {
-        cab->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        cab->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-    if (sys->IsolationStatus == GFD_Invalid)  //0: invalid (on going)
-    {
-        //For PSU
-        sys->EvBatterytargetVoltage = CABLECHECK_TARGET_VOLTAGE;	//500V	//[To-Do] this should be modified to auto decision.
-        sys->EvBatterytargetCurrent = CABLECHECK_TARGET_CURRENT;	//2A(default), unit: 1A
-
-        cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid;
-        cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_IsolationMonitoringActive;
-        cab->EVSEProcessing = iso1EVSEProcessingType_Ongoing;
-    }
-    else if ((sys->IsolationStatus == GFD_Valid) || (sys->IsolationStatus == GFD_Warning)) //1: valid, 2:waring
-    {
-        //For PSU
-        sys->EvBatterytargetVoltage = 0;	//0V, asking PSU to discharge to 0V
-        sys->EvBatterytargetCurrent = 0;	//0A, unit: 1A
-
-        if (sys->PresentChargingVoltage < 60)  // < 60V
-        {
-        	DEBUG_INFO( "[V2G][CableCheck]Pass (V_now = %.02f, Isolated = %d)\n", sys->PresentChargingVoltage, sys->IsolationStatus);
-
-            //IsolationStatus
-            if (sys->IsolationStatus == GFD_Valid)
-            {
-                cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;
-            }
-            else if (sys->IsolationStatus == GFD_Warning)
-            {
-                cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Warning;
-            }
-            else
-            {
-            	DEBUG_WARN("unexpected IsolationStatus(%d)\n", sys->IsolationStatus);
-            }
-
-            cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
-            cab->EVSEProcessing = iso1EVSEProcessingType_Finished;
-        }
-        else
-        {
-            cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid;
-            cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_IsolationMonitoringActive;
-            cab->EVSEProcessing = iso1EVSEProcessingType_Ongoing;
-        }
-    }
-    else if (sys->IsolationStatus == GFD_Fault) //3: fault
-    {
-        //For PSU
-        sys->EvBatterytargetVoltage = 0;	//0V, asking PSU to discharge to 0V
-        sys->EvBatterytargetCurrent = 0;	//0A, unit: 1A
-
-        cab->ResponseCode = FAILED_ISO15118_2014;
-        cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
-        cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_NotReady;
-        cab->EVSEProcessing = iso1EVSEProcessingType_Finished;
-        DEBUG_INFO("IsolationStatus = 3 (fault)\n");
-        errn = -1;
-    }
-    //else if (sys->IsolationStatus == GFD_No_IMD){}    //only for ISO15118
-    else
-    {
-        //For PSU
-        sys->EvBatterytargetVoltage = 0;	//0V, asking PSU to discharge to 0V
-        sys->EvBatterytargetCurrent = 0;	//0A, unit: 1A
-
-        cab->ResponseCode = FAILED_ISO15118_2014;
-        cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
-        cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_NotReady;
-        cab->EVSEProcessing = iso1EVSEProcessingType_Finished;
-        DEBUG_INFO("Undefined Isolation Status.\n");
-    }
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        cab->ResponseCode = FAILED_ISO15118_2014;
-        cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-        cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
-        cab->EVSEProcessing = iso1EVSEProcessingType_Finished;
-        errn = -1;
-        DEBUG_INFO("EVSE_Shutdown\n");
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        cab->ResponseCode = FAILED_ISO15118_2014;
-        cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
-        cab->EVSEProcessing = iso1EVSEProcessingType_Finished;
-        errn = -1;
-        DEBUG_INFO("EVSE_EmergencyShutdown\n");
-    }
-    else if (ShmInternalComm->ChargingPermission == FALSE)
-    {
-        cab->ResponseCode = FAILED_ISO15118_2014;
-        cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-        cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
-        cab->EVSEProcessing = iso1EVSEProcessingType_Finished;
-        errn = -1;
-        DEBUG_ERROR("ChargingPermission = FALSE\n");
-    }
-    else
-    {
-        //null
-    }
-
-    //Response to CP Error
-    #if CP_PROTECTION_MECHANISM == ENABLE
-    if (sys->CableCheckPreCountDownDone == TRUE)   //[To-Do] Here should be modified to 2 seconds
-    {
-        if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
-        {
-            cab->ResponseCode = FAILED_ISO15118_2014;
-            cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-            CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-            Update_V2G_Status(Other_Fault);
-            errn = -1;
-
-            //Update_ShmStatusCode(); //[To-Do] to be implemented
-            //CCS_SECC_CP_State_Error (023889)
-            ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-            ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-            ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-            ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-            ShmStatusCodeData->PresentStatusCode[0][4] = 8;
-            ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-            CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-
-            DEBUG_INFO("Emergency Stop by CP Error (%d, %.02f V, %d)\n", sys->CpState, sys->CpVoltage, cab->cnt);
-            //cab->cnt = 0;
-        }
-    }
-    #endif
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_iso1_CableCheckRes(&v2gObject.ISO1, ShmCcsData);
-    #else
-    Sudo_Parameter_iso1_CableCheckRes();
-    #endif
-
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO1) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-    sys->ConnectorLocked = TRUE;    //Inicating EVSE that the CCS Connector is Locked.
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_CableCheckReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_DIN_CableCheckReq(&v2gObject.DIN);
-
-    //Save into Share Memory
-    SHM_Save_din_CableCheckReq(ShmCcsData, &v2gObject.DIN, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.CableCheckRequest.DC_EVStatus.EVErrorCode);
-
-    errn = Proc_din_CableCheckRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_din_CableCheckRes() fail: %d (DEC)", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_CableCheckReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO1_CableCheckReq(&v2gObject.ISO1);
-
-    //Save into Share Memory
-    SHM_Save_iso1_CableCheckReq(ShmCcsData, &v2gObject.ISO1, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.CableCheckRequest.DC_EVStatus.EVErrorCode);
-
-    errn = Proc_iso1_CableCheckRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso1_CableCheckRes() fail: %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param shm_ccs
- */
-void SHM_Init_din_PreChargeRes(struct CcsData *shm_ccs)
-{
-	struct PreChargeResponse_DIN70121 *in;
-
-	in = &shm_ccs->V2GMessage_DIN70121.PreChargeResponse;
-
-	//----- [BODY (1/3)] ResponseCode -----
-    in->ResponseCode = dinresponseCodeType_OK;
-
-
-    //----- [BODY (2/3)] EVSEPresentVoltage -----
-    short value = 0; int multiplier = 0; unsigned char unit = 0;
-    //value = 3820; multiplier = -1; unit = V_DIN70121;    //382V, for Test
-    value = 0; multiplier = 0; unit = V_DIN70121; //waiting for CsuComm to update V to fit EV Target
-	SHM_Save_dinPhysicalValueType(&in->EVSEPresentVoltage, value, multiplier, unit);
-
-    //----- [BODY (3/3)] DC_EVSEStatus -----
-	SHM_Init_dinDC_EVSEStatusType(&in->DC_EVSEStatus);
-}
-
-/**
- *
- */
-void Sudo_Parameter_din_PreChargeRes()
-{
-    init_dinBodyType(&v2gObject.DIN.V2G_Message.Body);
-    init_dinPreChargeResType(&v2gObject.DIN.V2G_Message.Body.PreChargeRes);
-
-    v2gObject.DIN.V2G_Message.Body.PreChargeRes_isUsed = 1u;
-
-    //----- [BODY (1/3)] ResponseCode -----
-    struct dinPreChargeResType *res;
-    res = &v2gObject.DIN.V2G_Message.Body.PreChargeRes;
-    res->ResponseCode = dinresponseCodeType_OK;
-
-
-    //----- [BODY (2/3)] EVSEPresentVoltage -----
-    res->EVSEPresentVoltage.Value = 3820;
-    res->EVSEPresentVoltage.Multiplier = -1;
-    res->EVSEPresentVoltage.Unit_isUsed = 1u;
-    res->EVSEPresentVoltage.Unit = dinunitSymbolType_V;
-    //	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 -----
-    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
-    res->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;
-    //	dinisolationLevelType_Invalid = 0,
-    //	dinisolationLevelType_Valid = 1,
-    //	dinisolationLevelType_Warning = 2,
-    //	dinisolationLevelType_Fault = 3
-
-    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
-    // dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
-    // dinDC_EVSEStatusCodeType_EVSE_Ready = 1,
-    // 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
-
-    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
-
-    res->DC_EVSEStatus.EVSENotification = dinEVSENotificationType_None;
-    // dinEVSENotificationType_None = 0,
-    // dinEVSENotificationType_StopCharging = 1,
-    // dinEVSENotificationType_ReNegotiation = 2
-}
-
-/**
- *
- */
-void Sudo_Parameter_iso1_PreChargeRes()
-{
-    init_iso1BodyType(&v2gObject.ISO1.V2G_Message.Body);
-    init_iso1PreChargeResType(&v2gObject.ISO1.V2G_Message.Body.PreChargeRes);
-
-    v2gObject.ISO1.V2G_Message.Body.PreChargeRes_isUsed = 1u;
-
-    //----- [BODY (1/3)] ResponseCode -----
-    struct iso1PreChargeResType *res;
-    res = &v2gObject.ISO1.V2G_Message.Body.PreChargeRes;
-    res->ResponseCode = iso1responseCodeType_OK;
-
-
-    //----- [BODY (2/3)] EVSEPresentVoltage -----
-    res->EVSEPresentVoltage.Value = 3820;
-    res->EVSEPresentVoltage.Multiplier = -1;
-    //res->EVSEPresentVoltage.Unit_isUsed = 1u;
-    res->EVSEPresentVoltage.Unit = iso1unitSymbolType_V;
-    //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 -----
-    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
-    res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;
-    //iso1isolationLevelType_Invalid = 0,
-	//iso1isolationLevelType_Valid = 1,
-	//iso1isolationLevelType_Warning = 2,
-	//iso1isolationLevelType_Fault = 3,
-	//iso1isolationLevelType_No_IMD = 4
-
-    res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
-    //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
-
-    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
-
-    res->DC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
-    //iso1EVSENotificationType_None = 0,
-	//iso1EVSENotificationType_StopCharging = 1,
-	//iso1EVSENotificationType_ReNegotiation = 2
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_PreChargeRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct PreChargeResponse_DIN70121 *pre;
-    static struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    pre = &ShmCcsData->V2GMessage_DIN70121.PreChargeResponse;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    pre->ResponseCode = OK_DIN70121;
-
-    //EVSE Status Code
-    pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
-
-    //[HEADER] Check Req SessionID
-    if (Check_din_V2G_Rx_MSG_SessionID(&v2gObject.DIN) < 0)
-    {
-        pre->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        pre->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-    SAVE_PhysicalValueType_DIN70121(&pre->EVSEPresentVoltage, (int) (sys->PresentChargingVoltage * 10), V_DIN70121);
-
-    //Isolation Status
-    if (sys->IsolationStatus == GFD_Invalid)  //0: invalid
-    {
-        pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid; //0
-        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-        DEBUG_ERROR("IsolationStatus = %d\n", sys->IsolationStatus);
-    }
-    else if (sys->IsolationStatus == GFD_Valid) //1: valid
-    {
-        pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;  //1
-    }
-    else if (sys->IsolationStatus == GFD_Warning) //2: warning
-    {
-        pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Warning;  //2
-    }
-    else if (sys->IsolationStatus == GFD_Fault) //3: fault
-    {
-    	DEBUG_ERROR("GFD_Fault => Emergency Shutdown\n");
-        pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;  //3
-        pre->ResponseCode = FAILED_DIN70121;
-        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        errn = -1;
-    }
-    else    //GFD_No_IMD or other unexpected status
-    {
-        pre->ResponseCode = FAILED_DIN70121;
-        pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;  //3
-        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-        DEBUG_ERROR("IsolationStatus = %d (undefined)\n", sys->IsolationStatus);
-    }
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        //Check for Alarm Code: CCS GFD trip (012235)
-        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
-        {
-        	DEBUG_ERROR("CCS GFD trip => EVSE_Shutdown\n");
-            pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
-        }
-        else
-        {
-        	DEBUG_ERROR("EVSE_Shutdown\n");
-            pre->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
-        }
-
-        pre->ResponseCode = FAILED_DIN70121;
-        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-        errn = -1;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        //Check for Alarm Code: CCS GFD trip (012235)
-        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
-        {
-        	DEBUG_ERROR("CCS GFD trip => EVSE_EmergencyShutdown\n");
-            pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
-        }
-        else
-        {
-        	DEBUG_ERROR("EVSE_EmergencyShutdown\n");
-            pre->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
-        }
-
-        pre->ResponseCode = FAILED_DIN70121;
-        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        errn = -1;
-    }
-    else if (ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("ChargingPermission = FALSE\n");
-        pre->ResponseCode = FAILED_DIN70121;
-        pre->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
-        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-        errn = -1;
-    }
-    else
-    {
-        //null
-    }
-
-    //Response to CP Error
-    #if CP_PROTECTION_MECHANISM == ENABLE
-    if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
-    {
-        pre->ResponseCode = FAILED_DIN70121;
-        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_CP_State_Error (023889)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-
-        DEBUG_ERROR("Emergency Stop by CP Error (%d, %.02f V)\n", sys->CpState, sys->CpVoltage);
-    }
-    #endif
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_din_PreChargeRes(&v2gObject.DIN, ShmCcsData);
-    #else
-    Sudo_Parameter_din_PreChargeRes();
-    #endif
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.DIN) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_PreChargeRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct PreChargeResponse_ISO15118_2014 *pre;
-    static struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    pre = &ShmCcsData->V2GMessage_ISO15118_2014.PreChargeResponse;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    pre->ResponseCode = OK_ISO15118_2014;
-
-    //EVSE Status Code
-    pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
-
-    //[HEADER] Check Req SessionID
-    if (Check_iso1_V2G_Rx_MSG_SessionID(&v2gObject.ISO1) < 0)
-    {
-        pre->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        pre->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-    SAVE_PhysicalValueType_ISO15118_2014(&pre->EVSEPresentVoltage, (int) (sys->PresentChargingVoltage * 10), V_ISO15118_2014);
-
-
-    //Isolation Status
-    if (sys->IsolationStatus == GFD_Invalid)    //0: invalid(on going)
-    {
-        pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid; //0
-        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-
-        DEBUG_ERROR("IsolationStatus = %d\n", sys->IsolationStatus);
-    }
-    else if (sys->IsolationStatus == GFD_Valid) //1: valid
-    {
-        pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;  //1
-    }
-    else if (sys->IsolationStatus == GFD_Warning) //2: waring
-    {
-        pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Warning;  //1
-    }
-    else if (sys->IsolationStatus == GFD_Fault) //3: fault
-    {
-    	DEBUG_ERROR("GFD_Fault => Emergency Shutdown\n");
-        pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;  //3
-        pre->ResponseCode = FAILED_ISO15118_2014;
-        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        errn = -1;
-    }
-    else
-    {
-        pre->ResponseCode = FAILED_ISO15118_2014;
-        pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;  //3
-        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-
-        DEBUG_ERROR("IsolationStatus = %d (undefined)\n", sys->IsolationStatus);
-
-    }
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        //Check for Alarm Code: CCS GFD trip (012235)
-        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
-        {
-        	DEBUG_ERROR("CCS GFD trip => EVSE_Shutdown\n");
-            pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
-        }
-        else
-        {
-        	DEBUG_ERROR("EVSE_Shutdown\n");
-            pre->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
-        }
-
-        pre->ResponseCode = FAILED_ISO15118_2014;
-        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-        errn = -1;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        //Check for Alarm Code: CCS GFD trip (012235)
-        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
-        {
-        	DEBUG_ERROR("CCS GFD trip => EVSE_EmergencyShutdown\n");
-            pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
-        }
-        else
-        {
-        	DEBUG_ERROR("EVSE_EmergencyShutdown\n");
-            pre->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
-        }
-
-        pre->ResponseCode = FAILED_ISO15118_2014;
-        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        errn = -1;
-    }
-    else if (ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("ChargingPermission = FALSE\n");
-        pre->ResponseCode = FAILED_ISO15118_2014;
-        pre->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
-        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-        errn = -1;
-    }
-    else
-    {
-        //null
-    }
-
-    //Response to CP Error
-    #if CP_PROTECTION_MECHANISM == ENABLE
-    if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
-    {
-        pre->ResponseCode = FAILED_ISO15118_2014;
-        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_CP_State_Error (023889)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-
-        DEBUG_ERROR("Emergency Stop by CP Error (%d, %.02f V)\n", sys->CpState, sys->CpVoltage);
-    }
-    #endif
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_iso1_PreChargeRes(&v2gObject.ISO1, ShmCcsData);
-    #else
-    Sudo_Parameter_iso1_PreChargeRes();
-    #endif
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO1) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_PreChargeReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_DIN_PreChargeReq(&v2gObject.DIN);
-
-    //Save into Share Memory
-    SHM_Save_din_PreChargeReq(ShmCcsData, &v2gObject.DIN, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.PreChargeRequest.DC_EVStatus.EVErrorCode);
-
-    errn = Proc_din_PreChargeRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_din_PreChargeRes() fail: %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_PreChargeReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO1_PreChargeReq(&v2gObject.ISO1);
-
-    //Save into Share Memory
-    SHM_Save_iso1_PreChargeReq(ShmCcsData, &v2gObject.ISO1, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.PreChargeRequest.DC_EVStatus.EVErrorCode);
-
-    errn = Proc_iso1_PreChargeRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso1_PreChargeRes() fail: %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param shm_ccs
- */
-void SHM_Init_din_PowerDeliveryRes(struct CcsData *shm_ccs)
-{
-	struct PowerDeliveryResponse_DIN70121 *in;
-
-	in = &shm_ccs->V2GMessage_DIN70121.PowerDeliveryResponse;
-
-
-	//----- [BODY (1/3)] ResponseCode -----
-    in->ResponseCode = dinresponseCodeType_OK;
-
-
-    //----- [BODY (2/3)] AC_EVSEStatus -----
-    //ignore, since DIN 70121 doesn't support AC, yet.
-
-
-    //----- [BODY (2/3)] DC_EVSEStatus -----
-	SHM_Init_dinDC_EVSEStatusType(&in->DC_EVSEStatus);
-}
-
-/**
- *
- */
-void Sudo_Parameter_din_PowerDeliveryRes()
-{
-    init_dinBodyType(&v2gObject.DIN.V2G_Message.Body);
-    init_dinPowerDeliveryResType(&v2gObject.DIN.V2G_Message.Body.PowerDeliveryRes);
-
-    v2gObject.DIN.V2G_Message.Body.PowerDeliveryRes_isUsed = 1u;
-
-    //----- [BODY (1/3)] ResponseCode -----
-    struct dinPowerDeliveryResType *res;
-    res = &v2gObject.DIN.V2G_Message.Body.PowerDeliveryRes;
-    res->ResponseCode = dinresponseCodeType_OK;
-
-
-    //----- [BODY (2/3)] AC_EVSEStatus -----
-    //ignore, since DIN 70121 doesn't support AC, yet.
-
-
-    //----- [BODY (2/3)] DC_EVSEStatus -----
-    res->DC_EVSEStatus_isUsed = 1u;
-    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
-    res->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;
-    //	dinisolationLevelType_Invalid = 0,
-    //	dinisolationLevelType_Valid = 1,
-    //	dinisolationLevelType_Warning = 2,
-    //	dinisolationLevelType_Fault = 3
-
-    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
-    // dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
-    // dinDC_EVSEStatusCodeType_EVSE_Ready = 1,
-    // 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
-
-    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
-
-    res->DC_EVSEStatus.EVSENotification = dinEVSENotificationType_None;
-    // dinEVSENotificationType_None = 0,
-    // dinEVSENotificationType_StopCharging = 1,
-    // dinEVSENotificationType_ReNegotiation = 2
-}
-
-/**
- *
- */
-void Sudo_Parameter_iso1_PowerDeliveryRes()
-{
-    init_iso1BodyType(&v2gObject.ISO1.V2G_Message.Body);
-    init_iso1PowerDeliveryResType(&v2gObject.ISO1.V2G_Message.Body.PowerDeliveryRes);
-
-    v2gObject.ISO1.V2G_Message.Body.PowerDeliveryRes_isUsed = 1u;
-
-    //----- [BODY (1/3)] ResponseCode -----
-    struct iso1PowerDeliveryResType *res;
-    res = &v2gObject.ISO1.V2G_Message.Body.PowerDeliveryRes;
-    res->ResponseCode = iso1responseCodeType_OK;
-
-
-    //----- [BODY (2/3)] AC_EVSEStatus -----
-    //ignore, since our ISO1 70121 doesn't support AC, yet.
-
-
-    //----- [BODY (2/3)] DC_EVSEStatus -----
-    res->DC_EVSEStatus_isUsed = 1u;
-    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
-    res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;
-    //iso1isolationLevelType_Invalid = 0,
-	//iso1isolationLevelType_Valid = 1,
-	//iso1isolationLevelType_Warning = 2,
-	//iso1isolationLevelType_Fault = 3,
-	//iso1isolationLevelType_No_IMD = 4
-
-    res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
-    //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
-
-    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
-
-    res->DC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
-    //iso1EVSENotificationType_None = 0,
-	//iso1EVSENotificationType_StopCharging = 1,
-	//iso1EVSENotificationType_ReNegotiation = 2
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_PowerDeliveryStartRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    struct dinPowerDeliveryResType *res;
-    struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    res = &v2gObject.DIN.V2G_Message.Body.PowerDeliveryRes;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    res->ResponseCode = OK_DIN70121;
-
-    //[HEADER] Check Req SessionID
-    if (Check_din_V2G_Rx_MSG_SessionID(&v2gObject.DIN) < 0)
-    {
-        res->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        res->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_din_PowerDeliveryRes(&v2gObject.DIN, ShmCcsData);
-    #else
-    Sudo_Parameter_din_PowerDeliveryRes();
-    #endif
-
-    //EVSE Status Code
-    res->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;  //1
-    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        //res->ResponseCode = FAILED_DIN70121;
-        res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        //res->ResponseCode = FAILED_DIN70121;
-        res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-    }
-    else if (ShmInternalComm->ChargingPermission == FALSE)
-    {
-        //res->ResponseCode = FAILED_DIN70121;
-        res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-    }
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.DIN) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_PowerDeliveryStartRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    struct iso1PowerDeliveryResType *res;
-    struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    res = &v2gObject.ISO1.V2G_Message.Body.PowerDeliveryRes;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    res->ResponseCode = OK_ISO15118_2014;
-
-    //[HEADER] Check Req SessionID
-    if (Check_iso1_V2G_Rx_MSG_SessionID(&v2gObject.ISO1) < 0)
-    {
-        res->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_iso1_PowerDeliveryRes(&v2gObject.ISO1, ShmCcsData);
-    #else
-    Sudo_Parameter_iso1_PowerDeliveryRes();
-    #endif
-
-    //EVSE Status Code
-    res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;  //1
-    res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        //res->ResponseCode = FAILED_ISO15118_2014;
-        res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        //res->ResponseCode = FAILED_ISO15118_2014;
-        res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-    }
-    else if (ShmInternalComm->ChargingPermission == FALSE)
-    {
-        //res->ResponseCode = FAILED_ISO15118_2014;
-        res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-    }
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO1) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_PowerDeliveryStartReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_DIN_PowerDeliveryReq(&v2gObject.DIN);
-
-    //Save into Share Memory
-    SHM_Save_din_PowerDeliveryReq(ShmCcsData, &v2gObject.DIN, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.PowerDeliveryRequest.DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode);
-
-    errn = Proc_din_PowerDeliveryStartRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_din_PowerDeliveryStartRes() fail: %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_PowerDeliveryStartReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO1_PowerDeliveryReq(&v2gObject.ISO1);
-
-    //Save into Share Memory
-    SHM_Save_iso1_PowerDeliveryReq(ShmCcsData, &v2gObject.ISO1, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.PowerDeliveryRequest.DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode);
-
-    errn = Proc_iso1_PowerDeliveryStartRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso1_PowerDeliveryStartRes() fail: %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param shm_ccs
- */
-void SHM_Init_din_CurrentDemandRes(struct CcsData *shm_ccs)
-{
-	struct CurrentDemandResponse_DIN70121 *in;
-
-	in = &shm_ccs->V2GMessage_DIN70121.CurrentDemandResponse;
-
-
-	//----- [BODY (1/10)] ResponseCode -----
-    in->ResponseCode = dinresponseCodeType_OK;
-
-    //----- [BODY (2/10)] DC_EVSEStatus -----
-    SHM_Init_dinDC_EVSEStatusType(&in->DC_EVSEStatus);
-
-
-    //----- [BODY (3/10)] EVSEPresentVoltage -----
-    short value = 0; int multiplier = 0; unsigned char unit = 0;
-
-    //value = 3820; multiplier = -1; unit = V_DIN70121;    //382V, for test only.
-    value = 0; multiplier = 0; unit = V_DIN70121;
-	SHM_Save_dinPhysicalValueType(&in->EVSEPresentVoltage, value, multiplier, unit);
-
-
-    //----- [BODY (4/10)] EVSEPresentCurrent -----
-    //value = 600; multiplier = -1; unit = A_DIN70121;    //60A, for test only.
-    value = 0; multiplier = 0; unit = A_DIN70121;
-    SHM_Save_dinPhysicalValueType(&in->EVSEPresentCurrent, value, multiplier, unit);
-
-
-    //----- [BODY (5/10)] EVSECurrentLimitAchieved -----
-    in->EVSECurrentLimitAchieved = FALSE;
-
-    //----- [BODY (6/10)] EVSEVoltageLimitAchieved -----
-    in->EVSEVoltageLimitAchieved = FALSE;
-
-    //----- [BODY (7/10)] EVSEPowerLimitAchieved -----
-    in->EVSEPowerLimitAchieved = FALSE;
-
-    //----- [BODY (8/10)] EVSEMaximumVoltageLimit -----
-    //value = 7500; multiplier = -1; unit = V_DIN70121;    //750V
-    value = 5000; multiplier = -1; unit = V_DIN70121;    //500V
-    SHM_Save_dinPhysicalValueType(&in->EVSEMaximumVoltageLimit, value, multiplier, unit);
-
-    //----- [BODY (9/10)] EVSEMaximumCurrentLimit -----
-    value = 600; multiplier = -1; unit = A_DIN70121;    //60A
-    SHM_Save_dinPhysicalValueType(&in->EVSEMaximumCurrentLimit, value, multiplier, unit);
-
-    //----- [BODY (10/10)] EVSEMaximumPowerLimit -----
-    value = 3000; multiplier = 1; unit = W_DIN70121;    //30KW
-    SHM_Save_dinPhysicalValueType(&in->EVSEMaximumPowerLimit, value, multiplier, unit);
-}
-
-/**
- *
- */
-void Sudo_Parameter_din_CurrentDemandRes()
-{
-    init_dinBodyType(&v2gObject.DIN.V2G_Message.Body);
-    init_dinCurrentDemandResType(&v2gObject.DIN.V2G_Message.Body.CurrentDemandRes);
-
-    v2gObject.DIN.V2G_Message.Body.CurrentDemandRes_isUsed = 1u;
-
-    //----- [BODY (1/10)] ResponseCode -----
-    struct dinCurrentDemandResType *res;
-    res = &v2gObject.DIN.V2G_Message.Body.CurrentDemandRes;
-    res->ResponseCode = dinresponseCodeType_OK;
-
-    //----- [BODY (2/10)] DC_EVSEStatus -----
-    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
-    res->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;
-    //	dinisolationLevelType_Invalid = 0,
-    //	dinisolationLevelType_Valid = 1,
-    //	dinisolationLevelType_Warning = 2,
-    //	dinisolationLevelType_Fault = 3
-
-    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
-    // dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
-    // dinDC_EVSEStatusCodeType_EVSE_Ready = 1,
-    // 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
-
-    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
-    res->DC_EVSEStatus.EVSENotification = dinEVSENotificationType_None;
-    // dinEVSENotificationType_None = 0,
-    // dinEVSENotificationType_StopCharging = 1,
-    // dinEVSENotificationType_ReNegotiation = 2
-
-
-
-    //----- [BODY (3/10)] EVSEPresentVoltage -----
-    res->EVSEPresentVoltage.Value = 3820;
-    res->EVSEPresentVoltage.Multiplier = -1;
-    res->EVSEPresentVoltage.Unit_isUsed = 1u;
-    res->EVSEPresentVoltage.Unit = dinunitSymbolType_V;
-
-
-    //----- [BODY (4/10)] EVSEPresentCurrent -----
-    res->EVSEPresentCurrent.Value = 1200;
-    res->EVSEPresentCurrent.Multiplier = -1;
-    res->EVSEPresentCurrent.Unit_isUsed = 1u;
-    res->EVSEPresentCurrent.Unit = dinunitSymbolType_A;
-
-
-    //----- [BODY (5/10)] EVSECurrentLimitAchieved -----
-    res->EVSECurrentLimitAchieved = 0;
-
-    //----- [BODY (6/10)] EVSEVoltageLimitAchieved -----
-    res->EVSEVoltageLimitAchieved = 0;
-
-    //----- [BODY (7/10)] EVSEPowerLimitAchieved -----
-    res->EVSEPowerLimitAchieved = 0;
-
-    //----- [BODY (8/10)] EVSEMaximumVoltageLimit -----
-    res->EVSEMaximumVoltageLimit_isUsed = 1u;
-    res->EVSEMaximumVoltageLimit.Value = 7500;
-    res->EVSEMaximumVoltageLimit.Multiplier = -1;
-    res->EVSEMaximumVoltageLimit.Unit_isUsed = 1u;
-    res->EVSEMaximumVoltageLimit.Unit = dinunitSymbolType_V;
-
-    //----- [BODY (9/10)] EVSEMaximumCurrentLimit -----
-    res->EVSEMaximumCurrentLimit_isUsed = 1u;
-    res->EVSEMaximumCurrentLimit.Value = 1200;
-    res->EVSEMaximumCurrentLimit.Multiplier = -1;
-    res->EVSEMaximumCurrentLimit.Unit_isUsed = 1u;
-    res->EVSEMaximumCurrentLimit.Unit = dinunitSymbolType_A;
-
-    //----- [BODY (10/10)] EVSEMaximumPowerLimit -----
-    res->EVSEMaximumPowerLimit_isUsed = 1u;
-    res->EVSEMaximumPowerLimit.Value = 6000;
-    res->EVSEMaximumPowerLimit.Multiplier = 1;
-    res->EVSEMaximumPowerLimit.Unit_isUsed = 1u;
-    res->EVSEMaximumPowerLimit.Unit = dinunitSymbolType_W;
-}
-
-/**
- *
- */
-void Sudo_Parameter_iso1_CurrentDemandRes()
-{
-    init_iso1BodyType(&v2gObject.ISO1.V2G_Message.Body);
-    init_iso1CurrentDemandResType(&v2gObject.ISO1.V2G_Message.Body.CurrentDemandRes);
-
-    v2gObject.ISO1.V2G_Message.Body.CurrentDemandRes_isUsed = 1u;
-
-    //----- [BODY (1/10)] ResponseCode -----
-    struct iso1CurrentDemandResType *res;
-    res = &v2gObject.ISO1.V2G_Message.Body.CurrentDemandRes;
-    res->ResponseCode = iso1responseCodeType_OK;
-
-    //----- [BODY (2/10)] DC_EVSEStatus -----
-    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
-    res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid;
-    //iso1isolationLevelType_Invalid = 0,
-	//iso1isolationLevelType_Valid = 1,
-	//iso1isolationLevelType_Warning = 2,
-	//iso1isolationLevelType_Fault = 3,
-	//iso1isolationLevelType_No_IMD = 4
-
-    res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
-    //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
-
-    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
-    res->DC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
-    //iso1EVSENotificationType_None = 0,
-	//iso1EVSENotificationType_StopCharging = 1,
-	//iso1EVSENotificationType_ReNegotiation = 2
-
-
-
-    //----- [BODY (3/10)] EVSEPresentVoltage -----
-    res->EVSEPresentVoltage.Value = 3820;
-    res->EVSEPresentVoltage.Multiplier = -1;
-    //res->EVSEPresentVoltage.Unit_isUsed = 1u;
-    res->EVSEPresentVoltage.Unit = iso1unitSymbolType_V;
-
-
-    //----- [BODY (4/10)] EVSEPresentCurrent -----
-    res->EVSEPresentCurrent.Value = 1200;
-    res->EVSEPresentCurrent.Multiplier = -1;
-    //res->EVSEPresentCurrent.Unit_isUsed = 1u;
-    res->EVSEPresentCurrent.Unit = iso1unitSymbolType_A;
-
-
-    //----- [BODY (5/10)] EVSECurrentLimitAchieved -----
-    res->EVSECurrentLimitAchieved = 0;
-
-    //----- [BODY (6/10)] EVSEVoltageLimitAchieved -----
-    res->EVSEVoltageLimitAchieved = 0;
-
-    //----- [BODY (7/10)] EVSEPowerLimitAchieved -----
-    res->EVSEPowerLimitAchieved = 0;
-
-    //----- [BODY (8/10)] EVSEMaximumVoltageLimit -----
-    res->EVSEMaximumVoltageLimit_isUsed = 1u;
-    res->EVSEMaximumVoltageLimit.Value = 7500;
-    res->EVSEMaximumVoltageLimit.Multiplier = -1;
-    //res->EVSEMaximumVoltageLimit.Unit_isUsed = 1u;
-    res->EVSEMaximumVoltageLimit.Unit = iso1unitSymbolType_V;
-
-    //----- [BODY (9/10)] EVSEMaximumCurrentLimit -----
-    res->EVSEMaximumCurrentLimit_isUsed = 1u;
-    res->EVSEMaximumCurrentLimit.Value = 1200;
-    res->EVSEMaximumCurrentLimit.Multiplier = -1;
-    //res->EVSEMaximumCurrentLimit.Unit_isUsed = 1u;
-    res->EVSEMaximumCurrentLimit.Unit = iso1unitSymbolType_A;
-
-    //----- [BODY (10/10)] EVSEMaximumPowerLimit -----
-    res->EVSEMaximumPowerLimit_isUsed = 1u;
-    res->EVSEMaximumPowerLimit.Value = 6000;
-    res->EVSEMaximumPowerLimit.Multiplier = 1;
-    //res->EVSEMaximumPowerLimit.Unit_isUsed = 1u;
-    res->EVSEMaximumPowerLimit.Unit = iso1unitSymbolType_W;
-}
-
-/**
- *
- */
-void Sudo_Parameter_iso1_ChargingStatusRes()
-{
-    //int i = 0;
-	struct iso1ChargingStatusResType *res;
-	init_iso1BodyType(&v2gObject.ISO1.V2G_Message.Body);
-	init_iso1ChargingStatusResType(&v2gObject.ISO1.V2G_Message.Body.ChargingStatusRes);
-
-	res = &v2gObject.ISO1.V2G_Message.Body.ChargingStatusRes;
-	v2gObject.ISO1.V2G_Message.Body.ChargingStatusRes_isUsed = 1u;
-
-
-	//----- [BODY (1/10)] ResponseCode -----
-    res->ResponseCode = OK_ISO15118_2014;
-
-    //----- [BODY (2/10)] AC_EVSEStatus -----
-    res->AC_EVSEStatus.RCD = FALSE;     //FALSE(no error), TRUE(error is detected)
-    res->AC_EVSEStatus.NotificationMaxDelay = 0;
-    res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
-    //	iso1EVSENotificationType_None = 0,
-    //	iso1EVSENotificationType_StopCharging = 1,
-    //	iso1EVSENotificationType_ReNegotiation = 2
-
-    //----- [BODY (3/10)] EVSEMaxCurrent -----
-	res->EVSEMaxCurrent_isUsed = 1u;
-	res->EVSEMaxCurrent.Value = 32;
-	res->EVSEMaxCurrent.Multiplier = 0;
-	res->EVSEMaxCurrent.Unit = iso1unitSymbolType_A;
-
-    //----- [BODY (4/10)] SAScheduleTupleID -----
-	res->SAScheduleTupleID = 0;
-
-    //----- [BODY (5/10)] EVSEID -----
-    res->EVSEID.charactersLen = 37;
-    memset(res->EVSEID.characters, 0, sizeof(res->EVSEID.characters));
-    //sprintf((char*)res->EVSEID.characters, CCS_AC_EVSEID);
-
-    //----- [BODY (6/10)] MeterInfo -----
-    res->MeterInfo_isUsed = 1u;
-    memset(res->MeterInfo.MeterID.characters, 0, sizeof(res->MeterInfo.MeterID.characters));
-    memset(res->MeterInfo.SigMeterReading.bytes, 0, sizeof(res->MeterInfo.SigMeterReading.bytes));
-
-    //[MeterInfo][1/5] MeterID
-    //sprintf((char*)res->MeterInfo.MeterID , CCS_AC_METER_ID);
-
-    //[MeterInfo][2/5] SigMeterReading (optional)
-    //sprintf((char*)res->MeterInfo.SigMeterReading , CCS_AC_SIG_METER_READING);
-
-    //[MeterInfo][3/5] MeterStatus (optional)
-    res->MeterInfo.MeterStatus = 0;
-
-    //[MeterInfo][4/5] MeterReading (optional)
-    res->MeterInfo.MeterReading = 12345;
-
-    //[MeterInfo][5/5] TMeter (optional)
-    res->MeterInfo.TMeter = 1586243587; //Unix Time Stamp format
-
-
-    //----- [BODY (7/10)] ReceiptRequired -----
-    res->ReceiptRequired_isUsed = 1u;
-    res->ReceiptRequired = FALSE;       //optional
-}
-
-/**
- *
- * @param code
- */
-void Check_EVErrorCode(int code)
-{
-    if (code != NO_ERROR)	//NO_ERROR = 0
-    {
-        //Asking CSU to Stop
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        //Update_V2G_Status(Other_Fault);
-
-        DEBUG_INFO("Stop by EV (EVErrorCode = %d (DEC))\n", code);
-    }
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_CurrentDemandRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct CurrentDemandResponse_DIN70121 *cur;
-    static struct ChargingInfoData *sys;
-
-//    int i = 0;
-//    static int EVSE_max_current;
-//    int tmp = 0;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    cur = &ShmCcsData->V2GMessage_DIN70121.CurrentDemandResponse;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    cur->ResponseCode = OK_DIN70121;
-
-    //EVSE Status Code
-    cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
-
-    //[HEADER] Check Req SessionID
-    if (Check_din_V2G_Rx_MSG_SessionID(&v2gObject.DIN) < 0)
-    {
-        cur->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        cur->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //Check for negative EvBatteryMaxCurrent
-    if (sys->EvBatteryMaxCurrent < 0)
-    {
-    	DEBUG_ERROR("EvBatteryMaxCurrent is negative(%.02f) => End_Process\n", sys->EvBatteryMaxCurrent);
-
-        cur->DC_EVSEStatus.EVSEStatusCode = dinresponseCodeType_FAILED_WrongChargeParameter;    //16
-        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-        errn = -1;
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_WrongChargeParameter (023775)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 5;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-    }
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-    SAVE_PhysicalValueType_DIN70121(&cur->EVSEPresentCurrent, (int) (sys->PresentChargingCurrent * 10), A_DIN70121);
-    SAVE_PhysicalValueType_DIN70121(&cur->EVSEPresentVoltage, (int) (sys->PresentChargingVoltage * 10), V_DIN70121);
-    #if TESLA_SLOW_INCREASE_CURRENT_FUNCTION == DISABLE
-    SAVE_PhysicalValueType_DIN70121(&cur->EVSEMaximumCurrentLimit, (int) (sys->AvailableChargingCurrent * 10), A_DIN70121);
-    #endif
-    SAVE_PhysicalValueType_DIN70121(&cur->EVSEMaximumPowerLimit, (int) (sys->AvailableChargingPower * 10), W_DIN70121);
-    SAVE_PhysicalValueType_DIN70121(&cur->EVSEMaximumVoltageLimit, (int) (sys->MaximumChargingVoltage * 10), V_DIN70121);
-
-
-    #if PATCH_FOR_BMW_I3_BUG_EVSEMAXIMUMVOLTAGELIMIT_599V == ENABLE
-    if (sys->EvBatteryMaxVoltage <= 500)
-    {
-        SAVE_PhysicalValueType_DIN70121(&cur->EVSEMaximumVoltageLimit, (int) (500 * 10), V_DIN70121);   //500V
-    }
-    #endif
-
-    //Limit the EVTargetCurrent should be under EVSEMaximumCurrentLimit
-    if (sys->EvBatterytargetCurrent > sys->AvailableChargingCurrent)
-    {
-        sys->EvBatterytargetCurrent = sys->AvailableChargingCurrent;
-
-        //[To-Do] Limit is achieved flag
-    }
-
-    //Isolation Status
-    if (sys->IsolationStatus == GFD_Invalid)  //0:invalid (on going)
-    {
-        cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid; //0
-        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        DEBUG_ERROR("IsolationStatus = %d\n", sys->IsolationStatus);
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-
-    }
-    else if (sys->IsolationStatus == GFD_Valid) //1: valid
-    {
-        cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;  //1
-    }
-    else if (sys->IsolationStatus == GFD_Warning) //2: warning
-    {
-        cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Warning; //2
-    }
-    else if (sys->IsolationStatus == GFD_Fault) //3: fault
-    {
-        cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;  //3
-        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        DEBUG_ERROR("GFD_Fault => Emergency Shutdown\n");
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-    }
-    else //GFD_No_IMD or other unexpected status
-    {
-        cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;  //3
-        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        DEBUG_ERROR("IsolationStatus = %d(undefined)\n", sys->IsolationStatus);
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-    }
-
-    //For testing with Tesla Model 3
-    #if TESLA_SLOW_INCREASE_CURRENT_FUNCTION == ENABLE
-    //[CAUTION][To-Do] Decresement of Current is not implemented.
-    //SAVE_PhysicalValueType_DIN70121(&cur->EVSEMaximumCurrentLimit, 10, A_DIN70121);
-    if (sys->EvBatterytargetCurrent <= 0)
-    {
-        EVSE_max_current =  50;   //10A
-        cur->EVSEMaximumCurrentLimit.Value = 50;   //10A
-        /*
-          DEBUG_PRINTF_EVCOMM_DETAIL("1PresentChargingCurrent = %.02f, EvBatterytargetCurrent = %.02f, EVSE_max_current = %d, EVSEMaximumCurrentLimit = %d\n",
-                    sys->PresentChargingCurrent,
-                    sys->EvBatterytargetCurrent,
-                    EVSE_max_current,
-                    cur->EVSEMaximumCurrentLimit.Value
-                );
-        */
-    }
-    else //1A
-    {
-        /*
-    	  DEBUG_PRINTF_EVCOMM_DETAIL("2PresentChargingCurrent = %.02f, EvBatterytargetCurrent = %.02f, EVSE_max_current = %d, EVSEMaximumCurrentLimit = %d\n",
-                    sys->PresentChargingCurrent,
-                    sys->EvBatterytargetCurrent,
-                    EVSE_max_current,
-                    cur->EVSEMaximumCurrentLimit.Value
-                );
-        */
-        if ((abs((int)sys->PresentChargingCurrent - (int)sys->EvBatterytargetCurrent) < 3)&&(abs((int)(EVSE_max_current/10) - (int)sys->EvBatterytargetCurrent) < 3))
-        {
-            tmp = EVSE_max_current + 50; //10A
-
-            if (tmp <= (int)(sys->AvailableChargingCurrent * 10))
-            {
-             cur->EVSEMaximumCurrentLimit.Value = (int)tmp;
-                EVSE_max_current = tmp;
-            }
-            else
-            {
-                cur->EVSEMaximumCurrentLimit.Value = (int) (sys->AvailableChargingCurrent * 10);   //max is set to 40A
-                 EVSE_max_current =  (int) (sys->AvailableChargingCurrent * 10);
-            }
-        }
-    }
-    #endif
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        //Check for Alarm Code: CCS GFD trip (012235)
-        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
-        {
-        	DEBUG_ERROR("[DIN]CCS GFD trip => EVSE_Shutdown\n");
-            cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
-        }
-        else
-        {
-        	DEBUG_ERROR("[DIN]]EVSE_Shutdown\n");
-            cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
-        }
-
-        //cur->ResponseCode = FAILED_DIN70121;
-        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-        //errn = -1;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        //Check for Alarm Code: CCS GFD trip (012235)
-        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
-        {
-            DEBUG_INFO("[DIN]]CCS GFD trip => EVSE_EmergencyShutdown\n");
-            cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
-        }
-        else
-        {
-        	DEBUG_ERROR("[DIN]EVSE_EmergencyShutdown\n");
-            cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
-        }
-
-        //cur->ResponseCode = FAILED_DIN70121;
-        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        //errn = -1;
-    }
-    else if (ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("[DIN]Permission OFF\n");
-        //cur->ResponseCode = FAILED_DIN70121;
-        cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
-        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-        //errn = -1;
-    }
-    else
-    {
-        //null
-    }
-
-    //Response to CP Error
-    #if CP_PROTECTION_MECHANISM == ENABLE
-    if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
-    {
-        cur->ResponseCode = FAILED_DIN70121;
-        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_CP_State_Error (023889)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-
-        DEBUG_INFO("Emergency Stop by CP Error (%d, %.02f V)\n", sys->CpState, sys->CpVoltage);
-    }
-    #endif
-
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_din_CurrentDemandRes(&v2gObject.DIN, ShmCcsData);
-    #else
-    Sudo_Parameter_din_CurrentDemandRes();
-    #endif
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.DIN) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_CurrentDemandRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct CurrentDemandResponse_ISO15118_2014 *cur;
-    static struct ChargingInfoData *sys;
-//    int i = 0;
-//    static int EVSE_max_current;
-//    int tmp = 0;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    cur = &ShmCcsData->V2GMessage_ISO15118_2014.CurrentDemandResponse;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    cur->ResponseCode = OK_ISO15118_2014;
-
-    //EVSE Status Code
-    cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
-
-    //[HEADER] Check Req SessionID
-    if (Check_iso1_V2G_Rx_MSG_SessionID(&v2gObject.ISO1) < 0)
-    {
-        cur->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        cur->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //Check for negative EvBatteryMaxCurrent
-    if (sys->EvBatteryMaxCurrent < 0)
-    {
-    	DEBUG_ERROR("EvBatteryMaxCurrent is negative(%.02f) => End_Process\n", sys->EvBatteryMaxCurrent);
-
-        cur->ResponseCode = iso1responseCodeType_FAILED_WrongChargeParameter;   //16
-        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-        errn = -1;
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_WrongChargeParameter (023775)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 5;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-    }
-
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-    SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEPresentCurrent, (int) (sys->PresentChargingCurrent * 10), A_ISO15118_2014);
-    SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEPresentVoltage, (int) (sys->PresentChargingVoltage * 10), V_ISO15118_2014);
-    #if TESLA_SLOW_INCREASE_CURRENT_FUNCTION == DISABLE
-    SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEMaximumCurrentLimit, (int) (sys->AvailableChargingCurrent * 10), A_ISO15118_2014);
-    #endif
-    SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEMaximumPowerLimit, (int) (sys->AvailableChargingPower * 10), W_ISO15118_2014);
-    SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEMaximumVoltageLimit, (int) (sys->MaximumChargingVoltage * 10), V_ISO15118_2014);
-
-
-    #if PATCH_FOR_BMW_I3_BUG_EVSEMAXIMUMVOLTAGELIMIT_599V == ENABLE
-    if (sys->EvBatteryMaxVoltage <= 500)
-    {
-        SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEMaximumVoltageLimit, (int) (500 * 10), V_ISO15118_2014);   //500V
-    }
-    #endif
-
-    //Limit the EVTargetCurrent should be under EVSEMaximumCurrentLimit
-    if (sys->EvBatterytargetCurrent > sys->AvailableChargingCurrent)
-    {
-        sys->EvBatterytargetCurrent = sys->AvailableChargingCurrent;
-
-        //[To-Do] Limit is achieved flag
-    }
-
-    //Isolation Status
-    if (sys->IsolationStatus == GFD_Invalid) //0: invalid (on going)
-    {
-        cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid; //0
-        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        DEBUG_ERROR("IsolationStatus = %d\n", sys->IsolationStatus);
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-    }
-    else if (sys->IsolationStatus == GFD_Valid) //1: valid
-    {
-        cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;  //1
-    }
-    else if (sys->IsolationStatus == GFD_Warning) //2: warning
-    {
-        cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Warning; //2
-    }
-    else if (sys->IsolationStatus == GFD_Fault) //3: fault
-    {
-        cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;  //3
-        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        DEBUG_ERROR("GFD_Fault => EmergencyShutdown\n");
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-    }
-    else
-    {
-        cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;  //3
-        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        DEBUG_ERROR("IsolationStatus = %d(undefined)\n", sys->IsolationStatus);
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-    }
-
-    //For testing with Tesla Model 3
-    #if TESLA_SLOW_INCREASE_CURRENT_FUNCTION == ENABLE
-    //[CAUTION][To-Do] Decresement of Current is not implemented.
-    //SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEMaximumCurrentLimit, 10, A_ISO15118_2014);
-    if (sys->EvBatterytargetCurrent <= 0)
-    {
-        EVSE_max_current =  50;   //10A
-        cur->EVSEMaximumCurrentLimit.Value = 50;   //10A
-        /*
-          DEBUG_PRINTF_EVCOMM_DETAIL("1PresentChargingCurrent = %.02f, EvBatterytargetCurrent = %.02f, EVSE_max_current = %d, EVSEMaximumCurrentLimit = %d\n",
-                    sys->PresentChargingCurrent,
-                    sys->EvBatterytargetCurrent,
-                    EVSE_max_current,
-                    cur->EVSEMaximumCurrentLimit.Value
-                );
-        */
-    }
-    else //1A
-    {
-        /*
-    	  DEBUG_PRINTF_EVCOMM_DETAIL("2PresentChargingCurrent = %.02f, EvBatterytargetCurrent = %.02f, EVSE_max_current = %d, EVSEMaximumCurrentLimit = %d\n",
-                    sys->PresentChargingCurrent,
-                    sys->EvBatterytargetCurrent,
-                    EVSE_max_current,
-                    cur->EVSEMaximumCurrentLimit.Value
-                );
-        */
-        if ((abs((int)sys->PresentChargingCurrent - (int)sys->EvBatterytargetCurrent) < 3)&&(abs((int)(EVSE_max_current/10) - (int)sys->EvBatterytargetCurrent) < 3))
-        {
-            tmp = EVSE_max_current + 50; //10A
-
-            if (tmp <= (int)(sys->AvailableChargingCurrent * 10))
-            {
-             cur->EVSEMaximumCurrentLimit.Value = (int)tmp;
-                EVSE_max_current = tmp;
-            }
-            else
-            {
-                cur->EVSEMaximumCurrentLimit.Value = (int) (sys->AvailableChargingCurrent * 10);   //max is set to 40A
-                 EVSE_max_current =  (int) (sys->AvailableChargingCurrent * 10);
-            }
-        }
-    }
-    #endif
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        //Check for Alarm Code: CCS GFD trip (012235)
-        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
-        {
-        	DEBUG_ERROR("CCS GFD trip => EVSE_Shutdown\n");
-            cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
-        }
-        else
-        {
-        	DEBUG_ERROR("EVSE_Shutdown\n");
-            cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
-        }
-
-        //cur->ResponseCode = FAILED_ISO15118_2014;
-        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-        //errn = -1;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        //Check for Alarm Code: CCS GFD trip (012235)
-        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
-            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
-        {
-        	DEBUG_ERROR("CCS GFD trip => EVSE_EmergencyShutdown\n");
-            cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
-        }
-        else
-        {
-        	DEBUG_ERROR("EVSE_EmergencyShutdown\n");
-            cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
-        }
-
-        //cur->ResponseCode = FAILED_ISO15118_2014;
-        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        //errn = -1;
-    }
-    else if (ShmInternalComm->ChargingPermission == FALSE)
-    {
-    	DEBUG_ERROR("Permission OFF\n");
-        //cur->ResponseCode = FAILED_ISO15118_2014;
-        cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
-        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-        //errn = -1;
-    }
-    else
-    {
-        //null
-    }
-
-    //Response to CP Error
-    #if CP_PROTECTION_MECHANISM == ENABLE
-    if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
-    {
-        cur->ResponseCode = FAILED_ISO15118_2014;
-        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        Update_V2G_Status(Other_Fault);
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_CP_State_Error (023889)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-
-        DEBUG_INFO("[CurrentDemand]Emergency Stop by CP Error (%d, %.02f V)\n", sys->CpState, sys->CpVoltage);
-    }
-    #endif
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_iso1_CurrentDemandRes(&v2gObject.ISO1, ShmCcsData);
-    #else
-    Sudo_Parameter_iso1_CurrentDemandRes();
-    #endif
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO1) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_ChargingStatusRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct ChargingStatusResponse_ISO15118_2014 *res;
-    static struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    res = &ShmCcsData->V2GMessage_ISO15118_2014.ChargingStatusResponse;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    //Init
-    res->ResponseCode = OK_ISO15118_2014;
-    res->ReceiptRequired = FALSE;       //optional
-    res->SAScheduleTupleID = 0;
-    res->AC_EVSEStatus.RCD = FALSE;     //FALSE(no error), TRUE(error is detected)
-    res->AC_EVSEStatus.NotificationMaxDelay = 0;
-    res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
-    //	iso1EVSENotificationType_None = 0,
-    //	iso1EVSENotificationType_StopCharging = 1,
-    //	iso1EVSENotificationType_ReNegotiation = 2
-
-    //[HEADER] Check Req SessionID
-    if (Check_iso1_V2G_Rx_MSG_SessionID(&v2gObject.ISO1) < 0)
-    {
-        res->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        res->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //EVSE ID
-    memset(res->EVSEID, 0, sizeof(res->EVSEID));
-    sprintf((char*)res->EVSEID, CCS_AC_EVSEID);
-
-    //[MeterInfo][0/5] init
-    //memset(res->MeterInfo.MeterID, 0, sizeof(res->MeterInfo.MeterID));
-    //memset(res->MeterInfo.SigMeterReading, 0, sizeof(res->MeterInfo.SigMeterReading));
-
-    //[MeterInfo][1/5] MeterID
-    //sprintf((char*)res->MeterInfo.MeterID, CCS_AC_METER_ID);
-
-    //[MeterInfo][2/5] SigMeterReading (optional)
-    //sprintf((char*)res->MeterInfo.SigMeterReading , CCS_AC_SIG_METER_READING);
-
-    //[MeterInfo][3/5] MeterStatus (optional)
-    res->MeterInfo.MeterStatus = 0;
-
-    //[MeterInfo][4/5] MeterReading (optional)
-    res->MeterInfo.MeterReading = 12345;
-
-    //[MeterInfo][5/5] TMeter (optional)
-    res->MeterInfo.TMeter = 1586243587; //Unix Time Stamp format
-
-    //STEP 2: ============ Modify Parameter of ShmCcsData ============
-    if(ShmCcsData->EnergyTransferMode == MODE_DC_EXTENDED)
-    {
-    	SAVE_PhysicalValueType_ISO15118_2014(&res->EVSEMaxCurrent, (int)(sys->AvailableChargingCurrent * 10), A_ISO15118_2014);
-
-        //Isolation Status (RCD)
-        if (sys->IsolationStatus == 0)  //Isolation is invalid
-        {
-            res->AC_EVSEStatus.RCD = TRUE;     //FALSE(no error), TRUE(error is detected)
-            res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-            CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-            DEBUG_ERROR("IsolationStatus: %d\n", sys->IsolationStatus);
-            Update_V2G_Status(Other_Fault);
-            errn = -1;
-        }
-        else if (sys->IsolationStatus == 1) //Isolation is valid
-        {
-            res->AC_EVSEStatus.RCD = FALSE;     //FALSE(no error), TRUE(error is detected)
-            res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
-        }
-        else
-        {
-            res->AC_EVSEStatus.RCD = TRUE;     //FALSE(no error), TRUE(error is detected)
-            res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-            CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-            DEBUG_ERROR("IsolationStatus = %d(undefined)\n", sys->IsolationStatus);
-            Update_V2G_Status(Other_Fault);
-            errn = -1;
-        }
-
-        //Check for CSU command of "Stop by EVSE"
-        if (sys->DC_EVSEStatus == EVSE_Shutdown)
-        {
-            //res->ResponseCode = FAILED_ISO15118_2014;
-            res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-            //errn = -1;
-        }
-        else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-        {
-            //res->ResponseCode = FAILED_ISO15118_2014;
-            res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-            //errn = -1;
-        }
-        else if (ShmInternalComm->ChargingPermission == FALSE)
-        {
-            //res->ResponseCode = FAILED_ISO15118_2014;
-            res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-            //errn = -1;
-        }
-
-        //Response to CP Error
-        #if CP_PROTECTION_MECHANISM == ENABLE
-        if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
-        {
-            res->ResponseCode = FAILED_ISO15118_2014;
-            res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-            CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-            Update_V2G_Status(Other_Fault);
-
-            //Update_ShmStatusCode(); //[To-Do] to be implemented
-            //CCS_SECC_CP_State_Error (023889)
-            ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-            ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-            ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-            ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-            ShmStatusCodeData->PresentStatusCode[0][4] = 8;
-            ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-            CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-
-            DEBUG_INFO("Emergency Stop by CP Error (%d, %.02f V)\n", sys->CpState, sys->CpVoltage);
-        }
-        #endif
-    }
-    else
-    {
-    	SAVE_PhysicalValueType_ISO15118_2014(&res->EVSEMaxCurrent, (int)(sys->AvailableChargingCurrent * 10), A_ISO15118_2014);
-
-        //Isolation Status (RCD)
-		res->AC_EVSEStatus.RCD = FALSE;     //FALSE(no error), TRUE(error is detected)
-		res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
-
-		//Check for CSU command of "Stop by EVSE"
-        if (ShmInternalComm->ChargingPermission == FALSE)
-        {
-            //res->ResponseCode = FAILED_ISO15118_2014;
-            res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-            //errn = -1;
-        }
-
-        //Response to CP Error
-#if CP_PROTECTION_MECHANISM == ENABLE
-        if((sys->CpState != 3) && (sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
-        {
-            res->ResponseCode = FAILED_ISO15118_2014;
-            res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
-            CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-            Update_V2G_Status(Other_Fault);
-
-            //Update_ShmStatusCode(); //[To-Do] to be implemented
-            //CCS_SECC_CP_State_Error (023889)
-            ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-            ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-            ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-            ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-            ShmStatusCodeData->PresentStatusCode[0][4] = 8;
-            ShmStatusCodeData->PresentStatusCode[0][5] = 9;
-            CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-
-            DEBUG_ERROR("Emergency Stop by CP Error (%d, %.02f V)\n", sys->CpState, sys->CpVoltage);
-        }
-#endif
-    }
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-#if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_iso1_ChargingStatusRes(&v2gObject.ISO1, ShmCcsData);
-#else
-    Sudo_Parameter_iso1_ChargingStatusRes();
-    #endif
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO1) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_CurrentDemandReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("[V2G[RX]]CurrentDemandReq\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_DIN_CurrentDemandReq(&v2gObject.DIN);
-
-    //Save into Share Memory
-    SHM_Save_din_CurrentDemandReq(ShmCcsData, &v2gObject.DIN, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.CurrentDemandRequest.DC_EVStatus.EVErrorCode);
-
-    errn = Proc_din_CurrentDemandRes(AcceptFd);
-    if (errn == 0)
-    {
-        //Response is sent successfully.
-        DEBUG_INFO("[V2G][TX]CurrentDemandRes\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_din_CurrentDemandRes fail: (%d,DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_CurrentDemandReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO1_CurrentDemandReq(&v2gObject.ISO1);
-
-    //Save into Share Memory
-    SHM_Save_iso1_CurrentDemandReq(ShmCcsData, &v2gObject.ISO1, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.CurrentDemandRequest.DC_EVStatus.EVErrorCode);
-
-    errn = Proc_iso1_CurrentDemandRes(AcceptFd);
-    if (errn == 0)
-    {
-        //Response is sent successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso1_CurrentDemandRes fail: (%d,DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_ChargingStatusReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO1_ChargingStatusReq(&v2gObject.ISO1);
-
-    //Save into Share Memory
-    SHM_Save_iso1_ChargingStatusReq(ShmCcsData, &v2gObject.ISO1, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    //no content in ISO1
-
-    errn = Proc_iso1_ChargingStatusRes(AcceptFd);
-    if (errn == 0)
-    {
-        //Response is sent successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso1_ChargingStatusRes() fail: (%d,DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_PowerDeliveryStopRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    struct dinPowerDeliveryResType *res;
-    struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    res = &v2gObject.DIN.V2G_Message.Body.PowerDeliveryRes;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    res->ResponseCode = OK_DIN70121;
-
-    //[HEADER] Check Req SessionID
-    if (Check_din_V2G_Rx_MSG_SessionID(&v2gObject.DIN) < 0)
-    {
-        res->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        res->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    ShmCcsData->V2GMessage_DIN70121.PowerDeliveryResponse.DC_EVSEStatus.EVSEStatusCode = EVSE_NotReady;
-    SHM_Read_din_PowerDeliveryRes(&v2gObject.DIN, ShmCcsData);
-    #else
-    Sudo_Parameter_din_PreChargeRes();
-    #endif
-
-    //EVSE Status Code
-    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        //res->ResponseCode = FAILED_DIN70121;
-        res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        //res->ResponseCode = FAILED_DIN70121;
-        res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-    }
-    else if (ShmInternalComm->ChargingPermission == FALSE)
-    {
-        //res->ResponseCode = FAILED_DIN70121;
-        res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-    }
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.DIN) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_PowerDeliveryStopRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    struct iso1PowerDeliveryResType *res;
-    struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    res = &v2gObject.ISO1.V2G_Message.Body.PowerDeliveryRes;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    res->ResponseCode = OK_ISO15118_2014;
-
-    //[HEADER] Check Req SessionID
-    if (Check_iso1_V2G_Rx_MSG_SessionID(&v2gObject.ISO1) < 0)
-    {
-        res->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        res->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    if(ShmCcsData->EnergyTransferMode == MODE_DC_EXTENDED)
-    {
-#if PARAMETER_NORMAL_MODE == ENABLE
-		ShmCcsData->V2GMessage_ISO15118_2014.PowerDeliveryResponse.DC_EVSEStatus.DC_EVSEStatusCode = EVSE_NotReady;
-		SHM_Read_iso1_PowerDeliveryRes(&v2gObject.ISO1, ShmCcsData);
-#else
-		Sudo_Parameter_iso1_PreChargeRes();
-#endif
-
-        //EVSE Status Code
-        res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
-        res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;  //1 /*+++ 20200808, vern, Isolation Status should be valid during 2nd PowerDelivert ---*/
-
-        //Check for CSU command of "Stop by EVSE"
-        if (sys->DC_EVSEStatus == EVSE_Shutdown)
-        {
-            //res->ResponseCode = FAILED_ISO15118_2014;
-        	res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready; /*+++ 20200808, vern, Isolation Status should be valid during 2nd PowerDelivert ---*/
-        }
-        else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-        {
-            //res->ResponseCode = FAILED_ISO15118_2014;
-            res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        }
-        else if (ShmInternalComm->ChargingPermission == FALSE)
-        {
-            //res->ResponseCode = FAILED_ISO15118_2014;
-        	res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready; /*+++ 20200808, vern, Isolation Status should be valid during 2nd PowerDelivert ---*/
-        }
-    }
-    else
-    {
-#if PARAMETER_NORMAL_MODE == ENABLE
-		SHM_Read_iso1_PowerDeliveryRes(&v2gObject.ISO1, ShmCcsData);
-#endif
-
-        //EVSE Status Code
-		res->AC_EVSEStatus.RCD = 0;
-        res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
-        res->AC_EVSEStatus.NotificationMaxDelay = 10;
-
-    }
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO1) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_PowerDeliveryStopReq(int AcceptFd)
-{
-    int errn = 0;
-    //Request CSU to STOP
-    //This should be reponsed as soon as possible once this message is received.
-    CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-    EVCOMM_SYS_INFO.EvBatterytargetVoltage = 0;
-    EVCOMM_SYS_INFO.EvBatterytargetCurrent = 0;
-
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_DIN_PowerDeliveryReq(&v2gObject.DIN);
-
-    //Save into Share Memory
-    SHM_Save_din_PowerDeliveryReq(ShmCcsData, &v2gObject.DIN, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.PowerDeliveryRequest.DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode);
-
-    //[To-Do] Sending response after the EVSE output voltage decreases to under 60V
-    usleep(1500000);    //1.5 seconds
-    //sleep(1);   //1 second
-
-    errn = Proc_din_PowerDeliveryStopRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_din_PowerDeliveryStopRes() fail: %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_PowerDeliveryStopReq(int AcceptFd)
-{
-    int errn = 0;
-    //Request CSU to STOP
-    //This should be reponsed as soon as possible once this message is received.
-    CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-    EVCOMM_SYS_INFO.EvBatterytargetVoltage = 0;
-    EVCOMM_SYS_INFO.EvBatterytargetCurrent = 0;
-
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO1_PowerDeliveryReq(&v2gObject.ISO1);
-
-    //Save into Share Memory
-    SHM_Save_iso1_PowerDeliveryReq(ShmCcsData, &v2gObject.ISO1, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.PowerDeliveryRequest.DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode);
-
-    //[To-Do] Sending response after the EVSE output voltage decreases to under 60V
-    usleep(1500000);    //1.5 seconds
-    //sleep(1);   //1 second
-    errn = Proc_iso1_PowerDeliveryStopRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso1_PowerDeliveryStopRes fail(): %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param shm_ccs
- */
-void SHM_Init_din_WeldingDetectionRes(struct CcsData *shm_ccs)
-{
-	struct WeldingDetectionResponse_DIN70121 *in;
-
-	in = &shm_ccs->V2GMessage_DIN70121.WeldingDetectionResponse;
-
-
-	//----- [BODY (1/3)] ResponseCode -----
-    in->ResponseCode = dinresponseCodeType_OK;
-
-    //----- [BODY (2/3)] EVSEPresentVoltage -----
-    short value = 0; int multiplier = 0; unsigned char unit = 0;
-
-    //value = 3820; multiplier = -1; unit = V_DIN70121;    //382V, for test only.
-    value = 0; multiplier = 0; unit = V_DIN70121;
-	SHM_Save_dinPhysicalValueType(&in->EVSEPresentVoltage, value, multiplier, unit);
-
-    //----- [BODY (3/3)] DC_EVSEStatus -----
-    SHM_Init_dinDC_EVSEStatusType(&in->DC_EVSEStatus);
-}
-
-/**
- *
- */
-void Sudo_Parameter_din_WeldingDetectionRes()
-{
-    init_dinBodyType(&v2gObject.DIN.V2G_Message.Body);
-    init_dinWeldingDetectionResType(&v2gObject.DIN.V2G_Message.Body.WeldingDetectionRes);
-
-    v2gObject.DIN.V2G_Message.Body.WeldingDetectionRes_isUsed = 1u;
-
-    //----- [BODY (1/3)] ResponseCode -----
-    struct dinWeldingDetectionResType *res;
-    res = &v2gObject.DIN.V2G_Message.Body.WeldingDetectionRes;
-    res->ResponseCode = dinresponseCodeType_OK;
-
-
-    //----- [BODY (2/3)] EVSEPresentVoltage -----
-    res->EVSEPresentVoltage.Value = 3820;
-    res->EVSEPresentVoltage.Multiplier = -1;
-    res->EVSEPresentVoltage.Unit_isUsed = 1u;
-    res->EVSEPresentVoltage.Unit = dinunitSymbolType_V;
-    //	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 -----
-    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
-    res->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;
-    //	dinisolationLevelType_Invalid = 0,
-    //	dinisolationLevelType_Valid = 1,
-    //	dinisolationLevelType_Warning = 2,
-    //	dinisolationLevelType_Fault = 3
-
-    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
-    // dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
-    // dinDC_EVSEStatusCodeType_EVSE_Ready = 1,
-    // 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
-
-    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
-
-    res->DC_EVSEStatus.EVSENotification = dinEVSENotificationType_None;
-    // dinEVSENotificationType_None = 0,
-    // dinEVSENotificationType_StopCharging = 1,
-    // dinEVSENotificationType_ReNegotiation = 2
-}
-
-/**
- *
- */
-void Sudo_Parameter_iso1_WeldingDetectionRes()
-{
-    init_iso1BodyType(&v2gObject.ISO1.V2G_Message.Body);
-    init_iso1WeldingDetectionResType(&v2gObject.ISO1.V2G_Message.Body.WeldingDetectionRes);
-
-    v2gObject.ISO1.V2G_Message.Body.WeldingDetectionRes_isUsed = 1u;
-
-    //----- [BODY (1/3)] ResponseCode -----
-    struct iso1WeldingDetectionResType *res;
-    res = &v2gObject.ISO1.V2G_Message.Body.WeldingDetectionRes;
-    res->ResponseCode = iso1responseCodeType_OK;
-
-
-    //----- [BODY (2/3)] EVSEPresentVoltage -----
-    res->EVSEPresentVoltage.Value = 3820;
-    res->EVSEPresentVoltage.Multiplier = -1;
-    //res->EVSEPresentVoltage.Unit_isUsed = 1u;
-    res->EVSEPresentVoltage.Unit = iso1unitSymbolType_V;
-    //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 -----
-    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
-    res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;
-    //iso1isolationLevelType_Invalid = 0,
-	//iso1isolationLevelType_Valid = 1,
-	//iso1isolationLevelType_Warning = 2,
-	//iso1isolationLevelType_Fault = 3,
-	//iso1isolationLevelType_No_IMD = 4
-
-    res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
-    //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
-
-    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
-
-    res->DC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
-    //iso1EVSENotificationType_None = 0,
-	//iso1EVSENotificationType_StopCharging = 1,
-	//iso1EVSENotificationType_ReNegotiation = 2
-}
-
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_WeldingDetectionRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct WeldingDetectionResponse_DIN70121 *wel;
-    static struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    wel = &ShmCcsData->V2GMessage_DIN70121.WeldingDetectionResponse;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    wel->ResponseCode = OK_DIN70121;
-
-    //[HEADER] Check Req SessionID
-    if (Check_din_V2G_Rx_MSG_SessionID(&v2gObject.DIN) < 0)
-    {
-        wel->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        wel->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-    SAVE_PhysicalValueType_DIN70121(&wel->EVSEPresentVoltage, (int) (sys->PresentChargingVoltage * 10), V_DIN70121);
-
-    //EVSE Status Code
-    wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        //wel->ResponseCode = FAILED_DIN70121;
-        wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        //wel->ResponseCode = FAILED_DIN70121;
-        wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-    }
-    else if (ShmInternalComm->ChargingPermission == FALSE)
-    {
-        //wel->ResponseCode = FAILED_DIN70121;
-        wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
-    }
-
-    //Isolation Status
-    if (sys->IsolationStatus == GFD_Invalid)  //0:invalid (on going)
-    {
-        wel->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid; //0
-        wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        DEBUG_ERROR("IsolationStatus = %d\n", sys->IsolationStatus);
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-
-    }
-    else if (sys->IsolationStatus == GFD_Valid) //1: valid
-    {
-        wel->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;  //1
-    }
-    else if (sys->IsolationStatus == GFD_Warning) //2: warning
-    {
-        wel->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Warning; //2
-    }
-    else if (sys->IsolationStatus == GFD_Fault) //3: fault
-    {
-        wel->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;  //3
-        wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        DEBUG_ERROR("GFD_Fault => Emergency Shutdown\n");
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-    }
-    else //GFD_No_IMD or other unexpected status
-    {
-        wel->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;  //3
-        wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        DEBUG_ERROR("IsolationStatus = %d(undefined)\n", sys->IsolationStatus);
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-    }
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_din_WeldingDetectionRes(&v2gObject.DIN, ShmCcsData);
-    #else
-    Sudo_Parameter_din_WeldingDetectionRes();
-    #endif
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.DIN) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_WeldingDetectionRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    static struct WeldingDetectionResponse_ISO15118_2014 *wel;
-    static struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    wel = &ShmCcsData->V2GMessage_ISO15118_2014.WeldingDetectionResponse;
-    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    wel->ResponseCode = OK_ISO15118_2014;
-
-    //[HEADER] Check Req SessionID
-    if (Check_iso1_V2G_Rx_MSG_SessionID(&v2gObject.ISO1) < 0)
-    {
-        wel->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        wel->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-    SAVE_PhysicalValueType_ISO15118_2014(&wel->EVSEPresentVoltage, (int) (sys->PresentChargingVoltage * 10), V_ISO15118_2014);
-
-    //EVSE Status Code
-    wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
-
-    //Check for CSU command of "Stop by EVSE"
-    if (sys->DC_EVSEStatus == EVSE_Shutdown)
-    {
-        //wel->ResponseCode = FAILED_ISO15118_2014;
-        wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-    }
-    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
-    {
-        //wel->ResponseCode = FAILED_ISO15118_2014;
-        wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-    }
-    else if (ShmInternalComm->ChargingPermission == FALSE)
-    {
-        //wel->ResponseCode = FAILED_ISO15118_2014;
-        wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
-    }
-
-    //Isolation Status
-    if (sys->IsolationStatus == GFD_Invalid) //0: invalid (on going)
-    {
-        wel->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid; //0
-        wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        DEBUG_ERROR("IsolationStatus = %d\n", sys->IsolationStatus);
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-    }
-    else if (sys->IsolationStatus == GFD_Valid) //1: valid
-    {
-        wel->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;  //1
-    }
-    else if (sys->IsolationStatus == GFD_Warning) //2: warning
-    {
-        wel->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Warning; //2
-    }
-    else if (sys->IsolationStatus == GFD_Fault) //3: fault
-    {
-        wel->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;  //3
-        wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        DEBUG_ERROR("GFD_Fault => EmergencyShutdown\n");
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-    }
-    else
-    {
-        wel->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;  //3
-        wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
-        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-        DEBUG_ERROR("IsolationStatus = %d(undefined)\n", sys->IsolationStatus);
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-    }
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_iso1_WeldingDetectionRes(&v2gObject.ISO1, ShmCcsData);
-    #else
-    Sudo_Parameter_iso1_WeldingDetectionRes();
-    #endif
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO1) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_WeldingDetectionReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_DIN_WeldingDetectionReq(&v2gObject.DIN);
-
-    //Save into Share Memory
-    SHM_Save_din_WeldingDetectionReq(ShmCcsData, &v2gObject.DIN, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.WeldingDetectionRequest.DC_EVStatus.EVErrorCode);
-
-    errn = Proc_din_WeldingDetectionRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_din_WeldingDetectionRes() fail: %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_WeldingDetectionReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO1_WeldingDetectionReq(&v2gObject.ISO1);
-
-    //Save into Share Memory
-    SHM_Save_iso1_WeldingDetectionReq(ShmCcsData, &v2gObject.ISO1, ShmSysConfigAndInfo);
-
-    //Check for EV Error Code
-    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.WeldingDetectionRequest.DC_EVStatus.EVErrorCode);
-
-    errn = Proc_iso1_WeldingDetectionRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-        DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso1_WeldingDetectionRes() fail: %d (DEC)", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param shm_ccs
- */
-void SHM_Init_din_SessionStopRes(struct CcsData *shm_ccs)
-{
-	struct SessionStopResponse_DIN70121 *in;
-
-	in = &shm_ccs->V2GMessage_DIN70121.SessionStopResponse;
-
-	//----- [BODY (1/3)] ResponseCode -----
-    in->ResponseCode = dinresponseCodeType_OK;
-}
-
-/**
- *
- */
-void Sudo_Parameter_din_SessionStopRes()
-{
-    init_dinBodyType(&v2gObject.DIN.V2G_Message.Body);
-    init_dinSessionStopResType(&v2gObject.DIN.V2G_Message.Body.SessionStopRes);
-
-    v2gObject.DIN.V2G_Message.Body.SessionStopRes_isUsed = 1u;
-
-    //----- [BODY (1/3)] ResponseCode -----
-    struct dinSessionStopResType *res;
-    res = &v2gObject.DIN.V2G_Message.Body.SessionStopRes;
-    res->ResponseCode = dinresponseCodeType_OK;
-}
-
-/**
- *
- */
-void Sudo_Parameter_iso1_SessionStopRes()
-{
-    init_iso1BodyType(&v2gObject.ISO1.V2G_Message.Body);
-    init_iso1SessionStopResType(&v2gObject.ISO1.V2G_Message.Body.SessionStopRes);
-
-    v2gObject.ISO1.V2G_Message.Body.SessionStopRes_isUsed = 1u;
-
-    //----- [BODY (1/3)] ResponseCode -----
-    struct iso1SessionStopResType *res;
-    res = &v2gObject.ISO1.V2G_Message.Body.SessionStopRes;
-    res->ResponseCode = iso1responseCodeType_OK;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_SessionStopRes(int AcceptFd)
-{
-    //[ To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    struct SessionStopResponse_DIN70121 *stp;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    stp = &ShmCcsData->V2GMessage_DIN70121.SessionStopResponse;
-
-    stp->ResponseCode = OK_DIN70121;
-
-    //[HEADER] Check Req SessionID
-    if (Check_din_V2G_Rx_MSG_SessionID(&v2gObject.DIN) < 0)
-    {
-        stp->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        stp->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_din_SessionStopRes(&v2gObject.DIN, ShmCcsData);
-    #else
-    Sudo_Parameter_din_SessionStopRes();
-    #endif
-
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.DIN) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-
-    //STEP 5: ============ Update Flags ===========
-    EVCOMM_SYS_INFO.ConnectorLocked = FALSE;   //Indicating CSU that the Connector is unlocked.
-                                               //Once this is set, the CSU should
-
-    // =========== Annouce to CSU [To-Be Implemented]=============
-    CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;    //This should be also added to EV Error events.
-
-
-    // =========== Re-initialized [To-Be Implemented]=============
-    //Keep 5% PWM for 2 seconds
-    for(int idx=3;idx>0;idx++)
-    {
-		DEBUG_INFO("PWM 5\%% countdown: %d\n", idx);
-		sleep(1);
-    }
-    OutputCpPwmDuty(100);
-
-    //[To-Do] Reset All Share memory
-
-    //[To-Do] CCS Module enter "idle" mode and CSU should check for this state.
-
-    //system("reboot -f");
-    //sleep(5);
-    //system("reboot -f");
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_SessionStopRes(int AcceptFd)
-{
-    //[To-Do] Check SessionID of ServiceDiscoveryReq,
-    //if it is not the same, the packet should be ignored.
-
-    //STEP 1: ============ Initialize ============
-    //int i = 0;
-    int errn = 0;
-    bitstream_t v2g_tx_stream;
-    struct SessionStopResponse_ISO15118_2014 *stp;
-    //struct ChargingInfoData *sys;
-
-    size_t pos = 0;
-    v2g_tx_stream.pos = &pos;
-    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
-    v2g_tx_stream.data = v2gBuffer.tx;
-    stp = &ShmCcsData->V2GMessage_ISO15118_2014.SessionStopResponse;
-    //sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
-
-    stp->ResponseCode = OK_ISO15118_2014;
-
-    //[HEADER] Check Req SessionID
-    if (Check_iso1_V2G_Rx_MSG_SessionID(&v2gObject.ISO1) < 0)
-    {
-        stp->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
-        DEBUG_ERROR("unmatched SessionID => End_Process\n");
-        errn = -1;
-    }
-
-    //Check for SequenceError
-    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
-    {
-        stp->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
-        DEBUG_ERROR("SequenceError => End_Process\n");
-        errn = -1;
-
-        //Update_ShmStatusCode(); //[To-Do] to be implemented
-        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
-        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
-        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
-    }
-
-    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
-
-
-    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
-    #if PARAMETER_NORMAL_MODE == ENABLE
-    SHM_Read_iso1_SessionStopRes(&v2gObject.ISO1, ShmCcsData);
-    #else
-    Sudo_Parameter_iso1_SessionStopRes();
-    #endif
-
-
-    //STEP 4: ============ Encode and Send Response Message ===========
-    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &v2gObject.ISO1) != 0)
-    {
-    	DEBUG_ERROR("Tx encoded msg error\n");
-        errn = -1;
-    }
-
-    //STEP 5: ============ Update Flags ===========
-    EVCOMM_SYS_INFO.ConnectorLocked = FALSE;   //Indicating CSU that the Connector is unlocked.
-                                               //Once this is set, the CSU should
-
-    // =========== Annouce to CSU [To-Be Implemented]=============
-    CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;    //This should be also added to EV Error events.
-
-
-    // =========== Re-initialized [To-Be Implemented]=============
-    //Keep 5% PWM for 2 seconds
-    for(int idx=2;idx>0;idx--)
-    {
-    	DEBUG_INFO("PWM 5\%% count down: %d\n", idx);
-    	sleep(1);
-    }
-
-    OutputCpPwmDuty(100);
-
-    //[To-Do] Reset All Share memory
-
-    //[To-Do] CCS Module enter "idle" mode and CSU should check for this state.
-
-    //system("reboot -f");
-    //sleep(5);
-    //system("reboot -f");
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_din_SessionStopReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_DIN_SessionStopReq(&v2gObject.DIN);
-
-    //Save into Share Memory
-    SHM_Save_din_SessionStopReq(ShmCcsData, &v2gObject.DIN, ShmSysConfigAndInfo);
-
-    errn = Proc_din_SessionStopRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-    	DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_din_SessionStopRes() fail: %d (DEC)", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int Proc_iso1_SessionStopReq(int AcceptFd)
-{
-    int errn = 0;
-    DEBUG_INFO("Request in.\n");
-
-    //Print the decoded XML Document
-    PRINT_XML_DOC_ISO1_SessionStopReq(&v2gObject.ISO1);
-
-    //Save into Share Memory
-    SHM_Save_iso1_SessionStopReq(ShmCcsData, &v2gObject.ISO1, ShmSysConfigAndInfo);
-
-    errn = Proc_iso1_SessionStopRes(AcceptFd);
-    if (errn == 0)
-    {
-        //send response successfully.
-    	DEBUG_INFO("Response out.\n");
-    }
-    else
-    {
-    	DEBUG_ERROR("Proc_iso1_SessionStopRes() fail: %d (DEC)\n", errn);
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int V2gMsg_Process_din(int AcceptFd)
-{
-    unsigned char req_is_responsed = FALSE;
-    while (req_is_responsed == FALSE)
-    {
-        //Check if it is in End_Process
-        if (EVCOMM_SYS_INFO.End_Process_inused == TRUE)
-        {
-            break;
-        }
-
-        switch(V2gFlowStatus)
-        {
-            //-------------------------------------------
-            case SupportedAppProtocolRequest:
-            {
-                if (v2gObject.appHandshake.supportedAppProtocolReq_isUsed == 1u)
-                {
-                    v2gObject.appHandshake.supportedAppProtocolReq_isUsed = 0;
-                    if (Proc_supportedAppProtocolReq(AcceptFd) == 0)   //0: no error
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                        Update_V2G_Status(SupportedAppProtocolResponse);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("supportedAppProtocolResReq: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case SupportedAppProtocolResponse:
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionSetupRequest)
-                {
-                    Update_V2G_Status(SessionSetupRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case SessionSetupRequest:               //19
-            {
-                if (Proc_din_SessionSetupReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(SessionSetupResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("SessionSetupReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case SessionSetupResponse:              //20
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceDiscoveryRequest)
-                {
-                    Update_V2G_Status(ServiceDiscoveryRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case ServiceDiscoveryRequest:           //21
-            {
-                if (Proc_din_ServiceDiscoveryReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(ServiceDiscoveryResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("ServiceDiscoveryReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case ServiceDiscoveryResponse:          //22
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceAndPaymentSelectionRequest)
-                {
-                    Update_V2G_Status(ServiceAndPaymentSelectionRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case ServiceAndPaymentSelectionRequest:     //25
-            {
-                if (Proc_din_ServiceAndPaymentSelectionReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(ServiceAndPaymentSelectionResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("ServiceAndPaymentSelectionReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case ServiceAndPaymentSelectionResponse:    //26
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
-                {
-                    Update_V2G_Status(AuthorizationRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            //case ContractAuthenticationReq:
-            case AuthorizationRequest:              //29
-            {
-                if (Proc_din_ContractAuthenticationReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(AuthorizationResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("AuthorizationReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case AuthorizationResponse:             //30
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_din_ContractAuthenticationReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("AuthorizationReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                }
-                //Check for ChargeParameterDiscoveryReq
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(ChargeParameterDiscoveryRequest);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case ChargeParameterDiscoveryRequest:   //35
-            {
-                if (Proc_din_ChargeParameterDiscoveryReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(ChargeParameterDiscoveryResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("ChargeParameterDiscoveryReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case ChargeParameterDiscoveryResponse:
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > V2G_SECC_ChargingParameter_Performance_Time)  //60 seconds
-                {
-                	DEBUG_ERROR("ChargingParameter Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), V2G_SECC_ChargingParameter_Performance_Time);
-                    Update_V2G_Status(Sequence_Timeout);
-                    break;
-                }
-                #endif
-
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_din_ChargeParameterDiscoveryReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("ChargeParameterDiscoveryReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                    break;
-                }
-                //STEP 2: Check for CableCheckReq message
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CableCheckRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    DEBUG_INFO("[V2G][RX]CableCheckReqReq: isolated?\n");
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_Start);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
-
-                    Update_V2G_Status(CableCheckRequest);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                //STEP 3: Wait for PowerDeliveryReq Message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    Update_V2G_Status(PowerDeliveryRequestStop);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-
-                    if (Proc_din_PowerDeliveryStopReq(AcceptFd) == 0)
-                    {
-                        Update_V2G_Status(PowerDeliveryResponseStop);
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("PowerDeliveryStopReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case CableCheckRequest:                 //37
-            {
-                //STEP 3: Execute Cable Check Process
-                if (Proc_din_CableCheckReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(CableCheckResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("CableCheckReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case CableCheckResponse:                //38
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > V2G_SECC_CableCheck_Performance_Time)  //38 seconds
-                {
-                    //DEBUG_INFO("[CableCheck] end counting...\n");
-                	DEBUG_ERROR("CableCheck Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), V2G_SECC_CableCheck_Performance_Time);
-                    Update_V2G_Status(Sequence_Timeout);
-
-                    //Update_ShmStatusCode(); //[To-Do] to be implemented
-                    //CCS_SECC_TIMEOUT_V2G_CableCheck_Performance_Time (023847)
-                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                    ShmStatusCodeData->PresentStatusCode[0][4] = 4;
-                    ShmStatusCodeData->PresentStatusCode[0][5] = 7;
-                    break;
-                }
-                #endif
-
-                //STEP 2: Check for CableCheckReq message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CableCheckRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    //STEP 3: Execute Cable Check Process
-                    if (Proc_din_CableCheckReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("CableCheckReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                }
-                //STEP 3: Check for PreChargeReq message
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == PreChargeRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(PreChargeRequest);
-                    DEBUG_INFO("[V2G][RX]PreChargeReqReq: waiting for pre-charge voltage...\n");
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Precharge_Timer_Start);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                //STEP 3: Wait for PowerDeliveryReq Message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    Update_V2G_Status(PowerDeliveryRequestStop);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-
-                    if (Proc_din_PowerDeliveryStopReq(AcceptFd) == 0)
-                    {
-                        Update_V2G_Status(PowerDeliveryResponseStop);
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("PowerDeliveryStopReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case PreChargeRequest:                  //39
-            {
-                if (Proc_din_PreChargeReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(PreChargeResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("PreChargeReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case PreChargeResponse:                 //40
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > V2G_SECC_PreCharge_Performance_Time)  //5 seconds
-                {
-                	DEBUG_ERROR("Precharge Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), V2G_SECC_PreCharge_Performance_Time);
-                    Update_V2G_Status(Sequence_Timeout);
-
-                    //Update_ShmStatusCode(); //[To-Do] to be implemented
-                    //CCS_SECC_TIMEOUT_V2G_PreCharge_Performace_Time (023850)
-                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                    ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-                    ShmStatusCodeData->PresentStatusCode[0][5] = 0;
-                    break;
-                }
-                #endif
-
-                //STEP 2: Check for PreChargeReq message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == PreChargeRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_din_PreChargeReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("PreChargeReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                }
-                //STEP 3: Check for PowerDeliveryReq message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(PowerDeliveryRequestStart);
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Precharge_Timer_End);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case PowerDeliveryRequestStart:         //41
-            {
-                if (Proc_din_PowerDeliveryStartReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(PowerDeliveryResponsetStart);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("PowerDeliveryStartReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case PowerDeliveryResponsetStart:        //42
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                if (v2gObject.DIN.V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
-                {
-                    ftime(&timerStart.SeqEnd);
-                    if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > 2000)  //5 seconds
-                    {
-                    	DEBUG_ERROR("Wait for CurrentDemandReq Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), 2000);
-                        Update_V2G_Status(Sequence_Timeout);
-                    }
-                    break;
-                }
-                #endif
-
-                //STEP 2: Wait for CurrentDemandReq Message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CurrentDemandRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(CurrentDemandRequest);
-                    DEBUG_INFO("[V2G][RX]CurrentDemandReqReq: energy transfering...\n");
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CurrentDemand_Timer_Start);
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case CurrentDemandRequest:              //45,
-            {
-                if (Proc_din_CurrentDemandReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(CurrentDemandResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("CurrentDemandReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case CurrentDemandResponse:             //46,
-            {
-                //STEP 1: Wait for CurrentDemandReq Message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CurrentDemandRequest)
-                {
-                   EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    if (Proc_din_CurrentDemandReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("CurrentDemandReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                    break;
-                }
-
-                //STEP 2: Wait for PowerDeliveryReq Message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    Update_V2G_Status(PowerDeliveryRequestStop);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CurrentDemand_Timer_End);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case PowerDeliveryRequestStop:          //49,
-            {
-                if (Proc_din_PowerDeliveryStopReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(PowerDeliveryResponseStop);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else
-                {
-                	DEBUG_ERROR("PowerDeliveryStopReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case PowerDeliveryResponseStop:        //50,
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > 2000)  //2 seconds
-                {
-                	DEBUG_ERROR("Wait for WeldingDetectionReq or SessionStopReq Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), 2000);
-                    Update_V2G_Status(Sequence_Timeout);
-                    break;
-                }
-                #endif
-
-                //STEP 2: Check for WeldingDetectionReq Message
-                if(EVCOMM_SYS_INFO.V2G_Rx_Msg == WeldingDetectionRequest)
-                {
-                   EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(WeldingDetectionRequest);
-                    DEBUG_INFO("[V2G][RX]WeldingDetectionReq: ongoing...\n");
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_WeldingDetection_Timer_Start);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
-                {
-                    Update_V2G_Status(SessionStopRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_din_SessionStopReq(AcceptFd) == 0)
-                    {
-                        Update_V2G_Status(SessionStopResponse);
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("SessionStopReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    break;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case WeldingDetectionRequest:           //51,
-            {
-                if (Proc_din_WeldingDetectionReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(WeldingDetectionResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("WeldingDetectionReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case WeldingDetectionResponse:          //52,
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > V2G_SECC_WeldingDetection_Performance_Time)  //20 seconds
-                {
-                	DEBUG_ERROR("Wait for SessionStopReq Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), V2G_SECC_WeldingDetection_Performance_Time);
-                    Update_V2G_Status(Sequence_Timeout);
-                    break;
-                }
-                #endif
-
-                //STEP 2: Check for WeldingDetectionReq Message
-                if(EVCOMM_SYS_INFO.V2G_Rx_Msg == WeldingDetectionRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    if (Proc_din_WeldingDetectionReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("WeldingDetectionReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                }
-                //STEP 3: Check for SessionStopReq Message
-                else if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
-                {
-                    Update_V2G_Status(SessionStopRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_WeldingDetection_Timer_End);
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case SessionStopRequest:                //53,
-            {
-                if (Proc_din_SessionStopReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(SessionStopResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("SessionStopReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case SessionStopResponse:               //54,
-            {
-                break;
-            }
-            //-------------------------------------------
-            default:
-            {
-                break;
-            }
-        }
-        usleep(1000);
-    }
-
-    return 0;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int V2gMsg_Process_iso1_DC(int AcceptFd)
-{
-    unsigned char req_is_responsed = FALSE;
-
-    while (req_is_responsed == FALSE)
-    {
-        //Check if it is in End_Process
-        if (EVCOMM_SYS_INFO.End_Process_inused == TRUE)
-        {
-            break;
-        }
-
-        switch(V2gFlowStatus)
-        {
-            //-------------------------------------------
-            case SupportedAppProtocolRequest:
-            {
-                if (v2gObject.appHandshake.supportedAppProtocolReq_isUsed == 1u)
-                {
-                    v2gObject.appHandshake.supportedAppProtocolReq_isUsed = 0;
-                    if (Proc_supportedAppProtocolReq(AcceptFd) == 0)   //0: no error
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                        Update_V2G_Status(SupportedAppProtocolResponse);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("supportedAppProtocolResReq: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case SupportedAppProtocolResponse:
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionSetupRequest)
-                {
-                    Update_V2G_Status(SessionSetupRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case SessionSetupRequest:               //19
-            {
-                if (Proc_iso1_SessionSetupReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(SessionSetupResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("SessionSetupReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case SessionSetupResponse:              //20
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceDiscoveryRequest)
-                {
-                    Update_V2G_Status(ServiceDiscoveryRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case ServiceDiscoveryRequest:           //21
-            {
-                if (Proc_iso1_ServiceDiscoveryReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(ServiceDiscoveryResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("ServiceDiscoveryReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case ServiceDiscoveryResponse:          //22
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceAndPaymentSelectionRequest)
-                {
-                    Update_V2G_Status(ServiceAndPaymentSelectionRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case ServiceAndPaymentSelectionRequest:     //25
-            {
-                if (Proc_iso1_ServiceAndPaymentSelectionReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(ServiceAndPaymentSelectionResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("ServiceAndPaymentSelectionReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case ServiceAndPaymentSelectionResponse:    //26
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
-                {
-                    Update_V2G_Status(AuthorizationRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            //case ContractAuthenticationReq:
-            case AuthorizationRequest:              //29
-            {
-                if (Proc_iso1_AuthenticationReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(AuthorizationResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("AuthorizationReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case AuthorizationResponse:             //30
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_iso1_AuthenticationReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("AuthorizationReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                }
-                //Check for ChargeParameterDiscoveryReq
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(ChargeParameterDiscoveryRequest);
-                    DEBUG_INFO("[V2G][RX]ChargeParameterDiscoveryReq: CSU Permission?\n");
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case ChargeParameterDiscoveryRequest:   //35
-            {
-                if (Proc_iso1_ChargeParameterDiscoveryReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(ChargeParameterDiscoveryResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("ChargeParameterDiscoveryReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case ChargeParameterDiscoveryResponse:
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > V2G_SECC_ChargingParameter_Performance_Time)  //60 seconds
-                {
-                	DEBUG_ERROR("ChargingParameter Timeout - (%.02lf of %d ms)\n",
-											DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd),
-											V2G_SECC_ChargingParameter_Performance_Time);
-                    Update_V2G_Status(Sequence_Timeout);
-                    break;
-                }
-                #endif
-
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_iso1_ChargeParameterDiscoveryReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("ChargeParameterDiscoveryReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                }
-                //STEP 2: Check for CableCheckReq message
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CableCheckRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    DEBUG_INFO("[V2G][RX]CableCheckReqReq: isolated?\n");
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_Start);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
-
-                    Update_V2G_Status(CableCheckRequest);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                //STEP 3: Wait for PowerDeliveryReq Message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    Update_V2G_Status(PowerDeliveryRequestStop);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-
-                    if (Proc_iso1_PowerDeliveryStopReq(AcceptFd) == 0)
-                    {
-                        Update_V2G_Status(PowerDeliveryResponseStop);
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("PowerDeliveryStopReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    break;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-                break;
-            }
-            //-------------------------------------------
-            case CableCheckRequest:                 //37
-            {
-                //STEP 3: Execute Cable Check Process
-                if (Proc_iso1_CableCheckReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(CableCheckResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("CableCheckReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case CableCheckResponse:                //38
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > V2G_SECC_CableCheck_Performance_Time)  //38 seconds
-                {
-                    //DEBUG_INFO("[CableCheck] end counting...\n");
-                	DEBUG_ERROR("CableCheck Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), V2G_SECC_CableCheck_Performance_Time);
-                    Update_V2G_Status(Sequence_Timeout);
-
-                    //Update_ShmStatusCode(); //[To-Do] to be implemented
-                    //CCS_SECC_TIMEOUT_V2G_CableCheck_Performance_Time (023847)
-                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                    ShmStatusCodeData->PresentStatusCode[0][4] = 4;
-                    ShmStatusCodeData->PresentStatusCode[0][5] = 7;
-                    break;
-                }
-                #endif
-
-                //STEP 2: Check for CableCheckReq message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CableCheckRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    //STEP 3: Execute Cable Check Process
-                    if (Proc_iso1_CableCheckReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("CableCheckReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                }
-                //STEP 3: Check for PreChargeReq message
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == PreChargeRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(PreChargeRequest);
-                    DEBUG_INFO("[V2G][RX]PreChargeReqReq: waiting for pre-charge voltage...\n");
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Precharge_Timer_Start);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                //STEP 3: Wait for PowerDeliveryReq Message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    Update_V2G_Status(PowerDeliveryRequestStop);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-
-                    if (Proc_iso1_PowerDeliveryStopReq(AcceptFd) == 0)
-                    {
-                        Update_V2G_Status(PowerDeliveryResponseStop);
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("PowerDeliveryStopReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case PreChargeRequest:                  //39
-            {
-                if (Proc_iso1_PreChargeReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(PreChargeResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("PreChargeReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case PreChargeResponse:                 //40
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > V2G_SECC_PreCharge_Performance_Time)  //5 seconds
-                {
-                	DEBUG_ERROR("Precharge Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), V2G_SECC_PreCharge_Performance_Time);
-                    Update_V2G_Status(Sequence_Timeout);
-
-                    //Update_ShmStatusCode(); //[To-Do] to be implemented
-                    //CCS_SECC_TIMEOUT_V2G_PreCharge_Performace_Time (023850)
-                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                    ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-                    ShmStatusCodeData->PresentStatusCode[0][5] = 0;
-                    break;
-                }
-                #endif
-
-                //STEP 2: Check for PreChargeReq message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == PreChargeRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_iso1_PreChargeReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("PreChargeReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                }
-                //STEP 3: Check for PowerDeliveryReq message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(PowerDeliveryRequestStart);
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Precharge_Timer_End);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case PowerDeliveryRequestStart:         //41
-            {
-                if (Proc_iso1_PowerDeliveryStartReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(PowerDeliveryResponsetStart);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("PowerDeliveryStartReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case PowerDeliveryResponsetStart:        //42
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                if (v2gObject.ISO1.V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
-                {
-                    ftime(&timerStart.SeqEnd);
-                    if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > 2000)  //5 seconds
-                    {
-                    	DEBUG_ERROR("Wait for CurrentDemandReq Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), 2000);
-                        Update_V2G_Status(Sequence_Timeout);
-                    }
-                    break;
-                }
-                #endif
-
-                //STEP 2: Wait for CurrentDemandReq Message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CurrentDemandRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(CurrentDemandRequest);
-                    DEBUG_INFO("[V2G][RX]CurrentDemandReqReq: energy transfering...\n");
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CurrentDemand_Timer_Start);
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {}
-                break;
-            }
-            //-------------------------------------------
-            case CurrentDemandRequest:              //45,
-            {
-                if (Proc_iso1_CurrentDemandReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(CurrentDemandResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("CurrentDemandReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case CurrentDemandResponse:             //46,
-            {
-                //STEP 1: Wait for CurrentDemandReq Message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CurrentDemandRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    if (Proc_iso1_CurrentDemandReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("CurrentDemandReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                }
-                //STEP 2: Wait for PowerDeliveryReq Message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    Update_V2G_Status(PowerDeliveryRequestStop);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CurrentDemand_Timer_End);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case PowerDeliveryRequestStop:          //49,
-            {
-                if (Proc_iso1_PowerDeliveryStopReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(PowerDeliveryResponseStop);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else
-                {
-                	DEBUG_ERROR("PowerDeliveryStopReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case PowerDeliveryResponseStop:        //50,
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > 2000)  //2 seconds
-                {
-                	DEBUG_ERROR("Wait for WeldingDetectionReq or SessionStopReq Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), 2000);
-                    Update_V2G_Status(Sequence_Timeout);
-                    break;
-                }
-                #endif
-
-                //STEP 2: Check for WeldingDetectionReq Message
-                if(EVCOMM_SYS_INFO.V2G_Rx_Msg == WeldingDetectionRequest)
-                {
-                   EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(WeldingDetectionRequest);
-                    DEBUG_INFO("[V2G][RX]WeldingDetectionReq: ongoing...\n");
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_WeldingDetection_Timer_Start);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
-                {
-                    Update_V2G_Status(SessionStopRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_iso1_SessionStopReq(AcceptFd) == 0)
-                    {
-                        Update_V2G_Status(SessionStopResponse);
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("SessionStopReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case WeldingDetectionRequest:           //51,
-            {
-                if (Proc_iso1_WeldingDetectionReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(WeldingDetectionResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("WeldingDetectionReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case WeldingDetectionResponse:          //52,
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > V2G_SECC_WeldingDetection_Performance_Time)  //20 seconds
-                {
-                	DEBUG_ERROR("Wait for SessionStopReq Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), V2G_SECC_WeldingDetection_Performance_Time);
-                    Update_V2G_Status(Sequence_Timeout);
-                    break;
-                }
-                #endif
-
-                //STEP 2: Check for WeldingDetectionReq Message
-                if(EVCOMM_SYS_INFO.V2G_Rx_Msg == WeldingDetectionRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    if (Proc_iso1_WeldingDetectionReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("WeldingDetectionReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                }
-                //STEP 3: Check for SessionStopReq Message
-                else if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
-                {
-                    Update_V2G_Status(SessionStopRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_WeldingDetection_Timer_End);
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-
-                break;
-            }
-            //-------------------------------------------
-            case SessionStopRequest:                //53,
-            {
-                if (Proc_iso1_SessionStopReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(SessionStopResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("SessionStopReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case SessionStopResponse:               //54,
-            {
-                break;
-            }
-            //-------------------------------------------
-            default:
-            {
-                break;
-            }
-        }
-        usleep(1000);
-    }
-
-    return 0;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int V2gMsg_Process_iso1_AC(int AcceptFd)
-{
-    unsigned char req_is_responsed = FALSE;
-
-    while (req_is_responsed == FALSE)
-    {
-        //Check if it is in End_Process
-        if (EVCOMM_SYS_INFO.End_Process_inused == TRUE)
-        {
-            break;
-        }
-
-        switch(V2gFlowStatus)
-        {
-            //-------------------------------------------
-            case SupportedAppProtocolRequest:       //17
-            {
-                if (v2gObject.appHandshake.supportedAppProtocolReq_isUsed == 1u)
-                {
-                    v2gObject.appHandshake.supportedAppProtocolReq_isUsed = 0;
-                    if (Proc_supportedAppProtocolReq(AcceptFd) == 0)   //0: no error
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                        Update_V2G_Status(SupportedAppProtocolResponse);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("supportedAppProtocolResReq: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case SupportedAppProtocolResponse:      //18
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionSetupRequest)
-                {
-                    Update_V2G_Status(SessionSetupRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n",EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {}
-
-                break;
-            }
-            //-------------------------------------------
-            case SessionSetupRequest:               //19
-            {
-                if (Proc_iso1_SessionSetupReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(SessionSetupResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("SessionSetupReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case SessionSetupResponse:              //20
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceDiscoveryRequest)
-                {
-                    Update_V2G_Status(ServiceDiscoveryRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {}
-
-                break;
-            }
-            //-------------------------------------------
-            case ServiceDiscoveryRequest:           //21
-            {
-                if (Proc_iso1_ServiceDiscoveryReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(ServiceDiscoveryResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("ServiceDiscoveryReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case ServiceDiscoveryResponse:          //22
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceAndPaymentSelectionRequest)
-                {
-                    Update_V2G_Status(ServiceAndPaymentSelectionRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {}
-
-                break;
-            }
-            //-------------------------------------------
-            case ServiceAndPaymentSelectionRequest: //25
-            {
-                if (Proc_iso1_ServiceAndPaymentSelectionReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(ServiceAndPaymentSelectionResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("ServiceAndPaymentSelectionReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case ServiceAndPaymentSelectionResponse://26
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
-                {
-                    Update_V2G_Status(AuthorizationRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {}
-
-                break;
-            }
-            //-------------------------------------------
-            //case ContractAuthenticationReq:
-            case AuthorizationRequest:              //29
-            {
-                if (Proc_iso1_AuthenticationReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(AuthorizationResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("AuthorizationReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case AuthorizationResponse:             //30
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_iso1_AuthenticationReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("AuthorizationReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                }
-                //Check for ChargeParameterDiscoveryReq
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(ChargeParameterDiscoveryRequest);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {}
-
-                break;
-            }
-            //-------------------------------------------
-            case ChargeParameterDiscoveryRequest:   //35
-            {
-                if (Proc_iso1_ChargeParameterDiscoveryReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(ChargeParameterDiscoveryResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("ChargeParameterDiscoveryReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case ChargeParameterDiscoveryResponse:  //36
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-    	        ftime(&timerStart.SeqEnd);
-    	        if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > V2G_SECC_ChargingParameter_Performance_Time)  //60 seconds
-    	        {
-    	        	DEBUG_ERROR("ChargingParameter Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), V2G_SECC_ChargingParameter_Performance_Time);
-    	            Update_V2G_Status(Sequence_Timeout);
-                    break;
-    	        }
-                #endif
-
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_iso1_ChargeParameterDiscoveryReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("ChargeParameterDiscoveryReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                }
-
-                //STEP 3: Wait for PowerDeliveryReq Message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    Update_V2G_Status(PowerDeliveryRequestStart);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
-
-			#if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-			#endif
-/*
-                    if(Proc_iso1_PowerDeliveryStopReq(AcceptFd) == 0)
-                    {
-                        Update_V2G_Status(PowerDeliveryResponseStop);
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                        DEBUG_ERROR("PowerDeliveryStopReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }*/
-    		#if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-            #endif
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-
-                }
-                break;
-            }
-            //-------------------------------------------
-            case PowerDeliveryRequestStart:         //41
-            {
-                if (Proc_iso1_PowerDeliveryStartReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(PowerDeliveryResponsetStart);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("PowerDeliveryStartReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case PowerDeliveryResponsetStart:       //42
-            {
-                //STEP 1: Check for Process Timeout
-			#if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                if (v2gObject.ISO1.V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
-                {
-                    ftime(&timerStart.SeqEnd);
-                    if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > 2000)  //5 seconds
-                    {
-                    	DEBUG_ERROR("Wait for ChargingStatusReq Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), 2000);
-                        Update_V2G_Status(Sequence_Timeout);
-                    }
-                    break;
-                }
-			#endif
-
-                //STEP 2: Wait for ChargingStatusReq Message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargingStatusRequest)
-                {
-    	            EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(ChargingStatusRequest);
-                    DEBUG_INFO("[V2G][RX]ChargingStatusReq: energy transfering...\n");
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargingStatus_Timer_Start);
-                }
-                else
-                {}
-
-                break;
-            }
-            //-------------------------------------------
-            case ChargingStatusRequest:             //43
-            {
-                if (Proc_iso1_ChargingStatusReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(ChargingStatusResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("ChargingStatusRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case ChargingStatusResponse:            //44
-            {
-                //STEP 1: Wait for ChargingStatusReq Message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargingStatusRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    if (Proc_iso1_ChargingStatusReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("ChargingStatusRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                }
-                //STEP 2: Wait for PowerDeliveryReq Message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    Update_V2G_Status(PowerDeliveryRequestStop);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargingStatus_Timer_End);
-
-				#if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-				#endif
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {}
-
-                break;
-            }
-            //-------------------------------------------
-            case PowerDeliveryRequestStop:          //49
-            {
-                if (Proc_iso1_PowerDeliveryStopReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(PowerDeliveryResponseStop);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-
-				#if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-				#endif
-                }
-                else
-                {
-                	DEBUG_ERROR("PowerDeliveryStopReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case PowerDeliveryResponseStop:         //50
-            {
-                //STEP 1: Check for Process Timeout
-			#if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > 2000)  //2 seconds
-                {
-                	DEBUG_ERROR("Wait for SessionStopReq Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), 2000);
-                    Update_V2G_Status(Sequence_Timeout);
-                    break;
-                }
-			#endif
-
-                //STEP 3: Check for SessionStopReq Message
-                else if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
-                {
-                    Update_V2G_Status(SessionStopRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if ((EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest) &&
-                         (EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest))
-                {
-                	if((EVCOMM_SYS_INFO.V2G_Rx_Msg != ChargeParameterDiscoveryRequest))
-                	{
-						DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-						EVCOMM_SYS_INFO.SequenceError = TRUE;
-                	}
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {}
-
-                break;
-            }
-            case SessionStopRequest:                //53
-            {
-                if (Proc_iso1_SessionStopReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(SessionStopResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("SessionStopReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case SessionStopResponse:               //54
-            {
-                break;
-            }
-            default:
-            {
-                break;
-            }
-        }
-        usleep(1000);
-    }
-
-    return 0;
-}
-
-/**
- *
- * @param AcceptFd
- * @param EnergyTransferMode
- * @return
- */
-int V2gMsg_Process_iso1(int AcceptFd, unsigned char EnergyTransferMode)
-{
-    switch (EnergyTransferMode)
-    {
-        case DC_extended:
-        {
-        	//DEBUG_INFO("EnergyTransferMode: DC_extended\n");
-            V2gMsg_Process_iso1_DC(AcceptFd);
-            break;
-        }
-
-        case AC_single_phase_core:
-        case AC_three_phase_core:
-        {
-        	//DEBUG_INFO("EnergyTransferMode: AC_single_phase_core or AC_three_phase_core\n");
-            V2gMsg_Process_iso1_AC(AcceptFd);
-            break;
-        }
-
-        default:
-        {
-        	DEBUG_WARN("Unexpected EnergyTransferMode: (%d)\n", EnergyTransferMode);
-            break;
-        }
-    }
-
-    return 0;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int V2gMsg_Process_iso2_DC(int AcceptFd)
-{
-    unsigned char req_is_responsed = FALSE;
-    while (req_is_responsed == FALSE)
-    {
-        //Check if it is in End_Process
-        if (EVCOMM_SYS_INFO.End_Process_inused == TRUE)
-        {
-            break;
-        }
-
-        switch(V2gFlowStatus)
-        {
-            //-------------------------------------------
-            case SupportedAppProtocolRequest:
-            {
-                if (v2gObject.appHandshake.supportedAppProtocolReq_isUsed == 1u)
-                {
-                    v2gObject.appHandshake.supportedAppProtocolReq_isUsed = 0;
-                    if (Proc_supportedAppProtocolReq(AcceptFd) == 0)   //0: no error
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                        Update_V2G_Status(SupportedAppProtocolResponse);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("supportedAppProtocolResReq: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case SupportedAppProtocolResponse:
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionSetupRequest)
-                {
-                    Update_V2G_Status(SessionSetupRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {}
-
-                break;
-            }
-            //-------------------------------------------
-            case SessionSetupRequest:               //19
-            {
-                if (Proc_iso2_SessionSetupReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(SessionSetupResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("SessionSetupReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case SessionSetupResponse:              //20
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceDiscoveryRequest)
-                {
-                    Update_V2G_Status(ServiceDiscoveryRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {}
-
-                break;
-            }
-    #if 0
-            //-------------------------------------------
-            case ServiceDiscoveryRequest:           //21
-            {
-                if (Proc_iso2_ServiceDiscoveryReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(ServiceDiscoveryResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("ServiceDiscoveryReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case ServiceDiscoveryResponse:          //22
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceAndPaymentSelectionRequest)
-                {
-                    Update_V2G_Status(ServiceAndPaymentSelectionRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-                    break;
-                }
-            }
-            //-------------------------------------------
-            case ServiceAndPaymentSelectionRequest:     //25
-            {
-                if (Proc_iso2_ServiceAndPaymentSelectionReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(ServiceAndPaymentSelectionResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("ServiceAndPaymentSelectionReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case ServiceAndPaymentSelectionResponse:    //26
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
-                {
-                    Update_V2G_Status(AuthorizationRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-                    break;
-                }
-            }
-            //-------------------------------------------
-            //case ContractAuthenticationReq:
-            case AuthorizationRequest:              //29
-            {
-                if (Proc_iso2_AuthenticationReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(AuthorizationResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("AuthorizationReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case AuthorizationResponse:             //30
-            {
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_iso2_AuthenticationReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("AuthorizationReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                    break;
-                }
-
-                //Check for ChargeParameterDiscoveryReq
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(ChargeParameterDiscoveryRequest);
-                    DEBUG_INFO("[V2G][RX]ChargeParameterDiscoveryReq: CSU Permission?\n");
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-                    break;
-                }
-            }
-            //-------------------------------------------
-            case ChargeParameterDiscoveryRequest:   //35
-            {
-                if (Proc_iso2_ChargeParameterDiscoveryReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(ChargeParameterDiscoveryResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("ChargeParameterDiscoveryReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case ChargeParameterDiscoveryResponse:
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > V2G_SECC_ChargingParameter_Performance_Time)  //60 seconds
-                {
-                	DEBUG_ERROR("ChargingParameter Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), V2G_SECC_ChargingParameter_Performance_Time);
-                    Update_V2G_Status(Sequence_Timeout);
-                    break;
-                }
-                #endif
-
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_iso2_ChargeParameterDiscoveryReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("ChargeParameterDiscoveryReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                    break;
-                }
-                //STEP 2: Check for CableCheckReq message
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CableCheckRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(CableCheckRequest);
-                    DEBUG_INFO("[V2G][RX]CableCheckReqReq: isolated?\n");
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_Start);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                //STEP 3: Wait for PowerDeliveryReq Message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    Update_V2G_Status(PowerDeliveryRequestStop);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-
-                    if (Proc_iso2_PowerDeliveryStopReq(AcceptFd) == 0)
-                    {
-                        Update_V2G_Status(PowerDeliveryResponseStop);
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("PowerDeliveryStopReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    break;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-                    break;
-                }
-            }
-            //-------------------------------------------
-            case CableCheckRequest:                 //37
-            {
-                //STEP 3: Execute Cable Check Process
-                if (Proc_iso2_CableCheckReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(CableCheckResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("CableCheckReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case CableCheckResponse:                //38
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > V2G_SECC_CableCheck_Performance_Time)  //38 seconds
-                {
-                    //DEBUG_INFO("[CableCheck] end counting...\n");
-                	DEBUG_ERROR("CableCheck Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), V2G_SECC_CableCheck_Performance_Time);
-                    Update_V2G_Status(Sequence_Timeout);
-
-                    //Update_ShmStatusCode(); //[To-Do] to be implemented
-                    //CCS_SECC_TIMEOUT_V2G_CableCheck_Performance_Time (023847)
-                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                    ShmStatusCodeData->PresentStatusCode[0][4] = 4;
-                    ShmStatusCodeData->PresentStatusCode[0][5] = 7;
-                    break;
-                }
-                #endif
-
-                //STEP 2: Check for CableCheckReq message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CableCheckRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    //STEP 3: Execute Cable Check Process
-                    if (Proc_iso2_CableCheckReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("CableCheckReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                    break;
-                }
-                //STEP 3: Check for PreChargeReq message
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == PreChargeRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(PreChargeRequest);
-                    DEBUG_INFO("[V2G][RX]PreChargeReqReq: waiting for pre-charge voltage...\n");
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Precharge_Timer_Start);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                //STEP 3: Wait for PowerDeliveryReq Message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    Update_V2G_Status(PowerDeliveryRequestStop);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-
-                    if (Proc_iso2_PowerDeliveryStopReq(AcceptFd) == 0)
-                    {
-                        Update_V2G_Status(PowerDeliveryResponseStop);
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("PowerDeliveryStopReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    break;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-                    break;
-                }
-            }
-            //-------------------------------------------
-            case PreChargeRequest:                  //39
-            {
-                if (Proc_iso2_PreChargeReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(PreChargeResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("PreChargeReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case PreChargeResponse:                 //40
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > V2G_SECC_PreCharge_Performance_Time)  //5 seconds
-                {
-                	DEBUG_ERROR("Pre-charge Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), V2G_SECC_PreCharge_Performance_Time);
-                    Update_V2G_Status(Sequence_Timeout);
-
-                    //Update_ShmStatusCode(); //[To-Do] to be implemented
-                    //CCS_SECC_TIMEOUT_V2G_PreCharge_Performace_Time (023850)
-                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                    ShmStatusCodeData->PresentStatusCode[0][4] = 5;
-                    ShmStatusCodeData->PresentStatusCode[0][5] = 0;
-                    break;
-                }
-                #endif
-
-                //STEP 2: Check for PreChargeReq message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == PreChargeRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_iso2_PreChargeReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("PreChargeReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                    break;
-                }
-                //STEP 3: Check for PowerDeliveryReq message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(PowerDeliveryRequestStart);
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Precharge_Timer_End);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-                    break;
-                }
-            }
-            //-------------------------------------------
-            case PowerDeliveryRequestStart:         //41
-            {
-                if (Proc_iso2_PowerDeliveryStartReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(PowerDeliveryResponsetStart);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("PowerDeliveryStartReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case PowerDeliveryResponsetStart:        //42
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                if (v2gObject.ISO2.V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
-                {
-                    ftime(&timerStart.SeqEnd);
-                    if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > 2000)  //5 seconds
-                    {
-                    	DEBUG_ERROR("Wait for CurrentDemandReq Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), 2000);
-                        Update_V2G_Status(Sequence_Timeout);
-                    }
-                    break;
-                }
-                #endif
-
-                //STEP 2: Wait for CurrentDemandReq Message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CurrentDemandRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(CurrentDemandRequest);
-                    DEBUG_INFO("[V2G][RX]CurrentDemandReqReq: energy transfering...\n");
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CurrentDemand_Timer_Start);
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-                    break;
-                }
-            }
-            //-------------------------------------------
-            case CurrentDemandRequest:              //45,
-            {
-                if (Proc_iso2_CurrentDemandReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(CurrentDemandResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("CurrentDemandReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case CurrentDemandResponse:             //46,
-            {
-                //STEP 1: Wait for CurrentDemandReq Message
-                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CurrentDemandRequest)
-                {
-                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    if (Proc_iso2_CurrentDemandReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("CurrentDemandReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                    break;
-                }
-                //STEP 2: Wait for PowerDeliveryReq Message
-                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
-                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
-                {
-                    Update_V2G_Status(PowerDeliveryRequestStop);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CurrentDemand_Timer_End);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-                    break;
-                }
-            }
-            //-------------------------------------------
-            case PowerDeliveryRequestStop:          //49,
-            {
-                if (Proc_iso2_PowerDeliveryStopReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(PowerDeliveryResponseStop);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else
-                {
-                	DEBUG_ERROR("PowerDeliveryStopReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case PowerDeliveryResponseStop:        //50,
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > 2000)  //2 seconds
-                {
-                	DEBUG_ERROR("Wait for WeldingDetectionReq or SessionStopReq Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), 2000);
-                    Update_V2G_Status(Sequence_Timeout);
-                    break;
-                }
-                #endif
-
-                //STEP 2: Check for WeldingDetectionReq Message
-                if(EVCOMM_SYS_INFO.V2G_Rx_Msg == WeldingDetectionRequest)
-                {
-                   EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    Update_V2G_Status(WeldingDetectionRequest);
-                    DEBUG_INFO("[V2G][RX]WeldingDetectionReq: ongoing...\n");
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_WeldingDetection_Timer_Start);
-
-                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                    ftime(&timerStart.SeqStart);
-                    #endif
-                }
-                else if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
-                {
-                    Update_V2G_Status(SessionStopRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    if (Proc_iso2_SessionStopReq(AcceptFd) == 0)
-                    {
-                        Update_V2G_Status(SessionStopResponse);
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("SessionStopReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    break;
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-                    break;
-                }
-            }
-            //-------------------------------------------
-            case WeldingDetectionRequest:           //51,
-            {
-                if (Proc_iso2_WeldingDetectionReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(WeldingDetectionResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("WeldingDetectionReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                break;
-            }
-            case WeldingDetectionResponse:          //52,
-            {
-                //STEP 1: Check for Process Timeout
-                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > V2G_SECC_WeldingDetection_Performance_Time)  //20 seconds
-                {
-                	DEBUG_ERROR("Wait for SessionStopReq Timeout - (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), V2G_SECC_WeldingDetection_Performance_Time);
-                    Update_V2G_Status(Sequence_Timeout);
-                    break;
-                }
-                #endif
-
-                //STEP 2: Check for WeldingDetectionReq Message
-                if(EVCOMM_SYS_INFO.V2G_Rx_Msg == WeldingDetectionRequest)
-                {
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                    if (Proc_iso1_WeldingDetectionReq(AcceptFd) == 0)
-                    {
-                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                    }
-                    else
-                    {
-                    	DEBUG_ERROR("WeldingDetectionReqRes: fail\n");
-                        Update_V2G_Status(Other_Fault);
-                    }
-                    req_is_responsed = TRUE;
-                    break;
-                }
-                //STEP 3: Check for SessionStopReq Message
-                else if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
-                {
-                    Update_V2G_Status(SessionStopRequest);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_WeldingDetection_Timer_End);
-                }
-                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
-                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
-                {
-                	DEBUG_ERROR("SequenceError(%d) => Tx Res MSG\n", EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.SequenceError = TRUE;
-
-                    Update_V2G_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
-                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
-                }
-                else
-                {
-                    break;
-                }
-            }
-            //-------------------------------------------
-            case SessionStopRequest:                //53,
-            {
-                if (Proc_iso2_SessionStopReq(AcceptFd) == 0)
-                {
-                    Update_V2G_Status(SessionStopResponse);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-                }
-                else
-                {
-                	DEBUG_ERROR("SessionStopReqRes: fail\n");
-                    Update_V2G_Status(Other_Fault);
-                }
-                req_is_responsed = TRUE;
-                //break;
-            }
-            case SessionStopResponse:               //54,
-            {
-                break;
-            }
-    #endif
-            //-------------------------------------------
-            default:
-            {
-                break;
-            }
-        }
-        usleep(1000);
-    }
-
-    return 0;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int V2gMsg_Process_iso2_AC(int AcceptFd)
-{
-
-	return 0;
-}
-
-/**
- *
- * @param AcceptFd
- * @param EnergyTransferMode
- * @return
- */
-int V2gMsg_Process_iso2(int AcceptFd, unsigned char EnergyTransferMode)
-{
-    switch (EnergyTransferMode)
-    {
-        case DC_extended:
-        {
-            V2gMsg_Process_iso2_DC(AcceptFd);
-            break;
-        }
-
-        case AC_single_phase_core:
-        case AC_three_phase_core:
-        {
-            V2gMsg_Process_iso2_AC(AcceptFd);
-            break;
-        }
-
-        default:
-        {
-        	DEBUG_WARN("Unexpected EnergyTransferMode: (%d)\n", EnergyTransferMode);
-            break;
-        }
-    }
-
-    return 0;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int V2gMsg_Process(int AcceptFd)
-{
-    int errn = 0;
-
-    switch (ShmCcsData->CommProtocol)
-    {
-        case V2GT_MSG_PROTOCOL_DIN70121:        //0
-        {
-            V2gMsg_Process_din(AcceptFd);
-            break;
-        }
-
-        case V2GT_MSG_PROTOCOL_ISO15118_2014:   //1
-        {
-            V2gMsg_Process_iso1(AcceptFd, ShmCcsData->EnergyTransferMode);
-            break;
-        }
-
-        case V2GT_MSG_PROTOCOL_ISO15118_2018:   //2
-        {
-            V2gMsg_Process_iso2(AcceptFd, ShmCcsData->EnergyTransferMode);
-            break;
-        }
-
-        default:
-        {
-        	DEBUG_WARN("Unexpected Communication Protocol: (%d)\n", ShmCcsData->CommProtocol);
-            break;
-        }
-    }
-
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int V2gMsg_Rx(int AcceptFd)
-{
-    int errn = 0;
-    unsigned int packet_size = 0;
-
-    memset(v2gBuffer.rx, 0, V2GTP_MSG_RX_BUFFER_SIZE);
-    packet_size = recv(AcceptFd, v2gBuffer.rx, V2GTP_MSG_RX_BUFFER_SIZE, 0);
-    //[CAUTION] Everytime recv() is called, it will take a default time to wait for TCP packets.
-    //The more time you call recv(), the more time you will waste here.
-    //Here it is suggested that response immediatedly once you receive any packets.
-    //For configuring the Rx waiting time, please use setsockopt().
-
-    if(packet_size > 0) //[Joseph] If there is no data, ignore. (TBD)
-    {
-        //DEBUG_PRINTF_EVCOMM_DETAIL("\n\n Got TCP V2GTP Message: size = %d Bytes\n", packet_size);
-        errn = V2gMsgDecoder(v2gBuffer.rx, packet_size, V2gFlowStatus);
-        if (errn < 0)
-        {
-        	DEBUG_ERROR("V2gMsgDecoder fail: (%d)\n", errn);
-        }
-    }
-    return errn;
-}
-
-/**
- *
- * @param AcceptFd
- * @return
- */
-int V2gComm(int AcceptFd)
-{
-    int errn = 0;
-
-    if (V2gMsg_Rx(AcceptFd) < 0)
-    {
-        Update_V2G_Status(Other_Fault);
-        errn = -1;
-    }
-
-    //following are the response message handling according to status flag
-    if (V2gMsg_Process(AcceptFd) < 0)
-    {
-        errn = -1;
-    }
-
-    //Error Check
-    //V2G_Error_Monitor();
-
-    return errn;
-}
-
-/**
- *
- * @return
- */
-int SdpUdpConnected()
-{
-    int packet_size,Rtn;
-    struct sockaddr_in6 ServerAddr,ClientAddr;
-    struct V2gtpHeader *header;
-    unsigned char *payload;
-
-    // UDP server initial
-    if(socketFd.Udp <= 0)
-    {
-        if ((socketFd.Udp = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
-        {
-        	DEBUG_ERROR("Fail to open UdpSock\n");
-            return 0;
-        }
-
-        memset(&ServerAddr,0, sizeof(struct sockaddr_in));
-        ServerAddr.sin6_family = AF_INET6;
-        ServerAddr.sin6_addr = in6addr_any;
-        ServerAddr.sin6_port = htons(SdpUdpServerPort);
-        if(bind(socketFd.Udp, (struct sockaddr *)&ServerAddr, sizeof(struct sockaddr_in6)) < 0)
-        {
-        	DEBUG_ERROR("Fail to bind UdpSock(%d)\n", socketFd.Udp);
-
-            close(socketFd.Udp);
-            socketFd.Udp = -1;
-            return 0;
-        }
-
-        DEBUG_INFO("[UDP] opened(%d), port: %d\n", socketFd.Udp, SdpUdpServerPort);
-        DEBUG_INFO("[UDP] Wait connect request from EVCC\n");
-    }
-
-    // Receive packet from udp server
-    memset(v2gBuffer.rx, 0, V2GTP_MSG_RX_BUFFER_SIZE);
-    memset(&ClientAddr, 0, sizeof(struct sockaddr_in));
-    Rtn = sizeof(struct sockaddr_in6);
-    packet_size = recvfrom(socketFd.Udp, v2gBuffer.rx, V2GTP_MSG_RX_BUFFER_SIZE, MSG_DONTWAIT, (struct sockaddr *)&ClientAddr, (socklen_t *)&Rtn);
-    if(packet_size > 0)
-    {
-    	char buf[128];
-        header = (struct V2gtpHeader *) v2gBuffer.rx;
-        payload = v2gBuffer.rx+sizeof(struct V2gtpHeader);
-
-		DEBUG_PRINTF_EVCOMM_DETAIL("Got UDP packet_size: %d (Bytes)\n", packet_size);
-		DEBUG_PRINTF_EVCOMM_DETAIL("***********************************\n");
-		DEBUG_PRINTF_EVCOMM_DETAIL("***** Received SDP Packet *****\n");
-		DEBUG_PRINTF_EVCOMM_DETAIL("***********************************\n");
-
-		memset(buf, 0x00, ARRAY_SIZE(buf));
-		for(Rtn = 0; Rtn < 16; Rtn += 2)
-		{
-			sprintf(buf, "%s%02x%02x:", buf, ClientAddr.sin6_addr.s6_addr[Rtn],ClientAddr.sin6_addr.s6_addr[Rtn+1]);
-		}
-		DEBUG_PRINTF_EVCOMM_DETAIL("ClientAddress: %s\n", buf);
-		DEBUG_PRINTF_EVCOMM_DETAIL("ClientPort: %d\n",ClientAddr.sin6_port);
-		DEBUG_PRINTF_EVCOMM_DETAIL("ProtocolVersion: %d\n",header->ProtocolVersion);
-		DEBUG_PRINTF_EVCOMM_DETAIL("InverseProtocolVersion: 0x%x\n",header->InverseProtocolVersion);
-		DEBUG_PRINTF_EVCOMM_DETAIL("PayloadType: 0x%x\n",htons(header->PayloadType));
-		DEBUG_PRINTF_EVCOMM_DETAIL("PayloadLength: 0x%x\n",htonl(header->PayloadLength));
-		DEBUG_PRINTF_EVCOMM_DETAIL("htons(header->PayloadType): 0x%x\n",htons(header->PayloadType));
-
-        if( (header->ProtocolVersion == 0x01) &&
-            (header->InverseProtocolVersion == 0xFE) &&
-            (htons(header->PayloadType) == V2GTP_PAYLOAD_TYPE_SDP_REQUEST))
-        {
-            DEBUG_INFO("[UDP] Get connect request from EVCC: (%d)\n", socketFd.Udp);
-            DEBUG_PRINTF_EVCOMM_DETAIL("Security: 0x%02X\n", *(payload + 0));
-            DEBUG_PRINTF_EVCOMM_DETAIL("TransportProtocol: 0x%02X\n", *(payload + 1));
-
-            header->PayloadType = htons(V2GTP_PAYLOAD_TYPE_SDP_RESPONSE);
-            header->PayloadLength = htonl(20);    //Fixed Length=20
-            memset(payload, 0, 20);
-            // MAC address[0:2] + FFFE + MAC address[3:5]
-            payload[0] = (IPV6_LINK_LOCAL_PREFIX>>8) & 0xFF;
-            payload[1] = IPV6_LINK_LOCAL_PREFIX & 0xFF;
-#ifdef TEST_WITH_ETH0
-            payload[8] = macAddr.eth0[0];
-			payload[8] ^= 0x02;// bit 1 should complemented.
-			payload[9] = macAddr.eth0[1];
-			payload[10] = macAddr.eth0[2];
-			payload[11] = 0xFF;
-			payload[12] = 0xFE;
-			payload[13] = macAddr.eth0[3];
-			payload[14] = macAddr.eth0[4];
-			payload[15] = macAddr.eth0[5];
-#else
-
-            payload[8] = macAddr.eth1[0];
-            payload[8] ^= 0x02;// bit 1 should complemented.
-            payload[9] = macAddr.eth1[1];
-            payload[10] = macAddr.eth1[2];
-            payload[11] = 0xFF;
-            payload[12] = 0xFE;
-            payload[13] = macAddr.eth1[3];
-            payload[14] = macAddr.eth1[4];
-            payload[15] = macAddr.eth1[5];
-#endif
-            // Report TCP port
-            payload[16] = (EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active>>8) & 0xFF;
-            payload[17] = EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active & 0xFF;
-            payload[18] = SDP_PAYLOAD_SECURITY_NONE;      //Security
-            payload[19] = SDP_PAYLOAD_TRANS_PROTOCOL_TCP; //Transport protocol
-
-            // TODO:
-            // 	Setup the TCP in advance to receive the coming TCP handshake messages after SDP response.
-            Rtn = sendto(socketFd.Udp, v2gBuffer.rx, sizeof(struct V2gtpHeader) + htonl(header->PayloadLength), 0, (struct sockaddr *)&ClientAddr, sizeof(struct sockaddr_in6));
-            DEBUG_INFO("[UDP] Response to EVCC\n");
-			DEBUG_PRINTF_EVCOMM_DETAIL("***** Response SDP Packet *****\n");
-			DEBUG_PRINTF_EVCOMM_DETAIL("Send size: %d\n", Rtn);
-
-			memset(buf, 0x00, ARRAY_SIZE(buf));
-			for(Rtn = 0; Rtn < 16; Rtn++)
-			{
-				sprintf(buf, "%s%02x ", buf, ClientAddr.sin6_addr.s6_addr[Rtn]);
-			}
-			DEBUG_PRINTF_EVCOMM_DETAIL("Destination Address: %s\n", buf);
-			DEBUG_PRINTF_EVCOMM_DETAIL("Destination Port: %d\n", ClientAddr.sin6_port);
-			DEBUG_PRINTF_EVCOMM_DETAIL("ProtocolVersion: %d\n", header->ProtocolVersion);
-			DEBUG_PRINTF_EVCOMM_DETAIL("InverseProtocolVersion: 0x%x\n", header->InverseProtocolVersion);
-			DEBUG_PRINTF_EVCOMM_DETAIL("PayloadType: 0x%x\n", htons(header->PayloadType));
-			DEBUG_PRINTF_EVCOMM_DETAIL("PayloadLength: 0x%x\n", htonl(header->PayloadLength));
-
-			memset(buf, 0x00, ARRAY_SIZE(buf));
-			for(Rtn = 0; Rtn < 16; Rtn++)
-			{
-				sprintf(buf, "%s%02x:", buf, payload[Rtn]);
-			}
-			DEBUG_PRINTF_EVCOMM_DETAIL("SECC Ipv6 Address: %s\n", buf);
-			DEBUG_PRINTF_EVCOMM_DETAIL("SECC Port: %d\n", (payload[16]<<8 | payload[17]));
-			DEBUG_PRINTF_EVCOMM_DETAIL("Security: 0x%x\n", payload[19]);
-			DEBUG_PRINTF_EVCOMM_DETAIL("TransportProtocol: 0x%x\n", payload[20]);
-
-            if(Rtn > 0)
-            {
-                return 1;
-            }
-        }
-    }
-
-    return 0;
-}
-
-/**
- *
- * @return
- */
-int V2gTcpConnected()
-{
-    int Rtn,AcceptFd;
-    char buf[128];
-    struct sockaddr_in6 ServerAddr,ClientAddr;
-
-    // Initial TCP server
-    if(socketFd.Tcp <= 0)
-    {
-        if ((socketFd.Tcp = socket(PF_INET6, SOCK_STREAM, 0)) < 0)
-        {
-        	DEBUG_ERROR("Fail to open TcpSock (%s)\n", strerror(errno));
-            usleep(100000);
-
-            return 0;
-        }
-        fcntl(socketFd.Tcp, F_SETFL, O_NONBLOCK);    //set to O_NONBLOCK
-        DEBUG_INFO("[TCP]Socket set: DONE.\n");
-
-        memset(&ServerAddr,0, sizeof(struct sockaddr_in));
-        ServerAddr.sin6_family = PF_INET6;
-        ServerAddr.sin6_addr = in6addr_any;
-        ServerAddr.sin6_port = htons(EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active);
-        if(bind(socketFd.Tcp, (struct sockaddr *)&ServerAddr, sizeof(struct sockaddr_in6)) < 0)
-        {
-        	DEBUG_ERROR("Fail to bind TcpSock(%s), SdpTcpServerPort: %d\n", strerror(errno), EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active);
-
-            if(bind(socketFd.Tcp, (struct sockaddr *)&ServerAddr, sizeof(struct sockaddr_in6)) < 0)
-            {
-                DEBUG_INFO("[Error Fail to bind TcpSock(%s), SdpTcpServerPort: %d\n", strerror(errno), EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active);
-                usleep(100000);
-                close(socketFd.Tcp);
-                socketFd.Tcp = -1;
-
-                return 0;
-            }
-            DEBUG_INFO("[TCP]bind: DONE\n");
-        }
-
-
-        DEBUG_INFO("[TCP]listen: START\n");
-        if(listen(socketFd.Tcp, 1) == -1)     //only accept one connection
-        {
-        	DEBUG_ERROR("Fail to listen TcpSock(%s)", strerror(errno));
-            usleep(100000);
-            close(socketFd.Tcp);
-            socketFd.Tcp = -1;
-
-            return 0;
-        }
-        DEBUG_INFO("[TCP]listen: DONE\n");
-        DEBUG_INFO("[TCP]TcpSock: opened(%d), port=%d\n", socketFd.Tcp, htons(ServerAddr.sin6_port));
-        DEBUG_INFO("[TCP]accept: START\n");
-    }
-
-    // Wait connection in
-    Rtn = sizeof(struct sockaddr_in6);
-    if((AcceptFd = accept(socketFd.Tcp, (struct sockaddr *)&ClientAddr, (socklen_t *)&Rtn)) == -1)
-    {
-        static BOOL tmp = 0;
-        if (tmp == 0)
-        {
-            DEBUG_INFO("[TCP]Wait TCP connection...\n");
-            tmp = 1;
-        }
-        else
-        {
-            //DEBUG_PRINTF_EVCOMM_DETAIL(".");
-        }
-        return 0;
-    }
-    DEBUG_INFO("[TCP]Accept: DONE\n");
-
-	DEBUG_PRINTF_EVCOMM_DETAIL("Accept one TCP connection:\n");
-	DEBUG_PRINTF_EVCOMM_DETAIL("AcceptFd: %d\n",AcceptFd);
-
-	memset(buf, 0x00, ARRAY_SIZE(buf));
-	for(Rtn = 0; Rtn < 16; Rtn += 2)
-	{
-		sprintf(buf, "%s%02x%02x:", buf, ClientAddr.sin6_addr.s6_addr[Rtn], ClientAddr.sin6_addr.s6_addr[Rtn+1]);
-	}
-	DEBUG_PRINTF_EVCOMM_DETAIL("ClientAddress: %s\n", buf);
-	DEBUG_PRINTF_EVCOMM_DETAIL("ClientPort: %d\n", ClientAddr.sin6_port);
-
-    return AcceptFd;
-}
-
-/**
- *
- * @return
- */
-int End_Process()
-{
-    if(EVCOMM_SYS_INFO.End_Process_inused == TRUE)
-    {
-        DEBUG_INFO("End_Process has been triggered by another event.\n");
-        return -1;
-    }
-    DEBUG_INFO("Entering...\n");
-
-    //STEP 1: Ask CSU to Stop
-    EVCOMM_SYS_INFO.End_Process_inused = TRUE;
-    CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
-    EVCOMM_SYS_INFO.ConnectorLocked = FALSE;
-    ShmInternalComm->ChargingPermission = FALSE;
-
-    //Step 2: Close sockets
-    DEBUG_INFO("Close RAW, UDP, TCP sockets...\n");
-    if(socketFd.Raw > 0)
-    {
-        close(socketFd.Raw);
-    }
-    if(socketFd.Udp > 0)
-    {
-        close(socketFd.Udp);
-    }
-    if(socketFd.Tcp > 0)
-    {
-        close(socketFd.Tcp);
-        close(socketFd.TcpAccept);
-    }
-    socketFd.Raw = socketFd.Udp = socketFd.Tcp = socketFd.TcpAccept = -1;
-
-    //STEP 3: Switch to State E
-    //SwitchCpStateE(ENABLE);
-
-    //STEP 4: Close tcpdump
-    Sniffer_Tcpdump(DISABLE);
-
-    //STEP 5: Keep 100% PWM for 5 seconds
-    OutputCpPwmDuty(100);
-    for(int idx=5;idx>0;idx--)
-    {
-    	DEBUG_INFO("Wait PWM switch to 100%% count down: %d\n", idx);
-    	sleep(1);
-    }
-
-    qcaInfo.AttenProfileCnt = 0;
-    init_appHandEXIDocument(&v2gObject.appHandshake);
-    // Qca7kPowerReset();  //reset QCA7000 /* +++ 20200808, vern, should disconnected PLC connection after session stop ---*/
-
-    #if (FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == DISABLE)
-    {
-        system("sync");
-    }
-    #endif
-
-    //STEP 4: Switch to State E
-    //Keep State E for 5 seconds
-    #if 0
-    SwitchCpStateE(ENABLE); //Set PWM Duty as 0 and set State as E (0V)
-    for(uint8_t idx=5;idx>0;idx--)
-    {
-    	DEBUG_INFO("Wait CP change to State E count down: %d\n", idx);
-    	sleep(1);
-    }
-    #endif
-
-    //Reset Memory
-    unsigned char SlaveAddress_backup;
-    unsigned int matched_backup;
-    //unsigned char state_backup;
-
-    #if (FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == DISABLE)
-    {
-        system("sync");
-    }
-    #endif
-
-    sleep(1);
-
-    //Backup CsuComm flags
-    SlaveAddress_backup = ShmInternalComm->SlaveAddress;
-    matched_backup = CSUCOMMDC_TASK_FLAG.matched;
-    //state_backup = Get_V2G_Status();
-
-    memset(v2gBuffer.rx, 0, V2GTP_MSG_RX_BUFFER_SIZE);
-    memset(v2gBuffer.tx, 0, V2GTP_MSG_TX_BUFFER_SIZE);
-    memset(&v2gObject.appHandshake, 0, sizeof(struct appHandEXIDocument));
-    memset(&v2gObject.DIN, 0, sizeof(struct dinEXIDocument));
-    memset(ShmStatusCodeData, 0, sizeof(struct StatusCodeData));
-    memset(ShmInternalComm, 0, sizeof(struct InternalComm));
-    memset(ShmCcsData, 0, sizeof(struct CcsData));
-
-    //Resume CsuComm flags
-    ShmInternalComm->SlaveAddress = SlaveAddress_backup;
-    CSUCOMMDC_TASK_FLAG.matched = matched_backup;
-    Sniffer_Candump(DISABLE);
-    Sniffer_Candump(ENABLE);
-
-    DEBUG_INFO("---------------------------------------------\n");
-    DEBUG_INFO("--               EVCOMM: END               --\n");
-    DEBUG_INFO("---------------------------------------------\n");
-    system("pkill Module_CCS");
-    while(1)
-    {
-        //wait for CSU confirm
-    	usleep(1000);
-    }
-}
-
-/**
- *
- * @return
- */
-int Parameters_Init()
-{
-    //Step 0: Generate random number
-    unsigned int value_random;
-    struct timeb time_seed;
-    ftime(&time_seed);
-    srand(time_seed.millitm);
-
-    //Step 1: Init SDP TCP Port
-    srand(time(NULL));
-    value_random = rand();
-    EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active = (unsigned short)(SdpTcpServerPort + (value_random % 10000) + 1);
-    DEBUG_INFO("TCP Port assign: %d\n", EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active);
-
-    //Step 2: Init SessionID
-    srand(time(NULL));
-    value_random = rand();
-    memcpy(&EVCOMM_SYS_INFO.SessionID[0], &value_random, 4);
-
-    srand(time(NULL));
-    value_random = rand();
-    memcpy(&EVCOMM_SYS_INFO.SessionID[4], &value_random, 4);
-
-    DEBUG_INFO("SessionID: (%02X%02X%02X%02X%02X%02X%02X%02X)\n",
-							EVCOMM_SYS_INFO.SessionID[0],
-							EVCOMM_SYS_INFO.SessionID[1],
-							EVCOMM_SYS_INFO.SessionID[2],
-							EVCOMM_SYS_INFO.SessionID[3],
-							EVCOMM_SYS_INFO.SessionID[4],
-							EVCOMM_SYS_INFO.SessionID[5],
-							EVCOMM_SYS_INFO.SessionID[6],
-							EVCOMM_SYS_INFO.SessionID[7]);
-
-    return 0;
-}
-
-/**
- *
- * @return
- */
-int SyncAcShreaMemory()
-{
-#if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
-	pid_t pid;
-
-	pid = fork();
-	if(pid == 0)
-	{
-		for(;;)
-		{
-			if(!EVCOMM_SYS_INFO.End_Process_inused)
-			{
-				for(uint8_t gun_index=0;gun_index<1;gun_index++)
-				{
-					//========================================
-					// CSU -> CCS setting
-					//========================================
-					// Heart beat
-					ShmCharger->gun_info[gun_index].acCcsInfo.CcsHeartBeat++;
-
-					// Permission
-					if(ShmInternalComm->ChargingPermission != ShmCharger->gun_info[gun_index].acCcsInfo.ChargingPermission)
-					{
-						DEBUG_INFO("AC permission: %d -> %d\n", ShmInternalComm->ChargingPermission, ShmCharger->gun_info[gun_index].acCcsInfo.ChargingPermission);
-						ShmInternalComm->ChargingPermission_new = ShmCharger->gun_info[gun_index].acCcsInfo.ChargingPermission;
-						ShmInternalComm->ChargingPermission_pre = ShmInternalComm->ChargingPermission;
-						ShmInternalComm->ChargingPermission = ShmInternalComm->ChargingPermission_new;
-					}
-
-					// CP
-					ShmInternalComm->AC_CpPositiveVoltage = ShmCharger->gun_info[gun_index].acCcsInfo.CpPositiveVoltage;
-					if(ShmInternalComm->AC_CpPresentState != ShmCharger->gun_info[gun_index].acCcsInfo.CpPresentState)
-					{
-						DEBUG_INFO("CP state: %d -> %d\n", ShmInternalComm->AC_CpPresentState, ShmCharger->gun_info[gun_index].acCcsInfo.CpPresentState);
-						ShmInternalComm->AC_CpPresentState = ShmCharger->gun_info[gun_index].acCcsInfo.CpPresentState;
-					}
-
-					// Charging parameter
-					ShmSysConfigAndInfo->SysInfo.CcsChargingData[gun_index].AvailableChargingCurrent = ShmInternalComm->AvailableChargingCurrent = ShmCharger->gun_info[gun_index].targetCurrent;
-
-					// RCD status sync
-					ShmInternalComm->AC_RcdStatus = 0;
-
-					// EVSENotification
-					ShmInternalComm->AC_EVSENotification = 0;//ShmCharger->gun_info[gun_index].acCcsInfo.EVSENotification;
-
-					//========================================
-					// CCS -> CSU check
-					//========================================
-					// V2G message flow status
-					if(ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus != Get_V2G_Status())
-					{
-						//DEBUG_INFO("PresentMsgFlowStatus: %d -> %d\n", ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus, Get_V2G_Status());
-						ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus = Get_V2G_Status();
-
-						switch(ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus)
-						{
-							case PowerDeliveryRequestStart ... SessionStopRequest:
-								ShmCharger->gun_info[gun_index].acCcsInfo.EVChargeProgress = HLC_START_MODE;
-								break;
-							case CM_SLAC_PARM_REQ ... PreChargeResponse:
-								ShmCharger->gun_info[gun_index].acCcsInfo.EVChargeProgress = HLC_STANDBY_MODE;
-								break;
-							default:
-								ShmCharger->gun_info[gun_index].acCcsInfo.EVChargeProgress = HLC_STOP_MODE;
-								break;
-						}
-					}
-				}
-			}
-
-
-			usleep(1000);
-		}
-	}
-#endif
-
-	return 0;
-}
-
-/**
- *
- * @param argc
- * @param argv
- * @return
- */
-int main(int argc, char *argv[])
-{
-    DEBUG_INFO("---------------------------------------------\n");
-    DEBUG_INFO("--               EVCOMM: START             --\n");
-    DEBUG_INFO("---------------------------------------------\n");
-
-    // QCA7000 chip reset
-	Qca7kPowerReset();
-
-    // Share memory Initialization
-    ShareMemory_Init();
-    memset(ShmSysConfigAndInfo, 0, sizeof(struct SysConfigAndInfo));
-
-    // Release socket handler
-    if(socketFd.Raw > 0)
-    {
-        close(socketFd.Raw);
-    }
-    if(socketFd.Udp > 0)
-    {
-        close(socketFd.Udp);
-    }
-    if(socketFd.Tcp > 0)
-    {
-        close(socketFd.Tcp);
-    }
-
-    socketFd.Raw = socketFd.Udp = socketFd.Tcp = -1;
-    Update_V2G_Status(IDLE);
-
-
-    //Init V2G TCP/IPv6 packets buffer
-    memset(v2gBuffer.rx, 0, V2GTP_MSG_RX_BUFFER_SIZE);
-    memset(v2gBuffer.tx, 0, V2GTP_MSG_TX_BUFFER_SIZE);
-
-    //Release State E Control
-    SwitchCpStateE(DISABLE);
-    OutputCpPwmDuty(100);
-
-    //start to detect CP pilot state
-    pid.CP_Detection = 0;
-    CP_Detection();     //fork1
-    DEBUG_INFO("[fork1]CP Detection: ON\n");
-
-    //start to detect errors
-    Error_Monitor();    //fork2
-    DEBUG_INFO("[fork2]Error Monitor: ON\n");
-
-    //start to detect PP
-    pid.PP_Detection = 0;
-#if (PP_PROTECTION_MECHANISM == ENABLE)
-    PP_Detection();
-    DEBUG_INFO("[fork3]PP Detection: ON\n");
-#else
-    DEBUG_INFO("[fork3]PP Detection: OFF\n");
-#endif
-
-    // Get network interface MAC address
-    GetEthMac((uint8_t*)"eth0", macAddr.eth0);
-    GetEthMac((uint8_t*)QcaInterface, macAddr.eth1);
-
-    // XML parser initialization
-    qcaInfo.AttenProfileCnt = 0;
-    init_appHandEXIDocument(&v2gObject.appHandshake);
-
-    // Init Energy transfer mode
-    // TODO:
-    // 	1. Parsing Model Name
-    ShmCcsData->EnergyTransferMode = CCS_ENERGY_TRANSFER_MODE;
-
-    Parameters_Init();
-    Sniffer_Tcpdump(TCPDUMP_PACKETS_SNIFFER_SWITCH);
-#if (TCPDUMP_PACKETS_SNIFFER_SWITCH == ENABLE)
-    sleep(1); //wait for TCP dump getting ready
-#endif
-
-    // AC share memory exchange
-    SyncAcShreaMemory();
-    DEBUG_INFO("[fork4]AC share memory exchange: ON\n");
-
-    DEBUG_INFO("Module_CCS initialize OK.\n");
-
-    for(;;)
-    {
-        if(!EVCOMM_SYS_INFO.End_Process_inused)
-        {
-            if(V2gFlowStatus < SLACC_SDP_UDP_Connection)
-            {
-                SlacComm();
-            }
-            else if(V2gFlowStatus == SLACC_SDP_UDP_Connection)
-            {
-                if(SdpUdpConnected() == 1)
-                {
-                	Update_V2G_Status(SLACC_SDP_TCP_Connection);
-                	continue;
-                }
-                SlacComm(); //TC_SECC_VTB_CmSlacMatch_004
-                ftime(&timerStart.SeqEnd);
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > TT_match_join)
-                {
-                	DEBUG_ERROR("Wait SLACC_SDP_UDP_Connection Timeout - TT_match_join (%.02lf of %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), TT_match_join);
-                    Update_V2G_Status(Sequence_Timeout);
-                    //Update_ShmStatusCode(); //[To-Do] to be implemented
-                    //CCS_SECC_TIMEOUT_SLACC_SDP_UDP_TT_match_join (023823)
-                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                    ShmStatusCodeData->PresentStatusCode[0][4] = 2;
-                    ShmStatusCodeData->PresentStatusCode[0][5] = 3;
-                    //CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-                    Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
-                }
-            }
-            else if(V2gFlowStatus == SLACC_SDP_TCP_Connection)
-            {
-                if((socketFd.TcpAccept = V2gTcpConnected()) > 0)
-                {
-                    Update_V2G_Status(SupportedAppProtocolRequest);
-                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
-
-                    continue;
-                }
-                SlacComm();
-                ftime(&timerStart.SeqEnd);
-
-                if(DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd) > TT_match_join)
-                {
-                	DEBUG_ERROR("Wait SLACC_SDP_TCP_Connection Timeout - TT_match_join (%.02lf / %d ms)\n", DiffTimeb(timerStart.SeqStart, timerStart.SeqEnd), TT_match_join);
-                    Update_V2G_Status(Sequence_Timeout);
-                    //Update_ShmStatusCode(); //[To-Do] to be implemented
-                    //CCS_SECC_TIMEOUT_SLACC_SDP_TCP_TT_match_join (023824)
-                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
-                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
-                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
-                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
-                    ShmStatusCodeData->PresentStatusCode[0][4] = 2;
-                    ShmStatusCodeData->PresentStatusCode[0][5] = 4;
-                    //CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
-                    Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
-                }
-            }
-            else if(V2gFlowStatus <= SessionStopResponse)
-            {
-                if (V2gComm(socketFd.TcpAccept) < 0)
-                {
-                    //error occurs
-                }
-            }
-            else if (V2gFlowStatus >= Performance_Timeout)
-            {
-                //End_Process
-            }
-            else
-            {}
-        }
-        else
-        {
-        	// TODO:
-        	//	1. After complete or error occur task do not need to end
-
-        	//Update_V2G_Status(IDLE);
-            //SwitchCpStateE(DISABLE);
-            //OutputCpPwmDuty(100);
-        }
-
-        usleep(1000);
-    } //while
-}//main while

EVSE/Projects/AW-CCS/Apps/CCS/NidNmk.c

@@ -1,300 +1,341 @@
-/*===========================================================================
-                    Combined Charging System (CCS): SECC
-                                NidNmk.c
-
-                        initiated by Vern, Joseph
-                           (since 2019/07/19)
-=============================================================================*/
-#include <time.h>
-#include <sys/time.h>
-#include "NidNmk.h"
-
-/*===========================================================================
-FUNCTION: StoreLogMsg
-DESCRIPTION:
-PRE-CONDITION:
-INPUT:
-OUTPUT:
-GLOBAL VARIABLES:
-=============================================================================*/
-void HPAVKeyNMK(uint8_t NMK [], const char *string)
-
-{
-    struct sha256 sha256;
-    uint8_t digest [SHA256_DIGEST_LENGTH];
-    const uint8_t secret [] =
-    {
-        0x08,
-        0x85,
-        0x6D,
-        0xAF,
-        0x7C,
-        0xF5,
-        0x81,
-        0x86
-    };
-    unsigned rehash = 999;
-
-    SHA256Reset(&sha256);
-    SHA256Write(&sha256, string, strlen(string));
-    SHA256Write(&sha256, secret, sizeof(secret));
-    SHA256Fetch(&sha256, digest);
-
-    while(rehash--)
-    {
-        SHA256Reset(&sha256);
-        SHA256Write(&sha256, digest, sizeof(digest));
-        SHA256Fetch(&sha256, digest);
-    }
-
-    memcpy(NMK, digest, HPAVKEY_NMK_LEN);
-    return;
-}
-
-void HPAVKeyNID(uint8_t NID[], const uint8_t NMK[], uint8_t level)
-{
-    struct sha256 sha256;
-    uint8_t digest [SHA256_DIGEST_LENGTH];
-    unsigned int rehash = 4;
-
-    SHA256Reset(&sha256);
-    SHA256Write(&sha256, NMK, HPAVKEY_NMK_LEN);
-    SHA256Fetch(&sha256, digest);
-
-    while(rehash--)
-    {
-        SHA256Reset(&sha256);
-        SHA256Write(&sha256, digest, sizeof(digest));
-        SHA256Fetch(&sha256, digest);
-    }
-
-    #if 1
-
-        level <<= 4;
-        digest [HPAVKEY_NID_LEN - 1] >>= 4;
-        digest [HPAVKEY_NID_LEN - 1] |= level;
-
-    #else
-
-        digest [HPAVKEY_NID_LEN - 1] &= ~0xC0;
-        digest [HPAVKEY_NID_LEN - 1] |= level << 6;
-
-    #endif
-
-    memcpy(NID, digest, HPAVKEY_NID_LEN);
-
-    return;
-}
-
-void SHA256Reset(struct sha256 *sha256)
-
-{
-    memset(sha256, 0, sizeof(struct sha256));
-    sha256->state [0] = 0x6A09E667;
-    sha256->state [1] = 0xBB67AE85;
-    sha256->state [2] = 0x3C6EF372;
-    sha256->state [3] = 0xA54FF53A;
-    sha256->state [4] = 0x510E527F;
-    sha256->state [5] = 0x9B05688C;
-    sha256->state [6] = 0x1F83D9AB;
-    sha256->state [7] = 0x5BE0CD19;
-    sha256->extra [0] = 0x80;
-    return;
-}
-
-void SHA256Block(struct sha256 *sha256, void const *memory)
-{
-    static const uint32_t K [sizeof(sha256->block)] =
-    {
-        0x428A2F98,
-        0x71374491,
-        0xB5C0FBCF,
-        0xE9B5DBA5,
-        0x3956C25B,
-        0x59F111F1,
-        0x923F82A4,
-        0xAB1C5ED5,
-        0xD807AA98,
-        0x12835B01,
-        0x243185BE,
-        0x550C7DC3,
-        0x72BE5D74,
-        0x80DEB1FE,
-        0x9BDC06A7,
-        0xC19BF174,
-        0xE49B69C1,
-        0xEFBE4786,
-        0x0FC19DC6,
-        0x240CA1CC,
-        0x2DE92C6F,
-        0x4A7484AA,
-        0x5CB0A9DC,
-        0x76F988DA,
-        0x983E5152,
-        0xA831C66D,
-        0xB00327C8,
-        0xBF597FC7,
-        0xC6E00BF3,
-        0xD5A79147,
-        0x06CA6351,
-        0x14292967,
-        0x27B70A85,
-        0x2E1B2138,
-        0x4D2C6DFC,
-        0x53380D13,
-        0x650A7354,
-        0x766A0ABB,
-        0x81C2C92E,
-        0x92722C85,
-        0xA2BFE8A1,
-        0xA81A664B,
-        0xC24B8B70,
-        0xC76C51A3,
-        0xD192E819,
-        0xD6990624,
-        0xF40E3585,
-        0x106AA070,
-        0x19A4C116,
-        0x1E376C08,
-        0x2748774C,
-        0x34B0BCB5,
-        0x391C0CB3,
-        0x4ED8AA4A,
-        0x5B9CCA4F,
-        0x682E6FF3,
-        0x748F82EE,
-        0x78A5636F,
-        0x84C87814,
-        0x8CC70208,
-        0x90BEFFFA,
-        0xA4506CEB,
-        0xBEF9A3F7,
-        0xC67178F2
-    };
-    unsigned int pass;
-    unsigned int word;
-    uint32_t H [sizeof(sha256->state) / sizeof(uint32_t)];
-    uint32_t W [sizeof(sha256->block)];
-    uint8_t *buffer = (uint8_t *)(memory);
-
-    for(word = 0; word < 16; word++)
-    {
-        W [word] = 0;
-        W [word] |= (uint32_t)(*buffer++) << 24;
-        W [word] |= (uint32_t)(*buffer++) << 16;
-        W [word] |= (uint32_t)(*buffer++) << 8;
-        W [word] |= (uint32_t)(*buffer++) << 0;;
-    }
-
-    for(; word < sizeof(sha256->block); word++)
-    {
-        uint32_t s0 = ROTR(W [word - 15], 7) ^ ROTR(W [word - 15], 18) ^ SHR(W [word - 15], 3);
-        uint32_t s1 = ROTR(W [word - 2], 17) ^ ROTR(W [word - 2], 19) ^ SHR(W [word - 2], 10);
-        W [word] = W [word - 16] + s0 + W [word - 7] + s1;
-    }
-
-    for(word = 0; word < (sizeof(sha256->state) / sizeof(uint32_t)); word++)
-    {
-        H [word] = sha256->state [word];
-    }
-
-    for(pass = 0; pass < sizeof(sha256->block); pass++)
-    {
-        uint32_t s2 = ROTR(H [0], 2) ^ ROTR(H [0], 13) ^ ROTR(H [0], 22);
-        uint32_t maj = (H [0] & H [1]) ^ (H [0] & H [2]) ^ (H [1] & H [2]);
-        uint32_t t2 = s2 + maj;
-        uint32_t s3 = ROTR(H [4], 6) ^ ROTR(H [4], 11) ^ ROTR(H [4], 25);
-        uint32_t ch = (H [4] & H [5]) ^ ((~H [4]) & H [6]);
-        uint32_t t1 = H [7] + s3 + ch + K [pass] + W [pass];
-
-        for(word = (sizeof(sha256->state) / sizeof(uint32_t)) - 1; word > 0; word--)
-        {
-            H [word] = H [word - 1];
-        }
-
-        H [0] = t1 + t2;
-        H [4] += t1;
-    }
-
-    for(word = 0; word < (sizeof(sha256->state) / sizeof(uint32_t)); word++)
-    {
-        sha256->state [word] += H [word];
-    }
-
-    return;
-}
-
-void SHA256Write(struct sha256 *sha256, void const *memory, uint16_t extent)
-
-{
-    if(extent)
-    {
-        uint8_t *buffer = (uint8_t *)(memory);
-        unsigned int left = sha256->count [0] & 0x3F;
-        unsigned int fill = sizeof(sha256->block) - left;
-        sha256->count [0] += (uint32_t)(extent);
-        sha256->count [0] &= 0xFFFFFFFF;
-
-        if(sha256->count [0] < extent)
-        {
-            sha256->count [1]++;
-        }
-
-        if((left) && (extent >= fill))
-        {
-            memcpy(sha256->block + left, buffer, fill);
-            SHA256Block(sha256, sha256->block);
-            extent -= fill;
-            buffer += fill;
-            left = 0;
-        }
-
-        while(extent >= sizeof(sha256->block))
-        {
-            SHA256Block(sha256, buffer);
-            extent -= sizeof(sha256->block);
-            buffer += sizeof(sha256->block);
-        }
-
-        if(extent)
-        {
-            memcpy(sha256->block + left, buffer, extent);
-        }
-    }
-
-    return;
-}
-
-void SHAEncode(uint8_t memory[], uint32_t number)
-{
-    *memory++ = (uint8_t)(number >> 24);
-    *memory++ = (uint8_t)(number >> 16);
-    *memory++ = (uint8_t)(number >> 8);
-    *memory++ = (uint8_t)(number >> 0);
-    return;
-}
-
-void SHA256Fetch(struct sha256 *sha256, uint8_t digest[])
-
-{
-    unsigned int word;
-    uint8_t bits [8];
-    uint32_t upper = (sha256->count [0] >> 29) | (sha256->count [1] << 3);
-    uint32_t lower = (sha256->count [0] << 3);
-    uint32_t final = (sha256->count [0] & 0x3F);
-    uint32_t extra = (final < 56) ? (56 - final) : (120 - final);
-
-    SHAEncode(&bits[0], upper);
-    SHAEncode(&bits[4], lower);
-    SHA256Write(sha256, sha256->extra, extra);
-    SHA256Write(sha256, bits, sizeof(bits));
-
-    for(word = 0; word < sizeof(sha256->state) / sizeof(uint32_t); word++)
-    {
-        SHAEncode(digest, sha256->state [word]);
-        digest += sizeof(uint32_t);
-    }
-
-    memset(sha256, 0, sizeof(struct sha256));
-    return;
-}
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                NidNmk.c
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+#include "NidNmk.h"
+#include "define.h"
+#include <time.h>
+#include<sys/time.h>
+unsigned char buf_log_nidmmk[SIZE_OF_LOG_BUFFER];
+/*===========================================================================
+FUNCTION: StoreLogMsg
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+#if SAVE_SYS_LOG_MSG_NIDNMK_SWITCH == ENABLE
+int StoreLogMsg(unsigned char *DataString)
+{
+    static unsigned char Buf[1024];
+    static time_t CurrentTime;
+    static struct tm *tm;
+    static struct timeval tv;
+
+    memset(Buf, 0, sizeof(Buf));
+    CurrentTime = time(NULL);
+    tm = localtime(&CurrentTime);
+    gettimeofday(&tv, NULL); // get microseconds, 10^-6
+
+    sprintf(Buf, "echo \"[%04d%02d%02d: %02d:%02d:%02d.%06d][NidNmk]%s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog",
+            tm->tm_year + 1900,
+            tm->tm_mon + 1,
+            tm->tm_mday,
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            DataString,
+            tm->tm_year + 1900,
+            tm->tm_mon + 1);
+    system(Buf);
+
+    DEBUG_PRINTF_NIDNMK_SYSTEM_LOG("[%02d:%02d:%02d.%06d][NidNmk]%s \n",
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            DataString);
+
+    //Reset the buf_log_nidmmk Buffer, i.e. DataString
+    memset(buf_log_nidmmk, 0, SIZE_OF_LOG_BUFFER);
+}
+#endif
+
+void HPAVKeyNMK(uint8_t NMK [], const char *string)
+
+{
+    struct sha256 sha256;
+    uint8_t digest [SHA256_DIGEST_LENGTH];
+    const uint8_t secret [] =
+    {
+        0x08,
+        0x85,
+        0x6D,
+        0xAF,
+        0x7C,
+        0xF5,
+        0x81,
+        0x86
+    };
+    unsigned rehash = 999;
+
+    SHA256Reset(&sha256);
+    SHA256Write(&sha256, string, strlen(string));
+    SHA256Write(&sha256, secret, sizeof(secret));
+    SHA256Fetch(&sha256, digest);
+
+    while(rehash--)
+    {
+        SHA256Reset(&sha256);
+        SHA256Write(&sha256, digest, sizeof(digest));
+        SHA256Fetch(&sha256, digest);
+    }
+
+    memcpy(NMK, digest, HPAVKEY_NMK_LEN);
+    return;
+}
+
+
+void HPAVKeyNID(uint8_t NID[], const uint8_t NMK[], uint8_t level)
+
+{
+    struct sha256 sha256;
+    uint8_t digest [SHA256_DIGEST_LENGTH];
+    unsigned int rehash = 4;
+
+    SHA256Reset(&sha256);
+    SHA256Write(&sha256, NMK, HPAVKEY_NMK_LEN);
+    SHA256Fetch(&sha256, digest);
+
+    while(rehash--)
+    {
+        SHA256Reset(&sha256);
+        SHA256Write(&sha256, digest, sizeof(digest));
+        SHA256Fetch(&sha256, digest);
+    }
+
+    #if 1
+
+        level <<= 4;
+        digest [HPAVKEY_NID_LEN - 1] >>= 4;
+        digest [HPAVKEY_NID_LEN - 1] |= level;
+
+    #else
+
+        digest [HPAVKEY_NID_LEN - 1] &= ~0xC0;
+        digest [HPAVKEY_NID_LEN - 1] |= level << 6;
+
+    #endif
+
+    memcpy(NID, digest, HPAVKEY_NID_LEN);
+
+    return;
+}
+
+void SHA256Reset(struct sha256 *sha256)
+
+{
+    memset(sha256, 0, sizeof(struct sha256));
+    sha256->state [0] = 0x6A09E667;
+    sha256->state [1] = 0xBB67AE85;
+    sha256->state [2] = 0x3C6EF372;
+    sha256->state [3] = 0xA54FF53A;
+    sha256->state [4] = 0x510E527F;
+    sha256->state [5] = 0x9B05688C;
+    sha256->state [6] = 0x1F83D9AB;
+    sha256->state [7] = 0x5BE0CD19;
+    sha256->extra [0] = 0x80;
+    return;
+}
+void SHA256Block(struct sha256 *sha256, void const *memory)
+
+{
+    static const uint32_t K [sizeof(sha256->block)] =
+    {
+        0x428A2F98,
+        0x71374491,
+        0xB5C0FBCF,
+        0xE9B5DBA5,
+        0x3956C25B,
+        0x59F111F1,
+        0x923F82A4,
+        0xAB1C5ED5,
+        0xD807AA98,
+        0x12835B01,
+        0x243185BE,
+        0x550C7DC3,
+        0x72BE5D74,
+        0x80DEB1FE,
+        0x9BDC06A7,
+        0xC19BF174,
+        0xE49B69C1,
+        0xEFBE4786,
+        0x0FC19DC6,
+        0x240CA1CC,
+        0x2DE92C6F,
+        0x4A7484AA,
+        0x5CB0A9DC,
+        0x76F988DA,
+        0x983E5152,
+        0xA831C66D,
+        0xB00327C8,
+        0xBF597FC7,
+        0xC6E00BF3,
+        0xD5A79147,
+        0x06CA6351,
+        0x14292967,
+        0x27B70A85,
+        0x2E1B2138,
+        0x4D2C6DFC,
+        0x53380D13,
+        0x650A7354,
+        0x766A0ABB,
+        0x81C2C92E,
+        0x92722C85,
+        0xA2BFE8A1,
+        0xA81A664B,
+        0xC24B8B70,
+        0xC76C51A3,
+        0xD192E819,
+        0xD6990624,
+        0xF40E3585,
+        0x106AA070,
+        0x19A4C116,
+        0x1E376C08,
+        0x2748774C,
+        0x34B0BCB5,
+        0x391C0CB3,
+        0x4ED8AA4A,
+        0x5B9CCA4F,
+        0x682E6FF3,
+        0x748F82EE,
+        0x78A5636F,
+        0x84C87814,
+        0x8CC70208,
+        0x90BEFFFA,
+        0xA4506CEB,
+        0xBEF9A3F7,
+        0xC67178F2
+    };
+    unsigned int pass;
+    unsigned int word;
+    uint32_t H [sizeof(sha256->state) / sizeof(uint32_t)];
+    uint32_t W [sizeof(sha256->block)];
+    uint8_t *buffer = (uint8_t *)(memory);
+
+    for(word = 0; word < 16; word++)
+    {
+        W [word] = 0;
+        W [word] |= (uint32_t)(*buffer++) << 24;
+        W [word] |= (uint32_t)(*buffer++) << 16;
+        W [word] |= (uint32_t)(*buffer++) << 8;
+        W [word] |= (uint32_t)(*buffer++) << 0;;
+    }
+
+    for(word = word; word < sizeof(sha256->block); word++)
+    {
+        uint32_t s0 = ROTR(W [word - 15], 7) ^ ROTR(W [word - 15], 18) ^ SHR(W [word - 15], 3);
+        uint32_t s1 = ROTR(W [word - 2], 17) ^ ROTR(W [word - 2], 19) ^ SHR(W [word - 2], 10);
+        W [word] = W [word - 16] + s0 + W [word - 7] + s1;
+    }
+
+    for(word = 0; word < (sizeof(sha256->state) / sizeof(uint32_t)); word++)
+    {
+        H [word] = sha256->state [word];
+    }
+
+    for(pass = 0; pass < sizeof(sha256->block); pass++)
+    {
+        uint32_t s2 = ROTR(H [0], 2) ^ ROTR(H [0], 13) ^ ROTR(H [0], 22);
+        uint32_t maj = (H [0] & H [1]) ^ (H [0] & H [2]) ^ (H [1] & H [2]);
+        uint32_t t2 = s2 + maj;
+        uint32_t s3 = ROTR(H [4], 6) ^ ROTR(H [4], 11) ^ ROTR(H [4], 25);
+        uint32_t ch = (H [4] & H [5]) ^ ((~H [4]) & H [6]);
+        uint32_t t1 = H [7] + s3 + ch + K [pass] + W [pass];
+
+        for(word = (sizeof(sha256->state) / sizeof(uint32_t)) - 1; word > 0; word--)
+        {
+            H [word] = H [word - 1];
+        }
+
+        H [0] = t1 + t2;
+        H [4] += t1;
+    }
+
+    for(word = 0; word < (sizeof(sha256->state) / sizeof(uint32_t)); word++)
+    {
+        sha256->state [word] += H [word];
+    }
+
+    return;
+}
+
+void SHA256Write(struct sha256 *sha256, void const *memory, uint16_t extent)
+
+{
+    if(extent)
+    {
+        uint8_t *buffer = (uint8_t *)(memory);
+        unsigned int left = sha256->count [0] & 0x3F;
+        unsigned int fill = sizeof(sha256->block) - left;
+        sha256->count [0] += (uint32_t)(extent);
+        sha256->count [0] &= 0xFFFFFFFF;
+
+        if(sha256->count [0] < extent)
+        {
+            sha256->count [1]++;
+        }
+
+        if((left) && (extent >= fill))
+        {
+            memcpy(sha256->block + left, buffer, fill);
+            SHA256Block(sha256, sha256->block);
+            extent -= fill;
+            buffer += fill;
+            left = 0;
+        }
+
+        while(extent >= sizeof(sha256->block))
+        {
+            SHA256Block(sha256, buffer);
+            extent -= sizeof(sha256->block);
+            buffer += sizeof(sha256->block);
+        }
+
+        if(extent)
+        {
+            memcpy(sha256->block + left, buffer, extent);
+        }
+    }
+
+    return;
+}
+void SHAEncode(uint8_t memory[], uint32_t number)
+
+{
+    *memory++ = (uint8_t)(number >> 24);
+    *memory++ = (uint8_t)(number >> 16);
+    *memory++ = (uint8_t)(number >> 8);
+    *memory++ = (uint8_t)(number >> 0);
+    return;
+}
+
+void SHA256Fetch(struct sha256 *sha256, uint8_t digest[])
+
+{
+    unsigned int word;
+    uint8_t bits [8];
+    uint32_t upper = (sha256->count [0] >> 29) | (sha256->count [1] << 3);
+    uint32_t lower = (sha256->count [0] << 3);
+    uint32_t final = (sha256->count [0] & 0x3F);
+    uint32_t extra = (final < 56) ? (56 - final) : (120 - final);
+
+    SHAEncode(&bits[0], upper);
+    SHAEncode(&bits[4], lower);
+    SHA256Write(sha256, sha256->extra, extra);
+    SHA256Write(sha256, bits, sizeof(bits));
+
+    for(word = 0; word < sizeof(sha256->state) / sizeof(uint32_t); word++)
+    {
+        SHAEncode(digest, sha256->state [word]);
+        digest += sizeof(uint32_t);
+    }
+
+    memset(sha256, 0, sizeof(struct sha256));
+    return;
+}

EVSE/Projects/AW-CCS/Apps/CCS/NidNmk.h

@@ -1,40 +1,94 @@
-/*===========================================================================
-                    Combined Charging System (CCS): SECC
-                                 NidNmk.h
-
-                        initiated by Vern, Joseph
-                           (since 2019/07/19)
-=============================================================================*/
-
-#include <stdint.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <string.h>
-
-typedef struct sha256
-{
-
-    uint32_t count [2];
-    uint32_t state [8];
-    uint8_t block [64];
-    uint8_t extra [64];
-
-} SHA256;
-
-#define SHA256_DIGEST_LENGTH 256 / 8
-#define HPAVKEY_NMK_LEN 16
-#define HPAVKEY_NID_LEN 7
-#define SHR(word, bits) ((word & 0xFFFFFFFF) >> bits)
-#define ROTR(word, bits) (SHR(word, bits) | (word << (32 - bits)))
-#define DEFAULT_LEVEL 0
-//--------------------------------------------------------------------------
-/* Functions -----------------------------------------------------------*/
-//--------------------------------------------------------------------------
-void HPAVKeyNMK(uint8_t NMK [], const char *string);
-void HPAVKeyNID(uint8_t NID [], const uint8_t NMK [], uint8_t level);
-void SHA256Reset(struct sha256 *sha256);
-void SHA256Block(struct sha256 *sha256, void const *memory);
-void SHA256Write(struct sha256 *sha256, void const *memory, uint16_t extent);
-void SHAEncode(uint8_t memory [], uint32_t number);
-void SHA256Fetch(struct sha256 *sha256, uint8_t digest []);
-
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                 NidNmk.h
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+
+#include <stdint.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == ENABLE
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_NIDNMK_SWITCH         DISABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_NIDNMK_SHOW               DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_NIDNMK_BRIEF_SHOW         DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_NIDNMK_DETAIL_SHOW        DISABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_NIDNMK_SYSTEM_LOG_SHOW    DISABLE      //ENABLE, DISABLE
+#else //debug mode
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_NIDNMK_SWITCH         ENABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_NIDNMK_SHOW               ENABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_NIDNMK_BRIEF_SHOW         ENABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_NIDNMK_DETAIL_SHOW        ENABLE      //ENABLE, DISABLE
+#define DEBUG_PRINTF_NIDNMK_SYSTEM_LOG_SHOW    ENABLE      //ENABLE, DISABLE
+#endif
+
+typedef struct sha256
+{
+
+    uint32_t count [2];
+    uint32_t state [8];
+    uint8_t block [64];
+    uint8_t extra [64];
+
+} NidSHA256;
+
+#define SHA256_DIGEST_LENGTH 256 / 8
+#define HPAVKEY_NMK_LEN 16
+#define HPAVKEY_NID_LEN 7
+#define SHR(word, bits) ((word & 0xFFFFFFFF) >> bits)
+#define ROTR(word, bits) (SHR(word, bits) | (word << (32 - bits)))
+#define DEFAULT_LEVEL 0
+//--------------------------------------------------------------------------
+/* Functions -----------------------------------------------------------*/
+//--------------------------------------------------------------------------
+void HPAVKeyNMK(uint8_t NMK [], const char *string);
+void HPAVKeyNID(uint8_t NID [], const uint8_t NMK [], uint8_t level);
+void SHA256Reset(struct sha256 *sha256);
+void SHA256Block(struct sha256 *sha256, void const *memory);
+void SHA256Write(struct sha256 *sha256, void const *memory, uint16_t extent);
+void SHAEncode(uint8_t memory [], uint32_t number);
+void SHA256Fetch(struct sha256 *sha256, uint8_t digest []);
+
+//System Log
+#if SAVE_SYS_LOG_MSG_NIDNMK_SWITCH == ENABLE
+    #define SAVE_SYS_LOG_MSG_NIDNMK     StoreLogMsg
+#else
+    #define SAVE_SYS_LOG_MSG_NIDNMK(...)
+#endif
+
+//Debug Message
+#if DEBUG_PRINTF_NIDNMK_SHOW == ENABLE
+    //Brief Messages
+    #if DEBUG_PRINTF_NIDNMK_BRIEF_SHOW == ENABLE
+        #define DEBUG_PRINTF_NIDNMK_BRIEF      printf
+    #else
+        #define DEBUG_PRINTF_NIDNMK_BRIEF(...)
+    #endif
+
+    //Detail Messages
+    #if DEBUG_PRINTF_NIDNMK_DETAIL_SHOW == ENABLE
+        #define DEBUG_PRINTF_NIDNMK_DETAIL     printf
+    #else
+        #define DEBUG_PRINTF_NIDNMK_DETAIL(...)
+    #endif
+
+    //System Log Messages
+    #if DEBUG_PRINTF_NIDNMK_SYSTEM_LOG_SHOW == ENABLE
+        #define DEBUG_PRINTF_NIDNMK_SYSTEM_LOG    printf
+    #else
+        #define DEBUG_PRINTF_NIDNMK_SYSTEM_LOG(...)
+    #endif
+#else
+    #define DEBUG_PRINTF_NIDNMK_BRIEF(...)
+    #define DEBUG_PRINTF_NIDNMK_DETAIL(...)
+    #define DEBUG_PRINTF_NIDNMK_SYSTEM_LOG(...)
+#endif

EVSE/Projects/AW-CCS/Apps/CCS/PCBATester.c

@@ -0,0 +1,1238 @@
+/*===========================================================================
+                     Combined Charging System (CCS): SECC
+                                 PCBATester.c
+
+                             initiated by Joseph
+                              (since 2020/05/19)
+=============================================================================*/
+#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 <linux/can.h>
+#include <linux/can/raw.h>
+#include <sys/time.h>
+#include <sys/timeb.h>
+#include <math.h>//for pow
+#include <net/if.h>
+#include <unistd.h>
+#include <netinet/ip.h>
+#include <arpa/inet.h>
+#include <linux/if_packet.h>
+#include <netinet/if_ether.h>
+#include <netinet/ether.h>
+#include <errno.h>
+
+#include "define.h"
+#include "CsuComm.h"
+#include "SeccComm.h"
+#include "PCBATester.h"
+
+#if SAVE_SYS_LOG_MSG_PCBATESTER_SWITCH == ENABLE
+unsigned char buf_log_pcbatstr[SIZE_OF_LOG_BUFFER];
+#endif
+
+unsigned char QcaMac[6];
+unsigned char CsuMac[6] = {0x60, 0x39, 0x1F, 0x01, 0x02, 0x03};
+
+int RawSock = 0;
+unsigned char *V2gtpMsgRxBuf, *V2gtpMsgTxBuf;
+struct sockaddr_ll DestSocketAddress;
+struct ifreq Req;
+
+struct timeb SeqStartTime, SeqEndTime;
+
+/*===========================================================================
+FUNCTION: StoreLogMsg
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+#if SAVE_SYS_LOG_MSG_PCBATESTER_SWITCH == ENABLE
+int StoreLogMsg(unsigned char *DataString)
+{
+    static unsigned char Buf[1024];
+    static time_t CurrentTime;
+    static struct tm *tm;
+    static struct timeval tv;
+
+    memset(Buf, 0, sizeof(Buf));
+    CurrentTime = time(NULL);
+    tm = localtime(&CurrentTime);
+    gettimeofday(&tv, NULL); // get microseconds, 10^-6
+
+    sprintf(Buf, "echo \"[%04d%02d%02d: %02d:%02d:%02d.%06d][PCBATester]%s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog",
+            tm->tm_year + 1900,
+            tm->tm_mon + 1,
+            tm->tm_mday,
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            DataString,
+            tm->tm_year + 1900,
+            tm->tm_mon + 1);
+    system(Buf);
+
+    DEBUG_PRINTF_PCBATESTER_SYSTEM_LOG("[%02d:%02d:%02d.%06d][PCBATester]%s \n",
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            DataString);
+
+    //Reset the buf_log_pcbatstr Buffer, i.e. DataString
+    memset(buf_log_pcbatstr, 0, SIZE_OF_LOG_BUFFER);
+}
+#endif
+
+/*===========================================================================
+FUNCTION: DiffTimeb
+DESCRIPTION:
+    Caculating the time difference in ms precision (milli-second).
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+double DiffTimeb(struct timeb ST, struct timeb ET)
+{
+    //return milli-second
+    double StartTime, EndTime;
+    double t_diff;
+
+    StartTime = ((double)ST.time)*1000 + (double)ST.millitm;
+    EndTime = ((double)ET.time)*1000 + (double)ET.millitm;
+    t_diff = EndTime - StartTime;
+
+    //printf("%.02lf - %.02lf = %.02lf\n", EndTime, StartTime, t_diff);
+
+    if (t_diff < 0)
+    {
+        #if 0
+        if (t_diff < -1000)   //1000ms
+        {
+            sprintf(buf_log_pcbatstr,
+                    "[Warning]StartTime(%.02lf) > EndTime(%.02lf), d(%.02lf)",
+                    StartTime,
+                    EndTime,
+                    t_diff);
+            SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+        }
+        #endif
+
+        return -1;
+    }
+    return t_diff;
+}
+
+/*===========================================================================
+FUNCTION: GetQca7kMac
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int GetQca7kMac()
+{
+    int i = 0;
+    struct QcaVendorMmeHeader SendPacket;
+
+    memset(&SendPacket, 0, sizeof(struct QcaVendorMmeHeader));
+    memset(SendPacket.ODA, 0xFF, 6);    //broadcast
+    memcpy(SendPacket.OSA, CsuMac, 6);
+    SendPacket.MTYPE = htons(EtherType_HomePlug);
+    SendPacket.MMV = 0x00;
+    SendPacket.MMTYPE = MMTYPE_VENDOR_VS_NW_INFO;
+    SendPacket.OUI[0] = 0x00;
+    SendPacket.OUI[1] = 0xB0;
+    SendPacket.OUI[2] = 0x52;
+
+    i = sendto(RawSock, &SendPacket, 20, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+
+    DEBUG_PRINTF_EVCOMM_DETAIL("GetQca7kMac: send size =%d\n", i);
+    SAVE_SYS_LOG_MSG_PCBATESTER("[QCA7K][Tx][VENDOR_VS_NW_INFO]Req for QCA7K MacAddr");
+}
+
+
+/*===========================================================================
+FUNCTION: CANBus_Init
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int CANBus_Init()
+{
+    int s0, nbytes;
+    struct timeval tv;
+    struct ifreq ifr0;
+    struct sockaddr_can addr0;
+
+    system("/sbin/ip link set can0 type can bitrate 500000 restart-ms 100");
+    system("/sbin/ip link set can0 up");
+
+    s0 = socket(PF_CAN, SOCK_RAW, CAN_RAW);
+    if (s0 < 0) //added by Joseph (not full implemented)
+    {
+        SAVE_SYS_LOG_MSG_PCBATESTER("[ERROR] Fail on initializing CAN Bus socket");
+        return -1;
+    }
+
+    tv.tv_sec = 0;
+    tv.tv_usec = 10000;
+
+    if(setsockopt(s0, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct timeval)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_PCBATESTER("CANBus_Init:Set SO_RCVTIMEO NG");
+    }
+
+    nbytes = 40960;
+
+    if(setsockopt(s0, SOL_SOCKET,  SO_RCVBUF, &nbytes, sizeof(int)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_PCBATESTER("CANBus_Init:Set SO_RCVBUF NG");
+    }
+
+    nbytes = 40960;
+
+    if(setsockopt(s0, SOL_SOCKET, SO_SNDBUF, &nbytes, sizeof(int)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_PCBATESTER("CANBus_Init:Set SO_SNDBUF NG");
+    }
+
+    strcpy(ifr0.ifr_name, "can0" );
+    ioctl(s0, SIOCGIFINDEX, &ifr0); /* ifr.ifr_ifindex gets filled with that device's index */
+    addr0.can_family = AF_CAN;
+    addr0.can_ifindex = ifr0.ifr_ifindex;
+    bind(s0, (struct sockaddr *)&addr0, sizeof(addr0));
+    return s0;
+}
+
+/*===========================================================================
+FUNCTION: CAN_Tx_MSG
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int CAN_Tx_MSG(int Fd, unsigned int MsgId, unsigned char SlaveAddress, unsigned char DataLength, unsigned char *SendData)
+{
+    struct can_frame frame;
+    unsigned int tmp = 0;
+    int nbytes = 0;
+    int i = 0;
+
+    //Protection: To avoid unexpected length for CAN bus payload.
+    if (DataLength > 8)
+    {
+        DataLength = 8;
+    }
+
+    memset(&frame, 0, sizeof(struct can_frame));
+    frame.can_id = 0x80000000 | CAN_SEND_DIRECTION | MsgId | SlaveAddress;  //0x80000000: extension ID format
+    frame.can_dlc = DataLength;
+    memcpy(frame.data, SendData, DataLength);
+    nbytes = write(Fd, &frame, sizeof(struct can_frame));
+
+    #if 0
+    DEBUG_PRINTF_PCBATESTER_DETAIL("[CsuComm][CAN_Tx_MSG] <%X> ", frame.can_id);
+    for (i = 0; i < frame.can_dlc; i++)
+    {
+        DEBUG_PRINTF_PCBATESTER_DETAIL("%02X ", frame.data[i]);
+    }
+    DEBUG_PRINTF_PCBATESTER_DETAIL("(%d Bytes)\n", frame.can_dlc);
+    #endif
+
+    return nbytes;
+}
+
+/*===========================================================================
+FUNCTION: PRINT_CAN_FRAME
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_CAN_FRAME(struct can_frame *frame)
+{
+    if (frame->can_dlc != 0)
+    {
+        int i = 0;
+        DEBUG_PRINTF_PCBATESTER_DETAIL("[CsuComm] Got CAN Message: \n\
+                \t - Length: %d (Bytes, DEC)\n\
+                \t - ID: %08X\n\
+                \t - Payload: ",
+                frame->can_dlc,
+                frame->can_id
+                );
+        for (i = 0; i< frame->can_dlc; i++)
+        {
+            DEBUG_PRINTF_PCBATESTER_DETAIL("%02X ", frame->data[i]);
+        }
+        DEBUG_PRINTF_PCBATESTER_DETAIL("\n");
+    }
+}
+
+
+/*===========================================================================
+FUNCTION: System_Init
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int System_Init()
+{
+    system("../root/stop.sh");
+}
+
+/*===========================================================================
+FUNCTION: ReadAdcVolt
+DESCRIPTION:
+    1. fork1
+
+    #define ADC_CHANNEL_AIN0_NTC1   0
+    #define ADC_CHANNEL_AIN1_NTC2   1
+    #define ADC_CHANNEL_AIN2_PP     2
+    #define ADC_CHANNEL_AIN3_CP     3
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+float ReadAdcVolt(unsigned char AdcChannel)
+{
+    //AIN0=CCS GUN Temp 1
+    //AIN1=CCS GUN Temp 2
+    //AIN2=CCS_Proximity/2
+    //AIN3=pilot voltage
+
+    int fd;
+    int AvgTimes = 0;
+    unsigned char SampleBuf[4];
+    float TmpVolt = 0;
+    float AvgSample = 0;
+    float result = 0;
+
+    switch (AdcChannel)
+    {
+        case ADC_CHANNEL_AIN0_NTC1: //0
+        {
+            fd = open("/sys/bus/iio/devices/iio\:device0/in_voltage0_raw", O_RDONLY);
+            break;
+        }
+        case ADC_CHANNEL_AIN1_NTC2: //1
+        {
+            fd = open("/sys/bus/iio/devices/iio\:device0/in_voltage1_raw", O_RDONLY);
+            break;
+        }
+        case ADC_CHANNEL_AIN2_PP:   //2
+        {
+            fd = open("/sys/bus/iio/devices/iio\:device0/in_voltage2_raw", O_RDONLY);
+            break;
+        }
+        case ADC_CHANNEL_AIN3_CP:   //3
+        {
+            fd = open("/sys/bus/iio/devices/iio\:device0/in_voltage3_raw", O_RDONLY);
+            break;
+        }
+        default:
+        {
+            sprintf(buf_log_pcbatstr, "[ReadAdcVolt]unexpected AdcChannel(%d)", AdcChannel);
+            SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+            return -1;
+        }
+    }
+
+    if(fd > 0)
+    {
+        for(AvgTimes = 0; AvgTimes < 5; AvgTimes++) //get 5 samples
+        {
+            read(fd, SampleBuf, 4);
+            TmpVolt = (float)atoi(SampleBuf);
+            lseek(fd, 0, SEEK_SET);
+            AvgSample += TmpVolt;
+        }
+        close(fd);
+        AvgSample /= AvgTimes;
+
+        switch (AdcChannel)
+        {
+            case ADC_CHANNEL_AIN0_NTC1: //0
+            {
+                result = (3.6 * AvgSample) / 4095;
+                //sprintf(buf_log_pcbatstr, "[ReadAdcVolt]AIN0_NTC1 = %.02f", result);
+                //SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+                break;
+            }
+            case ADC_CHANNEL_AIN1_NTC2: //1
+            {
+                result = (3.6 * AvgSample) / 4095;
+                //sprintf(buf_log_pcbatstr, "[ReadAdcVolt]AIN1_NTC2 = %.02f", result);
+                //SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+                break;
+            }
+            case ADC_CHANNEL_AIN2_PP:   //2
+            {
+                result = (3.6 * AvgSample) / 4095;
+                //sprintf(buf_log_pcbatstr, "[ReadAdcVolt]AIN2_PP = %.02f", result);
+                //SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+                break;
+            }
+            case ADC_CHANNEL_AIN3_CP:   //3
+            {
+                result = (0.954-(1.8*AvgSample/4095))/0.06;
+                //sprintf(buf_log_pcbatstr, "[ReadAdcVolt]AIN3_CP = %.02f", result);
+                //SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+                break;
+            }
+            default:
+            {
+                sprintf(buf_log_pcbatstr, "[ReadAdcVolt]unknown AdcChannel(%d)", AdcChannel);
+                SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+                result = -1;
+                break;
+            }
+        }
+        return result;
+    }
+    else
+    {
+        SAVE_SYS_LOG_MSG_PCBATESTER("[ReadAdcVolt]failed on open adc channel");
+        return -1;
+    }
+}
+
+/*===========================================================================
+FUNCTION: PCBATstr_canbus
+DESCRIPTION:
+    1. Tx: AA 55
+    2. Rx: 55 AA (expected)
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int PCBATstr_canbus()
+{
+    int FD_CAN_Socket = 0;
+    int result = PASS;
+    int err_cnt = 0;
+    SAVE_SYS_LOG_MSG_PCBATESTER("-------- [canbus] start --------");
+    unsigned char can_tx_payload[8];
+    struct can_frame frame;
+
+    //Step 1: CAN Bus
+    FD_CAN_Socket = CANBus_Init();
+    if (FD_CAN_Socket < 0)
+    {
+         return FAIL;
+    }
+
+    while(1)
+    {
+        //Step 2: Tx CAN Message
+        memset(can_tx_payload, 0, sizeof(can_tx_payload));
+        can_tx_payload[0] = 0xAA;
+        can_tx_payload[1] = 0x55;
+
+        CAN_Tx_MSG(FD_CAN_Socket, CAN_CMD_PCBA_TEST, 0, 2, can_tx_payload);
+
+        sleep(1);
+
+        //Step 3: Rx CAN Message
+        memset(&frame, 0, sizeof(struct can_frame));
+        read(FD_CAN_Socket, &frame, sizeof(struct can_frame));
+
+        //PRINT_CAN_FRAME(&frame);
+
+        if( (frame.can_id == 0) ||          //all zero
+            (frame.can_id & 0x08000000) ||  //to avoid incoreect DIRECTION bit
+            ((frame.can_id & 0x0000FF00) != CAN_CMD_PCBA_TEST) ||  //the 1st command ID from Master should be 0x02
+            (frame.can_dlc != 2))           //payload length should be only 5 bytes.
+        {
+            if (err_cnt++ >= 10)
+            {
+                SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_canbus]Rx err_cnt >= 5");
+                result = FAIL;
+                break;
+            }
+            continue;
+        }
+
+        if ((frame.data[0] == 0x55) && (frame.data[1] == 0xAA))
+        {
+            sprintf(buf_log_pcbatstr,
+                    "[PCBATstr_canbus]rx: %02X %02X (PASS)",
+                    frame.data[0],
+                    frame.data[1]);
+            SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+            break;
+        }
+        else
+        {
+            sprintf(buf_log_pcbatstr,
+                    "[PCBATstr_canbus]rx: %02X %02X (FAIL)",
+                    frame.data[0],
+                    frame.data[1]);
+            SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+            result = FAIL;
+            break;
+        }
+    }
+    SAVE_SYS_LOG_MSG_PCBATESTER("-------- [canbus] end --------");
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: PCBATstr_ethernet
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int PCBATstr_ethernet()
+{
+    int result = PASS;
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("-------- [ethernet] --------");
+    system("/sbin/ifconfig eth0 192.168.1.10 netmask 255.255.255.0 up");
+    system("/sbin/route add default gw 192.168.1.1");
+    //system("ping -I eth0 -c 3 192.168.1.1");
+
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: PCBATstr_gpio_ntc
+DESCRIPTION:
+    1. AM_IO_1 <<==>> NTC1 & NTC2
+
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int PCBATstr_gpio_ntc()
+{
+    int result = PASS;
+    float ntc1 = 0;
+    float ntc2 = 0;
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("-------- [ntc] --------");
+
+    //Step 1: AM_IO_1
+    system("echo \"out\" > /sys/class/gpio/gpio87/direction");
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_gpio_ntc]AM_IO_1(ON): read NTC1, NTC2");
+    system("echo 1 > /sys/class/gpio/gpio87/value"); //[AM_IO_1](gpio2_25: output)
+    usleep(100000);
+    ntc1 = ReadAdcVolt(ADC_CHANNEL_AIN0_NTC1);
+    ntc2 = ReadAdcVolt(ADC_CHANNEL_AIN1_NTC2);
+    if (ntc1 > 3.0)
+    {
+        sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]ntc1 = %.02fV (PASS, > 3.0)", ntc1);
+        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+        if (ntc2 > 3.0)
+        {
+            sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]ntc2 = %.02fV (PASS, > 3.0)", ntc2);
+            SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+        }
+        else
+        {
+            sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]ntc2 = %.02fV (FAIL, > 3.0)", ntc2);
+            SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+            result = FAIL;
+        }
+    }
+    else
+    {
+        sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]ntc1 = %.02fV (FAIL, > 3.0)", ntc1);
+        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+        result = FAIL;
+    }
+
+    //=========================================================================
+    SAVE_SYS_LOG_MSG_PCBATESTER("\n");
+    SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_gpio_ntc]AM_IO_1(OFF): read NTC1, NTC2");
+    system("echo 0 > /sys/class/gpio/gpio87/value"); //[AM_IO_1](gpio2_25: output)
+    usleep(100000);
+    ntc1 = ReadAdcVolt(ADC_CHANNEL_AIN0_NTC1);
+    ntc2 = ReadAdcVolt(ADC_CHANNEL_AIN1_NTC2);
+    if (ntc1 < 0.5)
+    {
+        sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]ntc1 = %.02fV (PASS, < 0.5)", ntc1);
+        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+        if (ntc2 < 0.5)
+        {
+            sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]ntc2 = %.02fV (PASS, < 0.5)", ntc2);
+            SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+        }
+        else
+        {
+            sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]ntc2 = %.02fV (FAIL, < 0.5)", ntc2);
+            SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+            result = FAIL;
+        }
+    }
+    else
+    {
+        sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]ntc1 = %.02fV (FAIL, < 0.5)", ntc1);
+        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+        result = FAIL;
+    }
+
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: PCBATstr_gpio_pp
+DESCRIPTION:
+    1. AM_IO_2 <<==>> PP
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int PCBATstr_gpio_pp()
+{
+    int result = PASS;
+    float pp = 0;
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("-------- [pp] --------");
+
+    system("echo \"out\" > /sys/class/gpio/gpio89/direction");
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_gpio_ntc]PP(ON): read PP");
+    system("echo 1 > /sys/class/gpio/gpio89/value"); //[AM_IO_2](gpio2_25: output)
+    usleep(100000);
+    pp = ReadAdcVolt(ADC_CHANNEL_AIN2_PP);
+    if (pp > 2.0)
+    {
+        sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]PP = %.02fV (PASS, > 2.0)", pp);
+        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+    }
+    else
+    {
+        sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]PP = %.02fV (FAIL, > 2.0)", pp);
+        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+        result = FAIL;
+    }
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_gpio_ntc]PP(OFF): read PP...");
+    system("echo 0 > /sys/class/gpio/gpio89/value"); //[AM_IO_2](gpio2_25: output)
+    usleep(100000);
+    pp = ReadAdcVolt(ADC_CHANNEL_AIN2_PP);
+    if (pp < 0.5)
+    {
+        sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]PP = %.02fV (PASS, < 0.5)", pp);
+        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+    }
+    else
+    {
+        sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]PP = %.02fV (FAIL, < 0.5)", pp);
+        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+        result = FAIL;
+    }
+
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: PCBATstr_cp
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int PCBATstr_cp()
+{
+    int result = PASS;
+    float cp = 0;
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("-------- [cp] --------");
+
+    system("echo \"out\" > /sys/class/gpio/gpio89/direction");
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_gpio_ntc]CP(PWM:100%,SetStateE:OFF): read CP");
+    system("echo 1000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle");
+    system("echo 0 > /sys/class/gpio/gpio86/value"); //state E
+    usleep(100000);
+
+    cp = ReadAdcVolt(ADC_CHANNEL_AIN3_CP);
+    if (cp > 11.0)
+    {
+        sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]CP = %.02fV (PASS, > 11.0)", cp);
+        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+    }
+    else
+    {
+        sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]CP = %.02fV (FAIL, > 11.0)", cp);
+        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+        result = FAIL;
+    }
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("\n");
+    SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_gpio_ntc]CP(PWM:100%,SetStateE:ON): read CP");
+    system("echo 1000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle");
+    system("echo 1 > /sys/class/gpio/gpio86/value"); //state E
+    usleep(100000);
+    cp = ReadAdcVolt(ADC_CHANNEL_AIN3_CP);
+    if (cp < 1.0)
+    {
+        sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]CP = %.02fV (PASS, < 1.0V)", cp);
+        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+    }
+    else
+    {
+        sprintf(buf_log_pcbatstr, "[PCBATstr_gpio_ntc]CP = %.02fV (FAIL, < 1.0V)", cp);
+        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+        result = FAIL;
+    }
+
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: PCBATstr_reboot
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int PCBATstr_reboot()
+{
+    SAVE_SYS_LOG_MSG_PCBATESTER("-------- [reboot] --------");
+    system("reboot -f");
+    sleep(2);
+    system("reboot -f");
+    return PASS;
+}
+
+/*===========================================================================
+FUNCTION: PCBATstr_killtasks
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int PCBATstr_killtasks()
+{
+    SAVE_SYS_LOG_MSG_PCBATESTER("-------- [killtasks] --------");
+
+    system("../root/stop.sh");
+}
+
+
+/*===========================================================================
+FUNCTION: PCBATstr_qca7k
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int PCBATstr_qca7k()
+{
+    SAVE_SYS_LOG_MSG_PCBATESTER("-------- [qca7000] --------");
+
+    int state = IDLE;
+    int result = PASS;
+    int packet_size = 0;
+    double t_diff = 0;
+
+    //Step1: Init
+    if(RawSock > 0)
+    {
+        close(RawSock);
+    }
+    RawSock = -1;
+
+    //Init V2G TCP/IPv6 packets buffer
+    V2gtpMsgRxBuf = (unsigned char *)malloc(V2GTP_MSG_RX_BUFFER_SIZE);
+    memset(V2gtpMsgRxBuf, 0, V2GTP_MSG_RX_BUFFER_SIZE);
+
+    V2gtpMsgTxBuf = (unsigned char *)malloc(V2GTP_MSG_TX_BUFFER_SIZE);
+    memset(V2gtpMsgTxBuf, 0, V2GTP_MSG_TX_BUFFER_SIZE);
+
+    while (1)
+    {
+        if(RawSock >= 0)
+        {
+            memset(V2gtpMsgRxBuf, 0, V2GTP_MSG_RX_BUFFER_SIZE);
+            packet_size = recvfrom(RawSock, V2gtpMsgRxBuf, V2GTP_MSG_RX_BUFFER_SIZE, 0, NULL, NULL);
+            if(packet_size > 0)
+            {
+                struct MmeHeader *MmePacket;
+                MmePacket = (struct MmeHeader *)V2gtpMsgRxBuf;
+                switch(MmePacket->MMTYPE)
+                {
+                    case MMTYPE_VENDOR_VS_NW_INFO_CNF:
+                    {
+                        memcpy(QcaMac, MmePacket->OSA, 6);
+
+                        sprintf(buf_log_pcbatstr,
+                                "[QCA7K][Rx][VENDOR_VS_NW_INFO_CNF]Got QCA7K MacAddr:%02X:%02X:%02X:%02X:%02X:%02X (comm:OK)",
+                                 QcaMac[0],  QcaMac[1],  QcaMac[2],  QcaMac[3],  QcaMac[4],  QcaMac[5]);
+                        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+                        return PASS;
+                    }
+
+                    default:
+                    {
+                        break;
+                    }
+
+                }
+            }
+        }
+
+        switch(state)
+        {
+            case IDLE:
+            {
+                if(RawSock < 0)
+                {
+                    RawSock = socket(PF_PACKET, SOCK_RAW, htons(EtherType_HomePlug));
+
+                    sprintf(buf_log_pcbatstr, "[RawSock]opened(%d)", RawSock);
+                    SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+
+                    if(RawSock == -1)
+                    {
+                        SAVE_SYS_LOG_MSG_PCBATESTER("SlacComm:Failed to create socket");
+                        return FAIL;
+                    }
+
+                    if (setsockopt(RawSock, SOL_SOCKET, SO_BINDTODEVICE, QcaInterface, 4) < 0)
+                    {
+                        SAVE_SYS_LOG_MSG_PCBATESTER("SlacComm:Set SO_BINDTODEVICE NG");
+                        return FAIL;
+                    }
+
+                    struct timeval tv;
+                    tv.tv_sec = 0;
+                    tv.tv_usec = 100000;  //100ms (Rx timeout)
+                    if (setsockopt(RawSock, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct	timeval)) < 0)
+                    {
+                        SAVE_SYS_LOG_MSG_PCBATESTER("SlacComm:Set SO_RCVTIMEO NG");
+                        return FAIL;
+                    }
+
+                    tv.tv_usec = 100000;  //100ms (Tx timeout)
+                    if (setsockopt(RawSock, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(struct	timeval)) < 0)
+                    {
+                        SAVE_SYS_LOG_MSG_PCBATESTER("SlacComm:Set SO_SNDTIMEO NG");
+                        return FAIL;
+                    }
+
+                    memset(&Req, 0, sizeof(struct ifreq));
+                    strcpy( (char*)Req.ifr_name, QcaInterface);
+
+                    if (ioctl(RawSock, SIOCGIFINDEX, &Req) < 0)
+                    {
+                        SAVE_SYS_LOG_MSG_PCBATESTER("SlacComm: ioctl NG");
+                        return FAIL;
+                    }
+
+                    memset(&DestSocketAddress, 0, sizeof(struct sockaddr_ll));
+                    DestSocketAddress.sll_ifindex = Req.ifr_ifindex;
+                    DestSocketAddress.sll_halen = ETH_ALEN;
+
+                    SAVE_SYS_LOG_MSG_PCBATESTER("[QCA7K]connecting...");
+                    //Get QCA7K MAC address
+                    GetQca7kMac();
+                    ftime(&SeqStartTime);
+                    break;
+                }
+                else   //RawSock: opened
+                {
+                    ftime(&SeqEndTime);
+                    t_diff = DiffTimeb(SeqStartTime, SeqEndTime);
+                    if (t_diff > V2G_SECC_QCA7000_COMM_TIMEOUT)  //10 secs
+                    {
+                        sprintf(buf_log_pcbatstr,
+                                "[QCA7K][Error]comm: fail (%.02lf/%dms)",
+                                t_diff,
+                                V2G_SECC_QCA7000_COMM_TIMEOUT);
+                        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+                        return FAIL;
+                    }
+                    else if (t_diff > V2G_SECC_QCA7000_GET_MAC_ADDR_REQ_RETRY_PERIOD)   //3 secs
+                    {
+                        sprintf(buf_log_pcbatstr,
+                                "[QCA7K]re-try connecting...(%.02lf/%dms)",
+                                t_diff,
+                                V2G_SECC_QCA7000_GET_MAC_ADDR_REQ_RETRY_PERIOD);
+                        SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+
+                        GetQca7kMac(); //re-send req
+                        break;
+                    }
+                    else
+                    {
+                        //null
+                    }
+                }
+                break;
+            }
+
+            default:
+            {
+                break;
+            }
+        }
+    }
+}
+
+/*===========================================================================
+FUNCTION: PCBATstr_sdcard
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int PCBATstr_sdcard()
+{
+    int result = FAIL;
+    SAVE_SYS_LOG_MSG_PCBATESTER("-------- [sdcard] --------");
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_sdcard]mount SDCard on mnt");
+    system("mount /dev/mmcblk0p1 /mnt");
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_sdcard]delete file.txt");
+    system("rm -rfv /mnt/file.txt");
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_sdcard]creat file.txt in SDCard");
+    system("touch /mnt/file.txt");
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_sdcard]unmount SDCard from mnt");
+    system("umount /mnt");
+    sleep(1);
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_sdcard]mount SDCard on UsbFlash");
+    system("mount /dev/mmcblk0p1 /UsbFlash");
+    FILE *fp;
+    fp = fopen("/UsbFlash/file.txt", "r");
+    if (fp == NULL)
+    {
+        SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_sdcard]file.txt is not found");
+    }
+    else
+    {
+        SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_sdcard]file.txt is found");
+        SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_sdcard]delete file.txt");
+        system("rm -rfv /mnt/file.txt");
+        result = PASS;
+    }
+    fclose(fp);
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("[PCBATstr_sdcard]unmount SDCard from UsbFlash");
+    system("umount /UsbFlash");
+    return result;
+}
+
+
+/*===========================================================================
+FUNCTION: PCBATstr_all
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int PCBATstr_all()
+{
+    int result = PASS;
+
+    SAVE_SYS_LOG_MSG_PCBATESTER("-------- [all] --------");
+
+    //case 'k':   //Kill other tasks
+    if (PCBATstr_killtasks() == PASS)
+    {
+        printf("[kill]PASS\n");
+    }
+    else
+    {
+        printf("[kill]FAIL\n");
+        result = FAIL;
+    }
+
+    //case 'b':   //CAN Bus Test
+    if (PCBATstr_canbus() == PASS)
+    {
+        printf("[can]PASS\n");
+    }
+    else
+    {
+        printf("[can]FAIL\n");
+        result = FAIL;
+    }
+
+
+    //case 'e':   //Ethernet(eth1) Test
+    if (PCBATstr_ethernet() == PASS)
+    {
+        printf("[eth]READY\n");
+    }
+    else
+    {
+        printf("[eth]FAIL\n");
+        result = FAIL;
+    }
+
+
+    //case 'n':   //GPIO(AM_IO_1) and ADC(NTC1,NTC2) Test
+    if (PCBATstr_gpio_ntc() == PASS)
+    {
+        printf("[ntc]PASS\n");
+    }
+    else
+    {
+        printf("[ntc]FAIL\n");
+        result = FAIL;
+    }
+
+
+    //case 'p':   //GPIO(AM_IO_2) and ADC(PP) Test
+    if (PCBATstr_gpio_pp() == PASS)
+    {
+        printf("[pp]PASS\n");
+    }
+    else
+    {
+        printf("[pp]FAIL\n");
+        result = FAIL;
+    }
+
+    //case 'c':   //CP Test
+    if (PCBATstr_cp() == PASS)
+    {
+        printf("[cp]PASS\n");
+    }
+    else
+    {
+        printf("[cp]FAIL\n");
+        result = FAIL;
+    }
+
+
+    //case 'q':   //QCA7000 Test
+    if (PCBATstr_qca7k() == PASS)
+    {
+        printf("[qca]PASS\n");
+    }
+    else
+    {
+        printf("[qca]FAIL\n");
+        result = FAIL;
+    }
+
+    //case 's':   //SD Card Test
+    if (PCBATstr_sdcard() == PASS)
+    {
+        printf("[sd]PASS\n");
+    }
+    else
+    {
+        printf("[sd]FAIL\n");
+        result = FAIL;
+    }
+
+    return result;
+}
+
+
+/*===========================================================================
+FUNCTION: main
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int main(int argc, char *argv[])
+{
+    SAVE_SYS_LOG_MSG_PCBATESTER("PCBATester: on");
+    SAVE_SYS_LOG_MSG_PCBATESTER("---------------------------------------------");
+    SAVE_SYS_LOG_MSG_PCBATESTER("--                PCBATester               --");
+    SAVE_SYS_LOG_MSG_PCBATESTER("---------------------------------------------\n");
+
+    //Initialization
+    //System_Init();
+
+    //Arguments Parsing for Commands
+    if (argv[1][0] == '-' )
+    {
+        switch (argv[1][1])
+        {
+            case 'h':   //help
+            {
+                printf(" ================= [HELP] PCBATester ==============\n");
+                printf(" -h \t :help\n");
+                printf(" -a \t :Auto Run All Test Cases\n");
+                printf(" -b \t :CAN Bus Test\n");
+                printf(" -c \t :CP Test\n");
+                printf(" -e \t :Ethernet(eth1) Test\n");
+                printf(" -k \t :Killall other tasks\n");
+                printf(" -p \t :GPIO(AM_IO_2) and ADC(PP) Test\n");
+                printf(" -n \t :GPIO(AM_IO_1) and ADC(NTC1,NTC2) Test\n");
+                printf(" -q \t :QCA7000 Test\n");
+                printf(" -r \t :Reboot\n");
+                printf(" -s \t :SD Card Test\n");
+                break;
+            }
+            case 'a':   //Auto Run All Test Cases
+            {
+                if (PCBATstr_all() == PASS)
+                {
+                    printf("[all]PASS\n");
+                }
+                else
+                {
+                    printf("[all]FAIL\n");
+                }
+                break;
+            }
+            case 'b':   //CAN Bus Test
+            {
+                if (PCBATstr_canbus() == PASS)
+                {
+                    printf("[can]PASS\n");
+                }
+                else
+                {
+                    printf("[can]FAIL\n");
+                }
+                break;
+            }
+            case 'e':   //Ethernet(eth1) Test
+            {
+                if (PCBATstr_ethernet() == PASS)
+                {
+                    printf("[eth]READY\n");
+                }
+                else
+                {
+                    printf("[eth]FAIL\n");
+                }
+                break;
+            }
+            case 'n':   //GPIO(AM_IO_1) and ADC(NTC1,NTC2) Test
+            {
+                if (PCBATstr_gpio_ntc() == PASS)
+                {
+                    printf("[ntc]PASS\n");
+                }
+                else
+                {
+                    printf("[ntc]FAIL\n");
+                }
+                break;
+            }
+            case 'p':   //GPIO(AM_IO_2) and ADC(PP) Test
+            {
+                if (PCBATstr_gpio_pp() == PASS)
+                {
+                    printf("[pp]PASS\n");
+                }
+                else
+                {
+                    printf("[pp]FAIL\n");
+                }
+                break;
+            }
+            case 'k':   //Kill other tasks
+            {
+                if (PCBATstr_killtasks() == PASS)
+                {
+                    printf("[kill]PASS\n");
+                }
+                else
+                {
+                    printf("[kill]FAIL\n");
+                }
+                break;
+            }
+            case 'c':   //CP Test
+            {
+                if (PCBATstr_cp() == PASS)
+                {
+                    printf("[cp]PASS\n");
+                }
+                else
+                {
+                    printf("[cp]FAIL\n");
+                }
+                break;
+            }
+            case 'q':   //QCA7000 Test
+            {
+                if (PCBATstr_qca7k() == PASS)
+                {
+                    printf("[qca]PASS\n");
+                }
+                else
+                {
+                    printf("[qca]FAIL\n");
+                }
+                break;
+            }
+            case 'r':   //Reboot
+            {
+                if (PCBATstr_reboot() == PASS)
+                {
+                    printf("[reboot]PASS\n");
+                }
+                else
+                {
+                    printf("[reboot]FAIL\n");
+                }
+                break;
+            }
+            case 's':   //SD Card Test
+            {
+                if (PCBATstr_sdcard() == PASS)
+                {
+                    printf("[sd]PASS\n");
+                }
+                else
+                {
+                    printf("[sd]FAIL\n");
+                }
+                break;
+            }
+            default:
+            {
+                sprintf(buf_log_pcbatstr, "Unknown option -%c\n\n", argv[1][1]);
+                SAVE_SYS_LOG_MSG_PCBATESTER(buf_log_pcbatstr);
+                printf("[others]UNSUPPORTED\n");
+                break;
+            }
+        }
+    }
+}

EVSE/Projects/AW-CCS/Apps/CCS/PCBATester.h

@@ -0,0 +1,66 @@
+/*===========================================================================
+                     Combined Charging System (CCS): SECC
+                                 PCBATester.h
+
+                              initiated by Joseph
+                               (since 2020/05/19)
+=============================================================================*/
+#if FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == ENABLE
+    //Saving System Log
+    #define SAVE_SYS_LOG_MSG_PCBATESTER_SWITCH        ENABLE  //ENABLE, DISABLE
+
+    //Configuration for Debug Print Messages
+    #define DEBUG_PRINTF_PCBATESTER_SHOW              DISABLE  //ENABLE, DISABLE
+    #define DEBUG_PRINTF_PCBATESTER_BRIEF_SHOW        DISABLE  //ENABLE, DISABLE
+    #define DEBUG_PRINTF_PCBATESTER_DETAIL_SHOW       DISABLE  //ENABLE, DISABLE
+    #define DEBUG_PRINTF_PCBATESTER_SYSTEM_LOG_SHOW   DISABLE  //ENABLE, DISABLE
+#else   //debug mode
+    //Saving System Log
+    #define SAVE_SYS_LOG_MSG_PCBATESTER_SWITCH        ENABLE  //ENABLE, DISABLE
+
+    //Configuration for Debug Print Messages
+    #define DEBUG_PRINTF_PCBATESTER_SHOW              ENABLE  //ENABLE, DISABLE
+    #define DEBUG_PRINTF_PCBATESTER_BRIEF_SHOW        ENABLE  //ENABLE, DISABLE
+    #define DEBUG_PRINTF_PCBATESTER_DETAIL_SHOW       ENABLE  //ENABLE, DISABLE
+    #define DEBUG_PRINTF_PCBATESTER_SYSTEM_LOG_SHOW   ENABLE  //ENABLE, DISABLE
+#endif
+
+//System Log
+#if SAVE_SYS_LOG_MSG_PCBATESTER_SWITCH == ENABLE
+    #define SAVE_SYS_LOG_MSG_PCBATESTER           StoreLogMsg
+#else
+    #define SAVE_SYS_LOG_MSG_PCBATESTER(...)
+#endif
+
+
+//Debug Message
+#if DEBUG_PRINTF_PCBATESTER_SHOW == ENABLE
+
+    //Brief Messages
+    #if DEBUG_PRINTF_PCBATESTER_BRIEF_SHOW == ENABLE
+        #define DEBUG_PRINTF_PCBATESTER_BRIEF      printf
+    #else
+        #define DEBUG_PRINTF_PCBATESTER_BRIEF(...)
+    #endif
+
+    //Detail Messages
+    #if DEBUG_PRINTF_PCBATESTER_DETAIL_SHOW == ENABLE
+        #define DEBUG_PRINTF_PCBATESTER_DETAIL     printf
+    #else
+        #define DEBUG_PRINTF_PCBATESTER_DETAIL(...)
+    #endif
+
+    //System Log Messages
+    #if DEBUG_PRINTF_PCBATESTER_SYSTEM_LOG_SHOW == ENABLE
+        #define DEBUG_PRINTF_PCBATESTER_SYSTEM_LOG    printf
+    #else
+        #define DEBUG_PRINTF_PCBATESTER_SYSTEM_LOG(...)
+    #endif
+
+#else
+
+    #define DEBUG_PRINTF_PCBATESTER_BRIEF(...)
+    #define DEBUG_PRINTF_PCBATESTER_DETAIL(...)
+    #define DEBUG_PRINTF_PCBATESTER_SYSTEM_LOG(...)
+
+#endif

EVSE/Projects/AW-CCS/Apps/CCS/SeccComm.c

@@ -0,0 +1,17976 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                 EVComm.c
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+   =============================================================================*/
+#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 <errno.h>
+#include <linux/can.h>
+#include <linux/can/raw.h>
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+
+#include "define.h"
+#include "SeccComm.h"
+#include "NidNmk.h"
+#include "SeccComm.h"
+#include "CsuComm.h"
+
+#include "./exi_engine/api/api.h"
+#include "./exi_engine/appHandshake/appHandEXIDatatypes.h"
+#include "./exi_engine/transport/v2gtp.h"
+
+
+int MeterSMId[8];
+struct SysConfigAndInfo *ShmSysConfigAndInfo;
+struct StatusCodeData *ShmStatusCodeData;
+struct CcsData *ShmCcsData;
+struct InternalComm *ShmInternalComm;
+//struct InternalCommAC *ShmInternalCommAC;
+
+struct appHandEXIDocument ccs_handshake;
+struct dinEXIDocument ccs_exi_doc_DIN;
+struct iso1EXIDocument ccs_exi_doc_ISO1;
+struct iso2EXIDocument ccs_exi_doc_ISO2;
+unsigned char V2GTP_Tx_buf[V2GTP_MSG_TX_BUFFER_SIZE];   //64*1024 ﺿ65,536 = 65.5KB
+unsigned char buf_log_evcomm[SIZE_OF_LOG_BUFFER];
+unsigned char buf_log_evcomm_fork1[SIZE_OF_LOG_BUFFER];
+unsigned char buf_log_evcomm_fork2[SIZE_OF_LOG_BUFFER];
+unsigned char buf_log_evcomm_fork3[SIZE_OF_LOG_BUFFER];
+
+pid_t CP_Detection_Pid = 0;
+pid_t PP_Detection_Pid = 0;
+pid_t Error_Monitor_Pid = 0;
+int TcpAcceptFd;
+#ifdef SUPPORT_TLS_CONNECTION
+SSL_CTX *ctx;
+SSL *ssl;
+unsigned char EvSecurity;
+#endif
+enum MsgFlowStatus V2gFlowStatus;
+int RawSock,UdpSock,TcpSock;
+unsigned char *V2gtpMsgRxBuf, *V2gtpMsgTxBuf;
+
+unsigned short Aag[64];
+struct MmeHeader SendMmePacket;
+int SendMmePacketSize;
+unsigned char CsuMac[6],QcaMac[6],EvMac[6],SlacRunId[8];
+struct sockaddr_ll DestSocketAddress;
+struct ifreq Req;
+unsigned int PwmStartTime;
+struct timeb SeqStartTime, SeqEndTime;
+unsigned char AagGroupsNum, MnbcSoundNum, AttenProfileCnt;
+unsigned char NewNmkKey[16], Nid[7];
+
+
+int writeStringToEXIString(unsigned char* string, exi_string_character_t* exiString)
+{
+	int pos = 0;
+	while(string[pos]!='\0')
+	{
+		exiString[pos] = string[pos];
+		pos++;
+	}
+
+	return pos;
+}
+/*===========================================================================
+FUNCTION: Check_V2G_Flow_Status
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned char Check_V2G_Flow_Status()
+{
+    unsigned char result = 0;
+
+    switch (ShmCcsData->CommProtocol)
+    {
+        case V2GT_MSG_PROTOCOL_DIN70121:        //0
+        {
+            result = ShmCcsData->V2GMessage_DIN70121.PresentMsgFlowStatus;
+            break;
+        }
+
+        case V2GT_MSG_PROTOCOL_ISO15118_2014:   //1
+        {
+            result = ShmCcsData->V2GMessage_ISO15118_2014.PresentMsgFlowStatus;
+            break;
+        }
+
+        case V2GT_MSG_PROTOCOL_ISO15118_2018:   //2
+        {
+            result = ShmCcsData->V2GMessage_ISO15118_2018.PresentMsgFlowStatus;
+            break;
+        }
+
+        default:
+            break;
+    }
+    return result;
+}
+
+
+/*===========================================================================
+FUNCTION: StoreLogMsg
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+#if SAVE_SYS_LOG_MSG_EVCOMM_SWITCH == ENABLE
+int StoreLogMsg2(unsigned char *DataString)
+{
+    static unsigned char Buf[1024];
+    static time_t CurrentTime;
+    static struct tm *tm;
+    static struct timeval tv;
+
+    memset(Buf, 0, sizeof(Buf));
+    CurrentTime = time(NULL);
+    tm = localtime(&CurrentTime);
+    gettimeofday(&tv, NULL); // get microseconds, 10^-6
+	#ifdef AWCCS
+    sprintf(Buf, "echo \"[%04d%02d%02d: %02d:%02d:%02d.%06d][SECC][%d][%02d]%s\" >> /Storage/SystemLog/[%04d.%02d]CCS-SystemLog",
+            tm->tm_year + 1900,
+            tm->tm_mon + 1,
+            tm->tm_mday,
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            EVCOMM_SYS_INFO.CpState,
+            Check_V2G_Flow_Status(),
+            DataString,
+            tm->tm_year + 1900,
+            tm->tm_mon + 1);
+	#else
+	sprintf(Buf, "echo \"[%04d%02d%02d: %02d:%02d:%02d.%06d][SECC][%d][%02d]%s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog",
+            tm->tm_year + 1900,
+            tm->tm_mon + 1,
+            tm->tm_mday,
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            EVCOMM_SYS_INFO.CpState,
+            Check_V2G_Flow_Status(),
+            DataString,
+            tm->tm_year + 1900,
+            tm->tm_mon + 1);
+	#endif            
+    system(Buf);
+
+    DEBUG_PRINTF_EVCOMM_SYSTEM_LOG("[%02d:%02d:%02d.%06d][SECC][%d][%02d]%s \n",
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            EVCOMM_SYS_INFO.CpState,
+            Check_V2G_Flow_Status(),
+            DataString);
+
+    //Reset the buf_log_evcomm Buffer, i.e. DataString
+    memset(buf_log_evcomm, 0, SIZE_OF_LOG_BUFFER);
+}
+#endif
+
+/*===========================================================================
+FUNCTION: CAN_Tx_MSG
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int CAN_Tx_MSG(int Fd, unsigned int MsgId, unsigned char SlaveAddress, unsigned char DataLength, unsigned char *SendData)
+{
+    struct can_frame frame;
+    struct timeb StartTime, EndTime;
+    unsigned int tmp = 0;
+    int nbytes = 0;
+    int i = 0;
+
+    //Protection: To avoid unexpected length for CAN bus payload.
+    if (DataLength > 8)
+    {
+        DataLength = 8;
+    }
+
+    memset(&frame, 0, sizeof(struct can_frame));
+    frame.can_id = 0x80000000 | CAN_SEND_DIRECTION | MsgId | SlaveAddress;  //0x80000000: extension ID format
+    frame.can_dlc = DataLength;
+    memcpy(frame.data, SendData, DataLength);
+    nbytes = write(Fd, &frame, sizeof(struct can_frame));
+
+    #if 0
+    DEBUG_PRINTF_EVCOMM_DETAIL("[SeccComm][CAN_Tx_MSG] <%X> ", frame.can_id);
+    for (i = 0; i < frame.can_dlc; i++)
+    {
+        DEBUG_PRINTF_EVCOMM_DETAIL("%02X ", frame.data[i]);
+    }
+    DEBUG_PRINTF_EVCOMM_DETAIL("(%d Bytes)\n", frame.can_dlc);
+    #endif
+
+    return nbytes;
+}
+
+/*===========================================================================
+FUNCTION: Proc_EVStopRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_EVStopRes(int Fd)
+{
+    int nbytes;
+    unsigned char Buffer[8];
+
+    memset(Buffer, 0, sizeof(Buffer));
+    if (CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency == TRUE)
+    {
+        Buffer[0] = EV_EMERGENCY_STOP;  //2
+    }
+    else
+    {
+        Buffer[0] = EV_NORMAL_STOP;     //1
+    }
+
+    /*
+    if(strlen(ShmStatusCodeData->PresentStatusCode[0]) > 0)
+    {
+        memcpy(Buffer + 2, ShmStatusCodeData->PresentStatusCode[0], 6);
+    }
+    */
+    Buffer[1] = ShmStatusCodeData->PresentStatusCode[0][0];
+    Buffer[2] = ShmStatusCodeData->PresentStatusCode[0][1];
+    Buffer[3] = ShmStatusCodeData->PresentStatusCode[0][2];
+    Buffer[4] = ShmStatusCodeData->PresentStatusCode[0][3];
+    Buffer[5] = ShmStatusCodeData->PresentStatusCode[0][4];
+    Buffer[6] = ShmStatusCodeData->PresentStatusCode[0][5];
+
+
+    nbytes = CAN_Tx_MSG(Fd, CAN_CMD_EV_STOP_EVENT, ShmInternalComm->SlaveAddress, 7, Buffer);
+    //system("echo 1000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle"); //for test only
+
+    //system("echo 0 > /sys/class/gpio/gpio89/value");    //for test
+
+    SAVE_SYS_LOG_MSG_EVCOMM("[Proc_EVStopRes] Sending STOP Command to CSU");
+
+    CSUCOMMDC_TASK_FLAG.Send_EVStopReq = FALSE;
+
+    return nbytes;
+}
+
+/*===========================================================================
+FUNCTION: Sniffer_Candump
+DESCRIPTION:
+    1. Only used in End_Process(), which is in fork2 of SeccComm task.
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+    0: accept
+   -1: invalid
+GLOBAL VARIABLES:
+=============================================================================*/
+int Sniffer_Candump(char cmd)
+{
+    #if (CANDUMP_PACKETS_SNIFFER_SWITCH == ENABLE)
+    if (cmd == ENABLE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[candump]init");
+        system("cd /mnt/;rm -rf candump/");
+        system("cd /mnt/;mkdir candump");
+        SAVE_SYS_LOG_MSG_EVCOMM("[candump]on");
+        system("cd /mnt/candump;candump -l can0 &");
+        return 0;
+    }
+    else if (cmd == DISABLE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[candump]off");
+        system("killall candump");
+
+        SAVE_SYS_LOG_MSG_EVCOMM("[candump]save");
+        system("cd /;cp -rfv /mnt/candump /Storage/SystemLog/");
+        return 0;
+    }
+    else
+    {
+        sprintf(buf_log_evcomm_fork2, "[candump]unexpected cmd(%d)", cmd);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork2);
+        return -1;
+    }
+    #endif
+}
+
+/*===========================================================================
+FUNCTION: Sniffer_Tcpdump
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Sniffer_Tcpdump(char cmd)
+{
+    #if (TCPDUMP_PACKETS_SNIFFER_SWITCH == ENABLE)
+    if (cmd == ENABLE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[tcpdump]init...");
+        system("cd /mnt/;rm -rf tcpdump/");
+        system("cd /mnt/;mkdir tcpdump");
+
+        unsigned char buf[256];
+        time_t CurrentTime;
+        struct tm *tm;
+        struct timeval tv;
+
+        memset(buf, 0, sizeof(buf));
+        CurrentTime = time(NULL);
+        tm = localtime(&CurrentTime);
+        gettimeofday(&tv, NULL); // get microseconds, 10^-6
+        sprintf(buf,
+                "tcpdump -i eth1 -w /mnt/tcpdump/[%s][%04d%02d%02d-%02d:%02d:%02d.%06d]packets.pcap&",
+                FIRMWARE_VERSION,
+                tm->tm_year + 1900,
+                tm->tm_mon + 1,
+                tm->tm_mday,
+                tm->tm_hour,
+                tm->tm_min,
+                tm->tm_sec,
+                tv.tv_usec
+                );
+        SAVE_SYS_LOG_MSG_EVCOMM("[tcpdump]on");
+        system(buf);
+        return 0;
+    }
+    else if (cmd == DISABLE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[tcpdump]off");
+        system("killall tcpdump");
+        SAVE_SYS_LOG_MSG_EVCOMM("[tcpdump]wait: 2s");
+        sleep(1);
+        SAVE_SYS_LOG_MSG_EVCOMM("[tcpdump]wait: 1s");
+        sleep(1);
+        SAVE_SYS_LOG_MSG_EVCOMM("[tcpdump]save");
+        system("cd /;cp -rfv /mnt/tcpdump /Storage/SystemLog/");
+        return 0;
+    }
+    else
+    {
+        sprintf(buf_log_evcomm, "[tcpdump]unexpected cmd(%d)", cmd);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        return -1;
+    }
+    #endif
+}
+
+/*===========================================================================
+FUNCTION: Check_V2G_Flow_Status_pre
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+unsigned char Check_V2G_Flow_Status_pre()
+{
+    unsigned char result = 0;
+
+    switch (ShmCcsData->CommProtocol)
+    {
+        case V2GT_MSG_PROTOCOL_DIN70121:        //0
+        {
+            result = ShmCcsData->V2GMessage_DIN70121.PresentMsgFlowStatus_pre;
+            break;
+        }
+
+        case V2GT_MSG_PROTOCOL_ISO15118_2014:   //1
+        {
+            result = ShmCcsData->V2GMessage_ISO15118_2014.PresentMsgFlowStatus_pre;
+            break;
+        }
+
+        case V2GT_MSG_PROTOCOL_ISO15118_2018:   //2
+        {
+            result = ShmCcsData->V2GMessage_ISO15118_2018.PresentMsgFlowStatus_pre;
+            break;
+        }
+
+        default:
+            break;
+    }
+    return result;
+}
+
+
+/*===========================================================================
+FUNCTION: Update_V2G_Flow_Status
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+        1. V2gFlowStatus
+
+GLOBAL VARIABLES:
+        1. V2gFlowStatus
+=============================================================================*/
+int Update_V2G_Flow_Status(unsigned int state_new)
+{
+    unsigned char state_now;
+    state_now = Check_V2G_Flow_Status();
+
+    if (/*EVCOMM_SYS_INFO.End_Process_inused == TRUE ||*/
+        CSUCOMMDC_TASK_FLAG.FW_Update_Task_inused == TRUE)
+    {
+        if (state_now != Performance_Timeout &&     //253
+            state_now != Sequence_Timeout &&        //254
+            state_now != Other_Fault)               //255
+        {
+            sprintf(buf_log_evcomm,
+                    "[Warning]state(%d) change: ignored (End_Process_inused:%d, FW_Update_Task_inused:%d)",
+                    state_new,
+                    EVCOMM_SYS_INFO.End_Process_inused,
+                    CSUCOMMDC_TASK_FLAG.FW_Update_Task_inused
+                    );
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            return -1;
+        }
+    }
+    if (state_now != state_new)
+    {
+        //Step 1: Check if Error Occours
+        if (state_now == Performance_Timeout ||     //253
+            state_now == Sequence_Timeout ||        //254
+            state_now == Other_Fault)               //255
+        {
+            if (state_new != IDLE)
+            {
+                if (EVCOMM_SYS_INFO.State_Change_Ignored_Notice == FALSE)
+                {
+                    EVCOMM_SYS_INFO.State_Change_Ignored_Notice = TRUE;
+                    sprintf(buf_log_evcomm,
+                            "[Warning]state(%d) change: ignored(now in error state)",
+                            state_new,
+                            state_now);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                }
+                return -1;
+            }
+        }
+
+        //Updating the state formally.
+        sprintf(buf_log_evcomm,
+                "[stt]%02d >> %02d",
+                state_now,
+                state_new
+                );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+        V2gFlowStatus = state_new;
+        state_now = state_new;
+
+        switch (ShmCcsData->CommProtocol)
+        {
+            case V2GT_MSG_PROTOCOL_DIN70121:        //0
+            {
+                ShmCcsData->V2GMessage_DIN70121.PresentMsgFlowStatus_pre = ShmCcsData->V2GMessage_DIN70121.PresentMsgFlowStatus;
+                ShmCcsData->V2GMessage_DIN70121.PresentMsgFlowStatus = V2gFlowStatus;
+                //break;
+            }
+
+            case V2GT_MSG_PROTOCOL_ISO15118_2014:   //1
+            {
+                ShmCcsData->V2GMessage_ISO15118_2014.PresentMsgFlowStatus_pre = ShmCcsData->V2GMessage_ISO15118_2014.PresentMsgFlowStatus;
+                ShmCcsData->V2GMessage_ISO15118_2014.PresentMsgFlowStatus = V2gFlowStatus;
+                //break;
+            }
+
+            case V2GT_MSG_PROTOCOL_ISO15118_2018:   //2
+            {
+                ShmCcsData->V2GMessage_ISO15118_2018.PresentMsgFlowStatus_pre = ShmCcsData->V2GMessage_ISO15118_2018.PresentMsgFlowStatus;
+                ShmCcsData->V2GMessage_ISO15118_2018.PresentMsgFlowStatus = V2gFlowStatus;
+                //break;
+            }
+
+            default:
+                break;
+        }
+    }
+}
+
+double DiffTimeb(struct timeb ST, struct timeb ET)
+{
+    //return milli-second
+    double StartTime, EndTime;
+    double t_diff;
+
+    StartTime = ((double)ST.time)*1000 + (double)ST.millitm;
+    EndTime = ((double)ET.time)*1000 + (double)ET.millitm;
+    t_diff = EndTime - StartTime;
+
+    if (t_diff < 0)
+    {
+        #if 0
+        if (t_diff < -1000)   //1000ms
+        {
+            sprintf(buf_log_evcomm,
+                    "[Warning]StartTime(%.02lf) > EndTime(%.02lf), d(%.02lf)",
+                    StartTime,
+                    EndTime,
+                    t_diff);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        }
+        #endif
+
+        return -1;
+    }
+    return t_diff;
+}
+
+double DiffTimeb_fork1_Error_Monitor(struct timeb ST, struct timeb ET)
+{
+    //return milli-second
+    static double StartTime, EndTime;
+    static double t_diff;
+
+    StartTime = ((double)ST.time)*1000 + (double)ST.millitm;
+    EndTime = ((double)ET.time)*1000 + (double)ET.millitm;
+    t_diff = EndTime - StartTime;
+
+    if (t_diff < 0)
+    {
+        #if 0
+        if (t_diff < -1000)   //1000ms
+        {
+            sprintf(buf_log_evcomm_fork2,
+                    "[fork1][Warning]S(%.02lf) > E(%.02lf), d(%.02lf)",
+                    StartTime,
+                    EndTime,
+                    t_diff);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork2);
+        }
+        #endif
+
+        return -1;
+    }
+    return t_diff;
+}
+
+double DiffTimeb_fork2_Error_Monitor(struct timeb ST, struct timeb ET)
+{
+    //return milli-second
+    static double StartTime, EndTime;
+    static double t_diff;
+
+    StartTime = ((double)ST.time)*1000 + (double)ST.millitm;
+    EndTime = ((double)ET.time)*1000 + (double)ET.millitm;
+    t_diff = EndTime - StartTime;
+
+    if (t_diff < 0)
+    {
+        #if 0
+        if (t_diff < -1000)   //1000ms
+        {
+            sprintf(buf_log_evcomm_fork2,
+                    "[fork2][Warning]S(%.02lf) > E(%.02lf), d(%.02lf)",
+                    StartTime,
+                    EndTime,
+                    t_diff);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork2);
+        }
+        #endif
+
+        return -1;
+    }
+    return t_diff;
+}
+
+int CreateShareMemory()
+{
+    int MeterSMId;
+
+    //create ShmSysConfigAndInfo
+    if ((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo), IPC_CREAT | 0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[main]CreateShareMemory:shmget ShmSysConfigAndInfo NG");
+        return 0;
+    }
+    else if ((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *) -1)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[main]CreateShareMemory:shmat ShmSysConfigAndInfo NG");
+        return 0;
+    }
+    memset(ShmSysConfigAndInfo,0,sizeof(struct SysConfigAndInfo));
+    //create ShmStatusCodeData
+    if ((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData), IPC_CREAT | 0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[main]CreateShareMemory:shmget ShmStatusCodeData NG");
+        return 0;
+    }
+    else if ((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[main]CreateShareMemory:shmat ShmStatusCodeData NG");
+        return 0;
+    }
+    memset(ShmStatusCodeData,0,sizeof(struct StatusCodeData));
+    //create ShmCcsData
+    if ((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData), IPC_CREAT | 0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[main]CreateShareMemory:shmget ShmCcsData NG");
+        return 0;
+    }
+    else if ((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *) -1)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[main]CreateShareMemory:shmat ShmCcsData NG");
+        return 0;
+    }
+    memset(ShmCcsData,0,sizeof(struct CcsData));
+    return 1;
+}
+
+void DetachShareMemory()
+{
+	if(MeterSMId[0]>0)
+	{
+    		shmdt(ShmSysConfigAndInfo);
+		shmctl(MeterSMId[0], IPC_RMID, 0);
+    	}
+    	if(MeterSMId[1]>0)
+	{
+    		shmdt(ShmStatusCodeData);
+		shmctl(MeterSMId[1], IPC_RMID, 0);
+    	}
+    	if(MeterSMId[2]>0)
+	{
+    		shmdt(ShmCcsData);
+		shmctl(MeterSMId[2], IPC_RMID, 0);
+    	}
+    	if(MeterSMId[3]>0)
+	{
+    		shmdt(ShmInternalComm);
+		shmctl(MeterSMId[3], IPC_RMID, 0);
+    	}
+    	/*if(MeterSMId[4]>0)
+	{
+    		shmdt(ShmInternalCommAC);
+		shmctl(MeterSMId[4], IPC_RMID, 0);
+    	}*/
+}
+
+/*===========================================================================
+FUNCTION: ShareMemory_Init
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int ShareMemory_Init()
+{
+	memset(MeterSMId,0,sizeof(MeterSMId));
+    //create ShmSysConfigAndInfo
+    if ((MeterSMId[0] = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo),  0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("ShareMemory_Init:shmget ShmSysConfigAndInfo NG");
+        return 0;
+    }
+    else if ((ShmSysConfigAndInfo = shmat(MeterSMId[0], NULL, 0)) == (void *) -1)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("ShareMemory_Init:shmat ShmSysConfigAndInfo NG");
+        return 0;
+    }
+
+    //create ShmStatusCodeData
+    if ((MeterSMId[1] = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData),  0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("ShareMemory_Init:shmget ShmStatusCodeData NG");
+        return 0;
+    }
+    else if ((ShmStatusCodeData = shmat(MeterSMId[1], NULL, 0)) == (void *) -1)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("ShareMemory_Init:shmat ShmStatusCodeData NG");
+        return 0;
+    }
+
+    //create ShmCcsData
+    if ((MeterSMId[2] = shmget(ShmCcsCommKey, sizeof(struct CcsData),  0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("ShareMemory_Init:shmget ShmCcsData NG");
+        return 0;
+    }
+    else if ((ShmCcsData = shmat(MeterSMId[2], NULL, 0)) == (void *) -1)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("ShareMemory_Init:shmat ShmCcsData NG");
+        return 0;
+    }
+
+    //create ShmInternalComm
+    if ((MeterSMId[3] = shmget(ShmInternalCommKey, sizeof(struct InternalComm),   0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("ShareMemory_Init:shmget ShmInternalComm NG");
+        return 0;
+    }
+    else if ((ShmInternalComm = shmat(MeterSMId[3], NULL, 0)) == (void *) -1)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("ShareMemory_Init:shmat ShmInternalComm NG");
+        return 0;
+    }
+	#if 0
+    //create ShmInternalCommAC
+    if ((MeterSMId[4] = shmget(ShmInternalCommACKey, sizeof(struct InternalCommAC),   0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("ShareMemory_Init:shmget ShmInternalCommAC NG");
+        return 0;
+    }
+    else if ((ShmInternalCommAC = shmat(MeterSMId[4], NULL, 0)) == (void *) -1)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("ShareMemory_Init:shmat ShmInternalCommAC NG");
+        return 0;
+    }
+    #endif
+
+    //[To-Do] The initialization here is reduntant and should be removed partially.
+    //SHM_Init_supportedAppProtocolRes(ShmCcsData);
+    //SHM_Init_din_SessionSetupRes(ShmCcsData);
+    //SHM_Init_din_ServiceDiscoveryRes(ShmCcsData);
+    //SHM_Init_din_ServiceAndPaymentSelectionRes(ShmCcsData);
+    //SHM_Init_din_ContractAuthenticationRes(ShmCcsData);
+    SHM_Init_din_ChargeParameterDiscoveryRes(ShmCcsData);
+    SHM_Init_din_CableCheckRes(ShmCcsData);
+    SHM_Init_din_PreChargeRes(ShmCcsData);
+    SHM_Init_din_PowerDeliveryRes(ShmCcsData);
+    SHM_Init_din_CurrentDemandRes(ShmCcsData);
+    SHM_Init_din_WeldingDetectionRes(ShmCcsData);
+    SHM_Init_din_SessionStopRes(ShmCcsData);
+
+    return 1;
+}
+
+/*===========================================================================
+FUNCTION: GetEthMac
+DESCRIPTION:
+    1. Accessing current CsuMac address, if Eth = eth1
+    2. The address of eth1(for QCA7000) is a random number, which will be modified
+       after each time of booting up system.
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int GetEthMac(unsigned char *Eth, unsigned char *mac)
+{
+    //Parameters:MAC,IP,Mask,Gateway
+    int fd, rd = 0;
+    unsigned char addr[18], Buffer[128];
+
+    memset(Buffer, 0, sizeof(Buffer));
+    sprintf(Buffer, "cat /sys/class/net/%s/address > /mnt/GetEthInfo", Eth);    //CsuMac (Eth = eth1)
+    system(Buffer);
+    fd = open("/mnt/GetEthInfo", O_RDONLY);
+    if(fd < 0)
+    {
+        system("rm -f /mnt/GetEthInfo");
+        SAVE_SYS_LOG_MSG_EVCOMM("GetEthMac: MAC Address open error");
+        return 0;
+    }
+    memset(mac, 0, 6);
+    memset(addr, 0, sizeof(addr));
+    rd = read(fd, addr, 17);
+    close(fd);
+    system("rm -f /mnt/GetEthInfo");
+    sscanf(addr, "%02x:%02x:%02x:%02x:%02x:%02x", &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5]);    //CsuMac (Eth = eth1)
+    sprintf(buf_log_evcomm,
+            "[GetEthMac]EVSE MACAddr(CsuMac): %02x:%02x:%02x:%02x:%02x:%02x",
+            mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);    //CsuMac (Eth = eth1)
+    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    return 1;
+}
+
+/*===========================================================================
+FUNCTION: ReadAdcVolt
+DESCRIPTION:
+    1. fork1
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+float ReadAdcVolt(unsigned char AdcChannel)
+{
+    //AIN0=CCS GUN Temp 1
+    //AIN1=CCS GUN Temp 2
+    //AIN2=CCS_Proximity/2
+    //AIN3=pilot voltage
+
+	if(AdcChannel == 3)
+	{
+		int fd,count,AvgTimes;
+		unsigned char SampleBuf[4];
+		float TmpVolt, MinSample, AvgSample = 0;
+
+		fd = open("/sys/bus/iio/devices/iio\:device0/in_voltage3_raw", O_RDONLY);
+	        if(fd > 0)
+	        {
+	            //system("echo 1 > /sys/class/gpio/gpio89/value");    //for test
+	            for(AvgTimes = 0; AvgTimes < 3; AvgTimes++) //period = 60~91 ms(renice -10, , CurrentDemand()) /*+++ 20200909, vern, extend detection time for interference ---*/
+	            {
+	                count = 0;
+	                MinSample = 2306;
+	                //system("echo 1 > /sys/class/gpio/gpio89/value");    //for test
+	                while(count < 30)  //period = 21~42ms  (renice -10, CurrentDemand())/*+++ 20200909, vern, extend detection time for interference ---*/
+	                {
+	                    //re-sampling period = 3~13ms (renice -10, SLAC())
+	                    //system("echo 1 > /sys/class/gpio/gpio89/value");    //for test
+	                    read(fd, SampleBuf, 4); //period = 3.2~10ms (renice -10, SLAC())
+	                    //system("echo 0 > /sys/class/gpio/gpio89/value");    //for test
+	                    TmpVolt = atoi(SampleBuf);
+	
+	                    if((TmpVolt < 2306) && (TmpVolt > 0))//positive voltage
+	                    {
+	                        if(TmpVolt < MinSample)
+	                        {
+	                            MinSample = TmpVolt;
+	                        }
+	                        count++;
+	                    }
+	                    lseek(fd, 0, SEEK_SET);
+	                }
+	                //system("echo 0 > /sys/class/gpio/gpio89/value");    //for test
+	                AvgSample += MinSample;
+	            }
+	            AvgSample /= AvgTimes;
+	            close(fd);
+	            //system("echo 0 > /sys/class/gpio/gpio89/value");    //for test
+	            return ((0.954-(1.8*AvgSample/4095))/0.06);
+	        }
+		else
+		{
+			return -1;
+		}
+	}
+	else
+	{
+		FILE *fp;
+		unsigned char str[64];
+		unsigned char AdcValue[8];
+
+		if(AdcChannel > 7)
+		{
+		    return -1;
+		}
+
+		memset(str,0,sizeof(str));
+		memset(AdcValue,0,sizeof(AdcValue));
+		sprintf(str, "cat /sys/bus/iio/devices/iio\\:device0/in_voltage%d_raw", AdcChannel);
+		fp=popen(str, "r");
+		if(fgets(AdcValue,sizeof(AdcValue),fp) == NULL)
+		{
+		    pclose(fp);
+		    return -1;
+		}
+		pclose(fp);
+		//Vin =  Vref *D / (2^n - 1)
+		return ((float)1.8*(float)atoi(AdcValue))/4095;
+	}
+
+}
+
+/*===========================================================================
+FUNCTION: ReadAdcVolt
+DESCRIPTION:
+    //AIN0=CCS GUN Temp 1
+    //AIN1=CCS GUN Temp 2
+    //AIN2=CCS_Proximity/2
+    //AIN3=pilot voltage
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+float ReadAdcVolt_PP_fork3()
+{
+    int fd, AvgTimes;
+    unsigned char SampleBuf[4];
+    float TmpVolt = 0;
+    float AvgSample = 0;
+    float V_pp = 0;
+
+    fd = open("/sys/bus/iio/devices/iio\:device0/in_voltage2_raw", O_RDONLY); //PP
+    if(fd > 0)
+    {
+        for(AvgTimes = 0; AvgTimes < 5; AvgTimes++) //get 5 samples
+        {
+            read(fd, SampleBuf, 4);
+            TmpVolt = atoi(SampleBuf);
+            lseek(fd, 0, SEEK_SET);
+
+            AvgSample += TmpVolt;
+        }
+        close(fd);
+        AvgSample /= AvgTimes;
+        V_pp = (1.8*AvgSample)/4095;    //PP
+	//CCS1: plug : 0.61<=V_pp<=1.18
+	//CCS2:plug : 1.2<=V_pp<=2.4
+        #if 0
+        printf("PP_adc = %.02f, PP_v = %.02f\n", AvgSample, V_pp);
+        usleep(3000000); //300ms
+        #endif
+        usleep(20000);  //20ms
+
+        return V_pp;
+    }
+    else
+    {
+        return -1;
+    }
+}
+
+/*===========================================================================
+FUNCTION: Qca7kPowerReset
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Qca7kPowerReset()
+{
+    //printf("\n[CCS Board]Reset QCA7000...\n");
+    system("echo 1 > /sys/class/gpio/gpio88/value");
+    usleep(500000);
+    system("echo 0 > /sys/class/gpio/gpio88/value");
+}
+
+/*===========================================================================
+FUNCTION: SwitchCpStateE
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int SwitchCpStateE(unsigned char OnOff)
+{
+    if((OnOff != ENABLE) && (OnOff != DISABLE))
+    {
+        return -1;
+    }
+
+    struct ChargingInfoData *ccs;
+    ccs = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    ccs->SwitchCpStateE_status = OnOff;
+
+    //OnOff = 1 => switch State to E
+    //OnOff = 0 => return noraml
+    #if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
+    {
+        if(OnOff == DISABLE)
+        {
+            //SAVE_SYS_LOG_MSG_EVCOMM("SwitchCpStateE: released\n");
+           // CSUCOMMAC_SHM.CpSetStateE = DISABLE;
+        }
+        else
+        {
+            OutputCpPwmDuty(100); //set CP duty as 100, firstly.
+            //CSUCOMMAC_SHM.CpSetStateE = ENABLE;
+            //SAVE_SYS_LOG_MSG_EVCOMM("SwitchCpStateE: enabled!\n");
+        }
+    }
+    #else //CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED
+    {
+        if(OnOff == DISABLE)
+        {
+            //SAVE_SYS_LOG_MSG_EVCOMM("SwitchCpStateE: released\n");
+            system("echo 0 > /sys/class/gpio/gpio86/value");
+        }
+        else
+        {
+            OutputCpPwmDuty(100); //set CP duty as 100, firstly.
+            system("echo 1 > /sys/class/gpio/gpio86/value");
+            //SAVE_SYS_LOG_MSG_EVCOMM("SwitchCpStateE: enabled!\n");
+        }
+    }
+    #endif
+
+    if (ccs->SwitchCpStateE_status_pre != ccs->SwitchCpStateE_status)
+    {
+        sprintf(buf_log_evcomm,
+                "SwitchCpStateE: %d >> %d",
+                ccs->SwitchCpStateE_status_pre,
+                ccs->SwitchCpStateE_status
+                );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        ccs->SwitchCpStateE_status_pre = ccs->SwitchCpStateE_status;
+    }
+
+
+}
+
+/*===========================================================================
+FUNCTION: OutputCpPwmDuty
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int OutputCpPwmDuty(unsigned char Duty)
+{
+    int DutyInNanoSec;
+    struct ChargingInfoData *ccs;
+    ccs = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    if((Duty < 0)||(Duty > 100))
+    {
+        return -1;
+    }
+
+    #if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
+    {
+        //CSUCOMMAC_SHM.CpSetPWMDuty = Duty;
+    }
+    #else //CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED
+    {
+        DutyInNanoSec = 10000 * Duty;
+        sprintf(buf_log_evcomm, "echo %d > /sys/class/pwm/pwmchip0/pwm0/duty_cycle", DutyInNanoSec);//nanoseconds
+        system(buf_log_evcomm);
+    }
+    #endif
+
+    ccs->CpDuty = Duty;
+
+    //CP Duty
+    if (ccs->CpDuty != ccs->CpDuty_pre)
+    {
+        //memset(buf_log_evcomm, 0, sizeof(buf_log_evcomm));
+        sprintf(buf_log_evcomm, "CP Duty: %d\% >> %d\%", ccs->CpDuty_pre, ccs->CpDuty);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+        ccs->CpDuty_pre = ccs->CpDuty;
+    }
+
+    return 0;
+}
+
+/*===========================================================================
+FUNCTION: Check_Plugin_Status_Update_fork1
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+//#if SAVE_SYS_LOG_MSG_EVCOMM_SWITCH == ENABLE
+void Check_Plugin_Status_Update_fork1(struct ChargingInfoData *ccs)
+{
+    if (ccs->ConnectorPlugIn != ccs->ConnectorPlugIn_new)
+    {
+        sprintf(buf_log_evcomm_fork1, "[fork1]Plugin: %d >> %d (CP=%.2fV, PP=%.2fV)",
+                ccs->ConnectorPlugIn,
+                ccs->ConnectorPlugIn_new,
+                ccs->CpVoltage,
+                ccs->PpVoltage
+                );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork1);
+
+        ccs->ConnectorPlugIn_pre = ccs->ConnectorPlugIn;
+        ccs->ConnectorPlugIn = ccs->ConnectorPlugIn_new;
+        //ccs->CpVoltage_pre = ccs->CpVoltage;
+    }
+}
+//#endif
+
+/*===========================================================================
+FUNCTION: ConnectorPlugIn
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int CheckConnectorPlugIn()
+{
+    //return 0 => unplug
+    //return 1 => plug-in
+
+    //float TmpProximity;
+    //unsigned char Rtn = 0;
+    static struct ChargingInfoData *ccs;
+    ccs = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    #if (CP_PROTECTION_MECHANISM == ENABLE)
+    return (int)ccs->ConnectorPlugIn;
+    #else
+    return TRUE;
+    #endif
+
+/*
+    // PP Detection
+    TmpProximity = ReadAdcVolt(ADC_CHANNEL_AIN2_PP);
+    //[CAUTION] This function takes a period of time to deal with.
+    //Designers should avoid to call it in main function, repeatly.
+
+    if(((FIRMWARE_VERSION & 0x0000FF00) >> 8) == 0x01)
+    {
+        //UL version: judge with CP and proximity
+        //TmpProximity = ReadAdcVolt(ADC_CHANNEL_AIN2_PP);
+        //SAVE_SYS_LOG_MSG_EVCOMM("Connector: UL");
+        if((ccs->CpState >= 2) &&
+           (ccs->CpState <= 5) &&
+           (TmpProximity >= 0.4) &&
+           (TmpProximity <= 0.9))
+        {
+            Rtn = 1;
+        }
+    }
+    else
+    {
+        //SAVE_SYS_LOG_MSG_EVCOMM("Connector: CE");
+        //CE version: judge with CP only
+        if((ccs->CpState >=2 ) &&
+           (ccs->CpState <=5 ))
+        {
+            Rtn = 1;
+        }
+    }
+*/
+    //CE version: judge with CP only
+    /*
+    if((ccs->CpState >= 2 ) &&
+       (ccs->CpState <= 5 ))
+    {
+        Rtn = TRUE;
+    }
+
+    ccs->ConnectorPlugIn = Rtn;
+    //ccs->PpVoltage = TmpProximity;
+    return Rtn;
+    */
+}
+
+/*===========================================================================
+FUNCTION: Check_CP_State_Error_fork1
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Check_CP_State_Error_fork1(struct ChargingInfoData *ccs)
+{
+    #if (CP_PROTECTION_MECHANISM == DISABLE)
+    {
+        return -1;
+    }
+    #endif
+
+    unsigned char state = 0;
+    double time_diff = 0;
+    state = Check_V2G_Flow_Status();
+
+    //SLAC, SLAAC, SDP, ..., ChargeParameterDiscovery
+    if (state >= CM_SLAC_PARM_CONF &&   //by considering 15118(SLAC first)
+        state < ChargeParameterDiscoveryRequest &&
+        state != IDLE &&
+        state != CM_SET_KEY_REQ &&
+        state != CM_SET_KEY_CNF &&
+        state != CM_VALIDATE_REQ &&
+        state != CM_VALIDATE_CNF)
+    {
+        #if (SLAC_FIRST_RESPONSE_METHOD == SET_5_PWM_ONCE_GET_PERMISSION_IN_AUTHORIZATIONRES)
+        {
+            if((ccs->CpState != 2) && (ccs->CpState != 3))
+            {
+                if (ccs->CpState_err == FALSE)
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[fork1][CP][Error]before CPD");    //CPD: ChargeParameterDiscoveryRequest
+                    //CPD: ChargeParameterDiscovery
+                }
+                ccs->CpState_err = TRUE;
+            }
+        }
+        #else
+        {
+        	#ifdef AWCCS
+  			if((ccs->CpState != 2) && (ccs->CpState != 3))
+            {
+                if (ccs->CpState_err == FALSE)
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[fork1][CP][Error]before CPD");    //CPD: ChargeParameterDiscoveryRequest
+                    //CPD: ChargeParameterDiscovery
+                }
+                ccs->CpState_err = TRUE;
+            }
+        	#else
+            if(ccs->CpState != 3)
+            {
+                if (ccs->CpState_err == FALSE)
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[fork1][CP][Error]before CPD");    //CPD: ChargeParameterDiscoveryRequest
+                    //CPD: ChargeParameterDiscovery
+                }
+                ccs->CpState_err = TRUE;
+            }
+            #endif
+        }
+        #endif
+    }
+
+    #if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
+    {
+        //ChargeParameterDiscovery
+        if(state >= ChargeParameterDiscoveryRequest &&        //35
+           state <= ChargeParameterDiscoveryResponse)         //36
+        {
+            if(ccs->CpState != 3)
+            {
+                if (ccs->CpState_err == FALSE)
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[CP][Error]CPD");
+                    //PRC: Precharge
+                    //CUD: CurrentDemand
+                }
+                ccs->CpState_err = TRUE;
+            }
+        }
+
+        //ChargingStatus
+        if(state >= ChargingStatusRequest &&        //43
+           state <= ChargingStatusResponse)         //44
+        {
+            if(ccs->CpState != 4 && ccs->CpState != 5)
+            {
+                if (ccs->CpState_err == FALSE)
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[CP][Error]CGS");
+                    //PRC: Precharge
+                    //CUD: CurrentDemand
+                }
+                ccs->CpState_err = TRUE;
+            }
+        }
+    }
+    #else //CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED
+    {
+        //ChargeParameterDiscovery, CableCheck
+        if (state >= ChargeParameterDiscoveryRequest &&     //35
+            state <= CableCheckResponse)                    //38
+        {
+            if(ccs->CableCheckPreCountDownDone == FALSE &&
+            state >= CableCheckRequest)
+            {
+                ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
+                time_diff = DiffTimeb_fork1_Error_Monitor(EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_Start, EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
+                if(time_diff >= V2G_SECC_CP_Timeout_CableCheck)   //2 sec
+                {
+                    sprintf(buf_log_evcomm_fork1,
+                            "[fork1][CP]check C(4),D(5): ON (%.02lf of %dms)",
+                            time_diff,
+                            V2G_SECC_CP_Timeout_CableCheck);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork1);
+                    ccs->CableCheckPreCountDownDone = TRUE;
+                }
+            }
+
+            if(ccs->CableCheckPreCountDownDone == TRUE)
+            {
+                if(ccs->CpState != 4 && ccs->CpState != 5)
+                {
+                    if (ccs->CpState_err == FALSE)
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[CP][Error]CPD and CCK (after CNT)");
+                        //CPD: ChargeParameterDiscovery
+                        //CCK: CableCheck
+                        //CNT: count down
+                    }
+                    ccs->CpState_err = TRUE;
+                }
+            }
+            else
+            {
+                if(ccs->CpState != 3 && ccs->CpState != 4 && ccs->CpState != 5)
+                {
+                    if (ccs->CpState_err == FALSE)
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[CP][Error]CPD and CCK (before CNT)");
+                        //CPD: ChargeParameterDiscovery
+                        //CCK: CableCheck
+                        //CNT: count down
+                    }
+                    ccs->CpState_err = TRUE;
+                }
+            }
+        }
+
+        //Precharge, CurrentDemand
+        if(state >= PreChargeRequest &&      //39
+        state <= CurrentDemandResponse)   //46
+        {
+            //if(ccs->CpState != 4 && ccs->CpState != 5)
+            if( ccs->CpState  <=1)
+            {
+                if (ccs->CpState_err == FALSE)
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[CP][Error]PRC and CUD");
+                    //PRC: Precharge
+                    //CUD: CurrentDemand
+                }
+                ccs->CpState_err = TRUE;
+            }
+        }
+    }
+    #endif
+
+    if(ccs->CpState_err == TRUE && ccs->CpState_err_logged == FALSE)
+    {
+        OutputCpPwmDuty(100);
+        //system("echo 1 > /sys/class/gpio/gpio89/value");    //for test
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_CP_State_Error (023889)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+
+        Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
+        sprintf(buf_log_evcomm_fork1, "[fork1][Erorr]CP(%d) Error in state %d(%d)",
+                ccs->CpState,
+                state,
+                ccs->CableCheckPreCountDownDone
+                );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork1);
+        ccs->CpState_err_logged = TRUE;
+    }
+    return 0;
+}
+
+/*===========================================================================
+FUNCTION: Check_CP_State_Update_fork1
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+//#if SAVE_SYS_LOG_MSG_EVCOMM_SWITCH == ENABLE
+void Check_CP_State_Update_fork1(struct ChargingInfoData *ccs)
+{
+    //CP Voltage
+    /*
+    //Issues waiting to debug
+    //[CAUTION] This function shall not be used in charging state.
+    if (((int)(ccs->CpVoltage * 10)) != ((int)(ccs->CpVoltage_pre * 10)))
+    {
+        memset(buf, 0, sizeof(buf));
+        sprintf(buf, "CP Voltage: %.2lf >> %.2lf (%d >> %d)",
+                ccs->CpVoltage_pre,
+                ccs->CpVoltage,
+                (int)(ccs->CpVoltage_pre * 10),
+                (int)(ccs->CpVoltage * 10)
+               );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf);
+
+        ccs->CpVoltage_pre = ccs->CpVoltage;
+    }
+    */
+
+    //CP State
+    if (ccs->CpState != ccs->CpState_pre)
+    {
+        sprintf(buf_log_evcomm_fork1, "[fork1]CP State: %d >> %d (%.2fV)",
+                ccs->CpState_pre,
+                ccs->CpState,
+                ccs->CpVoltage
+                );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork1);
+
+        ccs->CpState_pre = ccs->CpState;
+    }
+}
+//#endif
+
+/*===========================================================================
+FUNCTION: CP_Detection
+DESCRIPTION:
+        1. In order to detect CP in efficient response time, we creat an independent
+           thead for this procedure.
+
+        2. The priority of this thread is set as the same as other tasks.
+
+        3. fork1
+
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void CP_Detection()
+{
+    pid_t tmp = 0;
+ //   struct timeb StartTime, EndTime;
+    unsigned char Statetmp;
+    float TotalTmpVolt;
+    struct ChargingInfoData *ccs;
+
+    ccs = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    if(CP_Detection_Pid == 0)
+    {
+        tmp = fork();
+        if(tmp > 0)
+        {
+            CP_Detection_Pid = tmp;
+
+            #if 1
+            unsigned char buf[64];
+            memset(buf, 0, sizeof(buf));
+            //sprintf(buf, "renice -20 -p %d", tmp);
+            sprintf(buf, "renice -10 -p %d", tmp);
+            system(buf);
+            #endif
+
+            return;
+        }
+    }
+
+    while(1)
+    {
+        //ADC_Voltage = (1+RE62/RE63)*0.9 - (RE62/RE63)*Pilot_Voltage,  RE62/RE63=0.06
+        //=>Pilot_Voltage=(0.954-ADC_Voltage)/0.06
+
+        #if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
+        {
+            ccs->CpVoltage = ShmInternalComm->AC_CpPositiveVoltage;
+            ccs->CpState = ShmInternalComm->AC_CpPresentState;
+        }
+        #else //CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED
+        {
+            TotalTmpVolt = ReadAdcVolt(3);
+
+            ccs->CpVoltage = TotalTmpVolt;
+
+            if (ccs->CpVoltage_pre != ccs->CpVoltage)
+            {
+                ccs->CpVoltage_pre = ccs->CpVoltage;
+            }
+
+            //printf("TotalTmpVolt = %.02f\n", TotalTmpVolt);
+
+            //If CP voltage is higer than 13.5V
+            if(TotalTmpVolt >= 13.5)
+            {
+                //Pilot Error
+                if((ccs->CpState == 1) &&
+                (TotalTmpVolt < 13.75))
+                {
+                    //V_cp = 13.5 ~ 13.75
+                    Statetmp = 1;
+                }
+                else
+                {
+                    //V_cp = 13.5 ~
+                    Statetmp = 8;
+                }
+            }
+            else if((TotalTmpVolt >= 10.5) && (TotalTmpVolt < 13.5)) //V_cp = 10.5 ~ 13.5
+            {
+                //State A (12V)
+                if((ccs->CpState >= 2) &&
+                (ccs->CpState <= 3) &&
+                (TotalTmpVolt < 10.75))
+                {
+                    if((ccs->CpDuty >= 5) &&
+                    (ccs->CpDuty < 100))
+                    {
+                        Statetmp = 3;
+                    }
+                    else
+                    {
+                        Statetmp = 2;
+                    }
+                }
+                else if((ccs->CpState == 8) &&
+                        (TotalTmpVolt >= 13.25))
+                {
+                    Statetmp = 8;
+                }
+                else
+                {
+                    Statetmp = 1;
+                }
+            }
+            else if((TotalTmpVolt >= 7.5) && (TotalTmpVolt < 10.5))
+            {
+                //State B (9V)
+                if((ccs->CpState == 4) && (TotalTmpVolt < 7.75))
+                {
+                    Statetmp = 4;
+                }
+                else if((ccs->CpState == 1) && (TotalTmpVolt >= 10.25))
+                {
+                    Statetmp = 1;
+                }
+                else
+                {
+                    if((ccs->CpDuty >= 5) && (ccs->CpDuty < 100))
+                    {
+                        Statetmp = 3;
+                    }
+                    else
+                    {
+                        Statetmp = 2;
+                    }
+                }
+            }
+            else if((TotalTmpVolt >= 4.5) && (TotalTmpVolt < 7.5))
+            {
+                //State C (6V)
+                if((ccs->CpState == 5) && (TotalTmpVolt < 4.75))
+                {
+                    Statetmp = 5;
+                }
+                else if((ccs->CpState >= 2) && (ccs->CpState <= 3) && (TotalTmpVolt >= 7.25))
+                {
+                    if((ccs->CpDuty >= 5)&&(ccs->CpDuty < 100))
+                    {
+                        Statetmp = 3;
+                    }
+                    else
+                    {
+                        Statetmp = 2;
+                    }
+                }
+                else
+                {
+                    Statetmp = 4;
+                }
+            }
+            else if((TotalTmpVolt >= 1.5) && (TotalTmpVolt < 4.5))
+            {
+                //State D (3V)
+                if((ccs->CpState == 6)&&(TotalTmpVolt < 1.75))
+                {
+                    Statetmp = 6;
+                }
+                else if((ccs->CpState == 4)&&(TotalTmpVolt >= 4.25))
+                {
+                    Statetmp = 4;
+                }
+                else
+                {
+                    Statetmp = 5;
+                }
+            }
+            else if((TotalTmpVolt >= -1.5) && (TotalTmpVolt < 1.5)) //V_cp = -1.5V ~ 1.5V
+            {
+                //State E (0V)
+                if((ccs->CpState == 8) &&
+                (TotalTmpVolt < -1.25))
+                {
+                    Statetmp = 8;
+                }
+                else if((ccs->CpState == 5) &&
+                        (TotalTmpVolt >= 1.25))
+                {
+                    Statetmp = 5;
+                }
+                else
+                {
+                    Statetmp = 6;
+                }
+            }
+            else if((TotalTmpVolt >= -13.5) && (TotalTmpVolt < -10.5)) //V_cp = -10.5V ~ -13.5V
+            {
+                //State F (-12V)
+                if((ccs->CpState == 8) &&
+                (TotalTmpVolt >= -10.75))
+                {
+                    Statetmp = 8;
+                }
+                else
+                {
+                    Statetmp = 7;
+                }
+            }
+            else
+            {
+                //null
+            }
+
+            ccs->CpState = Statetmp;
+        }
+        #endif
+
+        Check_CP_State_Update_fork1(ccs);
+        #ifndef AWCCS
+        Check_CP_State_Error_fork1(ccs);
+		#endif
+        //Updating Plugin status
+        #if (PP_PROTECTION_MECHANISM == ENABLE)
+        if((ccs->CpState >= 2 ) && (ccs->CpState <= 5 ) && 
+           (ShmInternalComm->CCSConnectorType>0?((EVCOMM_SYS_INFO.PpVoltage > 1.2)&&(EVCOMM_SYS_INFO.PpVoltage <= 2.4)):((EVCOMM_SYS_INFO.PpVoltage > 0.61)&&(EVCOMM_SYS_INFO.PpVoltage <= 1.185)))
+        )
+        #else
+        if((ccs->CpState >= 2 ) && (ccs->CpState <= 5 ))
+        #endif
+        {
+            ccs->ConnectorPlugIn_new = TRUE;
+        }
+        else
+        {
+            ccs->ConnectorPlugIn_new = FALSE;
+            OutputCpPwmDuty(100);
+        }
+
+        Check_Plugin_Status_Update_fork1(ccs);
+
+        //ftime(&EndTime);
+        //DEBUG_PRINTF_EVCOMM_DETAIL("duration:%.02lf\n", DiffTimeb(StartTime, EndTime));
+    }//while
+}
+
+/*===========================================================================
+FUNCTION: PP_Detection
+DESCRIPTION:
+    0. SeccComm fork3
+    1. In order to detect CP in efficient response time, we creat an independent
+       thead for this procedure.
+
+    2. The priority of this thread is set as the same as other tasks.
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PP_Detection()
+{
+    pid_t tmp = 0;
+ //   struct timeb StartTime, EndTime;
+    unsigned char Statetmp;
+    float TotalTmpVolt;
+
+    if(PP_Detection_Pid == 0)
+    {
+        tmp = fork();
+        if(tmp > 0)
+        {
+            PP_Detection_Pid = tmp;
+
+            #if 0
+            unsigned char buf[64];
+            memset(buf, 0, sizeof(buf));
+            sprintf(buf, "renice -10 -p %d", tmp);
+            system(buf);
+            #endif
+
+            return;
+        }
+    }
+	TotalTmpVolt = ReadAdcVolt_PP_fork3();
+    while(1)
+    {
+        TotalTmpVolt = ReadAdcVolt_PP_fork3();
+	
+        EVCOMM_SYS_INFO.PpVoltage = TotalTmpVolt;
+
+        if (EVCOMM_SYS_INFO.PpVoltage_pre != EVCOMM_SYS_INFO.PpVoltage)
+        {
+            if((( (ShmInternalComm->CCSConnectorType>0?((EVCOMM_SYS_INFO.PpVoltage > 1.2)&&(EVCOMM_SYS_INFO.PpVoltage <= 2.4)):((EVCOMM_SYS_INFO.PpVoltage > 0.61)&&(EVCOMM_SYS_INFO.PpVoltage <= 1.185))))&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].ConnectorPlugIn==FALSE))
+           	||(( (ShmInternalComm->CCSConnectorType>0?((EVCOMM_SYS_INFO.PpVoltage <= 1.2)||(EVCOMM_SYS_INFO.PpVoltage > 2.4)):((EVCOMM_SYS_INFO.PpVoltage <= 0.61)||(EVCOMM_SYS_INFO.PpVoltage > 1.185))))&&(ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].ConnectorPlugIn==TRUE)))
+            {
+            	// plug-in : CCS1 (0.61 < V <1.185),  CCS2 (1.2 < V <2.4)
+                sprintf(buf_log_evcomm_fork3,
+                        "[fork3]PP(%.2f >> %.2fV)",
+                        EVCOMM_SYS_INFO.PpVoltage_pre,
+                        EVCOMM_SYS_INFO.PpVoltage
+                        );
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork3);
+                EVCOMM_SYS_INFO.PpVoltage_pre = EVCOMM_SYS_INFO.PpVoltage;
+            }
+        }
+
+        #if 0
+        sleep(5);
+        printf("V_pp = %.02f\n", TotalTmpVolt);
+        #endif
+    }//while
+}
+
+/*===========================================================================
+FUNCTION: Error_Monitor
+DESCRIPTION:
+    1. This function only works in SeccComm fork2.
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Error_Monitor()
+{
+    pid_t tmp = 0;
+    double time_diff = 0;
+    unsigned char status = 0;
+    struct ChargingInfoData *ccs;
+    ccs = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    if(Error_Monitor_Pid == 0)
+    {
+        tmp = fork();   //SeccComm fork2
+        if(tmp > 0)
+        {
+            Error_Monitor_Pid = tmp;
+
+            #if 0
+            unsigned char buf[64];
+            memset(buf, 0, sizeof(buf));
+            sprintf(buf, "renice -20 -p %d", tmp);
+            system(buf);
+            #endif
+
+            return;
+        }
+    }
+
+    while(1)
+    {
+        //Step 0
+        if (EVCOMM_SYS_INFO.End_Process_inused == TRUE)
+        {
+            //If the End_Process is in processing, disable Error_Monitor.
+            continue;
+        }
+
+        //Step1 1: Check and Response to Plugin Status
+        if(CheckConnectorPlugIn() == FALSE)
+        {
+            status = Check_V2G_Flow_Status();
+            if (status > IDLE &&
+                status < Performance_Timeout &&
+                status != CM_SET_KEY_REQ &&
+                status != CM_SET_KEY_CNF &&
+                EVCOMM_SYS_INFO.End_Process_inused == FALSE)
+            {
+                #if (CP_PROTECTION_MECHANISM == ENABLE)
+                //SAVE_SYS_LOG_MSG_EVCOMM("[fork2] Emergency Stop (due to Connector is plugged out during communication.)");
+                SAVE_SYS_LOG_MSG_EVCOMM("[fork2]Plug out Error => End_Process");
+                //Update_ShmStatusCode(); //[To-Do] to be implemented
+                //CCS_SECC_CP_State_Error (023889)
+                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+                ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+                End_Process();
+                #else
+                //SAVE_SYS_LOG_MSG_EVCOMM("CP_PROTECTION_MECHANISM is disabled. Emergency Stop: skipped" );
+                #endif
+            }
+        }
+
+
+        //Step 2: Check for V2G_SECC_Sequence_Timeout
+        //#if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+        #if 1
+        status = Check_V2G_Flow_Status();
+        if (status >= SupportedAppProtocolRequest &&
+            status < SessionStopRequest)
+        {
+            ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_End);
+            time_diff = DiffTimeb_fork2_Error_Monitor(EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start, EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_End);
+            if(time_diff > V2G_SECC_Sequence_Timeout)   //60s
+            {
+                sprintf(buf_log_evcomm_fork2,
+                        "[fork2]V2G_SECC_Sequence_Timeout in state %d - (%.02lf of %d ms)\n",
+                        status,
+                        time_diff,
+                        V2G_SECC_Sequence_Timeout);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork2);
+                Update_V2G_Flow_Status(Sequence_Timeout);
+                //Update_ShmStatusCode(); //[To-Do] to be implemented
+                //CCS_SECC_TIMEOUT_V2G_Sequence_Time (023844)
+                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                ShmStatusCodeData->PresentStatusCode[0][4] = 4;
+                ShmStatusCodeData->PresentStatusCode[0][5] = 4;
+                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+                End_Process();
+                break;
+            }
+            else if (time_diff > 4000) //4s
+            {
+                //Check for CSU command of "Stop by EVSE"
+                if (EVCOMM_SYS_INFO.DC_EVSEStatus == EVSE_Shutdown)
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error_Monitor]EVSE_Shutdown");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                else if (EVCOMM_SYS_INFO.DC_EVSEStatus == EVSE_EmergencyShutdown)
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error_Monitor]EVSE_EmergencyShutdown");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                else if (ShmInternalComm->ChargingPermission == FALSE)
+                {
+                    if (status >= ChargeParameterDiscoveryRequest)  //&& status < SessionStopRequest
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error_Monitor]ChargingPermission = FALSE");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                }
+                else
+                {
+                    //null
+                }
+            }
+            else
+            {
+                //null
+            }
+        }
+        #endif
+
+
+        //Step 3: Check and Response to Error V2gFlowStatus
+        status = Check_V2G_Flow_Status();
+        if (status == Performance_Timeout ||
+            status == Sequence_Timeout ||
+            status == Other_Fault)
+        {
+            sprintf(buf_log_evcomm_fork2,
+                    "[fork2]Timeout or Fault State(%d) => End_Process",
+                    status);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork2);
+            //Normal Stop
+            //alarm and duty to 100%
+            //OutputCpPwmDuty(100);
+            //SwitchCpStateE(ENABLE); //Set CP duty as 100% and set CP state as E (0V).
+            //[Joseph/ To-Do] Set State E (0V) via GPIO setting
+            End_Process();
+        }
+
+
+        //Step 4: Check and Response to CP State Error
+        if(ccs->CpState_err == TRUE)
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[fork2]CP Error => End_Process");
+            Update_V2G_Flow_Status(Other_Fault);
+            //Update_ShmStatusCode(); //[To-Do] to be implemented
+            //CCS_SECC_CP_State_Error (023889)
+            ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+            ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+            ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+            ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+            ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+            ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+            CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+            End_Process();
+        }
+
+
+        //Step 5: Check and Response to Shutdown Commnad from CSU
+        if (EVCOMM_SYS_INFO.DC_EVSEStatus == EVSE_Shutdown ||
+            EVCOMM_SYS_INFO.DC_EVSEStatus == EVSE_EmergencyShutdown)
+        {
+            if (Check_V2G_Flow_Status() <= SLACC_SDP_TCP_Connection)
+            {
+                sprintf(buf_log_evcomm_fork2,
+                        "[fork2]EVSE Shutdown(%d) => End_Process",
+                        EVCOMM_SYS_INFO.DC_EVSEStatus);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork2);
+                Update_V2G_Flow_Status(Other_Fault);
+                End_Process();
+            }
+        }
+
+
+        //Step 6: Check and Response to SessionStop
+        status = Check_V2G_Flow_Status();
+        if (status == SessionStopResponse)
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[fork2]SessionStopResponse => End_Process");
+            End_Process();
+        }
+
+        //Step 7: Check for ChargingPermission from TRUE to FALSE before V2G Messages
+        /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
+        if ((ShmInternalComm->ChargingPermission == FALSE) &&
+            (ShmInternalComm->ChargingPermission_pre >=1) && 
+            (ccs->CpState >= 3) && (ccs->CpState <=5))
+        {
+            if (status >= CM_SLAC_PARM_REQ &&
+                status != CM_SET_KEY_REQ &&
+                status != CM_SET_KEY_CNF &&
+                status <= SLACC_SDP_TCP_Connection)
+            {
+                sprintf(buf_log_evcomm_fork2,
+                        "[fork2]Permission OFF before V2G msg(%d) => End_Process",
+                        ShmInternalComm->ChargingPermission);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork2);
+                Update_V2G_Flow_Status(Other_Fault);
+                End_Process();
+            }
+        }
+	#if 0
+        //Step 8: DC OVP Protection
+        if (CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED &&
+            status > CableCheckResponse &&
+            status <= SessionStopRequest &&
+            status != ChargingStatusRequest &&
+            status != ChargingStatusResponse &&
+            EVCOMM_SYS_INFO.EvBatteryMaxVoltage != 0)
+        {
+            //Part A: OVP Protection
+
+            if (EVCOMM_SYS_INFO.PresentChargingVoltage >= (EVCOMM_SYS_INFO.EvBatteryMaxVoltage * 1.02)) // 2%
+            {
+                sprintf(buf_log_evcomm_fork2,
+                        "[fork2][Error]OVP => End_Process (%.02f > %.02f)",
+                        EVCOMM_SYS_INFO.PresentChargingVoltage,
+                        (EVCOMM_SYS_INFO.EvBatteryMaxVoltage * 1.02));
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork2);
+
+                Update_V2G_Flow_Status(Other_Fault);
+                //Update_ShmStatusCode(); //[To-Do] to be implemented
+                //System CCS output OVP (012219)
+                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                ShmStatusCodeData->PresentStatusCode[0][1] = 1;
+                ShmStatusCodeData->PresentStatusCode[0][2] = 2;
+                ShmStatusCodeData->PresentStatusCode[0][3] = 2;
+                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
+                ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+                Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
+                End_Process();
+            }
+	   
+            //Part B: Over Voltage Request Protection
+            if (EVCOMM_SYS_INFO.EvBatterytargetVoltage >= (EVCOMM_SYS_INFO.EvBatteryMaxVoltage * 1.02))
+            {
+                sprintf(buf_log_evcomm_fork2,
+                        "[fork2]Over V Req => End_Process (%.02f > %.02f)",
+                        EVCOMM_SYS_INFO.EvBatterytargetVoltage,
+                        (EVCOMM_SYS_INFO.EvBatteryMaxVoltage * 1.02)
+                        );
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm_fork2);
+
+                Update_V2G_Flow_Status(Other_Fault);
+                //Update_ShmStatusCode(); //[To-Do] to be implemented
+                //System CCS output OVP (012219)
+                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                ShmStatusCodeData->PresentStatusCode[0][1] = 1;
+                ShmStatusCodeData->PresentStatusCode[0][2] = 2;
+                ShmStatusCodeData->PresentStatusCode[0][3] = 2;
+                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
+                ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+                Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
+                End_Process();
+            }
+           
+        }
+        #endif
+	
+	#if 1
+        //Step 9: Check 60V
+        /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
+        if (CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED &&
+            ShmInternalComm->ChargingPermission >=1 && 
+            status < CableCheckRequest)
+        {
+            if (EVCOMM_SYS_INFO.PresentChargingVoltage >= 60)  //60V
+            {
+                SAVE_SYS_LOG_MSG_EVCOMM("[fork2]DC Output Voltage is over 60V => End_Process");
+                Update_V2G_Flow_Status(Other_Fault);
+                //Update_ShmStatusCode(); //[To-Do] to be implemented
+                //CCS_SECC_Unexpected_60V_Before_Charing_Error (023890)
+                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                ShmStatusCodeData->PresentStatusCode[0][4] = 9;
+                ShmStatusCodeData->PresentStatusCode[0][5] = 0;
+                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+                //Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
+                End_Process();
+            }
+        }
+	#endif
+        //Step 10: Check if the connector is unplug from plugin
+        if (EVCOMM_SYS_INFO.ConnectorPlugIn_pre == TRUE && EVCOMM_SYS_INFO.ConnectorPlugIn == FALSE)
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[fork2]Unplug Reset => End_Process");
+            Update_V2G_Flow_Status(Other_Fault);
+            End_Process();
+        }
+
+    }//while
+}
+
+
+/*===========================================================================
+FUNCTION: SendSetKey
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int SendSetKey()
+{
+    int i = 0;
+    unsigned char nRandValue = 0x0;
+    unsigned char ConstString[16] = "PhihongKey000000";
+
+    memset(&SendMmePacket,0,sizeof(struct MmeHeader));
+    memcpy(SendMmePacket.ODA,QcaMac,6);
+    memcpy(SendMmePacket.OSA,CsuMac,6);
+    SendMmePacket.MTYPE = htons(EtherType_HomePlug);
+    SendMmePacket.MMV = 0x01;
+    SendMmePacket.MMTYPE = MMTYPE_CM_SET_KEY_REQ;
+    SendMmePacket.FMI[0] = SendMmePacket.FMI[1] = 0;
+    SendMmePacketSize = 0;
+    SendMmePacket.MMENTRY[SendMmePacketSize++] = 0x01;//Fixed value (0x01) to indicate ��NMK��
+    memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,4);//My Nonce, Fixed value(0x00000000), encrypted payload not used
+    SendMmePacketSize+=4;
+    memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,4);//Your Nonce, Fixed value(0x00000000), encrypted payload not used
+    SendMmePacketSize+=4;
+    SendMmePacket.MMENTRY[SendMmePacketSize++] = 0x04;//PID, Fixed value (0x04) to indicate ��HLE protocol��
+    memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,2);//PRN, Fixed value(0x00), encrypted payload not used
+    SendMmePacketSize+=2;
+    SendMmePacket.MMENTRY[SendMmePacketSize++] = 0x00;//PMN, Fixed value(0x00) encrypted payload not used
+    SendMmePacket.MMENTRY[SendMmePacketSize++] = 0x01;//CCo Capablility
+    srand(time(NULL));
+    for (i = 10; i < 16; i++)
+    {
+        nRandValue = (rand()%62) + 1;
+        if((nRandValue>=0)&&(nRandValue<=9))  // 0 ~ 9
+        {
+            ConstString[i]= nRandValue + 0x30;
+        }
+        else if((nRandValue>=10)&&(nRandValue<=35)) // A ~ Z
+        {
+            ConstString[i]= nRandValue -10 + 0x41;
+        }
+        else if((nRandValue>=36)&&(nRandValue<=61)) // a ~ z
+        {
+            ConstString[i]= nRandValue -37 + 0x61;
+        }
+        else
+        {
+            ConstString[i]= 0x30;
+        }
+    }
+    memset(NewNmkKey,0,sizeof(NewNmkKey));
+    memset(Nid,0,sizeof(Nid));
+    HPAVKeyNMK(NewNmkKey, ConstString);
+    HPAVKeyNID(Nid,NewNmkKey,DEFAULT_LEVEL);
+    memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,Nid,sizeof(Nid));    //NID, 54 LSBs contain the NID 2 MSBs = 0b00
+    SendMmePacketSize+=sizeof(Nid);
+    SendMmePacket.MMENTRY[SendMmePacketSize++]=0x01;//NewEKS,Fixed value (0x01)to indicate ��NMK��
+    memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,NewNmkKey,sizeof(NewNmkKey));//NewKey
+    SendMmePacketSize += sizeof(NewNmkKey);
+    SendMmePacketSize += 19;  //the size before MMENTRY
+
+    SAVE_SYS_LOG_MSG_EVCOMM("[QCA7K][Tx]CM_SET_KEY_REQ");
+    i = sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+    Update_V2G_Flow_Status(CM_SET_KEY_REQ);
+    DEBUG_PRINTF_EVCOMM_DETAIL("SendSetKey: send size =%d\n",i);
+}
+
+
+/*===========================================================================
+FUNCTION: GetQca7kMac
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int GetQca7kMac()
+{
+    int i = 0;
+    struct QcaVendorMmeHeader SendPacket;
+
+    memset(&SendPacket, 0, sizeof(struct QcaVendorMmeHeader));
+    memset(SendPacket.ODA, 0xFF, 6);    //broadcast
+    memcpy(SendPacket.OSA, CsuMac, 6);
+    SendPacket.MTYPE = htons(EtherType_HomePlug);
+    SendPacket.MMV = 0x00;
+    SendPacket.MMTYPE = MMTYPE_VENDOR_VS_NW_INFO;
+    SendPacket.OUI[0] = 0x00;
+    SendPacket.OUI[1] = 0xB0;
+    SendPacket.OUI[2] = 0x52;
+
+    i = sendto(RawSock, &SendPacket, 20, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+
+    DEBUG_PRINTF_EVCOMM_DETAIL("GetQca7kMac: send size =%d\n", i);
+    SAVE_SYS_LOG_MSG_EVCOMM("[QCA7K][Tx][VENDOR_VS_NW_INFO]Req for QCA7K MacAddr");
+}
+
+
+
+/*===========================================================================
+FUNCTION: Array_Check_All_Zero
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+    result:
+    (1) TRUE: all zero
+    (2) FALSE: not all zero
+GLOBAL VARIABLES:
+=============================================================================*/
+int Array_Check_All_Zero(unsigned char *ptr, int size)
+{
+    int result = TRUE;
+    int i = 0;
+
+    for (i = 0; i < size; i++)
+    {
+        if (ptr[i] != 0)
+        {
+            result = FALSE;
+            break;
+        }
+    }
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: Array_Compare_Identity
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+    result = FALSE (not identical)
+    result = TRUE  (identical)
+GLOBAL VARIABLES:
+=============================================================================*/
+int Array_Compare_Identity(unsigned char *ptrA, unsigned char *ptrB, int size)
+{
+    int result = TRUE;
+    int i = 0;
+
+    for (i = 0; i < size; i++)
+    {
+        if (ptrA[i] != ptrB[i])
+        {
+            result = FALSE;
+
+            #if 0
+            sprintf(buf_log_evcomm,
+                    "[Array_Compare_Identity]%02X%02X%02X%02X%02X%02X,%02X%02X%02X%02X%02X%02X(%d)\n",
+                    ptrA[0], ptrA[1], ptrA[2], ptrA[3], ptrA[4], ptrA[5],
+                    ptrB[0], ptrB[1], ptrB[2], ptrB[3], ptrB[4], ptrB[5],
+                    result);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            #endif
+            break;
+        }
+    }
+    return result;
+}
+
+
+/*===========================================================================
+FUNCTION: SLAC_DB_Search_EvMac_idx
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+    idx = -1 (not found)
+GLOBAL VARIABLES:
+=============================================================================*/
+int SLAC_DB_Search_EvMac_idx(struct EVCC_SLAC_DATA_TYPE *evcc, unsigned char *EvMac_in)
+{
+    int idx = -1;
+    int i = 0;
+
+    if (evcc->arrayLen == 0)
+    {
+        //printf("[SLAC_DB_Search_EvMac_idx]arrayLen is empty (%d)\n", evcc->arrayLen);
+        //no need to search
+    }
+    else if (evcc->arrayLen > EVCC_SLAC_DATA_ARRAY_TYPE_ARRAY_SIZE)
+    {
+        //error
+        sprintf(buf_log_evcomm,
+                "[ERROR][SLAC_DB_Search_EvMac_idx]DB length(%d) > %d",
+                evcc->arrayLen,
+                EVCC_SLAC_DATA_ARRAY_TYPE_ARRAY_SIZE);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        evcc->arrayLen = 0; //reset
+    }
+    else
+    {
+        //start searching
+        for (i = 0; i < evcc->arrayLen; i++)
+        {
+            //printf("[SLAC_DB_Search_EvMac_idx]checking DB[%d]...\n", i);
+            if (Array_Compare_Identity(evcc->array[i].EvMac, EvMac_in, SLAC_EVMAC_LENGTH) == TRUE)
+            {
+                //printf("[SLAC_DB_Search_EvMac_idx]identical at DB[%d]...\n", i);
+                idx = i;
+                break;
+            }
+        }
+    }
+
+    //printf("[SLAC_DB_Search_EvMac_idx]return = %d\n", idx);
+    return idx;
+}
+
+/*===========================================================================
+FUNCTION: SLAC_DB_Check_EvMac_RunID_Matching
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+    res = FALSE (unmatched)
+    res = TRUE  (matched)
+GLOBAL VARIABLES:
+=============================================================================*/
+int SLAC_DB_Check_EvMac_RunID_Matching(struct EVCC_SLAC_DATA_TYPE *evcc, unsigned char *EvMac_in, unsigned char *RunID_in)
+{
+    int res = FALSE;
+    int idx = -1;
+
+    idx = SLAC_DB_Search_EvMac_idx(evcc, EvMac_in);
+
+    if (idx >= 0)
+    {
+        res = Array_Compare_Identity(evcc->array[idx].RunID, RunID_in, SLAC_RUNID_LENGTH);
+    }
+    else
+    {
+        //not found the EvMac data in DB
+        res = FALSE;
+    }
+
+    return res;
+}
+
+/*===========================================================================
+FUNCTION: SLAC_DB_Add
+DESCRIPTION:
+    1. Saving each CM_SLAC_PARM_REQ data into EVCC database if its
+       EvMac and RunID data are different, respectively.
+
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+    idx = saved index (must be a positive value)
+GLOBAL VARIABLES:
+=============================================================================*/
+int SLAC_DB_Add(unsigned char *EvMac_in, unsigned char *RunID_in)
+{
+    int idx = -1;
+
+    //Search if this EvMac and RunID already exists
+    idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
+
+    if (idx < 0)   //not exist, yet.
+    {
+        if (SLAC_INFO.arrayLen < EVCC_SLAC_DATA_ARRAY_TYPE_ARRAY_SIZE)  //20
+        {
+            sprintf(buf_log_evcomm,
+                    "[SLAC_DB_Add]data does not exist => added to %d-th",
+                    SLAC_INFO.arrayLen);
+            DEBUG_PRINTF_EVCOMM_DETAIL(buf_log_evcomm);
+
+            if (SLAC_INFO.arrayLen >= 0)
+            {
+                memset(&SLAC_INFO.array[SLAC_INFO.arrayLen], 0, sizeof(struct EVCC_SLAC_DATA_ARRAY_TYPE));
+                memcpy(SLAC_INFO.array[SLAC_INFO.arrayLen].EvMac, EvMac_in, SLAC_EVMAC_LENGTH);
+                memcpy(SLAC_INFO.array[SLAC_INFO.arrayLen].RunID, RunID_in, SLAC_RUNID_LENGTH);
+                idx = SLAC_INFO.arrayLen;
+                SLAC_INFO.arrayLen++;
+            }
+            else
+            {
+                sprintf(buf_log_evcomm,
+                        "[ERROR][SLAC_DB_Add]arrayLen: unexpected(%d)",
+                        SLAC_INFO.arrayLen);
+                DEBUG_PRINTF_EVCOMM_DETAIL(buf_log_evcomm);
+
+                SLAC_INFO.arrayLen = 0;
+            }
+        }
+        else
+        {
+            //DB is full
+            sprintf(buf_log_evcomm,
+                    "[SLAC_DB_Add]DB is full(%d) => bypass",
+                    SLAC_INFO.arrayLen);
+            DEBUG_PRINTF_EVCOMM_DETAIL(buf_log_evcomm);
+        }
+    }
+    else
+    {
+        #if 0
+        sprintf(buf_log_evcomm,
+                "[SLAC_DB_Add]EvMac: existed (%d)",
+                idx);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #endif
+
+        //Check RunID
+        if (Array_Compare_Identity(SLAC_INFO.array[idx].RunID, RunID_in, SLAC_RUNID_LENGTH) == TRUE)
+        {
+            //RunID is the same
+            //SAVE_SYS_LOG_MSG_EVCOMM("[SLAC_DB_Add]RunID: same");
+        }
+        else
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[SLAC_DB_Add]RunID: diff");
+        }
+
+        //Reset all corresponding parameters
+        #if 0
+        sprintf(buf_log_evcomm,
+                "[SLAC_DB_Add]EvMac: reset para(%d)",
+                idx);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #endif
+
+        memset(&SLAC_INFO.array[idx], 0, sizeof(struct EVCC_SLAC_DATA_ARRAY_TYPE));
+        memcpy(SLAC_INFO.array[idx].EvMac, EvMac_in, SLAC_EVMAC_LENGTH);
+        memcpy(SLAC_INFO.array[idx].RunID, RunID_in, SLAC_RUNID_LENGTH);
+    }
+    return idx;
+}
+
+/*===========================================================================
+FUNCTION: SLAC_DB_Reset
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int SLAC_DB_Reset()
+{
+    memset(&SLAC_INFO, 0, sizeof(struct EVCC_SLAC_DATA_TYPE));
+    SAVE_SYS_LOG_MSG_EVCOMM("[SLAC_DB_Reset]DONE");
+}
+
+
+/*===========================================================================
+FUNCTION: MmeProcess
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int MmeProcess(unsigned char *Buffer, int DataLength)
+{
+	//struct ethhdr	*EthPacket;
+	struct MmeHeader *MmePacket;
+	static unsigned char counter;
+	unsigned char state = 0;
+	unsigned char *EvMac_in;
+	unsigned char *RunID_in;
+	int Rtn = 0;
+	int idx = 0;
+
+	MmePacket = (struct MmeHeader *)Buffer;
+	state = Check_V2G_Flow_Status();
+
+	#if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+	{
+		DEBUG_PRINTF_EVCOMM_DETAIL("\n\n***********************************\n");
+		DEBUG_PRINTF_EVCOMM_DETAIL("***** Received MME Packet *****\n");
+		DEBUG_PRINTF_EVCOMM_DETAIL("***********************************\n");
+		DEBUG_PRINTF_EVCOMM_DETAIL("DataLength=%d\n",DataLength);
+		DEBUG_PRINTF_EVCOMM_DETAIL("ODA: %02x:%02x:%02x:%02x:%02x:%02x\n", //Destination MAC Address
+		MmePacket->ODA[0], MmePacket->ODA[1],
+		MmePacket->ODA[2], MmePacket->ODA[3],
+		MmePacket->ODA[4], MmePacket->ODA[5]);
+		DEBUG_PRINTF_EVCOMM_DETAIL("OSA: %02x:%02x:%02x:%02x:%02x:%02x\n", //Source MAC Address (EV MAC)
+		MmePacket->OSA[0], MmePacket->OSA[1],
+		MmePacket->OSA[2], MmePacket->OSA[3],
+		MmePacket->OSA[4], MmePacket->OSA[5]);
+		DEBUG_PRINTF_EVCOMM_DETAIL("MTYPE: 0x%x\n", htons(MmePacket->MTYPE));
+		DEBUG_PRINTF_EVCOMM_DETAIL("MMV: 0x%x\n", MmePacket->MMV);
+		DEBUG_PRINTF_EVCOMM_DETAIL("MMTYPE: 0x%x\n", MmePacket->MMTYPE);
+		DEBUG_PRINTF_EVCOMM_DETAIL("FMI 0x%x, 0x%x\n",
+		MmePacket->FMI[0],MmePacket->FMI[1]);
+	}
+	#endif
+
+	#if (SLAC_FIRST_RESPONSE_METHOD == SET_NO_PWM_IF_NOT_GET_PERMISSION)
+	{
+		//Check CP as 5%
+		if (EVCOMM_SYS_INFO.CpState != 3 &&
+		EVCOMM_SYS_INFO.CpState != 4 &&
+		MmePacket->MMTYPE != MMTYPE_CM_SET_KEY_CNF &&
+		MmePacket->MMTYPE != MMTYPE_VENDOR_VS_HOST_ACTION &&
+		MmePacket->MMTYPE != MMTYPE_VENDOR_ATTEN_CHAR &&
+		MmePacket->MMTYPE != MMTYPE_VENDOR_VS_NW_INFO_CNF
+		)
+		{
+			//SAVE_SYS_LOG_MSG_EVCOMM("[SLAC]ignored(wrong CP state)");
+			return 0;
+		}
+	}
+	#endif
+
+    	//[To-Do] Adding a pre-check filter mechanism for Source and Destination MAC Address
+
+    	//check if the destination address is broadcast or EVSE itself, it can be ignore if not belong to itself.
+	switch(MmePacket->MMTYPE)
+	{
+	    	case MMTYPE_CM_SET_KEY_CNF:
+		{
+		        DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_SET_KEY_CNF ---\n");
+		        DEBUG_PRINTF_EVCOMM_DETAIL("Result: 0x%x\n", MmePacket->MMENTRY[0]);
+		
+		        SAVE_SYS_LOG_MSG_EVCOMM("[QCA7K][Rx]CM_SET_KEY_CNF (SetKey: DONE)");
+		        Update_V2G_Flow_Status(CM_SET_KEY_CNF);
+		        break;
+		}
+	    case MMTYPE_CM_SLAC_PARM_REQ:
+		{
+		        //Check QCA7000 status
+		        if (EVCOMM_SYS_INFO.QCA7K_SetKeyDone == FALSE)
+		        {
+		            //SAVE_SYS_LOG_MSG_EVCOMM("[SLAC][Rx]CM_SLAC_PARM_REQ: ignored(QCA7K init...)");
+		            break;
+		        }
+	
+		        //Check error state
+		        state = Check_V2G_Flow_Status();
+		        if (state == Performance_Timeout ||     //253
+		            state == Sequence_Timeout ||        //254
+		            state == Other_Fault)               //255
+		        {
+		            SAVE_SYS_LOG_MSG_EVCOMM("[SLAC][Rx]CM_SLAC_PARM_REQ: ignored(in error state)");
+					break;
+		        }
+	
+		        //Printing EV MAC Address
+		        SAVE_SYS_LOG_MSG_EVCOMM("[SLAC][Rx]CM_SLAC_PARM_REQ");
+	
+		        //Avoid Coupled SLAC_PARM_REQ
+		        if (CheckConnectorPlugIn() == FALSE)  //12V(State 1)
+		        {
+		            #if 0
+		            sprintf(buf_log_evcomm,
+		                    "[WARNING][SLAC][Rx]CM_SLAC_PARM_REQ: ignored(coupled SLAC,%d)",
+		                    CheckConnectorPlugIn());
+		            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		            #endif
+		            break;
+		        }
+	
+		        //[TC_SECC_VTB_CmSlacParm_003] SECURITY_TYPE needs to be 0x00 (no security)
+		        if (MmePacket->MMENTRY[1] != 0)
+		        {
+		            sprintf(buf_log_evcomm,
+		                    "[WARNING][SLAC][Rx]CM_SLAC_PARM_REQ: ignored(invalid SECURITY_TYPE,%d)", //Source MAC Address (EV MAC)
+		                    MmePacket->MMENTRY[1]);
+		            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		            break;
+		        }
+	
+	       		 //=================== Legal CM_SLAC_PARM_REQ Zone =================
+	
+	       		 Update_V2G_Flow_Status(CM_SLAC_PARM_REQ);
+	
+		        #if (SLAC_FIRST_RESPONSE_METHOD == SET_5_PWM_ONCE_RX_CM_SLAC_PARM_REQ)
+		        {
+		            //Once receiving CM_SLAC_PARM_REQ, set PWM as 5%
+		            SwitchCpStateE(DISABLE);
+		            OutputCpPwmDuty(5);
+		        }
+		        #endif
+	
+		        //Checking if this SLAC Req comes before 5% PWM (for 15118)
+		        if(ShmInternalComm->ChargingPermission == FALSE)
+		        {
+		            //Sniffer_Tcpdump(ENABLE);
+		            sprintf(buf_log_evcomm, "Check Permission: %d (SLAC first => START)", ShmInternalComm->ChargingPermission);
+		            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		        }
+	
+		        #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+		        {
+		            DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_SLAC_PARM_REQ ---\n");
+		            DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
+		            DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
+		            DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+		                MmePacket->MMENTRY[2], MmePacket->MMENTRY[3],
+		                MmePacket->MMENTRY[4], MmePacket->MMENTRY[5],
+		                MmePacket->MMENTRY[6], MmePacket->MMENTRY[7],
+		                MmePacket->MMENTRY[8], MmePacket->MMENTRY[9]);
+		            DEBUG_PRINTF_EVCOMM_DETAIL("CipherSuiteSetSize: 0x%x\n", MmePacket->MMENTRY[10]);
+		            DEBUG_PRINTF_EVCOMM_DETAIL("CipherSuite [1]: 0x%x,0x%x\n",
+		                MmePacket->MMENTRY[11], MmePacket->MMENTRY[12]);
+		        }
+		        #endif
+	
+		        #if (NEW_SLAC_ARCHITECTURE_SWITCH == ENABLE)
+		        {
+		            //Saving each CM_SLAC_PARM_REQ data into EVCC database
+		            EvMac_in = &MmePacket->OSA[0];
+		            RunID_in = &MmePacket->MMENTRY[2];
+		            idx = SLAC_DB_Add(EvMac_in, RunID_in); //(EvMac, RunID)
+		
+		            if (idx < 0)
+		            {
+		                sprintf(buf_log_evcomm,
+		                        "[WARNING][CM_SLAC_PARM_REQ]DB is full or errors occour(%d) => ignore",
+		                        idx);
+		                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		                break;
+		            }
+		
+		            //Select the 1st EV MAC address
+		            if (SLAC_INFO.arrayLen == 1)   //1st Req
+		            {
+		                #if 1
+		                sprintf(buf_log_evcomm,
+		                        "[SLAC][Rx]CM_SLAC_PARM_REQ[%d](%02X:%02X:%02X:%02X:%02X:%02X,%02X%02X%02X%02X%02X%02X%02X%02X):selected",
+		                        (idx + 1),
+		                        MmePacket->OSA[0], MmePacket->OSA[1], MmePacket->OSA[2], MmePacket->OSA[3], MmePacket->OSA[4], MmePacket->OSA[5],
+		                        MmePacket->MMENTRY[2], MmePacket->MMENTRY[3], MmePacket->MMENTRY[4], MmePacket->MMENTRY[5],
+		                        MmePacket->MMENTRY[6], MmePacket->MMENTRY[7], MmePacket->MMENTRY[8], MmePacket->MMENTRY[9]);
+		                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		                #endif
+		                /*
+		                sprintf(buf_log_evcomm,
+		                        "[SLAC][EVMAC][%d-th]%02X:%02X:%02X:%02X:%02X:%02X (selected)", //Source MAC Address (EV MAC)
+		                        SLAC_INFO.arrayLen,
+		                        MmePacket->OSA[0], MmePacket->OSA[1],
+		                        MmePacket->OSA[2], MmePacket->OSA[3],
+		                        MmePacket->OSA[4], MmePacket->OSA[5]);
+		                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		
+		                sprintf(buf_log_evcomm,
+		                        "[SLAC][RunID][%d-th]%02X%02X%02X%02X%02X%02X%02X%02X (selected)", //RunID (from EVCC)
+		                        SLAC_INFO.arrayLen,
+		                        MmePacket->MMENTRY[2], MmePacket->MMENTRY[3],
+		                        MmePacket->MMENTRY[4], MmePacket->MMENTRY[5],
+		                        MmePacket->MMENTRY[6], MmePacket->MMENTRY[7],
+		                        MmePacket->MMENTRY[8], MmePacket->MMENTRY[9]);
+		                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		                */
+		            }
+		            else    //2nd Req
+		            {
+		                #if 1
+		                sprintf(buf_log_evcomm,
+		                        "[SLAC][Rx]CM_SLAC_PARM_REQ[%d](%02X:%02X:%02X:%02X:%02X:%02X,%02X%02X%02X%02X%02X%02X%02X%02X):not selected",
+		                        (idx + 1),
+		                        MmePacket->OSA[0], MmePacket->OSA[1], MmePacket->OSA[2], MmePacket->OSA[3], MmePacket->OSA[4], MmePacket->OSA[5],
+		                        MmePacket->MMENTRY[2], MmePacket->MMENTRY[3], MmePacket->MMENTRY[4], MmePacket->MMENTRY[5],
+		                        MmePacket->MMENTRY[6], MmePacket->MMENTRY[7], MmePacket->MMENTRY[8], MmePacket->MMENTRY[9]);
+		                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		                #endif
+		                /*
+		                sprintf(buf_log_evcomm,
+		                        "[SLAC][EVMAC][%d-th]%02X:%02X:%02X:%02X:%02X:%02X (not selected)", //Source MAC Address (EV MAC)
+		                        SLAC_INFO.arrayLen,
+		                        MmePacket->OSA[0], MmePacket->OSA[1],
+		                        MmePacket->OSA[2], MmePacket->OSA[3],
+		                        MmePacket->OSA[4], MmePacket->OSA[5]);
+		                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		
+		                sprintf(buf_log_evcomm,
+		                        "[SLAC][RunID][%d-th]%02X%02X%02X%02X%02X%02X%02X%02X (not selected)", //RunID (from EVCC)
+		                        SLAC_INFO.arrayLen,
+		                        MmePacket->MMENTRY[2], MmePacket->MMENTRY[3],
+		                        MmePacket->MMENTRY[4], MmePacket->MMENTRY[5],
+		                        MmePacket->MMENTRY[6], MmePacket->MMENTRY[7],
+		                        MmePacket->MMENTRY[8], MmePacket->MMENTRY[9]);
+		                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		                */
+		            }
+		            memcpy(EvMac, MmePacket->OSA, sizeof(EvMac));
+		            memcpy(DestSocketAddress.sll_addr, MmePacket->OSA, SLAC_EVMAC_LENGTH);
+		            memcpy(SlacRunId, MmePacket->MMENTRY + 2, SLAC_RUNID_LENGTH);
+		            memset(&SendMmePacket, 0, sizeof(struct MmeHeader));
+		            memcpy(SendMmePacket.ODA, MmePacket->OSA, 6);
+		            memcpy(SendMmePacket.OSA, CsuMac, 6);
+		            SendMmePacket.MTYPE = htons(EtherType_HomePlug);
+		            SendMmePacket.MMV = MmePacket->MMV;
+		            SendMmePacket.MMTYPE = MMTYPE_CM_SLAC_PARM_CNF;
+		            SendMmePacket.FMI[0] = SendMmePacket.FMI[1] = 0;
+		            SendMmePacketSize = 0;
+		            memset(SendMmePacket.MMENTRY, 0xFF, 6); //M-SOUND_TARGET(6-byte:0xFFFFFFFFFFFF): Fixed value indicating that M-Sounds to be sent as Ethernet broadcast
+		            SendMmePacketSize += 6;
+		            SendMmePacket.MMENTRY[SendMmePacketSize++] = C_EV_match_MNBC; //NUM_SOUNDS(0x0A): Number of M-Sounds to be transmitted by the EV GP Station during the SLAC process
+		            SendMmePacket.MMENTRY[SendMmePacketSize++] = 6; //Time_Out(0x06): unit = 100ms
+		            SendMmePacket.MMENTRY[SendMmePacketSize++] = 0x01; //RESP_TYPE(0x01): Fixed value indicating Other GP station, 0x00 V HLE of the STA, 0x01 V Another GP STA, 0x02 V 0xFF V Reserved
+		            memcpy(SendMmePacket.MMENTRY + SendMmePacketSize, SLAC_INFO.array[idx].EvMac, 6); //FORWARDING_STA(MAC Address of the EV HLE)
+		            SendMmePacketSize += 6;
+		            SendMmePacket.MMENTRY[SendMmePacketSize++] = 0; //APPLICATION_TYPE(0x00): 0x00(PEV-EVSE Association), 0x01-0xFF(Reserved)
+		            SendMmePacket.MMENTRY[SendMmePacketSize++] = 0; //SECURITY_TYPE(0x00): 0x00(No Security), 0x01(Public Key Signature), 0x02-0xFF(Reserved)
+		            memcpy(SendMmePacket.MMENTRY + SendMmePacketSize, SlacRunId, SLAC_RUNID_LENGTH); //RunID (8-byte)
+		            SendMmePacketSize += SLAC_RUNID_LENGTH;
+		            SendMmePacketSize += 19;      //the size before MMENTRY
+		
+		            #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+		            {
+		                DEBUG_PRINTF_EVCOMM_DETAIL("\n\n***** Response MME Packet *****\n");
+		                DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.ODA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+		                       SendMmePacket.ODA[0],SendMmePacket.ODA[1],SendMmePacket.ODA[2],SendMmePacket.ODA[3],SendMmePacket.ODA[4],SendMmePacket.ODA[5]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.OSA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+		                       SendMmePacket.OSA[0],SendMmePacket.OSA[1],SendMmePacket.OSA[2],SendMmePacket.OSA[3],SendMmePacket.OSA[4],SendMmePacket.OSA[5]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("MTYPE: 0x%x\n", htons(SendMmePacket.MTYPE));
+		                DEBUG_PRINTF_EVCOMM_DETAIL("MMV: 0x%x\n", SendMmePacket.MMV);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("MMTYPE: 0x%x\n", SendMmePacket.MMTYPE);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("FMI 0x%x, 0x%x\n", SendMmePacket.FMI[0],SendMmePacket.FMI[1]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("--- CM_SLAC_PARM_CNF ---\n");
+		                DEBUG_PRINTF_EVCOMM_DETAIL("M-SOUND_TARGET: %02x:%02x:%02x:%02x:%02x:%02x\n",
+		                       SendMmePacket.MMENTRY[0],SendMmePacket.MMENTRY[1],SendMmePacket.MMENTRY[2],SendMmePacket.MMENTRY[3],
+		                       SendMmePacket.MMENTRY[4],SendMmePacket.MMENTRY[5]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("NUM_SOUNDS: 0x%x\n", SendMmePacket.MMENTRY[6]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("Time_Out: 0x%x\n", SendMmePacket.MMENTRY[7]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("RESP_TYPE: 0x%x\n", SendMmePacket.MMENTRY[8]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("M-FORWARDING_STA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+		                       SendMmePacket.MMENTRY[9],SendMmePacket.MMENTRY[10],SendMmePacket.MMENTRY[11],SendMmePacket.MMENTRY[12],
+		                       SendMmePacket.MMENTRY[13],SendMmePacket.MMENTRY[14]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", SendMmePacket.MMENTRY[15]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", SendMmePacket.MMENTRY[16]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+		                       SendMmePacket.MMENTRY[17],SendMmePacket.MMENTRY[18],SendMmePacket.MMENTRY[19],SendMmePacket.MMENTRY[20],
+		                       SendMmePacket.MMENTRY[21],SendMmePacket.MMENTRY[22],SendMmePacket.MMENTRY[23],SendMmePacket.MMENTRY[24]);
+		            }
+		            #endif
+		
+		            Update_V2G_Flow_Status(CM_SLAC_PARM_CONF);
+		            Rtn = sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+		
+		            DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacketSize=%d,Rtn=%d\n",SendMmePacketSize,Rtn);
+		
+		            ftime(&SeqStartTime);
+		            break;
+		        }
+		        #else
+		        {
+		            memcpy(EvMac, MmePacket->OSA, sizeof(EvMac));
+		            memcpy(DestSocketAddress.sll_addr, MmePacket->OSA, sizeof(EvMac));
+		            memcpy(SlacRunId,MmePacket->MMENTRY + 2, sizeof(SlacRunId));
+		            memset(&SendMmePacket, 0, sizeof(struct MmeHeader));
+		            memcpy(SendMmePacket.ODA, MmePacket->OSA, 6);
+		            memcpy(SendMmePacket.OSA, CsuMac, 6);
+		            SendMmePacket.MTYPE = htons(EtherType_HomePlug);
+		            SendMmePacket.MMV = MmePacket->MMV;
+		            SendMmePacket.MMTYPE = MMTYPE_CM_SLAC_PARM_CNF;
+		            SendMmePacket.FMI[0] = SendMmePacket.FMI[1] = 0;
+		            SendMmePacketSize = 0;
+		            memset(SendMmePacket.MMENTRY, 0xFF, 6); //M-SOUND_TARGET(6-byte:0xFFFFFFFFFFFF): Fixed value indicating that M-Sounds to be sent as Ethernet broadcast
+		            SendMmePacketSize += 6;
+		            SendMmePacket.MMENTRY[SendMmePacketSize++] = C_EV_match_MNBC; //NUM_SOUNDS(0x0A): Number of M-Sounds to be transmitted by the EV GP Station during the SLAC process
+		            SendMmePacket.MMENTRY[SendMmePacketSize++] = 6; //Time_Out(0x06): unit = 100ms
+		            SendMmePacket.MMENTRY[SendMmePacketSize++] = 0x01; //RESP_TYPE(0x01): Fixed value indicating Other GP station, 0x00 V HLE of the STA, 0x01 V Another GP STA, 0x02 V 0xFF V Reserved
+		            memcpy(SendMmePacket.MMENTRY + SendMmePacketSize, EvMac, 6); //FORWARDING_STA(MAC Address of the EV HLE)
+		            SendMmePacketSize += 6;
+		            SendMmePacket.MMENTRY[SendMmePacketSize++] = 0; //APPLICATION_TYPE(0x00): 0x00(PEV-EVSE Association), 0x01-0xFF(Reserved)
+		            SendMmePacket.MMENTRY[SendMmePacketSize++] = 0; //SECURITY_TYPE(0x00): 0x00(No Security), 0x01(Public Key Signature), 0x02-0xFF(Reserved)
+		            memcpy(SendMmePacket.MMENTRY + SendMmePacketSize, SlacRunId, sizeof(SlacRunId)); //RunID (8-byte)
+		            SendMmePacketSize += sizeof(SlacRunId);
+		            SendMmePacketSize += 19;      //the size before MMENTRY
+		
+		            #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+		            {
+		                DEBUG_PRINTF_EVCOMM_DETAIL("\n\n***** Response MME Packet *****\n");
+		                DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.ODA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+		                       SendMmePacket.ODA[0],SendMmePacket.ODA[1],SendMmePacket.ODA[2],SendMmePacket.ODA[3],SendMmePacket.ODA[4],SendMmePacket.ODA[5]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.OSA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+		                       SendMmePacket.OSA[0],SendMmePacket.OSA[1],SendMmePacket.OSA[2],SendMmePacket.OSA[3],SendMmePacket.OSA[4],SendMmePacket.OSA[5]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("MTYPE: 0x%x\n", htons(SendMmePacket.MTYPE));
+		                DEBUG_PRINTF_EVCOMM_DETAIL("MMV: 0x%x\n", SendMmePacket.MMV);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("MMTYPE: 0x%x\n", SendMmePacket.MMTYPE);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("FMI 0x%x, 0x%x\n", SendMmePacket.FMI[0],SendMmePacket.FMI[1]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("--- CM_SLAC_PARM_CNF ---\n");
+		                DEBUG_PRINTF_EVCOMM_DETAIL("M-SOUND_TARGET: %02x:%02x:%02x:%02x:%02x:%02x\n",
+		                       SendMmePacket.MMENTRY[0],SendMmePacket.MMENTRY[1],SendMmePacket.MMENTRY[2],SendMmePacket.MMENTRY[3],
+		                       SendMmePacket.MMENTRY[4],SendMmePacket.MMENTRY[5]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("NUM_SOUNDS: 0x%x\n", SendMmePacket.MMENTRY[6]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("Time_Out: 0x%x\n", SendMmePacket.MMENTRY[7]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("RESP_TYPE: 0x%x\n", SendMmePacket.MMENTRY[8]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("M-FORWARDING_STA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+		                       SendMmePacket.MMENTRY[9],SendMmePacket.MMENTRY[10],SendMmePacket.MMENTRY[11],SendMmePacket.MMENTRY[12],
+		                       SendMmePacket.MMENTRY[13],SendMmePacket.MMENTRY[14]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", SendMmePacket.MMENTRY[15]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", SendMmePacket.MMENTRY[16]);
+		                DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+		                       SendMmePacket.MMENTRY[17],SendMmePacket.MMENTRY[18],SendMmePacket.MMENTRY[19],SendMmePacket.MMENTRY[20],
+		                       SendMmePacket.MMENTRY[21],SendMmePacket.MMENTRY[22],SendMmePacket.MMENTRY[23],SendMmePacket.MMENTRY[24]);
+		            }
+		            #endif
+		
+		            Rtn = sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+		            Update_V2G_Flow_Status(CM_SLAC_PARM_CONF);
+		
+		            DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacketSize=%d,Rtn=%d\n",SendMmePacketSize,Rtn);
+		
+		            ftime(&SeqStartTime);
+		            counter = 0;
+		            break;
+		        }
+		        #endif
+		}
+	    case MMTYPE_CM_START_ATTEN_CHAR_IND:
+		{
+		        if(V2gFlowStatus >= CM_ATTEN_CHAR_IND)
+		        {
+		            SAVE_SYS_LOG_MSG_EVCOMM("[WARNING][SLAC][Rx]CM_START_ATTEN_CHAR_IND: ignored(timeup)");
+		            break;
+		        }
+	
+		        //Avoid Coupled CM_START_ATTEN_CHAR_IND
+		        if (CheckConnectorPlugIn() == FALSE)  //12V(State 1)
+		        {
+		            sprintf(buf_log_evcomm,
+		                    "[WARNING][SLAC][Rx]CM_START_ATTEN_CHAR_IND: ignored(coupled SLAC,%d)",
+		                    CheckConnectorPlugIn());
+		            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		            break;
+		        }
+	
+		        #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+		        {
+		            DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_START_ATTEN_CHAR_IND (counter : %d/3 ) ---\n",counter + 1);
+		            DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
+		            DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
+		            DEBUG_PRINTF_EVCOMM_DETAIL("NUM_SOUNDS: 0x%x\n", MmePacket->MMENTRY[2]);
+		            DEBUG_PRINTF_EVCOMM_DETAIL("Time_Out 0x%x\n", MmePacket->MMENTRY[3]);
+		            DEBUG_PRINTF_EVCOMM_DETAIL("RESP_TYPE 0x%x\n", MmePacket->MMENTRY[4]);    //Fixed value (0x01) indicating other Green PHY station
+		            DEBUG_PRINTF_EVCOMM_DETAIL("FORWARDING_STA: %02x:%02x:%02x:%02x:%02x:%02x\n",
+		                   MmePacket->MMENTRY[5],MmePacket->MMENTRY[6],MmePacket->MMENTRY[7],MmePacket->MMENTRY[8],
+		                   MmePacket->MMENTRY[9],MmePacket->MMENTRY[10]);
+		            DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+		                   MmePacket->MMENTRY[11],MmePacket->MMENTRY[12],MmePacket->MMENTRY[13],MmePacket->MMENTRY[14],
+		                   MmePacket->MMENTRY[15],MmePacket->MMENTRY[16],MmePacket->MMENTRY[17],MmePacket->MMENTRY[18]);
+		        }
+		        #endif
+	
+	        //New SLAC architecture designed by Joseph
+	        #if (NEW_SLAC_ARCHITECTURE_SWITCH == ENABLE)
+	        {
+	            EvMac_in = &MmePacket->OSA[0];
+	            RunID_in = &MmePacket->MMENTRY[11];
+	            idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
+	
+	            if (idx >= 0)
+	            {
+	                Update_V2G_Flow_Status(CM_START_ATTEN_CHAR_IND);
+	
+	                //[TC_SECC_VTB_AttenuationCharacterization_013]
+	                if (MmePacket->MMENTRY[0] != 0) //APPLICATION_TYPE must be 0x00(EV-EVSE Matching)
+	                {
+	                    sprintf(buf_log_evcomm,
+	                            "[WARNING][SLAC][Rx][CM_START_ATTEN_CHAR_IND]APPLICATION_TYPE(%d): invalid => ignore Req",
+	                            MmePacket->MMENTRY[0]);
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                    break;
+	                }
+	
+	                //[TC_SECC_VTB_AttenuationCharacterization_014]
+	                if (MmePacket->MMENTRY[1] != 0) //SECURITY_TYPE must be 0x00(No Security)
+	                {
+	                    sprintf(buf_log_evcomm,
+	                            "[WARNING][SLAC][Rx][CM_START_ATTEN_CHAR_IND]SECURITY_TYPE(%d): invalid => ignore Req",
+	                            MmePacket->MMENTRY[1]);
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                    break;
+	                }
+			 //[TC_SECC_VTB_AttenuationCharacterization_016]
+	                if (MmePacket->MMENTRY[3] != 0x06) //Time_Out must be 0x06 , (600ms)
+	                {
+	                    sprintf(buf_log_evcomm,
+	                            "[WARNING][SLAC][Rx][CM_START_ATTEN_CHAR_IND]Time_Out(%d): invalid => ignore Req",
+	                            MmePacket->MMENTRY[3]);
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                    break;
+	                }
+	                
+	                //[TC_SECC_VTB_AttenuationCharacterization_017]
+	                if (MmePacket->MMENTRY[4] != 0x01) //RESP_TYPE must be 0x01(Send to another GP STA(EV))
+	                {
+	                    sprintf(buf_log_evcomm,
+	                            "[WARNING][SLAC][Rx][CM_START_ATTEN_CHAR_IND]RESP_TYPE(%d): invalid => ignore Req",
+	                            MmePacket->MMENTRY[4]);
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                    break;
+	                }
+	
+	                //[TC_SECC_VTB_AttenuationCharacterization_021]
+	                //FORWARDING_STA: MAC Address of the EV HLE (station which the measurement results shall be sent to)
+	                if (Array_Compare_Identity(EvMac_in, &MmePacket->MMENTRY[5], SLAC_EVMAC_LENGTH) == FALSE)
+	                {
+	                    sprintf(buf_log_evcomm,
+	                            "[WARNING][SLAC][Rx][CM_START_ATTEN_CHAR_IND]FORWARDING_STA(%02X:%02X:%02X:%02X:%02X:%02X): invalid => ignore Req",
+	                            MmePacket->MMENTRY[5], MmePacket->MMENTRY[6],
+	                            MmePacket->MMENTRY[7], MmePacket->MMENTRY[8],
+	                            MmePacket->MMENTRY[9], MmePacket->MMENTRY[10]);
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	
+	                    SLAC_INFO.array[idx].StartAttenCharErr = TRUE;
+	                    break;
+	                }
+	
+	                //Check RunID
+	                if (SLAC_DB_Check_EvMac_RunID_Matching(&SLAC_INFO, EvMac_in, RunID_in) == TRUE)
+	                {
+	                    SLAC_INFO.array[idx].MnbcSoundNum = MmePacket->MMENTRY[2];
+	                    SLAC_INFO.array[idx].StartAttenCharCnt++;
+	
+	                    #if 0
+	                    sprintf(buf_log_evcomm,
+	                            "[SLAC][Rx]CM_START_ATTEN_CHAR_IND[%d]:%d-th",
+	                            (idx + 1),
+	                            SLAC_INFO.array[idx].StartAttenCharCnt);
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                    #endif
+	
+	                    if (SLAC_INFO.array[idx].StartAttenCharCnt == 1)
+	                    {
+	                        memset(SLAC_INFO.array[idx].AAG, 0, sizeof(SLAC_INFO.array[idx].AAG));
+	                        SLAC_INFO.array[idx].AttenProfileCnt = 0;
+	                        ftime(&SeqStartTime);       //start TT_EVSE_match_MNBC
+	                    }
+	                    else if (SLAC_INFO.array[idx].StartAttenCharCnt >= 3)
+	                    {
+	                        sprintf(buf_log_evcomm,
+	                                "[WARNING][SLAC][Rx][CM_START_ATTEN_CHAR_IND]counter(%d): unexpected",
+	                                SLAC_INFO.array[idx].StartAttenCharCnt);
+	                    }
+	                    else
+	                    {
+	                        //null
+	                    }
+	                }
+	                else
+	                {
+	                    //This RunID is not matched with this EvMac,
+	                    //or this RunID is not found in DB.
+	                    sprintf(buf_log_evcomm,
+	                            "[WARNING][SLAC][Rx][CM_START_ATTEN_CHAR_IND]EvMac-RunID: unmatched => ignore Req");
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	
+	                    //Response: ignore
+	                }
+	            }
+	            else
+	            {
+	                //this msg source is not in database
+	                //ignore
+	            }
+	            break;
+	        }
+	        #else   //Old SLAC architecture designed by Vern
+	        {
+	            MnbcSoundNum = MmePacket->MMENTRY[2];
+	            Update_V2G_Flow_Status(CM_START_ATTEN_CHAR_IND);
+	            counter++;
+	            if(counter == 1)
+	            {
+	                memset(Aag, 0, sizeof(Aag));
+	                AttenProfileCnt = 0;
+	                ftime(&SeqStartTime);       //start TT_EVSE_match_MNBC
+	            }
+	            else if(counter >= 3)
+	            {
+	                counter = 0;
+	            }
+	            break;
+	        }
+	        #endif
+		}
+	
+	    case MMTYPE_CM_MNBC_SOUND_IND:
+		{
+	        if(V2gFlowStatus >= CM_ATTEN_CHAR_IND)
+	        {
+	            SAVE_SYS_LOG_MSG_EVCOMM("[WARNING][SLAC][Rx]CM_MNBC_SOUND_IND: ignored(timeup)");
+	            break;
+	        }
+	
+	        //Avoid Coupled CM_MNBC_SOUND_IND
+	        if (CheckConnectorPlugIn() == FALSE)  //12V(State 1)
+	        {
+	            sprintf(buf_log_evcomm,
+	                    "[WARNING][SLAC][Rx]CM_MNBC_SOUND_IND: ignored(coupled SLAC,%d)",
+	                    CheckConnectorPlugIn());
+	            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	            break;
+	        }
+	
+	        #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == TRUE)
+	        {
+	            DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_MNBC_SOUND_IND (counter : %d/%d) ---\n",counter + 1 , MnbcSoundNum);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("SenderID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	                   MmePacket->MMENTRY[2],MmePacket->MMENTRY[3],MmePacket->MMENTRY[4],MmePacket->MMENTRY[5],
+	                   MmePacket->MMENTRY[6],MmePacket->MMENTRY[7],MmePacket->MMENTRY[8],MmePacket->MMENTRY[9],
+	                   MmePacket->MMENTRY[10],MmePacket->MMENTRY[11],MmePacket->MMENTRY[12],MmePacket->MMENTRY[13],
+	                   MmePacket->MMENTRY[14],MmePacket->MMENTRY[15],MmePacket->MMENTRY[16],MmePacket->MMENTRY[17],
+	                   MmePacket->MMENTRY[18]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("Cnt: 0x%x\n", MmePacket->MMENTRY[19]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	                   MmePacket->MMENTRY[20],MmePacket->MMENTRY[21],MmePacket->MMENTRY[22],MmePacket->MMENTRY[23],
+	                   MmePacket->MMENTRY[24],MmePacket->MMENTRY[25],MmePacket->MMENTRY[26],MmePacket->MMENTRY[27]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("RSVD: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	                   MmePacket->MMENTRY[28],MmePacket->MMENTRY[29],MmePacket->MMENTRY[30],MmePacket->MMENTRY[31],
+	                   MmePacket->MMENTRY[32],MmePacket->MMENTRY[33],MmePacket->MMENTRY[34],MmePacket->MMENTRY[35]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("Rnd: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	                   MmePacket->MMENTRY[36],MmePacket->MMENTRY[37],MmePacket->MMENTRY[38],MmePacket->MMENTRY[39],
+	                   MmePacket->MMENTRY[40],MmePacket->MMENTRY[41],MmePacket->MMENTRY[42],MmePacket->MMENTRY[43],
+	                   MmePacket->MMENTRY[44],MmePacket->MMENTRY[45],MmePacket->MMENTRY[46],MmePacket->MMENTRY[47],
+	                   MmePacket->MMENTRY[48],MmePacket->MMENTRY[49],MmePacket->MMENTRY[50],MmePacket->MMENTRY[51]);
+	        }
+	        #endif
+	
+	
+	        //New SLAC architecture designed by Joseph
+	        #if (NEW_SLAC_ARCHITECTURE_SWITCH == ENABLE)
+	        {
+	            EvMac_in = &MmePacket->OSA[0];
+	            RunID_in = &MmePacket->MMENTRY[20];
+	            idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
+	
+	            if (idx >= 0)
+	            {
+	                Update_V2G_Flow_Status(CM_MNBC_SOUND_IND);
+	
+	                //Check for RunID
+	                if (SLAC_DB_Check_EvMac_RunID_Matching(&SLAC_INFO, EvMac_in, RunID_in) == TRUE)
+	                {
+	                    SLAC_INFO.array[idx].MnbcSoundCnt++;
+	
+	                    /*
+	                    sprintf(buf_log_evcomm,
+	                            "[SLAC][Rx]CM_MNBC_SOUND_IND[%d]:%d-th",
+	                            (idx + 1),
+	                            SLAC_INFO.array[idx].MnbcSoundCnt);
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                    */
+	                }
+	                else
+	                {
+	                    //RunID is not matched or does not exist.
+	                    sprintf(buf_log_evcomm,
+	                            "[WARNING][SLAC][Rx]CM_MNBC_SOUND_IND]EvMac-RunID: unmatched");
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                }
+	            }
+	            else
+	            {
+	                //ignore
+	                sprintf(buf_log_evcomm,
+	                        "[WARNING][SLAC][Rx]CM_MNBC_SOUND_IND]EvMac does not exist");
+	                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	            }
+	            break;
+	        }
+	        #else   //Old SLAC architecture designed by Vern
+	        {
+	            Update_V2G_Flow_Status(CM_MNBC_SOUND_IND);
+	            counter++;
+	            break;
+	        }
+	        #endif
+		}
+	
+	    case MMTYPE_CM_ATTEN_PROFILE_IND:
+		{
+	        if(V2gFlowStatus >= CM_ATTEN_CHAR_IND)
+	        {
+	            SAVE_SYS_LOG_MSG_EVCOMM("[WARNING][SLAC][Rx]CM_ATTEN_PROFILE_IND: ignore(timeup)");
+				break;
+			}
+	
+	        #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == TRUE)
+	        {
+	            DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_ATTEN_PROFILE_IND (counter : %d/%d) ---\n", counter, MnbcSoundNum);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("EV MAC: %02x:%02x:%02x:%02x:%02x:%02x\n",
+	                   MmePacket->MMENTRY[0], MmePacket->MMENTRY[1], MmePacket->MMENTRY[2], MmePacket->MMENTRY[3],
+	                   MmePacket->MMENTRY[4], MmePacket->MMENTRY[5]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("NumGroups: 0x%x\n", MmePacket->MMENTRY[6]);  //NumGroups, Number of AAG Groups (ex: 0x3A = 58)
+	            //NumGroups: Number of OFDM carrier groups used for the SLAC signal characterization.
+	            //AAG[i]: Average Attenuation of Group i (i = 1 ~ 58)
+	            DEBUG_PRINTF_EVCOMM_DETAIL("RSVD: 0x%x\n", MmePacket->MMENTRY[7]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("AAG: \n");
+	
+	            for(Rtn = 0; Rtn < MmePacket->MMENTRY[6]; Rtn++)
+	            {
+	                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[8 + Rtn]);
+	            }
+	            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	        }
+	        #endif
+	
+	        //New SLAC architecture designed by Joseph
+	        #if (NEW_SLAC_ARCHITECTURE_SWITCH == ENABLE)
+	        {
+	            EvMac_in = &MmePacket->MMENTRY[0]; //[CAUTION] The EvMac address is not &MmePacket->OSA[0]
+	            //[CAUTION] There is no RunID information of CM_ATTEN_PROFILE_IND
+	            //          packet, which means SECC cannot use the RunID to
+	            //          distinguish those SLAC request with identical EvMac
+	            //          but with different RunID.
+	            idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
+	
+	            /*
+	            printf("%d, %d, %d, %d\n",
+	                    idx,
+	                    SLAC_INFO.array[idx].AagGroupsNum,
+	                    MmePacket->MMENTRY[6],
+	                    SLAC_INFO.array[idx].AttenProfileCnt);
+	            */
+	
+	            if (idx >= 0)
+	            {
+	                SLAC_INFO.array[idx].AttenProfileCnt++;
+	
+	                /*
+	                sprintf(buf_log_evcomm,
+	                        "[SLAC][Rx]CM_ATTEN_PROFILE_IND[%d]:%d-th",
+	                        (idx + 1),
+	                        SLAC_INFO.array[idx].AttenProfileCnt);
+	                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                */
+	
+	                //printf("%d, %d\n", SLAC_INFO.array[idx].AagGroupsNum, MmePacket->MMENTRY[6]);
+	
+	                SLAC_INFO.array[idx].AagGroupsNum = MmePacket->MMENTRY[6];
+	                ////NumGroups, Number of AAG Groups (ex: 0x3A = 58)
+	
+	                for(Rtn = 0; Rtn < SLAC_INFO.array[idx].AagGroupsNum; Rtn++) //ex:58
+	                {
+	                    SLAC_INFO.array[idx].AAG[Rtn] += MmePacket->MMENTRY[8 + Rtn];
+	                }
+	
+	                Update_V2G_Flow_Status(CM_MNBC_SOUND_IND);
+	                break;
+	            }
+	            else
+	            {
+	                //The EvMac is not in the database
+	                //ignore
+	                sprintf(buf_log_evcomm,
+	                        "[SLAC][Rx][CM_ATTEN_PROFILE_IND]EvMac(%02X%02X%02X%02X%02X%02X): not exist => ignore",
+	                        EvMac_in[0], EvMac_in[1], EvMac_in[2], EvMac_in[3], EvMac_in[4], EvMac_in[5]);
+	                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                break;
+	            }
+	        }
+	        #else   //Old SLAC architecture designed by Vern
+	        {
+	            AagGroupsNum = MmePacket->MMENTRY[6];
+	            for(Rtn = 0; Rtn < MmePacket->MMENTRY[6]; Rtn++)
+	            {
+	                Aag[Rtn] += MmePacket->MMENTRY[8 + Rtn];
+	            }
+	            AttenProfileCnt++;
+	            Update_V2G_Flow_Status(CM_MNBC_SOUND_IND);
+	            break;
+	        }
+	        #endif
+		}
+	
+	    case MMTYPE_CM_ATTEN_CHAR_RSP:
+		{
+	        #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+	        {
+	            DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_ATTEN_CHAR_RSP ---\n");
+	            DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("SOURCE_ADDRESS: %02x:%02x:%02x:%02x:%02x:%02x\n",
+	                   MmePacket->MMENTRY[2],MmePacket->MMENTRY[3],MmePacket->MMENTRY[4],MmePacket->MMENTRY[5],
+	                   MmePacket->MMENTRY[6],MmePacket->MMENTRY[7]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+	                   MmePacket->MMENTRY[8],MmePacket->MMENTRY[9],MmePacket->MMENTRY[10],MmePacket->MMENTRY[11],
+	                   MmePacket->MMENTRY[12],MmePacket->MMENTRY[13],MmePacket->MMENTRY[14],MmePacket->MMENTRY[15]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("SOURCE_ID: \n");
+	            for(Rtn = 0; Rtn < 17; Rtn++)
+	            {
+	                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[16 + Rtn]);
+	            }
+	            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	            DEBUG_PRINTF_EVCOMM_DETAIL("RESP_ID: \n");
+	            for(Rtn = 0; Rtn < 17; Rtn++)
+	            {
+	                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[33 + Rtn]);
+	            }
+	            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	            DEBUG_PRINTF_EVCOMM_DETAIL("Result: 0x%x\n", MmePacket->MMENTRY[50]);    //Fixed value of 0x00 indicates a successful SLAC process
+	        }
+	        #endif
+	
+	        #if (NEW_SLAC_ARCHITECTURE_SWITCH == ENABLE)
+	        {
+	            //Check ODA (Destination Address)
+	            if (Array_Compare_Identity(CsuMac, MmePacket->ODA, SLAC_EVSE_MAC_LENGTH) == FALSE)
+	            {
+	                SAVE_SYS_LOG_MSG_EVCOMM("[SLAC][Rx][CM_ATTEN_CHAR_RSP]wrong ODA: ignore");
+	                break;
+	            }
+	
+	            EvMac_in = &MmePacket->OSA[0];
+	            RunID_in = &MmePacket->MMENTRY[8];
+	            idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
+	
+	            //Check Parameters
+	            if ((MmePacket->MMENTRY[0] != 0) ||   //[TC_SECC_VTB_AttenuationCharacterization_005] applicationType must be 0x00
+	                (MmePacket->MMENTRY[1] != 0) ||   //[TC_SECC_VTB_AttenuationCharacterization_006] securityType must be 0x00
+	                (SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in) < 0) || //[TC_SECC_VTB_AttenuationCharacterization_007] sourceAddress cannot not be all zero
+	                (SLAC_DB_Check_EvMac_RunID_Matching(&SLAC_INFO, EvMac_in, RunID_in) == FALSE) ||    //[TC_SECC_VTB_AttenuationCharacterization_008] check for invalid runID
+	                (Array_Check_All_Zero(&MmePacket->MMENTRY[16], 17) == FALSE) ||  //[TC_SECC_VTB_AttenuationCharacterization_009] SourceID(17 bytes) must be all zero.
+	                (Array_Check_All_Zero(&MmePacket->MMENTRY[33], 17) == FALSE) ||  //[TC_SECC_VTB_AttenuationCharacterization_009] RESP_ID (17 bytes) must be all zero.
+	                (MmePacket->MMENTRY[50] != 0)   //Result:  must be 0x00(Success)
+	                )
+	            {
+	                EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry++;
+	
+	                sprintf(buf_log_evcomm,
+	                        "[WARNING][SLAC][Rx]CM_ATTEN_CHAR_RSP:invalid para(%d,%d,%d,%d,%d) => %d-th retry",
+	                        MmePacket->MMENTRY[0],  //applicationType must be 0x00
+	                        MmePacket->MMENTRY[1],  //securityType must be 0x00
+	                        SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in),
+	                        SLAC_DB_Check_EvMac_RunID_Matching(&SLAC_INFO, EvMac_in, RunID_in),
+	                        MmePacket->MMENTRY[50],
+	                        EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry
+	                        );
+	                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	
+	                if (EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry <= 2)   //limited to 2 retries
+	                {
+	                    Update_V2G_Flow_Status(CM_MNBC_SOUND_IND);
+	                    ftime(&SeqStartTime);
+	                    break;
+	                }
+	                else
+	                {
+	                    SAVE_SYS_LOG_MSG_EVCOMM("[ERROR][SLAC][Rx]CM_ATTEN_CHAR_RSP:invalid para => 2-retry fail => End_Process");
+	                    Update_V2G_Flow_Status(Other_Fault);
+	                    break;
+	                }
+	            }
+	            else
+	            {
+	                //The CM_ATTEN_CHAR_IND is legal
+	                SLAC_INFO.array[idx].AttenCharRspCnt++;
+	
+	                sprintf(buf_log_evcomm,
+	                        "[SLAC][Rx]CM_ATTEN_CHAR_RSP[%d]:%d-th",
+	                        (idx + 1),
+	                        SLAC_INFO.array[idx].AttenCharRspCnt);
+	                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	
+	                EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry = 0;
+	                Update_V2G_Flow_Status(CM_ATTEN_CHAR_RSP);
+	                ftime(&SeqStartTime);
+	                break;
+	            }
+	        }
+	        #else
+	        {
+	            //Check Parameters
+	            if ((MmePacket->MMENTRY[0] != 0) ||   //[TC_SECC_VTB_AttenuationCharacterization_005] applicationType must be 0x00
+	                (MmePacket->MMENTRY[1] != 0) ||   //[TC_SECC_VTB_AttenuationCharacterization_006] securityType must be 0x00
+	                (Array_Compare_Identity(SLAC_INFO.array[0].EvMac, &MmePacket->MMENTRY[2], 6) == TRUE) || //[TC_SECC_VTB_AttenuationCharacterization_007] sourceAddress cannot not be all zero
+	                (Array_Compare_Identity(SLAC_INFO.array[0].RunID, &MmePacket->MMENTRY[8], 8) == TRUE)    //[TC_SECC_VTB_AttenuationCharacterization_008] check for invalid runID
+	                )
+	            {
+	                EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry++;
+	
+	                sprintf(buf_log_evcomm,
+	                        "[WARNING][SLAC][Rx]CM_ATTEN_CHAR_RSP: invalid parameters(%d-th)",
+	                        EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry);
+	                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	
+	                if (EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry <= 2)   //limited to 2 retries
+	                {
+	                    Update_V2G_Flow_Status(CM_MNBC_SOUND_IND);
+	                    ftime(&SeqStartTime);
+	                    break;
+	                }
+	                else
+	                {
+	                    SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]CM_ATTEN_CHAR_RSP: invalid parameters => End_Process");
+	                    Update_V2G_Flow_Status(Other_Fault);
+	                    ftime(&SeqStartTime);
+	                    break;
+	                }
+	            }
+	            else
+	            {
+	                EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry = 0;
+	                Update_V2G_Flow_Status(CM_ATTEN_CHAR_RSP);
+	                ftime(&SeqStartTime);
+	                break;
+	            }
+	        }
+	        #endif
+		}
+	
+	    case MMTYPE_CM_VALIDATE_REQ:   //BCB Toggle
+		{
+	        #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+	        {
+	            DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_VALIDATE_REQ ---\n");
+	            DEBUG_PRINTF_EVCOMM_DETAIL("Signal Type: 0x%x\n", MmePacket->MMENTRY[0]);    //Fixed value (0x00) to indicate ��PEV S2 toggles on control pilot line��
+	            DEBUG_PRINTF_EVCOMM_DETAIL("Timer: 0x%x\n", MmePacket->MMENTRY[1]);    //Fixed value In the first VALIDATE Request-Response exchange, the Timer field shall be set to zero.
+	            DEBUG_PRINTF_EVCOMM_DETAIL("Result: 0x%x\n", MmePacket->MMENTRY[2]);    //Fixed value In the first VALIDATE Request-Response exchange, the Result field shall be set to 0x01 = ��ready��.
+	        }
+	        #endif
+	
+	        #if (NEW_SLAC_ARCHITECTURE_SWITCH == ENABLE)
+	        {
+	            counter = 0;
+	
+	            EvMac_in = &MmePacket->OSA[0];
+	            idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
+	
+	            if (idx >= 0)
+	            {
+	                Update_V2G_Flow_Status(CM_VALIDATE_CNF);
+	                SLAC_INFO.array[idx].ValidateReqCnt++;
+	
+	                sprintf(buf_log_evcomm,
+	                        "[SLAC][Rx]CM_VALIDATE_REQ[%d]:%d-th",
+	                        (idx + 1),
+	                        SLAC_INFO.array[idx].ValidateReqCnt);
+	                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	
+	
+	                //[To-Do] Protection
+	
+	
+	                memset(&SendMmePacket, 0, sizeof(struct MmeHeader));
+	                memcpy(SendMmePacket.ODA, EvMac_in, SLAC_EVMAC_LENGTH);
+	                memcpy(SendMmePacket.OSA, CsuMac, 6);
+	                SendMmePacket.MTYPE = htons(EtherType_HomePlug);
+	                SendMmePacket.MMV = 0x01;
+	                SendMmePacket.MMTYPE = MMTYPE_CM_VALIDATE_CNF;
+	                SendMmePacket.FMI[0] = SendMmePacket.FMI[1] = 0;
+	                SendMmePacketSize = 0;
+	
+	                if(counter == 0)
+	                {
+	                    //The First MMTYPE_CM_VALIDATE_REQ because Unicast
+	                    SendMmePacket.MMENTRY[SendMmePacketSize++] = 0;    //SignalType(0x00): Fixed value to indicate "EV S2 toggles on control pilot line"
+	                    SendMmePacket.MMENTRY[SendMmePacketSize++] = 0;    //ToggleNum(0x00): Fixed value. In the first VALIDATE Request-Response exchange, the ToggleNum field shall be set to zero.
+	
+	                    #if (SUPPORT_BCB_TOGGLE_FUNCTION == ENABLE)
+	                        SendMmePacket.MMENTRY[SendMmePacketSize++] = 1;    //0x01 = Ready
+	                    #else
+	                        SendMmePacket.MMENTRY[SendMmePacketSize++] = 4;    //0x04 = Not Required
+	                    #endif
+	                }
+	                else
+	                {
+	                    //The Second MMTYPE_CM_VALIDATE_REQ because Broadcast
+	                    unsigned char PreStatus = 3;
+	                    unsigned char ToggleNum = 0;
+	                    ftime(&SeqStartTime);
+	                    while(1)
+	                    {
+	                        if((EVCOMM_SYS_INFO.CpState == 4) && (PreStatus == 3))
+	                        {
+	                            ToggleNum++;
+	                            PreStatus = 4;
+	                        }
+	                        else
+	                        {
+	                            PreStatus = 3;
+	                        }
+	
+	                        ftime(&SeqEndTime);
+	                        if((DiffTimeb(SeqStartTime, SeqEndTime) >= (SendMmePacket.MMENTRY[1]*100 + 100))||(EVCOMM_SYS_INFO.CpState == 1))
+	                        {
+	                            SendMmePacket.MMENTRY[SendMmePacketSize++] = 0;    //Fixed value to indicate "PEV S2 toggles on control pilot line"
+	                            SendMmePacket.MMENTRY[SendMmePacketSize++] = ToggleNum;
+	
+	                            #if (SUPPORT_BCB_TOGGLE_FUNCTION == ENABLE)
+	                            	if(ToggleNum==0)
+	                            		SendMmePacket.MMENTRY[SendMmePacketSize++] = 3;    //0x02 = Failure
+	                            	else	
+	                                	SendMmePacket.MMENTRY[SendMmePacketSize++] = 2;    //0x02 = Success
+	                            #else
+	                             	SendMmePacket.MMENTRY[SendMmePacketSize++] = 4;    //0x04 = Not Required
+	                            #endif
+	
+	                            break;
+	                        }
+	                    }
+	                }
+	                SendMmePacketSize += 19;      //the size before MMENTRY
+	                Rtn = sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+	                ftime(&SeqStartTime);
+	            }
+	            else
+	            {
+	                //EvMac does not exist.
+	                //ignore
+	            }
+	            break;
+	        }
+	        #else
+	        {
+	            counter = 0;
+	
+	            for(Rtn = 0; Rtn < 6; Rtn++)
+	            {
+	                if(MmePacket->ODA[Rtn] != CsuMac[Rtn])
+	                {
+	                    counter = 1;
+	                    break;
+	                }
+	            }
+	
+	            memset(&SendMmePacket, 0, sizeof(struct MmeHeader));
+	            memcpy(SendMmePacket.ODA, EvMac,6);
+	            memcpy(SendMmePacket.OSA, CsuMac,6);
+	            SendMmePacket.MTYPE = htons(EtherType_HomePlug);
+	            SendMmePacket.MMV = 0x01;
+	            SendMmePacket.MMTYPE = MMTYPE_CM_VALIDATE_CNF;
+	            SendMmePacket.FMI[0] = SendMmePacket.FMI[1] = 0;
+	            SendMmePacketSize = 0;
+	            if(counter == 0)
+	            {
+	                //The First MMTYPE_CM_VALIDATE_REQ because Unicast
+	                SendMmePacket.MMENTRY[SendMmePacketSize++] = 0;    //Fixed value to indicate PEV S2 toggles on control pilot line
+	                SendMmePacket.MMENTRY[SendMmePacketSize++] = 0;    //Fixed value In the first VALIDATE Request-Response exchange, the ToggleNum field shall be set to zero.
+	                #if (SUPPORT_BCB_TOGGLE_FUNCTION == ENABLE)
+	                SendMmePacket.MMENTRY[SendMmePacketSize++] = 1;    //0x01 = Ready
+	                #else
+	                SendMmePacket.MMENTRY[SendMmePacketSize++] = 4;    //0x04 = Not Required
+	                #endif
+	            }
+	            else
+	            {
+	                //The Second MMTYPE_CM_VALIDATE_REQ because Broadcast
+	                unsigned char PreStatus = 3, ToggleNum = 0;
+	                ftime(&SeqStartTime);
+	                while(1)
+	                {
+	                    ftime(&SeqEndTime);
+	                    if((EVCOMM_SYS_INFO.CpState == 4) && (PreStatus == 3))
+	                    {
+	                        ToggleNum++;
+	                        PreStatus = 4;
+	                    }
+	                    else
+	                    {
+	                        PreStatus = 3;
+	                    }
+	                    if(DiffTimeb(SeqStartTime, SeqEndTime) >= (SendMmePacket.MMENTRY[1]*100 + 100))
+	                    {
+	                        SendMmePacket.MMENTRY[SendMmePacketSize++] = 0;    //Fixed value to indicate ��PEV S2 toggles on control pilot line��
+	                        SendMmePacket.MMENTRY[SendMmePacketSize++] = ToggleNum;
+	                        #if (SUPPORT_BCB_TOGGLE_FUNCTION == ENABLE)
+	                        SendMmePacket.MMENTRY[SendMmePacketSize++] = 2;    //0x02 = Success
+	                        #else
+	                        SendMmePacket.MMENTRY[SendMmePacketSize++] = 4;    //0x04 = Not Required
+	                        #endif
+	                        break;
+	                    }
+	                }
+	            }
+	            SendMmePacketSize += 19;      //the size before MMENTRY
+	            Rtn = sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+	            Update_V2G_Flow_Status(CM_VALIDATE_CNF);
+	            ftime(&SeqStartTime);
+	            break;
+	        }
+	        #endif
+		}
+	
+	    case MMTYPE_CM_SLAC_MATCH_REQ:
+		{
+	        #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+	        {
+	            DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_SLAC_MATCH_REQ ---\n");
+	            DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
+	            DEBUG_PRINTF_EVCOMM_DETAIL("MVFLength: 0x%x, 0x%x\n", MmePacket->MMENTRY[2],MmePacket->MMENTRY[3]);    //Fixed value (0x3E) for matching
+	            DEBUG_PRINTF_EVCOMM_DETAIL("PEV ID: \n");
+	            for(Rtn=0; Rtn<17; Rtn++)
+	            {
+	                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[4+Rtn]);
+	            }
+	            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	            DEBUG_PRINTF_EVCOMM_DETAIL("PEV MAC: \n");
+	            for(Rtn=0; Rtn<6; Rtn++)
+	            {
+	                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[21+Rtn]);
+	            }
+	            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	            DEBUG_PRINTF_EVCOMM_DETAIL("EVSE ID: \n");
+	            for(Rtn=0; Rtn<17; Rtn++)
+	            {
+	                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[27+Rtn]);
+	            }
+	            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	            DEBUG_PRINTF_EVCOMM_DETAIL("EVSE MAC: \n");
+	            for(Rtn=0; Rtn<6; Rtn++)
+	            {
+	                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[44+Rtn]);
+	            }
+	            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	            DEBUG_PRINTF_EVCOMM_DETAIL("RunID: \n");
+	            for(Rtn=0; Rtn<8; Rtn++)
+	            {
+	                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[50+Rtn]);
+	            }
+	            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	            DEBUG_PRINTF_EVCOMM_DETAIL("RSVD: \n");
+	            for(Rtn=0; Rtn<8; Rtn++)
+	            {
+	                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[58+Rtn]);
+	            }
+	            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	        }
+	        #endif
+	
+	        #if (NEW_SLAC_ARCHITECTURE_SWITCH == ENABLE)
+	        {
+	            //SAVE_SYS_LOG_MSG_EVCOMM("[SLAC][Rx]CM_SLAC_MATCH_REQ");
+	
+	            //Check ODA (Destination Address)
+	            if (Array_Compare_Identity(CsuMac, MmePacket->ODA, SLAC_EVSE_MAC_LENGTH) == FALSE)
+	            {
+	                SAVE_SYS_LOG_MSG_EVCOMM("[SLAC][Rx][CM_SLAC_MATCH_REQ]wrong ODA: ignore");
+	                //break; //patch for DEKRA I2SE EVCC (another EVSE MAC Address protection comes as below.)
+	            }
+	
+	            EvMac_in = &MmePacket->OSA[0];
+	            RunID_in = &MmePacket->MMENTRY[50];
+	            idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
+	
+	            if (idx >= 0)
+	            {
+	                Update_V2G_Flow_Status(CM_SLAC_MATCH_REQ);
+	
+	                SLAC_INFO.array[idx].MatchReqNum++;
+	
+	                sprintf(buf_log_evcomm,
+	                        "[SLAC][Rx]CM_SLAC_MATCH_REQ[%d]:%d-th",
+	                        (idx + 1),
+	                        SLAC_INFO.array[idx].MatchReqNum);
+	                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	
+	                //[TC_SECC_VTB_CmSlacMatch_007] APPLICATION_TYPE must be 0x00(EV-EVSE Matching)
+	                //[TC_SECC_VTB_CmSlacMatch_008]
+	                if (MmePacket->MMENTRY[0] != 0)
+	                {
+	                    sprintf(buf_log_evcomm,
+	                            "[SLAC][Rx]CM_SLAC_MATCH_REQ[%d]:wrong APPLICATION_TYPE(%d)",
+	                            (idx + 1),
+	                            MmePacket->MMENTRY[0]);
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                    break;
+	                }
+	
+	                //[TC_SECC_VTB_CmSlacMatch_009] SECURITY_TYPE must be 0x00(No Security)
+	                //[TC_SECC_VTB_CmSlacMatch_010]
+	                if (MmePacket->MMENTRY[1] != 0)
+	                {
+	                    sprintf(buf_log_evcomm,
+	                            "[SLAC][Rx]CM_SLAC_MATCH_REQ[%d]:wrong SECURITY_TYPE(%d)",
+	                            (idx + 1),
+	                            MmePacket->MMENTRY[1]);
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                    break;
+	                }
+	
+	                //[TC_SECC_VTB_CmSlacMatch_011] MVFLength must be 0x3E(MatchVarField Length)
+	                //[TC_SECC_VTB_CmSlacMatch_012]
+	                if (MmePacket->MMENTRY[2] != 0x3E || MmePacket->MMENTRY[3] != 0x00)
+	                {
+	                    sprintf(buf_log_evcomm,
+	                            "[SLAC][Rx]CM_SLAC_MATCH_REQ[%d]:wrong MVFLength(%d,%d)",
+	                            (idx + 1),
+	                            MmePacket->MMENTRY[2],
+	                            MmePacket->MMENTRY[3]);
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                    break;
+	                }
+	
+	                //[TC_SECC_VTB_CmSlacMatch_013] EV ID (muxt be all zero)
+	                //[TC_SECC_VTB_CmSlacMatch_014]
+	                if (Array_Check_All_Zero(&MmePacket->MMENTRY[4], 17) == FALSE)
+	                {
+	                    sprintf(buf_log_evcomm,
+	                            "[SLAC][Rx]CM_SLAC_MATCH_REQ[%d]: wrong EV ID",
+	                            (idx + 1));
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                    break;
+	                }
+	
+	                //[TC_SECC_VTB_CmSlacMatch_015] EV MAC
+	                //[TC_SECC_VTB_CmSlacMatch_016]
+	                if (Array_Compare_Identity(EvMac_in, &MmePacket->MMENTRY[21], SLAC_EVMAC_LENGTH) == FALSE)
+	                {
+	                    sprintf(buf_log_evcomm,
+	                            "[SLAC][Rx]CM_SLAC_MATCH_REQ[%d]: wrong EV MAC(%02X:%02X:%02X:%02X:%02X:%02X)",
+	                            (idx + 1),
+	                            MmePacket->MMENTRY[21], MmePacket->MMENTRY[22], MmePacket->MMENTRY[23],
+	                            MmePacket->MMENTRY[24], MmePacket->MMENTRY[25], MmePacket->MMENTRY[26]);
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                    break;
+	                }
+	
+	                //[TC_SECC_VTB_CmSlacMatch_017] EVSE ID should be all zero
+	                //[TC_SECC_VTB_CmSlacMatch_018]
+	                if (Array_Check_All_Zero(&MmePacket->MMENTRY[27], 17) == FALSE)
+	                {
+	                    sprintf(buf_log_evcomm,
+	                            "[SLAC][Rx]CM_SLAC_MATCH_REQ[%d]: wrong EVSE ID",
+	                            (idx + 1));
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                    break;
+	                }
+	
+	                //[TC_SECC_VTB_CmSlacMatch_019] EVSE MAC
+	                //[TC_SECC_VTB_CmSlacMatch_020]
+	                if (Array_Compare_Identity(CsuMac, &MmePacket->MMENTRY[44], SLAC_EVSE_MAC_LENGTH) == FALSE)
+	                {
+	                    sprintf(buf_log_evcomm,
+	                            "[SLAC][Rx]CM_SLAC_MATCH_REQ[%d]: wrong EVSE MAC(%02X:%02X:%02X:%02X:%02X:%02X)",
+	                            (idx + 1),
+	                            MmePacket->MMENTRY[44], MmePacket->MMENTRY[45], MmePacket->MMENTRY[46],
+	                            MmePacket->MMENTRY[47], MmePacket->MMENTRY[48], MmePacket->MMENTRY[49]);
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	                    break;
+	                }
+	
+	                //[TC_SECC_VTB_CmSlacMatch_021]runID: Check RunID
+	                //[TC_SECC_VTB_CmSlacMatch_022]
+	                if (SLAC_DB_Check_EvMac_RunID_Matching(&SLAC_INFO, EvMac_in, RunID_in) == TRUE &&
+	                   (idx == 0)) //only setup a successful link establishment with the first SLAC Req instance
+	                {
+	                    memset(&SendMmePacket, 0, sizeof(struct MmeHeader));
+	        	        memcpy(SendMmePacket.ODA, MmePacket->OSA, 6);
+	        	        memcpy(SendMmePacket.OSA, CsuMac, 6);
+	        	        SendMmePacket.MTYPE = htons(EtherType_HomePlug);
+	        	        SendMmePacket.MMV = MmePacket->MMV;
+	        	        SendMmePacket.MMTYPE = MMTYPE_CM_SLAC_MATCH_CNF;
+	        	        SendMmePacket.FMI[0] = SendMmePacket.FMI[1] = 0;
+	        	        SendMmePacketSize = 0;
+	        	        SendMmePacket.MMENTRY[SendMmePacketSize++] = 0x00;    //APPLICATION_TYPE: Fixed value (0x00: EV-EVSE matching)
+	        	        SendMmePacket.MMENTRY[SendMmePacketSize++] = 0x00;    //SECURITY_TYPE: Fixed value (0x00: No Security)
+	        	        SendMmePacket.MMENTRY[SendMmePacketSize++] = 0x56;    //MVFLength: MatchVarField Length (Fixed value: 0x0056)
+	        	        SendMmePacket.MMENTRY[SendMmePacketSize++] = 0x00;    //MVFLength: MatchVarField Length (Fixed value: 0x0056)
+	        	        memset(SendMmePacket.MMENTRY + SendMmePacketSize, 0, 17);         //EV ID
+	        	        SendMmePacketSize += 17;
+	        	        memcpy(SendMmePacket.MMENTRY + SendMmePacketSize, EvMac_in, SLAC_EVMAC_LENGTH); //EV MAC
+	        	        SendMmePacketSize += 6;
+	        	        memset(SendMmePacket.MMENTRY + SendMmePacketSize, 0, 17);         //EVSE ID
+	        	        SendMmePacketSize += 17;
+	        	        memcpy(SendMmePacket.MMENTRY + SendMmePacketSize, CsuMac, 6);     //EVSE MAC
+	        	        SendMmePacketSize += 6;
+	        	        memcpy(SendMmePacket.MMENTRY + SendMmePacketSize, RunID_in, SLAC_RUNID_LENGTH);
+	        	        SendMmePacketSize += SLAC_RUNID_LENGTH;
+	        	        memset(SendMmePacket.MMENTRY + SendMmePacketSize, 0, 8);    //RSVD
+	        	        SendMmePacketSize += 8;
+	        	        memcpy(SendMmePacket.MMENTRY + SendMmePacketSize, Nid, sizeof(Nid));   //NID: Network ID given by the CCo(EVSE)
+	        	        SendMmePacketSize += sizeof(Nid);                                      //NID caculated from the random NMK that will be set.
+	        	        SendMmePacket.MMENTRY[SendMmePacketSize++] = 0x00;          //RSVD
+	        	        memcpy(SendMmePacket.MMENTRY + SendMmePacketSize, NewNmkKey, sizeof(NewNmkKey)); //NMK: Random value
+	        	        SendMmePacketSize += sizeof(NewNmkKey);                                          //NMK: Private NMK of the EVSE (random value)
+	        	        SendMmePacketSize += 19;      //the size before MMENTRY
+	
+	                    #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+	                    {
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("\n\n***** Response MME Packet *****\n");
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.ODA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+	                               SendMmePacket.ODA[0],SendMmePacket.ODA[1],SendMmePacket.ODA[2],SendMmePacket.ODA[3],SendMmePacket.ODA[4],SendMmePacket.ODA[5]);
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.OSA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+	                               SendMmePacket.OSA[0],SendMmePacket.OSA[1],SendMmePacket.OSA[2],SendMmePacket.OSA[3],SendMmePacket.OSA[4],SendMmePacket.OSA[5]);
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("MTYPE: 0x%x\n", htons(SendMmePacket.MTYPE));
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("MMV: 0x%x\n", SendMmePacket.MMV);
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("MMTYPE: 0x%x\n", SendMmePacket.MMTYPE);
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("FMI 0x%x, 0x%x\n", SendMmePacket.FMI[0],SendMmePacket.FMI[1]);
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("--- CM_SLAC_MATCH_CNF ---\n");
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", SendMmePacket.MMENTRY[0]);
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", SendMmePacket.MMENTRY[1]);
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("MVFLength: 0x%x, 0x%x\n", SendMmePacket.MMENTRY[2],SendMmePacket.MMENTRY[3]);
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("PEV ID: \n");
+	                        for(Rtn=0; Rtn<17; Rtn++)
+	                        {
+	                            DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[4+Rtn]);
+	                        }
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("PEV MAC: \n");
+	                        for(Rtn=0; Rtn<6; Rtn++)
+	                        {
+	                            DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[21+Rtn]);
+	                        }
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("EVSE ID: \n");
+	                        for(Rtn=0; Rtn<17; Rtn++)
+	                        {
+	                            DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[27+Rtn]);
+	                        }
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("EVSE MAC: \n");
+	                        for(Rtn=0; Rtn<6; Rtn++)
+	                        {
+	                            DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[44+Rtn]);
+	                        }
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("RunID: \n");
+	                        for(Rtn=0; Rtn<8; Rtn++)
+	                        {
+	                            DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[50+Rtn]);
+	                        }
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("RSVD: \n");
+	                        for(Rtn=0; Rtn<8; Rtn++)
+	                        {
+	                            DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[58+Rtn]);
+	                        }
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("NID: \n");
+	                        for(Rtn=0; Rtn<7; Rtn++)
+	                        {
+	                            DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[66+Rtn]);
+	                        }
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("RSVD: 0x%x\n", SendMmePacket.MMENTRY[73]);
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("NMK: \n");
+	                        for(Rtn=0; Rtn<16; Rtn++)
+	                        {
+	                            DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[74+Rtn]);
+	                        }
+	                        DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                    }
+	                    #endif
+	
+	                    Update_V2G_Flow_Status(CM_SLAC_MATCH_CNF);
+	        	        Rtn = sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+	
+	
+	        	        DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacketSize=%d,Rtn=%d\n",SendMmePacketSize,Rtn);
+	                    sprintf(buf_log_evcomm,
+	                            "[SLAC][Tx]CM_SLAC_MATCH_CNF[%d]",
+	                            (idx + 1));
+	                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	
+	                    ftime(&SeqStartTime);
+	                }
+	                else
+	                {
+	                    //RunID does not match and it's not the first SLAC request
+	                    //Reset the SLAC database to embrace SLAC retry
+	                    SAVE_SYS_LOG_MSG_EVCOMM("[CM_SLAC_MATCH_REQ]No Real MATCH_REQ");
+	                    SLAC_DB_Reset();
+	                }
+	            }
+	            else
+	            {
+	                //OSA(EvMac) does not exist
+	            }
+	            break;
+	        }
+	        #else
+	        {
+	            Update_V2G_Flow_Status(CM_SLAC_MATCH_REQ);
+	            SAVE_SYS_LOG_MSG_EVCOMM("[SLAC][Rx]CM_SLAC_MATCH_REQ");
+	
+	            memset(&SendMmePacket,0,sizeof(struct MmeHeader));
+	            memcpy(SendMmePacket.ODA,MmePacket->OSA,6);
+	            memcpy(SendMmePacket.OSA,CsuMac,6);
+	            SendMmePacket.MTYPE=htons(EtherType_HomePlug);
+	            SendMmePacket.MMV=MmePacket->MMV;
+	            SendMmePacket.MMTYPE=MMTYPE_CM_SLAC_MATCH_CNF;
+	            SendMmePacket.FMI[0]=SendMmePacket.FMI[1]=0;
+	            SendMmePacketSize=0;
+	            SendMmePacket.MMENTRY[SendMmePacketSize++]=0x00;    //Fixed value (0x00) indicating PEV-EVSE matching
+	            SendMmePacket.MMENTRY[SendMmePacketSize++]=0x00;    //Fixed value (0x00) indicating No Security
+	            SendMmePacket.MMENTRY[SendMmePacketSize++]=0x56;    //Fixed value (0x0056) for matching
+	            SendMmePacket.MMENTRY[SendMmePacketSize++]=0x00;    //Fixed value (0x0056) for matching
+	            memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,17);    //PEV ID
+	            SendMmePacketSize+=17;
+	            memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,EvMac,6);
+	            SendMmePacketSize+=6;
+	            memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,17);    //EVSE ID
+	            SendMmePacketSize+=17;
+	            memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,CsuMac,6);
+	            SendMmePacketSize+=6;
+	            memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,SlacRunId,sizeof(SlacRunId));
+	            SendMmePacketSize+=sizeof(SlacRunId);
+	            memset(SendMmePacket.MMENTRY+SendMmePacketSize,0,8);    //RSVD
+	            SendMmePacketSize+=8;
+	            memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,Nid,sizeof(Nid));
+	            SendMmePacketSize+=sizeof(Nid);
+	            SendMmePacket.MMENTRY[SendMmePacketSize++]=0x00;    //RSVD
+	            memcpy(SendMmePacket.MMENTRY+SendMmePacketSize,NewNmkKey,sizeof(NewNmkKey));
+	            SendMmePacketSize+=sizeof(NewNmkKey);
+	            SendMmePacketSize+=19;      //the size before MMENTRY
+	
+	            #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+	                DEBUG_PRINTF_EVCOMM_DETAIL("\n\n***** Response MME Packet *****\n");
+	                DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.ODA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+	                       SendMmePacket.ODA[0],SendMmePacket.ODA[1],SendMmePacket.ODA[2],SendMmePacket.ODA[3],SendMmePacket.ODA[4],SendMmePacket.ODA[5]);
+	                DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.OSA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+	                       SendMmePacket.OSA[0],SendMmePacket.OSA[1],SendMmePacket.OSA[2],SendMmePacket.OSA[3],SendMmePacket.OSA[4],SendMmePacket.OSA[5]);
+	                DEBUG_PRINTF_EVCOMM_DETAIL("MTYPE: 0x%x\n", htons(SendMmePacket.MTYPE));
+	                DEBUG_PRINTF_EVCOMM_DETAIL("MMV: 0x%x\n", SendMmePacket.MMV);
+	                DEBUG_PRINTF_EVCOMM_DETAIL("MMTYPE: 0x%x\n", SendMmePacket.MMTYPE);
+	                DEBUG_PRINTF_EVCOMM_DETAIL("FMI 0x%x, 0x%x\n", SendMmePacket.FMI[0],SendMmePacket.FMI[1]);
+	                DEBUG_PRINTF_EVCOMM_DETAIL("--- CM_SLAC_MATCH_CNF ---\n");
+	                DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", SendMmePacket.MMENTRY[0]);
+	                DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", SendMmePacket.MMENTRY[1]);
+	                DEBUG_PRINTF_EVCOMM_DETAIL("MVFLength: 0x%x, 0x%x\n", SendMmePacket.MMENTRY[2],SendMmePacket.MMENTRY[3]);
+	                DEBUG_PRINTF_EVCOMM_DETAIL("PEV ID: \n");
+	                for(Rtn=0; Rtn<17; Rtn++)
+	                {
+	                    DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[4+Rtn]);
+	                }
+	                DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                DEBUG_PRINTF_EVCOMM_DETAIL("PEV MAC: \n");
+	                for(Rtn=0; Rtn<6; Rtn++)
+	                {
+	                    DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[21+Rtn]);
+	                }
+	                DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                DEBUG_PRINTF_EVCOMM_DETAIL("EVSE ID: \n");
+	                for(Rtn=0; Rtn<17; Rtn++)
+	                {
+	                    DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[27+Rtn]);
+	                }
+	                DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                DEBUG_PRINTF_EVCOMM_DETAIL("EVSE MAC: \n");
+	                for(Rtn=0; Rtn<6; Rtn++)
+	                {
+	                    DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[44+Rtn]);
+	                }
+	                DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                DEBUG_PRINTF_EVCOMM_DETAIL("RunID: \n");
+	                for(Rtn=0; Rtn<8; Rtn++)
+	                {
+	                    DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[50+Rtn]);
+	                }
+	                DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                DEBUG_PRINTF_EVCOMM_DETAIL("RSVD: \n");
+	                for(Rtn=0; Rtn<8; Rtn++)
+	                {
+	                    DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[58+Rtn]);
+	                }
+	                DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                DEBUG_PRINTF_EVCOMM_DETAIL("NID: \n");
+	                for(Rtn=0; Rtn<7; Rtn++)
+	                {
+	                    DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[66+Rtn]);
+	                }
+	                DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	                DEBUG_PRINTF_EVCOMM_DETAIL("RSVD: 0x%x\n", SendMmePacket.MMENTRY[73]);
+	                DEBUG_PRINTF_EVCOMM_DETAIL("NMK: \n");
+	                for(Rtn=0; Rtn<16; Rtn++)
+	                {
+	                    DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[74+Rtn]);
+	                }
+	                DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+	            #endif
+	
+	            Update_V2G_Flow_Status(CM_SLAC_MATCH_CNF);
+	            Rtn = sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+	
+	
+	            DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacketSize=%d,Rtn=%d\n",SendMmePacketSize,Rtn);
+	            SAVE_SYS_LOG_MSG_EVCOMM("[SLAC][Tx]CM_SLAC_MATCH_CNF");
+	
+	            ftime(&SeqStartTime);
+	            break;
+	        }
+	        #endif
+		}
+	   case MMTYPE_CM_AMP_MAP_REQ:
+		{
+		        #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+		        {
+		            DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_CM_SLAC_MATCH_REQ ---\n");
+		            DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", MmePacket->MMENTRY[0]);
+		            DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", MmePacket->MMENTRY[1]);
+		            DEBUG_PRINTF_EVCOMM_DETAIL("MVFLength: 0x%x, 0x%x\n", MmePacket->MMENTRY[2],MmePacket->MMENTRY[3]);    //Fixed value (0x3E) for matching
+		            DEBUG_PRINTF_EVCOMM_DETAIL("PEV ID: \n");
+		            for(Rtn=0; Rtn<17; Rtn++)
+		            {
+		                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[4+Rtn]);
+		            }
+		            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+		            DEBUG_PRINTF_EVCOMM_DETAIL("PEV MAC: \n");
+		            for(Rtn=0; Rtn<6; Rtn++)
+		            {
+		                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[21+Rtn]);
+		            }
+		            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+		            DEBUG_PRINTF_EVCOMM_DETAIL("EVSE ID: \n");
+		            for(Rtn=0; Rtn<17; Rtn++)
+		            {
+		                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[27+Rtn]);
+		            }
+		            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+		            DEBUG_PRINTF_EVCOMM_DETAIL("EVSE MAC: \n");
+		            for(Rtn=0; Rtn<6; Rtn++)
+		            {
+		                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[44+Rtn]);
+		            }
+		            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+		            DEBUG_PRINTF_EVCOMM_DETAIL("RunID: \n");
+		            for(Rtn=0; Rtn<8; Rtn++)
+		            {
+		                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[50+Rtn]);
+		            }
+		            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+		            DEBUG_PRINTF_EVCOMM_DETAIL("RSVD: \n");
+		            for(Rtn=0; Rtn<8; Rtn++)
+		            {
+		                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",MmePacket->MMENTRY[58+Rtn]);
+		            }
+		            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+		        }
+		        #endif
+		
+		         //Check ODA (Destination Address)
+		            if (Array_Compare_Identity(CsuMac, MmePacket->ODA, SLAC_EVSE_MAC_LENGTH) == FALSE)
+		            {
+		                SAVE_SYS_LOG_MSG_EVCOMM("[SLAC][Rx][CM_AMP_MAP_REQ]wrong ODA: ignore");
+		                //break; //patch for DEKRA I2SE EVCC (another EVSE MAC Address protection comes as below.)
+		            }
+		
+		            EvMac_in = &MmePacket->OSA[0];
+		            RunID_in = &MmePacket->MMENTRY[50];
+		            idx = SLAC_DB_Search_EvMac_idx(&SLAC_INFO, EvMac_in);
+		
+		            if (idx >= 0)
+		            {
+		                Update_V2G_Flow_Status(CM_AMP_MAP_REQ);
+		
+		                SLAC_INFO.array[idx].MatchReqNum++;
+		
+		                sprintf(buf_log_evcomm,
+		                        "[SLAC][Rx]CM_AMP_MAP_REQ[%d]:%d-th",
+		                        (idx + 1),
+		                        SLAC_INFO.array[idx].MatchReqNum);
+		                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		
+		                //[TC_SECC_VTB_CmSlacMatch_007] APPLICATION_TYPE must be 0x00(EV-EVSE Matching)
+		                //[TC_SECC_VTB_CmSlacMatch_008]
+		                if ((MmePacket->MMENTRY[0] != 0x3A)||(MmePacket->MMENTRY[1] != 0))
+		                {
+		                    sprintf(buf_log_evcomm,
+		                            "[SLAC][Rx]CM_AMP_MAP_REQ[%d]:wrong AMLEN(%d)",
+		                            (idx + 1),
+		                            MmePacket->MMENTRY[0]);
+		                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		                    break;
+		                }
+				
+		                //[TC_SECC_VTB_CmSlacMatch_021]runID: Check RunID
+		                //[TC_SECC_VTB_CmSlacMatch_022]
+		                if (SLAC_DB_Check_EvMac_RunID_Matching(&SLAC_INFO, EvMac_in, RunID_in) == TRUE &&
+		                   (idx == 0)) //only setup a successful link establishment with the first SLAC Req instance
+		                {
+		                    	memset(&SendMmePacket, 0, sizeof(struct MmeHeader));
+		        	        memcpy(SendMmePacket.ODA, MmePacket->OSA, 6);
+		        	        memcpy(SendMmePacket.OSA, CsuMac, 6);
+		        	        SendMmePacket.MTYPE = htons(EtherType_HomePlug);
+		        	        SendMmePacket.MMV = MmePacket->MMV;
+		        	        SendMmePacket.MMTYPE = MMTYPE_CM_AMP_MAP_CNF;
+		        	        SendMmePacket.FMI[0] = SendMmePacket.FMI[1] = 0;
+		        	        SendMmePacketSize = 0;
+		        	        SendMmePacket.MMENTRY[SendMmePacketSize++] = 0x00;    //success
+		        	     
+		                    	Update_V2G_Flow_Status(CM_AMP_MAP_CNF);
+		        	        Rtn = sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+		
+		
+		        	        DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacketSize=%d,Rtn=%d\n",SendMmePacketSize,Rtn);
+		                    sprintf(buf_log_evcomm,
+		                            "[SLAC][Tx]CM_AMP_MAP_CNF[%d]",
+		                            (idx + 1));
+		                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		
+		                    ftime(&SeqStartTime);
+		                }
+		                else
+		                {
+		                    //RunID does not match and it's not the first SLAC request
+		                    //Reset the SLAC database to embrace SLAC retry
+		                    SAVE_SYS_LOG_MSG_EVCOMM("[CM_SLAC_MATCH_REQ]No Real MATCH_REQ");
+		                    SLAC_DB_Reset();
+		                }
+		            }
+		            else
+		            {
+		                //OSA(EvMac) does not exist
+		            }
+		            break;
+		        }
+	
+	    case MMTYPE_VENDOR_VS_HOST_ACTION:
+	    {
+	        struct QcaVendorMmeHeader *RecvPacket;
+	        RecvPacket = (struct QcaVendorMmeHeader *)Buffer;
+	
+	        DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_VENDOR_VS_HOST_ACTION ---\n");
+	
+	        switch (RecvPacket->MBODY[0])
+	        {
+		        case 0x00:
+		            //Loader (Device Softloader or Bootloader) ready
+		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: Loader Ready\n");
+		            break;
+	
+		        case 0x01:
+		            //Firmware Upgrade Ready
+		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: Firmware Upgrade Ready\n");
+		            break;
+	
+		        case 0x02:
+		            //PIB Update Ready
+		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: PIB Update Ready\n");
+		            break;
+	
+		        case 0x03:
+		            //Firmware Upgrade and PIB Update ready
+		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: Firmware Upgrade and PIB Update ready\n");
+		            break;
+	
+		        case 0x04:
+		            //Loader (Bootloader) ready to receive SDRAM configuration.
+		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: Loader ready to receive SDRAM configuration\n");
+		            break;
+	
+		        case 0x05:
+		            //Reset to Factory Defaults.
+		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: Reset to Factory Defaults\n");
+		            break;
+	
+		        default:
+		            //Reserved
+		            DEBUG_PRINTF_EVCOMM_DETAIL("QCA7K: Reserved\n");
+		            break;
+	        }
+			break;
+	    }
+	
+	    case MMTYPE_VENDOR_ATTEN_CHAR:
+		{
+	        DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_VENDOR_ATTEN_CHAR ---\n");
+	        break;
+		}
+	
+	    case MMTYPE_VENDOR_VS_NW_INFO_CNF:
+		{
+			struct QcaVendorMmeHeader *RecvPacket;
+	        		RecvPacket = (struct QcaVendorMmeHeader *)Buffer;
+	        		memcpy(QcaMac, RecvPacket->OSA, 6);
+	        		sprintf(buf_log_evcomm,
+		                "[QCA7K][Rx][VENDOR_VS_NW_INFO_CNF]Got QCA7K MacAddr:%02X:%02X:%02X:%02X:%02X:%02X (comm:OK)",
+		                 QcaMac[0],  QcaMac[1],  QcaMac[2],  QcaMac[3],  QcaMac[4],  QcaMac[5]);
+	        		SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	
+		        DEBUG_PRINTF_EVCOMM_DETAIL("--- MMTYPE_VENDOR_VS_NW_INFO_CNF ---\n");
+		        DEBUG_PRINTF_EVCOMM_DETAIL("QcaMac: %02x:%02x:%02x:%02x:%02x:%02x\n",
+		                QcaMac[0],
+		                QcaMac[1],
+		                QcaMac[2],
+		                QcaMac[3],
+		                QcaMac[4],
+		                QcaMac[5]);
+	
+		        Update_V2G_Flow_Status(CM_SET_KEY_REQ);
+		        ftime(&SeqStartTime);
+	        		break;
+		}
+	case MMTYPE_VENDOR_VS_PL_LNK_STATUS_CNF:
+		{
+			struct QcaVendorMmeHeader *RecvPacket;
+	        		RecvPacket = (struct QcaVendorMmeHeader *)Buffer;
+	        		
+	        		if(RecvPacket->MBODY[1]==0)
+	        		{
+	        			//PLC disconnected
+	        			sprintf(buf_log_evcomm,
+			                "[QCA7K][Rx][MMTYPE_VENDOR_VS_PL_LNK_STATUS_CNF]Got PLC Link Status:%d",
+			                RecvPacket->MBODY[1]);
+	        			SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	        			Update_V2G_Flow_Status(Other_Fault);
+	        		}
+	        		else	
+		        		Update_V2G_Flow_Status(CM_SET_KEY_REQ);
+		        ftime(&SeqStartTime);
+	        		break;
+		}
+	
+	    default:
+		{
+	       		 break;
+		}
+	}
+}
+
+
+/*===========================================================================
+FUNCTION: SlacComm
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int SlacComm()
+{
+    static unsigned char qca7k_comm_retry = 0;
+    unsigned char *EvMac_in;
+    unsigned char *RunID_in;
+    double t_diff = 0;
+    int packet_size = 0;
+    int count = 0;
+    int idx = 0;
+    int i = 0;
+
+    if(RawSock >= 0)
+    {
+        memset(V2gtpMsgRxBuf, 0, V2GTP_MSG_RX_BUFFER_SIZE);
+        packet_size = recvfrom(RawSock, V2gtpMsgRxBuf, V2GTP_MSG_RX_BUFFER_SIZE, 0, NULL, NULL);
+        if(packet_size > 0)
+        {
+            /*#ifdef Debug
+               DEBUG_PRINTF_EVCOMM_DETAIL("Raw Data: ");
+               for(count=0;count<packet_size;count++)
+                DEBUG_PRINTF_EVCOMM_DETAIL("0x%x, ",V2gtpMsgRxBuf[count]);
+               DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+             #endif*/
+            MmeProcess(V2gtpMsgRxBuf, packet_size);
+        }
+    }
+
+    switch(Check_V2G_Flow_Status())
+    {
+	    case IDLE:
+		{
+	        if(RawSock < 0)
+	        {
+	            RawSock = socket(PF_PACKET, SOCK_RAW, htons(EtherType_HomePlug));
+
+	            sprintf(buf_log_evcomm, "[RawSock]opened(%d)", RawSock);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+	            if(RawSock == -1)
+	            {
+	                SAVE_SYS_LOG_MSG_EVCOMM("SlacComm:Failed to create socket");
+	                Update_V2G_Flow_Status(Other_Fault);
+	                return -1;
+	            }
+				ShmSysConfigAndInfo->SysInfo.SystemAmbientTemp=RawSock;
+	            if (setsockopt(RawSock, SOL_SOCKET, SO_BINDTODEVICE, QcaInterface, 4) < 0)
+	            {
+                    SAVE_SYS_LOG_MSG_EVCOMM("SlacComm:Set SO_BINDTODEVICE NG");
+                    Update_V2G_Flow_Status(Other_Fault);
+                    return -1;
+                }
+
+                struct timeval tv;
+	            tv.tv_sec = 0;
+		        tv.tv_usec = 100000;  //100ms (Rx timeout)
+	            if (setsockopt(RawSock, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv, sizeof(struct	timeval)) < 0)
+	            {
+	                SAVE_SYS_LOG_MSG_EVCOMM("SlacComm:Set SO_RCVTIMEO NG");
+	                Update_V2G_Flow_Status(Other_Fault);
+	                return -1;
+	            }
+
+                tv.tv_usec = 100000;  //100ms (Tx timeout)
+                if (setsockopt(RawSock, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv, sizeof(struct	timeval)) < 0)
+	            {
+	                SAVE_SYS_LOG_MSG_EVCOMM("SlacComm:Set SO_SNDTIMEO NG");
+	                Update_V2G_Flow_Status(Other_Fault);
+	                return -1;
+	            }
+
+	            memset(&Req, 0, sizeof(struct ifreq));
+	            strcpy( (char*)Req.ifr_name, QcaInterface);
+
+	            if (ioctl(RawSock, SIOCGIFINDEX, &Req) < 0)
+	            {
+	                SAVE_SYS_LOG_MSG_EVCOMM("SlacComm: ioctl NG");
+	                Update_V2G_Flow_Status(Other_Fault);
+	                return -1;
+	            }
+
+	            memset( &DestSocketAddress, 0, sizeof(struct sockaddr_ll));
+	            DestSocketAddress.sll_ifindex = Req.ifr_ifindex;
+	            DestSocketAddress.sll_halen = ETH_ALEN;
+
+                PwmStartTime = 0;
+
+                EVCOMM_SYS_INFO.QCA7K_SetKeyDone = FALSE;
+                SAVE_SYS_LOG_MSG_EVCOMM("[QCA7K]connecting...");
+                //Get QCA7K MAC address
+                GetQca7kMac();
+                ftime(&SeqStartTime);
+                break;
+	        }
+	        else   //RawSock: opened
+	        {
+                if(EVCOMM_SYS_INFO.QCA7K_SetKeyDone == FALSE)
+                {
+                    ftime(&SeqEndTime);
+                    t_diff = DiffTimeb(SeqStartTime, SeqEndTime);
+
+                    if (t_diff > V2G_SECC_QCA7000_GET_MAC_ADDR_REQ_RETRY_PERIOD)   //3 secs
+                    {
+                        qca7k_comm_retry++;
+                        sprintf(buf_log_evcomm,
+                                "[QCA7K]re-try connecting...(%.02lf/%dms)",
+                                t_diff,
+                                V2G_SECC_QCA7000_GET_MAC_ADDR_REQ_RETRY_PERIOD);
+                        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+                        GetQca7kMac(); //re-send req
+                        ftime(&SeqStartTime);
+                        break;
+                    }
+                    else
+                    {
+                        //null
+                    }
+
+                    //Retry by 3 times
+                    if (qca7k_comm_retry >= 3)
+                    {
+                        sprintf(buf_log_evcomm,
+                                "[QCA7K][Error]comm: fail (retry by %d times)",
+                                qca7k_comm_retry);
+                        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+                        //Update_ShmStatusCode(); //[To-Do] to be implemented
+                        //CCS_SECCC_TIMEOUT_QCA7000_COMM (023892): The firmware code of QCA7000 may not be installed, yet
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                        ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                        ShmStatusCodeData->PresentStatusCode[0][4] = 9;
+                        ShmStatusCodeData->PresentStatusCode[0][5] = 2;
+                        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+                        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+                        Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
+
+                        Update_V2G_Flow_Status(Sequence_Timeout);
+                        qca7k_comm_retry = 0;
+                        break;
+                    }
+                }
+                else    //RawSock: opened; Set Key: DONE
+                {
+                	/*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
+                    if((CheckConnectorPlugIn() == TRUE) && (ShmInternalComm->ChargingPermission >=1)) 
+                    {
+                        if(PwmStartTime <= 0)
+                        {
+                            //Sniffer_Tcpdump(ENABLE);
+                            //#if (TCPDUMP_PACKETS_SNIFFER_SWITCH == ENABLE)
+                            //sleep(1);   //wait for tcpdump to be ready.
+                            //#endif
+                            SwitchCpStateE(DISABLE);
+                            OutputCpPwmDuty(5);
+                            PwmStartTime = time(NULL);
+                        }
+                        else
+                        {
+                            if((time(NULL) - PwmStartTime) > TT_EVSE_SLAC_init)
+                            {
+                                sprintf(buf_log_evcomm,
+                                        "SlacComm: Wait CM_SLAC_PARM_REQ Timeout - TT_EVSE_SLAC_init, NowTime(%d)-PwmStartTime(%d)>%d (sec)",
+                                        time(NULL),
+                                        PwmStartTime,
+                                        TT_EVSE_SLAC_init);
+                                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+                                //Update_ShmStatusCode(); //[To-Do] to be implemented
+                                //CCS_SECC_TIMEOUT_SLAC_TT_EVSE_SLAC_init (023809)
+                                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                                ShmStatusCodeData->PresentStatusCode[0][4] = 0;
+                                ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+                                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+                                Update_V2G_Flow_Status(Sequence_Timeout);
+                                PwmStartTime = 0;
+                                return -1;
+                            }
+                            else
+                            {
+                                //waiting for CM_SLAC_PARM_REQ
+                            }
+                        }
+                    }
+                    else
+                    {
+                        PwmStartTime = 0;
+                    }
+                }
+	        }
+	        break;
+		}
+
+	    case CM_SET_KEY_REQ:   //13
+		{
+	        //CM_SET_KEY_REQ
+            //SAVE_SYS_LOG_MSG_EVCOMM("[QCA7K][Rx]CM_SET_KEY_REQ");
+            ftime(&SeqEndTime);
+            t_diff = DiffTimeb(SeqStartTime, SeqEndTime);
+            if (t_diff > V2G_SECC_QCA7000_COMM_TIMEOUT)   //10 seconds
+            {
+                sprintf(buf_log_evcomm,
+                        "[QCA7K]Failed on SetKey => End_Process (%.02lf/%dms)",
+                        t_diff,
+                        V2G_SECC_QCA7000_COMM_TIMEOUT);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+                //Update_ShmStatusCode(); //[To-Do] to be implemented
+                //CCS_SECCC_TIMEOUT_QCA7000_COMM (023892): The firmware code of QCA7000 may not be installed, yet
+                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                ShmStatusCodeData->PresentStatusCode[0][4] = 9;
+                ShmStatusCodeData->PresentStatusCode[0][5] = 2;
+                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+
+                Update_V2G_Flow_Status(Sequence_Timeout);
+            }
+            else if (t_diff > V2G_SECC_QCA7000_SEND_SET_KEY_PERIOD)  //2 seconds
+            {
+                sprintf(buf_log_evcomm,
+                        "[QCA7K]SetKey: proceed (%.02lf/%dms)",
+                        t_diff,
+                        V2G_SECC_QCA7000_SEND_SET_KEY_PERIOD);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+                SendSetKey();
+                ftime(&SeqStartTime);
+            }
+            else
+            {
+                //null
+            }
+	        break;
+		}
+
+	    case CM_SET_KEY_CNF:   //14
+		{
+            sprintf(buf_log_evcomm,
+                    "[SECCReady]Wait: plugin(%d), matached(%d), permission(%d)...",
+                    CheckConnectorPlugIn(),
+                    CSUCOMMDC_TASK_FLAG.matched,
+                    ShmInternalComm->ChargingPermission
+                    );
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+            EVCOMM_SYS_INFO.QCA7K_SetKeyDone = TRUE;
+            PwmStartTime = 0;
+            Update_V2G_Flow_Status(IDLE);
+	        break;
+		}
+
+	    case CM_SLAC_PARM_CONF:
+		{
+	        ftime(&SeqEndTime);
+	        if(DiffTimeb(SeqStartTime, SeqEndTime) > TT_match_sequence)
+	        {
+	            sprintf(buf_log_evcomm,
+                        "SlacComm: Wait CM_START_ATTEN_CHAR_IND Timeout - TT_match_sequence (%.02lf of %dms)",
+                        DiffTimeb(SeqStartTime, SeqEndTime),
+                        TT_match_sequence);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+                //Update_ShmStatusCode(); //[To-Do] to be implemented
+                //CCS_SECC_TIMEOUT_CM_START_ATTEN_CHAR_IND (023811): 
+                //[Possible Reason] CCS Board image might not be updated properly. The 2nd reboot process is not finished.
+                //[Verification Method] By tying reboot command to the terminal and see if it could be executed immediately.
+                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
+                ShmStatusCodeData->PresentStatusCode[0][5] = 1;
+                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+
+	            Update_V2G_Flow_Status(Sequence_Timeout);
+	            return -1;
+	        }
+	        break;
+		}
+
+	    case CM_START_ATTEN_CHAR_IND:
+		{
+	        ftime(&SeqEndTime);
+	        if(DiffTimeb(SeqStartTime, SeqEndTime) > (TP_EV_batch_msg_interval))    //one more time interval for tolerance
+	        {
+	            sprintf(buf_log_evcomm,
+                        "SlacComm: Wait CM_MNBC_SOUND_IND Timeout - TP_EV_batch_msg_interval (%.02lf of %dms)",
+                        DiffTimeb(SeqStartTime, SeqEndTime),
+                        TP_EV_batch_msg_interval);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+                //Update_ShmStatusCode(); //[To-Do] to be implemented
+                //CCS_SECC_TIMEOUT_SLAC_CM_MNBC_SOUND_IND (023818): 
+                //[Possible Reason] CCS Board image might not be updated properly. The 2nd reboot process is not finished.
+                //[Verification Method] By tying reboot command to the terminal and see if it could be executed immediately.
+                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
+                ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+
+	            Update_V2G_Flow_Status(Sequence_Timeout);
+	            return -1;
+	        }
+	        break;
+		}
+
+	    case CM_MNBC_SOUND_IND:
+		{
+            #if (NEW_SLAC_ARCHITECTURE_SWITCH == ENABLE)
+            {
+                ftime(&SeqEndTime);
+                t_diff = DiffTimeb(SeqStartTime, SeqEndTime);
+                //printf("time:%.02lf, profilNum:%d\n",DiffTimeb(SeqStartTime, SeqEndTime),AttenProfileCnt);  //added by Vern
+    	        if(t_diff > TT_EVSE_match_MNBC ||
+                  (SLAC_INFO.array[0].AttenProfileCnt >= SLAC_INFO.array[0].MnbcSoundNum) ||
+                  (EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry > 0)) //TC_SECC_VTB_AttenuationCharacterization_003
+                {
+                    //Wait for other SLAC Req sets
+                    if ((SLAC_INFO.arrayLen >= 2) &&
+                        (t_diff < TT_EVSE_match_MNBC) &&
+                        (EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry == 0)) //not a retry
+                    {
+                        break;
+                    }
+
+                    //Check if it is a timeup response
+                    if (t_diff > TT_EVSE_match_MNBC)
+                    {
+                        sprintf(buf_log_evcomm,
+                                "[WARNING][SLAC][Tx]CM_ATTEN_CHAR_IND[%d]: timeup(%.2f/%dms) => send",
+                                (i + 1),
+                                t_diff,
+                                TT_EVSE_match_MNBC);
+                        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    }
+
+                    //Sending all CM_ATTEN_CHAR_IND according to all corresponding SLAC Req sets
+                    for (i = 0; i < SLAC_INFO.arrayLen; i++)
+                    {
+                        if ((SLAC_INFO.array[i].AttenProfileCnt == 0) ||
+                            (SLAC_INFO.array[i].AagGroupsNum == 0) ||
+                            (SLAC_INFO.array[i].StartAttenCharCnt == 0) ||
+                            (SLAC_INFO.array[i].MnbcSoundNum != 10) || //received in CM_START_ATTEN_CHAR_IND
+                            (SLAC_INFO.array[i].StartAttenCharErr == TRUE)
+                           )
+                        {
+                            //Ignoring those SLAC request sets without sending CM_MNBC_SOUND_IND(CM_ATTEN_PROFILE_IND)
+                            sprintf(buf_log_evcomm,
+                                    "[WARNING][SLAC][Tx]CM_ATTEN_CHAR_IND[%d]: para err(%d,%d,%d,%d,%d) => canceled",
+                                    (i + 1),
+                                    SLAC_INFO.array[i].AttenProfileCnt,
+                                    SLAC_INFO.array[i].AagGroupsNum,
+                                    SLAC_INFO.array[i].StartAttenCharCnt,
+                                    SLAC_INFO.array[i].MnbcSoundNum,
+                                    SLAC_INFO.array[i].StartAttenCharErr);
+                            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                            continue;
+                        }
+
+                        //In CM_ATTEN_CHAR_IND retry process, here only re-send this message according to the 1st coming SLAC request
+                        if ((EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry > 0) && (i != 0))
+                        {
+                            sprintf(buf_log_evcomm,
+                                    "[NOTE][SLAC][Tx]CM_ATTEN_CHAR_IND[%d]: canceled",
+                                    (i + 1));
+                            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                            break;
+                        }
+
+                        EvMac_in = SLAC_INFO.array[i].EvMac;
+                        RunID_in = SLAC_INFO.array[i].RunID;
+
+                        memset(&SendMmePacket, 0, sizeof(struct MmeHeader));
+                        memcpy(SendMmePacket.ODA, EvMac_in, SLAC_EVMAC_LENGTH);
+                        memcpy(SendMmePacket.OSA, CsuMac, 6);
+                        SendMmePacket.MTYPE = htons(EtherType_HomePlug);
+                        SendMmePacket.MMV = 0x01;
+                        SendMmePacket.MMTYPE = MMTYPE_CM_ATTEN_CHAR_IND;
+                        SendMmePacket.FMI[0] = SendMmePacket.FMI[1] = 0;
+                        SendMmePacketSize = 0;
+                        SendMmePacket.MMENTRY[SendMmePacketSize++] = 0;    //APPLICATION_TYPE(0x00: EV-EVSE Matching)
+                        SendMmePacket.MMENTRY[SendMmePacketSize++] = 0;    //SECURITY_TYPE(0x00: No Security)
+                        memcpy(SendMmePacket.MMENTRY + SendMmePacketSize, EvMac_in, SLAC_EVMAC_LENGTH); //SOURCE_ADDRESS, MAC address of the EV Host
+                        SendMmePacketSize += SLAC_EVMAC_LENGTH;
+                        memcpy(SendMmePacket.MMENTRY + SendMmePacketSize, RunID_in, SLAC_RUNID_LENGTH);
+                        SendMmePacketSize += SLAC_RUNID_LENGTH;
+                        memset(SendMmePacket.MMENTRY + SendMmePacketSize, 0, 17); //SOURCE_ID(0x00)
+                        SendMmePacketSize += 17;
+                        memset(SendMmePacket.MMENTRY + SendMmePacketSize, 0, 17); //RESP_ID(0x00)
+                        SendMmePacketSize += 17;
+                        SendMmePacket.MMENTRY[SendMmePacketSize++] = SLAC_INFO.array[i].AttenProfileCnt; //NumSounds: Number of M-Sounds used for generation of the ATTEN_PROFILE
+                        SendMmePacket.MMENTRY[SendMmePacketSize++] = SLAC_INFO.array[i].AagGroupsNum;    //NumGroups
+
+                        for(count = 0; count < SLAC_INFO.array[i].AagGroupsNum; count++)
+                        {
+                            unsigned char TmpAag;
+                            TmpAag = ((SLAC_INFO.array[i].AAG[count] / SLAC_INFO.array[i].AttenProfileCnt) & 0xFF);
+                            SLAC_INFO.array[i].AAG_quality_ori += (float) TmpAag;   //original signal quality
+
+                            #if (SUDO_PSD_PARAMETER_MECHANISM == ENABLE)    //default: ENABLE
+                                #if 1
+                                //TC_SECC_VTB_AttenuationCharacterization_019
+                                TmpAag = TmpAag >> 1;   //new method proposed by Joseph (divided by 2)
+                                #else
+                                if(TmpAag >= 39)        //original method proposed by Vern
+                                {
+                                    TmpAag = 37;
+                                }
+                                #endif
+                            #endif
+                            SendMmePacket.MMENTRY[SendMmePacketSize++] = TmpAag;
+                            SLAC_INFO.array[i].AAG_quality_refined += (float) TmpAag;   //refined signal quality
+                        }
+                        SendMmePacketSize += 19;      //the size before MMENTRY
+
+                        #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == TRUE)
+                        {
+                            DEBUG_PRINTF_EVCOMM_DETAIL("\n\n***** Send MME Packet *****\n");
+                            DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.ODA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+                                   SendMmePacket.ODA[0],SendMmePacket.ODA[1],SendMmePacket.ODA[2],SendMmePacket.ODA[3],SendMmePacket.ODA[4],SendMmePacket.ODA[5]);
+                            DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.OSA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+                                   SendMmePacket.OSA[0],SendMmePacket.OSA[1],SendMmePacket.OSA[2],SendMmePacket.OSA[3],SendMmePacket.OSA[4],SendMmePacket.OSA[5]);
+                            DEBUG_PRINTF_EVCOMM_DETAIL("MTYPE: 0x%x\n", htons(SendMmePacket.MTYPE));
+                            DEBUG_PRINTF_EVCOMM_DETAIL("MMV: 0x%x\n", SendMmePacket.MMV);
+                            DEBUG_PRINTF_EVCOMM_DETAIL("MMTYPE: 0x%x\n", SendMmePacket.MMTYPE);
+                            DEBUG_PRINTF_EVCOMM_DETAIL("FMI 0x%x, 0x%x\n", SendMmePacket.FMI[0],SendMmePacket.FMI[1]);
+                            DEBUG_PRINTF_EVCOMM_DETAIL("--- CM_ATTEN_CHAR_IND ---\n");
+                            DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", SendMmePacket.MMENTRY[0]);
+                            DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", SendMmePacket.MMENTRY[1]);
+                            DEBUG_PRINTF_EVCOMM_DETAIL("SOURCE_ADDRESS: %02x:%02x:%02x:%02x:%02x:%02x\n",
+                                   SendMmePacket.MMENTRY[2],SendMmePacket.MMENTRY[3],SendMmePacket.MMENTRY[4],SendMmePacket.MMENTRY[5],
+                                   SendMmePacket.MMENTRY[6],SendMmePacket.MMENTRY[7]);
+                            DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+                                   SendMmePacket.MMENTRY[8],SendMmePacket.MMENTRY[9],SendMmePacket.MMENTRY[10],SendMmePacket.MMENTRY[11],
+                                   SendMmePacket.MMENTRY[12],SendMmePacket.MMENTRY[13],SendMmePacket.MMENTRY[14],SendMmePacket.MMENTRY[15]);
+                            DEBUG_PRINTF_EVCOMM_DETAIL("SOURCE_ID: \n");
+                            for(count=0; count<17; count++)
+                            {
+                                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[16+count]);
+                            }
+                            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+                            DEBUG_PRINTF_EVCOMM_DETAIL("RESP_ID: \n");
+                            for(count=0; count<17; count++)
+                            {
+                                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[33+count]);
+                            }
+                            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+                            DEBUG_PRINTF_EVCOMM_DETAIL("NumSounds: 0x%x\n", SendMmePacket.MMENTRY[50]);
+                            DEBUG_PRINTF_EVCOMM_DETAIL("ATTEN_PROFILE: \n");
+                            for(count=0; count<AagGroupsNum; count++)
+                            {
+                                DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[51+count]);
+                            }
+                            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+                        }
+                        #endif
+
+                        count = sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+
+                        SLAC_INFO.array[i].AAG_quality_ori /= SLAC_INFO.array[i].AagGroupsNum;
+                        SLAC_INFO.array[i].AAG_quality_refined /= SLAC_INFO.array[i].AagGroupsNum;
+
+                        //Print log if this CM_ATTEN_CHAR_IND belongs to RETRY Tx message.
+                        if (EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry > 0)
+                        {
+                            sprintf(buf_log_evcomm,
+                                    "[SLAC][Tx]CM_ATTEN_CHAR_IND[%d]: %d-th resend (Q=%.2f/%.2f)(%d/%d)",
+                                    (i + 1),
+                                    EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry,
+                                    SLAC_INFO.array[i].AAG_quality_refined,
+                                    SLAC_INFO.array[i].AAG_quality_ori,
+                                    SLAC_INFO.array[i].AttenProfileCnt,
+                                    SLAC_INFO.array[i].MnbcSoundNum);
+                            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                        }
+                        else if (EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry == 0)
+                        {
+                            sprintf(buf_log_evcomm,
+                                    "[SLAC][Tx]CM_ATTEN_CHAR_IND[%d]: Q=%.2f/%.2f(%d/%d)",
+                                    (i + 1),
+                                    SLAC_INFO.array[i].AAG_quality_refined,
+                                    SLAC_INFO.array[i].AAG_quality_ori,
+                                    SLAC_INFO.array[i].AttenProfileCnt,
+                                    SLAC_INFO.array[i].MnbcSoundNum);
+                            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                        }
+                        else
+                        {
+                            sprintf(buf_log_evcomm,
+                                    "[SLAC][Tx]CM_ATTEN_CHAR_IND[%d]: unexpected CM_ATTEN_CHAR_IND_retry(%d))",
+                                    i,
+                                    EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry);
+                            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                        }
+
+                        DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacketSize=%d,Rtn=%d\n", SendMmePacketSize,count);
+                    } //end of for loop
+
+                    Update_V2G_Flow_Status(CM_ATTEN_CHAR_IND);
+                    ftime(&SeqStartTime);
+    	        }
+    	        break;
+            }
+            #else
+            {
+                ftime(&SeqEndTime);
+                //printf("time:%.02lf, profilNum:%d\n",DiffTimeb(SeqStartTime, SeqEndTime),AttenProfileCnt);  //added by Vern
+
+    	        if(DiffTimeb(SeqStartTime, SeqEndTime) > TT_EVSE_match_MNBC || (AttenProfileCnt >= MnbcSoundNum) || (EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry > 0))
+                {
+                    memset(&SendMmePacket, 0, sizeof(struct MmeHeader));
+                    memcpy(SendMmePacket.ODA, EvMac, 6);
+                    memcpy(SendMmePacket.OSA, CsuMac, 6);
+                    SendMmePacket.MTYPE = htons(EtherType_HomePlug);
+                    SendMmePacket.MMV = 0x01;
+                    SendMmePacket.MMTYPE = MMTYPE_CM_ATTEN_CHAR_IND;
+                    SendMmePacket.FMI[0] = SendMmePacket.FMI[1] = 0;
+                    SendMmePacketSize = 0;
+                    SendMmePacket.MMENTRY[SendMmePacketSize++] = 0;    //APPLICATION_TYPE(0x00: EV-EVSE Matching)
+                    SendMmePacket.MMENTRY[SendMmePacketSize++] = 0;    //SECURITY_TYPE(0x00: No Security)
+                    memcpy(SendMmePacket.MMENTRY + SendMmePacketSize, EvMac, 6); //SOURCE_ADDRESS, MAC address of the EV Host
+                    SendMmePacketSize += 6;
+                    memcpy(SendMmePacket.MMENTRY+SendMmePacketSize, SlacRunId, sizeof(SlacRunId));
+                    SendMmePacketSize += sizeof(SlacRunId);
+                    memset(SendMmePacket.MMENTRY+SendMmePacketSize, 0, 17);    //SOURCE_ID
+                    SendMmePacketSize += 17;
+                    memset(SendMmePacket.MMENTRY+SendMmePacketSize, 0, 17);    //RESP_ID
+                    SendMmePacketSize += 17;
+                    SendMmePacket.MMENTRY[SendMmePacketSize++] = AttenProfileCnt;    //NumSounds
+                    SendMmePacket.MMENTRY[SendMmePacketSize++] = AagGroupsNum;    //NumGroups
+                    for(count=0; count < AagGroupsNum; count++)
+                    {
+                        unsigned char TmpAag;
+                        TmpAag = ((Aag[count] / AttenProfileCnt) & 0xFF);
+                        #if (SUDO_PSD_PARAMETER_MECHANISM == ENABLE)    //default: ENABLE
+                            #if 1
+                            //TC_SECC_VTB_AttenuationCharacterization_019
+                            TmpAag = TmpAag >> 1;   //new method proposed by Joseph (divided by 2)
+                            #else
+                            if(TmpAag >= 39)        //original method proposed by Vern
+                            {
+                                /*
+                                // [To-do] If this statement is enabled, SLAC will fail due to timeout.
+                                {
+                                    unsigned char TmpBuf[64];
+                                    memset(TmpBuf,0,sizeof(TmpBuf));
+                                    sprintf(TmpBuf,"SlacComm: bad Aag[%d]=%d",count,TmpAag);
+                                    SAVE_SYS_LOG_MSG_EVCOMM(TmpBuf);
+                                }
+                                */
+                                printf("%d,", TmpAag);
+                                TmpAag = 37;
+                            }
+                            #endif
+                        #endif
+                        SendMmePacket.MMENTRY[SendMmePacketSize++] = TmpAag;
+                    }
+                    SendMmePacketSize += 19;      //the size before MMENTRY
+
+                    #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == TRUE)
+                    {
+                        DEBUG_PRINTF_EVCOMM_DETAIL("\n\n***** Send MME Packet *****\n");
+                        DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.ODA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+                               SendMmePacket.ODA[0],SendMmePacket.ODA[1],SendMmePacket.ODA[2],SendMmePacket.ODA[3],SendMmePacket.ODA[4],SendMmePacket.ODA[5]);
+                        DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacket.OSA: %02x:%02x:%02x:%02x:%02x:%02x:\n",
+                               SendMmePacket.OSA[0],SendMmePacket.OSA[1],SendMmePacket.OSA[2],SendMmePacket.OSA[3],SendMmePacket.OSA[4],SendMmePacket.OSA[5]);
+                        DEBUG_PRINTF_EVCOMM_DETAIL("MTYPE: 0x%x\n", htons(SendMmePacket.MTYPE));
+                        DEBUG_PRINTF_EVCOMM_DETAIL("MMV: 0x%x\n", SendMmePacket.MMV);
+                        DEBUG_PRINTF_EVCOMM_DETAIL("MMTYPE: 0x%x\n", SendMmePacket.MMTYPE);
+                        DEBUG_PRINTF_EVCOMM_DETAIL("FMI 0x%x, 0x%x\n", SendMmePacket.FMI[0],SendMmePacket.FMI[1]);
+                        DEBUG_PRINTF_EVCOMM_DETAIL("--- CM_ATTEN_CHAR_IND ---\n");
+                        DEBUG_PRINTF_EVCOMM_DETAIL("APPLICATION_TYPE: 0x%x\n", SendMmePacket.MMENTRY[0]);
+                        DEBUG_PRINTF_EVCOMM_DETAIL("SECURITY_TYPE: 0x%x\n", SendMmePacket.MMENTRY[1]);
+                        DEBUG_PRINTF_EVCOMM_DETAIL("SOURCE_ADDRESS: %02x:%02x:%02x:%02x:%02x:%02x\n",
+                               SendMmePacket.MMENTRY[2],SendMmePacket.MMENTRY[3],SendMmePacket.MMENTRY[4],SendMmePacket.MMENTRY[5],
+                               SendMmePacket.MMENTRY[6],SendMmePacket.MMENTRY[7]);
+                        DEBUG_PRINTF_EVCOMM_DETAIL("RunID: %02x,%02x,%02x,%02x,%02x,%02x,%02x,%02x\n",
+                               SendMmePacket.MMENTRY[8],SendMmePacket.MMENTRY[9],SendMmePacket.MMENTRY[10],SendMmePacket.MMENTRY[11],
+                               SendMmePacket.MMENTRY[12],SendMmePacket.MMENTRY[13],SendMmePacket.MMENTRY[14],SendMmePacket.MMENTRY[15]);
+                        DEBUG_PRINTF_EVCOMM_DETAIL("SOURCE_ID: \n");
+                        for(count=0; count<17; count++)
+                        {
+                            DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[16+count]);
+                        }
+                        DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+                        DEBUG_PRINTF_EVCOMM_DETAIL("RESP_ID: \n");
+                        for(count=0; count<17; count++)
+                        {
+                            DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[33+count]);
+                        }
+                        DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+                        DEBUG_PRINTF_EVCOMM_DETAIL("NumSounds: 0x%x\n", SendMmePacket.MMENTRY[50]);
+                        DEBUG_PRINTF_EVCOMM_DETAIL("ATTEN_PROFILE: \n");
+                        for(count=0; count<AagGroupsNum; count++)
+                        {
+                            DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ",SendMmePacket.MMENTRY[51+count]);
+                        }
+                        DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+                    }
+                    #endif
+
+                    Update_V2G_Flow_Status(CM_ATTEN_CHAR_IND);
+                    count = sendto(RawSock, &SendMmePacket, SendMmePacketSize, 0, (struct sockaddr*)&DestSocketAddress, sizeof(struct sockaddr_ll));
+
+                    //Print log if this CM_ATTEN_CHAR_IND belongs to RETRY Tx message.
+                    if (EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry > 0)
+                    {
+                        sprintf(buf_log_evcomm,
+                                "[SLAC][Tx]CM_ATTEN_CHAR_IND: resend(%d-th)",
+                                EVCOMM_SYS_INFO.CM_ATTEN_CHAR_IND_retry);
+                        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    }
+
+                    DEBUG_PRINTF_EVCOMM_DETAIL("SendMmePacketSize=%d,Rtn=%d\n", SendMmePacketSize,count);
+
+                    ftime(&SeqStartTime);
+    	        }
+    	        break;
+            }
+            #endif
+		}
+
+	    case CM_ATTEN_CHAR_IND:
+		{
+	        ftime(&SeqEndTime);
+	        //if(DiffTimeb(SeqStartTime, SeqEndTime)>TT_match_response)
+	        if(DiffTimeb(SeqStartTime, SeqEndTime) > TT_match_response)     //extended to 400ms due to the response of CM_ATTEN_CHAR.RSP of some EVCC is slower than 200ms.
+	        {
+	         	sprintf(buf_log_evcomm,
+                        	"SlacComm: Wait CM_ATTEN_CHAR_RSP Timeout - TT_match_response (%.02lf of %dms)",
+                        	DiffTimeb(SeqStartTime, SeqEndTime),
+                        	TT_match_response);
+               	 	SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+	                //Update_ShmStatusCode(); //[To-Do] to be implemented
+	                //CCS_SECC_TIMEOUT_SLAC_CM_ATTEN_CHAR_RSP (023814): 
+	                //[Possible Reason] Frequent on BMW i3, need to drive the EV a bit.
+	                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+	                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+	                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+	                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+	                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
+	                ShmStatusCodeData->PresentStatusCode[0][5] = 4;
+	                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+	                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+
+		         Update_V2G_Flow_Status(Sequence_Timeout);
+		         return -1;
+	        }
+	        break;
+		}
+
+	    case CM_ATTEN_CHAR_RSP:
+		{
+	        	ftime(&SeqEndTime);
+		        if(DiffTimeb(SeqStartTime, SeqEndTime) > TT_EVSE_match_session)
+		        {
+		        	sprintf(buf_log_evcomm,
+		                        "SlacComm: Wait CM_VALIDATE_REQ_1ST or CM_SLAC_MATCH_REQ Timeout - TT_EVSE_match_session (%.02lf of %dms)",
+		                        DiffTimeb(SeqStartTime, SeqEndTime),
+		                        TT_EVSE_match_session);
+	                	SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	
+		                //Update_ShmStatusCode(); //[To-Do] to be implemented
+		                //CCS_SECC_TIMEOUT_SLAC_CM_VALIDATE_REQ_1ST__CM_SLAC_MATCH_REQ (023815): 
+		                //[Possible Reason] Frequent on BMW i3, need to drive the EV a bit.
+		                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+		                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
+		                ShmStatusCodeData->PresentStatusCode[0][5] = 5;
+		                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+	
+		            	Update_V2G_Flow_Status(Sequence_Timeout);
+		            return -1;
+		        }
+	        	break;
+		}
+
+	    case CM_VALIDATE_CNF:
+		{
+	        	ftime(&SeqEndTime);
+		        if(DiffTimeb(SeqStartTime, SeqEndTime) > TT_match_sequence)
+		        {
+		            	sprintf(buf_log_evcomm,
+		                        "SlacComm: Wait CM_VALIDATE_REQ_2ND or CM_SLAC_MATCH_REQ Timeout - TT_match_sequence (%.02lf of %dms)",
+		                        DiffTimeb(SeqStartTime, SeqEndTime),
+		                        TT_match_sequence);
+			                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+		
+		                //Update_ShmStatusCode(); //[To-Do] to be implemented
+		                //CCS_SECC_TIMEOUT_SLAC_CM_VALIDATE_REQ_2ND__CM_SLAC_MATCH_REQ (023819): 
+		                //[Possible Reason] Frequent on BMW i3, need to drive the EV a bit.
+		                ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		                ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		                ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		                ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+		                ShmStatusCodeData->PresentStatusCode[0][4] = 1;
+		                ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+		                CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+	
+		            	Update_V2G_Flow_Status(Sequence_Timeout);
+		            	return -1;
+		        }
+	        	break;
+		}
+	    case CM_AMP_MAP_CNF:	
+	    case CM_SLAC_MATCH_CNF:
+		{
+		        if(UdpSock > 0)
+		        {
+		            close(UdpSock);
+		            UdpSock = -1;
+		        }
+		        if(TcpSock > 0)
+		        {
+		            close(TcpSock);
+		            TcpSock = -1;
+		        }
+	        	ftime(&SeqStartTime);
+            		V2gTcpConnected();
+            		Update_V2G_Flow_Status(SLACC_SDP_UDP_Connection);
+            		SAVE_SYS_LOG_MSG_EVCOMM("SLAAC,SDP,UDP: connecting...");
+	       		break;
+		}
+		default:
+		{
+		    break;
+		}
+    }
+    return 0;
+}
+
+
+/*===========================================================================
+FUNCTION: V2gMsgDecoder
+DESCRIPTION:
+        1. Decode the V2GTP messages inside "msg" and save the decoded
+           messages in ccs_exi_doc_DIN, ccs_exi_doc_ISO1, and ccs_exi_doc_ISO2,
+           respectively.
+
+        2. After decoding, V2gMsg_Process() could then use
+           ccs_exi_doc_DIN, ccs_exi_doc_ISO1, or ccs_exi_doc_ISO2
+           to deal with the corresponding Response messages, respectively.
+
+PRE-CONDITION:
+        1. msg_length > 0
+
+INPUT:
+        1. msg
+        2. msg_length
+
+OUTPUT:
+        1. ccs_exi_doc_DIN     //global variable
+           ccs_exi_doc_ISO1
+           ccs_exi_doc_ISO2
+
+        2. v2g_state            //Status Flag
+                                //indicating the V2gMsg_Process_din to proceed
+                                  the next process.
+        3. return value         // < 0: ERROR
+                                // > 0: Message Type
+
+GLOBAL VARIABLES:
+=============================================================================*/
+int V2gMsgDecoder(unsigned char *msg, unsigned int msg_length, unsigned int v2g_state)
+{
+    int errn = 0;
+
+    //Checking the minimum Header size requirement
+    if(msg_length < V2GTP_MSG_HEADER_LENGTH)   //The minimum requirement should be 8-byte header.
+    {
+        errn = -1;
+        return errn;
+    }
+
+    //Decode the 1st V2GMSG: AppProtocol
+    if(v2g_state == SupportedAppProtocolRequest)   //17
+    {
+        if (errn = API_V2GMSG_EXI_Decoder_AppProtocol(msg, msg_length, &ccs_handshake) < 0)
+        {
+            DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR = %d (DEC)]V2gMsgDecoder: SupportedAppProtocolRequest()\n", errn);
+        }
+        else    //decoded successfully.
+        {
+            //PRINT_XML_DOC_supportedAppProtocolReq(&ccs_handshake);
+        }
+    }
+    //Decode the subsequent V2GMSG (DIN 70121, ISO 15118-2, ISO 15118-20)
+    else if(v2g_state > SupportedAppProtocolRequest && v2g_state <= SessionStopResponse)
+    {
+        //Decoding according to its own protocol
+        switch (ShmCcsData->CommProtocol)
+        {
+            case V2GT_MSG_PROTOCOL_DIN70121:        //0
+            {
+                //DIN
+                if(errn = API_V2GMSG_EXI_Decoder_DIN(msg, msg_length, &ccs_exi_doc_DIN) < 0)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR = %d (DEC)]V2gMsgDecoder: API_V2GMSG_EXI_Decoder_DIN()",
+                            errn);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                }
+                break;
+            }
+
+            case V2GT_MSG_PROTOCOL_ISO15118_2014:   //1
+            {
+                //ISO1
+                if(errn = API_V2GMSG_EXI_Decoder_ISO1(msg, msg_length, &ccs_exi_doc_ISO1) < 0)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR = %d (DEC)]V2gMsgDecoder: API_V2GMSG_EXI_Decoder_ISO1()",
+                            errn);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                }
+                break;
+            }
+
+            case V2GT_MSG_PROTOCOL_ISO15118_2018:   //2
+            {
+                //ISO2
+                if(errn = API_V2GMSG_EXI_Decoder_ISO2(msg, msg_length, &ccs_exi_doc_ISO2) < 0)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR = %d (DEC)]V2gMsgDecoder: API_V2GMSG_EXI_Decoder_ISO2()",
+                            errn);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                }
+                break;
+            }
+
+            default:
+                break;
+        }
+    }
+    else
+    {
+        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR = %d (DEC)]V2gMsgDecoder: Unexpected v2g_state\n", errn);
+        errn = -1;
+    }
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: encode_din_V2GTP_stream
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int encode_din_V2GTP_stream(bitstream_t *v2g_tx_stream, struct dinEXIDocument *ccs_exi_doc_DIN)
+{
+    int errn = 0;
+    *v2g_tx_stream->pos = V2GTP_HEADER_LENGTH;
+
+    errn = encode_dinExiDocument(v2g_tx_stream, ccs_exi_doc_DIN);
+    if (errn == 0)
+    {
+        //successfully encoded
+        errn = write_v2gtpHeader(v2g_tx_stream->data, (*v2g_tx_stream->pos) - V2GTP_HEADER_LENGTH, V2GTP_EXI_TYPE);
+        v2g_tx_stream->size = *v2g_tx_stream->pos;	//total length of the encoded V2GMSG.
+
+        if (errn != 0)
+        {
+            DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm][encode_din_V2GTP_stream]write_v2gtpHeader(): %d (DEC)\n", errn);
+        }
+    }
+    else
+    {
+        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm][encode_din_V2GTP_stream]encode_dinExiDocument(): %d (DEC)\n", errn);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: encode_iso1_V2GTP_stream
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int encode_iso1_V2GTP_stream(bitstream_t *v2g_tx_stream, struct iso1EXIDocument *ccs_exi_doc_ISO1)
+{
+    int errn = 0;
+    *v2g_tx_stream->pos = V2GTP_HEADER_LENGTH;
+
+    errn = encode_iso1ExiDocument(v2g_tx_stream, ccs_exi_doc_ISO1);   
+    if (errn == 0)
+    {
+        //successfully encoded
+        errn = write_v2gtpHeader(v2g_tx_stream->data, (*v2g_tx_stream->pos) - V2GTP_HEADER_LENGTH, V2GTP_EXI_TYPE);
+        v2g_tx_stream->size = *v2g_tx_stream->pos;	//total length of the encoded V2GMSG.
+
+        if (errn != 0)
+        {
+            DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm][encode_iso1_V2GTP_stream]write_v2gtpHeader(): %d (DEC)\n", errn);
+        }
+    }
+    else
+    {
+        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm][encode_iso1_V2GTP_stream]encode_iso1ExiDocument(): %d (DEC)\n", errn);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: encode_iso2_V2GTP_stream
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int encode_iso2_V2GTP_stream(bitstream_t *v2g_tx_stream, struct iso2EXIDocument *ccs_exi_doc_ISO2)
+{
+    int errn = 0;
+    *v2g_tx_stream->pos = V2GTP_HEADER_LENGTH;
+
+    errn = encode_iso2ExiDocument(v2g_tx_stream, ccs_exi_doc_ISO2);
+    if (errn == 0)
+    {
+        //successfully encoded
+        errn = write_v2gtpHeader(v2g_tx_stream->data, (*v2g_tx_stream->pos) - V2GTP_HEADER_LENGTH, V2GTP_EXI_TYPE);
+        v2g_tx_stream->size = *v2g_tx_stream->pos;	//total length of the encoded V2GMSG.
+
+        if (errn != 0)
+        {
+            DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm][encode_iso2_V2GTP_stream]write_v2gtpHeader(): %d (DEC)\n", errn);
+        }
+    }
+    else
+    {
+        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm][encode_iso2_V2GTP_stream]encode_iso2ExiDocument(): %d (DEC)\n", errn);
+    }
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: send_encoded_din_V2GTP_Stream
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int send_encoded_din_V2GTP_Stream(int AcceptFd, bitstream_t *v2g_tx_stream, struct dinEXIDocument *ccs_exi_doc_DIN)
+{
+    int errn = 0;
+
+    // STEP 1: =========== Encoding into EXI and Composing into V2GTP Stream ==========
+    errn = encode_din_V2GTP_stream(v2g_tx_stream, ccs_exi_doc_DIN);
+
+    // STEP 2: =========== Send Response Packet  ===========
+    int rtn = 0;
+    #ifdef SUPPORT_TLS_CONNECTION
+    if(EvSecurity == 0)//support security
+    {	
+		rtn = SSL_write(ssl, v2g_tx_stream->data, v2g_tx_stream->size); 
+	}
+	else
+	{
+		rtn = send(AcceptFd, v2g_tx_stream->data, v2g_tx_stream->size, 0);
+	}	
+	#else
+    rtn = send(AcceptFd, v2g_tx_stream->data, v2g_tx_stream->size, 0);
+	#endif
+	if (rtn == v2g_tx_stream->size)
+    {
+        /*
+        DEBUG_PRINTF_EVCOMM_DETAIL("[SeccComm][send_encoded_din_V2GTP_Stream] Response Message is sent ( %d / %d ). (Bytes, DEC): OK\n",
+                rtn, v2g_tx_stream->size);
+        */
+
+        //Reset all EXI doc Req/Res _isUsed Flags after each Res Tx
+
+    }
+    else if (rtn >= 0)
+    {
+        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm][send_encoded_din_V2GTP_Stream]Imcomplete Tx ( %d / %d ). (Bytes, DEC): FAIL\n",
+                                    rtn, v2g_tx_stream->size);
+    }
+    else
+    {
+        errn = rtn;
+        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][send_encoded_din_V2GTP_Stream]send(): %d (DEC)\n", errn);
+    }
+
+    //STEP 3: ========= Reset V2G MSG Flags ==========
+    init_dinBodyType(&ccs_exi_doc_DIN->V2G_Message.Body);
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: send_encoded_iso1_V2GTP_Stream
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int send_encoded_iso1_V2GTP_Stream(int AcceptFd, bitstream_t *v2g_tx_stream, struct iso1EXIDocument *ccs_exi_doc_ISO1)
+{
+    int errn = 0;
+
+    // STEP 1: =========== Encoding into EXI and Composing into V2GTP Stream ==========
+    errn = encode_iso1_V2GTP_stream(v2g_tx_stream, ccs_exi_doc_ISO1);
+    // STEP 2: =========== Send Response Packet  ===========
+    int rtn = 0;
+    #ifdef SUPPORT_TLS_CONNECTION
+    if(EvSecurity == 0)//support security
+    {	
+		rtn = SSL_write(ssl, v2g_tx_stream->data, v2g_tx_stream->size); 
+	}
+	else
+	{
+		 rtn = send(AcceptFd, v2g_tx_stream->data, v2g_tx_stream->size, 0);
+	}	
+	#else
+    rtn = send(AcceptFd, v2g_tx_stream->data, v2g_tx_stream->size, 0);
+	#endif
+	if (rtn == v2g_tx_stream->size)
+    {
+        /*
+        DEBUG_PRINTF_EVCOMM_DETAIL("[SeccComm][send_encoded_iso1_V2GTP_Stream] Response Message is sent ( %d / %d ). (Bytes, DEC): OK\n",
+                rtn, v2g_tx_stream->size);
+        */
+
+        //Reset all EXI doc Req/Res _isUsed Flags after each Res Tx
+
+    }
+    else if (rtn >= 0)
+    {
+        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm][send_encoded_iso1_V2GTP_Stream]Imcomplete Tx ( %d / %d ). (Bytes, DEC): FAIL\n",
+                                    rtn, v2g_tx_stream->size);
+    }
+    else
+    {
+        errn = rtn;
+        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][send_encoded_iso1_V2GTP_Stream]send(): %d (DEC)\n", errn);
+    }
+
+    //STEP 3: ========= Reset V2G MSG Flags ==========
+    init_iso1BodyType(&ccs_exi_doc_ISO1->V2G_Message.Body);
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: send_encoded_iso2_V2GTP_Stream
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int send_encoded_iso2_V2GTP_Stream(int AcceptFd, bitstream_t *v2g_tx_stream, struct iso2EXIDocument *ccs_exi_doc_ISO2)
+{
+    int errn = 0;
+
+    // STEP 1: =========== Encoding into EXI and Composing into V2GTP Stream ==========
+    errn = encode_iso2_V2GTP_stream(v2g_tx_stream, ccs_exi_doc_ISO2);
+
+    // STEP 2: =========== Send Response Packet  ===========
+    int rtn = 0;
+    #ifdef SUPPORT_TLS_CONNECTION
+    if(EvSecurity == 0)//support security
+    {
+		rtn = SSL_write(ssl, v2g_tx_stream->data, v2g_tx_stream->size); 
+	}
+	else
+	{
+		rtn = send(AcceptFd, v2g_tx_stream->data, v2g_tx_stream->size, 0);
+	}	
+	#else
+    rtn = send(AcceptFd, v2g_tx_stream->data, v2g_tx_stream->size, 0);
+	#endif
+	if (rtn == v2g_tx_stream->size)
+    {
+        /*
+        DEBUG_PRINTF_EVCOMM_DETAIL("[SeccComm][send_encoded_iso2_V2GTP_Stream] Response Message is sent ( %d / %d ). (Bytes, DEC): OK\n",
+                rtn, v2g_tx_stream->size);
+        */
+
+        //Reset all EXI doc Req/Res _isUsed Flags after each Res Tx
+
+    }
+    else if (rtn >= 0)
+    {
+        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][SeccComm][send_encoded_iso2_V2GTP_Stream]Imcomplete Tx ( %d / %d ). (Bytes, DEC): FAIL\n",
+                                    rtn, v2g_tx_stream->size);
+    }
+    else
+    {
+        errn = rtn;
+        DEBUG_PRINTF_EVCOMM_DETAIL("[ERROR][send_encoded_iso2_V2GTP_Stream]send(): %d (DEC)\n", errn);
+    }
+
+    //STEP 3: ========= Reset V2G MSG Flags ==========
+    init_iso2BodyType(&ccs_exi_doc_ISO2->V2G_Message.Body);
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Check_din_V2G_Rx_MSG_SessionID
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Check_din_V2G_Rx_MSG_SessionID(struct dinEXIDocument *exi_doc_DIN)
+{
+    int i = 0;
+    int leng = 0;
+    int errn = 0;
+    leng = exi_doc_DIN->V2G_Message.Header.SessionID.bytesLen;
+
+    //Step 1: Check SessionID Length
+    if (leng != 8)  //8-byte
+    {
+        sprintf(buf_log_evcomm, "[ERROR]SessionID: incorrect length(%d)", leng);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        errn = -1;
+    }
+    else
+    {
+        //Step 2-1: Check SessionID content
+        for (i = 0; i < leng; i++)
+        {
+            if (exi_doc_DIN->V2G_Message.Header.SessionID.bytes[i] != EVCOMM_SYS_INFO.SessionID[i])
+            {
+                errn = -2;
+                break;
+            }
+        }
+    }
+
+    //Step 2-2: Print Incorrect ID
+    if (errn == -2) //incorrect ID
+    {
+        sprintf(buf_log_evcomm,
+                "[ERROR]SessionID: incorrect ID(RX:%02X%02X%02X%02X%02X%02X%02X%02X, ORI:%02X%02X%02X%02X%02X%02X%02X%02X)",
+                exi_doc_DIN->V2G_Message.Header.SessionID.bytes[0],
+                exi_doc_DIN->V2G_Message.Header.SessionID.bytes[1],
+                exi_doc_DIN->V2G_Message.Header.SessionID.bytes[2],
+                exi_doc_DIN->V2G_Message.Header.SessionID.bytes[3],
+                exi_doc_DIN->V2G_Message.Header.SessionID.bytes[4],
+                exi_doc_DIN->V2G_Message.Header.SessionID.bytes[5],
+                exi_doc_DIN->V2G_Message.Header.SessionID.bytes[6],
+                exi_doc_DIN->V2G_Message.Header.SessionID.bytes[7],
+                EVCOMM_SYS_INFO.SessionID[0],
+                EVCOMM_SYS_INFO.SessionID[1],
+                EVCOMM_SYS_INFO.SessionID[2],
+                EVCOMM_SYS_INFO.SessionID[3],
+                EVCOMM_SYS_INFO.SessionID[4],
+                EVCOMM_SYS_INFO.SessionID[5],
+                EVCOMM_SYS_INFO.SessionID[6],
+                EVCOMM_SYS_INFO.SessionID[7]
+            );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+
+    //Step 3: Correct SessionID for Res Message
+    if (errn != 0)
+    {
+        exi_doc_DIN->V2G_Message.Header.SessionID.bytesLen = 8;
+        memset(exi_doc_DIN->V2G_Message.Header.SessionID.bytes, 0, 8);
+        memcpy(exi_doc_DIN->V2G_Message.Header.SessionID.bytes, EVCOMM_SYS_INFO.SessionID, 8);
+    }
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Check_iso1_V2G_Rx_MSG_SessionID
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Check_iso1_V2G_Rx_MSG_SessionID(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    int i = 0;
+    int leng = 0;
+    int errn = 0;
+    leng = exi_doc_ISO1->V2G_Message.Header.SessionID.bytesLen;
+
+    //Step 1: Check SessionID Length
+    if (leng != 8)  //8-byte
+    {
+        sprintf(buf_log_evcomm, "[ERROR]SessionID: incorrect length(%d)", leng);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        errn = -1;
+    }
+    else
+    {
+        //Step 2-1: Check SessionID content
+        for (i = 0; i < leng; i++)
+        {
+            if (exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[i] != EVCOMM_SYS_INFO.SessionID[i])
+            {
+                errn = -2;
+                break;
+            }
+        }
+    }
+
+    //Step 2-2: Print Incorrect ID
+    if (errn == -2) //incorrect ID
+    {
+        sprintf(buf_log_evcomm,
+                "[ERROR]SessionID: incorrect ID(RX:%02X%02X%02X%02X%02X%02X%02X%02X, ORI:%02X%02X%02X%02X%02X%02X%02X%02X)",
+                exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[0],
+                exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[1],
+                exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[2],
+                exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[3],
+                exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[4],
+                exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[5],
+                exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[6],
+                exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[7],
+                EVCOMM_SYS_INFO.SessionID[0],
+                EVCOMM_SYS_INFO.SessionID[1],
+                EVCOMM_SYS_INFO.SessionID[2],
+                EVCOMM_SYS_INFO.SessionID[3],
+                EVCOMM_SYS_INFO.SessionID[4],
+                EVCOMM_SYS_INFO.SessionID[5],
+                EVCOMM_SYS_INFO.SessionID[6],
+                EVCOMM_SYS_INFO.SessionID[7]
+            );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+
+    //Step 3: Correct SessionID for Res Message
+    if (errn != 0)
+    {
+        exi_doc_ISO1->V2G_Message.Header.SessionID.bytesLen = 8;
+        memset(exi_doc_ISO1->V2G_Message.Header.SessionID.bytes, 0, 8);
+        memcpy(exi_doc_ISO1->V2G_Message.Header.SessionID.bytes, EVCOMM_SYS_INFO.SessionID, 8);
+    }
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Check_iso2_V2G_Rx_MSG_SessionID
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Check_iso2_V2G_Rx_MSG_SessionID(struct iso2EXIDocument *exi_doc_ISO2)
+{
+    int i = 0;
+    int leng = 0;
+    int errn = 0;
+    leng = exi_doc_ISO2->V2G_Message.Header.SessionID.bytesLen;
+
+    //Step 1: Check SessionID Length
+    if (leng != 8)  //8-byte
+    {
+        sprintf(buf_log_evcomm, "[ERROR]SessionID: incorrect length(%d)", leng);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        errn = -1;
+    }
+    else
+    {
+        //Step 2-1: Check SessionID content
+        for (i = 0; i < leng; i++)
+        {
+            if (exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[i] != EVCOMM_SYS_INFO.SessionID[i])
+            {
+                errn = -2;
+                break;
+            }
+        }
+    }
+
+    //Step 2-2: Print Incorrect ID
+    if (errn == -2) //incorrect ID
+    {
+        sprintf(buf_log_evcomm,
+                "[ERROR]SessionID: incorrect ID(RX:%02X%02X%02X%02X%02X%02X%02X%02X, ORI:%02X%02X%02X%02X%02X%02X%02X%02X)",
+                exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[0],
+                exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[1],
+                exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[2],
+                exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[3],
+                exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[4],
+                exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[5],
+                exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[6],
+                exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[7],
+                EVCOMM_SYS_INFO.SessionID[0],
+                EVCOMM_SYS_INFO.SessionID[1],
+                EVCOMM_SYS_INFO.SessionID[2],
+                EVCOMM_SYS_INFO.SessionID[3],
+                EVCOMM_SYS_INFO.SessionID[4],
+                EVCOMM_SYS_INFO.SessionID[5],
+                EVCOMM_SYS_INFO.SessionID[6],
+                EVCOMM_SYS_INFO.SessionID[7]
+            );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+
+    //Step 3: Correct SessionID for Res Message
+    if (errn != 0)
+    {
+        exi_doc_ISO2->V2G_Message.Header.SessionID.bytesLen = 8;
+        memset(exi_doc_ISO2->V2G_Message.Header.SessionID.bytes, 0, 8);
+        memcpy(exi_doc_ISO2->V2G_Message.Header.SessionID.bytes, EVCOMM_SYS_INFO.SessionID, 8);
+    }
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: GetSchemaID_of_Protocol
+DESCRIPTION:
+    1. Get the SchemaID accroding to the input target
+        *V2GT_MSG_PROTOCOL_DIN70121: choose DIN 70121
+        *V2GT_MSG_PROTOCOL_ISO15118_2014: choose ISO 15118-2 (ed1)
+        *V2GT_MSG_PROTOCOL_ISO15118_2018: choose ISO 15118-20 (ed2)
+        *V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY: choose the one with the highest priority
+
+    2. [To-do] Checking Major and Minor version
+    3. The parsing method will not support those private protocols,
+       such as "usr:tesla...," since "tesla" is 5 bytes but "din" and "iso" are 3 bytes.
+
+    4. [To-do] If the target is selected as DIN," but there is no DIN.
+               However, if EV and EVSE all support ISO, how to use ISO instead?
+
+PRE-CONDITION:
+INPUT:
+    1. target: target protocol
+
+OUTPUT:
+    1. id: SchemaID of selected protocol by EVSE
+    2. ShmCcsData->CommProtocol  (selected protocol)
+    3. SupportedAppProtocol_result
+        (1) appHandresponseCodeType_OK_SuccessfulNegotiation = 0,
+        (2) appHandresponseCodeType_OK_SuccessfulNegotiationWithMinorDeviation = 1,
+        (3) appHandresponseCodeType_Failed_NoNegotiation = 2
+
+GLOBAL VARIABLES:
+    1. ccs_handshake
+    2. ShmCcsData
+=============================================================================*/
+int GetSchemaID_of_Protocol(unsigned char target)
+{
+    int i = 0;
+    int ii = 0;
+    int id = 0;
+    unsigned char tmp = 0;
+    unsigned char pri = 20; //priority = 1(highest)~20(lowerest)
+    char num[10];
+
+    //struct CCS_ProtocolNamespacestructCharacters pro;
+
+    //Choose the 1st protocol as default.
+    //id = CCS_HANDSHAKE_PROTOCOLS.array[0].SchemaID;
+    id = -1;
+    ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_DIN70121;
+
+    for(i = 0; i < CCS_HANDSHAKE_PROTOCOLS.arrayLen; i++)
+    {
+        //Checking for <ProtocolNamespace>urn:din:70121:2012:MsgDef</ProtocolNamespace>
+        //[To-Do] Ignoring the priority from EV and force DIN 70121 as our only option. (for temp)
+
+        //[CAUTION] The parsing method will not support those private protocols, such as "usr:tesla..."
+        num[0] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[8];
+        num[1] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[9];
+        num[2] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[10];
+        num[3] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[11];
+        num[4] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[12];
+        num[5] = '\0';
+
+        if (atoi(num) == 70121)
+        {
+            sprintf(buf_log_evcomm,
+                    "[GetSchemaID_of_Protocol]supported(%d-th/%d): DIN 70121(%d:v%d.%d;id=%d,pri=%d)",
+                    (i+1),
+                    CCS_HANDSHAKE_PROTOCOLS.arrayLen,
+                    atoi(num),
+                    CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
+                    CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
+                    CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
+                    CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+			#ifdef AWCCS
+			continue;
+			#endif
+            if (target == V2GT_MSG_PROTOCOL_DIN70121)
+            {
+                sprintf(buf_log_evcomm,
+                        "[GetSchemaID_of_Protocol]selected(%d-th/%d): DIN 70121(%d:v%d.%d;id=%d,pri=%d)",
+                        (i+1),
+                        CCS_HANDSHAKE_PROTOCOLS.arrayLen,
+                        atoi(num),
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+                if (CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor == DIN_SPEC_70121_2012_VersionNumberMajor)
+                {
+                    if (CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor == DIN_SPEC_70121_2012_VersionNumberMinor)
+                    {
+                        EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_OK_SuccessfulNegotiation;
+                    }
+                    else
+                    {   //[TC_SECC_VTB_SupportedAppProtocol_005]
+                        EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_OK_SuccessfulNegotiationWithMinorDeviation;
+                    }
+                    id = CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID;
+                    ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_DIN70121;
+                    return id;
+                }
+                else
+                {
+                    //keep looking for the suitable protocol
+                }
+            }
+            else if (target == V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY)
+            {
+                if (pri > CCS_HANDSHAKE_PROTOCOLS.array[i].Priority)
+                {
+                    ii = i;
+                    id = CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID;
+                    pri = CCS_HANDSHAKE_PROTOCOLS.array[i].Priority;
+                    ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_DIN70121;
+                }
+                else
+                {
+                    //not using this SchemaID, and keep looking for that SchemaID with higer priority
+                }
+            }
+            else
+            {
+                //null
+            }
+        }
+        else if (atoi(num) == 15118)
+        {
+            //urn:din:70121:2012:MsgDef
+            //urn:iso:15118:2:2013:MsgDef
+            memset(num, 0, sizeof(num));
+            num[0] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[16];
+            num[1] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[17];
+            num[2] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[18];
+            num[3] = CCS_HANDSHAKE_PROTOCOLS.array[i].ProtocolNamespace.characters[19];
+            num[4] = '\0';
+
+            if (atoi(num) < 2018 && atoi(num) >= 2010)
+            {
+                sprintf(buf_log_evcomm,
+                        "[GetSchemaID_of_Protocol]supported(%d-th/%d): ISO 15118-2(ed1,%d:v%d.%d;id=%d,pri=%d)",
+                        (i+1),
+                        CCS_HANDSHAKE_PROTOCOLS.arrayLen,
+                        atoi(num),
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+                if (target == V2GT_MSG_PROTOCOL_ISO15118_2014)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[GetSchemaID_of_Protocol]selected(%d-th/%d): ISO 15118-2,ed1(%d:v%d.%d;id=%d,pri=%d)",
+                            (i+1),
+                            CCS_HANDSHAKE_PROTOCOLS.arrayLen,
+                            atoi(num),
+                            CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
+                            CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
+                            CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
+                            CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+                    if (CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor == ISO1_15118_2013_VersionNumberMajor)
+                    {
+                        if (CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor == ISO1_15118_2013_VersionNumberMinor)
+                        {
+                            EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_OK_SuccessfulNegotiation;
+                        }
+                        else
+                        {
+                            EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_OK_SuccessfulNegotiationWithMinorDeviation;
+                        }
+                        id = CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID;
+                        ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_ISO15118_2014;
+                        return id;
+                    }
+                    else
+                    {
+                        //keep looking for the suitable protocol
+                    }
+                }
+                else if (target == V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY)
+                {
+                    if (pri > CCS_HANDSHAKE_PROTOCOLS.array[i].Priority)
+                    {
+                        ii = i;
+                        id = CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID;
+                        pri = CCS_HANDSHAKE_PROTOCOLS.array[i].Priority;
+                        ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_ISO15118_2014;
+                    }
+                    else
+                    {
+                        //not using this SchemaID, and keep looking for that SchemaID with higer priority
+                    }
+                }
+                else
+                {
+                    //null
+                }
+            }
+            else if (atoi(num) >= 2018 && atoi(num) <= 2100)    // >= 2018
+            {
+                sprintf(buf_log_evcomm,
+                        "[GetSchemaID_of_Protocol]supported(%d-th/%d): ISO 15118-20(ed2,%d:v%d.%d;id=%d,pri=%d)",
+                        (i+1),
+                        CCS_HANDSHAKE_PROTOCOLS.arrayLen,
+                        atoi(num),
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+                if (target == V2GT_MSG_PROTOCOL_ISO15118_2018)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[GetSchemaID_of_Protocol]selected(%d-th/%d): ISO 15118-20,ed2(%d:v%d.%d;id=%d,pri=%d)",
+                            (i+1),
+                            CCS_HANDSHAKE_PROTOCOLS.arrayLen,
+                            atoi(num),
+                            CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
+                            CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
+                            CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
+                            CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+                    if (CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor == ISO2_15118_2018_VersionNumberMajor)
+                    {
+                        if (CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor == ISO2_15118_2018_VersionNumberMinor)
+                        {
+                            EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_OK_SuccessfulNegotiation;
+                        }
+                        else
+                        {
+                            EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_OK_SuccessfulNegotiationWithMinorDeviation;
+                        }
+                        id = CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID;
+                        ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_ISO15118_2018;
+                        return id;
+                    }
+                    else
+                    {
+                        //keep looking for the suitable protocol
+                    }
+                }
+                else if (target == V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY)
+                {
+                    if (pri > CCS_HANDSHAKE_PROTOCOLS.array[i].Priority)
+                    {
+                        ii = i;
+                        id = CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID;
+                        pri = CCS_HANDSHAKE_PROTOCOLS.array[i].Priority;
+                        ShmCcsData->CommProtocol = V2GT_MSG_PROTOCOL_ISO15118_2018;
+                    }
+                    else
+                    {
+                        //not using this SchemaID, and keep looking for that SchemaID with higer priority
+                    }
+                }
+                else
+                {
+                    //null
+                }
+            }
+            else
+            {
+                //Unexpected Year
+                sprintf(buf_log_evcomm,
+                        "[GetSchemaID_of_Protocol]unsupported(%d-th/%d): ISO 15118-X(unexpected year:%d,v%d.%d),id=%d,pri=%d",
+                        (i+1),
+                        CCS_HANDSHAKE_PROTOCOLS.arrayLen,
+                        atoi(num),
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
+                        CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                //return -1;
+            }
+        }
+        else
+        {
+            sprintf(buf_log_evcomm,
+                    "[GetSchemaID_of_Protocol]unsupported protocol(%d-th/%d)(%d:v%d.%d;id=%d,pri=%d)",
+                    (i+1),
+                    CCS_HANDSHAKE_PROTOCOLS.arrayLen,
+                    atoi(num),
+                    CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMajor,
+                    CCS_HANDSHAKE_PROTOCOLS.array[i].VersionNumberMinor,
+                    CCS_HANDSHAKE_PROTOCOLS.array[i].SchemaID,
+                    CCS_HANDSHAKE_PROTOCOLS.array[i].Priority);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            //return -1;
+        }
+    }
+
+    //The final result of highest priority protocol
+    sprintf(buf_log_evcomm,
+            "[GetSchemaID_of_Protocol]selected(%d-th/%d): pro=%d(0:DIN,1:ISO1,2:ISO2);id=%d,pri=%d",
+            (ii+1),
+            CCS_HANDSHAKE_PROTOCOLS.arrayLen,
+            ShmCcsData->CommProtocol,
+            id,
+            pri);
+    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+    if (id < 0)
+    {
+        EVCOMM_SYS_INFO.SupportedAppProtocol_result = appHandresponseCodeType_Failed_NoNegotiation;
+    }
+
+    return id;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_supportedAppProtocolRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_supportedAppProtocolRes(int AcceptFd)
+{
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct ChargingInfoData *sys;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    //STEP 1: =========== Setting the Response Message ===========
+	init_appHandEXIDocument(&ccs_handshake);
+    ccs_handshake.supportedAppProtocolRes.ResponseCode = appHandresponseCodeType_OK_SuccessfulNegotiation;
+	ccs_handshake.supportedAppProtocolRes_isUsed = 1u;
+
+    //select the 1st one as the default
+    ccs_handshake.supportedAppProtocolRes.SchemaID = CCS_HANDSHAKE_PROTOCOLS.array[0].SchemaID;
+    ccs_handshake.supportedAppProtocolRes.SchemaID_isUsed = 1u;
+    int id = 0;
+    /*+++ 20200808, vern, support both DIN and ISO +++*/
+    id = GetSchemaID_of_Protocol(V2GT_MSG_PROTOCOL_PREFERENCE); //output: EVCOMM_SYS_INFO.SupportedAppProtocol_result
+    //id = GetSchemaID_of_Protocol(V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY); //output: EVCOMM_SYS_INFO.SupportedAppProtocol_result
+       /*--- 20200808, vern, support both DIN and ISO ---*/
+    ccs_handshake.supportedAppProtocolRes.ResponseCode = EVCOMM_SYS_INFO.SupportedAppProtocol_result;   //updating the response code
+    if (id < 0)
+    {
+        sprintf(buf_log_evcomm,
+                "[Error]No avalible CCS protocol (id = %d, preference = %d)",
+                id,
+                V2GT_MSG_PROTOCOL_PREFERENCE);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    else
+    {
+        //selected SchemaID
+        ccs_handshake.supportedAppProtocolRes.SchemaID = (unsigned char) id;
+    }
+
+
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_supportedAppProtocolRes]EVSE_Shutdown => End_Process");
+        ccs_handshake.supportedAppProtocolRes.ResponseCode = appHandresponseCodeType_Failed_NoNegotiation;
+        errn = -1;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_supportedAppProtocolRes]EVSE_EmergencyShutdown => End_Process");
+        ccs_handshake.supportedAppProtocolRes.ResponseCode = appHandresponseCodeType_Failed_NoNegotiation;
+        errn = -1;
+    }
+    else
+    {
+        //null
+    }
+
+    //Check for Permission Changing from TRUE to FALSE
+    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
+    if (ShmInternalComm->ChargingPermission_pre >=1 &&
+        ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][DIN][supportedAppProtocolRes]Permission OFF");
+        ccs_handshake.supportedAppProtocolRes.ResponseCode = appHandresponseCodeType_Failed_NoNegotiation;
+        //errn = -1;
+    }
+
+    #if (CP_PROTECTION_MECHANISM == ENABLE)
+    {
+        #if (SLAC_FIRST_RESPONSE_METHOD == SET_5_PWM_ONCE_GET_PERMISSION_IN_AUTHORIZATIONRES)
+        {
+            //Detect for CP State should be 9V with 5% PWM or 100%PWM (State B1, B2)
+            if (sys->CpState != 2 && sys->CpState != 3)  //State B1, B2
+            {
+                ccs_handshake.supportedAppProtocolRes.ResponseCode = appHandresponseCodeType_Failed_NoNegotiation;
+                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+                Update_V2G_Flow_Status(Other_Fault);
+                sprintf(buf_log_evcomm,
+                        "[Proc_supportedAppProtocolRes]Emergency Stop by CP Error (%d, %.02f V)\n",
+                        sys->CpState,
+                        sys->CpVoltage);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            }
+        }
+        #else
+        {
+            //Detect for CP State should be 9V (State B)
+            if (sys->CpState != 3)  //B2
+            {
+                ccs_handshake.supportedAppProtocolRes.ResponseCode = appHandresponseCodeType_Failed_NoNegotiation;
+                CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+                Update_V2G_Flow_Status(Other_Fault);
+                sprintf(buf_log_evcomm,
+                        "[Proc_supportedAppProtocolRes]Emergency Stop by CP Error (%d, %.02f V)\n",
+                        sys->CpState,
+                        sys->CpVoltage);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            }
+        }
+        #endif
+    }
+    #endif
+
+
+    //STEP 2: =========== Encode into EXI ===========
+    if (errn = API_V2GMSG_EXI_Encoder_AppProtocol(&ccs_handshake, &v2g_tx_stream) !=0)
+    {
+        DEBUG_PRINTF_EVCOMM_DETAIL("\n[Error]API_V2GMSG_EXI_Encoder_AppProtocol\n");
+        return errn;
+    }
+
+    //STEP 3: =========== Send Response Packet ===========
+    int Rtn = 0;
+	#ifdef SUPPORT_TLS_CONNECTION
+	if(EvSecurity == 0)//support security
+    {
+		Rtn = SSL_write(ssl, v2g_tx_stream.data, v2g_tx_stream.size); 
+	}
+	else
+	{
+		Rtn = send(AcceptFd, v2g_tx_stream.data, v2g_tx_stream.size, 0);
+	}	
+	#else
+	Rtn = send(AcceptFd, v2g_tx_stream.data, v2g_tx_stream.size, 0);
+	#endif
+    //Rtn = send(6, v2g_tx_stream.data, v2g_tx_stream.size, 0);
+
+    DEBUG_PRINTF_EVCOMM_DETAIL("Send V2GTP Packet Size = %d, Rtn = %d (Bytes, DEC)\n", v2g_tx_stream.size, Rtn);
+
+    if (Rtn < 0)
+    {
+        return Rtn;
+    }
+
+    //STEP 4: =========== Save into Share Memory =========
+	//[Joseph, To-Do] Adding a mechanism to choose DIN 70121 as our 1st priority. (for multiple protocols)
+
+    //STEP 5: =========== Updating the Flow State Flag =========
+    if (id < 0)
+    {
+        errn = -1;
+    }
+
+    //STEP 6: ===========  Reset Flags ============
+    //Reset all EXI doc Req/Res _isUsed Flags after each Res Tx
+    init_appHandEXIDocument(&ccs_handshake);
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_supportedAppProtocolReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_supportedAppProtocolReq(int AcceptFd)
+{
+    //[Joseph, To-Do] analysis on Req message and choose the prefered protocol
+    //Default: DIN 70121 (find SchemaID)
+    int errn = 0;
+
+    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]supportedAppProtocolReq");
+    SHM_Save_din_supportedAppProtocolReq(ShmCcsData, &ccs_handshake, ShmSysConfigAndInfo);
+
+    errn = Proc_supportedAppProtocolRes(AcceptFd);
+    if (errn == 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Tx]supportedAppProtocolRes");
+    }
+    else
+    {
+        DEBUG_PRINTF_EVCOMM_DETAIL("[Error]Proc_supportedAppProtocolRes(): %d (DEC)\n", errn);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_din_SessionSetupRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_SessionSetupRes(int AcceptFd)
+{
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct ChargingInfoData *sys;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+
+    init_dinBodyType(&ccs_exi_doc_DIN.V2G_Message.Body);
+    init_dinSessionSetupResType(&ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes);
+
+
+    // ====== [BODY (1/2) ResponseCode ======
+    ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes_isUsed = 1u;
+    ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = dinresponseCodeType_OK_NewSessionEstablished;
+
+
+    //[HEADER] Assign Res SessionID
+    ccs_exi_doc_DIN.V2G_Message.Header.SessionID.bytesLen = 8;
+    memset(ccs_exi_doc_DIN.V2G_Message.Header.SessionID.bytes, 0, 8);
+    memcpy(ccs_exi_doc_DIN.V2G_Message.Header.SessionID.bytes, EVCOMM_SYS_INFO.SessionID, 8);
+
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = dinresponseCodeType_FAILED_SequenceError;
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //#if PARAMETER_NORMAL_MODE == ENABLE
+    //SHM_Read_din_V2GMSG_Header(&ccs_exi_doc_DIN, ShmCcsData);
+    //#endif
+
+
+    //Detect for CP State should be 9V (State B)
+    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
+    {
+	    #if CP_PROTECTION_MECHANISM == ENABLE
+        ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = dinresponseCodeType_FAILED;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+
+        sprintf(buf_log_evcomm,
+                "[Proc_din_SessionSetupRes]Emergency Stop by CP Error (%d)\n",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #else
+        sprintf(buf_log_evcomm,
+                "[Proc_din_SessionSetupRes]Emergency Stop by CP Error (%d): ignored\n",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #endif
+    }
+
+    //Check for shutdown commands from EVSE(DC Main Board)
+    if (/*sys->DC_EVSEStatus == EVSE_Shutdown ||*/
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = dinresponseCodeType_FAILED;
+        sprintf(buf_log_evcomm, "[Proc_din_SessionSetupRes]Stop by EVSE(%d:normal, %d:emergency): (%d)\n",
+                EVSE_Shutdown,
+                EVSE_EmergencyShutdown,
+                sys->DC_EVSEStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        errn = -1;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_Shutdown/* ||
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown*/)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = dinresponseCodeType_FAILED;
+        sprintf(buf_log_evcomm, "[Proc_din_SessionSetupRes]Stop by EVSE(%d:normal, %d:emergency): (%d)\n",
+                EVSE_Shutdown,
+                EVSE_EmergencyShutdown,
+                sys->DC_EVSEStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        //errn = -1;
+    }
+
+    //Check for Permission Changing from TRUE to FALSE
+    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
+    if (ShmInternalComm->ChargingPermission_pre >=1 &&
+        ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][DIN][SessionSetupRes]Permission OFF");
+        ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = dinresponseCodeType_FAILED;
+        errn = -1;
+    }
+
+    // ====== [BODY (2/3) EVSEID ======
+    //EVSEID = all zero
+    memset(ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes.EVSEID.bytes, 0, sizeof(ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes.EVSEID.bytes));
+    //vern, should be encode  by SN
+    ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes.EVSEID.bytesLen = 1;  //max: DIN = 32, ISO1/ISO2 = 37 bytes
+
+    // ====== [BODY (3/3) DateTimeNow ======
+    ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes.DateTimeNow_isUsed = 1u;
+    ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes.DateTimeNow = (int64_t)time(NULL);   //[Joseph] Format: Unix Time Stamp
+
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    ///////////SHM_Read_din_SessionSetupRes(&ccs_exi_doc_DIN, ShmCcsData);
+    #endif
+
+    // ============ Encode and Send Response Message ===========
+    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_DIN) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_SessionSetupRes][Error]Tx encoded msg error");
+        errn = -1;
+    }
+
+    return errn;
+
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_SessionSetupRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_SessionSetupRes(int AcceptFd)
+{
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct ChargingInfoData *sys;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+
+    init_iso1BodyType(&ccs_exi_doc_ISO1.V2G_Message.Body);
+    init_iso1SessionSetupResType(&ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes);
+
+    // ====== [BODY (1/2) ResponseCode ======
+    ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes_isUsed = 1u;
+    ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_OK_NewSessionEstablished;
+
+
+    //[HEADER] Assign Res SessionID
+    ccs_exi_doc_ISO1.V2G_Message.Header.SessionID.bytesLen = 8;
+    memset(ccs_exi_doc_ISO1.V2G_Message.Header.SessionID.bytes, 0, 8);
+    memcpy(ccs_exi_doc_ISO1.V2G_Message.Header.SessionID.bytes, EVCOMM_SYS_INFO.SessionID, 8);
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //#if PARAMETER_NORMAL_MODE == ENABLE
+    //SHM_Read_iso1_V2GMSG_Header(&ccs_exi_doc_ISO1, ShmCcsData);
+    //#endif
+
+    //Detect for CP State should be 9V (State B)
+    //if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2	//Benz already CP=4
+    if ((sys->CpState < 2) ||(sys->CpState > 5))  //State B1, B2	//Benz already CP=4
+    {
+        #if CP_PROTECTION_MECHANISM == ENABLE
+        ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_FAILED;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+
+        sprintf(buf_log_evcomm,
+                "[Proc_iso1_SessionSetupRes]Emergency Stop by CP Error (%d)\n",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #else
+        sprintf(buf_log_evcomm,
+                "[Proc_iso1_SessionSetupRes]Emergency Stop by CP Error (%d): ignored\n",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #endif
+    }
+
+    //Check for shutdown commands from EVSE(DC Main Board)
+    if (/*sys->DC_EVSEStatus == EVSE_Shutdown ||*/
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_FAILED;
+        sprintf(buf_log_evcomm, "[Proc_iso1_SessionSetupRes]Stop by EVSE(%d:normal, %d:emergency): (%d)\n",
+                EVSE_Shutdown,
+                EVSE_EmergencyShutdown,
+                sys->DC_EVSEStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        errn = -1;
+    }
+    else   if (sys->DC_EVSEStatus == EVSE_Shutdown /*||
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown*/)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_FAILED;
+        sprintf(buf_log_evcomm, "[Proc_iso1_SessionSetupRes]Stop by EVSE(%d:normal, %d:emergency): (%d)\n",
+                EVSE_Shutdown,
+                EVSE_EmergencyShutdown,
+                sys->DC_EVSEStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    //   errn = -1;
+    }
+
+    //Check for Permission Changing from TRUE to FALSE
+    if (ShmInternalComm->ChargingPermission_pre >=1 &&
+        ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][ISO1][SessionSetupRes]Permission OFF");
+        ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_FAILED;
+        //errn = -1;
+    }
+
+    // ====== [BODY (2/3) EVSEID ======
+    //EVSEID = all zero
+    memset(ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters, 0, sizeof(ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters));
+	/*+++ 20200808, vern, set default EVSEID +++*/
+     //vern, should be encoded  by SN
+	ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[0]='Z';
+	ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[1]='Z';
+	ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[2]='0';
+	ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[3]='0';
+	ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[4]='0';
+	ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[5]='0';
+	ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.characters[6]='0';
+    	ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.EVSEID.charactersLen = 7;  //max: DIN = 32, ISO1/ISO2 = 37 bytes
+    /*--- 20200808, vern, set default EVSEID ---*/
+
+    // ====== [BODY (3/3) DateTimeNow ======
+    ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.EVSETimeStamp_isUsed = 1u;
+    ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.EVSETimeStamp = (int64_t)time(NULL);   //[Joseph] Format: Unix Time Stamp
+
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    ///////////SHM_Read_iso1_SessionSetupRes(&ccs_exi_doc_ISO1, ShmCcsData);
+    #endif
+
+
+    // ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_SessionSetupRes][Error]Tx encoded msg error");
+        errn = -1;
+    }
+
+    return errn;
+
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso2_SessionSetupRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso2_SessionSetupRes(int AcceptFd)
+{
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct ChargingInfoData *sys;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+
+    init_iso2BodyType(&ccs_exi_doc_ISO2.V2G_Message.Body);
+    init_iso2SessionSetupResType(&ccs_exi_doc_ISO2.V2G_Message.Body.SessionSetupRes);
+
+    // ====== [BODY (1/2) ResponseCode ======
+    ccs_exi_doc_ISO2.V2G_Message.Body.SessionSetupRes_isUsed = 1u;
+    ccs_exi_doc_ISO2.V2G_Message.Body.SessionSetupRes.ResponseCode = iso2responseCodeType_OK_NewSessionEstablished;
+
+
+    //[HEADER] Assign Res SessionID
+    ccs_exi_doc_ISO2.V2G_Message.Header.SessionID.bytesLen = 8;
+    memset(ccs_exi_doc_ISO2.V2G_Message.Header.SessionID.bytes, 0, 8);
+    memcpy(ccs_exi_doc_ISO2.V2G_Message.Header.SessionID.bytes, EVCOMM_SYS_INFO.SessionID, 8);
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //#if PARAMETER_NORMAL_MODE == ENABLE
+    //SHM_Read_iso2_V2GMSG_Header(&ccs_exi_doc_ISO2, ShmCcsData);
+    //#endif
+
+    //Detect for CP State should be 9V (State B)
+    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
+    {
+        #if CP_PROTECTION_MECHANISM == ENABLE
+        ccs_exi_doc_ISO2.V2G_Message.Body.SessionSetupRes.ResponseCode = iso2responseCodeType_FAILED;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+
+        sprintf(buf_log_evcomm,
+                "[Proc_iso2_SessionSetupRes]Emergency Stop by CP Error (%d)",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #else
+        sprintf(buf_log_evcomm,
+                "[Proc_iso2_SessionSetupRes]Emergency Stop by CP Error (%d): ignored",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #endif
+    }
+
+    //Check for shutdown commands from EVSE(DC Main Board)
+    if (sys->DC_EVSEStatus == EVSE_Shutdown ||
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        ccs_exi_doc_ISO2.V2G_Message.Body.SessionSetupRes.ResponseCode = iso2responseCodeType_FAILED;
+        sprintf(buf_log_evcomm, "[Proc_iso2_SessionSetupRes]Stop by EVSE(%d:normal, %d:emergency): (%d)\n",
+                EVSE_Shutdown,
+                EVSE_EmergencyShutdown,
+                sys->DC_EVSEStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        errn = -1;
+    }
+
+    //Check for Permission Changing from TRUE to FALSE
+    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
+    if (ShmInternalComm->ChargingPermission_pre >=1 &&
+        ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][ISO2][SessionSetupRes]Permission OFF");
+        ccs_exi_doc_DIN.V2G_Message.Body.SessionSetupRes.ResponseCode = iso2responseCodeType_FAILED;
+        errn = -1;
+    }
+
+    // ====== [BODY (2/3) EVSEID ======
+    //EVSEID = all zero
+    memset(ccs_exi_doc_ISO2.V2G_Message.Body.SessionSetupRes.EVSEID.characters, 0, sizeof(ccs_exi_doc_ISO2.V2G_Message.Body.SessionSetupRes.EVSEID.characters));
+    ccs_exi_doc_ISO2.V2G_Message.Body.SessionSetupRes.EVSEID.charactersLen = 15;  //max: DIN = 32, ISO1/ISO2 = 37 bytes
+
+    // ====== [BODY (3/3) DateTimeNow ======
+    ccs_exi_doc_ISO2.V2G_Message.Body.SessionSetupRes.EVSETimeStamp_isUsed = 1u;
+    ccs_exi_doc_ISO2.V2G_Message.Body.SessionSetupRes.EVSETimeStamp = (int64_t)time(NULL);   //[Joseph] Format: Unix Time Stamp
+
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    ///////////SHM_Read_iso2_SessionSetupRes(&ccs_exi_doc_ISO2, ShmCcsData);
+    #endif
+
+
+    // ============ Encode and Send Response Message ===========
+    if (send_encoded_iso2_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO2) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso2_SessionSetupRes][Error]Tx encoded msg error");
+        errn = -1;
+    }
+
+    return errn;
+
+}
+
+/*===========================================================================
+FUNCTION: Proc_din_SessionSetupReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+        2. ccs_exi_doc_DIN
+=============================================================================*/
+int Proc_din_SessionSetupReq(int AcceptFd)
+{
+    int errn = 0;
+
+    DEBUG_PRINTF_EVCOMM_DETAIL("\n[Proc_din_SessionSetupReq]Got SessionSetupReq\n");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_DIN_SessionSetupReq(&ccs_exi_doc_DIN);
+
+    //Save into Share Memory
+    SHM_Save_din_SessionSetupReq(ShmCcsData, &ccs_exi_doc_DIN, ShmSysConfigAndInfo);
+
+    errn = Proc_din_SessionSetupRes(AcceptFd);
+    if (errn == 0)
+    {
+    	//successfully send response.
+        SAVE_SYS_LOG_MSG_EVCOMM("[DIN][V2G][Tx]SessionSetupRes");
+    }
+    else
+    {
+    	sprintf(buf_log_evcomm,
+                "[Error]Proc_din_SessionSetupRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_SessionSetupReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+        2. ccs_exi_doc_ISO1
+=============================================================================*/
+int Proc_iso1_SessionSetupReq(int AcceptFd)
+{
+    int errn = 0;
+    DEBUG_PRINTF_EVCOMM_DETAIL("\n[Proc_iso1_SessionSetupReq]Got SessionSetupReq\n");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO1_SessionSetupReq(&ccs_exi_doc_ISO1);
+
+    //Save into Share Memory
+    SHM_Save_iso1_SessionSetupReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+    errn = Proc_iso1_SessionSetupRes(AcceptFd);
+    if (errn == 0)
+    {
+        //successfully send response.
+        SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][V2G][Tx]SessionSetupRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error]Proc_iso1_SessionSetupRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso2_SessionSetupReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+        2. ccs_exi_doc_ISO2
+=============================================================================*/
+int Proc_iso2_SessionSetupReq(int AcceptFd)
+{
+    int errn = 0;
+    DEBUG_PRINTF_EVCOMM_DETAIL("\n[Proc_iso2_SessionSetupReq]Got SessionSetupReq\n");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO2_SessionSetupReq(&ccs_exi_doc_ISO2);
+
+    //Save into Share Memory
+    SHM_Save_iso2_SessionSetupReq(ShmCcsData, &ccs_exi_doc_ISO2, ShmSysConfigAndInfo);
+
+    errn = Proc_iso2_SessionSetupRes(AcceptFd);
+    if (errn == 0)
+    {
+        //successfully send response.
+        SAVE_SYS_LOG_MSG_EVCOMM("[ISO2][V2G][Tx]SessionSetupRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error]Proc_iso2_SessionSetupRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_ServiceDiscoveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_ServiceDiscoveryRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    struct ChargingInfoData *sys;
+    struct ServiceDiscoveryRequest_DIN70121 *req;
+    struct ServiceDiscoveryResponse_DIN70121 *res;
+
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+    req = &ShmCcsData->V2GMessage_DIN70121.ServiceDiscoveryRequest;
+    res = &ShmCcsData->V2GMessage_DIN70121.ServiceDiscoveryResponse;
+
+
+    init_dinBodyType(&ccs_exi_doc_DIN.V2G_Message.Body);
+    init_dinServiceDiscoveryResType(&ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes);
+
+    //[1/4] Response Code
+    ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes_isUsed = 1u;
+    ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = dinresponseCodeType_OK;
+
+    //[HEADER] Check Req SessionID
+    if (Check_din_V2G_Rx_MSG_SessionID(&ccs_exi_doc_DIN) < 0)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+
+    //Detect for CP State should be 9V (State B)
+    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
+    {
+        #if CP_PROTECTION_MECHANISM == ENABLE
+        ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode =  dinresponseCodeType_FAILED;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+	    errn = -1;
+        sprintf(buf_log_evcomm,
+                "[Proc_din_ServiceDiscoveryRes]Emergency Stop by CP Error (%d)",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #else
+        sprintf(buf_log_evcomm,
+                "[Proc_din_ServiceDiscoveryRes]Emergency Stop by CP Error (%d): ignored",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #endif
+    }
+
+    if (sys->DC_EVSEStatus == EVSE_Shutdown /*||
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown*/)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = dinresponseCodeType_FAILED;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_ServiceDiscoveryRes]shutdown by EVSE");
+      //  errn = -1;
+    }
+    else if (/*sys->DC_EVSEStatus == EVSE_Shutdown ||*/
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = dinresponseCodeType_FAILED;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_ServiceDiscoveryRes]shutdown by EVSE");
+        errn = -1;
+    }
+
+    //Check for Permission Changing from TRUE to FALSE
+    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
+    if (ShmInternalComm->ChargingPermission_pre >=1 &&
+        ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][DIN][ServiceDiscoveryRes]Permission OFF");
+        ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = dinresponseCodeType_FAILED;
+     //   errn = -1;
+    }
+
+    //[2/4] PaymentOptions
+    ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.PaymentOptions.PaymentOption.arrayLen = 1u;
+    ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.PaymentOptions.PaymentOption.array[0] = dinpaymentOptionType_ExternalPayment; //1
+
+    //[3/4] Charge Service
+    res->ChargeService_DIN70121.Services.ServiceTag.ServiceID = 1;
+    ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceTag.ServiceID = (unsigned short) res->ChargeService_DIN70121.Services.ServiceTag.ServiceID;
+    ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceTag.ServiceCategory = dinserviceCategoryType_EVCharging;
+    ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.FreeService = 1; //[Joseph] for test
+    ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.EnergyTransferType = dinEVSESupportedEnergyTransferType_DC_extended;
+
+    //[4/4] Service List (null, not be uesed for now.)
+    //#if PARAMETER_NORMAL_MODE == ENABLE
+    ///////////////SHM_Read_din_ServiceDiscoveryRes(&ccs_exi_doc_DIN, ShmCcsData);
+    //#endif
+
+    // ============ Encode and Send Response Message ===========
+    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_DIN) != 0)
+    {
+        errn = -1;
+    }
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_ServiceDiscoveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_ServiceDiscoveryRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    struct ChargingInfoData *sys;
+    struct ServiceDiscoveryRequest_ISO15118_2014 *req;
+    struct ServiceDiscoveryResponse_ISO15118_2014 *res;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+    req = &ShmCcsData->V2GMessage_ISO15118_2014.ServiceDiscoveryRequest;
+    res = &ShmCcsData->V2GMessage_ISO15118_2014.ServiceDiscoveryResponse;
+
+    init_iso1BodyType(&ccs_exi_doc_ISO1.V2G_Message.Body);
+    init_iso1ServiceDiscoveryResType(&ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes);
+
+    //[1/4] Response Code
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes_isUsed = 1u;
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso1responseCodeType_OK;
+
+
+    //[HEADER] Check Req SessionID
+    if (Check_iso1_V2G_Rx_MSG_SessionID(&ccs_exi_doc_ISO1) < 0)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+
+    //Detect for CP State should be 9V (State B)
+    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
+    {
+        #if CP_PROTECTION_MECHANISM == ENABLE
+        ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso1responseCodeType_FAILED;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+        sprintf(buf_log_evcomm,
+                "[Proc_iso1_ServiceDiscoveryRes]Emergency Stop by CP Error (%d)",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #else
+        sprintf(buf_log_evcomm,
+                "[Proc_iso1_ServiceDiscoveryRes]Emergency Stop by CP Error (%d): ignored",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #endif
+    }
+
+    if (/*sys->DC_EVSEStatus == EVSE_Shutdown ||*/
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso1responseCodeType_FAILED;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_ServiceDiscoveryRes]shutdown by EVSE");
+        errn = -1;
+    }
+    else  if (sys->DC_EVSEStatus == EVSE_Shutdown /*||
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown*/)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso1responseCodeType_FAILED;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_ServiceDiscoveryRes]shutdown by EVSE");
+      //  errn = -1;
+    }
+
+    //Check for Permission Changing from TRUE to FALSE
+    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
+    if (ShmInternalComm->ChargingPermission_pre >=1 &&
+        ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][ISO1][ServiceDiscoveryRes]Permission OFF");
+        ccs_exi_doc_DIN.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso1responseCodeType_FAILED;
+      //  errn = -1;
+    }
+
+    //[2/4] PaymentOptionList
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.PaymentOptionList.PaymentOption.arrayLen = 1u;
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.PaymentOptionList.PaymentOption.array[0] = iso1paymentOptionType_ExternalPayment; //1
+    #ifdef SUPPORT_ISO15118_PnC
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.PaymentOptionList.PaymentOption.arrayLen = 2u;
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.PaymentOptionList.PaymentOption.array[1] = iso1paymentOptionType_Contract; //0
+    #endif
+
+    //[3/4] Charge Service
+    res->ChargeService.Services.ServiceID = 1;
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceID = (unsigned short) res->ChargeService.Services.ServiceID;
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceName_isUsed = 1;   
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceName.charactersLen = strlen("AC_DC_Charging");//AC_Charging 
+    writeStringToEXIString("AC_DC_Charging", ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceName.characters);
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceCategory = iso1serviceCategoryType_EVCharging;
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.FreeService = 1; 
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.SupportedEnergyTransferMode.EnergyTransferMode.arrayLen = 1u;    //[ISO1] max = 6
+
+    switch (ShmCcsData->EnergyTransferMode)
+    {
+        case DC_extended:
+        {
+            ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.SupportedEnergyTransferMode.EnergyTransferMode.array[0] = iso1EnergyTransferModeType_DC_extended;
+            break;
+        }
+
+        case AC_single_phase_core:
+        {
+            ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.SupportedEnergyTransferMode.EnergyTransferMode.array[0] = iso1EnergyTransferModeType_AC_single_phase_core;
+            break;
+        }
+
+        case AC_three_phase_core:
+        {
+            ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.SupportedEnergyTransferMode.EnergyTransferMode.array[0] = iso1EnergyTransferModeType_AC_three_phase_core;
+            break;
+        }
+
+        default:
+        {
+        	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.SupportedEnergyTransferMode.EnergyTransferMode.array[0] = iso1EnergyTransferModeType_DC_extended;
+            sprintf(buf_log_evcomm,
+                    "[ISO1][ServiceDiscoveryRes][Warning]unexpected EnergyTransferMode(%d)",
+                    ShmCcsData->EnergyTransferMode);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            break;
+        }
+    }
+
+
+    //[4/4] Service List 
+    i=0;
+    #ifdef SUPPORT_ISO15118_PnC
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList_isUsed = 1u;
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.arrayLen=i;
+	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.array[i].ServiceID = 2;
+	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.array[i].ServiceName_isUsed = 1;
+	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.array[i].ServiceName.charactersLen = strlen("Certificate");
+	writeStringToEXIString("Certificate", ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.array[i].ServiceName.characters);
+	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.array[i].ServiceCategory = iso1serviceCategoryType_ContractCertificate;
+	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.array[i].FreeService = 0;
+	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.arrayLen++;
+	i++;
+    #endif
+    #ifdef SUPPORT_ISO15118_VAS
+  	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList_isUsed = 1u;
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.arrayLen=i;
+	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.array[i].ServiceID = 3;
+	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.array[i].ServiceName_isUsed = 1;
+	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.array[i].ServiceName.charactersLen = strlen("InternetAccess");
+	writeStringToEXIString("InternetAccess", ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.array[i].ServiceName.characters);
+	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.array[i].ServiceCategory = iso1serviceCategoryType_Internet;
+	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.array[i].FreeService = 0;
+	ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.arrayLen++;
+	i++;
+	#endif
+    // ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        errn = -1;
+    }
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_ServiceDetailReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_ServiceDetailReq(int AcceptFd)
+{
+    int errn = 0;
+
+
+    //Save into Share Memory
+    SHM_Save_iso1_ServiceDetailReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+    errn = Proc_iso1_ServiceDetailRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][V2G][Tx]ServiceDetailRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_iso1_ServiceDetailReq]Proc_iso1_ServiceDetailRes(): %d (DEC)",
+                errn
+                );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_ServiceDetailRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_ServiceDetailRes(int AcceptFd)
+{
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    struct ChargingInfoData *sys;
+    struct ServiceDetailRequest_ISO15118_2014 *req;
+    struct ServiceDetailResponse_ISO15118_2014 *res;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+    req = &ShmCcsData->V2GMessage_ISO15118_2014.ServiceDetailRequest;
+    res = &ShmCcsData->V2GMessage_ISO15118_2014.ServiceDetailResponse;
+
+    init_iso1BodyType(&ccs_exi_doc_ISO1.V2G_Message.Body);
+    init_iso1ServiceDetailResType(&ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes);
+    
+
+    //[1/4] Response Code
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes_isUsed = 1u;
+    ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ResponseCode = iso1responseCodeType_OK;
+
+
+    //[HEADER] Check Req SessionID
+    if (Check_iso1_V2G_Rx_MSG_SessionID(&ccs_exi_doc_ISO1) < 0)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+
+    //Detect for CP State should be 9V (State B)
+    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
+    {
+        #if CP_PROTECTION_MECHANISM == ENABLE
+        ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ResponseCode = iso1responseCodeType_FAILED;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+        sprintf(buf_log_evcomm,
+                "[ServiceDetailRes]Emergency Stop by CP Error (%d)",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #else
+        sprintf(buf_log_evcomm,
+                "[ServiceDetailRes]Emergency Stop by CP Error (%d): ignored",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #endif
+    }
+
+    if (/*sys->DC_EVSEStatus == EVSE_Shutdown ||*/
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ResponseCode = iso1responseCodeType_FAILED;
+        SAVE_SYS_LOG_MSG_EVCOMM("[ServiceDetailRes]shutdown by EVSE");
+        errn = -1;
+    }
+    else  if (sys->DC_EVSEStatus == EVSE_Shutdown /*||
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown*/)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ResponseCode = iso1responseCodeType_FAILED;
+        SAVE_SYS_LOG_MSG_EVCOMM("[ServiceDetailRes]shutdown by EVSE");
+      //  errn = -1;
+    }
+
+    //Check for Permission Changing from TRUE to FALSE
+    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
+    if (ShmInternalComm->ChargingPermission_pre >=1 &&
+        ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][ISO1][ServiceDetailRes]Permission OFF");
+        ccs_exi_doc_DIN.V2G_Message.Body.ServiceDetailRes.ResponseCode = iso1responseCodeType_FAILED;
+      //  errn = -1;
+    }
+    switch (req->ServiceID)
+    {
+    	#ifdef SUPPORT_ISO15118_PnC
+    	case 2:
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceID = req->ServiceID;
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList_isUsed = 1;  
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.arrayLen = 2;//Installation(1), Update(2)
+    		//=============Set ParameterSet===================
+    		{
+    			unsigned char ServiceName[16];
+	    		for(int j=0;j<ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.arrayLen;j++)
+	    		{
+	    			memset(ServiceName,0,sizeof(ServiceName));
+	    			switch (j)
+	    			{
+	    				case 0://ftp with port 20
+	    					strcpy(ServiceName,"Installation");
+	    					break;
+	    				case 1://ftp with port 21
+	    					strcpy(ServiceName,"Update");
+	    					break;	
+	    				default:
+	    					break;	
+	    			}
+	    			if(strlen(ServiceName)>0)
+	    			{
+	    					ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].ParameterSetID=j+1;
+				    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.arrayLen=1;//Service
+				    		//Name= Protocol
+				    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[0].Name.charactersLen= strlen("Service");
+				    		writeStringToEXIString("Service", ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[0].Name.characters);
+				    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[0].stringValue_isUsed=1;
+				    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[0].stringValue.charactersLen=strlen(ServiceName);
+				    		writeStringToEXIString(ServiceName, ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[0].stringValue.characters);
+	    			}
+	    			else
+	    				break;	
+	    		}//for
+    		}
+    		break;
+    	#endif	
+    	#ifdef SUPPORT_ISO15118_VAS
+    	case 3:
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceID = req->ServiceID;
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList_isUsed = 1;  
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.arrayLen = 4;//ftp(1), ftp(2), http(3), https(4)
+    		//=============Set ParameterSet===================
+    		{
+    			unsigned char ProtocolName[16];
+    			int ProtocolPort; 
+	    		for(int j=0;j<ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.arrayLen;j++)
+	    		{
+	    			memset(ProtocolName,0,sizeof(ProtocolName));
+	    			switch (j)
+	    			{
+	    				case 0://ftp with port 20
+	    					strcpy(ProtocolName,"ftp");
+	    					ProtocolPort=20;
+	    					break;
+	    				case 1://ftp with port 21
+	    					strcpy(ProtocolName,"ftp");
+	    					ProtocolPort=21;
+	    					break;	
+	    				case 2://http with port 80
+	    					strcpy(ProtocolName,"http");
+	    					ProtocolPort=80;
+	    					break;	
+	    				case 3://https with port 443
+	    					strcpy(ProtocolName,"https");
+	    					ProtocolPort=443;
+	    					break;		
+	    				default:
+	    					break;	
+	    			}
+	    			if(strlen(ProtocolName)>0)
+	    			{
+	    					ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].ParameterSetID=j+1;
+				    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.arrayLen=2;//protocol and port
+				    		//Name= Protocol
+				    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[0].Name.charactersLen= strlen("Protocol");
+				    		writeStringToEXIString("Protocol", ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[0].Name.characters);
+				    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[0].stringValue_isUsed=1;
+				    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[0].stringValue.charactersLen=strlen(ProtocolName);
+				    		writeStringToEXIString(ProtocolName, ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[0].stringValue.characters);
+				    		//Name= Port
+				    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[1].Name.charactersLen= strlen("Port");
+				    		writeStringToEXIString("Port", ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[1].Name.characters);
+				    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[1].intValue_isUsed=1;
+				    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[j].Parameter.array[1].intValue=ProtocolPort;
+	    			}
+	    			else
+	    				break;	
+	    		}//for
+    		}
+    		/*
+    		//=============http,ParameterSetID=3===================
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].ParameterSetID=3;//http
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.arrayLen=2;//protocol and port
+    		//Name= Protocol, value= "HTTP"
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.charactersLen= strlen("Protocol");
+    		writeStringToEXIString("Protocol", ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters);
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].stringValue_isUsed=1;
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].stringValue.charactersLen=strlen("http");
+    		writeStringToEXIString("http", ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].stringValue.characters);
+    		//Name= Port, value= 80
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].Name.charactersLen= strlen("Port");
+    		writeStringToEXIString("Port", ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].Name.characters);
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].intValue_isUsed=1;
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].intValue=80;
+    		
+    		//==================https,ParameterSetID=4=====================
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].ParameterSetID=4;//https
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.arrayLen=2;//protocol and port
+    		//Name= Protocol, value= "HTTP"
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.charactersLen= strlen("Protocol");
+    		writeStringToEXIString("Protocol", ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters);
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].stringValue_isUsed=1;
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].stringValue.charactersLen=strlen("https");
+    		writeStringToEXIString("https", ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].stringValue.characters);
+    		//Name= Port, value= 443
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[1].Name.charactersLen= strlen("Port");
+    		writeStringToEXIString("Port", ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[1].Name.characters);
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[1].intValue_isUsed=1;
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[1].intValue=443;
+    		*/
+    		break;
+    	#endif	
+    	default:
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceID = req->ServiceID;
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ServiceParameterList_isUsed = 0;  
+    		ccs_exi_doc_ISO1.V2G_Message.Body.ServiceDetailRes.ResponseCode = iso1responseCodeType_FAILED_ServiceIDInvalid;
+    		break;	
+    }
+    // ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        errn = -1;
+    }
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_din_ServiceDiscoveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_ServiceDiscoveryReq(int AcceptFd)
+{
+    int errn = 0;
+    DEBUG_PRINTF_EVCOMM_DETAIL("\n[SeccComm][Proc_din_ServiceDiscoveryReq]Got ServiceDiscoveryReq\n");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_DIN_ServiceDiscoveryReq(&ccs_exi_doc_DIN);
+
+    //Save into Share Memory
+    SHM_Save_din_ServiceDiscoveryReq(ShmCcsData, &ccs_exi_doc_DIN, ShmSysConfigAndInfo);
+
+    errn = Proc_din_ServiceDiscoveryRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        SAVE_SYS_LOG_MSG_EVCOMM("[DIN][V2G][Tx]ServiceDiscoveryRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_din_ServiceDiscoveryReq]Proc_din_ServiceDiscoveryRes(): %d (DEC)",
+                errn
+                );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_ServiceDiscoveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_ServiceDiscoveryReq(int AcceptFd)
+{
+    int errn = 0;
+    DEBUG_PRINTF_EVCOMM_DETAIL("\n[SeccComm][Proc_iso1_ServiceDiscoveryReq]Got ServiceDiscoveryReq\n");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO1_ServiceDiscoveryReq(&ccs_exi_doc_ISO1);
+
+    //Save into Share Memory
+    SHM_Save_iso1_ServiceDiscoveryReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+    errn = Proc_iso1_ServiceDiscoveryRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][V2G][Tx]ServiceDiscoveryRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_iso1_ServiceDiscoveryReq]Proc_iso1_ServiceDiscoveryRes(): %d (DEC)",
+                errn
+                );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_din_ServiceAndPaymentSelectionRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_ServiceAndPaymentSelectionRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    struct ServiceAndPaymentSelectionRequest_DIN70121 *req;
+    struct ServiceAndPaymentSelectionResponse_DIN70121 *res;
+    struct ServiceDiscoveryResponse_DIN70121 *sd_res;
+    struct ChargingInfoData *sys;
+
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    req = &ShmCcsData->V2GMessage_DIN70121.ServiceAndPaymentSelectionRequest;
+    res = &ShmCcsData->V2GMessage_DIN70121.ServiceAndPaymentSelectionResponse;
+    sd_res = &ShmCcsData->V2GMessage_DIN70121.ServiceDiscoveryResponse;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+
+    init_dinBodyType(&ccs_exi_doc_DIN.V2G_Message.Body);
+    init_dinServicePaymentSelectionResType(&ccs_exi_doc_DIN.V2G_Message.Body.ServicePaymentSelectionRes);
+
+    //[1/1] Response Code
+    ccs_exi_doc_DIN.V2G_Message.Body.ServicePaymentSelectionRes_isUsed = 1u;
+    ccs_exi_doc_DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_OK;
+
+
+    //[HEADER] Check Req SessionID
+    if (Check_din_V2G_Rx_MSG_SessionID(&ccs_exi_doc_DIN) < 0)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //Check for SelectedPaymentOption (TC_SECC_VTB_ServicePaymentSelection_007)
+    if (req->SelectedPaymentOption != dinpaymentOptionType_ExternalPayment)  //1
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED_PaymentSelectionInvalid;
+        sprintf(buf_log_evcomm,
+                "[ERROR]unexpected SelectedPaymentOption(%d) => End_Process (EIM only, no PnC, yet.)",
+                req->SelectedPaymentOption);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_Payment SelectionInvalid (023762)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 6;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 2;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+    }
+
+    //Check for ServiceID (TC_SECC_VTB_ServicePaymentSelection_004)
+    if (req->SelectedServiceList.SelectedService[0].ServiceID != sd_res->ChargeService_DIN70121.Services.ServiceTag.ServiceID)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED_ServiceSelectionInvalid;  //8
+        sprintf(buf_log_evcomm,
+                "[ERROR]Wrong selected ServiceID(%d) => End_Process",
+                req->SelectedServiceList.SelectedService[0].ServiceID);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_ServiceSelectionInvalid (023764)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 6;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 4;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+    }
+
+
+    //Detect for CP State should be 9V (State B)
+    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
+    {
+        #if CP_PROTECTION_MECHANISM == ENABLE
+        ccs_exi_doc_DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+        sprintf(buf_log_evcomm,
+                "[Proc_din_ServiceAndPaymentSelectionRes]Emergency Stop by CP Error (%d)",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #else
+        sprintf(buf_log_evcomm,
+                "[Proc_din_ServiceAndPaymentSelectionRes]Emergency Stop by CP Error (%d): ignored due to function is disabled",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #endif
+    }
+
+    if (sys->DC_EVSEStatus == EVSE_Shutdown /*||
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown*/)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_ServiceAndPaymentSelectionRes]shutdown by EVSE");
+        ccs_exi_doc_DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED;
+      //  errn = -1;
+    }
+    else   if (/*sys->DC_EVSEStatus == EVSE_Shutdown ||*/
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_ServiceAndPaymentSelectionRes]shutdown by EVSE");
+        ccs_exi_doc_DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED;
+        errn = -1;
+    }
+
+    //Check for Permission Changing from TRUE to FALSE
+    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
+    if (ShmInternalComm->ChargingPermission_pre >=1 &&
+        ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][DIN][ServicePaymentSelectionRes]Permission OFF");
+        ccs_exi_doc_DIN.V2G_Message.Body.ServicePaymentSelectionRes.ResponseCode = dinresponseCodeType_FAILED;
+        //errn = -1;
+    }
+
+    // ============ Encode and Send Response Message ===========
+    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_DIN) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_ServiceAndPaymentSelectionRes]Tx encoded msg error");
+        errn = -1;
+    }
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_ServiceAndPaymentSelectionRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_ServiceAndPaymentSelectionRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    struct ServiceAndPaymentSelectionRequest_ISO15118_2014 *req;
+    struct ServiceAndPaymentSelectionResponse_ISO15118_2014 *res;
+    struct ServiceDiscoveryResponse_ISO15118_2014 *sd_res;
+    static struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    req = &ShmCcsData->V2GMessage_ISO15118_2014.ServiceAndPaymentSelectionRequest;
+    res = &ShmCcsData->V2GMessage_ISO15118_2014.ServiceAndPaymentSelectionResponse;
+    sd_res = &ShmCcsData->V2GMessage_ISO15118_2014.ServiceDiscoveryResponse;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    init_iso1BodyType(&ccs_exi_doc_ISO1.V2G_Message.Body);
+    init_iso1PaymentServiceSelectionResType(&ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes);
+
+    //[1/1] Response Code
+    ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes_isUsed = 1u;
+    ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_OK;
+
+
+    //[HEADER] Check Req SessionID
+    if (Check_iso1_V2G_Rx_MSG_SessionID(&ccs_exi_doc_ISO1) < 0)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+	#ifdef SUPPORT_ISO15118_PnC
+	if (req->SelectedPaymentOption > iso1paymentOptionType_ExternalPayment)  //1
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED_PaymentSelectionInvalid;
+        sprintf(buf_log_evcomm,
+                "[ERROR]unexpected SelectedPaymentOption(%d) => End_Process (EIM only, no PnC, yet.)",
+                req->SelectedPaymentOption);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_Payment SelectionInvalid (023762)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 6;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 2;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+    }
+	#else
+    //Check for SelectedPaymentOption (TC_SECC_VTB_ServicePaymentSelection_007)
+    if (req->SelectedPaymentOption != iso1paymentOptionType_ExternalPayment)  //1
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED_PaymentSelectionInvalid;
+        sprintf(buf_log_evcomm,
+                "[ERROR]unexpected SelectedPaymentOption(%d) => End_Process (EIM only, no PnC, yet.)",
+                req->SelectedPaymentOption);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_Payment SelectionInvalid (023762)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 6;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 2;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+    }
+	#endif
+	
+	for(i=0;i<req->SelectedServiceList.SelectedServiceLen;i++)
+	{
+		switch(req->SelectedServiceList.SelectedService[i].ServiceID)
+		{
+			case 1:
+				break;
+			case 2:
+				#ifndef SUPPORT_ISO15118_PnC
+				ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED_ServiceSelectionInvalid;  //8
+			    sprintf(buf_log_evcomm,
+			                "[ERROR]Wrong selected ServiceID(%d) => End_Process",
+			                req->SelectedServiceList.SelectedService[0].ServiceID);
+			     SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+			     errn = -1;
+			
+			     //Update_ShmStatusCode(); //[To-Do] to be implemented
+			     //CCS_SECC_ResponseCode_FAILED_ServiceSelectionInvalid (023764)
+			     ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+			     ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+			     ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+			     ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+			     ShmStatusCodeData->PresentStatusCode[0][4] = 6;
+			     ShmStatusCodeData->PresentStatusCode[0][5] = 4;
+			     CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+				 #endif
+				 break;
+			case 3:
+				#ifndef SUPPORT_ISO15118_VAS
+				ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED_ServiceSelectionInvalid;  //8
+			    sprintf(buf_log_evcomm,
+			                "[ERROR]Wrong selected ServiceID(%d) => End_Process",
+			                req->SelectedServiceList.SelectedService[0].ServiceID);
+			     SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+			     errn = -1;
+			
+			     //Update_ShmStatusCode(); //[To-Do] to be implemented
+			     //CCS_SECC_ResponseCode_FAILED_ServiceSelectionInvalid (023764)
+			     ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+			     ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+			     ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+			     ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+			     ShmStatusCodeData->PresentStatusCode[0][4] = 6;
+			     ShmStatusCodeData->PresentStatusCode[0][5] = 4;
+			     CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+				 #endif
+				 break;			 
+			default:
+				ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED_ServiceSelectionInvalid;  //8
+			    sprintf(buf_log_evcomm,
+			                "[ERROR]Wrong selected ServiceID(%d) => End_Process",
+			                req->SelectedServiceList.SelectedService[0].ServiceID);
+			     SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+			     errn = -1;
+			
+			     //Update_ShmStatusCode(); //[To-Do] to be implemented
+			     //CCS_SECC_ResponseCode_FAILED_ServiceSelectionInvalid (023764)
+			     ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+			     ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+			     ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+			     ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+			     ShmStatusCodeData->PresentStatusCode[0][4] = 6;
+			     ShmStatusCodeData->PresentStatusCode[0][5] = 4;
+			     CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+			     break;
+		}
+	}
+    //Detect for CP State should be 9V (State B)
+    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
+    {
+        #if CP_PROTECTION_MECHANISM == ENABLE
+        ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+        sprintf(buf_log_evcomm,
+                "[Proc_iso1_ServiceAndPaymentSelectionRes]Emergency Stop by CP Error (%d)",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #else
+        sprintf(buf_log_evcomm,
+                "[Proc_iso1_ServiceAndPaymentSelectionRes]Emergency Stop by CP Error (%d): ignored due to function is disabled",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #endif
+    }
+
+    if (sys->DC_EVSEStatus == EVSE_Shutdown /*||
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown*/)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_ServiceAndPaymentSelectionRes]shutdown by EVSE");
+        ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED;
+        //errn = -1;
+    }
+    else  if (/*sys->DC_EVSEStatus == EVSE_Shutdown ||*/
+        sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_ServiceAndPaymentSelectionRes]shutdown by EVSE");
+        ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED;
+        errn = -1;
+    }
+
+    //Check for Permission Changing from TRUE to FALSE
+    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
+    if (ShmInternalComm->ChargingPermission_pre >=1 &&
+        ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][ISO1][PaymentServiceSelectionRes]Permission OFF");
+        ccs_exi_doc_ISO1.V2G_Message.Body.PaymentServiceSelectionRes.ResponseCode = iso1responseCodeType_FAILED;
+       // errn = -1;
+    }
+
+    // ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_ServiceAndPaymentSelectionRes]Tx encoded msg error");
+        errn = -1;
+    }
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_din_ServiceAndPaymentSelectionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_ServiceAndPaymentSelectionReq(int AcceptFd)
+{
+    int errn = 0;
+    DEBUG_PRINTF_EVCOMM_DETAIL("[SeccComm][Proc_din_ServiceAndPaymentSelectionReq]Got ServiceAndPaymentSelectionReq");
+    //Print the decoded XML Document
+    PRINT_XML_DOC_DIN_ServiceAndPaymentSelectionReq(&ccs_exi_doc_DIN);
+
+    //Save into Share Memory
+    SHM_Save_din_ServiceAndPaymentSelectionReq(ShmCcsData, &ccs_exi_doc_DIN, ShmSysConfigAndInfo);
+
+    errn = Proc_din_ServiceAndPaymentSelectionRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        SAVE_SYS_LOG_MSG_EVCOMM("[DIN][V2G][Tx]ServiceAndPaymentSelectionRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+        "[Error][Proc_iso1_ServiceAndPaymentSelectionReq]Proc_iso1_ServiceAndPaymentSelectionRes(): %d (DEC)",
+        errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_iso1_ServiceAndPaymentSelectionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_ServiceAndPaymentSelectionReq(int AcceptFd)
+{
+    int errn = 0;
+    DEBUG_PRINTF_EVCOMM_DETAIL("[SeccComm][Proc_iso1_ServiceAndPaymentSelectionReq]Got ServiceAndPaymentSelectionReq");
+
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO1_ServiceAndPaymentSelectionReq(&ccs_exi_doc_ISO1);
+
+    //Save into Share Memory
+    SHM_Save_iso1_ServiceAndPaymentSelectionReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+    errn = Proc_iso1_ServiceAndPaymentSelectionRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][V2G][Tx]ServiceAndPaymentSelectionRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][Proc_iso1_ServiceAndPaymentSelectionReq]Proc_iso1_ServiceAndPaymentSelectionRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_ContractAuthenticationRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_ContractAuthenticationRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct ChargingInfoData *sys;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+
+    init_dinBodyType(&ccs_exi_doc_DIN.V2G_Message.Body);
+    init_dinContractAuthenticationResType(&ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes);
+
+    ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes_isUsed = 1u;
+
+    //[BODY (1/2)] ResponseCode
+    ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_OK;
+    ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes.EVSEProcessing = dinEVSEProcessingType_Ongoing; //0
+
+
+    //[HEADER] Check Req SessionID
+    if (Check_din_V2G_Rx_MSG_SessionID(&ccs_exi_doc_DIN) < 0)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //Detect for CP State should be 9V (State B)
+    #if CP_PROTECTION_MECHANISM == ENABLE
+    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_FAILED;
+        ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes.EVSEProcessing =  dinEVSEProcessingType_Finished;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+        sprintf(buf_log_evcomm,
+                "[Proc_din_ContractAuthenticationRes]Emergency Stop by CP Error (%d)",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    #endif
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_FAILED;
+        ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes.EVSEProcessing =  dinEVSEProcessingType_Finished;
+      //  errn = -1;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_FAILED;
+        ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes.EVSEProcessing =  dinEVSEProcessingType_Finished;
+        errn = -1;
+    }
+
+    //[BODY (2/2)] EVSEProcessing
+    if(ShmInternalComm->ChargingPermission == TRUE)
+    {
+        ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes.EVSEProcessing = dinEVSEProcessingType_Finished; //0
+        SAVE_SYS_LOG_MSG_EVCOMM("CSU Permission: OK");
+
+        #if (SLAC_FIRST_RESPONSE_METHOD == SET_5_PWM_ONCE_GET_PERMISSION_IN_AUTHORIZATIONRES)
+        {
+            //Set PWM as 5% (for SLAC first case)
+            SAVE_SYS_LOG_MSG_EVCOMM("Set PWM as 5%%");
+            SwitchCpStateE(DISABLE);
+            OutputCpPwmDuty(5);
+        }
+        #endif
+    }
+
+    //Check for Permission Changing from TRUE to FALSE
+    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
+    if (ShmInternalComm->ChargingPermission_pre >=1 &&
+        ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][DIN][ContractAuthenticationRes]Permission OFF");
+        ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes.ResponseCode = dinresponseCodeType_FAILED;
+        ccs_exi_doc_DIN.V2G_Message.Body.ContractAuthenticationRes.EVSEProcessing =  dinEVSEProcessingType_Finished;
+     //   errn = -1;
+    }
+
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    ////////////SHM_Read_din_ContractAuthenticationRes(&ccs_exi_doc_DIN, ShmCcsData);
+    #endif
+
+
+    // ============ Encode and Send Response Message ===========
+    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_DIN) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_ChargeParameterDiscoveryRes][Error]Tx encoded msg error");
+        errn = -1;
+    }
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_iso1_AuthorizationRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_AuthorizationRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct ChargingInfoData *sys;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+
+    init_iso1BodyType(&ccs_exi_doc_ISO1.V2G_Message.Body);
+    init_iso1AuthorizationResType(&ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes);
+
+    ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes_isUsed = 1u;
+
+    //[BODY (1/2)] ResponseCode
+    ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = iso1responseCodeType_OK;
+    /*+++ 20200808, vern, EVSEProcessing should be waiting for Customer during authrization +++*/
+    ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes.EVSEProcessing = iso1EVSEProcessingType_Ongoing_WaitingForCustomerInteraction; //0
+    /*--- 20200808, vern, should be waiting for Customer during authrization ---*/
+
+    //[HEADER] Check Req SessionID
+    if (Check_iso1_V2G_Rx_MSG_SessionID(&ccs_exi_doc_ISO1) < 0)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+
+    //Detect for CP State should be 9V (State B)
+    #if CP_PROTECTION_MECHANISM == ENABLE
+    if ((sys->CpState != 2) && (sys->CpState != 3))  //State B1, B2
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = iso1responseCodeType_FAILED;
+        ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes.EVSEProcessing =  iso1EVSEProcessingType_Finished;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+
+        sprintf(buf_log_evcomm,
+                "[Proc_iso1_AuthorizationRes]Emergency Stop by CP Error (%d)",
+                sys->CpState);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    #endif
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = FAILED_ISO15118_2014;
+        ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes.EVSEProcessing =  iso1EVSEProcessingType_Finished;
+        //errn = -1;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = FAILED_ISO15118_2014;
+        ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes.EVSEProcessing =  iso1EVSEProcessingType_Finished;
+        errn = -1;
+    }
+    //[BODY (2/2)] EVSEProcessing
+    //Check for Permission from CSU
+    if(ShmInternalComm->ChargingPermission == TRUE)
+    {
+        ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes.EVSEProcessing = iso1EVSEProcessingType_Finished; //0
+        SAVE_SYS_LOG_MSG_EVCOMM("CSU Permission: OK");
+
+        #if (SLAC_FIRST_RESPONSE_METHOD == SET_5_PWM_ONCE_GET_PERMISSION_IN_AUTHORIZATIONRES)
+        {
+            //Set PWM as 5% (for SLAC first case)
+            SAVE_SYS_LOG_MSG_EVCOMM("Set PWM as 5%%");
+            SwitchCpStateE(DISABLE);
+            OutputCpPwmDuty(5);
+        }
+        #endif
+    }
+
+    //Check for Permission Changing from TRUE to FALSE
+    /*+++ 20200808, vern, sync with Tesla CHAdeMO adaptor, 2 for start communication(not yet auth), 1 for star charging (authorized)  ---*/
+    if (ShmInternalComm->ChargingPermission_pre >=1 &&
+        ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][ISO1][AuthorizationRes]Permission OFF");
+        ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes.ResponseCode = FAILED_ISO15118_2014;
+        ccs_exi_doc_ISO1.V2G_Message.Body.AuthorizationRes.EVSEProcessing =  iso1EVSEProcessingType_Finished;
+      //  errn = -1;
+    }
+
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    ////////////SHM_Read_iso1_AuthorizationRes(&ccs_exi_doc_ISO1, ShmCcsData);
+    #endif
+
+
+    // ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_ChargeParameterDiscoveryRes][Error]Tx encoded msg error");
+        errn = -1;
+    }
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_ContractAuthenticationReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_ContractAuthenticationReq(int AcceptFd)
+{
+    int errn = 0;
+
+        DEBUG_PRINTF_EVCOMM_DETAIL("\n[SeccComm][Proc_din_ContractAuthenticationReq]Got Proc_din_ContractAuthenticationReq\n");
+
+
+        //Print the decoded XML Document
+        PRINT_XML_DOC_DIN_ContractAuthenticationReq(&ccs_exi_doc_DIN);
+
+        //Save into Share Memory
+        SHM_Save_din_ContractAuthenticationReq(ShmCcsData, &ccs_exi_doc_DIN, ShmSysConfigAndInfo);
+
+        errn = Proc_din_ContractAuthenticationRes(AcceptFd);
+        if (errn == 0)
+        {
+            //send response successfully.
+            //SAVE_SYS_LOG_MSG_EVCOMM("[DIN][V2G][Tx]ContractAuthenticationRes");
+        }
+        else
+        {
+            sprintf(buf_log_evcomm,
+                    "[Error][SeccComm][Proc_din_ContractAuthenticationReq]Proc_iso1_AuthenticationRes(): %d (DEC)",
+                    errn);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        }
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_AuthenticationReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_AuthenticationReq(int AcceptFd)
+{
+    int errn = 0;
+    DEBUG_PRINTF_EVCOMM_DETAIL("\n[SeccComm][Proc_iso1_AuthenticationReq]Got AuthorizationReq\n");
+
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO1_AuthorizationReq(&ccs_exi_doc_ISO1);
+
+    //Save into Share Memory
+    SHM_Save_iso1_AuthorizationReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+    errn = Proc_iso1_AuthorizationRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        //SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][V2G][Tx]AuthorizationRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_iso1_AuthenticationReq]Proc_iso1_AuthenticationRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+
+
+/*===========================================================================
+FUNCTION: SHM_Init_dinDC_EVSEStatusType
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. in
+OUTPUT:
+		2. out
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Init_dinDC_EVSEStatusType(struct DC_EVSEStatusType_DIN70121 *in)
+{
+	in->EVSEIsolationStatus = dinisolationLevelType_Valid;
+	//	dinisolationLevelType_Invalid = 0,
+	//	dinisolationLevelType_Valid = 1, (default)
+	//	dinisolationLevelType_Warning = 2,
+	//	dinisolationLevelType_Fault = 3
+
+	in->EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
+	// 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
+
+	in->EVSENotification = dinEVSENotificationType_None;
+	// dinEVSENotificationType_None = 0, (default)
+	// dinEVSENotificationType_StopCharging = 1,
+	// dinEVSENotificationType_ReNegotiation = 2
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_dinPhysicalValueType
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_dinPhysicalValueType(struct PhysicalValueType_DIN70121 *obj, short value, int multiplier, unsigned char unit)
+{
+    obj->Value = value;
+    obj->Multiplier = multiplier;
+    obj->Unit =unit;
+}
+
+/*===========================================================================
+FUNCTION: SHM_Init_din_ChargeParameterDiscoveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. shm_ccs
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Init_din_ChargeParameterDiscoveryRes(struct CcsData *shm_ccs)
+{
+	struct ChargeParameterDiscoveryResponse_DIN70121 *in;
+
+	in = &shm_ccs->V2GMessage_DIN70121.ChargeParameterDiscoveryResponse;
+
+	//----- [BODY (1/5)] ResponseCode -----
+    in->ResponseCode = dinresponseCodeType_OK;
+
+    //----- [BODY (2/5)] EVSEProcessing -----
+    in->EVSEProcessing = dinEVSEProcessingType_Ongoing;    //0
+    // 	dinEVSEProcessingType_Finished = 0,
+    //	dinEVSEProcessingType_Ongoing = 1
+
+    //----- [BODY (3/5)] SAScheduleList of SASchedules -----
+	//be fixed in another function.
+
+    //-----  [BODY (4/5)] AC_EVSEChargeParameter of EVSEChargeParameter -----
+    //ignore, since DIN doesn't support AC
+
+    //----- [BODY (5/5)] DC_EVSEChargeParameter of EVSEChargeParameter -----
+	struct DC_EVSEChargeParameterType_DIN70121 *in_para;
+	in_para = &in->DC_EVSEChargeParameter;
+
+    //DC_EVSEStatus
+	SHM_Init_dinDC_EVSEStatusType(&in_para->DC_EVSEStatus);
+    in_para->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;
+
+    short value = 0; int multiplier = 0; unsigned char unit = 0;
+
+    //EVSEMaximumCurrentLimit
+    value = 600; multiplier = -1; unit = A_DIN70121;    //60A
+	SHM_Save_dinPhysicalValueType(&in_para->EVSEMaximumCurrentLimit, value, multiplier, unit);
+
+    //EVSEMaximumPowerLimit
+    value = 3000; multiplier = 1; unit = W_DIN70121;    //30KW
+	SHM_Save_dinPhysicalValueType(&in_para->EVSEMaximumPowerLimit, value, multiplier, unit);
+
+    //EVSEMaximumVoltageLimit
+    value = 7500; multiplier = -1; unit = V_DIN70121;   //750V
+	SHM_Save_dinPhysicalValueType(&in_para->EVSEMaximumVoltageLimit, value, multiplier, unit);
+
+    //EVSEMinimumVoltageLimit
+    value = 1500; multiplier = -1; unit = V_DIN70121;   //150V
+	SHM_Save_dinPhysicalValueType(&in_para->EVSEMinimumVoltageLimit, value, multiplier, unit);
+
+
+    //EVSEMinimumCurrentLimit
+    value = 10; multiplier = -1; unit = A_DIN70121;     //1A
+	SHM_Save_dinPhysicalValueType(&in_para->EVSEMinimumCurrentLimit, value, multiplier, unit);
+
+    //EVSECurrentRegulationTolerance
+    value = 10; multiplier = -1; unit = A_DIN70121;      //1A
+	SHM_Save_dinPhysicalValueType(&in_para->EVSECurrentRegulationTolerance, value, multiplier, unit);
+
+    //EVSEPeakCurrentRipple
+    value = 2; multiplier = -1; unit = A_DIN70121;      //0.2A
+	SHM_Save_dinPhysicalValueType(&in_para->EVSEPeakCurrentRipple, value, multiplier, unit);
+
+    //EVSEEnergyToBeDelivered (optional)
+    //SHM_Save_dinPhysicalValueType(&out_para->EVSEEnergyToBeDelivered, &in_para->EVSEEnergyToBeDelivered);
+}
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_din_ChargeParameterDiscoveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_din_ChargeParameterDiscoveryRes()
+{
+    init_dinBodyType(&ccs_exi_doc_DIN.V2G_Message.Body);
+    init_dinChargeParameterDiscoveryResType(&ccs_exi_doc_DIN.V2G_Message.Body.ChargeParameterDiscoveryRes);
+
+    ccs_exi_doc_DIN.V2G_Message.Body.ChargeParameterDiscoveryRes_isUsed = 1u;
+
+    //----- [BODY (1/5)] ResponseCode -----
+    struct dinChargeParameterDiscoveryResType *res;
+    res = &ccs_exi_doc_DIN.V2G_Message.Body.ChargeParameterDiscoveryRes;
+    res->ResponseCode = dinresponseCodeType_OK;
+
+    //----- [BODY (2/5)] EVSEProcessing -----
+    res->EVSEProcessing = dinEVSEProcessingType_Finished; //0
+    // 	dinEVSEProcessingType_Finished = 0,
+    //	dinEVSEProcessingType_Ongoing = 1
+
+    //----- [BODY (3/5)] SAScheduleList of SASchedules -----
+    res->SAScheduleList_isUsed = 1u;
+    struct dinSAScheduleListType *list;
+    list = &res->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 = xxx
+    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.duration_isUsed = 1u;
+    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval_isUsed = 0u;
+    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval.xxx
+    //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 -----
+    res->DC_EVSEChargeParameter_isUsed = 1u;
+    struct dinDC_EVSEChargeParameterType *para;
+    para = &res->DC_EVSEChargeParameter;
+
+    //DC_EVSEStatus
+    para->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+    para->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;
+    //	dinisolationLevelType_Invalid = 0,
+    //	dinisolationLevelType_Valid = 1,
+    //	dinisolationLevelType_Warning = 2,
+    //	dinisolationLevelType_Fault = 3
+
+    para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
+    // dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
+    // dinDC_EVSEStatusCodeType_EVSE_Ready = 1,
+    // 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
+
+    para->DC_EVSEStatus.NotificationMaxDelay = 0u;
+
+    para->DC_EVSEStatus.EVSENotification = dinEVSENotificationType_None;
+    // dinEVSENotificationType_None = 0,
+    // dinEVSENotificationType_StopCharging = 1,
+    // dinEVSENotificationType_ReNegotiation = 2
+
+    //EVSEMaximumCurrentLimit
+    para->EVSEMaximumCurrentLimit.Value = 2400;
+    para->EVSEMaximumCurrentLimit.Multiplier = -1;
+    para->EVSEMaximumCurrentLimit.Unit_isUsed = 1u;
+    para->EVSEMaximumCurrentLimit.Unit = dinunitSymbolType_A;
+    //	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
+
+    //EVSEMaximumPowerLimit
+    para->EVSEMaximumPowerLimit.Value = 6000;
+    para->EVSEMaximumPowerLimit.Multiplier = 1;
+    para->EVSEMaximumPowerLimit.Unit_isUsed = 1u;
+    para->EVSEMaximumPowerLimit.Unit = dinunitSymbolType_W;
+
+
+    //EVSEMaximumVoltageLimit
+    para->EVSEMaximumVoltageLimit.Value = 7500;
+    para->EVSEMaximumVoltageLimit.Multiplier = -1;
+    para->EVSEMaximumVoltageLimit.Unit_isUsed = 1u;
+    para->EVSEMaximumVoltageLimit.Unit = dinunitSymbolType_V;
+
+    //EVSEMinimumVoltageLimit
+    para->EVSEMinimumVoltageLimit.Value = 1500;
+    para->EVSEMinimumVoltageLimit.Multiplier = -1;
+    para->EVSEMinimumVoltageLimit.Unit_isUsed = 1u;
+    para->EVSEMinimumVoltageLimit.Unit = dinunitSymbolType_V;
+
+
+    //EVSEMinimumCurrentLimit
+    para->EVSEMinimumCurrentLimit.Value = 20;
+    para->EVSEMinimumCurrentLimit.Multiplier = -1;
+    para->EVSEMinimumCurrentLimit.Unit_isUsed = 1u;
+    para->EVSEMinimumCurrentLimit.Unit = dinunitSymbolType_A;
+
+    //EVSECurrentRegulationTolerance_isUsed
+    para->EVSECurrentRegulationTolerance_isUsed = 1u;
+    //EVSECurrentRegulationTolerance
+    para->EVSECurrentRegulationTolerance.Value = 10;
+    para->EVSECurrentRegulationTolerance.Multiplier = -1;
+    para->EVSECurrentRegulationTolerance.Unit_isUsed = 1u;
+    para->EVSECurrentRegulationTolerance.Unit = dinunitSymbolType_A;
+
+
+    //EVSEEnergyToBeDelivered_isUsed
+    para->EVSEEnergyToBeDelivered_isUsed = 1u;
+    //EVSEPeakCurrentRipple
+    para->EVSEPeakCurrentRipple.Value = 2;
+    para->EVSEPeakCurrentRipple.Multiplier = -1;
+    para->EVSEPeakCurrentRipple.Unit_isUsed = 1u;
+    para->EVSEPeakCurrentRipple.Unit = dinunitSymbolType_A;
+
+
+    //EVSEEnergyToBeDelivered (optional)
+    /*
+    para->EVSEEnergyToBeDelivered.Value = 360;
+    para->EVSEEnergyToBeDelivered.Multiplier = 3;
+    para->EVSEEnergyToBeDelivered.Unit_isUsed = 1u;
+    para->EVSEEnergyToBeDelivered.Unit = dinunitSymbolType_Wh;
+    */
+}
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_iso1_ChargeParameterDiscoveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_iso1_ChargeParameterDiscoveryRes()
+{
+    init_iso1BodyType(&ccs_exi_doc_ISO1.V2G_Message.Body);
+    init_iso1ChargeParameterDiscoveryResType(&ccs_exi_doc_ISO1.V2G_Message.Body.ChargeParameterDiscoveryRes);
+
+    ccs_exi_doc_ISO1.V2G_Message.Body.ChargeParameterDiscoveryRes_isUsed = 1u;
+
+    //----- [BODY (1/5)] ResponseCode -----
+    struct iso1ChargeParameterDiscoveryResType *res;
+    res = &ccs_exi_doc_ISO1.V2G_Message.Body.ChargeParameterDiscoveryRes;
+    res->ResponseCode = iso1responseCodeType_OK;
+
+    //----- [BODY (2/5)] EVSEProcessing -----
+    res->EVSEProcessing = iso1EVSEProcessingType_Finished; //0
+    // 	iso1EVSEProcessingType_Finished = 0,
+    //	iso1EVSEProcessingType_Ongoing = 1
+
+    //----- [BODY (3/5)] SAScheduleList of SASchedules -----
+    res->SAScheduleList_isUsed = 1u;
+    struct iso1SAScheduleListType *list;
+    list = &res->SAScheduleList;
+    //
+    list->SAScheduleTuple.arrayLen = 1;
+    list->SAScheduleTuple.array[0].SAScheduleTupleID = 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 = xxx
+    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.duration_isUsed = 1u;
+    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval_isUsed = 0u;
+    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval.xxx
+    //list->SAScheduleTuple.array[0].SalesTariff.xxx
+    //list->SAScheduleTuple.array[0].SalesTariff_isUsed = 0u;
+
+
+    //-----  [BODY (4/5)] AC_EVSEChargeParameter of EVSEChargeParameter -----
+    //ignore, since our ISO1 doesn't support AC, yet
+
+    //----- [BODY (5/5)] DC_EVSEChargeParameter of EVSEChargeParameter -----
+    res->DC_EVSEChargeParameter_isUsed = 1u;
+    struct iso1DC_EVSEChargeParameterType *para;
+    para = &res->DC_EVSEChargeParameter;
+
+    //DC_EVSEStatus
+    para->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+    para->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid;
+    //	iso1isolationLevelType_Invalid = 0,
+    //	iso1isolationLevelType_Valid = 1,
+    //	iso1isolationLevelType_Warning = 2,
+    //	iso1isolationLevelType_Fault = 3
+
+    para->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+    // 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
+
+    para->DC_EVSEStatus.NotificationMaxDelay = 0u;
+
+    para->DC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
+    // iso1EVSENotificationType_None = 0,
+    // iso1EVSENotificationType_StopCharging = 1,
+    // iso1EVSENotificationType_ReNegotiation = 2
+
+    //EVSEMaximumCurrentLimit
+    para->EVSEMaximumCurrentLimit.Value = 2400;
+    para->EVSEMaximumCurrentLimit.Multiplier = -1;
+    //para->EVSEMaximumCurrentLimit.Unit_isUsed = 1u;
+    para->EVSEMaximumCurrentLimit.Unit = iso1unitSymbolType_A;
+    //iso1unitSymbolType_h = 0,
+	//iso1unitSymbolType_m = 1,
+	//iso1unitSymbolType_s = 2,
+	//iso1unitSymbolType_A = 3,
+	//iso1unitSymbolType_V = 4,
+	//iso1unitSymbolType_W = 5,
+	//iso1unitSymbolType_Wh = 6
+
+    //EVSEMaximumPowerLimit
+    para->EVSEMaximumPowerLimit.Value = 6000;
+    para->EVSEMaximumPowerLimit.Multiplier = 1;
+    //para->EVSEMaximumPowerLimit.Unit_isUsed = 1u;
+    para->EVSEMaximumPowerLimit.Unit = iso1unitSymbolType_W;
+
+
+    //EVSEMaximumVoltageLimit
+    para->EVSEMaximumVoltageLimit.Value = 7500;
+    para->EVSEMaximumVoltageLimit.Multiplier = -1;
+    //para->EVSEMaximumVoltageLimit.Unit_isUsed = 1u;
+    para->EVSEMaximumVoltageLimit.Unit = iso1unitSymbolType_V;
+
+    //EVSEMinimumVoltageLimit
+    para->EVSEMinimumVoltageLimit.Value = 1500;
+    para->EVSEMinimumVoltageLimit.Multiplier = -1;
+    //para->EVSEMinimumVoltageLimit.Unit_isUsed = 1u;
+    para->EVSEMinimumVoltageLimit.Unit = iso1unitSymbolType_V;
+
+
+    //EVSEMinimumCurrentLimit
+    para->EVSEMinimumCurrentLimit.Value = 20;
+    para->EVSEMinimumCurrentLimit.Multiplier = -1;
+    //para->EVSEMinimumCurrentLimit.Unit_isUsed = 1u;
+    para->EVSEMinimumCurrentLimit.Unit = iso1unitSymbolType_A;
+
+    //EVSECurrentRegulationTolerance_isUsed
+    para->EVSECurrentRegulationTolerance_isUsed = 1u;
+    //EVSECurrentRegulationTolerance
+    para->EVSECurrentRegulationTolerance.Value = 10;
+    para->EVSECurrentRegulationTolerance.Multiplier = -1;
+    //para->EVSECurrentRegulationTolerance.Unit_isUsed = 1u;
+    para->EVSECurrentRegulationTolerance.Unit = iso1unitSymbolType_A;
+
+
+    //EVSEEnergyToBeDelivered_isUsed
+    para->EVSEEnergyToBeDelivered_isUsed = 1u;
+    //EVSEPeakCurrentRipple
+    para->EVSEPeakCurrentRipple.Value = 2;
+    para->EVSEPeakCurrentRipple.Multiplier = -1;
+    //para->EVSEPeakCurrentRipple.Unit_isUsed = 1u;
+    para->EVSEPeakCurrentRipple.Unit = iso1unitSymbolType_A;
+
+
+    //EVSEEnergyToBeDelivered (optional)
+    /*
+    para->EVSEEnergyToBeDelivered.Value = 360;
+    para->EVSEEnergyToBeDelivered.Multiplier = 3;
+    para->EVSEEnergyToBeDelivered.Unit_isUsed = 1u;
+    para->EVSEEnergyToBeDelivered.Unit = iso1unitSymbolType_Wh;
+    */
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_ChargeParameterDiscoveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_ChargeParameterDiscoveryRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    struct ChargeParameterDiscoveryResponse_DIN70121 *res;
+    struct ChargeParameterDiscoveryRequest_DIN70121 *req;
+    struct DC_EVSEChargeParameterType_DIN70121 *dc_para;
+    struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    res = &ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryResponse;
+    req = &ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryRequest;
+    dc_para = &ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryResponse.DC_EVSEChargeParameter;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    res->ResponseCode = OK_DIN70121;
+    res->EVSEProcessing =  Ongoing_DIN70121;
+    dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;    //1
+
+
+    //[HEADER] Check Req SessionID
+    if (Check_din_V2G_Rx_MSG_SessionID(&ccs_exi_doc_DIN) < 0)
+    {
+        res->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        res->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+
+    //[TC_SECC_VTB_ChargeParameterDiscovery_005]
+      if (	(sys->EvBatteryMaxCurrent < 0) ||
+    	(sys->EvBatteryMaxVoltage<150)
+        )
+    {
+        sprintf(buf_log_evcomm,
+                "[ERROR]EvBatteryMaxCurrent is negative(%.02f) => End_Process",
+                sys->EvBatteryMaxCurrent);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+        res->ResponseCode = dinresponseCodeType_FAILED_WrongChargeParameter;    //16
+        res->EVSEProcessing = Finished_DIN70121;
+        dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+        errn = -1;
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_WrongChargeParameter (023775)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 5;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+    }
+
+
+    //STEP 2: ============ Modify Parameters of ShmCcsData ============
+    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMaximumPowerLimit, (int) (sys->AvailableChargingPower * 10), W_DIN70121);
+    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMaximumCurrentLimit, (int) (sys->AvailableChargingCurrent * 10), A_DIN70121);
+    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMaximumVoltageLimit, (int) (sys->MaximumChargingVoltage * 10), V_DIN70121);
+
+    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMinimumVoltageLimit, 1500, V_DIN70121); //150V
+    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMinimumCurrentLimit, MIN_SUPPORTED_CURRENT*10, A_DIN70121); //1A
+    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSECurrentRegulationTolerance, 10, A_DIN70121); //1A
+    SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEPeakCurrentRipple, 2, A_DIN70121);   //0.2A
+    //SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEEnergyToBeDelivered, 0, WH_DIN70121); //optional
+
+    #if PATCH_FOR_BMW_I3_BUG_EVSEMAXIMUMVOLTAGELIMIT_599V == ENABLE
+    if (sys->EvBatteryMaxVoltage <= 500)
+    {
+        SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMaximumVoltageLimit, (int) (500 * 10), V_DIN70121);  //500V
+    }
+    #endif
+
+    //for test with Tesla Model 3, 10A
+    //SAVE_PhysicalValueType_DIN70121(&dc_para->EVSEMaximumCurrentLimit, (int) (10 * 10), A_DIN70121);   //10A, for testing with Tesla Model 3
+
+
+    //Check for EnergyTransferMode [TC_SECC_VTB_ChargeParameterDiscovery_004]
+    if (req->EVRequestedEnergyTransferType != dinEVSESupportedEnergyTransferType_DC_extended)
+    {
+        sprintf(buf_log_evcomm,
+                "[ERROR]Wrong EVRequestedEnergyTransferType(%d,%d)",
+                req->EVRequestedEnergyTransferType,
+                dinEVSESupportedEnergyTransferType_DC_extended);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        res->ResponseCode = FAILED_WrongEnergyTransferType_DIN70121;
+        res->EVSEProcessing = Finished_DIN70121;
+        dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+        errn = -1;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_WrongEnergyTransferMode (023774)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 4;
+    }
+
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_ChargeParameterDiscoveryRes]EVSE_Shutdown");
+        res->ResponseCode = FAILED_DIN70121;
+        res->EVSEProcessing = Finished_DIN70121;
+        dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+       // errn = -1;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_ChargeParameterDiscoveryRes]EVSE_EmergencyShutdown");
+        res->ResponseCode = FAILED_DIN70121;
+        res->EVSEProcessing = Finished_DIN70121;
+        dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        errn = -1;
+    }
+
+    //Detect for CP State should be 9V (State B)
+    #if CP_PROTECTION_MECHANISM == ENABLE
+    if (sys->CpState != 3)  //State B1, B2
+    {
+        res->ResponseCode = FAILED_DIN70121;
+        dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        res->EVSEProcessing = Finished_DIN70121;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+
+        sprintf(buf_log_evcomm,
+                "[Proc_din_ChargeParameterDiscoveryRes]Emergency Stop by CP Error (%d, %.02f V)\n",
+                sys->CpState,
+                sys->CpVoltage);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    #endif
+
+    //Check for Permission from CSU
+    if (ShmInternalComm->ChargingPermission == TRUE)
+    {
+        res->EVSEProcessing = Finished_DIN70121;
+    }
+
+    //Check for Permission Off
+    if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][DIN][ChargeParameterDiscoveryRes]Permission OFF");
+        res->ResponseCode = FAILED_DIN70121;
+        res->EVSEProcessing = Finished_DIN70121;
+        dc_para->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+     //   errn = -1;
+    }
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_din_ChargeParameterDiscoveryRes(&ccs_exi_doc_DIN, ShmCcsData);
+    #else
+    Sudo_Parameter_din_ChargeParameterDiscoveryRes();
+    #endif
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_DIN) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_ChargeParameterDiscoveryRes][Error]Tx encoded msg error");
+        errn = -1;
+    }
+
+    //STPE 5: ============ Update Flags ============
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_iso1_ChargeParameterDiscoveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_ChargeParameterDiscoveryRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    struct ChargeParameterDiscoveryResponse_ISO15118_2014 *res;
+    struct ChargeParameterDiscoveryRequest_ISO15118_2014 *req;
+    struct DC_EVSEChargeParameterType_ISO15118_2014 *dc_para;
+    struct AC_EVSEChargeParameterType_ISO15118_2014 *ac_para;
+    struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    res = &ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryResponse;
+    req = &ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest;
+    dc_para = &ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryResponse.DC_EVSEChargeParameter;
+    ac_para = &ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryResponse.AC_EVSEChargeParameter;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    res->ResponseCode = OK_ISO15118_2014;
+    /*+++ 20200808, vern, EVSEProcessing should be on-going during ChargeParameterDiscovery +++*/
+    res->EVSEProcessing =  iso1EVSEProcessingType_Ongoing;
+    /*--- 20200808, vern, EVSEProcessing should be on-going during ChargeParameterDiscovery ---*/
+    dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;    //1
+    ac_para->AC_EVSEStatus.RCD = ShmInternalComm->AC_RcdStatus; //0:no error, 1:error
+    ac_para->AC_EVSEStatus.NotificationMaxDelay = 0;  //unit: 1s
+    ac_para->AC_EVSEStatus.EVSENotification = ShmInternalComm->AC_EVSENotification; //0:none, 1:StopCharging, 2:RenNgotiation
+
+
+    //[HEADER] Check Req SessionID
+    if (Check_iso1_V2G_Rx_MSG_SessionID(&ccs_exi_doc_ISO1) < 0)
+    {
+        res->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        res->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+/*	printf("req->RequestedEnergyTransferMode=%d\n",req->RequestedEnergyTransferMode);
+	printf("req->AC_EVChargeParameter.DepartureTime=%d\n",req->AC_EVChargeParameter.DepartureTime);
+	
+	printf("req->AC_EVChargeParameter.EAmount.Multiplier=%d\n",req->AC_EVChargeParameter.EAmount.Multiplier);
+	printf("req->AC_EVChargeParameter.EAmount.Unit=%d\n",req->AC_EVChargeParameter.EAmount.Unit);
+	printf("req->AC_EVChargeParameter.EAmount.Value=%d\n",req->AC_EVChargeParameter.EAmount.Value);
+	
+	printf("req->AC_EVChargeParameter.EVMaxVoltage.Multiplier=%d\n",req->AC_EVChargeParameter.EVMaxVoltage.Multiplier);
+	printf("req->AC_EVChargeParameter.EVMaxVoltage.Unit=%d\n",req->AC_EVChargeParameter.EVMaxVoltage.Unit);
+	printf("req->AC_EVChargeParameter.EVMaxVoltage.Value=%d\n",req->AC_EVChargeParameter.EVMaxVoltage.Value);
+	
+	printf("req->AC_EVChargeParameter.EVMaxCurrent.Multiplier=%d\n",req->AC_EVChargeParameter.EVMaxCurrent.Multiplier);
+	printf("req->AC_EVChargeParameter.EVMaxCurrent.Unit=%d\n",req->AC_EVChargeParameter.EVMaxCurrent.Unit);
+	printf("req->AC_EVChargeParameter.EVMaxCurrent.Value=%d\n",req->AC_EVChargeParameter.EVMaxCurrent.Value);
+	
+	printf("req->AC_EVChargeParameter.EVMinCurrent.Multiplier=%d\n",req->AC_EVChargeParameter.EVMinCurrent.Multiplier);
+	printf("req->AC_EVChargeParameter.EVMinCurrent.Unit=%d\n",req->AC_EVChargeParameter.EVMinCurrent.Unit);
+	printf("req->AC_EVChargeParameter.EVMinCurrent.Value=%d\n",req->AC_EVChargeParameter.EVMinCurrent.Value);*/
+
+	if(req->RequestedEnergyTransferMode <= 1)//0 for 1P, 1 for 3P
+	{
+		//AC parameters
+		SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_ChargeParameterDiscoveryRes]AC charging");
+		//AC
+	    SAVE_PhysicalValueType_ISO15118_2014(&ac_para->EVSENominalVoltage, (int) (sys->AC_EVSENominalVoltage * 10), V_ISO15118_2014);
+	    //SAVE_PhysicalValueType_ISO15118_2014(&ac_para->EVSEMaxCurrent, (int) (sys->AvailableChargingCurrent * 10), A_ISO15118_2014);
+	    SAVE_PhysicalValueType_ISO15118_2014(&ac_para->EVSEMaxCurrent, (int) (ShmInternalComm->AC_EVSEMaxCurrent * 10), A_ISO15118_2014);
+	}
+	else
+	{
+		//DC parameters
+		SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_ChargeParameterDiscoveryRes]DC charging");
+		//[TC_SECC_VTB_ChargeParameterDiscovery_005]
+    	 /*+++ 20200808, vern, should check the voltage and current to see if the range of battery parameter is accepted by charger ---*/
+	    if ((sys->EvBatteryMaxCurrent < 0) ||(sys->EvBatteryMaxVoltage<150))
+	    {
+	        sprintf(buf_log_evcomm,
+	                "[ERROR]EvBatteryMaxCurrent/MaxVolatge is mismatch(current=%.02f, voltage=%.02f) => End_Process",
+	                sys->EvBatteryMaxCurrent,sys->EvBatteryMaxVoltage);
+	        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	
+	        res->ResponseCode = iso1responseCodeType_FAILED_WrongChargeParameter;   //16
+	        res->EVSEProcessing = Finished_ISO15118_2014;
+	        dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+	        ac_para->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
+	        errn = -1;
+	        //Update_ShmStatusCode(); //[To-Do] to be implemented
+	        //CCS_SECC_ResponseCode_FAILED_WrongChargeParameter (023775)
+	        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+	        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+	        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+	        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+	        ShmStatusCodeData->PresentStatusCode[0][4] = 7;
+	        ShmStatusCodeData->PresentStatusCode[0][5] = 5;
+	        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+	    }
+	     //STEP 2: ============ Modify Parameters of ShmCcsData ============
+	    //DC
+	    SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMaximumPowerLimit, (int) (sys->AvailableChargingPower * 10), W_ISO15118_2014);
+	    SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMaximumCurrentLimit, (int) (sys->AvailableChargingCurrent * 10), A_ISO15118_2014);
+	    SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMaximumVoltageLimit, (int) (sys->MaximumChargingVoltage * 10), V_ISO15118_2014);
+	
+	    SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMinimumVoltageLimit, 1500, V_ISO15118_2014); //150V
+	    SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMinimumCurrentLimit, MIN_SUPPORTED_CURRENT*10, A_ISO15118_2014); //1A
+	    SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSECurrentRegulationTolerance, 10, A_ISO15118_2014); //1A
+	    SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEPeakCurrentRipple, 2, A_ISO15118_2014);   //0.2A
+	    //SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEEnergyToBeDelivered, 0, Wh_ISO15118_2014); //optional
+	    
+	    #if PATCH_FOR_BMW_I3_BUG_EVSEMAXIMUMVOLTAGELIMIT_599V == ENABLE
+		if (sys->EvBatteryMaxVoltage <= 500)
+		{
+		    SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMaximumVoltageLimit, (int) (500 * 10), V_ISO15118_2014);  //500V
+		}
+		#endif
+		 //Check for CSU command of "Stop by EVSE"
+	    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+	    {
+	        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_ChargeParameterDiscoveryRes]EVSE_Shutdown");
+	        res->ResponseCode = FAILED_ISO15118_2014;
+	        res->EVSEProcessing = iso1EVSEProcessingType_Finished;
+	        dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+	        ac_para->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
+	      //  errn = -1;
+	    }
+	    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+	    {
+	        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_ChargeParameterDiscoveryRes]EVSE_EmergencyShutdown");
+	        res->ResponseCode = FAILED_ISO15118_2014;
+	        res->EVSEProcessing =  iso1EVSEProcessingType_Finished;
+	        dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+	        ac_para->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
+	        errn = -1;
+	    }
+	       //Detect for CP State should be 9V (State B)
+	    #if CP_PROTECTION_MECHANISM == ENABLE
+	    if (sys->CpState != 3)  //State B1, B2
+	    {
+	        res->ResponseCode = FAILED_ISO15118_2014;
+	        dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+	        ac_para->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
+	        res->EVSEProcessing = iso1EVSEProcessingType_Finished;
+	        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+	        Update_V2G_Flow_Status(Other_Fault);
+	        errn = -1;
+	
+	        sprintf(buf_log_evcomm,
+	                "[Proc_iso1_ChargeParameterDiscoveryRes]Emergency Stop by CP Error (%d, %.02f V)\n",
+	                sys->CpState,
+	                sys->CpVoltage);
+	        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	    }
+	    #endif
+	}		
+
+    //for test with Tesla Model 3, 10A
+    //SAVE_PhysicalValueType_ISO15118_2014(&dc_para->EVSEMaximumCurrentLimit, (int) (10 * 10), A_ISO15118_2014);   //10A, for testing with Tesla Model 3
+
+    //Check for EnergyTransferMode
+    if (req->RequestedEnergyTransferMode != ShmCcsData->EnergyTransferMode) //[CAUTION] Their table should be kept as the same.
+    {
+        sprintf(buf_log_evcomm,
+                "[ERROR]Unmatched RequestedEnergyTransferMode(%d,%d)",
+                req->RequestedEnergyTransferMode,
+                ShmCcsData->EnergyTransferMode);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        res->ResponseCode = FAILED_WrongEnergyTransferMode_ISO15118_2014;
+        res->EVSEProcessing = iso1EVSEProcessingType_Finished;
+        dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+        ac_para->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
+        errn = -1;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_WrongEnergyTransferMode (023774)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 4;
+    }
+
+    //Check for Permission from CSU
+    if(ShmInternalComm->ChargingPermission == TRUE)
+    {
+        res->EVSEProcessing = iso1EVSEProcessingType_Finished;
+    }
+
+    //Check for Permission Off
+    if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][ISO1][ChargeParameterDiscoveryRes]Permission OFF");
+        res->ResponseCode = FAILED_ISO15118_2014;
+        res->EVSEProcessing = iso1EVSEProcessingType_Finished;
+        dc_para->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+        ac_para->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
+   //     errn = -1;
+    }
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_iso1_ChargeParameterDiscoveryRes(&ccs_exi_doc_ISO1, ShmCcsData);
+    #else
+    Sudo_Parameter_iso1_ChargeParameterDiscoveryRes();
+    #endif
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_ChargeParameterDiscoveryRes][Error]Tx encoded msg error");
+        errn = -1;
+    }
+
+    //STPE 5: ============ Update Flags ============
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_ChargeParameterDiscoveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_ChargeParameterDiscoveryReq(int AcceptFd)
+{
+    int errn = 0;
+
+        //SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_ChargeParameterDiscoveryReq] Got ChargeParameterDiscoveryReq");
+
+        //ftime(&SeqStartTime);
+        //Print the decoded XML Document
+        PRINT_XML_DOC_DIN_ChargeParameterDiscoveryReq(&ccs_exi_doc_DIN);
+
+        //Save into Share Memory
+        SHM_Save_din_ChargeParameterDiscoveryReq(ShmCcsData, &ccs_exi_doc_DIN, ShmSysConfigAndInfo);
+
+        //Check for EV Error Code
+        Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.DC_EVStatus.EVErrorCode);
+
+        errn = Proc_din_ChargeParameterDiscoveryRes(AcceptFd);
+        //ftime(&SeqEndTime);
+        //DEBUG_PRINTF_EVCOMM_DETAIL("\ndelta = %.02lf ms\n", DiffTimeb(SeqStartTime, SeqEndTime));
+        if ( errn == 0)
+        {
+            //send response successfully.
+            //SAVE_SYS_LOG_MSG_EVCOMM("[DIN][V2G][Tx]ChargeParameterDiscoveryRes");
+
+        }
+        else
+        {
+            sprintf(buf_log_evcomm,
+                    "[Error][DIN][ChargeParameterDiscoveryRes]%d (DEC)",
+                    errn);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        }
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_iso1_ChargeParameterDiscoveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_ChargeParameterDiscoveryReq(int AcceptFd)
+{
+    int errn = 0;
+    //SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_ChargeParameterDiscoveryReq] Got ChargeParameterDiscoveryReq");
+
+    //ftime(&SeqStartTime);
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO1_ChargeParameterDiscoveryReq(&ccs_exi_doc_ISO1);
+
+    //Save into Share Memory
+    SHM_Save_iso1_ChargeParameterDiscoveryReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+    //Check for EV Error Code
+    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest.DC_EVChargeParameter.DC_EVStatus.EVErrorCode);
+
+    errn = Proc_iso1_ChargeParameterDiscoveryRes(AcceptFd);
+    //ftime(&SeqEndTime);
+    //DEBUG_PRINTF_EVCOMM_DETAIL("\ndelta = %.02lf ms\n", DiffTimeb(SeqStartTime, SeqEndTime));
+    if (errn == 0)
+    {
+        //send response successfully.
+        //SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][V2G][Tx]ChargeParameterDiscoveryRes");
+
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][ISO1][ChargeParameterDiscoveryRes]%d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Init_din_CableCheckRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+    1. shm_ccs
+
+OUTPUT:
+    1. shm_ccs
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Init_din_CableCheckRes(struct CcsData *shm_ccs)
+{
+	struct CableCheckResponse_DIN70121 *in;
+
+	in = &shm_ccs->V2GMessage_DIN70121.CableCheckResponse;
+
+	//----- [BODY (1/3)] ResponseCode -----
+    in->ResponseCode = dinresponseCodeType_OK;
+
+    //----- [BODY (2/3)] EVSEProcessing -----
+	//in->EVSEProcessing = dinEVSEProcessingType_Finished; //for test
+    in->EVSEProcessing = dinEVSEProcessingType_Ongoing; //default
+    // 	dinEVSEProcessingType_Finished = 0,
+    //	dinEVSEProcessingType_Ongoing = 1
+
+    //----- [BODY (3/3)] DC_EVSEStatus -----
+	SHM_Init_dinDC_EVSEStatusType(&in->DC_EVSEStatus);
+    in->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;    //0 (default)
+    //	dinisolationLevelType_Invalid = 0,
+    //	dinisolationLevelType_Valid = 1, (default)
+    //	dinisolationLevelType_Warning = 2,
+    //	dinisolationLevelType_Fault = 3
+}
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_din_CableCheckRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_din_CableCheckRes()
+{
+    init_dinBodyType(&ccs_exi_doc_DIN.V2G_Message.Body);
+    init_dinCableCheckResType(&ccs_exi_doc_DIN.V2G_Message.Body.CableCheckRes);
+
+    ccs_exi_doc_DIN.V2G_Message.Body.CableCheckRes_isUsed = 1u;
+
+    //----- [BODY (1/3)] ResponseCode -----
+    struct dinCableCheckResType *res;
+    res = &ccs_exi_doc_DIN.V2G_Message.Body.CableCheckRes;
+    res->ResponseCode = dinresponseCodeType_OK;
+
+    //----- [BODY (2/3)] EVSEProcessing -----
+    res->EVSEProcessing = dinEVSEProcessingType_Finished; //0
+    // 	dinEVSEProcessingType_Finished = 0,
+    //	dinEVSEProcessingType_Ongoing = 1
+
+    //----- [BODY (3/3)] DC_EVSEStatus -----
+    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+    res->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;
+    //	dinisolationLevelType_Invalid = 0,
+    //	dinisolationLevelType_Valid = 1,
+    //	dinisolationLevelType_Warning = 2,
+    //	dinisolationLevelType_Fault = 3
+
+    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
+    // dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
+    // dinDC_EVSEStatusCodeType_EVSE_Ready = 1,
+    // 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
+
+    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
+
+    res->DC_EVSEStatus.EVSENotification = dinEVSENotificationType_None;
+    // dinEVSENotificationType_None = 0,
+    // dinEVSENotificationType_StopCharging = 1,
+    // dinEVSENotificationType_ReNegotiation = 2
+}
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_iso1_CableCheckRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_iso1_CableCheckRes()
+{
+    init_iso1BodyType(&ccs_exi_doc_ISO1.V2G_Message.Body);
+    init_iso1CableCheckResType(&ccs_exi_doc_ISO1.V2G_Message.Body.CableCheckRes);
+
+    ccs_exi_doc_ISO1.V2G_Message.Body.CableCheckRes_isUsed = 1u;
+
+    //----- [BODY (1/3)] ResponseCode -----
+    struct iso1CableCheckResType *res;
+    res = &ccs_exi_doc_ISO1.V2G_Message.Body.CableCheckRes;
+    res->ResponseCode = iso1responseCodeType_OK;
+
+    //----- [BODY (2/3)] EVSEProcessing -----
+    res->EVSEProcessing = iso1EVSEProcessingType_Finished; //0
+    //iso1EVSEProcessingType_Finished = 0,
+	//iso1EVSEProcessingType_Ongoing = 1,
+	//iso1EVSEProcessingType_Ongoing_WaitingForCustomerInteraction = 2
+
+    //----- [BODY (3/3)] DC_EVSEStatus -----
+    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+    res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;
+    //iso1isolationLevelType_Invalid = 0,
+	//iso1isolationLevelType_Valid = 1,
+	//iso1isolationLevelType_Warning = 2,
+	//iso1isolationLevelType_Fault = 3,
+	//iso1isolationLevelType_No_IMD = 4
+
+    res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+    //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
+
+    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
+
+    res->DC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
+    //iso1EVSENotificationType_None = 0,
+	//iso1EVSENotificationType_StopCharging = 1,
+	//iso1EVSENotificationType_ReNegotiation = 2
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_CableCheckRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_CableCheckRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct CableCheckResponse_DIN70121 *cab;
+    static struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    cab = &ShmCcsData->V2GMessage_DIN70121.CableCheckResponse;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    cab->ResponseCode = OK_DIN70121;
+    cab->cnt++;
+
+    DEBUG_PRINTF_EVCOMM_DETAIL("CP_State = %d (%.02f V), V_now = %.02f, Isolation Status = %d, EVSEProcessing = %d\n",
+            sys->CpState,
+            sys->CpVoltage,
+            sys->PresentChargingVoltage,
+            sys->IsolationStatus,
+            cab->EVSEProcessing);
+
+    //[HEADER] Check Req SessionID
+    if (Check_din_V2G_Rx_MSG_SessionID(&ccs_exi_doc_DIN) < 0)
+    {
+        cab->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        cab->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+    if (sys->IsolationStatus == GFD_Invalid)  //0: on going
+    {
+        //For PSU
+        sys->EvBatterytargetVoltage = CABLECHECK_TARGET_VOLTAGE;	//500V	//[To-Do] this should be modified to auto decision.
+        sys->EvBatterytargetCurrent = CABLECHECK_TARGET_CURRENT;	//2A(default), unit: 1A
+
+        cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;
+        cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_IsolationMonitoringActive;    //4
+        cab->EVSEProcessing = dinEVSEProcessingType_Ongoing;
+    }
+    else if ((sys->IsolationStatus == GFD_Valid) || (sys->IsolationStatus == GFD_Warning)) //1: valid, 2: warning
+    {
+        //For PSU
+        sys->EvBatterytargetVoltage = 0;	//0V, asking PSU to discharge to 0V
+        sys->EvBatterytargetCurrent = 0;	//0A, unit: 1A
+
+        if (sys->PresentChargingVoltage < 60)  // < 60V
+        {
+            //memset(buf_log_evcomm, 0, sizeof(buf_log_evcomm));
+            sprintf(buf_log_evcomm, "[V2G][CableCheck]Pass (V_now = %.02f, Isolated = %d)",
+                    sys->PresentChargingVoltage,
+                    sys->IsolationStatus);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+            //IsolationStatus
+            if (sys->IsolationStatus == GFD_Valid)
+            {
+                cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;
+            }
+            else if (sys->IsolationStatus == GFD_Warning)
+            {
+                cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Warning;
+            }
+            else
+            {
+                sprintf(buf_log_evcomm,
+                        "[WARNING]unexpected IsolationStatus(%d)",
+                        sys->IsolationStatus);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            }
+            cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
+            cab->EVSEProcessing = dinEVSEProcessingType_Finished;
+        }
+        else
+        {
+            cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;
+            cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_IsolationMonitoringActive;
+            cab->EVSEProcessing = dinEVSEProcessingType_Ongoing;
+        }
+    }
+    else if (sys->IsolationStatus == GFD_Fault) //3: fault
+    {
+        //For PSU
+        sys->EvBatterytargetVoltage = 0;	//0V, asking PSU to discharge to 0V
+        sys->EvBatterytargetCurrent = 0;	//0A, unit: 1A
+
+        cab->ResponseCode = FAILED_DIN70121;
+        cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
+        cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_NotReady;
+        cab->EVSEProcessing = dinEVSEProcessingType_Finished;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_CableCheckRes]IsolationStatus = 3 (fault)");
+        errn = -1;
+    }
+    else
+    {
+        //For PSU
+        sys->EvBatterytargetVoltage = 0;	//0V, asking PSU to discharge to 0V
+        sys->EvBatterytargetCurrent = 0;	//0A, unit: 1A
+
+        cab->ResponseCode = FAILED_DIN70121;
+        cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;
+        cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_NotReady;
+        cab->EVSEProcessing = dinEVSEProcessingType_Finished;
+        sprintf(buf_log_evcomm,
+                "[Proc_din_CableCheckRes]Undefined Isolation Status(%d)",
+                sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        cab->ResponseCode = FAILED_DIN70121;
+        cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+        cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
+        cab->EVSEProcessing = dinEVSEProcessingType_Finished;
+	//    errn = -1;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_CableCheckRes]EVSE_Shutdown");
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        cab->ResponseCode = FAILED_DIN70121;
+        cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
+        cab->EVSEProcessing = dinEVSEProcessingType_Finished;
+	    errn = -1;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_CableCheckRes]EVSE_EmergencyShutdown");
+    }
+    else if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        cab->ResponseCode = FAILED_DIN70121;
+        cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+        cab->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
+        cab->EVSEProcessing = dinEVSEProcessingType_Finished;
+	//    errn = -1;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_din_CableCheckRes]ChargingPermission = FALSE");
+    }
+    else
+    {
+        //null
+    }
+
+    //Response to CP Error
+    #if CP_PROTECTION_MECHANISM == ENABLE
+    //#if 1
+    if (sys->CableCheckPreCountDownDone == TRUE)   //[To-Do] Here should be modified to 2 seconds
+    {
+        if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
+        {
+            cab->ResponseCode = FAILED_DIN70121;
+            cab->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+            CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+            Update_V2G_Flow_Status(Other_Fault);
+            errn = -1;
+
+            //Update_ShmStatusCode(); //[To-Do] to be implemented
+            //CCS_SECC_CP_State_Error (023889)
+            ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+            ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+            ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+            ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+            ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+            ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+            CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+
+            sprintf(buf_log_evcomm,
+                    "[CableCheck]Emergency Stop by CP Error (%d, %.02f V, %d)\n",
+                    sys->CpState,
+                    sys->CpVoltage,
+                    cab->cnt
+                    );
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            //cab->cnt = 0;
+        }
+    }
+    #endif
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_din_CableCheckRes(&ccs_exi_doc_DIN, ShmCcsData);
+    #else
+    Sudo_Parameter_din_CableCheckRes();
+    #endif
+
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_DIN) != 0)
+    {
+      errn = -1;
+    }
+
+    //STEP 5: ============ Update Flags ===========
+    sys->ConnectorLocked = TRUE;    //Inicating EVSE that the CCS Connector is Locked.
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_iso1_CableCheckRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_CableCheckRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct CableCheckResponse_ISO15118_2014 *cab;
+    static struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    cab = &ShmCcsData->V2GMessage_ISO15118_2014.CableCheckResponse;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    cab->ResponseCode = OK_ISO15118_2014;
+    cab->cnt++;
+
+    DEBUG_PRINTF_EVCOMM_DETAIL("CP_State = %d (%.02f V), V_now = %.02f, Isolation Status = %d, EVSEProcessing = %d\n",
+            sys->CpState,
+            sys->CpVoltage,
+            sys->PresentChargingVoltage,
+            sys->IsolationStatus,
+            cab->EVSEProcessing);
+
+
+    //[HEADER] Check Req SessionID
+    if (Check_iso1_V2G_Rx_MSG_SessionID(&ccs_exi_doc_ISO1) < 0)
+    {
+        cab->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        cab->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+    if (sys->IsolationStatus == GFD_Invalid)  //0: invalid (on going)
+    {
+        //For PSU
+        sys->EvBatterytargetVoltage = CABLECHECK_TARGET_VOLTAGE;	//500V	//[To-Do] this should be modified to auto decision.
+        sys->EvBatterytargetCurrent = CABLECHECK_TARGET_CURRENT;	//2A(default), unit: 1A
+
+        cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid;
+        cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_IsolationMonitoringActive;
+        cab->EVSEProcessing = iso1EVSEProcessingType_Ongoing;
+    }
+    else if ((sys->IsolationStatus == GFD_Valid) || (sys->IsolationStatus == GFD_Warning)) //1: valid, 2:waring
+    {
+        //For PSU
+        sys->EvBatterytargetVoltage = 0;	//0V, asking PSU to discharge to 0V
+        sys->EvBatterytargetCurrent = 0;	//0A, unit: 1A
+
+        if (sys->PresentChargingVoltage < 60)  // < 60V
+        {
+            //memset(buf_log_evcomm, 0, sizeof(buf_log_evcomm));
+            sprintf(buf_log_evcomm, "[V2G][CableCheck]Pass (V_now = %.02f, Isolated = %d)",
+                    sys->PresentChargingVoltage,
+                    sys->IsolationStatus);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+            //IsolationStatus
+            if (sys->IsolationStatus == GFD_Valid)
+            {
+                cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;
+            }
+            else if (sys->IsolationStatus == GFD_Warning)
+            {
+                cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Warning;
+            }
+            else
+            {
+                sprintf(buf_log_evcomm,
+                        "[WARNING]unexpected IsolationStatus(%d)",
+                        sys->IsolationStatus);
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            }
+
+            cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+            cab->EVSEProcessing = iso1EVSEProcessingType_Finished;
+        }
+        else
+        {
+            cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid;
+            cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_IsolationMonitoringActive;
+            cab->EVSEProcessing = iso1EVSEProcessingType_Ongoing;
+        }
+    }
+    else if (sys->IsolationStatus == GFD_Fault) //3: fault
+    {
+        //For PSU
+        sys->EvBatterytargetVoltage = 0;	//0V, asking PSU to discharge to 0V
+        sys->EvBatterytargetCurrent = 0;	//0A, unit: 1A
+
+        cab->ResponseCode = FAILED_ISO15118_2014;
+        cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
+        cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_NotReady;
+        cab->EVSEProcessing = iso1EVSEProcessingType_Finished;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_CableCheckRes]IsolationStatus = 3 (fault)");
+        errn = -1;
+    }
+    //else if (sys->IsolationStatus == GFD_No_IMD){}    //only for ISO15118
+    else
+    {
+        //For PSU
+        sys->EvBatterytargetVoltage = 0;	//0V, asking PSU to discharge to 0V
+        sys->EvBatterytargetCurrent = 0;	//0A, unit: 1A
+
+        cab->ResponseCode = FAILED_ISO15118_2014;
+        cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
+        cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_NotReady;
+        cab->EVSEProcessing = iso1EVSEProcessingType_Finished;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_CableCheckRes]Undefined Isolation Status.");
+    }
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        cab->ResponseCode = FAILED_ISO15118_2014;
+        cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+        cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
+        cab->EVSEProcessing = iso1EVSEProcessingType_Finished;
+      //  errn = -1;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_CableCheckRes]EVSE_Shutdown");
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        cab->ResponseCode = FAILED_ISO15118_2014;
+        cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
+        cab->EVSEProcessing = iso1EVSEProcessingType_Finished;
+        errn = -1;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_CableCheckRes]EVSE_EmergencyShutdown");
+    }
+    else if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        cab->ResponseCode = FAILED_ISO15118_2014;
+        cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+        cab->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
+        cab->EVSEProcessing = iso1EVSEProcessingType_Finished;
+    //    errn = -1;
+	    SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_iso1_CableCheckRes]ChargingPermission = FALSE");
+    }
+    else
+    {
+        //null
+    }
+
+    //Response to CP Error
+    #if CP_PROTECTION_MECHANISM == ENABLE
+    if (sys->CableCheckPreCountDownDone == TRUE)   //[To-Do] Here should be modified to 2 seconds
+    {
+        if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
+        {
+            cab->ResponseCode = FAILED_ISO15118_2014;
+            cab->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+            CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+            Update_V2G_Flow_Status(Other_Fault);
+            errn = -1;
+
+            //Update_ShmStatusCode(); //[To-Do] to be implemented
+            //CCS_SECC_CP_State_Error (023889)
+            ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+            ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+            ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+            ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+            ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+            ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+            CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+
+            sprintf(buf_log_evcomm,
+                    "[CableCheck]Emergency Stop by CP Error (%d, %.02f V, %d)\n",
+                    sys->CpState,
+                    sys->CpVoltage,
+                    cab->cnt
+                    );
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            //cab->cnt = 0;
+        }
+    }
+    #endif
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_iso1_CableCheckRes(&ccs_exi_doc_ISO1, ShmCcsData);
+    #else
+    Sudo_Parameter_iso1_CableCheckRes();
+    #endif
+
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        errn = -1;
+    }
+
+    //STEP 5: ============ Update Flags ===========
+    sys->ConnectorLocked = TRUE;    //Inicating EVSE that the CCS Connector is Locked.
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_CableCheckReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_CableCheckReq(int AcceptFd)
+{
+    int errn = 0;
+    //SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_CableCheckReq] Got CableCheckReq\n");
+
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_DIN_CableCheckReq(&ccs_exi_doc_DIN);
+
+    //Save into Share Memory
+    SHM_Save_din_CableCheckReq(ShmCcsData, &ccs_exi_doc_DIN, ShmSysConfigAndInfo);
+
+    //Check for EV Error Code
+    Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.CableCheckRequest.DC_EVStatus.EVErrorCode);
+
+    errn = Proc_din_CableCheckRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        //SAVE_SYS_LOG_MSG_EVCOMM("[DIN][V2G][Tx]CableCheckRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_din_CableCheckReq]Proc_iso1_CableCheckRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_CableCheckReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_CableCheckReq(int AcceptFd)
+{
+    int errn = 0;
+    //SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_CableCheckReq] Got CableCheckReq");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO1_CableCheckReq(&ccs_exi_doc_ISO1);
+
+    //Save into Share Memory
+    SHM_Save_iso1_CableCheckReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+    //Check for EV Error Code
+    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.CableCheckRequest.DC_EVStatus.EVErrorCode);
+
+    errn = Proc_iso1_CableCheckRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        //SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][V2G][Tx]CableCheckRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_iso1_CableCheckReq]Proc_iso1_CableCheckRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+
+
+/*===========================================================================
+FUNCTION: SHM_Init_din_PreChargeRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+    1. shm_ccs
+
+OUTPUT:
+    1. shm_ccs
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Init_din_PreChargeRes(struct CcsData *shm_ccs)
+{
+	struct PreChargeResponse_DIN70121 *in;
+
+	in = &shm_ccs->V2GMessage_DIN70121.PreChargeResponse;
+
+	//----- [BODY (1/3)] ResponseCode -----
+    in->ResponseCode = dinresponseCodeType_OK;
+
+
+    //----- [BODY (2/3)] EVSEPresentVoltage -----
+    short value = 0; int multiplier = 0; unsigned char unit = 0;
+    //value = 3820; multiplier = -1; unit = V_DIN70121;    //382V, for Test
+    value = 0; multiplier = 0; unit = V_DIN70121; //waiting for CsuComm to update V to fit EV Target
+	SHM_Save_dinPhysicalValueType(&in->EVSEPresentVoltage, value, multiplier, unit);
+
+    //----- [BODY (3/3)] DC_EVSEStatus -----
+	SHM_Init_dinDC_EVSEStatusType(&in->DC_EVSEStatus);
+}
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_din_PreChargeRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_din_PreChargeRes()
+{
+    init_dinBodyType(&ccs_exi_doc_DIN.V2G_Message.Body);
+    init_dinPreChargeResType(&ccs_exi_doc_DIN.V2G_Message.Body.PreChargeRes);
+
+    ccs_exi_doc_DIN.V2G_Message.Body.PreChargeRes_isUsed = 1u;
+
+    //----- [BODY (1/3)] ResponseCode -----
+    struct dinPreChargeResType *res;
+    res = &ccs_exi_doc_DIN.V2G_Message.Body.PreChargeRes;
+    res->ResponseCode = dinresponseCodeType_OK;
+
+
+    //----- [BODY (2/3)] EVSEPresentVoltage -----
+    res->EVSEPresentVoltage.Value = 3820;
+    res->EVSEPresentVoltage.Multiplier = -1;
+    res->EVSEPresentVoltage.Unit_isUsed = 1u;
+    res->EVSEPresentVoltage.Unit = dinunitSymbolType_V;
+    //	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 -----
+    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+    res->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;
+    //	dinisolationLevelType_Invalid = 0,
+    //	dinisolationLevelType_Valid = 1,
+    //	dinisolationLevelType_Warning = 2,
+    //	dinisolationLevelType_Fault = 3
+
+    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
+    // dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
+    // dinDC_EVSEStatusCodeType_EVSE_Ready = 1,
+    // 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
+
+    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
+
+    res->DC_EVSEStatus.EVSENotification = dinEVSENotificationType_None;
+    // dinEVSENotificationType_None = 0,
+    // dinEVSENotificationType_StopCharging = 1,
+    // dinEVSENotificationType_ReNegotiation = 2
+}
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_iso1_PreChargeRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_iso1_PreChargeRes()
+{
+    init_iso1BodyType(&ccs_exi_doc_ISO1.V2G_Message.Body);
+    init_iso1PreChargeResType(&ccs_exi_doc_ISO1.V2G_Message.Body.PreChargeRes);
+
+    ccs_exi_doc_ISO1.V2G_Message.Body.PreChargeRes_isUsed = 1u;
+
+    //----- [BODY (1/3)] ResponseCode -----
+    struct iso1PreChargeResType *res;
+    res = &ccs_exi_doc_ISO1.V2G_Message.Body.PreChargeRes;
+    res->ResponseCode = iso1responseCodeType_OK;
+
+
+    //----- [BODY (2/3)] EVSEPresentVoltage -----
+    res->EVSEPresentVoltage.Value = 3820;
+    res->EVSEPresentVoltage.Multiplier = -1;
+    //res->EVSEPresentVoltage.Unit_isUsed = 1u;
+    res->EVSEPresentVoltage.Unit = iso1unitSymbolType_V;
+    //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 -----
+    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+    res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;
+    //iso1isolationLevelType_Invalid = 0,
+	//iso1isolationLevelType_Valid = 1,
+	//iso1isolationLevelType_Warning = 2,
+	//iso1isolationLevelType_Fault = 3,
+	//iso1isolationLevelType_No_IMD = 4
+
+    res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+    //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
+
+    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
+
+    res->DC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
+    //iso1EVSENotificationType_None = 0,
+	//iso1EVSENotificationType_StopCharging = 1,
+	//iso1EVSENotificationType_ReNegotiation = 2
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_PreChargeRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_PreChargeRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct PreChargeResponse_DIN70121 *pre;
+    static struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    pre = &ShmCcsData->V2GMessage_DIN70121.PreChargeResponse;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    pre->ResponseCode = OK_DIN70121;
+
+    //EVSE Status Code
+    pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
+
+    //[HEADER] Check Req SessionID
+    if (Check_din_V2G_Rx_MSG_SessionID(&ccs_exi_doc_DIN) < 0)
+    {
+        pre->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        pre->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+    SAVE_PhysicalValueType_DIN70121(&pre->EVSEPresentVoltage, (int) (sys->PresentChargingVoltage * 10), V_DIN70121);
+
+    //Isolation Status
+    if (sys->IsolationStatus == GFD_Invalid)  //0: invalid
+    {
+    	#if 0
+        pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid; //0
+        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+        sprintf(buf_log_evcomm, "[Error][Proc_din_PreChargeRes]IsolationStatus = %d", sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #else
+          pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;  //1
+        #endif
+    }
+    else if (sys->IsolationStatus == GFD_Valid) //1: valid
+    {
+        pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;  //1
+    }
+    else if (sys->IsolationStatus == GFD_Warning) //2: warning
+    {
+        pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Warning;  //2
+    }
+    else if (sys->IsolationStatus == GFD_Fault) //3: fault
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_din_PreChargeRes]GFD_Fault => Emergency Shutdown");
+        pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;  //3
+        pre->ResponseCode = FAILED_DIN70121;
+        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        errn = -1;
+    }
+    else    //GFD_No_IMD or other unexpected status
+    {
+        pre->ResponseCode = FAILED_DIN70121;
+        pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;  //3
+        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+        sprintf(buf_log_evcomm,
+                "[Error][Proc_din_PreChargeRes]IsolationStatus = %d (undefined)",
+                sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        //Check for Alarm Code: CCS GFD trip (012235)
+        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_din_PreChargeRes]CCS GFD trip => EVSE_Shutdown");
+            pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
+        }
+        else
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_din_PreChargeRes]EVSE_Shutdown");
+            pre->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+        }
+
+        pre->ResponseCode = FAILED_DIN70121;
+        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+        errn = -1;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        //Check for Alarm Code: CCS GFD trip (012235)
+        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_din_PreChargeRes]CCS GFD trip => EVSE_EmergencyShutdown");
+            pre->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
+        }
+        else
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_din_PreChargeRes]EVSE_EmergencyShutdown");
+            pre->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+        }
+
+        pre->ResponseCode = FAILED_DIN70121;
+        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        errn = -1;
+    }
+    else if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_din_PreChargeRes]ChargingPermission = FALSE");
+        pre->ResponseCode = FAILED_DIN70121;
+        pre->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+        errn = -1;
+    }
+    else
+    {
+        //null
+    }
+
+    //Response to CP Error
+    #if CP_PROTECTION_MECHANISM == ENABLE
+    if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
+    {
+        pre->ResponseCode = FAILED_DIN70121;
+        pre->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_CP_State_Error (023889)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+
+        sprintf(buf_log_evcomm,
+                "[Error][Proc_din_PreChargeRes]Emergency Stop by CP Error (%d, %.02f V)\n",
+                sys->CpState,
+                sys->CpVoltage
+                );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    #endif
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_din_PreChargeRes(&ccs_exi_doc_DIN, ShmCcsData);
+    #else
+    Sudo_Parameter_din_PreChargeRes();
+    #endif
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_DIN) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][send_encoded_din_V2GTP_Stream]:Tx encoded msg error");
+        errn = -1;
+    }
+
+    //STEP 5: ============ Update Flags ===========
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_PreChargeRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_PreChargeRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct PreChargeResponse_ISO15118_2014 *pre;
+    static struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    pre = &ShmCcsData->V2GMessage_ISO15118_2014.PreChargeResponse;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    pre->ResponseCode = OK_ISO15118_2014;
+
+    //EVSE Status Code
+    pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+
+    //[HEADER] Check Req SessionID
+    if (Check_iso1_V2G_Rx_MSG_SessionID(&ccs_exi_doc_ISO1) < 0)
+    {
+        pre->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        pre->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+    SAVE_PhysicalValueType_ISO15118_2014(&pre->EVSEPresentVoltage, (int) (sys->PresentChargingVoltage * 10), V_ISO15118_2014);
+
+
+    //Isolation Status
+    if (sys->IsolationStatus == GFD_Invalid)    //0: invalid(on going)
+    {
+    	#if 0
+        pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid; //0
+        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+      //  Update_V2G_Flow_Status(Other_Fault);
+      //  errn = -1;
+
+        sprintf(buf_log_evcomm, "[Error][Proc_iso1_PreChargeRes]IsolationStatus = %d", sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        #else
+          pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;  //1
+        #endif
+    }
+    else if (sys->IsolationStatus == GFD_Valid) //1: valid
+    {
+        pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;  //1
+    }
+    else if (sys->IsolationStatus == GFD_Warning) //2: waring
+    {
+        pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Warning;  //1
+    }
+    else if (sys->IsolationStatus == GFD_Fault) //3: fault
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_iso1_PreChargeRes]GFD_Fault => Emergency Shutdown");
+        pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;  //3
+        pre->ResponseCode = FAILED_ISO15118_2014;
+        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        errn = -1;
+    }
+    else
+    {
+        pre->ResponseCode = FAILED_ISO15118_2014;
+        pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;  //3
+        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+
+        sprintf(buf_log_evcomm,
+                "[Error][Proc_iso1_PreChargeRes]IsolationStatus = %d (undefined)",
+                sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        //Check for Alarm Code: CCS GFD trip (012235)
+        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_iso1_PreChargeRes]CCS GFD trip => EVSE_Shutdown");
+            pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
+        }
+        else
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_iso1_PreChargeRes]EVSE_Shutdown");
+            pre->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+        }
+
+        pre->ResponseCode = FAILED_ISO15118_2014;
+        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+       // errn = -1;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        //Check for Alarm Code: CCS GFD trip (012235)
+        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_iso1_PreChargeRes]CCS GFD trip => EVSE_EmergencyShutdown");
+            pre->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
+        }
+        else
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_iso1_PreChargeRes]EVSE_EmergencyShutdown");
+            pre->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+        }
+
+        pre->ResponseCode = FAILED_ISO15118_2014;
+        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        errn = -1;
+    }
+    else if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_iso1_PreChargeRes]ChargingPermission = FALSE");
+        pre->ResponseCode = FAILED_ISO15118_2014;
+        pre->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+      //  errn = -1;
+    }
+    else
+    {
+        //null
+    }
+
+    //Response to CP Error
+    #if CP_PROTECTION_MECHANISM == ENABLE
+    if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
+    {
+        pre->ResponseCode = FAILED_ISO15118_2014;
+        pre->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_CP_State_Error (023889)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+
+        sprintf(buf_log_evcomm,
+                "[Error][Proc_iso1_PreChargeRes]Emergency Stop by CP Error (%d, %.02f V)\n",
+                sys->CpState,
+                sys->CpVoltage
+                );
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    #endif
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_iso1_PreChargeRes(&ccs_exi_doc_ISO1, ShmCcsData);
+    #else
+    Sudo_Parameter_iso1_PreChargeRes();
+    #endif
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][send_encoded_iso1_V2GTP_Stream]:Tx encoded msg error");
+        errn = -1;
+    }
+
+    //STEP 5: ============ Update Flags ===========
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_PreChargeReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_PreChargeReq(int AcceptFd)
+{
+    int errn = 0;
+    //SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_PreChargeReq] Got PreChargeReq");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_DIN_PreChargeReq(&ccs_exi_doc_DIN);
+
+    //Save into Share Memory
+    SHM_Save_din_PreChargeReq(ShmCcsData, &ccs_exi_doc_DIN, ShmSysConfigAndInfo);
+
+    //Check for EV Error Code
+    Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.PreChargeRequest.DC_EVStatus.EVErrorCode);
+
+    errn = Proc_din_PreChargeRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        //SAVE_SYS_LOG_MSG_EVCOMM("[DIN][V2G][Tx]PreChargeRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_din_PreChargeReq]Proc_iso1_PreChargeRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_PreChargeReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_PreChargeReq(int AcceptFd)
+{
+    int errn = 0;
+    //SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_PreChargeReq] Got PreChargeReq");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO1_PreChargeReq(&ccs_exi_doc_ISO1);
+
+    //Save into Share Memory
+    SHM_Save_iso1_PreChargeReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+    //Check for EV Error Code
+    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.PreChargeRequest.DC_EVStatus.EVErrorCode);
+
+    errn = Proc_iso1_PreChargeRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        //SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][V2G][Tx]PreChargeRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_iso1_PreChargeReq]Proc_iso1_PreChargeRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Init_din_PowerDeliveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+    1. shm_ccs
+
+OUTPUT:
+    1. shm_ccs
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Init_din_PowerDeliveryRes(struct CcsData *shm_ccs)
+{
+	struct PowerDeliveryResponse_DIN70121 *in;
+
+	in = &shm_ccs->V2GMessage_DIN70121.PowerDeliveryResponse;
+
+
+	//----- [BODY (1/3)] ResponseCode -----
+    in->ResponseCode = dinresponseCodeType_OK;
+
+
+    //----- [BODY (2/3)] AC_EVSEStatus -----
+    //ignore, since DIN 70121 doesn't support AC, yet.
+
+
+    //----- [BODY (2/3)] DC_EVSEStatus -----
+	SHM_Init_dinDC_EVSEStatusType(&in->DC_EVSEStatus);
+}
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_din_PowerDeliveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_din_PowerDeliveryRes()
+{
+    init_dinBodyType(&ccs_exi_doc_DIN.V2G_Message.Body);
+    init_dinPowerDeliveryResType(&ccs_exi_doc_DIN.V2G_Message.Body.PowerDeliveryRes);
+
+    ccs_exi_doc_DIN.V2G_Message.Body.PowerDeliveryRes_isUsed = 1u;
+
+    //----- [BODY (1/3)] ResponseCode -----
+    struct dinPowerDeliveryResType *res;
+    res = &ccs_exi_doc_DIN.V2G_Message.Body.PowerDeliveryRes;
+    res->ResponseCode = dinresponseCodeType_OK;
+
+
+    //----- [BODY (2/3)] AC_EVSEStatus -----
+    //ignore, since DIN 70121 doesn't support AC, yet.
+
+
+    //----- [BODY (2/3)] DC_EVSEStatus -----
+    res->DC_EVSEStatus_isUsed = 1u;
+    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+    res->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;
+    //	dinisolationLevelType_Invalid = 0,
+    //	dinisolationLevelType_Valid = 1,
+    //	dinisolationLevelType_Warning = 2,
+    //	dinisolationLevelType_Fault = 3
+
+    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
+    // dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
+    // dinDC_EVSEStatusCodeType_EVSE_Ready = 1,
+    // 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
+
+    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
+
+    res->DC_EVSEStatus.EVSENotification = dinEVSENotificationType_None;
+    // dinEVSENotificationType_None = 0,
+    // dinEVSENotificationType_StopCharging = 1,
+    // dinEVSENotificationType_ReNegotiation = 2
+}
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_iso1_PowerDeliveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_iso1_PowerDeliveryRes()
+{
+    init_iso1BodyType(&ccs_exi_doc_ISO1.V2G_Message.Body);
+    init_iso1PowerDeliveryResType(&ccs_exi_doc_ISO1.V2G_Message.Body.PowerDeliveryRes);
+
+    ccs_exi_doc_ISO1.V2G_Message.Body.PowerDeliveryRes_isUsed = 1u;
+
+    //----- [BODY (1/3)] ResponseCode -----
+    struct iso1PowerDeliveryResType *res;
+    res = &ccs_exi_doc_ISO1.V2G_Message.Body.PowerDeliveryRes;
+    res->ResponseCode = iso1responseCodeType_OK;
+
+
+    //----- [BODY (2/3)] AC_EVSEStatus -----
+    //ignore, since our ISO1 70121 doesn't support AC, yet.
+
+
+    //----- [BODY (2/3)] DC_EVSEStatus -----
+    res->DC_EVSEStatus_isUsed = 1u;
+    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+    res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;
+    //iso1isolationLevelType_Invalid = 0,
+	//iso1isolationLevelType_Valid = 1,
+	//iso1isolationLevelType_Warning = 2,
+	//iso1isolationLevelType_Fault = 3,
+	//iso1isolationLevelType_No_IMD = 4
+
+    res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+    //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
+
+    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
+
+    res->DC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
+    //iso1EVSENotificationType_None = 0,
+	//iso1EVSENotificationType_StopCharging = 1,
+	//iso1EVSENotificationType_ReNegotiation = 2
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_PowerDeliveryStartRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_PowerDeliveryStartRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    struct dinPowerDeliveryResType *res;
+    struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    res = &ccs_exi_doc_DIN.V2G_Message.Body.PowerDeliveryRes;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    res->ResponseCode = OK_DIN70121;
+
+    //[HEADER] Check Req SessionID
+    if (Check_din_V2G_Rx_MSG_SessionID(&ccs_exi_doc_DIN) < 0)
+    {
+        res->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        res->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_din_PowerDeliveryRes(&ccs_exi_doc_DIN, ShmCcsData);
+    #else
+    Sudo_Parameter_din_PowerDeliveryRes();
+    #endif
+
+    //EVSE Status Code
+    res->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;  //1
+    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        //res->ResponseCode = FAILED_DIN70121;
+        res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        //res->ResponseCode = FAILED_DIN70121;
+        res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+          errn = -1;
+    }
+    else if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        //res->ResponseCode = FAILED_DIN70121;
+        res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+    }
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_DIN) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_PowerDeliveryStartRes][Error]Tx encoded msg error");
+        errn = -1;
+    }
+
+    //STEP 5: ============ Update Flags ===========
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_iso1_PowerDeliveryStartRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_PowerDeliveryStartRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    struct iso1PowerDeliveryResType *res;
+    struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    res = &ccs_exi_doc_ISO1.V2G_Message.Body.PowerDeliveryRes;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    res->ResponseCode = OK_ISO15118_2014;
+
+    //[HEADER] Check Req SessionID
+    if (Check_iso1_V2G_Rx_MSG_SessionID(&ccs_exi_doc_ISO1) < 0)
+    {
+        res->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_iso1_PowerDeliveryRes(&ccs_exi_doc_ISO1, ShmCcsData);
+    #else
+    Sudo_Parameter_iso1_PowerDeliveryRes();
+    #endif
+
+    //EVSE Status Code
+    res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;  //1
+    res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        //res->ResponseCode = FAILED_ISO15118_2014;
+        res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        //res->ResponseCode = FAILED_ISO15118_2014;
+        res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+          errn = -1;
+    }
+    else if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        //res->ResponseCode = FAILED_ISO15118_2014;
+        res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+    }
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_PowerDeliveryStartRes][Error]Tx encoded msg error");
+        errn = -1;
+    }
+
+    //STEP 5: ============ Update Flags ===========
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_PowerDeliveryStartReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_PowerDeliveryStartReq(int AcceptFd)
+{
+    int errn = 0;
+    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]PowerDeliveryStartReq");
+
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_DIN_PowerDeliveryReq(&ccs_exi_doc_DIN);
+
+    //Save into Share Memory
+    SHM_Save_din_PowerDeliveryReq(ShmCcsData, &ccs_exi_doc_DIN, ShmSysConfigAndInfo);
+
+    //Check for EV Error Code
+    Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.PowerDeliveryRequest.DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode);
+
+    errn = Proc_din_PowerDeliveryStartRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        SAVE_SYS_LOG_MSG_EVCOMM("[DIN][V2G][Tx]PowerDeliveryStartRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][Proc_din_PowerDeliveryStartReq]Proc_iso1_PowerDeliveryStartRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_PowerDeliveryStartReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_PowerDeliveryStartReq(int AcceptFd)
+{
+    int errn = 0;
+    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]PowerDeliveryStartReq");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO1_PowerDeliveryReq(&ccs_exi_doc_ISO1);
+
+    //Save into Share Memory
+    SHM_Save_iso1_PowerDeliveryReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+    //Check for EV Error Code
+    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.PowerDeliveryRequest.DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode);
+
+    errn = Proc_iso1_PowerDeliveryStartRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][V2G][Tx]PowerDeliveryStartRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][Proc_iso1_PowerDeliveryStartReq]Proc_iso1_PowerDeliveryStartRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Init_din_CurrentDemandRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+    1. shm_ccs
+
+OUTPUT:
+    1. shm_ccs
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Init_din_CurrentDemandRes(struct CcsData *shm_ccs)
+{
+	struct CurrentDemandResponse_DIN70121 *in;
+
+	in = &shm_ccs->V2GMessage_DIN70121.CurrentDemandResponse;
+
+
+	//----- [BODY (1/10)] ResponseCode -----
+    in->ResponseCode = dinresponseCodeType_OK;
+
+    //----- [BODY (2/10)] DC_EVSEStatus -----
+    SHM_Init_dinDC_EVSEStatusType(&in->DC_EVSEStatus);
+
+
+    //----- [BODY (3/10)] EVSEPresentVoltage -----
+    short value = 0; int multiplier = 0; unsigned char unit = 0;
+
+    //value = 3820; multiplier = -1; unit = V_DIN70121;    //382V, for test only.
+    value = 0; multiplier = 0; unit = V_DIN70121;
+	SHM_Save_dinPhysicalValueType(&in->EVSEPresentVoltage, value, multiplier, unit);
+
+
+    //----- [BODY (4/10)] EVSEPresentCurrent -----
+    //value = 600; multiplier = -1; unit = A_DIN70121;    //60A, for test only.
+    value = 0; multiplier = 0; unit = A_DIN70121;
+    SHM_Save_dinPhysicalValueType(&in->EVSEPresentCurrent, value, multiplier, unit);
+
+
+    //----- [BODY (5/10)] EVSECurrentLimitAchieved -----
+    in->EVSECurrentLimitAchieved = FALSE;
+
+    //----- [BODY (6/10)] EVSEVoltageLimitAchieved -----
+    in->EVSEVoltageLimitAchieved = FALSE;
+
+    //----- [BODY (7/10)] EVSEPowerLimitAchieved -----
+    in->EVSEPowerLimitAchieved = FALSE;
+
+    //----- [BODY (8/10)] EVSEMaximumVoltageLimit -----
+    //value = 7500; multiplier = -1; unit = V_DIN70121;    //750V
+    value = 5000; multiplier = -1; unit = V_DIN70121;    //500V
+    SHM_Save_dinPhysicalValueType(&in->EVSEMaximumVoltageLimit, value, multiplier, unit);
+
+    //----- [BODY (9/10)] EVSEMaximumCurrentLimit -----
+    value = 600; multiplier = -1; unit = A_DIN70121;    //60A
+    SHM_Save_dinPhysicalValueType(&in->EVSEMaximumCurrentLimit, value, multiplier, unit);
+
+    //----- [BODY (10/10)] EVSEMaximumPowerLimit -----
+    value = 3000; multiplier = 1; unit = W_DIN70121;    //30KW
+    SHM_Save_dinPhysicalValueType(&in->EVSEMaximumPowerLimit, value, multiplier, unit);
+}
+
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_din_CurrentDemandRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_din_CurrentDemandRes()
+{
+    init_dinBodyType(&ccs_exi_doc_DIN.V2G_Message.Body);
+    init_dinCurrentDemandResType(&ccs_exi_doc_DIN.V2G_Message.Body.CurrentDemandRes);
+
+    ccs_exi_doc_DIN.V2G_Message.Body.CurrentDemandRes_isUsed = 1u;
+
+    //----- [BODY (1/10)] ResponseCode -----
+    struct dinCurrentDemandResType *res;
+    res = &ccs_exi_doc_DIN.V2G_Message.Body.CurrentDemandRes;
+    res->ResponseCode = dinresponseCodeType_OK;
+
+    //----- [BODY (2/10)] DC_EVSEStatus -----
+    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+    res->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid;
+    //	dinisolationLevelType_Invalid = 0,
+    //	dinisolationLevelType_Valid = 1,
+    //	dinisolationLevelType_Warning = 2,
+    //	dinisolationLevelType_Fault = 3
+
+    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
+    // dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
+    // dinDC_EVSEStatusCodeType_EVSE_Ready = 1,
+    // 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
+
+    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
+    res->DC_EVSEStatus.EVSENotification = dinEVSENotificationType_None;
+    // dinEVSENotificationType_None = 0,
+    // dinEVSENotificationType_StopCharging = 1,
+    // dinEVSENotificationType_ReNegotiation = 2
+
+
+
+    //----- [BODY (3/10)] EVSEPresentVoltage -----
+    res->EVSEPresentVoltage.Value = 3820;
+    res->EVSEPresentVoltage.Multiplier = -1;
+    res->EVSEPresentVoltage.Unit_isUsed = 1u;
+    res->EVSEPresentVoltage.Unit = dinunitSymbolType_V;
+
+
+    //----- [BODY (4/10)] EVSEPresentCurrent -----
+    res->EVSEPresentCurrent.Value = 1200;
+    res->EVSEPresentCurrent.Multiplier = -1;
+    res->EVSEPresentCurrent.Unit_isUsed = 1u;
+    res->EVSEPresentCurrent.Unit = dinunitSymbolType_A;
+
+
+    //----- [BODY (5/10)] EVSECurrentLimitAchieved -----
+    res->EVSECurrentLimitAchieved = 0;
+
+    //----- [BODY (6/10)] EVSEVoltageLimitAchieved -----
+    res->EVSEVoltageLimitAchieved = 0;
+
+    //----- [BODY (7/10)] EVSEPowerLimitAchieved -----
+    res->EVSEPowerLimitAchieved = 0;
+
+    //----- [BODY (8/10)] EVSEMaximumVoltageLimit -----
+    res->EVSEMaximumVoltageLimit_isUsed = 1u;
+    res->EVSEMaximumVoltageLimit.Value = 7500;
+    res->EVSEMaximumVoltageLimit.Multiplier = -1;
+    res->EVSEMaximumVoltageLimit.Unit_isUsed = 1u;
+    res->EVSEMaximumVoltageLimit.Unit = dinunitSymbolType_V;
+
+    //----- [BODY (9/10)] EVSEMaximumCurrentLimit -----
+    res->EVSEMaximumCurrentLimit_isUsed = 1u;
+    res->EVSEMaximumCurrentLimit.Value = 1200;
+    res->EVSEMaximumCurrentLimit.Multiplier = -1;
+    res->EVSEMaximumCurrentLimit.Unit_isUsed = 1u;
+    res->EVSEMaximumCurrentLimit.Unit = dinunitSymbolType_A;
+
+    //----- [BODY (10/10)] EVSEMaximumPowerLimit -----
+    res->EVSEMaximumPowerLimit_isUsed = 1u;
+    res->EVSEMaximumPowerLimit.Value = 6000;
+    res->EVSEMaximumPowerLimit.Multiplier = 1;
+    res->EVSEMaximumPowerLimit.Unit_isUsed = 1u;
+    res->EVSEMaximumPowerLimit.Unit = dinunitSymbolType_W;
+}
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_iso1_CurrentDemandRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_iso1_CurrentDemandRes()
+{
+    init_iso1BodyType(&ccs_exi_doc_ISO1.V2G_Message.Body);
+    init_iso1CurrentDemandResType(&ccs_exi_doc_ISO1.V2G_Message.Body.CurrentDemandRes);
+
+    ccs_exi_doc_ISO1.V2G_Message.Body.CurrentDemandRes_isUsed = 1u;
+
+    //----- [BODY (1/10)] ResponseCode -----
+    struct iso1CurrentDemandResType *res;
+    res = &ccs_exi_doc_ISO1.V2G_Message.Body.CurrentDemandRes;
+    res->ResponseCode = iso1responseCodeType_OK;
+
+    //----- [BODY (2/10)] DC_EVSEStatus -----
+    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+    res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid;
+    //iso1isolationLevelType_Invalid = 0,
+	//iso1isolationLevelType_Valid = 1,
+	//iso1isolationLevelType_Warning = 2,
+	//iso1isolationLevelType_Fault = 3,
+	//iso1isolationLevelType_No_IMD = 4
+
+    res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+    //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
+
+    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
+    res->DC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
+    //iso1EVSENotificationType_None = 0,
+	//iso1EVSENotificationType_StopCharging = 1,
+	//iso1EVSENotificationType_ReNegotiation = 2
+
+
+
+    //----- [BODY (3/10)] EVSEPresentVoltage -----
+    res->EVSEPresentVoltage.Value = 3820;
+    res->EVSEPresentVoltage.Multiplier = -1;
+    //res->EVSEPresentVoltage.Unit_isUsed = 1u;
+    res->EVSEPresentVoltage.Unit = iso1unitSymbolType_V;
+
+
+    //----- [BODY (4/10)] EVSEPresentCurrent -----
+    res->EVSEPresentCurrent.Value = 1200;
+    res->EVSEPresentCurrent.Multiplier = -1;
+    //res->EVSEPresentCurrent.Unit_isUsed = 1u;
+    res->EVSEPresentCurrent.Unit = iso1unitSymbolType_A;
+
+
+    //----- [BODY (5/10)] EVSECurrentLimitAchieved -----
+    res->EVSECurrentLimitAchieved = 0;
+
+    //----- [BODY (6/10)] EVSEVoltageLimitAchieved -----
+    res->EVSEVoltageLimitAchieved = 0;
+
+    //----- [BODY (7/10)] EVSEPowerLimitAchieved -----
+    res->EVSEPowerLimitAchieved = 0;
+
+    //----- [BODY (8/10)] EVSEMaximumVoltageLimit -----
+    res->EVSEMaximumVoltageLimit_isUsed = 1u;
+    res->EVSEMaximumVoltageLimit.Value = 7500;
+    res->EVSEMaximumVoltageLimit.Multiplier = -1;
+    //res->EVSEMaximumVoltageLimit.Unit_isUsed = 1u;
+    res->EVSEMaximumVoltageLimit.Unit = iso1unitSymbolType_V;
+
+    //----- [BODY (9/10)] EVSEMaximumCurrentLimit -----
+    res->EVSEMaximumCurrentLimit_isUsed = 1u;
+    res->EVSEMaximumCurrentLimit.Value = 1200;
+    res->EVSEMaximumCurrentLimit.Multiplier = -1;
+    //res->EVSEMaximumCurrentLimit.Unit_isUsed = 1u;
+    res->EVSEMaximumCurrentLimit.Unit = iso1unitSymbolType_A;
+
+    //----- [BODY (10/10)] EVSEMaximumPowerLimit -----
+    res->EVSEMaximumPowerLimit_isUsed = 1u;
+    res->EVSEMaximumPowerLimit.Value = 6000;
+    res->EVSEMaximumPowerLimit.Multiplier = 1;
+    //res->EVSEMaximumPowerLimit.Unit_isUsed = 1u;
+    res->EVSEMaximumPowerLimit.Unit = iso1unitSymbolType_W;
+}
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_iso1_ChargingStatusRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_iso1_ChargingStatusRes()
+{
+    int i = 0;
+	struct iso1ChargingStatusResType *res;
+	init_iso1BodyType(&ccs_exi_doc_ISO1.V2G_Message.Body);
+	init_iso1ChargingStatusResType(&ccs_exi_doc_ISO1.V2G_Message.Body.ChargingStatusRes);
+
+	res = &ccs_exi_doc_ISO1.V2G_Message.Body.ChargingStatusRes;
+	ccs_exi_doc_ISO1.V2G_Message.Body.ChargingStatusRes_isUsed = 1u;
+
+
+	//----- [BODY (1/10)] ResponseCode -----
+    res->ResponseCode = OK_ISO15118_2014;
+
+    //----- [BODY (2/10)] AC_EVSEStatus -----
+    res->AC_EVSEStatus.RCD = FALSE;     //FALSE(no error), TRUE(error is detected)
+    res->AC_EVSEStatus.NotificationMaxDelay = 0;
+    res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
+    //	iso1EVSENotificationType_None = 0,
+    //	iso1EVSENotificationType_StopCharging = 1,
+    //	iso1EVSENotificationType_ReNegotiation = 2
+
+    //----- [BODY (3/10)] EVSEMaxCurrent -----
+	res->EVSEMaxCurrent_isUsed = 1u;
+	res->EVSEMaxCurrent.Value = 32;
+	res->EVSEMaxCurrent.Multiplier = 0;
+	res->EVSEMaxCurrent.Unit = iso1unitSymbolType_A;
+
+    //----- [BODY (4/10)] SAScheduleTupleID -----
+	res->SAScheduleTupleID = 0;
+
+    //----- [BODY (5/10)] EVSEID -----
+    res->EVSEID.charactersLen = 37;
+    memset(res->EVSEID.characters, 0, sizeof(res->EVSEID.characters));
+    //sprintf(res->EVSEID.characters, CCS_AC_EVSEID);
+
+    //----- [BODY (6/10)] MeterInfo -----
+    res->MeterInfo_isUsed = 1u;
+    memset(res->MeterInfo.MeterID.characters, 0, sizeof(res->MeterInfo.MeterID.characters));
+    memset(res->MeterInfo.SigMeterReading.bytes, 0, sizeof(res->MeterInfo.SigMeterReading.bytes));
+
+    //[MeterInfo][1/5] MeterID
+    //sprintf(res->MeterInfo.MeterID , CCS_AC_METER_ID);
+
+    //[MeterInfo][2/5] SigMeterReading (optional)
+    //sprintf(res->MeterInfo.SigMeterReading , CCS_AC_SIG_METER_READING);
+
+    //[MeterInfo][3/5] MeterStatus (optional)
+    res->MeterInfo.MeterStatus = 0;
+
+    //[MeterInfo][4/5] MeterReading (optional)
+    res->MeterInfo.MeterReading = 12345;
+
+    //[MeterInfo][5/5] TMeter (optional)
+    res->MeterInfo.TMeter = 1586243587; //Unix Time Stamp format
+
+
+    //----- [BODY (7/10)] ReceiptRequired -----
+    res->ReceiptRequired_isUsed = 1u;
+    res->ReceiptRequired = FALSE;       //optional
+}
+
+/*===========================================================================
+FUNCTION: Check_EVErrorCode
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Check_EVErrorCode(int code)
+{
+	 struct ChargingInfoData *sys;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+    
+        
+    if (code != NO_ERROR)	//NO_ERROR = 0
+    {
+        //Asking CSU to Stop
+	    switch (code)
+	    {
+	        /*case dinDC_EVErrorCodeType_NO_ERROR:                           // = 0,
+	        {
+	            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(NO_ERROR)");
+	            break;
+	        }*/
+	    	case dinDC_EVErrorCodeType_FAILED_RESSTemperatureInhibit:      // = 1,
+	        {	//023737
+	        	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+		    	ShmStatusCodeData->PresentStatusCode[0][4] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][5] = 7;
+	            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_RESSTemperatureInhibit)");
+	            break;
+	        }
+	    	case dinDC_EVErrorCodeType_FAILED_EVShiftPosition:             // = 2,
+	        {//023738
+	        	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+		    	ShmStatusCodeData->PresentStatusCode[0][4] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+	            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_EVShiftPosition)");
+	            break;
+	        }
+	    	case dinDC_EVErrorCodeType_FAILED_ChargerConnectorLockFault:   // = 3,
+	        {
+	        	//023739
+	        	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+		    	ShmStatusCodeData->PresentStatusCode[0][4] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+	            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ChargerConnectorLockFault)");
+	            break;
+	        }
+	    	case dinDC_EVErrorCodeType_FAILED_EVRESSMalfunction:           // = 4,
+	        {
+	        	//023740
+	        	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+		    	ShmStatusCodeData->PresentStatusCode[0][4] = 4;
+		    	ShmStatusCodeData->PresentStatusCode[0][5] = 0;
+	            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_EVRESSMalfunction)");
+	            break;
+	        }
+	    	case dinDC_EVErrorCodeType_FAILED_ChargingCurrentdifferential: // = 5,
+	        {
+	        	//023741
+	        	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+		    	ShmStatusCodeData->PresentStatusCode[0][4] = 4;
+		    	ShmStatusCodeData->PresentStatusCode[0][5] = 1;
+	            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingCurrentdifferential)");
+	            break;
+	        }
+	    	case dinDC_EVErrorCodeType_FAILED_ChargingVoltageOutOfRange:   // = 6,
+	        {
+	        	//023742
+	        	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+		    	ShmStatusCodeData->PresentStatusCode[0][4] = 4;
+		    	ShmStatusCodeData->PresentStatusCode[0][5] = 2;
+	            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingVoltageOutOfRange)");
+	            break;
+	        }
+	    	case dinDC_EVErrorCodeType_Reserved_A:                         // = 7,
+	        {
+	        	//023983
+	        	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		    	ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		    	ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+	            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_A)");
+	            break;
+	        }
+	    	case dinDC_EVErrorCodeType_Reserved_B:                         // = 8,
+	        {
+	        	//023983
+	        	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		    	ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		    	ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+	            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_B)");
+	            break;
+	        }
+	    	case dinDC_EVErrorCodeType_Reserved_C:                         // = 9,
+	        {
+	        	//023983
+	        	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		    	ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		    	ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+	            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_C)");
+	            break;
+	        }
+	    	case dinDC_EVErrorCodeType_FAILED_ChargingSystemIncompatibility:// = 10,
+	        {
+	        	//023743
+	        	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+		    	ShmStatusCodeData->PresentStatusCode[0][4] = 4;
+		    	ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+	            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingSystemIncompatibility)");
+	            break;
+	        }
+	    	case dinDC_EVErrorCodeType_NoData:                             // = 11
+	        {
+	        	//023746
+	        	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		    	ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+		    	ShmStatusCodeData->PresentStatusCode[0][4] = 4;
+		    	ShmStatusCodeData->PresentStatusCode[0][5] = 6;
+	            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(NoData)");
+	            break;
+	        }
+	        default:
+	        {
+	        	if(sys->EvBatterySoc==100)
+			{	
+			    	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+			    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+			    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+			    	ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+			    	ShmStatusCodeData->PresentStatusCode[0][4] = 7;
+			    	ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+			 }
+			 else
+			 {	
+		        	//023983
+		        	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+			    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+			    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+			    	ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+			    	ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+			    	ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+			   }
+	            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([WARNING] Unexpected din EVErrorCode)");
+	            break;
+	        }
+	    }
+	     CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        //Update_V2G_Flow_Status(Other_Fault);
+
+        //memset(buf_log_evcomm, 0, sizeof(buf_log_evcomm));
+        sprintf(buf_log_evcomm,
+                "Stop by EV (EVErrorCode = %d (DEC))",
+                code);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    else
+    {
+    	if(Check_V2G_Flow_Status()>=49)
+    	{	
+	    	if((sys->EvBatterySoc==100)||(ShmCcsData->V2GMessage_ISO15118_2014.PowerDeliveryRequest.DC_EVPowerDeliveryParameter.ChargingComplete))
+		{	
+			    	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+			    	ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+			    	ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+			    	ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+			    	ShmStatusCodeData->PresentStatusCode[0][4] = 7;
+			    	ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+			    	 CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = FALSE;
+			    	  sprintf(buf_log_evcomm,
+		                "Check_EVErrorCode => Stop by EV (EVErrorCode = %d (023979))",
+		                code);
+		        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);	
+		 }
+		 else if(ShmStatusCodeData->PresentStatusCode[0][1] ==0)
+		 {
+		 	if(!( (ShmInternalComm->ChargingPermission == FALSE)||
+		 	    (sys->DC_EVSEStatus == EVSE_Shutdown)||
+		 	    (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)))
+		 	{	
+			 	//023983
+			 	ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+				ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+				ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+				ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+				ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+				ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+				  CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+				  sprintf(buf_log_evcomm,
+		                "Check_EVErrorCode => Stop by EV (EVErrorCode = %d (023983))",
+		                code);
+		        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);	
+			}
+		 }
+	   }
+    }	
+}
+
+/*===========================================================================
+FUNCTION: Proc_din_CurrentDemandRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_CurrentDemandRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct CurrentDemandResponse_DIN70121 *cur;
+    static struct ChargingInfoData *sys;
+    static int EVSE_max_current;
+    int tmp = 0;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    cur = &ShmCcsData->V2GMessage_DIN70121.CurrentDemandResponse;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    cur->ResponseCode = OK_DIN70121;
+
+    //EVSE Status Code
+    cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
+
+    //[HEADER] Check Req SessionID
+    if (Check_din_V2G_Rx_MSG_SessionID(&ccs_exi_doc_DIN) < 0)
+    {
+        cur->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        cur->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //Check for negative EvBatteryMaxCurrent
+    if (sys->EvBatteryMaxCurrent < 0)
+    {
+        sprintf(buf_log_evcomm,
+                "[ERROR]EvBatteryMaxCurrent is negative(%.02f) => End_Process",
+                sys->EvBatteryMaxCurrent);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+        cur->DC_EVSEStatus.EVSEStatusCode = dinresponseCodeType_FAILED_WrongChargeParameter;    //16
+        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+        errn = -1;
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_WrongChargeParameter (023775)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 5;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+    }
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+    SAVE_PhysicalValueType_DIN70121(&cur->EVSEPresentCurrent, (int) (sys->PresentChargingCurrent * 10), A_DIN70121);
+    SAVE_PhysicalValueType_DIN70121(&cur->EVSEPresentVoltage, (int) (sys->PresentChargingVoltage * 10), V_DIN70121);
+    #if TESLA_SLOW_INCREASE_CURRENT_FUNCTION == DISABLE
+    SAVE_PhysicalValueType_DIN70121(&cur->EVSEMaximumCurrentLimit, (int) (sys->AvailableChargingCurrent * 10), A_DIN70121);
+    #endif
+    SAVE_PhysicalValueType_DIN70121(&cur->EVSEMaximumPowerLimit, (int) (sys->AvailableChargingPower * 10), W_DIN70121);
+    SAVE_PhysicalValueType_DIN70121(&cur->EVSEMaximumVoltageLimit, (int) (sys->MaximumChargingVoltage * 10), V_DIN70121);
+
+
+    #if PATCH_FOR_BMW_I3_BUG_EVSEMAXIMUMVOLTAGELIMIT_599V == ENABLE
+    if (sys->EvBatteryMaxVoltage <= 500)
+    {
+        SAVE_PhysicalValueType_DIN70121(&cur->EVSEMaximumVoltageLimit, (int) (500 * 10), V_DIN70121);   //500V
+    }
+    #endif
+
+    //Limit the EVTargetCurrent should be under EVSEMaximumCurrentLimit
+    if (sys->EvBatterytargetCurrent > sys->AvailableChargingCurrent)
+    {
+        sys->EvBatterytargetCurrent = sys->AvailableChargingCurrent;
+
+        //[To-Do] Limit is achieved flag
+    }
+
+    //Isolation Status
+    if (sys->IsolationStatus == GFD_Invalid)  //0:invalid (on going)
+    {
+    	#if 0
+        cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid; //0
+        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        sprintf(buf_log_evcomm, "[Error][Proc_din_CurrentDemandRes]IsolationStatus = %d", sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        //Update_V2G_Flow_Status(Other_Fault);
+        //errn = -1;
+        #else
+        cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;  //1
+        #endif
+
+    }
+    else if (sys->IsolationStatus == GFD_Valid) //1: valid
+    {
+        cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;  //1
+    }
+    else if (sys->IsolationStatus == GFD_Warning) //2: warning
+    {
+        cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Warning; //2
+    }
+    else if (sys->IsolationStatus == GFD_Fault) //3: fault
+    {
+        cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;  //3
+        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_din_CurrentDemandRes]GFD_Fault => Emergency Shutdown");
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+    }
+    else //GFD_No_IMD or other unexpected status
+    {
+        cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;  //3
+        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        sprintf(buf_log_evcomm, "[Error][Proc_din_CurrentDemandRes]IsolationStatus = %d(undefined)", sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+    }
+
+    //For testing with Tesla Model 3
+    #if TESLA_SLOW_INCREASE_CURRENT_FUNCTION == ENABLE
+    //[CAUTION][To-Do] Decresement of Current is not implemented.
+    //SAVE_PhysicalValueType_DIN70121(&cur->EVSEMaximumCurrentLimit, 10, A_DIN70121);
+    if (sys->EvBatterytargetCurrent <= 0)
+    {
+        EVSE_max_current =  50;   //10A
+        cur->EVSEMaximumCurrentLimit.Value = 50;   //10A
+        /*
+          DEBUG_PRINTF_EVCOMM_DETAIL("1PresentChargingCurrent = %.02f, EvBatterytargetCurrent = %.02f, EVSE_max_current = %d, EVSEMaximumCurrentLimit = %d\n",
+                    sys->PresentChargingCurrent,
+                    sys->EvBatterytargetCurrent,
+                    EVSE_max_current,
+                    cur->EVSEMaximumCurrentLimit.Value
+                );
+        */
+    }
+    else //1A
+    {
+        /*
+    	  DEBUG_PRINTF_EVCOMM_DETAIL("2PresentChargingCurrent = %.02f, EvBatterytargetCurrent = %.02f, EVSE_max_current = %d, EVSEMaximumCurrentLimit = %d\n",
+                    sys->PresentChargingCurrent,
+                    sys->EvBatterytargetCurrent,
+                    EVSE_max_current,
+                    cur->EVSEMaximumCurrentLimit.Value
+                );
+        */
+        if ((abs((int)sys->PresentChargingCurrent - (int)sys->EvBatterytargetCurrent) < 3)&&(abs((int)(EVSE_max_current/10) - (int)sys->EvBatterytargetCurrent) < 3))
+        {
+            tmp = EVSE_max_current + 50; //10A
+
+            if (tmp <= (int)(sys->AvailableChargingCurrent * 10))
+            {
+             cur->EVSEMaximumCurrentLimit.Value = (int)tmp;
+                EVSE_max_current = tmp;
+            }
+            else
+            {
+                cur->EVSEMaximumCurrentLimit.Value = (int) (sys->AvailableChargingCurrent * 10);   //max is set to 40A
+                 EVSE_max_current =  (int) (sys->AvailableChargingCurrent * 10);
+            }
+        }
+    }
+    #endif
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        //Check for Alarm Code: CCS GFD trip (012235)
+        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[DIN][Error][CurrentDemandRes]CCS GFD trip => EVSE_Shutdown");
+            cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
+        }
+        else
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[DIN][Error][CurrentDemandRes]EVSE_Shutdown");
+            cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+        }
+
+        //cur->ResponseCode = FAILED_DIN70121;
+        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+        //errn = -1;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        //Check for Alarm Code: CCS GFD trip (012235)
+        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[DIN][Error][CurrentDemandRes]CCS GFD trip => EVSE_EmergencyShutdown");
+            cur->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;
+        }
+        else
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[DIN][Error][CurrentDemandRes]EVSE_EmergencyShutdown");
+            cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+        }
+
+        //cur->ResponseCode = FAILED_DIN70121;
+        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        errn = -1;
+    }
+    else if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[DIN][Error][CurrentDemandRes]Permission OFF");
+        //cur->ResponseCode = FAILED_DIN70121;
+        cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+        //errn = -1;
+    }
+    else
+    {
+        //null
+    }
+
+    //Response to CP Error
+    #if CP_PROTECTION_MECHANISM == ENABLE
+    if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
+    {
+    	 if(sys->CpState <= 1)
+    	 {	
+	        cur->ResponseCode = FAILED_DIN70121;
+	        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+	        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+	        Update_V2G_Flow_Status(Other_Fault);
+
+	        //Update_ShmStatusCode(); //[To-Do] to be implemented
+	        //CCS_SECC_CP_State_Error (023889)
+	        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+	        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+	        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+	        ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+	        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+	        ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+	        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+	
+	        sprintf(buf_log_evcomm,
+	                "[CurrentDemand]Emergency Stop by CP Error (%d, %.02f V)",
+	                sys->CpState,
+	                sys->CpVoltage);
+	        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	     }
+	     else 
+	     {
+	     	SAVE_SYS_LOG_MSG_EVCOMM("[DIN][Error][CurrentDemandRes]EVSE Normal Stop");
+	        //cur->ResponseCode = FAILED_DIN70121;
+	        cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+	        cur->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+	        //errn = -1;
+	     }	
+    }
+    #endif
+
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_din_CurrentDemandRes(&ccs_exi_doc_DIN, ShmCcsData);
+    #else
+    Sudo_Parameter_din_CurrentDemandRes();
+    #endif
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_DIN) != 0)
+    {
+        errn = -1;
+    }
+
+    //STEP 5: ============ Update Flags ===========
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_CurrentDemandRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_CurrentDemandRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct CurrentDemandResponse_ISO15118_2014 *cur;
+    static struct ChargingInfoData *sys;
+    static int EVSE_max_current;
+    int tmp = 0;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    cur = &ShmCcsData->V2GMessage_ISO15118_2014.CurrentDemandResponse;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    cur->ResponseCode = OK_ISO15118_2014;
+    //EVSE Status Code
+    cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+    //[HEADER] Check Req SessionID
+    if (Check_iso1_V2G_Rx_MSG_SessionID(&ccs_exi_doc_ISO1) < 0)
+    {
+        cur->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        cur->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //Check for negative EvBatteryMaxCurrent
+    if (sys->EvBatteryMaxCurrent < 0)
+    {
+        sprintf(buf_log_evcomm,
+                "[ERROR]EvBatteryMaxCurrent is negative(%.02f) => End_Process",
+                sys->EvBatteryMaxCurrent);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+        cur->ResponseCode = iso1responseCodeType_FAILED_WrongChargeParameter;   //16
+        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+        errn = -1;
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_WrongChargeParameter (023775)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 5;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+    }
+
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+    SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEPresentCurrent, (int) (sys->PresentChargingCurrent * 10), A_ISO15118_2014);
+    SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEPresentVoltage, (int) (sys->PresentChargingVoltage * 10), V_ISO15118_2014);
+    #if TESLA_SLOW_INCREASE_CURRENT_FUNCTION == DISABLE
+    SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEMaximumCurrentLimit, (int) (sys->AvailableChargingCurrent * 10), A_ISO15118_2014);
+    #endif
+    SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEMaximumPowerLimit, (int) (sys->AvailableChargingPower * 10), W_ISO15118_2014);
+    SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEMaximumVoltageLimit, (int) (sys->MaximumChargingVoltage * 10), V_ISO15118_2014);
+    #if PATCH_FOR_BMW_I3_BUG_EVSEMAXIMUMVOLTAGELIMIT_599V == ENABLE
+    if (sys->EvBatteryMaxVoltage <= 500)
+    {
+        SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEMaximumVoltageLimit, (int) (500 * 10), V_ISO15118_2014);   //500V
+    }
+    #endif
+
+    //Limit the EVTargetCurrent should be under EVSEMaximumCurrentLimit
+    if (sys->EvBatterytargetCurrent > sys->AvailableChargingCurrent)
+    {
+        sys->EvBatterytargetCurrent = sys->AvailableChargingCurrent;
+        //[To-Do] Limit is achieved flag
+    }
+
+    //Isolation Status
+    if (sys->IsolationStatus == GFD_Invalid) //0: invalid (on going)
+    {
+    	#if 0
+        cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid; //0
+        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        sprintf(buf_log_evcomm, "[Error][Proc_iso1_CurrentDemandRes]IsolationStatus = %d", sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+      //  Update_V2G_Flow_Status(Other_Fault);
+        //errn = -1;
+        #else
+         cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;  //1
+         #endif
+    }
+    else if (sys->IsolationStatus == GFD_Valid) //1: valid
+    {
+        cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;  //1
+    }
+    else if (sys->IsolationStatus == GFD_Warning) //2: warning
+    {
+        cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Warning; //2
+    }
+    else if (sys->IsolationStatus == GFD_Fault) //3: fault
+    {
+        cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;  //3
+        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_iso1_CurrentDemandRes]GFD_Fault => EmergencyShutdown");
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+    }
+    else
+    {
+        cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;  //3
+        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        sprintf(buf_log_evcomm, "[Error][Proc_iso1_CurrentDemandRes]IsolationStatus = %d(undefined)", sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+    }
+    //For testing with Tesla Model 3
+    #if TESLA_SLOW_INCREASE_CURRENT_FUNCTION == ENABLE
+    //[CAUTION][To-Do] Decresement of Current is not implemented.
+    //SAVE_PhysicalValueType_ISO15118_2014(&cur->EVSEMaximumCurrentLimit, 10, A_ISO15118_2014);
+    if (sys->EvBatterytargetCurrent <= 0)
+    {
+        EVSE_max_current =  50;   //10A
+        cur->EVSEMaximumCurrentLimit.Value = 50;   //10A
+        /*
+          DEBUG_PRINTF_EVCOMM_DETAIL("1PresentChargingCurrent = %.02f, EvBatterytargetCurrent = %.02f, EVSE_max_current = %d, EVSEMaximumCurrentLimit = %d\n",
+                    sys->PresentChargingCurrent,
+                    sys->EvBatterytargetCurrent,
+                    EVSE_max_current,
+                    cur->EVSEMaximumCurrentLimit.Value
+                );
+        */
+    }
+    else //1A
+    {
+        /*
+    	  DEBUG_PRINTF_EVCOMM_DETAIL("2PresentChargingCurrent = %.02f, EvBatterytargetCurrent = %.02f, EVSE_max_current = %d, EVSEMaximumCurrentLimit = %d\n",
+                    sys->PresentChargingCurrent,
+                    sys->EvBatterytargetCurrent,
+                    EVSE_max_current,
+                    cur->EVSEMaximumCurrentLimit.Value
+                );
+        */
+        if ((abs((int)sys->PresentChargingCurrent - (int)sys->EvBatterytargetCurrent) < 3)&&(abs((int)(EVSE_max_current/10) - (int)sys->EvBatterytargetCurrent) < 3))
+        {
+            tmp = EVSE_max_current + 50; //10A
+
+            if (tmp <= (int)(sys->AvailableChargingCurrent * 10))
+            {
+             cur->EVSEMaximumCurrentLimit.Value = (int)tmp;
+                EVSE_max_current = tmp;
+            }
+            else
+            {
+                cur->EVSEMaximumCurrentLimit.Value = (int) (sys->AvailableChargingCurrent * 10);   //max is set to 40A
+                 EVSE_max_current =  (int) (sys->AvailableChargingCurrent * 10);
+            }
+        }
+    }
+    #endif
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        //Check for Alarm Code: CCS GFD trip (012235)
+        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][Error][CurrentDemandRes]CCS GFD trip => EVSE_Shutdown");
+            cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
+        }
+        else
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][Error][CurrentDemandRes]EVSE_Shutdown");
+            cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+        }
+
+        //cur->ResponseCode = FAILED_ISO15118_2014;
+        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+        //errn = -1;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        //Check for Alarm Code: CCS GFD trip (012235)
+        if (ShmInternalComm->EVSEStopChargingReq.alarmcode[0] == 0 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[1] == 1 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[2] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[3] == 2 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[4] == 3 &&
+            ShmInternalComm->EVSEStopChargingReq.alarmcode[5] == 5)
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][Error][CurrentDemandRes]CCS GFD trip => EVSE_EmergencyShutdown");
+            cur->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;
+        }
+        else
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][Error][CurrentDemandRes]EVSE_EmergencyShutdown");
+            cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+        }
+
+        //cur->ResponseCode = FAILED_ISO15118_2014;
+        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        errn = -1;
+    }
+    else if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][Error][CurrentDemandRes]Permission OFF");
+        //cur->ResponseCode = FAILED_ISO15118_2014;
+        cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+        //errn = -1;
+    }
+    else
+    {
+        //null
+    }
+
+    //Response to CP Error
+    #if CP_PROTECTION_MECHANISM == ENABLE
+    if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
+    {
+    	 if(sys->CpState <= 1)
+    	 {	
+	        cur->ResponseCode = FAILED_ISO15118_2014;
+	        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+	        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+	        Update_V2G_Flow_Status(Other_Fault);
+
+	        //Update_ShmStatusCode(); //[To-Do] to be implemented
+	        //CCS_SECC_CP_State_Error (023889)
+	        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+	        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+	        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+	        ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+	        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+	        ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+	        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+
+	        sprintf(buf_log_evcomm,
+	                "[CurrentDemand]Emergency Stop by CP Error (%d, %.02f V)",
+	                sys->CpState,
+	                sys->CpVoltage);
+	        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+	  }
+	  else
+	  {
+	  	    SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][Error][CurrentDemandRes]EVSE Normal Stop");
+	        //cur->ResponseCode = FAILED_ISO15118_2014;
+	        cur->DC_EVSEStatus.EVSEIsolationStatus = (unsigned char)sys->IsolationStatus;
+	        cur->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Shutdown;
+	  }	
+    }
+    #endif
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_iso1_CurrentDemandRes(&ccs_exi_doc_ISO1, ShmCcsData);
+    #else
+    Sudo_Parameter_iso1_CurrentDemandRes();
+    #endif
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        errn = -1;
+    }
+
+    //STEP 5: ============ Update Flags ===========
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_ChargingStatusRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_ChargingStatusRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct ChargingStatusResponse_ISO15118_2014 *res;
+    static struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    res = &ShmCcsData->V2GMessage_ISO15118_2014.ChargingStatusResponse;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    //Init
+    res->ResponseCode = OK_ISO15118_2014;
+    res->ReceiptRequired = FALSE;       //optional
+    res->SAScheduleTupleID = 1;
+    res->AC_EVSEStatus.RCD = FALSE;     //FALSE(no error), TRUE(error is detected)
+    res->AC_EVSEStatus.NotificationMaxDelay = 0;
+    res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
+    //	iso1EVSENotificationType_None = 0,
+    //	iso1EVSENotificationType_StopCharging = 1,
+    //	iso1EVSENotificationType_ReNegotiation = 2
+
+    //[HEADER] Check Req SessionID
+    if (Check_iso1_V2G_Rx_MSG_SessionID(&ccs_exi_doc_ISO1) < 0)
+    {
+        res->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        res->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //EVSE ID
+    memset(res->EVSEID, 0, sizeof(res->EVSEID));
+    res->EVSEID[0]='Z';
+	res->EVSEID[1]='Z';
+	res->EVSEID[2]='0';
+	res->EVSEID[3]='0';
+	res->EVSEID[4]='0';
+	res->EVSEID[5]='0';
+	res->EVSEID[6]='0';
+ 
+    //sprintf(res->EVSEID, CCS_AC_EVSEID);
+
+    //[MeterInfo][0/5] init
+    //memset(res->MeterInfo.MeterID.characters, 0, sizeof(res->MeterInfo.MeterID.characters));
+    //memset(res->MeterInfo.SigMeterReading.bytes, 0, sizeof(res->MeterInfo.SigMeterReading.bytes));
+
+    //[MeterInfo][1/5] MeterID
+    strcpy(res->MeterInfo.MeterID , ShmSysConfigAndInfo->SysConfig.SerialNumber);
+	
+    //[MeterInfo][2/5] SigMeterReading (optional)
+    //sprintf(res->MeterInfo.SigMeterReading , CCS_AC_SIG_METER_READING);
+
+
+    //[MeterInfo][3/5] MeterStatus (optional)
+    res->MeterInfo.MeterStatus = 1;
+
+    //[MeterInfo][4/5] MeterReading (optional)
+    res->MeterInfo.MeterReading = ShmInternalComm->AC_MeterReadingValue;//Wh
+    //[MeterInfo][5/5] TMeter (optional)
+    res->MeterInfo.TMeter =  time(NULL); //Unix Time Stamp format
+
+
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+    SAVE_PhysicalValueType_ISO15118_2014(&res->EVSEMaxCurrent, (int)(sys->AvailableChargingCurrent * 10), A_ISO15118_2014);
+
+    //Isolation Status (RCD)
+    if (ShmInternalComm->AC_RcdStatus == 1)  //RCD tripped,Isolation is invalid
+    {
+        res->AC_EVSEStatus.RCD = TRUE;     //FALSE(no error), TRUE(error is detected)
+        res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        sprintf(buf_log_evcomm, "[ISO1][Error][ChargingStatusRes]IsolationStatus = %d", sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+    }
+
+    if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        //res->ResponseCode = FAILED_ISO15118_2014;
+        res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
+        sprintf(buf_log_evcomm, "[ISO1][ChargingStatusRes]ChargingPermission = FALSE");
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        //errn = -1;
+    }
+
+    //Response to CP Error
+    //#if CP_PROTECTION_MECHANISM == ENABLE
+    #if 1
+   // if ((sys->CpState != 4) && (sys->CpState != 5))  //State C (6V), D (3V)
+    if ((sys->CpState < 3) || (sys->CpState > 5))  //State C (6V), D (3V)
+    {
+        res->ResponseCode = FAILED_ISO15118_2014;
+        res->AC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        Update_V2G_Flow_Status(Other_Fault);
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_CP_State_Error (023889)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 9;
+        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+
+        sprintf(buf_log_evcomm,
+                "[ChargingStatus]Emergency Stop by CP Error (%d, %.02f V)",
+                sys->CpState,
+                sys->CpVoltage);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    #endif
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_iso1_ChargingStatusRes(&ccs_exi_doc_ISO1, ShmCcsData);
+    #else
+    Sudo_Parameter_iso1_ChargingStatusRes();
+    #endif
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        errn = -1;
+    }
+
+    //STEP 5: ============ Update Flags ===========
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_din_CurrentDemandReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_CurrentDemandReq(int AcceptFd)
+{
+    int errn = 0;
+    //SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_CurrentDemandReq] Got CurrentDemandReq\n");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_DIN_CurrentDemandReq(&ccs_exi_doc_DIN);
+
+    //Save into Share Memory
+    SHM_Save_din_CurrentDemandReq(ShmCcsData, &ccs_exi_doc_DIN, ShmSysConfigAndInfo);
+
+    //Check for EV Error Code
+    Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.CurrentDemandRequest.DC_EVStatus.EVErrorCode);
+
+    errn = Proc_din_CurrentDemandRes(AcceptFd);
+    if (errn == 0)
+    {
+        //Response is sent successfully.
+        //SAVE_SYS_LOG_MSG_EVCOMM("[DIN][V2G][Tx]CurrentDemandRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[DIN][Error][CurrentDemandReq]CurrentDemandRes: fail(%d,DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_CurrentDemandReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_CurrentDemandReq(int AcceptFd)
+{
+    int errn = 0;
+    //SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_CurrentDemandReq] Got CurrentDemandReq\n");
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO1_CurrentDemandReq(&ccs_exi_doc_ISO1);
+
+    //Save into Share Memory
+    SHM_Save_iso1_CurrentDemandReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+    //Check for EV Error Code
+    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.CurrentDemandRequest.DC_EVStatus.EVErrorCode);
+    errn = Proc_iso1_CurrentDemandRes(AcceptFd);
+    if (errn == 0)
+    {
+        //Response is sent successfully.
+        //SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][V2G][Tx]CurrentDemandRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[ISO1][Error][CurrentDemandReq]CurrentDemandRes: fail(%d,DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_ChargingStatusReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_ChargingStatusReq(int AcceptFd)
+{
+    int errn = 0;
+    //SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_ChargingStatusReq] Got ChargingStatusReq\n");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO1_ChargingStatusReq(&ccs_exi_doc_ISO1);
+
+    //Save into Share Memory
+    SHM_Save_iso1_ChargingStatusReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+    //Check for EV Error Code
+    //no content in ISO1
+
+    errn = Proc_iso1_ChargingStatusRes(AcceptFd);
+    if (errn == 0)
+    {
+        //Response is sent successfully.
+        //SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][V2G][Tx]ChargingStatusRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[ISO1][Error][ChargingStatusReq]ChargingStatusRes: fail(%d,DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_din_PowerDeliveryStopRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_PowerDeliveryStopRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    struct dinPowerDeliveryResType *res;
+    struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    res = &ccs_exi_doc_DIN.V2G_Message.Body.PowerDeliveryRes;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    res->ResponseCode = OK_DIN70121;
+
+    //[HEADER] Check Req SessionID
+    if (Check_din_V2G_Rx_MSG_SessionID(&ccs_exi_doc_DIN) < 0)
+    {
+        res->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        res->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    ShmCcsData->V2GMessage_DIN70121.PowerDeliveryResponse.DC_EVSEStatus.EVSEStatusCode = EVSE_NotReady;
+    SHM_Read_din_PowerDeliveryRes(&ccs_exi_doc_DIN, ShmCcsData);
+    #else
+    Sudo_Parameter_din_PreChargeRes();
+    #endif
+
+    //EVSE Status Code
+    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        //res->ResponseCode = FAILED_DIN70121;
+        res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        //res->ResponseCode = FAILED_DIN70121;
+        res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+          errn = -1;
+    }
+    else if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        //res->ResponseCode = FAILED_DIN70121;
+        res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+    }
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_DIN) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_PowerDeliveryStopRes][Error]Tx encoded msg error");
+        errn = -1;
+    }
+
+    //STEP 5: ============ Update Flags ===========
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_PowerDeliveryStopRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_PowerDeliveryStopRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    struct iso1PowerDeliveryResType *res;
+    struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    res = &ccs_exi_doc_ISO1.V2G_Message.Body.PowerDeliveryRes;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    res->ResponseCode = OK_ISO15118_2014;
+
+    //[HEADER] Check Req SessionID
+    if (Check_iso1_V2G_Rx_MSG_SessionID(&ccs_exi_doc_ISO1) < 0)
+    {
+        res->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+	
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        res->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    if(ShmCcsData->V2GMessage_ISO15118_2014.PowerDeliveryRequest.ChargeProgress==iso1chargeProgressType_Stop)
+    	ShmCcsData->V2GMessage_ISO15118_2014.PowerDeliveryResponse.DC_EVSEStatus.DC_EVSEStatusCode = EVSE_NotReady;
+    SHM_Read_iso1_PowerDeliveryRes(&ccs_exi_doc_ISO1, ShmCcsData);
+    #else
+    Sudo_Parameter_iso1_PreChargeRes();
+    #endif
+
+    //EVSE Status Code
+    res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+    res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;  //1 /*+++ 20200808, vern, Isolation Status should be valid during 2nd PowerDelivert ---*/
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        //res->ResponseCode = FAILED_ISO15118_2014;
+        res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready; /*+++ 20200808, vern, Isolation Status should be valid during 2nd PowerDelivert ---*/
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        //res->ResponseCode = FAILED_ISO15118_2014;
+        res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+          errn = -1;
+    }
+    else if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        //res->ResponseCode = FAILED_ISO15118_2014;
+        res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready; /*+++ 20200808, vern, Isolation Status should be valid during 2nd PowerDelivert ---*/
+    }
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_PowerDeliveryStopRes][Error]Tx encoded msg error");
+        errn = -1;
+    }
+
+    //STEP 5: ============ Update Flags ===========
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_din_PowerDeliveryStopReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_PowerDeliveryStopReq(int AcceptFd)
+{
+    int errn = 0;
+      struct ChargingInfoData *sys;
+    //Request CSU to STOP
+    //This should be reponsed as soon as possible once this message is received.
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+  
+    EVCOMM_SYS_INFO.EvBatterytargetVoltage = 0;
+    EVCOMM_SYS_INFO.EvBatterytargetCurrent = 0;
+
+    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]PowerDeliveryReq (2nd)\n");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_DIN_PowerDeliveryReq(&ccs_exi_doc_DIN);
+
+    //Save into Share Memory
+    SHM_Save_din_PowerDeliveryReq(ShmCcsData, &ccs_exi_doc_DIN, ShmSysConfigAndInfo);
+
+    //Check for EV Error Code
+    Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.PowerDeliveryRequest.DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode);
+    
+    CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+    //[To-Do] Sending response after the EVSE output voltage decreases to under 60V
+    usleep(1500000);    //1.5 seconds
+    //sleep(1);   //1 second
+
+    errn = Proc_din_PowerDeliveryStopRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        SAVE_SYS_LOG_MSG_EVCOMM("[DIN][V2G][Tx]PowerDeliveryRes (2nd)\n");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_din_PowerDeliveryStopReq]Proc_iso1_PowerDeliveryStopRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_PowerDeliveryStopReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_PowerDeliveryStopReq(int AcceptFd)
+{
+	 int errn = 0;
+      struct ChargingInfoData *sys;
+    //Request CSU to STOP
+    //This should be reponsed as soon as possible once this message is received.
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO1_PowerDeliveryReq(&ccs_exi_doc_ISO1);
+
+    //Save into Share Memory
+    SHM_Save_iso1_PowerDeliveryReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+	if(ShmCcsData->V2GMessage_ISO15118_2014.PowerDeliveryRequest.ChargeProgress==iso1chargeProgressType_Stop)
+	{
+		 //CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+    	EVCOMM_SYS_INFO.EvBatterytargetVoltage = 0;
+    	EVCOMM_SYS_INFO.EvBatterytargetCurrent = 0;
+		CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+    	SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]PowerDeliveryReq (2nd-Stop)\n");
+    	//[To-Do] Sending response after the EVSE output voltage decreases to under 60V
+    	usleep(1500000);    //1.5 seconds
+    	//sleep(1);   //1 second
+	}	
+	else
+		SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]PowerDeliveryReq (2nd-Renegotiation)\n");
+    //Check for EV Error Code
+    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.PowerDeliveryRequest.DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode);
+	
+    errn = Proc_iso1_PowerDeliveryStopRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][V2G][Tx]PowerDeliveryRes (2nd-stop)");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_iso1_PowerDeliveryStopReq]Proc_iso1_PowerDeliveryStopRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Init_din_WeldingDetectionRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+    1. shm_ccs
+
+OUTPUT:
+    1. shm_ccs
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Init_din_WeldingDetectionRes(struct CcsData *shm_ccs)
+{
+	struct WeldingDetectionResponse_DIN70121 *in;
+
+	in = &shm_ccs->V2GMessage_DIN70121.WeldingDetectionResponse;
+
+
+	//----- [BODY (1/3)] ResponseCode -----
+    in->ResponseCode = dinresponseCodeType_OK;
+
+    //----- [BODY (2/3)] EVSEPresentVoltage -----
+    short value = 0; int multiplier = 0; unsigned char unit = 0;
+
+    //value = 3820; multiplier = -1; unit = V_DIN70121;    //382V, for test only.
+    value = 0; multiplier = 0; unit = V_DIN70121;
+	SHM_Save_dinPhysicalValueType(&in->EVSEPresentVoltage, value, multiplier, unit);
+
+    //----- [BODY (3/3)] DC_EVSEStatus -----
+    SHM_Init_dinDC_EVSEStatusType(&in->DC_EVSEStatus);
+}
+
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_din_WeldingDetectionRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_din_WeldingDetectionRes()
+{
+    init_dinBodyType(&ccs_exi_doc_DIN.V2G_Message.Body);
+    init_dinWeldingDetectionResType(&ccs_exi_doc_DIN.V2G_Message.Body.WeldingDetectionRes);
+
+    ccs_exi_doc_DIN.V2G_Message.Body.WeldingDetectionRes_isUsed = 1u;
+
+    //----- [BODY (1/3)] ResponseCode -----
+    struct dinWeldingDetectionResType *res;
+    res = &ccs_exi_doc_DIN.V2G_Message.Body.WeldingDetectionRes;
+    res->ResponseCode = dinresponseCodeType_OK;
+
+
+    //----- [BODY (2/3)] EVSEPresentVoltage -----
+    res->EVSEPresentVoltage.Value = 3820;
+    res->EVSEPresentVoltage.Multiplier = -1;
+    res->EVSEPresentVoltage.Unit_isUsed = 1u;
+    res->EVSEPresentVoltage.Unit = dinunitSymbolType_V;
+    //	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 -----
+    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+    res->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;
+    //	dinisolationLevelType_Invalid = 0,
+    //	dinisolationLevelType_Valid = 1,
+    //	dinisolationLevelType_Warning = 2,
+    //	dinisolationLevelType_Fault = 3
+
+    res->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
+    // dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
+    // dinDC_EVSEStatusCodeType_EVSE_Ready = 1,
+    // 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
+
+    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
+
+    res->DC_EVSEStatus.EVSENotification = dinEVSENotificationType_None;
+    // dinEVSENotificationType_None = 0,
+    // dinEVSENotificationType_StopCharging = 1,
+    // dinEVSENotificationType_ReNegotiation = 2
+}
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_iso1_WeldingDetectionRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_iso1_WeldingDetectionRes()
+{
+    init_iso1BodyType(&ccs_exi_doc_ISO1.V2G_Message.Body);
+    init_iso1WeldingDetectionResType(&ccs_exi_doc_ISO1.V2G_Message.Body.WeldingDetectionRes);
+
+    ccs_exi_doc_ISO1.V2G_Message.Body.WeldingDetectionRes_isUsed = 1u;
+
+    //----- [BODY (1/3)] ResponseCode -----
+    struct iso1WeldingDetectionResType *res;
+    res = &ccs_exi_doc_ISO1.V2G_Message.Body.WeldingDetectionRes;
+    res->ResponseCode = iso1responseCodeType_OK;
+
+
+    //----- [BODY (2/3)] EVSEPresentVoltage -----
+    res->EVSEPresentVoltage.Value = 3820;
+    res->EVSEPresentVoltage.Multiplier = -1;
+    //res->EVSEPresentVoltage.Unit_isUsed = 1u;
+    res->EVSEPresentVoltage.Unit = iso1unitSymbolType_V;
+    //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 -----
+    res->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+    res->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;
+    //iso1isolationLevelType_Invalid = 0,
+	//iso1isolationLevelType_Valid = 1,
+	//iso1isolationLevelType_Warning = 2,
+	//iso1isolationLevelType_Fault = 3,
+	//iso1isolationLevelType_No_IMD = 4
+
+    res->DC_EVSEStatus.EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+    //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
+
+    res->DC_EVSEStatus.NotificationMaxDelay = 0u;
+
+    res->DC_EVSEStatus.EVSENotification = iso1EVSENotificationType_None;
+    //iso1EVSENotificationType_None = 0,
+	//iso1EVSENotificationType_StopCharging = 1,
+	//iso1EVSENotificationType_ReNegotiation = 2
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_WeldingDetectionRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_WeldingDetectionRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct WeldingDetectionResponse_DIN70121 *wel;
+    static struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    wel = &ShmCcsData->V2GMessage_DIN70121.WeldingDetectionResponse;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    wel->ResponseCode = OK_DIN70121;
+
+    //[HEADER] Check Req SessionID
+    if (Check_din_V2G_Rx_MSG_SessionID(&ccs_exi_doc_DIN) < 0)
+    {
+        wel->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        wel->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+    SAVE_PhysicalValueType_DIN70121(&wel->EVSEPresentVoltage, (int) (sys->PresentChargingVoltage * 10), V_DIN70121);
+
+    //EVSE Status Code
+    wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Ready;
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        //wel->ResponseCode = FAILED_DIN70121;
+        wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        //wel->ResponseCode = FAILED_DIN70121;
+        wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        errn = -1;
+    }
+    else if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        //wel->ResponseCode = FAILED_DIN70121;
+        wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_Shutdown;
+    }
+
+    //Isolation Status
+    if (sys->IsolationStatus == GFD_Invalid)  //0:invalid (on going)
+    {
+       // wel->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Invalid; //0
+          wel->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;  //1
+        //wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        sprintf(buf_log_evcomm, "[Error][Proc_din_WeldingDetectionRes]IsolationStatus = %d", sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        //Update_V2G_Flow_Status(Other_Fault);
+       // errn = -1;
+
+    }
+    else if (sys->IsolationStatus == GFD_Valid) //1: valid
+    {
+        wel->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Valid;  //1
+    }
+    else if (sys->IsolationStatus == GFD_Warning) //2: warning
+    {
+        wel->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Warning; //2
+    }
+    else if (sys->IsolationStatus == GFD_Fault) //3: fault
+    {
+        wel->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;  //3
+        wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_din_WeldingDetectionRes]GFD_Fault => Emergency Shutdown");
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+    }
+    else //GFD_No_IMD or other unexpected status
+    {
+        wel->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Fault;  //3
+        wel->DC_EVSEStatus.EVSEStatusCode = dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        sprintf(buf_log_evcomm, "[Error][Proc_din_WeldingDetectionRes]IsolationStatus = %d(undefined)", sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+    }
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_din_WeldingDetectionRes(&ccs_exi_doc_DIN, ShmCcsData);
+    #else
+    Sudo_Parameter_din_WeldingDetectionRes();
+    #endif
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_DIN) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_WeldingDetectionRes][Error]Tx encoded msg error");
+        errn = -1;
+    }
+
+    //STEP 5: ============ Update Flags ===========
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_WeldingDetectionRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_WeldingDetectionRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    static struct WeldingDetectionResponse_ISO15118_2014 *wel;
+    static struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    wel = &ShmCcsData->V2GMessage_ISO15118_2014.WeldingDetectionResponse;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    wel->ResponseCode = OK_ISO15118_2014;
+
+    //[HEADER] Check Req SessionID
+    if (Check_iso1_V2G_Rx_MSG_SessionID(&ccs_exi_doc_ISO1) < 0)
+    {
+        wel->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        wel->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+    SAVE_PhysicalValueType_ISO15118_2014(&wel->EVSEPresentVoltage, (int) (sys->PresentChargingVoltage * 10), V_ISO15118_2014);
+
+    //EVSE Status Code
+    wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+
+    //Check for CSU command of "Stop by EVSE"
+    if (sys->DC_EVSEStatus == EVSE_Shutdown)
+    {
+        //wel->ResponseCode = FAILED_ISO15118_2014;
+        wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+    }
+    else if (sys->DC_EVSEStatus == EVSE_EmergencyShutdown)
+    {
+        //wel->ResponseCode = FAILED_ISO15118_2014;
+        wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+          errn = -1;
+    }
+    else if (ShmInternalComm->ChargingPermission == FALSE)
+    {
+        //wel->ResponseCode = FAILED_ISO15118_2014;
+        wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_Ready;
+    }
+
+    //Isolation Status
+    if (sys->IsolationStatus == GFD_Invalid) //0: invalid (on going)
+    {
+        //wel->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Invalid; //0
+         wel->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;  //1
+       // wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        sprintf(buf_log_evcomm, "[Error][Proc_iso1_WeldingDetectionRes]IsolationStatus = %d", sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+      // Update_V2G_Flow_Status(Other_Fault);
+       // errn = -1;
+    }
+    else if (sys->IsolationStatus == GFD_Valid) //1: valid
+    {
+        wel->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Valid;  //1
+    }
+    else if (sys->IsolationStatus == GFD_Warning) //2: warning
+    {
+        wel->DC_EVSEStatus.EVSEIsolationStatus = dinisolationLevelType_Warning; //2
+    }
+    else if (sys->IsolationStatus == GFD_Fault) //3: fault
+    {
+        wel->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;  //3
+        wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        SAVE_SYS_LOG_MSG_EVCOMM("[Error][Proc_iso1_WeldingDetectionRes]GFD_Fault => EmergencyShutdown");
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+    }
+    else
+    {
+        wel->DC_EVSEStatus.EVSEIsolationStatus = iso1isolationLevelType_Fault;  //3
+        wel->DC_EVSEStatus.DC_EVSEStatusCode = iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown;
+        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+        sprintf(buf_log_evcomm, "[Error][Proc_iso1_WeldingDetectionRes]IsolationStatus = %d(undefined)", sys->IsolationStatus);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+    }
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_iso1_WeldingDetectionRes(&ccs_exi_doc_ISO1, ShmCcsData);
+    #else
+    Sudo_Parameter_iso1_WeldingDetectionRes();
+    #endif
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_WeldingDetectionRes][Error]Tx encoded msg error");
+        errn = -1;
+    }
+
+    //STEP 5: ============ Update Flags ===========
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_WeldingDetectionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_WeldingDetectionReq(int AcceptFd)
+{
+    int errn = 0;
+    //SAVE_SYS_LOG_MSG_EVCOMM("[Proc_din_WeldingDetectionReq] Got WeldingDetectionReq\n");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_DIN_WeldingDetectionReq(&ccs_exi_doc_DIN);
+
+    //Save into Share Memory
+    SHM_Save_din_WeldingDetectionReq(ShmCcsData, &ccs_exi_doc_DIN, ShmSysConfigAndInfo);
+
+    //Check for EV Error Code
+    Check_EVErrorCode(ShmCcsData->V2GMessage_DIN70121.WeldingDetectionRequest.DC_EVStatus.EVErrorCode);
+
+    errn = Proc_din_WeldingDetectionRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        //SAVE_SYS_LOG_MSG_EVCOMM("[DIN][V2G][Tx]WeldingDetectionRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_din_WeldingDetectionReq]Proc_din_WeldingDetectionRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_WeldingDetectionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_WeldingDetectionReq(int AcceptFd)
+{
+    int errn = 0;
+    //SAVE_SYS_LOG_MSG_EVCOMM("[Proc_iso1_WeldingDetectionReq] Got WeldingDetectionReq\n");
+
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO1_WeldingDetectionReq(&ccs_exi_doc_ISO1);
+
+    //Save into Share Memory
+    SHM_Save_iso1_WeldingDetectionReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+    //Check for EV Error Code
+    Check_EVErrorCode(ShmCcsData->V2GMessage_ISO15118_2014.WeldingDetectionRequest.DC_EVStatus.EVErrorCode);
+
+    errn = Proc_iso1_WeldingDetectionRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+        //SAVE_SYS_LOG_MSG_EVCOMM("[ISO1][V2G][Tx]WeldingDetectionRes");
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_iso1_WeldingDetectionReq]Proc_iso1_WeldingDetectionRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Init_din_SessionStopRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+    1. shm_ccs
+
+OUTPUT:
+    1. shm_ccs
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Init_din_SessionStopRes(struct CcsData *shm_ccs)
+{
+	struct SessionStopResponse_DIN70121 *in;
+
+	in = &shm_ccs->V2GMessage_DIN70121.SessionStopResponse;
+
+	//----- [BODY (1/3)] ResponseCode -----
+    in->ResponseCode = dinresponseCodeType_OK;
+}
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_din_SessionStopRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_din_SessionStopRes()
+{
+    init_dinBodyType(&ccs_exi_doc_DIN.V2G_Message.Body);
+    init_dinSessionStopResType(&ccs_exi_doc_DIN.V2G_Message.Body.SessionStopRes);
+
+    ccs_exi_doc_DIN.V2G_Message.Body.SessionStopRes_isUsed = 1u;
+
+    //----- [BODY (1/3)] ResponseCode -----
+    struct dinSessionStopResType *res;
+    res = &ccs_exi_doc_DIN.V2G_Message.Body.SessionStopRes;
+    res->ResponseCode = dinresponseCodeType_OK;
+}
+
+/*===========================================================================
+FUNCTION: Sudo_Parameter_iso1_SessionStopRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Sudo_Parameter_iso1_SessionStopRes()
+{
+    init_iso1BodyType(&ccs_exi_doc_ISO1.V2G_Message.Body);
+    init_iso1SessionStopResType(&ccs_exi_doc_ISO1.V2G_Message.Body.SessionStopRes);
+
+    ccs_exi_doc_ISO1.V2G_Message.Body.SessionStopRes_isUsed = 1u;
+
+    //----- [BODY (1/3)] ResponseCode -----
+    struct iso1SessionStopResType *res;
+    res = &ccs_exi_doc_ISO1.V2G_Message.Body.SessionStopRes;
+    res->ResponseCode = iso1responseCodeType_OK;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_SessionStopRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_SessionStopRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    struct SessionStopResponse_DIN70121 *stp;
+    struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    stp = &ShmCcsData->V2GMessage_DIN70121.SessionStopResponse;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    stp->ResponseCode = OK_DIN70121;
+
+    //[HEADER] Check Req SessionID
+    if (Check_din_V2G_Rx_MSG_SessionID(&ccs_exi_doc_DIN) < 0)
+    {
+        stp->ResponseCode = dinresponseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        stp->ResponseCode = dinresponseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_din_SessionStopRes(&ccs_exi_doc_DIN, ShmCcsData);
+    #else
+    Sudo_Parameter_din_SessionStopRes();
+    #endif
+
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_din_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_DIN) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Tx]SessionStopRes: fail");
+        errn = -1;
+    }
+    else 
+    {
+        //send response successfully.
+        SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Tx]SessionStopRes");
+    }
+
+
+    //STEP 5: ============ Update Flags ===========
+    EVCOMM_SYS_INFO.ConnectorLocked = FALSE;   //Indicating CSU that the Connector is unlocked.
+                                               //Once this is set, the CSU should
+
+    // =========== Annouce to CSU [To-Be Implemented]=============
+    CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;    //This should be also added to EV Error events.
+
+
+    // =========== Re-initialized [To-Be Implemented]=============
+    //Keep 5% PWM for 2 seconds
+    SAVE_SYS_LOG_MSG_EVCOMM("PWM 5\% countdown: 2");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("PWM 5\% countdown: 1");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("PWM 5\% countdown: 0");
+    OutputCpPwmDuty(100);
+
+    //[To-Do] Reset All Share memory
+
+    //[To-Do] CCS Module enter "idle" mode and CSU should check for this state.
+
+    //system("reboot -f");
+    //sleep(5);
+    //system("reboot -f");
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_iso1_SessionStopRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_SessionStopRes(int AcceptFd)
+{
+    //[Joseph, To-Do] Check SessionID of ServiceDiscoveryReq,
+    //if it is not the same, the packet should be ignored.
+
+    //STEP 1: ============ Initialize ============
+    int i = 0;
+    int errn = 0;
+    bitstream_t v2g_tx_stream;
+    struct SessionStopResponse_ISO15118_2014 *stp;
+    struct ChargingInfoData *sys;
+
+    size_t pos = 0;
+    v2g_tx_stream.pos = &pos;
+    v2g_tx_stream.size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+    v2g_tx_stream.data = V2GTP_Tx_buf;
+    stp = &ShmCcsData->V2GMessage_ISO15118_2014.SessionStopResponse;
+    sys = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    stp->ResponseCode = OK_ISO15118_2014;
+
+    //[HEADER] Check Req SessionID
+    if (Check_iso1_V2G_Rx_MSG_SessionID(&ccs_exi_doc_ISO1) < 0)
+    {
+        stp->ResponseCode = iso1responseCodeType_FAILED_UnknownSession; //6
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]unmatched SessionID => End_Process");
+        errn = -1;
+    }
+
+    //Check for SequenceError
+    if (EVCOMM_SYS_INFO.SequenceError == TRUE)
+    {
+        stp->ResponseCode = iso1responseCodeType_FAILED_SequenceError; //5
+        SAVE_SYS_LOG_MSG_EVCOMM("[ERROR]SequenceError => End_Process");
+        errn = -1;
+
+        //Update_ShmStatusCode(); //[To-Do] to be implemented
+        //CCS_SECC_ResponseCode_FAILED_SequenceError (023758)
+        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+        ShmStatusCodeData->PresentStatusCode[0][3] = 7;
+        ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+        ShmStatusCodeData->PresentStatusCode[0][5] = 8;
+    }
+
+    //STEP 2: ============ Modifiy Parameter of ShmCcsData ============
+
+
+    //STEP 3: ============ Save Parameters from ShmCcsData to EXI Engine Buffer ============
+    #if PARAMETER_NORMAL_MODE == ENABLE
+    SHM_Read_iso1_SessionStopRes(&ccs_exi_doc_ISO1, ShmCcsData);
+    #else
+    Sudo_Parameter_iso1_SessionStopRes();
+    #endif
+
+
+    //STEP 4: ============ Encode and Send Response Message ===========
+    if (send_encoded_iso1_V2GTP_Stream(AcceptFd, &v2g_tx_stream, &ccs_exi_doc_ISO1) != 0)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Tx]SessionStopRes: fail");
+        errn = -1;
+    }
+    else 
+    {
+        //send response successfully.
+        SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Tx]SessionStopRes");
+    }
+
+    //STEP 5: ============ Update Flags ===========
+    EVCOMM_SYS_INFO.ConnectorLocked = FALSE;   //Indicating CSU that the Connector is unlocked.
+                                               //Once this is set, the CSU should
+
+    // =========== Annouce to CSU [To-Be Implemented]=============
+    CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;    //This should be also added to EV Error events.
+
+
+    // =========== Re-initialized [To-Be Implemented]=============
+    //Keep 5% PWM for 2 seconds
+    SAVE_SYS_LOG_MSG_EVCOMM("PWM 5\% countdown: 2");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("PWM 5\% countdown: 1");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("PWM 5\% countdown: 0");
+    OutputCpPwmDuty(100);
+
+    //[To-Do] Reset All Share memory
+
+    //[To-Do] CCS Module enter "idle" mode and CSU should check for this state.
+
+    //system("reboot -f");
+    //sleep(5);
+    //system("reboot -f");
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: Proc_din_SessionStopReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_din_SessionStopReq(int AcceptFd)
+{
+    int errn = 0;
+    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]SessionStopReq");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_DIN_SessionStopReq(&ccs_exi_doc_DIN);
+
+    //Save into Share Memory
+    SHM_Save_din_SessionStopReq(ShmCcsData, &ccs_exi_doc_DIN, ShmSysConfigAndInfo);
+
+    errn = Proc_din_SessionStopRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_din_SessionStopReq]Proc_iso1_SessionStopRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: Proc_iso1_SessionStopReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Proc_iso1_SessionStopReq(int AcceptFd)
+{
+    int errn = 0;
+    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]SessionStopReq");
+
+    //Print the decoded XML Document
+    PRINT_XML_DOC_ISO1_SessionStopReq(&ccs_exi_doc_ISO1);
+
+    //Save into Share Memory
+    SHM_Save_iso1_SessionStopReq(ShmCcsData, &ccs_exi_doc_ISO1, ShmSysConfigAndInfo);
+
+    errn = Proc_iso1_SessionStopRes(AcceptFd);
+    if (errn == 0)
+    {
+        //send response successfully.
+    }
+    else
+    {
+        sprintf(buf_log_evcomm,
+                "[Error][SeccComm][Proc_iso1_SessionStopReq]Proc_iso1_SessionStopRes(): %d (DEC)",
+                errn);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: V2gMsg_Process_din
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+        1. V2gFlowStatus
+OUTPUT:
+GLOBAL VARIABLES:
+        1. V2gFlowStatus
+=============================================================================*/
+int V2gMsg_Process_din(int AcceptFd)
+{
+    unsigned char req_is_responsed = FALSE;
+    while (req_is_responsed == FALSE)
+    {
+        //Check if it is in End_Process
+        if (EVCOMM_SYS_INFO.End_Process_inused == TRUE)
+        {
+            break;
+        }
+
+        switch(V2gFlowStatus)
+        {
+            //-------------------------------------------
+            case SupportedAppProtocolRequest:
+            {
+                if (ccs_handshake.supportedAppProtocolReq_isUsed == 1u)
+                {
+                    ccs_handshake.supportedAppProtocolReq_isUsed = 0;
+                    if (Proc_supportedAppProtocolReq(AcceptFd) == 0)   //0: no error
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                        Update_V2G_Flow_Status(SupportedAppProtocolResponse);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]supportedAppProtocolResReq: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case SupportedAppProtocolResponse:
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionSetupRequest)
+                {
+                    Update_V2G_Flow_Status(SessionSetupRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    
+                   if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case SessionSetupRequest:               //19
+            {
+                if (Proc_din_SessionSetupReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(SessionSetupResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]SessionSetupReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case SessionSetupResponse:              //20
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceDiscoveryRequest)
+                {
+                    Update_V2G_Flow_Status(ServiceDiscoveryRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                    if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case ServiceDiscoveryRequest:           //21
+            {
+                if (Proc_din_ServiceDiscoveryReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(ServiceDiscoveryResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]ServiceDiscoveryReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case ServiceDiscoveryResponse:          //22
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceAndPaymentSelectionRequest)
+                {
+                    Update_V2G_Flow_Status(ServiceAndPaymentSelectionRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                 else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                     if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case ServiceAndPaymentSelectionRequest:     //25
+            {
+                if (Proc_din_ServiceAndPaymentSelectionReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(ServiceAndPaymentSelectionResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]ServiceAndPaymentSelectionReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case ServiceAndPaymentSelectionResponse:    //26
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
+                {
+                    Update_V2G_Flow_Status(AuthorizationRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                 else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                   if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            //case ContractAuthenticationReq:
+            case AuthorizationRequest:              //29
+            {
+                if (Proc_din_ContractAuthenticationReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(AuthorizationResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]AuthorizationReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case AuthorizationResponse:             //30
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_din_ContractAuthenticationReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]AuthorizationReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //Check for ChargeParameterDiscoveryReq
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(ChargeParameterDiscoveryRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]ChargeParameterDiscoveryReq: CSU Permission?");
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                     if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case ChargeParameterDiscoveryRequest:   //35
+            {
+                if (Proc_din_ChargeParameterDiscoveryReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(ChargeParameterDiscoveryResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]ChargeParameterDiscoveryReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case ChargeParameterDiscoveryResponse:
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > V2G_SECC_ChargingParameter_Performance_Time)  //60 seconds
+                {
+                    sprintf(buf_log_evcomm,
+                            "ChargingParameter Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            V2G_SECC_ChargingParameter_Performance_Time);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+                    break;
+                }
+                #endif
+
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_din_ChargeParameterDiscoveryReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]ChargeParameterDiscoveryReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 2: Check for CableCheckReq message
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CableCheckRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]CableCheckReqReq: isolated?");
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_Start);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
+
+                    Update_V2G_Flow_Status(CableCheckRequest);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                //STEP 3: Wait for PowerDeliveryReq Message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStop);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+
+                    if (Proc_din_PowerDeliveryStopReq(AcceptFd) == 0)
+                    {
+                        Update_V2G_Flow_Status(PowerDeliveryResponseStop);
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStopReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    break;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                   if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case CableCheckRequest:                 //37
+            {
+                //STEP 3: Execute Cable Check Process
+                if (Proc_din_CableCheckReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(CableCheckResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]CableCheckReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case CableCheckResponse:                //38
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > V2G_SECC_CableCheck_Performance_Time)  //38 seconds
+                {
+                    //SAVE_SYS_LOG_MSG_EVCOMM("[CableCheck] end counting...");
+                    sprintf(buf_log_evcomm,
+                            "CableCheck Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            V2G_SECC_CableCheck_Performance_Time);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+
+                    //Update_ShmStatusCode(); //[To-Do] to be implemented
+                    //CCS_SECC_TIMEOUT_V2G_CableCheck_Performance_Time (023847)
+                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                    ShmStatusCodeData->PresentStatusCode[0][4] = 4;
+                    ShmStatusCodeData->PresentStatusCode[0][5] = 7;
+                    break;
+                }
+                #endif
+
+                //STEP 2: Check for CableCheckReq message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CableCheckRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    //STEP 3: Execute Cable Check Process
+                    if (Proc_din_CableCheckReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]CableCheckReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 3: Check for PreChargeReq message
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == PreChargeRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(PreChargeRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]PreChargeReqReq: waiting for precharge voltage...");
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Precharge_Timer_Start);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                //STEP 3: Wait for PowerDeliveryReq Message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStop);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+
+                    if (Proc_din_PowerDeliveryStopReq(AcceptFd) == 0)
+                    {
+                        Update_V2G_Flow_Status(PowerDeliveryResponseStop);
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStopReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    break;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                    if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case PreChargeRequest:                  //39
+            {
+                if (Proc_din_PreChargeReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(PreChargeResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]PreChargeReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case PreChargeResponse:                 //40
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > V2G_SECC_PreCharge_Performance_Time)  //5 seconds
+                {
+                    sprintf(buf_log_evcomm,
+                            "Precharge Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            V2G_SECC_PreCharge_Performance_Time);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+
+                    //Update_ShmStatusCode(); //[To-Do] to be implemented
+                    //CCS_SECC_TIMEOUT_V2G_PreCharge_Performace_Time (023850)
+                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                    ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+                    ShmStatusCodeData->PresentStatusCode[0][5] = 0;
+                    break;
+                }
+                #endif
+
+                //STEP 2: Check for PreChargeReq message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == PreChargeRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_din_PreChargeReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]PreChargeReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+
+                //STEP 3: Check for PowerDeliveryReq message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStart);
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Precharge_Timer_End);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                   if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case PowerDeliveryRequestStart:         //41
+            {
+                if (Proc_din_PowerDeliveryStartReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryResponsetStart);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStartReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case PowerDeliveryResponsetStart:        //42
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                if (ccs_exi_doc_DIN.V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
+                {
+                    ftime(&SeqEndTime);
+                    if(DiffTimeb(SeqStartTime, SeqEndTime) > 2000)  //5 seconds
+                    {
+                        sprintf(buf_log_evcomm,
+                                "Wait for CurrentDemandReq Timeout - (%.02lf of %d ms)\n",
+                                DiffTimeb(SeqStartTime, SeqEndTime),
+                                2000);
+                        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                        Update_V2G_Flow_Status(Sequence_Timeout);
+                    }
+                    break;
+                }
+                #endif
+
+                //STEP 2: Wait for CurrentDemandReq Message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CurrentDemandRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(CurrentDemandRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]CurrentDemandReqReq: energy transfering...");
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CurrentDemand_Timer_Start);
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                     if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case CurrentDemandRequest:              //45,
+            {
+                if (Proc_din_CurrentDemandReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(CurrentDemandResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]CurrentDemandReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case CurrentDemandResponse:             //46,
+            {
+                //STEP 1: Wait for CurrentDemandReq Message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CurrentDemandRequest)
+                {
+                   EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    if (Proc_din_CurrentDemandReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]CurrentDemandReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+
+                //STEP 2: Wait for PowerDeliveryReq Message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStop);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CurrentDemand_Timer_End);
+			if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		       } 
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                 else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                     if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case PowerDeliveryRequestStop:          //49,
+            {
+                if (Proc_din_PowerDeliveryStopReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryResponseStop);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStopReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case PowerDeliveryResponseStop:        //50,
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > 2000)  //2 seconds
+                {
+                    sprintf(buf_log_evcomm,
+                            "Wait for WeldingDetectionReq or SessionStopReq Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            2000);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+                    break;
+                }
+                #endif
+
+                //STEP 2: Check for WeldingDetectionReq Message
+                if(EVCOMM_SYS_INFO.V2G_Rx_Msg == WeldingDetectionRequest)
+                {
+                   EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(WeldingDetectionRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]WeldingDetectionReq: ongoing...");
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_WeldingDetection_Timer_Start);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
+                {
+                    Update_V2G_Flow_Status(SessionStopRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_din_SessionStopReq(AcceptFd) == 0)
+                    {
+                        Update_V2G_Flow_Status(SessionStopResponse);
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]SessionStopReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    break;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    
+                }
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case WeldingDetectionRequest:           //51,
+            {
+                if (Proc_din_WeldingDetectionReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(WeldingDetectionResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]WeldingDetectionReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case WeldingDetectionResponse:          //52,
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > V2G_SECC_WeldingDetection_Performance_Time)  //20 seconds
+                {
+                    sprintf(buf_log_evcomm,
+                            "Wait for SessionStopReq Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            V2G_SECC_WeldingDetection_Performance_Time);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+                    break;
+                }
+                #endif
+
+                //STEP 2: Check for WeldingDetectionReq Message
+                if(EVCOMM_SYS_INFO.V2G_Rx_Msg == WeldingDetectionRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    if (Proc_din_WeldingDetectionReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]WeldingDetectionReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 3: Check for SessionStopReq Message
+                else if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
+                {
+                    Update_V2G_Flow_Status(SessionStopRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_WeldingDetection_Timer_End);
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case SessionStopRequest:                //53,
+            {
+                if (Proc_din_SessionStopReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(SessionStopResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]SessionStopReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case SessionStopResponse:               //54,
+            {
+                break;
+            }
+            //-------------------------------------------
+            default:
+            {
+                break;
+            }
+        }
+    }
+
+}
+
+/*===========================================================================
+FUNCTION: V2gMsg_Process_iso1_DC
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+        1. V2gFlowStatus
+OUTPUT:
+GLOBAL VARIABLES:
+        1. V2gFlowStatus
+=============================================================================*/
+int V2gMsg_Process_iso1_DC(int AcceptFd)
+{
+    unsigned char req_is_responsed = FALSE;
+    while (req_is_responsed == FALSE)
+    {
+        //Check if it is in End_Process
+        if (EVCOMM_SYS_INFO.End_Process_inused == TRUE)
+        {
+            break;
+        }
+
+        switch(V2gFlowStatus)
+        {
+            //-------------------------------------------
+            case SupportedAppProtocolRequest:
+            {
+                if (ccs_handshake.supportedAppProtocolReq_isUsed == 1u)
+                {
+                    ccs_handshake.supportedAppProtocolReq_isUsed = 0;
+                    if (Proc_supportedAppProtocolReq(AcceptFd) == 0)   //0: no error
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                        Update_V2G_Flow_Status(SupportedAppProtocolResponse);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]supportedAppProtocolResReq: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case SupportedAppProtocolResponse:
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionSetupRequest)
+                {
+                    Update_V2G_Flow_Status(SessionSetupRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                 else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);	
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case SessionSetupRequest:               //19
+            {
+                if (Proc_iso1_SessionSetupReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(SessionSetupResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]SessionSetupReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case SessionSetupResponse:              //20
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceDiscoveryRequest)
+                {
+                    Update_V2G_Flow_Status(ServiceDiscoveryRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                 else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                   if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case ServiceDiscoveryRequest:           //21
+            {
+                if (Proc_iso1_ServiceDiscoveryReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(ServiceDiscoveryResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]ServiceDiscoveryReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case ServiceDiscoveryResponse:          //22
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceAndPaymentSelectionRequest)
+                {
+                    Update_V2G_Flow_Status(ServiceAndPaymentSelectionRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                    if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case ServiceAndPaymentSelectionRequest:     //25
+            {
+                if (Proc_iso1_ServiceAndPaymentSelectionReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(ServiceAndPaymentSelectionResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]ServiceAndPaymentSelectionReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case ServiceAndPaymentSelectionResponse:    //26
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
+                {
+                    Update_V2G_Flow_Status(AuthorizationRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                 else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                    if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            //case ContractAuthenticationReq:
+            case AuthorizationRequest:              //29
+            {
+                if (Proc_iso1_AuthenticationReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(AuthorizationResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]AuthorizationReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case AuthorizationResponse:             //30
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_iso1_AuthenticationReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]AuthorizationReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //Check for ChargeParameterDiscoveryReq
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(ChargeParameterDiscoveryRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]ChargeParameterDiscoveryReq: CSU Permission?");
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                    if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case ChargeParameterDiscoveryRequest:   //35
+            {
+                if (Proc_iso1_ChargeParameterDiscoveryReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(ChargeParameterDiscoveryResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]ChargeParameterDiscoveryReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case ChargeParameterDiscoveryResponse:
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > V2G_SECC_ChargingParameter_Performance_Time)  //60 seconds
+                {
+                    sprintf(buf_log_evcomm,
+                            "ChargingParameter Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            V2G_SECC_ChargingParameter_Performance_Time);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+                    break;
+                }
+                #endif
+
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_iso1_ChargeParameterDiscoveryReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]ChargeParameterDiscoveryReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 2: Check for CableCheckReq message
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CableCheckRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]CableCheckReqReq: isolated?");
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_Start);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
+
+                    Update_V2G_Flow_Status(CableCheckRequest);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                //STEP 3: Wait for PowerDeliveryReq Message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStop);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+
+                    if (Proc_iso1_PowerDeliveryStopReq(AcceptFd) == 0)
+                    {
+                        Update_V2G_Flow_Status(PowerDeliveryResponseStop);
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStopReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    break;
+                }
+               else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                     if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case CableCheckRequest:                 //37
+            {
+                //STEP 3: Execute Cable Check Process
+                if (Proc_iso1_CableCheckReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(CableCheckResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]CableCheckReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case CableCheckResponse:                //38
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > V2G_SECC_CableCheck_Performance_Time)  //38 seconds
+                {
+                    //SAVE_SYS_LOG_MSG_EVCOMM("[CableCheck] end counting...");
+                    sprintf(buf_log_evcomm,
+                            "CableCheck Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            V2G_SECC_CableCheck_Performance_Time);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+
+                    //Update_ShmStatusCode(); //[To-Do] to be implemented
+                    //CCS_SECC_TIMEOUT_V2G_CableCheck_Performance_Time (023847)
+                   if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		       } 
+                    break;
+                }
+                #endif
+
+                //STEP 2: Check for CableCheckReq message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CableCheckRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    //STEP 3: Execute Cable Check Process
+                    if (Proc_iso1_CableCheckReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]CableCheckReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 3: Check for PreChargeReq message
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == PreChargeRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(PreChargeRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]PreChargeReqReq: waiting for precharge voltage...");
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Precharge_Timer_Start);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                //STEP 3: Wait for PowerDeliveryReq Message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStop);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+
+                    if (Proc_iso1_PowerDeliveryStopReq(AcceptFd) == 0)
+                    {
+                        Update_V2G_Flow_Status(PowerDeliveryResponseStop);
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStopReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    break;
+                }
+                 else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                     if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case PreChargeRequest:                  //39
+            {
+                if (Proc_iso1_PreChargeReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(PreChargeResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]PreChargeReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case PreChargeResponse:                 //40
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > V2G_SECC_PreCharge_Performance_Time)  //5 seconds
+                {
+                    sprintf(buf_log_evcomm,
+                            "Precharge Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            V2G_SECC_PreCharge_Performance_Time);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+
+                    //Update_ShmStatusCode(); //[To-Do] to be implemented
+                    //CCS_SECC_TIMEOUT_V2G_PreCharge_Performace_Time (023850)
+                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                    ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+                    ShmStatusCodeData->PresentStatusCode[0][5] = 0;
+                    break;
+                }
+                #endif
+
+                //STEP 2: Check for PreChargeReq message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == PreChargeRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_iso1_PreChargeReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]PreChargeReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 3: Check for PowerDeliveryReq message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStart);
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Precharge_Timer_End);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+               else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                   if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case PowerDeliveryRequestStart:         //41
+            {
+                if (Proc_iso1_PowerDeliveryStartReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryResponsetStart);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStartReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case PowerDeliveryResponsetStart:        //42
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                if (ccs_exi_doc_ISO1.V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
+                {
+                    ftime(&SeqEndTime);
+                    if(DiffTimeb(SeqStartTime, SeqEndTime) > 2000)  //5 seconds
+                    {
+                        sprintf(buf_log_evcomm,
+                                "Wait for CurrentDemandReq Timeout - (%.02lf of %d ms)\n",
+                                DiffTimeb(SeqStartTime, SeqEndTime),
+                                2000);
+                        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                        Update_V2G_Flow_Status(Sequence_Timeout);
+                    }
+                    break;
+                }
+                #endif
+
+                //STEP 2: Wait for CurrentDemandReq Message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CurrentDemandRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(CurrentDemandRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]CurrentDemandReqReq: energy transfering...");
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CurrentDemand_Timer_Start);
+                }
+               else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                     
+                     if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+	                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+					        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+					        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+					        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+					        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+					        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+					        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+					        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+				       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case CurrentDemandRequest:              //45,
+            {
+                if (Proc_iso1_CurrentDemandReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(CurrentDemandResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]CurrentDemandReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case CurrentDemandResponse:             //46,
+            {
+                //STEP 1: Wait for CurrentDemandReq Message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CurrentDemandRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    if (Proc_iso1_CurrentDemandReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]CurrentDemandReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 2: Wait for PowerDeliveryReq Message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStop);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CurrentDemand_Timer_End);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                    
+                    if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+				        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+				        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+				        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+				        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+				        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+				        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+				        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		       		} 
+                }
+               else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                  if((EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_Shutdown) && (EVCOMM_SYS_INFO.DC_EVSEStatus != EVSE_EmergencyShutdown))
+                     {	
+                        ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+		        ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+		        ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+		        ShmStatusCodeData->PresentStatusCode[0][3] = 9;
+		        ShmStatusCodeData->PresentStatusCode[0][4] = 8;
+		        ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+		        CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+		        CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+		       } 
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case PowerDeliveryRequestStop:          //49,
+            {
+                if (Proc_iso1_PowerDeliveryStopReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryResponseStop);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStopReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case PowerDeliveryResponseStop:        //50,
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > 2000)  //2 seconds
+                {
+                    sprintf(buf_log_evcomm,
+                            "Wait for WeldingDetectionReq or SessionStopReq Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            2000);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+                    break;
+                }
+                #endif
+
+                //STEP 2: Check for WeldingDetectionReq Message
+                if(EVCOMM_SYS_INFO.V2G_Rx_Msg == WeldingDetectionRequest)
+                {
+                   EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(WeldingDetectionRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]WeldingDetectionReq: ongoing...");
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_WeldingDetection_Timer_Start);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
+                {
+                    Update_V2G_Flow_Status(SessionStopRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_iso1_SessionStopReq(AcceptFd) == 0)
+                    {
+                        Update_V2G_Flow_Status(SessionStopResponse);
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]SessionStopReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    break;
+                }
+                 else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    if(ShmCcsData->V2GMessage_ISO15118_2014.PowerDeliveryRequest.ChargeProgress==iso1chargeProgressType_Stop)
+                    	EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case WeldingDetectionRequest:           //51,
+            {
+                if (Proc_iso1_WeldingDetectionReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(WeldingDetectionResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]WeldingDetectionReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case WeldingDetectionResponse:          //52,
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > V2G_SECC_WeldingDetection_Performance_Time)  //20 seconds
+                {
+                    sprintf(buf_log_evcomm,
+                            "Wait for SessionStopReq Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            V2G_SECC_WeldingDetection_Performance_Time);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+                    break;
+                }
+                #endif
+
+                //STEP 2: Check for WeldingDetectionReq Message
+                if(EVCOMM_SYS_INFO.V2G_Rx_Msg == WeldingDetectionRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    if (Proc_iso1_WeldingDetectionReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]WeldingDetectionReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 3: Check for SessionStopReq Message
+                else if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
+                {
+                    Update_V2G_Flow_Status(SessionStopRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_WeldingDetection_Timer_End);
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg < PowerDeliveryRequestStop)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= PowerDeliveryRequestStop &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                	 sprintf(buf_log_evcomm,
+                            "[ERROR]Receive EV Stop Message(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }         
+                else
+                {
+                    break;
+                }
+                 break;
+            }
+            //-------------------------------------------
+            case SessionStopRequest:                //53,
+            {
+                if (Proc_iso1_SessionStopReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(SessionStopResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]SessionStopReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case SessionStopResponse:               //54,
+            {
+                break;
+            }
+            //-------------------------------------------
+            default:
+            {
+                break;
+            }
+        }
+    }
+}
+
+
+/*===========================================================================
+FUNCTION: V2gMsg_Process_iso1_AC
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+        1. V2gFlowStatus
+OUTPUT:
+GLOBAL VARIABLES:
+        1. V2gFlowStatus
+=============================================================================*/
+int V2gMsg_Process_iso1_AC(int AcceptFd)
+{
+    unsigned char req_is_responsed = FALSE;
+    while (req_is_responsed == FALSE)
+    {
+        //Check if it is in End_Process
+        if (EVCOMM_SYS_INFO.End_Process_inused == TRUE)
+        {
+            break;
+        }
+
+        switch(V2gFlowStatus)
+        {
+            //-------------------------------------------
+            case SupportedAppProtocolRequest:       //17
+            {
+                if (ccs_handshake.supportedAppProtocolReq_isUsed == 1u)
+                {
+                    ccs_handshake.supportedAppProtocolReq_isUsed = 0;
+                    if (Proc_supportedAppProtocolReq(AcceptFd) == 0)   //0: no error
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                        Update_V2G_Flow_Status(SupportedAppProtocolResponse);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]supportedAppProtocolResReq: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case SupportedAppProtocolResponse:      //18
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionSetupRequest)
+                {
+                    Update_V2G_Flow_Status(SessionSetupRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case SessionSetupRequest:               //19
+            {
+                if (Proc_iso1_SessionSetupReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(SessionSetupResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]SessionSetupReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case SessionSetupResponse:              //20
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceDiscoveryRequest)
+                {
+                    Update_V2G_Flow_Status(ServiceDiscoveryRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case ServiceDiscoveryRequest:           //21
+            {
+                if (Proc_iso1_ServiceDiscoveryReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(ServiceDiscoveryResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]ServiceDiscoveryReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case ServiceDiscoveryResponse:          //22
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceAndPaymentSelectionRequest)
+                {
+                    Update_V2G_Flow_Status(ServiceAndPaymentSelectionRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case ServiceAndPaymentSelectionRequest: //25
+            {
+                if (Proc_iso1_ServiceAndPaymentSelectionReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(ServiceAndPaymentSelectionResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]ServiceAndPaymentSelectionReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case ServiceAndPaymentSelectionResponse://26
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
+                {
+                    Update_V2G_Flow_Status(AuthorizationRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            //case ContractAuthenticationReq:
+            case AuthorizationRequest:              //29
+            {
+                if (Proc_iso1_AuthenticationReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(AuthorizationResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]AuthorizationReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                 req_is_responsed = TRUE;
+                break;
+            }
+            case AuthorizationResponse:             //30
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_iso1_AuthenticationReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]AuthorizationReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //Check for ChargeParameterDiscoveryReq
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(ChargeParameterDiscoveryRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]ChargeParameterDiscoveryReq: CSU Permission?");
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case ChargeParameterDiscoveryRequest:   //35
+            {
+                if (Proc_iso1_ChargeParameterDiscoveryReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(ChargeParameterDiscoveryResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]ChargeParameterDiscoveryReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case ChargeParameterDiscoveryResponse:  //36
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+    	        ftime(&SeqEndTime);
+    	        if(DiffTimeb(SeqStartTime, SeqEndTime) > V2G_SECC_ChargingParameter_Performance_Time)  //60 seconds
+    	        {
+    	            sprintf(buf_log_evcomm,
+                            "ChargingParameter Timeout - (%.02lf of %d ms)\n",
+    	                    DiffTimeb(SeqStartTime, SeqEndTime),
+    	                    V2G_SECC_ChargingParameter_Performance_Time);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    	            Update_V2G_Flow_Status(Sequence_Timeout);
+                    break;
+    	        }
+                #endif
+
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_iso1_ChargeParameterDiscoveryReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]ChargeParameterDiscoveryReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+
+                //STEP 3: Wait for PowerDeliveryReq Message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {            	
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStart);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                    break;
+                }
+    	    else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case PowerDeliveryRequestStart:         //41
+            {
+                if (Proc_iso1_PowerDeliveryStartReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryResponsetStart);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStartReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case PowerDeliveryResponsetStart:       //42
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                if (ccs_exi_doc_ISO1.V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
+                {
+                    ftime(&SeqEndTime);
+                    if(DiffTimeb(SeqStartTime, SeqEndTime) > 2000)  //5 seconds
+                    {
+                        sprintf(buf_log_evcomm,
+                                "Wait for ChargingStatusReq Timeout - (%.02lf of %d ms)\n",
+                                DiffTimeb(SeqStartTime, SeqEndTime),
+                                2000);
+                        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                        Update_V2G_Flow_Status(Sequence_Timeout);
+                    }
+                    break;
+                }
+                #endif
+
+                //STEP 2: Wait for ChargingStatusReq Message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargingStatusRequest)
+                {
+    	            EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(ChargingStatusRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]ChargingStatusReq: energy transfering...");
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargingStatus_Timer_Start);
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case ChargingStatusRequest:             //43
+            {
+                if (Proc_iso1_ChargingStatusReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(ChargingStatusResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]ChargingStatusRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case ChargingStatusResponse:            //44
+            {
+                //STEP 1: Wait for ChargingStatusReq Message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargingStatusRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    if (Proc_iso1_ChargingStatusReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]ChargingStatusRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 2: Wait for PowerDeliveryReq Message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStop);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargingStatus_Timer_End);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                   // EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    break;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case PowerDeliveryRequestStop:          //49
+            {
+                if (Proc_iso1_PowerDeliveryStopReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryResponseStop);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStopReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case PowerDeliveryResponseStop:         //50
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > 2000)  //2 seconds
+                {
+                    sprintf(buf_log_evcomm,
+                            "Wait for SessionStopReq Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            2000);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+                    break;
+                }
+                #endif
+
+                //STEP 3: Check for SessionStopReq Message
+               	if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
+                {
+                    Update_V2G_Flow_Status(SessionStopRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                      if(ShmCcsData->V2GMessage_ISO15118_2014.PowerDeliveryRequest.ChargeProgress==iso1chargeProgressType_Stop)        
+                    	EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case SessionStopRequest:                //53
+            {
+                if (Proc_iso1_SessionStopReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(SessionStopResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]SessionStopReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case SessionStopResponse:               //54
+            {
+                break;
+            }
+            //-------------------------------------------
+            default:
+            {
+                break;
+            }
+        }
+    }
+
+}
+
+
+/*===========================================================================
+FUNCTION: V2gMsg_Process_iso1
+DESCRIPTION:
+    1. EnergyTransferMode:
+        AC_single_phase_core =  0,
+        AC_three_phase_core =   1,
+        DC_core =               2,
+        DC_extended =           3,
+        DC_combo_core =         4,
+        DC_unique =             5
+
+        iso1EnergyTransferModeType_AC_single_phase_core = 0,
+    	iso1EnergyTransferModeType_AC_three_phase_core = 1,
+    	iso1EnergyTransferModeType_DC_core = 2,
+    	iso1EnergyTransferModeType_DC_extended = 3,
+    	iso1EnergyTransferModeType_DC_combo_core = 4,
+    	iso1EnergyTransferModeType_DC_unique = 5
+PRE-CONDITION:
+INPUT:
+        1. V2gFlowStatus
+OUTPUT:
+GLOBAL VARIABLES:
+        1. V2gFlowStatus
+=============================================================================*/
+int V2gMsg_Process_iso1(int AcceptFd, unsigned char EnergyTransferMode)
+{
+    switch (EnergyTransferMode)
+    {
+        case DC_extended:
+        {
+            V2gMsg_Process_iso1_DC(AcceptFd);
+            break;
+        }
+
+        case AC_single_phase_core:
+        case AC_three_phase_core:
+        {
+            V2gMsg_Process_iso1_AC(AcceptFd);
+            break;
+        }
+
+        default:
+        {
+            sprintf(buf_log_evcomm,
+                    "[ISO1][Warning]Unexpected EnergyTransferMode(%d)",
+                    EnergyTransferMode);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            break;
+        }
+    }
+}
+
+/*===========================================================================
+FUNCTION: V2gMsg_Process_iso2_DC
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+        1. V2gFlowStatus
+OUTPUT:
+GLOBAL VARIABLES:
+        1. V2gFlowStatus
+=============================================================================*/
+int V2gMsg_Process_iso2_DC(int AcceptFd)
+{
+    unsigned char req_is_responsed = FALSE;
+    while (req_is_responsed == FALSE)
+    {
+        //Check if it is in End_Process
+        if (EVCOMM_SYS_INFO.End_Process_inused == TRUE)
+        {
+            break;
+        }
+
+        switch(V2gFlowStatus)
+        {
+            //-------------------------------------------
+            case SupportedAppProtocolRequest:
+            {
+                if (ccs_handshake.supportedAppProtocolReq_isUsed == 1u)
+                {
+                    ccs_handshake.supportedAppProtocolReq_isUsed = 0;
+                    if (Proc_supportedAppProtocolReq(AcceptFd) == 0)   //0: no error
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                        Update_V2G_Flow_Status(SupportedAppProtocolResponse);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]supportedAppProtocolResReq: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case SupportedAppProtocolResponse:
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionSetupRequest)
+                {
+                    Update_V2G_Flow_Status(SessionSetupRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case SessionSetupRequest:               //19
+            {
+                if (Proc_iso2_SessionSetupReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(SessionSetupResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]SessionSetupReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case SessionSetupResponse:              //20
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceDiscoveryRequest)
+                {
+                    Update_V2G_Flow_Status(ServiceDiscoveryRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+    #if 0
+            //-------------------------------------------
+            case ServiceDiscoveryRequest:           //21
+            {
+                if (Proc_iso2_ServiceDiscoveryReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(ServiceDiscoveryResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]ServiceDiscoveryReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case ServiceDiscoveryResponse:          //22
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ServiceAndPaymentSelectionRequest)
+                {
+                    Update_V2G_Flow_Status(ServiceAndPaymentSelectionRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case ServiceAndPaymentSelectionRequest:     //25
+            {
+                if (Proc_iso2_ServiceAndPaymentSelectionReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(ServiceAndPaymentSelectionResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]ServiceAndPaymentSelectionReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case ServiceAndPaymentSelectionResponse:    //26
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
+                {
+                    Update_V2G_Flow_Status(AuthorizationRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            //case ContractAuthenticationReq:
+            case AuthorizationRequest:              //29
+            {
+                if (Proc_iso2_AuthenticationReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(AuthorizationResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]AuthorizationReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case AuthorizationResponse:             //30
+            {
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == AuthorizationRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_iso2_AuthenticationReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]AuthorizationReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+
+                //Check for ChargeParameterDiscoveryReq
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(ChargeParameterDiscoveryRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]ChargeParameterDiscoveryReq: CSU Permission?");
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case ChargeParameterDiscoveryRequest:   //35
+            {
+                if (Proc_iso2_ChargeParameterDiscoveryReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(ChargeParameterDiscoveryResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]ChargeParameterDiscoveryReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case ChargeParameterDiscoveryResponse:
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > V2G_SECC_ChargingParameter_Performance_Time)  //60 seconds
+                {
+                    sprintf(buf_log_evcomm,
+                            "ChargingParameter Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            V2G_SECC_ChargingParameter_Performance_Time);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+                    break;
+                }
+                #endif
+
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == ChargeParameterDiscoveryRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_iso2_ChargeParameterDiscoveryReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]ChargeParameterDiscoveryReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 2: Check for CableCheckReq message
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CableCheckRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(CableCheckRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]CableCheckReqReq: isolated?");
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_Start);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                //STEP 3: Wait for PowerDeliveryReq Message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStop);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+
+                    if (Proc_iso2_PowerDeliveryStopReq(AcceptFd) == 0)
+                    {
+                        Update_V2G_Flow_Status(PowerDeliveryResponseStop);
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStopReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    break;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case CableCheckRequest:                 //37
+            {
+                //STEP 3: Execute Cable Check Process
+                if (Proc_iso2_CableCheckReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(CableCheckResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]CableCheckReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case CableCheckResponse:                //38
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > V2G_SECC_CableCheck_Performance_Time)  //38 seconds
+                {
+                    //SAVE_SYS_LOG_MSG_EVCOMM("[CableCheck] end counting...");
+                    sprintf(buf_log_evcomm,
+                            "CableCheck Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            V2G_SECC_CableCheck_Performance_Time);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+
+                    //Update_ShmStatusCode(); //[To-Do] to be implemented
+                    //CCS_SECC_TIMEOUT_V2G_CableCheck_Performance_Time (023847)
+                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                    ShmStatusCodeData->PresentStatusCode[0][4] = 4;
+                    ShmStatusCodeData->PresentStatusCode[0][5] = 7;
+                    break;
+                }
+                #endif
+
+                //STEP 2: Check for CableCheckReq message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CableCheckRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    //STEP 3: Execute Cable Check Process
+                    if (Proc_iso2_CableCheckReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]CableCheckReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 3: Check for PreChargeReq message
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg == PreChargeRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(PreChargeRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]PreChargeReqReq: waiting for precharge voltage...");
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CableCheck_Timer_End);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Precharge_Timer_Start);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                //STEP 3: Wait for PowerDeliveryReq Message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStop);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    //ftime(&EVCOMM_SYS_INFO.V2G_SECC_ChargeParameterDiscovery_Timer_End);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+
+                    if (Proc_iso2_PowerDeliveryStopReq(AcceptFd) == 0)
+                    {
+                        Update_V2G_Flow_Status(PowerDeliveryResponseStop);
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStopReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    break;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case PreChargeRequest:                  //39
+            {
+                if (Proc_iso2_PreChargeReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(PreChargeResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]PreChargeReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case PreChargeResponse:                 //40
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > V2G_SECC_PreCharge_Performance_Time)  //5 seconds
+                {
+                    sprintf(buf_log_evcomm,
+                            "Precharge Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            V2G_SECC_PreCharge_Performance_Time);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+
+                    //Update_ShmStatusCode(); //[To-Do] to be implemented
+                    //CCS_SECC_TIMEOUT_V2G_PreCharge_Performace_Time (023850)
+                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                    ShmStatusCodeData->PresentStatusCode[0][4] = 5;
+                    ShmStatusCodeData->PresentStatusCode[0][5] = 0;
+                    break;
+                }
+                #endif
+
+                //STEP 2: Check for PreChargeReq message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == PreChargeRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_iso2_PreChargeReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]PreChargeReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 3: Check for PowerDeliveryReq message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStart);
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Precharge_Timer_End);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case PowerDeliveryRequestStart:         //41
+            {
+                if (Proc_iso2_PowerDeliveryStartReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryResponsetStart);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStartReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case PowerDeliveryResponsetStart:        //42
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                if (ccs_exi_doc_ISO2.V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
+                {
+                    ftime(&SeqEndTime);
+                    if(DiffTimeb(SeqStartTime, SeqEndTime) > 2000)  //5 seconds
+                    {
+                        sprintf(buf_log_evcomm,
+                                "Wait for CurrentDemandReq Timeout - (%.02lf of %d ms)\n",
+                                DiffTimeb(SeqStartTime, SeqEndTime),
+                                2000);
+                        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                        Update_V2G_Flow_Status(Sequence_Timeout);
+                    }
+                    break;
+                }
+                #endif
+
+                //STEP 2: Wait for CurrentDemandReq Message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CurrentDemandRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(CurrentDemandRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]CurrentDemandReqReq: energy transfering...");
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CurrentDemand_Timer_Start);
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case CurrentDemandRequest:              //45,
+            {
+                if (Proc_iso2_CurrentDemandReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(CurrentDemandResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]CurrentDemandReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case CurrentDemandResponse:             //46,
+            {
+                //STEP 1: Wait for CurrentDemandReq Message
+                if (EVCOMM_SYS_INFO.V2G_Rx_Msg == CurrentDemandRequest)
+                {
+                     EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    if (Proc_iso2_CurrentDemandReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]CurrentDemandReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 2: Wait for PowerDeliveryReq Message
+                else if((EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStop) ||
+                        (EVCOMM_SYS_INFO.V2G_Rx_Msg == PowerDeliveryRequestStart))
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryRequestStop);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_CurrentDemand_Timer_End);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case PowerDeliveryRequestStop:          //49,
+            {
+                if (Proc_iso2_PowerDeliveryStopReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(PowerDeliveryResponseStop);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]PowerDeliveryStopReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case PowerDeliveryResponseStop:        //50,
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > 2000)  //2 seconds
+                {
+                    sprintf(buf_log_evcomm,
+                            "Wait for WeldingDetectionReq or SessionStopReq Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            2000);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+                    break;
+                }
+                #endif
+
+                //STEP 2: Check for WeldingDetectionReq Message
+                if(EVCOMM_SYS_INFO.V2G_Rx_Msg == WeldingDetectionRequest)
+                {
+                   EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    Update_V2G_Flow_Status(WeldingDetectionRequest);
+                    SAVE_SYS_LOG_MSG_EVCOMM("[V2G][Rx]WeldingDetectionReq: ongoing...");
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_WeldingDetection_Timer_Start);
+
+                    #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                    ftime(&SeqStartTime);
+                    #endif
+                }
+                else if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
+                {
+                    Update_V2G_Flow_Status(SessionStopRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    if (Proc_iso2_SessionStopReq(AcceptFd) == 0)
+                    {
+                        Update_V2G_Flow_Status(SessionStopResponse);
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]SessionStopReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    break;
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case WeldingDetectionRequest:           //51,
+            {
+                if (Proc_iso2_WeldingDetectionReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(WeldingDetectionResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]WeldingDetectionReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case WeldingDetectionResponse:          //52,
+            {
+                //STEP 1: Check for Process Timeout
+                #if V2G_SECC_TIMEOUT_PROTECTION == ENABLE
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > V2G_SECC_WeldingDetection_Performance_Time)  //20 seconds
+                {
+                    sprintf(buf_log_evcomm,
+                            "Wait for SessionStopReq Timeout - (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            V2G_SECC_WeldingDetection_Performance_Time);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+                    break;
+                }
+                #endif
+
+                //STEP 2: Check for WeldingDetectionReq Message
+                if(EVCOMM_SYS_INFO.V2G_Rx_Msg == WeldingDetectionRequest)
+                {
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                    if (Proc_iso1_WeldingDetectionReq(AcceptFd) == 0)
+                    {
+                        ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    }
+                    else
+                    {
+                        SAVE_SYS_LOG_MSG_EVCOMM("[Error]WeldingDetectionReqRes: fail");
+                        Update_V2G_Flow_Status(Other_Fault);
+                    }
+                    req_is_responsed = TRUE;
+                    break;
+                }
+                //STEP 3: Check for SessionStopReq Message
+                else if(EVCOMM_SYS_INFO.V2G_Rx_Msg == SessionStopRequest)
+                {
+                    Update_V2G_Flow_Status(SessionStopRequest);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_WeldingDetection_Timer_End);
+                }
+                else if (EVCOMM_SYS_INFO.V2G_Rx_Msg >= SupportedAppProtocolRequest &&
+                         EVCOMM_SYS_INFO.V2G_Rx_Msg <= SessionStopRequest)
+                {
+                    sprintf(buf_log_evcomm,
+                            "[ERROR]SequenceError(%d) => Tx Res MSG",
+                            EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.SequenceError = TRUE;
+
+                    Update_V2G_Flow_Status(EVCOMM_SYS_INFO.V2G_Rx_Msg);
+                    EVCOMM_SYS_INFO.V2G_Rx_Msg = 0;
+                }
+                else
+                {
+                    break;
+                }
+                break;
+            }
+            //-------------------------------------------
+            case SessionStopRequest:                //53,
+            {
+                if (Proc_iso2_SessionStopReq(AcceptFd) == 0)
+                {
+                    Update_V2G_Flow_Status(SessionStopResponse);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                }
+                else
+                {
+                    SAVE_SYS_LOG_MSG_EVCOMM("[Error]SessionStopReqRes: fail");
+                    Update_V2G_Flow_Status(Other_Fault);
+                }
+                req_is_responsed = TRUE;
+                break;
+            }
+            case SessionStopResponse:               //54,
+            {
+                break;
+            }
+    #endif
+            //-------------------------------------------
+            default:
+            {
+                break;
+            }
+        }
+    }
+}
+
+
+
+/*===========================================================================
+FUNCTION: V2gMsg_Process_iso2_AC
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+        1. V2gFlowStatus
+OUTPUT:
+GLOBAL VARIABLES:
+        1. V2gFlowStatus
+=============================================================================*/
+int V2gMsg_Process_iso2_AC(int AcceptFd)
+{
+}
+
+/*===========================================================================
+FUNCTION: V2gMsg_Process_iso2
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+        1. V2gFlowStatus
+OUTPUT:
+GLOBAL VARIABLES:
+        1. V2gFlowStatus
+=============================================================================*/
+int V2gMsg_Process_iso2(int AcceptFd, unsigned char EnergyTransferMode)
+{
+    switch (EnergyTransferMode)
+    {
+        case DC_extended:
+        {
+            V2gMsg_Process_iso2_DC(AcceptFd);
+            break;
+        }
+
+        case AC_single_phase_core:
+        case AC_three_phase_core:
+        {
+            V2gMsg_Process_iso2_AC(AcceptFd);
+            break;
+        }
+
+        default:
+        {
+            sprintf(buf_log_evcomm,
+                    "[ISO2][Warning]Unexpected EnergyTransferMode(%d)",
+                    EnergyTransferMode);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            break;
+        }
+    }
+}
+
+/*===========================================================================
+FUNCTION: V2gMsg_Process
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int V2gMsg_Process(int AcceptFd)
+{
+    int errn = 0;
+
+    switch (ShmCcsData->CommProtocol)
+    {
+        case V2GT_MSG_PROTOCOL_DIN70121:        //0
+        {
+            V2gMsg_Process_din(AcceptFd);
+            break;
+        }
+
+        case V2GT_MSG_PROTOCOL_ISO15118_2014:   //1
+        {
+            V2gMsg_Process_iso1(AcceptFd, ShmCcsData->EnergyTransferMode);
+            break;
+        }
+
+        case V2GT_MSG_PROTOCOL_ISO15118_2018:   //2
+        {
+            V2gMsg_Process_iso2(AcceptFd, ShmCcsData->EnergyTransferMode);
+            break;
+        }
+
+        default:
+        {
+            sprintf(buf_log_evcomm,
+                    "[Warning]Unexpected CommProtocol(%d)",
+                    ShmCcsData->CommProtocol);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            break;
+        }
+    }
+
+    return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: V2gMsg_Rx
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int V2gMsg_Rx(int AcceptFd)
+{
+    int errn = 0;
+    unsigned int packet_size = 0;
+
+    memset(V2gtpMsgRxBuf, 0, V2GTP_MSG_RX_BUFFER_SIZE);
+    #ifdef SUPPORT_TLS_CONNECTION
+    if(EvSecurity == 0)//support security
+    {
+    	packet_size = SSL_read(ssl, V2gtpMsgRxBuf, V2GTP_MSG_RX_BUFFER_SIZE);
+    }
+    else
+    {
+    	packet_size = recv(AcceptFd, V2gtpMsgRxBuf, V2GTP_MSG_RX_BUFFER_SIZE, 0);
+    }
+    #else
+    packet_size = recv(AcceptFd, V2gtpMsgRxBuf, V2GTP_MSG_RX_BUFFER_SIZE, 0);
+    #endif
+    //[CAUTION] Everytime recv() is called, it will take a default time to wait for TCP packets.
+    //The more time you call recv(), the more time you will waste here.
+    //Here it is suggested that response immediatedly once you receive any packets.
+    //For configuring the Rx waiting time, please use setsockopt().
+
+    if(packet_size > 0) //[Joseph] If there is no data, ignore. (TBD)
+    {
+        //DEBUG_PRINTF_EVCOMM_DETAIL("\n\n Got TCP V2GTP Message: size = %d Bytes\n", packet_size);
+        errn = V2gMsgDecoder(V2gtpMsgRxBuf, packet_size, V2gFlowStatus);
+        if (errn < 0)
+        {
+            sprintf(buf_log_evcomm, "[ERROR]V2gMsgDecoder", errn);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        }
+    }
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: V2gComm
+DESCRIPTION:
+PRE-CONDITION:
+        1. TCP socket is connected.
+INPUT:
+        1. AcceptFd         //TCP Connection ID
+        2. V2gtpMsgRxBuf[]     //V2GTP Messages (Header + Payload)
+        3. V2GTP_MSG_RX_BUFFER_SIZE   //64*1024 = 65,536 = 65.5K (Bytes)
+
+OUTPUT:
+GLOBAL VARIABLES:
+        1. V2gtpMsgRxBuf[]
+=============================================================================*/
+int V2gComm(int AcceptFd)
+{
+    int errn = 0;
+
+    if (V2gMsg_Rx(AcceptFd) < 0)
+    {
+        Update_V2G_Flow_Status(Other_Fault);
+        errn = -1;
+    }
+
+    //following are the response message handling according to status flag
+    if (V2gMsg_Process(AcceptFd) < 0)
+    {
+        errn = -1;
+    }
+
+    //Error Check
+    //V2G_Error_Monitor();
+
+    return errn;
+}
+
+/*===========================================================================
+FUNCTION: SdpUdpConnected
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int SdpUdpConnected()
+{
+    int packet_size,Rtn;
+    struct sockaddr_in6 ServerAddr,ClientAddr;
+    struct V2gtpHeader *header;
+    unsigned char *payload;
+
+    if(UdpSock <= 0)
+    {
+        if ((UdpSock = socket(AF_INET6, SOCK_DGRAM, 0)) < 0)
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("SdpUdpConnected: Fail to open UdpSock");
+            return 0;
+        }
+        ShmSysConfigAndInfo->SysInfo.SystemCriticalTemp=UdpSock;
+        memset(&ServerAddr,0, sizeof(struct sockaddr_in));
+        ServerAddr.sin6_family = AF_INET6;
+        ServerAddr.sin6_addr = in6addr_any;
+        ServerAddr.sin6_port = htons(SdpUdpServerPort);
+        if(bind(UdpSock, (struct sockaddr *)&ServerAddr, sizeof(struct sockaddr_in6)) <0)
+        {
+            sprintf(buf_log_evcomm,
+                    "SdpUdpConnected: Fail to bind UdpSock(%d)",
+                    UdpSock);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+            close(UdpSock);
+            UdpSock = -1;
+            return 0;
+        }
+        sprintf(buf_log_evcomm, "[UdpSock]opend:%d", UdpSock);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+        sprintf(buf_log_evcomm, "[SDP]Req from EVCC: waiting...(%d)", UdpSock);
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    }
+
+    memset(V2gtpMsgRxBuf, 0, V2GTP_MSG_RX_BUFFER_SIZE);
+    memset(&ClientAddr, 0, sizeof(struct sockaddr_in));
+    Rtn = sizeof(struct sockaddr_in6);
+    packet_size = recvfrom(UdpSock, V2gtpMsgRxBuf, V2GTP_MSG_RX_BUFFER_SIZE, MSG_DONTWAIT, (struct sockaddr *)&ClientAddr, &Rtn);
+
+    if(packet_size > 0)
+    {
+        header = (struct V2gtpHeader *) V2gtpMsgRxBuf;
+        payload = V2gtpMsgRxBuf+sizeof(struct V2gtpHeader);
+
+        #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+        {
+            DEBUG_PRINTF_EVCOMM_DETAIL("\n\n Got UDP packet_size = %d (Bytes)\n", packet_size);
+
+            DEBUG_PRINTF_EVCOMM_DETAIL("\n\n***********************************\n");
+            DEBUG_PRINTF_EVCOMM_DETAIL("***** Received SDP Packet *****\n");
+            DEBUG_PRINTF_EVCOMM_DETAIL("***********************************\n");
+            DEBUG_PRINTF_EVCOMM_DETAIL("ClientAddress=");
+
+            for(Rtn = 0; Rtn < 16; Rtn += 2)
+            {
+                DEBUG_PRINTF_EVCOMM_DETAIL("%02x%02x:",ClientAddr.sin6_addr.s6_addr[Rtn],ClientAddr.sin6_addr.s6_addr[Rtn+1]);
+            }
+            DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+            DEBUG_PRINTF_EVCOMM_DETAIL("ClientPort=%d\n",ClientAddr.sin6_port);
+            DEBUG_PRINTF_EVCOMM_DETAIL("ProtocolVersion=%d\n",header->ProtocolVersion);
+            DEBUG_PRINTF_EVCOMM_DETAIL("InverseProtocolVersion=0x%x\n",header->InverseProtocolVersion);
+            DEBUG_PRINTF_EVCOMM_DETAIL("PayloadType=0x%x\n",htons(header->PayloadType));
+            DEBUG_PRINTF_EVCOMM_DETAIL("PayloadLength=0x%x\n",htonl(header->PayloadLength));
+            DEBUG_PRINTF_EVCOMM_DETAIL("htons(header->PayloadType)=0x%x\n",htons(header->PayloadType));
+        }
+        #endif
+
+        if( (header->ProtocolVersion == 0x01) &&
+            (header->InverseProtocolVersion == 0xFE) &&
+            (htons(header->PayloadType) == V2GTP_PAYLOAD_TYPE_SDP_REQUEST))
+        {
+            sprintf(buf_log_evcomm, "[SDP][Rx]Req from EVCC: GOT(%d)", UdpSock);
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+            DEBUG_PRINTF_EVCOMM_DETAIL("Security=0x%x\n", *(payload + 0));
+            DEBUG_PRINTF_EVCOMM_DETAIL("TransportProtocol=0x%x\n", *(payload + 1));
+	   		#ifdef SUPPORT_TLS_CONNECTION
+	   		EvSecurity= 	*(payload);
+	   		#endif
+		
+            header->PayloadType = htons(V2GTP_PAYLOAD_TYPE_SDP_RESPONSE);
+            header->PayloadLength = htonl(20);    //Fixed Length=20
+            memset(payload, 0, 20);
+            // MAC address[0:2] + FFFE + MAC address[3:5]
+            payload[0] = (IPV6_LINK_LOCAL_PREFIX>>8) & 0xFF;
+            payload[1] = IPV6_LINK_LOCAL_PREFIX & 0xFF;
+            payload[8 ]= CsuMac[0];
+            payload[8] ^= 0x02;// bit 1 should complemented.
+            payload[9] = CsuMac[1];
+            payload[10] = CsuMac[2];
+            payload[11] = 0xFF;
+            payload[12] = 0xFE;
+            payload[13] = CsuMac[3];
+            payload[14] = CsuMac[4];
+            payload[15] = CsuMac[5];
+            //TCP port
+            payload[16] = (EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active>>8) & 0xFF;
+            payload[17] = EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active & 0xFF;
+            #ifdef SUPPORT_TLS_CONNECTION
+            if(EvSecurity == 0)//support security
+            	 payload[18] = SDP_PAYLOAD_SECURITY_TLS;      //Security
+            else
+            	 payload[18] = SDP_PAYLOAD_SECURITY_NONE;      // No Security	 
+            #else
+            payload[18] = SDP_PAYLOAD_SECURITY_NONE;      //No Security
+            #endif
+            payload[19] = SDP_PAYLOAD_TRANS_PROTOCOL_TCP; //Transport protocol
+
+            //[To-Do] Setup the TCP in advance to receive the coming TCP handshke messages after SDP response.
+
+            Rtn = sendto(UdpSock, V2gtpMsgRxBuf, sizeof(struct V2gtpHeader) + htonl(header->PayloadLength), 0, (struct sockaddr *)&ClientAddr, sizeof(struct sockaddr_in6));
+
+            sprintf(buf_log_evcomm, "[SDP][Tx]Res from SECC");
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+            #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+            {
+                DEBUG_PRINTF_EVCOMM_DETAIL("\n\n***** Response SDP Packet *****\n");
+                DEBUG_PRINTF_EVCOMM_DETAIL("Send size=%d\n",Rtn);
+                DEBUG_PRINTF_EVCOMM_DETAIL("Destination Address=");
+                for(Rtn = 0; Rtn < 16; Rtn++)
+                {
+                    DEBUG_PRINTF_EVCOMM_DETAIL("%02x, ", ClientAddr.sin6_addr.s6_addr[Rtn]);
+                }
+                DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+                DEBUG_PRINTF_EVCOMM_DETAIL("Destination Port=%d\n", ClientAddr.sin6_port);
+                DEBUG_PRINTF_EVCOMM_DETAIL("ProtocolVersion=%d\n", header->ProtocolVersion);
+                DEBUG_PRINTF_EVCOMM_DETAIL("InverseProtocolVersion=0x%x\n", header->InverseProtocolVersion);
+                DEBUG_PRINTF_EVCOMM_DETAIL("PayloadType=0x%x\n", htons(header->PayloadType));
+                DEBUG_PRINTF_EVCOMM_DETAIL("PayloadLength=0x%x\n", htonl(header->PayloadLength));
+                DEBUG_PRINTF_EVCOMM_DETAIL("SECC Ipv6 Address=");
+                for(Rtn = 0; Rtn < 16; Rtn++)
+                {
+                    DEBUG_PRINTF_EVCOMM_DETAIL("%02x:",payload[Rtn]);
+                }
+                DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+                DEBUG_PRINTF_EVCOMM_DETAIL("SECC Port=%d\n", (payload[16]<<8 | payload[17]));
+                DEBUG_PRINTF_EVCOMM_DETAIL("Security=0x%x\n", payload[19]);
+                DEBUG_PRINTF_EVCOMM_DETAIL("TransportProtocol=0x%x\n", payload[20]);
+            }
+            #endif
+
+            if(Rtn >= 28)
+            {
+                return 1;
+            }
+        }
+    }
+    return 0;
+}
+
+/*===========================================================================
+FUNCTION: V2gTcpConnected
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int V2gTcpConnected()
+{
+    int packet_size,Rtn,AcceptFd;
+    struct sockaddr_in6 ServerAddr,ClientAddr;
+
+    if(TcpSock <= 0)
+    {
+        if ((TcpSock = socket(PF_INET6, SOCK_STREAM, 0)) < 0)
+        {
+            sprintf(buf_log_evcomm,
+                    "V2gTcpConnected: Fail to open TcpSock (%s)",
+                    strerror(errno));
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            usleep(100000); //100ms
+
+            return 0;
+        }
+        ShmSysConfigAndInfo->SysInfo.PsuAmbientTemp=TcpSock;
+        fcntl(TcpSock, F_SETFL, O_NONBLOCK);    //set to O_NONBLOCK
+        SAVE_SYS_LOG_MSG_EVCOMM("[TCP]socket set: DONE");
+
+        memset(&ServerAddr,0, sizeof(struct sockaddr_in));
+        ServerAddr.sin6_family = PF_INET6;
+        ServerAddr.sin6_addr = in6addr_any;
+        ServerAddr.sin6_port = htons(EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active);
+        //ServerAddr.sin6_port = htons(SdpTcpServerPort + (rand() % 10) + 1);
+        //printf("SdpTcpServerPort = %d(DEC)\n", htons(ServerAddr.sin6_port));
+        if(bind(TcpSock, (struct sockaddr *)&ServerAddr, sizeof(struct sockaddr_in6)) < 0)
+        {
+            sprintf(buf_log_evcomm,
+                    "V2gTcpConnected: Fail to bind TcpSock (%s), SdpTcpServerPort = %d",
+                    strerror(errno),
+                    EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active
+                    );
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+            //Change to another TCP port
+            /*
+            memset(&ServerAddr, 0, sizeof(struct sockaddr_in));
+            ServerAddr.sin6_family = PF_INET6;
+            ServerAddr.sin6_addr = in6addr_any;
+            //ServerAddr.sin6_port = htons(SdpTcpServerPort + (rand() % 1000) + 1);
+            ServerAddr.sin6_port = htons(EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active);
+            */
+            if(bind(TcpSock, (struct sockaddr *)&ServerAddr, sizeof(struct sockaddr_in6)) < 0)
+            {
+                sprintf(buf_log_evcomm,
+                        "V2gTcpConnected: Fail to bind TcpSock (%s), SdpTcpServerPort = %d",
+                        strerror(errno),
+                        EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active
+                        );
+                SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+                usleep(100000); //100ms
+                close(TcpSock);
+                TcpSock = -1;
+                return 0;
+            }
+        }
+        SAVE_SYS_LOG_MSG_EVCOMM("[TCP]blid: DONE");
+
+        SAVE_SYS_LOG_MSG_EVCOMM("[TCP]listen: START");
+
+        if(listen(TcpSock, 1) < 0)     //only accept one connection
+        {
+            sprintf(buf_log_evcomm,
+                    "V2gTcpConnected: Fail to listen TcpSock (%s)",
+                    strerror(errno));
+            SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+            usleep(100000); //100ms
+
+            close(TcpSock);
+            TcpSock = -1;
+            return 0;
+        }
+        SAVE_SYS_LOG_MSG_EVCOMM("[TCP]listen: DONE");
+
+        sprintf(buf_log_evcomm, "[TCP]TcpSock: opened(%d), port=%d", TcpSock, htons(ServerAddr.sin6_port));
+        SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+        SAVE_SYS_LOG_MSG_EVCOMM("[TCP]accept: START");
+    }
+    Rtn = sizeof(struct sockaddr_in6);
+    if((AcceptFd = accept(TcpSock, (struct sockaddr *)&ClientAddr, &Rtn)) < 0 )
+    {
+        static BOOL tmp = 0;
+        if (tmp = 0)
+        {
+            SAVE_SYS_LOG_MSG_EVCOMM("[TCP]Wait TCP connection...");
+            tmp = 1;
+        }
+        else
+        {
+            //DEBUG_PRINTF_EVCOMM_DETAIL(".");
+        }
+        return 0;
+    }
+	ShmSysConfigAndInfo->SysInfo.PsuFanRotaSpeed=AcceptFd;
+    SAVE_SYS_LOG_MSG_EVCOMM("[TCP]accept: DONE\n");
+
+    #if (DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE)
+    {
+        DEBUG_PRINTF_EVCOMM_DETAIL("\n\nAccept one TCP connection:\n");
+        DEBUG_PRINTF_EVCOMM_DETAIL("AcceptFd=%d\n",AcceptFd);
+        DEBUG_PRINTF_EVCOMM_DETAIL("ClientAddress=");
+
+        for(Rtn = 0; Rtn < 16; Rtn += 2)
+        {
+            DEBUG_PRINTF_EVCOMM_DETAIL("%02x%02x:", ClientAddr.sin6_addr.s6_addr[Rtn], ClientAddr.sin6_addr.s6_addr[Rtn+1]);
+        }
+        DEBUG_PRINTF_EVCOMM_DETAIL("\n");
+        DEBUG_PRINTF_EVCOMM_DETAIL("ClientPort=%d\n", ClientAddr.sin6_port);
+    }
+    #endif
+    
+    #ifdef SUPPORT_TLS_CONNECTION
+    /* TCP connection is ready. Do server side SSL connection. */
+    if(EvSecurity == 0)//support security
+    {	
+		ssl = SSL_new(ctx);
+		SSL_set_fd(ssl, AcceptFd);
+		if (SSL_accept(ssl) <= 0) 
+		{
+			//SAVE_SYS_LOG_MSG_EVCOMM("[SSL]SSL_accept Failed");
+			//SSL_free(ssl);
+			//close(AcceptFd);
+			//AcceptFd = -1;
+			return 0;
+	  	}
+	 }
+    #endif
+
+    return AcceptFd;
+}
+
+/*===========================================================================
+FUNCTION: End_Process
+DESCRIPTION:
+PRE-CONDITION:
+        1. <CAUTION> This function could only be used in SeccComm fork2.
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int End_Process()
+{
+    if(EVCOMM_SYS_INFO.End_Process_inused == TRUE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("End_Process has been triggered by another event.");
+        return -1;
+    }
+
+    SAVE_SYS_LOG_MSG_EVCOMM("[End_Process]entering...");
+
+    //STEP 1: Ask CSU to Stop
+    EVCOMM_SYS_INFO.End_Process_inused = TRUE;
+    CSUCOMMDC_TASK_FLAG.Send_EVStopReq = TRUE;
+    EVCOMM_SYS_INFO.ConnectorLocked = FALSE;
+    ShmInternalComm->ChargingPermission = FALSE;
+
+    //Step 2: Close sockets
+    SAVE_SYS_LOG_MSG_EVCOMM("[End_Process]close sockets...");
+    if(RawSock > 0)
+    {
+        close(RawSock);
+    }
+    if(UdpSock > 0)
+    {
+        close(UdpSock);
+    }
+    if(TcpSock > 0)
+    {
+        close(TcpSock);
+        close(TcpAcceptFd);
+    }
+    RawSock = UdpSock = TcpSock = TcpAcceptFd = -1;
+     if(ShmSysConfigAndInfo->SysInfo.SystemAmbientTemp > 0)
+    {
+        close(ShmSysConfigAndInfo->SysInfo.SystemAmbientTemp);
+        ShmSysConfigAndInfo->SysInfo.SystemAmbientTemp=0;
+    }
+    if(ShmSysConfigAndInfo->SysInfo.SystemCriticalTemp > 0)
+    {
+        close(ShmSysConfigAndInfo->SysInfo.SystemCriticalTemp);
+         ShmSysConfigAndInfo->SysInfo.SystemCriticalTemp=0;
+    }
+    if(ShmSysConfigAndInfo->SysInfo.PsuAmbientTemp > 0)
+    {
+        close(ShmSysConfigAndInfo->SysInfo.PsuAmbientTemp);
+        close(ShmSysConfigAndInfo->SysInfo.PsuFanRotaSpeed);
+         ShmSysConfigAndInfo->SysInfo.PsuAmbientTemp=0;
+          ShmSysConfigAndInfo->SysInfo.PsuFanRotaSpeed=0;
+    }
+    /*#ifdef SUPPORT_TLS_CONNECTION
+	if(EvSecurity == 0)//support security
+    {	
+    	SSL_shutdown(ssl);
+		SSL_free (ssl);
+  	}
+  	SSL_CTX_free (ctx);
+  	#endif*/
+    //STEP 3: Switch to State E
+    //SwitchCpStateE(ENABLE);
+
+    //STEP 4: Close tcpdump
+    Sniffer_Tcpdump(DISABLE);
+
+    //STEP 5: Keep 100% PWM for 5 seconds
+    OutputCpPwmDuty(100);
+    SAVE_SYS_LOG_MSG_EVCOMM("PWM 100\% countdown: 5");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("PWM 100\% countdown: 4");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("PWM 100\% countdown: 3");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("PWM 100\% countdown: 2");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("PWM 100\% countdown: 1");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("PWM 100\% countdown: 0");
+
+    AttenProfileCnt = 0;
+    init_appHandEXIDocument(&ccs_handshake);
+ 
+
+    #if (FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == DISABLE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[End_Process]1st sync...");
+        system("sync");
+    }
+    #endif
+
+    //STEP 4: Switch to State E
+    //Keep State E for 5 seconds
+    #if 0
+    SwitchCpStateE(ENABLE); //Set PWM Duty as 0 and set State as E (0V)
+    SAVE_SYS_LOG_MSG_EVCOMM("State E countdown: 5");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("State E countdown: 4");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("State E countdown: 3");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("State E countdown: 2");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("State E countdown: 1");
+    sleep(1);
+    SAVE_SYS_LOG_MSG_EVCOMM("State E countdown: 0");
+    #endif
+
+    //Reset Memory
+    unsigned char SlaveAddress_backup;
+    unsigned int matched_backup;
+    //unsigned char state_backup;
+
+
+    SAVE_SYS_LOG_MSG_EVCOMM("[CCS Board]soft reset (closing SeccComm)...");
+    SAVE_SYS_LOG_MSG_EVCOMM("---------------------------------------------");
+    SAVE_SYS_LOG_MSG_EVCOMM("--    EVCOMM: END             --");
+    SAVE_SYS_LOG_MSG_EVCOMM("-----------------------------------------\n");
+
+    #if (FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == DISABLE)
+    {
+        SAVE_SYS_LOG_MSG_EVCOMM("[End_Process]2nd sync...");
+        system("sync");
+    }
+    #endif
+
+  //  system("sleep 1");
+
+    //Backup CsuComm flags
+    SlaveAddress_backup = ShmInternalComm->SlaveAddress;
+    matched_backup = CSUCOMMDC_TASK_FLAG.matched;
+    //state_backup = Check_V2G_Flow_Status();
+
+    memset(V2gtpMsgRxBuf, 0, V2GTP_MSG_RX_BUFFER_SIZE);
+    memset(V2gtpMsgTxBuf, 0, V2GTP_MSG_TX_BUFFER_SIZE);
+    memset(&ccs_handshake, 0, sizeof(struct appHandEXIDocument));
+    memset(&ccs_exi_doc_DIN, 0, sizeof(struct dinEXIDocument));
+    memset(V2GTP_Tx_buf, 0, V2GTP_MSG_TX_BUFFER_SIZE);
+    memset(buf_log_evcomm, 0, sizeof(buf_log_evcomm));
+    memset(ShmStatusCodeData, 0, sizeof(struct StatusCodeData));
+    memset(ShmInternalComm, 0, sizeof(struct InternalComm));
+    memset(ShmCcsData, 0, sizeof(struct CcsData));
+    ShmCcsData->V2GMessage_ISO15118_2014.PowerDeliveryRequest.ChargeProgress= 0xFF;
+
+    //Resume CsuComm flags
+    ShmInternalComm->SlaveAddress = SlaveAddress_backup;
+    CSUCOMMDC_TASK_FLAG.matched = matched_backup;
+    Sniffer_Candump(DISABLE);
+    Sniffer_Candump(ENABLE);
+    //memset(ShmSysConfigAndInfo, 0, sizeof(struct SysConfigAndInfo)); //EVCOMM_SYS_INFO.End_Process_inused = FALSE;
+    //EVCOMM_SYS_INFO.End_Process_inused = TRUE;
+    EVCOMM_SYS_INFO.DC_EVSEStatus=EVSE_NotReady;
+    //Update_V2G_Flow_Status(state_backup);
+    //CP_Detection_Pid = 0;
+    //PP_Detection_Pid = 0;
+    //Error_Monitor_Pid = 0;
+ /*  while(CheckConnectorPlugIn() != TRUE)
+   {
+   	sleep(1);
+   }*/
+	free(V2gtpMsgRxBuf);
+	free(V2gtpMsgTxBuf);
+	//DetachShareMemory();
+	Qca7kPowerReset();  //reset QCA7000 /* +++ 20200808, vern, should disconnected PLC connection after session stop ---*/
+    system("cd /root;./reset_soft.sh");
+    while(1)
+    {
+        //wait for CSU configrm
+    }
+}
+
+
+/*===========================================================================
+FUNCTION: Parameters_Init
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Parameters_Init()
+{
+    //Step 0: Generate random number
+    unsigned int value_random;
+    struct timeb time_seed;
+    ftime(&time_seed);
+    srand(time_seed.millitm);
+
+    //Step 1: Init SDP TCP Port
+    value_random = rand();
+    EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active = (unsigned short)(SdpTcpServerPort + (value_random % 10000) + 1);
+    if((EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active <= 49152)||(EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active >= 65535))//49152-65535
+    	EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active=59438;
+    sprintf(buf_log_evcomm,
+            "[Init]TCP Port:OK(%d)",
+            EVCOMM_SYS_INFO.SDP_TCP_Server_Port_active);
+    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+    //Step 2: Init SessionID
+    value_random = rand();
+    memcpy(&EVCOMM_SYS_INFO.SessionID[0], &value_random, 4);
+
+    value_random = rand();
+    memcpy(&EVCOMM_SYS_INFO.SessionID[4], &value_random, 4);
+
+    sprintf(buf_log_evcomm,
+            "[Init]SessionID:OK(%02X%02X%02X%02X%02X%02X%02X%02X)",
+            EVCOMM_SYS_INFO.SessionID[0],
+            EVCOMM_SYS_INFO.SessionID[1],
+            EVCOMM_SYS_INFO.SessionID[2],
+            EVCOMM_SYS_INFO.SessionID[3],
+            EVCOMM_SYS_INFO.SessionID[4],
+            EVCOMM_SYS_INFO.SessionID[5],
+            EVCOMM_SYS_INFO.SessionID[6],
+            EVCOMM_SYS_INFO.SessionID[7]);
+    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+}
+
+#ifdef SUPPORT_TLS_CONNECTION
+SSL_CTX *create_sslcontext()
+{
+    const SSL_METHOD *method;
+    SSL_CTX *ctx;
+    
+    // Support only TLSv1.2
+    method = TLSv1_2_server_method();
+    
+    // Create context
+    ctx = SSL_CTX_new(method);
+    if (!ctx) 
+    {
+    	ERR_print_errors_fp(stderr);	
+        return NULL;
+    }   
+    return ctx;
+}
+
+int configure_sslcertkey_file(SSL_CTX *ctx)
+{
+    SSL_CTX_set_ecdh_auto(ctx, 1);
+    
+    // Load certificate file
+    if (SSL_CTX_use_certificate_file(ctx, "/root/cacert.pem", SSL_FILETYPE_PEM) <= 0) 
+    {
+    	ERR_print_errors_fp(stderr);	
+        return -1;
+    }
+    // Load private key file
+    if (SSL_CTX_use_PrivateKey_file(ctx, "/root/cakey.pem", SSL_FILETYPE_PEM) <= 0 )
+    {
+    	ERR_print_errors_fp(stderr);		
+        return -1;
+    }
+    return 0;
+}
+#endif
+
+/*===========================================================================
+FUNCTION: main
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int main(int argc, char *argv[])
+{
+    unsigned char Rtn;
+
+    //Initialization
+    if(ShareMemory_Init()==0)
+    {
+	system("reboot -f");
+	sleep(5);
+	system("reboot -f");
+    }	
+    memset(ShmSysConfigAndInfo, 0, sizeof(struct SysConfigAndInfo));
+
+    if(RawSock > 0)
+    {
+        close(RawSock);
+    }
+    if(UdpSock > 0)
+    {
+        close(UdpSock);
+    }
+    if(TcpSock > 0)
+    {
+        close(TcpSock);
+    }
+
+    RawSock = UdpSock = TcpSock = -1;
+    Update_V2G_Flow_Status(IDLE);
+
+    SAVE_SYS_LOG_MSG_EVCOMM("---------------------------------------------");
+    SAVE_SYS_LOG_MSG_EVCOMM("--               EVCOMM: START             --");
+    SAVE_SYS_LOG_MSG_EVCOMM("---------------------------------------------\n");
+    
+    //Print Linux Kernel Version
+    sprintf(buf_log_evcomm, "\nLinux Image SHA1: %s\n", LINUX_IMAGE_VERSION);
+    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+    //Print Hardware Version
+    sprintf(buf_log_evcomm, "HW: %s\n", HARDWARE_VERSION);
+    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+    //Print Firmware Version
+    sprintf(buf_log_evcomm, "FW: %s\n", FIRMWARE_VERSION);
+    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+
+    SAVE_SYS_LOG_MSG_EVCOMM("init...");
+
+    //Init V2G TCP/IPv6 packets buffer
+    V2gtpMsgRxBuf = (unsigned char *)malloc(V2GTP_MSG_RX_BUFFER_SIZE);
+    memset(V2gtpMsgRxBuf, 0, V2GTP_MSG_RX_BUFFER_SIZE);
+
+    V2gtpMsgTxBuf = (unsigned char *)malloc(V2GTP_MSG_TX_BUFFER_SIZE);
+    memset(V2gtpMsgTxBuf, 0, V2GTP_MSG_TX_BUFFER_SIZE);
+
+    //Release State E Control
+    SwitchCpStateE(DISABLE);
+    OutputCpPwmDuty(100);
+
+    //start to detect CP pilot state
+    CP_Detection_Pid = 0;
+    CP_Detection();     //fork1
+    SAVE_SYS_LOG_MSG_EVCOMM("[fork1]CP Detection: ON");
+
+    //start to detect errors
+    Error_Monitor();    //fork2
+    SAVE_SYS_LOG_MSG_EVCOMM("[fork2]Error Monitor: ON");
+
+    //CCS connector type
+    sprintf(buf_log_evcomm, "CCS connector type : %s\n",  ShmInternalComm->CCSConnectorType > 0? "CCS2":"CCS1" );
+    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+    
+    //start to detect PP
+    PP_Detection_Pid = 0;
+    #if (PP_PROTECTION_MECHANISM == ENABLE)
+    PP_Detection();
+    SAVE_SYS_LOG_MSG_EVCOMM("[fork3]PP Detection: ON");
+    #else
+    SAVE_SYS_LOG_MSG_EVCOMM("[fork3]PP Detection: OFF");
+    #endif
+
+    //Init communication parameters
+    GetEthMac(QcaInterface, CsuMac);
+
+    AttenProfileCnt = 0;
+    init_appHandEXIDocument(&ccs_handshake);
+
+    //Init Energy transfer mode
+    //[To-Do] Parsing Model Name
+    ShmCcsData->EnergyTransferMode = CCS_ENERGY_TRANSFER_MODE;
+
+    struct ChargingInfoData *ccs;
+    ccs = &ShmSysConfigAndInfo->SysInfo.CcsChargingData[0];
+
+    Parameters_Init();
+    Sniffer_Tcpdump(ENABLE);
+    #if (TCPDUMP_PACKETS_SNIFFER_SWITCH == ENABLE)
+    sleep(1); //wait for tcpdump getting ready
+    #endif
+    
+    #ifdef SUPPORT_TLS_CONNECTION
+    // SSL init
+    //SSL_free (ssl);
+  	//SSL_CTX_free (ctx);
+    SSL_load_error_strings();
+    OpenSSL_add_ssl_algorithms();
+    // Create SSL_CTX
+    ctx = create_sslcontext();
+    if (ctx  == NULL)
+    {	
+		SAVE_SYS_LOG_MSG_EVCOMM("[SSL]create_sslcontext Failed");
+    }
+    else
+    	SAVE_SYS_LOG_MSG_EVCOMM("[SSL]create_sslcontext OK");
+    // Configure cert and key
+    if (configure_sslcertkey_file(ctx) < 0)
+    {	
+		SAVE_SYS_LOG_MSG_EVCOMM("[SSL]configure_sslcertkey_file Failed");
+    }
+    else
+    	SAVE_SYS_LOG_MSG_EVCOMM("[SSL]configure_sslcertkey_file OK");
+    #endif
+    
+    SAVE_SYS_LOG_MSG_EVCOMM("[Init]DONE");
+
+    while(1)
+    {
+        //DEBUG_PRINTF_EVCOMM_DETAIL("\nV2gFlowStatus = %d\n", V2gFlowStatus);
+        //if((ShmInternalComm->ChargingPermission == 0x01) && (CheckConnectorPlugIn() == 1))
+        //if((CheckConnectorPlugIn() == TRUE) && (ShmInternalComm->ChargingPermission == TRUE))
+        //if(ShmInternalComm->ChargingPermission == 0x01)
+        //if(CheckConnectorPlugIn() == TRUE)
+        if (EVCOMM_SYS_INFO.End_Process_inused == FALSE)
+        {
+            if(V2gFlowStatus < SLACC_SDP_UDP_Connection)
+            {
+                SlacComm();
+            }
+            else if(V2gFlowStatus == SLACC_SDP_UDP_Connection)
+            {
+                if(SdpUdpConnected() == 1)
+                {
+                    Update_V2G_Flow_Status(SLACC_SDP_TCP_Connection);
+                    continue;
+                }
+                SlacComm(); //TC_SECC_VTB_CmSlacMatch_004
+                ftime(&SeqEndTime);
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > TT_match_join)
+                {
+                    sprintf(buf_log_evcomm,
+                            "Wait SLACC_SDP_UDP_Connection Timeout - TT_match_join (%.02lf of %d ms)\n",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            TT_match_join);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+                    //Update_ShmStatusCode(); //[To-Do] to be implemented
+                    //CCS_SECC_TIMEOUT_SLACC_SDP_UDP_TT_match_join (023823)
+                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                    ShmStatusCodeData->PresentStatusCode[0][4] = 2;
+                    ShmStatusCodeData->PresentStatusCode[0][5] = 3;
+                    CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+                    Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
+                }
+            }
+            else if(V2gFlowStatus == SLACC_SDP_TCP_Connection)
+            {
+                if((TcpAcceptFd = V2gTcpConnected()) > 0)
+                {
+                    Update_V2G_Flow_Status(SupportedAppProtocolRequest);
+                    ftime(&EVCOMM_SYS_INFO.V2G_SECC_Sequence_Timer_Start);
+                    continue;
+                }
+                SlacComm();
+                ftime(&SeqEndTime);
+
+                if(DiffTimeb(SeqStartTime, SeqEndTime) > TT_match_join)
+                {
+                    sprintf(buf_log_evcomm,
+                            "Wait SLACC_SDP_TCP_Connection Timeout - TT_match_join (%.02lf / %d ms)",
+                            DiffTimeb(SeqStartTime, SeqEndTime),
+                            TT_match_join);
+                    SAVE_SYS_LOG_MSG_EVCOMM(buf_log_evcomm);
+                    Update_V2G_Flow_Status(Sequence_Timeout);
+                    //Update_ShmStatusCode(); //[To-Do] to be implemented
+                    //CCS_SECC_TIMEOUT_SLACC_SDP_TCP_TT_match_join (023824)
+                    ShmStatusCodeData->PresentStatusCode[0][0] = 0;
+                    ShmStatusCodeData->PresentStatusCode[0][1] = 2;
+                    ShmStatusCodeData->PresentStatusCode[0][2] = 3;
+                    ShmStatusCodeData->PresentStatusCode[0][3] = 8;
+                    ShmStatusCodeData->PresentStatusCode[0][4] = 2;
+                    ShmStatusCodeData->PresentStatusCode[0][5] = 4;
+                    CSUCOMMDC_TASK_FLAG.EV_Stop_Type_Emergency = TRUE;
+                    Proc_EVStopRes(ShmInternalComm->FD_CAN_Socket);
+                }
+            }
+            else if(V2gFlowStatus <= SessionStopResponse)
+            {
+                if (V2gComm(TcpAcceptFd) < 0)
+                {
+                    //error occours
+                }
+                if(V2gFlowStatus == SessionStopResponse)
+                {
+                	 if(RawSock > 0)
+				    {
+				        close(RawSock);
+				    }
+				    if(UdpSock > 0)
+				    {
+				        close(UdpSock);
+				    }
+				    if(TcpSock > 0)
+				    {
+				        close(TcpSock);
+				        close(TcpAcceptFd);
+				    }
+				    RawSock = UdpSock = TcpSock = TcpAcceptFd = -1;
+                	#ifdef SUPPORT_TLS_CONNECTION
+					if(EvSecurity == 0)//support security
+				    {	
+				    	SSL_shutdown(ssl);
+						SSL_free (ssl);
+				  	}
+				  	SSL_CTX_free (ctx);
+				  #endif
+                }	
+            }
+            else if (V2gFlowStatus >= Performance_Timeout)
+            {
+                //End_Process
+                 if(RawSock > 0)
+			    {
+			        close(RawSock);
+			    }
+			    if(UdpSock > 0)
+			    {
+			        close(UdpSock);
+			    }
+			    if(TcpSock > 0)
+			    {
+			        close(TcpSock);
+			        close(TcpAcceptFd);
+			    }
+			    RawSock = UdpSock = TcpSock = TcpAcceptFd = -1;
+                #ifdef SUPPORT_TLS_CONNECTION
+				if(EvSecurity == 0)//support security
+			    {	
+			    	SSL_shutdown(ssl);
+					SSL_free (ssl);
+			  	}
+			  	SSL_CTX_free (ctx);
+			  	#endif
+            }
+            else
+            {
+                //null
+            }
+        }
+      //  printf("V2gFlowStatus=%d, socket=%d,%d,%d\n",V2gFlowStatus,RawSock,UdpSock,TcpSock);
+    } //while
+}//main while

EVSE/Projects/AW-CCS/Apps/CCS/Module_CCS.h → EVSE/Projects/AW-CCS/Apps/CCS/SeccComm.h

@@ -1,234 +1,238 @@
-/*
- * Module_CCS.h
- *
- *  Created on: 2020¦~3¤ë16¤é
- *      Author: foluswen
- */
-
-#ifndef MODULE_CCS_H_
-#define MODULE_CCS_H_
-
-#include    <sys/types.h>
-#include    <sys/stat.h>
-#include 	<sys/time.h>
-#include 	<sys/timeb.h>
-#include 	<sys/ipc.h>
-#include 	<sys/shm.h>
-#include 	<sys/mman.h>
-#include 	<sys/socket.h>
-#include 	<netinet/in.h>
-#include 	<net/if.h>
-#include 	<net/ethernet.h>
-#include 	<linux/if_packet.h>
-
-#include 	<unistd.h>
-#include 	<stdarg.h>
-#include    <stdio.h>
-#include    <stdlib.h>
-#include    <unistd.h>
-#include    <fcntl.h>
-#include    <errno.h>
-#include 	<errno.h>
-#include 	<string.h>
-#include	<time.h>
-#include	<ctype.h>
-
-#include 	"SystemLogMessage.h"
-#include 	"NidNmk.h"
-#include	"v2g/api/api.h"
-#include	"v2g/transport/v2gtp.h"
-
-//#define TEST_WITH_ETH0
-
-#define	QcaInterface						"eth1"
-#define SupportBcbToggle
-#define	SdpUdpServerPort					15118
-#define	SdpTcpServerPort					55000		//49152-65535
-#define	IPV6_LINK_LOCAL_PREFIX				0xFE80
-#define V2GTP_MSG_RX_BUFFER_SIZE            (64*1024)   //65,536 = 65.5KB
-#define V2GTP_MSG_TX_BUFFER_SIZE            (64*1024)   //65,536 = 65.5KB
-#define V2GTP_MSG_HEADER_LENGTH             8           //8 Bytes
-
-/***********************************************/
-/*********** Ethernet Type ********************/
-/**********************************************/
-#define EtherType_HomePlug					0x88E1
-
-/***********************************************/
-/*** MMTYPE (Management Message Type) **/
-/**********************************************/
-#define MMTYPE_CM_SET_KEY_REQ					0x6008
-#define MMTYPE_CM_SET_KEY_CNF					0x6009
-#define MMTYPE_CM_SLAC_PARM_REQ					0x6064
-#define MMTYPE_CM_SLAC_PARM_CNF					0x6065
-#define MMTYPE_CM_START_ATTEN_CHAR_IND			0x606A
-#define MMTYPE_CM_MNBC_SOUND_IND				0x6076
-#define MMTYPE_CM_ATTEN_CHAR_IND				0x606E
-#define MMTYPE_CM_ATTEN_CHAR_RSP				0x606F
-#define MMTYPE_CM_VALIDATE_REQ					0x6078
-#define MMTYPE_CM_VALIDATE_CNF					0x6079
-#define MMTYPE_CM_SLAC_MATCH_REQ				0x607C
-#define MMTYPE_CM_SLAC_MATCH_CNF				0x607D
-#define MMTYPE_CM_ATTEN_PROFILE_IND				0x6086
-//following are the vendor specific type
-#define MMTYPE_VENDOR_VS_HOST_ACTION	 		0xA062		//Embedded Host Action Requested Indication MME
-#define MMTYPE_VENDOR_ATTEN_CHAR				0xA14E		//Attenuation Characteristics MME (VS_ATTEN_CHAR)
-#define MMTYPE_VENDOR_VS_NW_INFO				0xA038		//Network Info MME
-#define MMTYPE_VENDOR_VS_NW_INFO_CNF			0xA039		//Network Info MME
-#define MMTYPE_VENDOR_VS_PL_LNK_STATUS       	0xA0B8      //Powerline Link Status /*+++ 20200808, vern, for PLC connection monitoring ---*/
-#define MMTYPE_VENDOR_VS_PL_LNK_STATUS_CNF    	0xA0B9      //Powerline Link Status /*+++ 20200808, vern, for PLC connection monitoring ---*/
-
-/***********************************************/
-/************** V2GTP Payload Type ************/
-/**********************************************/
-#define V2GTP_PAYLOAD_TYPE_SDP_REQUEST		0x9000		//SDP request message
-#define V2GTP_PAYLOAD_TYPE_SDP_RESPONSE		0x9001		//SDP response message
-#define V2GTP_PAYLOAD_TYPE_EXI_MSG			0x8001		//EXI encoded V2G Message
-//Payload
-#define SDP_PAYLOAD_SECURITY_TLS			0x00		//0x00 = secured with TLS
-#define SDP_PAYLOAD_SECURITY_NONE			0x10		//0x10 = No transport layer security
-#define SDP_PAYLOAD_TRANS_PROTOCOL_TCP		0x00		//0x00= TCP
-#define SDP_PAYLOAD_TRANS_PROTOCOL_UDP		0x10		//0x10 = reserved for UDP
-
-/***********************************************/
-/****** Timing and constant values **********/
-/*********** [2015] ISO 15118_3 ***************/
-/**********************************************/
-#define TT_EVSE_match_MNBC                  (600+400)   //unit: 1ms (default: 600ms)
-#define C_EV_match_MNBC                     0x0A
-#define TT_EVSE_SLAC_init                   50          //unit: sec.
-#define TT_match_sequence                   400         //unit: ms
-#define TP_match_response                   100         //unit: ms, General performance time for a response to a request
-#define TT_match_response                   (200*3)     //unit: ms, Time that the EV/EVSE shall wait for a response from the EVSE/EV
-#define TP_EV_batch_msg_interval            (50*3)      //unit: ms
-#define TT_EVSE_match_session               10000       //unit: ms
-#define TT_match_join                       (12000*2)   //unit: ms
-
-#define V2G_SECC_ReadyToCharge_Performance_Time             148000  //unit: ms (148 sec)
-#define V2G_SECC_CommunicationSetup_Performance_Time        18000   //unit: ms (18 sec)
-#define V2G_SECC_ChargingParameter_Performance_Time         60000   //unit: ms (60 sec)
-//#define V2G_SECC_ChargingParameter_Performance_Time       120000   //unit: ms (120 sec)
-#define V2G_SECC_CableCheck_Performance_Time                38000   //unit: ms (38 sec)
-//#define V2G_SECC_CableCheck_Performance_Time              60000   //unit: ms (extend to 60 sec)
-//#define V2G_SECC_PreCharge_Performance_Time                 5000    //unit: ms (5 sec)
-#define V2G_SECC_PreCharge_Performance_Time                 10000   //unit: ms (extend to 10 sec)
-#define V2G_SECC_WeldingDetection_Performance_Time          20000   //unit: ms (20 sec)
-#define V2G_SECC_CPState_Detection_Timeout                  1500    //unit: ms (1.5 sec)
-#define V2G_SECC_CPOscillator_Retain_Timeout                1500    //unit: ms (1.5 sec)
-
-#define V2G_EVCC_Msg_Timeout_SupportedAppProtocolReq        2000    //unit: ms (1.5 sec)
-#define V2G_EVCC_Msg_Timeout_SessionSetupReq                2000    //unit: ms (1.5 sec)
-#define V2G_EVCC_Msg_Timeout_ServiceDiscoveryReq            2000
-#define V2G_EVCC_Msg_Timeout_ServicePaymentSelectionReq     2000
-#define V2G_EVCC_Msg_Timeout_ContractAuthenticationReq      2000
-#define V2G_EVCC_Msg_Timeout_ChargeParameterDiscoveryReq    2000
-#define V2G_EVCC_Msg_Timeout_PowerDeliveryReq               2000
-#define V2G_EVCC_Msg_Timeout_CableCheckReq                  2000
-#define V2G_EVCC_Msg_Timeout_PreChargeReq                   2000
-#define V2G_EVCC_Msg_Timeout_CurrentDemandReq               25
-#define V2G_EVCC_Msg_Timeout_WeldingDetectionReq            2000
-#define V2G_EVCC_Msg_Timeout_SessionStopReq                 2000
-#define V2G_SECC_Sequence_Timeout                           60000   //unit: ms (default: 60000, i.e. 60 sec)
-#define V2G_SECC_QCA7000_GET_MAC_ADDR_REQ_RETRY_PERIOD      3000    //unit: ms (default: 3000, i.e. 3 sec)
-#define V2G_SECC_QCA7000_SEND_SET_KEY_PERIOD                2000    //unit: ms (default: 2000, i.e. 2 sec)
-#define V2G_SECC_QCA7000_COMM_TIMEOUT                       10000   //unit: ms (default: 10000, i.e. 20 sec)
-//[To-Do] to be continued. (DIN 70121, Table 75)
-
-#define V2G_SECC_CP_Timeout_CableCheck                      2000    //unit: ms (default: 2 sec)
-
-#define DIN_SPEC_70121_2012_VersionNumberMajor              2
-#define DIN_SPEC_70121_2012_VersionNumberMinor              0
-#define ISO1_15118_2013_VersionNumberMajor                  2
-#define ISO1_15118_2013_VersionNumberMinor                  0
-#define ISO2_15118_2018_VersionNumberMajor                  2
-#define ISO2_15118_2018_VersionNumberMinor                  0
-
-
-//Protocol format : Message ID
-#define CAN_CMD_ADDRESS_REQUEST                     0x00000100
-#define CAN_CMD_ADDRESS_ASSIGN                      0x00000200
-#define CAN_CMD_EV_BOARD_STATUS                     0x00000300
-#define CAN_CMD_GET_FW_VERSION                      0x00000400
-#define CAN_CMD_GET_HW_VERSION                      0x00000500
-#define CAN_CMD_CHARGING_PERMISSION                 0x00000600
-#define CAN_CMD_EVSE_OUTPUT_STATUS_ANNOUNCEMENT     0x00000700
-#define CAN_CMD_EVSE_CAPACITY_ANNOUNCEMENT          0x00000800
-#define CAN_CMD_GET_EV_TARGET_INFO                  0x00000900
-#define CAN_CMD_GET_EV_BATTERY_INFO                 0x00000A00
-#define CAN_CMD_EV_STOP_EVENT                       0x00000B00
-#define CAN_CMD_EVSE_STOP_EVENT                     0x00000C00
-#define CAN_CMD_GET_MISC_INFO                       0x00000D00
-#define CAN_CMD_DOWNLOAD_REQUEST                    0x00000E00
-#define CAN_CMD_START_BLOCK_TRANSFER                0x00000F00
-#define CAN_CMD_DATA_TRANSFER                       0x00001000
-#define CAN_CMD_DOWNLOAD_FINISH                     0x00001100
-#define CAN_CMD_ISOLATION_STATUS                    0x00001200
-#define CAN_CMD_CCS_CONNECTOR_INFO                  0x00001300
-#define CAN_CMD_RTC_INFO                            0x00001400
-#define CAN_CMD_EVSE_PRECHARGE_INFO                 0x00001500
-#define CAN_CMD_EVCCID_REQUEST                      0x00001600
-#define CAN_CMD_PCBA_TEST                           0x0000AA00
-
-/***********************************************/
-/*************** Structure *********************/
-/**********************************************/
-struct MmeHeader
-{
-    unsigned char ODA[6];           //Original Destination Address
-    unsigned char OSA[6];           //Original source Address
-    //unsigned int VLAN Tag;        //IEEE802.1Q VLAN Tag (optional)
-    unsigned short MTYPE;           //Ethernet Type for HomePlug, should be 0x88E1
-    unsigned char MMV;              //Management Message Version
-    unsigned short MMTYPE;          //Management Message Type
-    unsigned char FMI[2];           //Fragmentation Management Information, Fragmentation Message Sequence Number
-    unsigned char MMENTRY[256];     //Management Message Entry Data
-} __attribute__((packed));
-
-//Qualcomm Atheros Vendor Specific MME Format
-struct QcaVendorMmeHeader
-{
-    unsigned char ODA[6];           //Original Destination Address
-    unsigned char OSA[6];           //Original source Address
-    //unsigned int VLAN Tag;        //IEEE802.1Q VLAN Tag (optional)
-    unsigned short MTYPE;           //Ethernet Type for HomePlug, should be 0x88E1
-    unsigned char MMV;              //Management Message Version
-    unsigned short MMTYPE;          //Management Message Type
-    unsigned char OUI[3];           //Fragmentation Management Information, Fragmentation Message Sequence Number
-    unsigned char MBODY[1024];      //Management Message Entry Data
-} __attribute__((packed));
-
-struct V2gtpHeader                          //8 Bytes (see Figure 25 in DIN 70121)
-{
-    unsigned char ProtocolVersion;          //0x01: V2GTP version 1, 0x00, 0x02-0xFF reserved
-    unsigned char InverseProtocolVersion;   //Equals the <Protocol_Version> XOR 0xFF, 0xFE: V2GTP Version 1
-    unsigned short PayloadType;             //0x8001:	EXI encoded V2G Message,
-                                            //0x9000:	SDP request message,
-                                            //0x9001:	SDP response message,
-                                            //0xA000 - 0xFFFF:	Manufacturer specific use
-    unsigned int PayloadLength;             //excluding the generic V2GTP header byte
-} __attribute__((packed));
-
-typedef struct MODULE_INFO
-{
-	struct timeb	startTime[10];
-	uint8_t 	    QCA7K_SetKey_status;
-}Module_Info;
-
-int Proc_din_supportedAppProtocolRes(int AcceptFd);
-void SHM_Init_din_ChargeParameterDiscoveryRes(struct CcsData *shm_ccs);
-void SHM_Init_din_CableCheckRes(struct CcsData *shm_ccs);
-void SHM_Init_din_PreChargeRes(struct CcsData *shm_ccs);
-void SHM_Init_din_PowerDeliveryRes(struct CcsData *shm_ccs);
-void SHM_Init_din_CurrentDemandRes(struct CcsData *shm_ccs);
-void SHM_Init_din_WeldingDetectionRes(struct CcsData *shm_ccs);
-void SHM_Init_din_SessionStopRes(struct CcsData *shm_ccs);
-int OutputCpPwmDuty(unsigned char Duty);
-void Check_EVErrorCode(int code);
-unsigned char Check_V2G_Flow_Status_pre();
-int End_Process();
-int SdpUdpConnected();
-int V2gTcpConnected();
-
-
-
-#endif /* MODULE_CCS_H_ */
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                EVComm.h
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+   =============================================================================*/
+
+#ifndef EVCOMM_H_
+#define EVCOMM_H_
+
+#if FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == ENABLE
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_EVCOMM_SWITCH          ENABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_EVCOMM_SHOW                DISABLE     //DISABLE, ENABLE
+#define DEBUG_PRINTF_EVCOMM_BRIEF_SHOW          DISABLE      //DISABLE, ENABLE
+#define DEBUG_PRINTF_EVCOMM_DETAIL_SHOW         DISABLE      //DISABLE, ENABLE
+#define DEBUG_PRINTF_EVCOMM_SYSTEM_LOG_SHOW     DISABLE      //ENABLE, DISABLE
+#else //debug mode
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_EVCOMM_SWITCH          ENABLE      //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_EVCOMM_SHOW                ENABLE     //DISABLE, ENABLE
+#define DEBUG_PRINTF_EVCOMM_BRIEF_SHOW          DISABLE      //DISABLE, ENABLE
+#define DEBUG_PRINTF_EVCOMM_DETAIL_SHOW         DISABLE      //DISABLE, ENABLE
+#define DEBUG_PRINTF_EVCOMM_SYSTEM_LOG_SHOW     ENABLE      //ENABLE, DISABLE
+#endif
+
+//ADC Channels (0, 1, 2, 3)
+#define ADC_CHANNEL_AIN0_NTC1   0
+#define ADC_CHANNEL_AIN1_NTC2   1
+#define ADC_CHANNEL_AIN2_PP     2
+#define ADC_CHANNEL_AIN3_CP     3
+
+#define QcaInterface                        "eth1"
+#define SUPPORT_BCB_TOGGLE_FUNCTION         ENABLE      //BCB
+#define SdpUdpServerPort                    15118
+//#define SdpTcpServerPort                    59438       //49152-65535 (default:59438)
+#define SdpTcpServerPort                    50000       //49152-65535 (base: 50000)
+#define IPV6_LINK_LOCAL_PREFIX              0xFE80
+
+//[Joseph] These Tx/Rx buffer size should owns 8 + 4294967295 = 4,294,967,303 Bytes = 4.GB as maximum.
+//(according to Figure 24 in DIN 70121)
+#define V2GTP_MSG_RX_BUFFER_SIZE           (64*1024)   //65,536 = 65.5KB
+#define V2GTP_MSG_TX_BUFFER_SIZE           (64*1024)   //65,536 = 65.5KB
+#define V2GTP_MSG_HEADER_LENGTH             8           //8 Bytes
+
+/***********************************************/
+/*********** Ethernet Type ********************/
+/**********************************************/
+#define EtherType_HomePlug                  0x88E1
+
+/***********************************************/
+/*** MMTYPE (Management Message Type) **/
+/**********************************************/
+#define MMTYPE_CM_SET_KEY_REQ               0x6008
+#define MMTYPE_CM_SET_KEY_CNF               0x6009
+#define MMTYPE_CM_AMP_MAP_REQ             0x601C
+#define MMTYPE_CM_AMP_MAP_CNF             0x601D
+#define MMTYPE_CM_SLAC_PARM_REQ             0x6064
+#define MMTYPE_CM_SLAC_PARM_CNF             0x6065
+#define MMTYPE_CM_START_ATTEN_CHAR_IND      0x606A
+#define MMTYPE_CM_MNBC_SOUND_IND            0x6076
+#define MMTYPE_CM_ATTEN_CHAR_IND             0x606E
+#define MMTYPE_CM_ATTEN_CHAR_RSP            0x606F
+#define MMTYPE_CM_VALIDATE_REQ              0x6078
+#define MMTYPE_CM_VALIDATE_CNF              0x6079
+#define MMTYPE_CM_SLAC_MATCH_REQ            0x607C
+#define MMTYPE_CM_SLAC_MATCH_CNF            0x607D
+#define MMTYPE_CM_ATTEN_PROFILE_IND         0x6086
+//following are the vendor specific type
+#define MMTYPE_VENDOR_VS_HOST_ACTION        0xA062      //Embedded Host Action Requested Indication MME
+#define MMTYPE_VENDOR_ATTEN_CHAR            0xA14E      //Attenuation Characteristics MME (VS_ATTEN_CHAR)
+#define MMTYPE_VENDOR_VS_NW_INFO            0xA038      //Network Info MME
+#define MMTYPE_VENDOR_VS_NW_INFO_CNF        0xA039      //Network Info MME
+#define MMTYPE_VENDOR_VS_PL_LNK_STATUS        0xA0B8      //Powerline Link Status /*+++ 20200808, vern, for PLC connection monitoring ---*/
+#define MMTYPE_VENDOR_VS_PL_LNK_STATUS_CNF        0xA0B9      //Powerline Link Status /*+++ 20200808, vern, for PLC connection monitoring ---*/
+
+/***********************************************/
+/************** V2GTP Payload Type ************/
+/**********************************************/
+//Reference:
+//Table 16 — "Overview on V2GTP payload types," page 79, DIN SPEC 70121:2014-12
+#define V2GTP_PAYLOAD_TYPE_SDP_REQUEST      0x9000      //SDP request message
+#define V2GTP_PAYLOAD_TYPE_SDP_RESPONSE     0x9001      //SDP response message
+#define V2GTP_PAYLOAD_TYPE_EXI_MSG          0x8001      //EXI encoded V2G Message
+//Payload
+#define SDP_PAYLOAD_SECURITY_TLS            0x00        //0x00 = secured with TLS
+#define SDP_PAYLOAD_SECURITY_NONE           0x10        //0x10 = No transport layer security
+#define SDP_PAYLOAD_TRANS_PROTOCOL_TCP      0x00        //0x00= TCP
+#define SDP_PAYLOAD_TRANS_PROTOCOL_UDP      0x10        //0x10 = reserved for UDP
+/***********************************************/
+/****** Timing and constant values **********/
+/*********** [2015] ISO 15118_3 ***************/
+/**********************************************/
+//#define TT_EVSE_match_MNBC                  600         //unit: 1ms (default: 600ms)
+#define TT_EVSE_match_MNBC                  (600+400)   //unit: 1ms (default: 600ms)
+#define C_EV_match_MNBC                     0x0A
+#define TT_EVSE_SLAC_init                   50          //unit: sec.
+#define TT_match_sequence                   400         //unit: ms
+#define TP_match_response                   100         //unit: ms, General performance time for a response to a request
+#define TT_match_response                   (200*3)     //unit: ms, Time that the EV/EVSE shall wait for a response from the EVSE/EV
+#define TP_EV_batch_msg_interval            (50*3)      //unit: ms
+#define TT_EVSE_match_session               10000       //unit: ms
+#define TT_match_join                       (12000*2)   //unit: ms
+
+#define V2G_SECC_ReadyToCharge_Performance_Time             148000  //unit: ms (148 sec)
+#define V2G_SECC_CommunicationSetup_Performance_Time        18000   //unit: ms (18 sec)
+#define V2G_SECC_ChargingParameter_Performance_Time         60000   //unit: ms (60 sec)
+//#define V2G_SECC_ChargingParameter_Performance_Time       120000   //unit: ms (120 sec)
+#define V2G_SECC_CableCheck_Performance_Time                38000   //unit: ms (38 sec)
+//#define V2G_SECC_CableCheck_Performance_Time              60000   //unit: ms (extend to 60 sec)
+//#define V2G_SECC_PreCharge_Performance_Time                 5000    //unit: ms (5 sec)
+#define V2G_SECC_PreCharge_Performance_Time                 10000   //unit: ms (extend to 10 sec)
+#define V2G_SECC_WeldingDetection_Performance_Time          20000   //unit: ms (20 sec)
+#define V2G_SECC_CPState_Detection_Timeout                  1500    //unit: ms (1.5 sec)
+#define V2G_SECC_CPOscillator_Retain_Timeout                1500    //unit: ms (1.5 sec)
+
+#define V2G_EVCC_Msg_Timeout_SupportedAppProtocolReq        2000    //unit: ms (1.5 sec)
+#define V2G_EVCC_Msg_Timeout_SessionSetupReq                2000    //unit: ms (1.5 sec)
+#define V2G_EVCC_Msg_Timeout_ServiceDiscoveryReq            2000
+#define V2G_EVCC_Msg_Timeout_ServicePaymentSelectionReq     2000
+#define V2G_EVCC_Msg_Timeout_ContractAuthenticationReq      2000
+#define V2G_EVCC_Msg_Timeout_ChargeParameterDiscoveryReq    2000
+#define V2G_EVCC_Msg_Timeout_PowerDeliveryReq               2000
+#define V2G_EVCC_Msg_Timeout_CableCheckReq                  2000
+#define V2G_EVCC_Msg_Timeout_PreChargeReq                   2000
+#define V2G_EVCC_Msg_Timeout_CurrentDemandReq               25
+#define V2G_EVCC_Msg_Timeout_WeldingDetectionReq            2000
+#define V2G_EVCC_Msg_Timeout_SessionStopReq                 2000
+#define V2G_SECC_Sequence_Timeout                           60000   //unit: ms (default: 60000, i.e. 60 sec)
+#define V2G_SECC_QCA7000_GET_MAC_ADDR_REQ_RETRY_PERIOD      3000    //unit: ms (default: 3000, i.e. 3 sec)
+#define V2G_SECC_QCA7000_SEND_SET_KEY_PERIOD                2000    //unit: ms (default: 2000, i.e. 2 sec)
+#define V2G_SECC_QCA7000_COMM_TIMEOUT                       10000   //unit: ms (default: 10000, i.e. 20 sec)
+//[To-Do] to be continued. (DIN 70121, Table 75)
+
+#define V2G_SECC_CP_Timeout_CableCheck                      2000    //unit: ms (default: 2 sec)
+
+#define DIN_SPEC_70121_2012_VersionNumberMajor              2
+#define DIN_SPEC_70121_2012_VersionNumberMinor              0
+#define ISO1_15118_2013_VersionNumberMajor                  2
+#define ISO1_15118_2013_VersionNumberMinor                  0
+#define ISO2_15118_2018_VersionNumberMajor                  3
+#define ISO2_15118_2018_VersionNumberMinor                  0
+
+/***********************************************/
+/*************** Structure *********************/
+/**********************************************/
+struct MmeHeader
+{
+    unsigned char ODA[6];           //Original Destination Address
+    unsigned char OSA[6];           //Original source Address
+    //unsigned int VLAN Tag;        //IEEE802.1Q VLAN Tag (optional)
+    unsigned short MTYPE;           //Ethernet Type for HomePlug, should be 0x88E1
+    unsigned char MMV;              //Management Message Version
+    unsigned short MMTYPE;          //Management Message Type
+    unsigned char FMI[2];           //Fragmentation Management Information, Fragmentation Message Sequence Number
+    unsigned char MMENTRY[256];     //Management Message Entry Data
+} __attribute__((packed));
+
+//Qualcomm Atheros Vendor Specific MME Format
+struct QcaVendorMmeHeader
+{
+    unsigned char ODA[6];           //Original Destination Address
+    unsigned char OSA[6];           //Original source Address
+    //unsigned int VLAN Tag;        //IEEE802.1Q VLAN Tag (optional)
+    unsigned short MTYPE;           //Ethernet Type for HomePlug, should be 0x88E1
+    unsigned char MMV;              //Management Message Version
+    unsigned short MMTYPE;          //Management Message Type
+    unsigned char OUI[3];           //Fragmentation Management Information, Fragmentation Message Sequence Number
+    unsigned char MBODY[1024];      //Management Message Entry Data
+} __attribute__((packed));
+
+struct V2gtpHeader                          //8 Bytes (see Figure 25 in DIN 70121)
+{
+    unsigned char ProtocolVersion;          //0x01: V2GTP version 1, 0x00, 0x02-0xFF reserved
+    unsigned char InverseProtocolVersion;   //Equals the <Protocol_Version> XOR 0xFF, 0xFE: V2GTP Version 1
+    unsigned short PayloadType;             //0x8001:	EXI encoded V2G Message,
+                                            //0x9000:	SDP request message,
+                                            //0x9001:	SDP response message,
+                                            //0xA000 - 0xFFFF:	Manufacturer specific use
+    unsigned int PayloadLength;             //excluding the generic V2GTP header byte
+} __attribute__((packed));
+
+int Proc_din_supportedAppProtocolRes(int AcceptFd);
+void SHM_Init_din_ChargeParameterDiscoveryRes(struct CcsData *shm_ccs);
+void SHM_Init_din_CableCheckRes(struct CcsData *shm_ccs);
+void SHM_Init_din_PreChargeRes(struct CcsData *shm_ccs);
+void SHM_Init_din_PowerDeliveryRes(struct CcsData *shm_ccs);
+void SHM_Init_din_CurrentDemandRes(struct CcsData *shm_ccs);
+void SHM_Init_din_WeldingDetectionRes(struct CcsData *shm_ccs);
+void SHM_Init_din_SessionStopRes(struct CcsData *shm_ccs);
+int OutputCpPwmDuty(unsigned char Duty);
+void Check_EVErrorCode(int code);
+unsigned char Check_V2G_Flow_Status_pre();
+int End_Process();
+int SdpUdpConnected();
+int V2gTcpConnected();
+
+//System Log
+#if SAVE_SYS_LOG_MSG_EVCOMM_SWITCH == ENABLE
+    #define SAVE_SYS_LOG_MSG_EVCOMM     StoreLogMsg2
+#else
+    #define SAVE_SYS_LOG_MSG_EVCOMM(...)
+#endif
+
+//Debug Message
+#if DEBUG_PRINTF_EVCOMM_SHOW == ENABLE
+    //Brief Messages
+    #if DEBUG_PRINTF_EVCOMM_BRIEF_SHOW == ENABLE
+        #define DEBUG_PRINTF_EVCOMM_BRIEF      printf
+    #else
+        #define DEBUG_PRINTF_EVCOMM_BRIEF(...)
+    #endif
+
+    //Detail Messages
+    #if DEBUG_PRINTF_EVCOMM_DETAIL_SHOW == ENABLE
+        #define DEBUG_PRINTF_EVCOMM_DETAIL     printf
+    #else
+        #define DEBUG_PRINTF_EVCOMM_DETAIL(...)
+    #endif
+
+    //System Log Messages
+    #if DEBUG_PRINTF_EVCOMM_SYSTEM_LOG_SHOW == ENABLE
+        #define DEBUG_PRINTF_EVCOMM_SYSTEM_LOG    printf
+    #else
+        #define DEBUG_PRINTF_EVCOMM_SYSTEM_LOG(...)
+    #endif
+#else
+    #define DEBUG_PRINTF_EVCOMM_BRIEF(...)
+    #define DEBUG_PRINTF_EVCOMM_DETAIL(...)
+    #define DEBUG_PRINTF_EVCOMM_SYSTEM_LOG(...)
+#endif
+
+#endif

EVSE/Projects/AW-CCS/Apps/CCS/SystemLogMessage.c

@@ -1,69 +0,0 @@
-/*
- * Module_CCS.c
- *
- *  Created on: 2020/03/16
- *      Author: foluswen
- */
-#include 	<sys/time.h>
-#include 	<sys/timeb.h>
-#include    <sys/types.h>
-#include    <sys/stat.h>
-#include 	<sys/types.h>
-#include 	<sys/ioctl.h>
-#include 	<sys/socket.h>
-#include 	<sys/ipc.h>
-#include 	<sys/shm.h>
-#include 	<sys/shm.h>
-#include 	<sys/mman.h>
-#include 	<linux/wireless.h>
-#include 	<arpa/inet.h>
-#include 	<netinet/in.h>
-
-#include 	<unistd.h>
-#include 	<stdarg.h>
-#include    <stdio.h>
-#include    <stdlib.h>
-#include    <unistd.h>
-#include    <fcntl.h>
-#include    <termios.h>
-#include    <errno.h>
-#include 	<errno.h>
-#include 	<string.h>
-#include	<time.h>
-#include	<ctype.h>
-#include 	<ifaddrs.h>
-#include	"SystemLogMessage.h"
-
-int StoreLogMsg(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_SystemLog",
-			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);
-
-#ifdef SystemLogMessage
-	system((const char*)Buf);
-#endif
-
-#ifdef ConsloePrintLog
-	printf("[%04d.%02d.%02d %02d:%02d:%02d.%03ld]%s", 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);
-#endif
-
-	return rc;
-}

EVSE/Projects/AW-CCS/Apps/CCS/SystemLogMessage.h

@@ -1,37 +0,0 @@
-/*
- * Module_CCS.c
- *
- *  Created on: 2020/03/16
- *      Author: foluswen
- */
-#ifndef SystemLogMessage_H
-#define SystemLogMessage_H
-
-#define SystemLogMessage            //for engineer to do analysis
-//#define ConsloePrintLog
-
-#define SAVE_SYS_LOG_MSG_EVCOMM
-//#define DEBUG_PRINTF_EVCOMM_DETAIL_SHOW
-
-// Normal debug Message
-#ifdef SAVE_SYS_LOG_MSG_EVCOMM
-	#define DEBUG_INFO(format, args...) StoreLogMsg("[%s:%d][%s][Info] "format, (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__), __LINE__, __FUNCTION__, ##args)
-	#define DEBUG_WARN(format, args...) StoreLogMsg("[%s:%d][%s][Warn] "format, (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__), __LINE__, __FUNCTION__, ##args)
-	#define DEBUG_ERROR(format, args...) StoreLogMsg("[%s:%d][%s][Error] "format, (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__), __LINE__, __FUNCTION__, ##args)
-#else
-    #define DEBUG_INFO(...)
-	#define DEBUG_WARN(...)
-	#define DEBUG_ERROR(...)
-#endif
-
-// Detail debug Message, will effect SLAC if enable
-#ifdef DEBUG_PRINTF_EVCOMM_DETAIL_SHOW
-	#define DEBUG_PRINTF_EVCOMM_DETAIL(format, args...) StoreLogMsg("[%s:%d][%s][Detail] "format, (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__), __LINE__, __FUNCTION__, ##args)
-#else
-	#define DEBUG_PRINTF_EVCOMM_DETAIL(...)
-#endif
-
-
-int StoreLogMsg(const char *fmt, ...);
-
-#endif

EVSE/Projects/AW-CCS/Apps/CCS/UpdateRootfs.c

@@ -0,0 +1,86 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                              UpdateRootfs.c
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+#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 "define.h"
+#include "UpdateRootfs.h"
+
+int main(int argc, char *argv[])
+{
+    unsigned int MaxLen = 25 * 1024 * 1024, ImageLen = 0;
+    unsigned char *ptr;
+    int fd, wrd;
+
+    ptr = malloc(MaxLen);
+
+    if(ptr == NULL)
+    {
+        printf("UpdateRootfs NG - can not malloc\n");
+        return 0;
+    }
+
+    memset(ptr, 0xFF, MaxLen);
+
+    fd = open(argv[1], O_RDONLY);
+
+    if(fd < 0)
+    {
+        printf("UpdateRootfs NG - can not open rootfs\n");
+        free(ptr);
+        return 0;
+    }
+
+    ImageLen = read(fd, ptr, MaxLen);
+    close(fd);
+    printf("ImageLen=0x%x\n", ImageLen);
+
+    if(ImageLen < (24 * 1024 * 1024))
+    {
+        printf("ImageLen size mismatch\n");
+        free(ptr);
+        return 0;
+    }
+
+    fd = open("/dev/mtdblock8", O_RDWR);
+
+    if(fd < 0)
+    {
+        printf("UpdateRootfs NG - can not open mtdblock8\n");
+        free(ptr);
+        return 0;
+    }
+
+    wrd = write(fd, ptr, ImageLen);
+    close(fd);
+
+    if(wrd != ImageLen)
+    {
+        printf("UpdateRootfs NG - wrd(0x%x) != ImageLen(0x%x)\n", wrd, ImageLen);
+        free(ptr);
+        return 0;
+    }
+
+    free(ptr);
+    printf("UpdateRootfs OK\n");
+}

EVSE/Projects/AW-CCS/Apps/CCS/UpdateRootfs.h

@@ -0,0 +1,7 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                              UpdateRootfs.h
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/

EVSE/Projects/AW-CCS/Apps/CCS/cacert.pem

@@ -0,0 +1,14 @@
+subject=/C=AU/SOP=QLD/O=Mincom Pty. Ltd./OU=CS/CN=SSLeay demo server
+issuer= /C=AU/SOP=QLD/O=Mincom Pty. Ltd./OU=CS/CN=CA
+-----BEGIN X509 CERTIFICATE-----
+
+MIIBgjCCASwCAQQwDQYJKoZIhvcNAQEEBQAwODELMAkGA1UEBhMCQVUxDDAKBgNV
+BAgTA1FMRDEbMBkGA1UEAxMSU1NMZWF5L3JzYSB0ZXN0IENBMB4XDTk1MTAwOTIz
+MzIwNVoXDTk4MDcwNTIzMzIwNVowYDELMAkGA1UEBhMCQVUxDDAKBgNVBAgTA1FM
+RDEZMBcGA1UEChMQTWluY29tIFB0eS4gTHRkLjELMAkGA1UECxMCQ1MxGzAZBgNV
+BAMTElNTTGVheSBkZW1vIHNlcnZlcjBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQC3
+LCXcScWua0PFLkHBLm2VejqpA1F4RQ8q0VjRiPafjx/Z/aWH3ipdMVvuJGa/wFXb
+/nDFLDlfWp+oCPwhBtVPAgMBAAEwDQYJKoZIhvcNAQEEBQADQQArNFsihWIjBzb0
+DCsU0BvL2bvSwJrPEqFlkDq3F4M6EGutL9axEcANWgbbEdAvNJD1dmEmoWny27Pn
+IMs6ZOZB
+-----END X509 CERTIFICATE-----

EVSE/Projects/AW-CCS/Apps/CCS/cakey.pem

@@ -0,0 +1,24 @@
+issuer= /C=AU/SOP=QLD/O=Mincom Pty. Ltd./OU=CS/CN=CA
+subject=/C=AU/SOP=QLD/O=Mincom Pty. Ltd./OU=CS/CN=SSLeay demo server
+-----BEGIN X509 CERTIFICATE-----
+
+MIIBgjCCASwCAQQwDQYJKoZIhvcNAQEEBQAwODELMAkGA1UEBhMCQVUxDDAKBgNV
+BAgTA1FMRDEbMBkGA1UEAxMSU1NMZWF5L3JzYSB0ZXN0IENBMB4XDTk1MTAwOTIz
+MzIwNVoXDTk4MDcwNTIzMzIwNVowYDELMAkGA1UEBhMCQVUxDDAKBgNVBAgTA1FM
+RDEZMBcGA1UEChMQTWluY29tIFB0eS4gTHRkLjELMAkGA1UECxMCQ1MxGzAZBgNV
+BAMTElNTTGVheSBkZW1vIHNlcnZlcjBcMA0GCSqGSIb3DQEBAQUAA0sAMEgCQQC3
+LCXcScWua0PFLkHBLm2VejqpA1F4RQ8q0VjRiPafjx/Z/aWH3ipdMVvuJGa/wFXb
+/nDFLDlfWp+oCPwhBtVPAgMBAAEwDQYJKoZIhvcNAQEEBQADQQArNFsihWIjBzb0
+DCsU0BvL2bvSwJrPEqFlkDq3F4M6EGutL9axEcANWgbbEdAvNJD1dmEmoWny27Pn
+IMs6ZOZB
+-----END X509 CERTIFICATE-----
+-----BEGIN RSA PRIVATE KEY-----
+
+MIIBPAIBAAJBALcsJdxJxa5rQ8UuQcEubZV6OqkDUXhFDyrRWNGI9p+PH9n9pYfe
+Kl0xW+4kZr/AVdv+cMUsOV9an6gI/CEG1U8CAwEAAQJAXJMBZ34ZXHd1vtgL/3hZ
+hexKbVTx/djZO4imXO/dxPGRzG2ylYZpHmG32/T1kaHpZlCHoEPgHoSzmxYXfxjG
+sQIhAPmZ/bQOjmRUHM/VM2X5zrjjM6z18R1P6l3ObFwt9FGdAiEAu943Yh9SqMRw
+tL0xHGxKmM/YJueUw1gB6sLkETN71NsCIQCeT3RhoqXfrpXDoEcEU+gwzjI1bpxq
+agiNTOLfqGoA5QIhAIQFYjgzONxex7FLrsKBm16N2SFl5pXsN9SpRqqL2n63AiEA
+g9VNIQ3xwpw7og3IbONifeku+J9qGMGQJMKwSTwrFtI=
+-----END RSA PRIVATE KEY-----

EVSE/Projects/AW-CCS/Apps/CCS/define_ccs.h → EVSE/Projects/AW-CCS/Apps/CCS/define.h

@@ -1,4 +1,4 @@
-/*===========================================================================
+/*===========================================================================
                     Combined Charging System (CCS): SECC
                                  define.h
 
@@ -8,11 +8,13 @@
 
 #ifndef DEFINE_H_
 #define DEFINE_H_
-
+#include "version.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <time.h>
 #include <sys/timeb.h>
+//#include "CsuCommAC.h"
+
 
 /**************************************************************************************/
 /*********************************NAND Flash mapping *****************************/
@@ -40,17 +42,34 @@
    Factory default configuration	0x05400000-0x0059FFFF		6 MB
    Storage					        0x05A00000-0x7FFFFFFF		1958 MB
  */
-#define ARRAY_SIZE(A)				(sizeof(A) / sizeof(A[0]))
-#define PASS						1
-#define FAIL			   			-1
-#define ENABLE						1
-#define	DISABLE						0
-#define ON							1
-#define	OFF							0
+ #define ENABLE              1
+ #define DISABLE             0
+ #define PASS                1
+ #define FAIL                0
 
 /**************************************************************************************/
 /*********************************System Limitation**********************************/
 /**************************************************************************************/
+#ifdef AWCCS
+#undef CONNECTOR_TEMP_DETECTION
+#define CCS_ENERGY_TRANSFER_MODE                    MODE_AC_SINGLE_PHASE_CORE //MODE_AC_THREE_PHASE_CORE
+#else
+#define CCS_ENERGY_TRANSFER_MODE                    MODE_DC_EXTENDED
+#endif
+
+//#define SUPPORT_ISO15118_PnC      
+//#define SUPPORT_ISO15118_VAS      
+//#define SUPPORT_TLS_CONNECTION              
+#define SUPPORT_DIN70122_ISO15118_4              0         		
+#define MIN_SUPPORTED_CURRENT              	   3 	   			   
+#define CONNECTOR_TEMP_DETECTION                  //REMA
+
+#ifdef SUPPORT_ISO15118_VAS
+#define SUPPORT_TLS_CONNECTION          
+#endif
+#ifdef SUPPORT_ISO15118_PnC
+#define SUPPORT_TLS_CONNECTION          
+#endif
 
 #define SIZE_OF_LOG_BUFFER              256         //Bytes
 
@@ -73,16 +92,13 @@
 #define CCS_AC_SIG_METER_READING                "SIG_METER_READING_ABCDE-0123456789" //max = 64 bytes
 
 /*CCS Protocol ID*/
-enum V2GT_MSG_PROTOCOL
-{
-	V2GT_MSG_PROTOCOL_DIN70121=0,
-	V2GT_MSG_PROTOCOL_ISO15118_2014,			//i.e. ISO15118-2 (ISO 1)
-	V2GT_MSG_PROTOCOL_ISO15118_2018,			//i.e. ISO15118-20 (ISO 2)
-	V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY=255		//for auto detect highest priority protocol
-};
+#define V2GT_MSG_PROTOCOL_DIN70121                  0
+#define V2GT_MSG_PROTOCOL_ISO15118_2014             1    //i.e. ISO15118-2 (ISO 1)
+#define V2GT_MSG_PROTOCOL_ISO15118_2018             2    //i.e. ISO15118-20 (ISO 2)
+#define V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY          255  //for auto detect highest priority protocol
 
-#define V2GT_MSG_PROTOCOL_PREFERENCE                V2GT_MSG_PROTOCOL_ISO15118_2014
-#define CCS_ENERGY_TRANSFER_MODE                    MODE_AC_SINGLE_PHASE_CORE
+#define V2GT_MSG_PROTOCOL_PREFERENCE              V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY // V2GT_MSG_PROTOCOL_ISO15118_2014//V2GT_MSG_PROTOCOL_HIGHEST_PRIORITY
+//#define CCS_ENERGY_TRANSFER_MODE                    MODE_DC_EXTENDED
                                                     //DC: MODE_DC_EXTENDED (default)
                                                     //AC: MODE_AC_SINGLE_PHASE_CORE, MODE_AC_THREE_PHASE_CORE
 
@@ -90,28 +106,26 @@ enum V2GT_MSG_PROTOCOL
 #define SET_5_PWM_ONCE_RX_CM_SLAC_PARM_REQ                  1
 #define SET_5_PWM_ONCE_GET_PERMISSION_IN_AUTHORIZATIONRES   2
 
-#define FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE       DISABLE	//default: ENABLE: release; DISABLE: debug
-#define CAN_RAMDOM_MATCHING_ID_MECHANISM                    ENABLE	//defualt: ENABLE
-#define CAN_RX_TIMEOUT_MECHANISM                            DISABLE	//defualt: ENABLE
-#define SLAC_FIRST_RESPONSE_METHOD                          SET_5_PWM_ONCE_GET_PERMISSION_IN_AUTHORIZATIONRES
+#define FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE       ENABLE  //default: ENABLE: release; DISABLE: debug
+#define NEW_SLAC_ARCHITECTURE_SWITCH                        ENABLE  //defualt: ENABLE
+#define CAN_RAMDOM_MATCHING_ID_MECHANISM                    ENABLE  //defualt: ENABLE
+#define CAN_RX_TIMEOUT_MECHANISM                            DISABLE  //defualt: ENABLE
+#define SLAC_FIRST_RESPONSE_METHOD                          SET_5_PWM_ONCE_RX_CM_SLAC_PARM_REQ
 
-#define TCPDUMP_PACKETS_SNIFFER_SWITCH                      ENABLE	//default: DISABLE
-#define CANDUMP_PACKETS_SNIFFER_SWITCH                      DISABLE	//default: DISABLE
+#define TCPDUMP_PACKETS_SNIFFER_SWITCH                      DISABLE //default: DISABLE
+#define CANDUMP_PACKETS_SNIFFER_SWITCH                      DISABLE //default: DISABLE
 
-#define DYNAMIC_ETH0_IP_MECHANISM                           ENABLE	//default: DISABLE
-#define CP_PROTECTION_MECHANISM                             ENABLE	//default: ENABLE
-#define PP_PROTECTION_MECHANISM                             DISABLE	//default: DISABLE
-#define SUDO_PSD_PARAMETER_MECHANISM                        ENABLE	//default: ENABLE
+#define DYNAMIC_ETH0_IP_MECHANISM                           ENABLE //default: DISABLE
+#define CP_PROTECTION_MECHANISM                             DISABLE  //default: ENABLE
+#define PP_PROTECTION_MECHANISM                             DISABLE //default: DISABLE
+#define SUDO_PSD_PARAMETER_MECHANISM                        ENABLE  //default: ENABLE
 #define TESLA_SLOW_INCREASE_CURRENT_FUNCTION                DISABLE
 #define V2G_SECC_TIMEOUT_PROTECTION                         ENABLE
 #define PATCH_FOR_BMW_I3_BUG_EVSEMAXIMUMVOLTAGELIMIT_599V   ENABLE   //default: ENABLE; CE/UL: DISABLE
 
 //CSU CAN Message EV Stop Type
-enum EV_STOP_TYPE
-{
-	EV_NORMAL_STOP=1,
-	EV_EMERGENCY_STOP
-};
+#define EV_NORMAL_STOP      1
+#define EV_EMERGENCY_STOP   2
 
 //CSU CAN Message GFD Isolation Status Type
 #define GFD_Invalid       0     //ongoing
@@ -162,11 +176,14 @@ enum EV_STOP_TYPE
 #define CCS_QUANTITY        1
 #define GB_QUANTITY         1
 
+/*SystemLog message*/
+#define SystemLogMessage            //for engineer to do analysis
+
 #define CSUCOMMDC_TASK_FLAG        (ShmInternalComm->InternalCommUnion.bits)
-#define CSUCOMMAC_SHM              (ShmCharger->gun_info[0].acCcsInfo)
+//#define CSUCOMMAC_SHM              (ShmInternalCommAC->gun_info[0].acCcsInfo)
 #define EVCOMM_SYS_INFO            (ShmSysConfigAndInfo->SysInfo.CcsChargingData[0])
 #define SLAC_INFO                  (ShmSysConfigAndInfo->SysInfo.CcsChargingData[0].evcc_slac_data)
-#define CCS_HANDSHAKE_PROTOCOLS    (v2gObject.appHandshake.supportedAppProtocolReq.AppProtocol)
+#define CCS_HANDSHAKE_PROTOCOLS    (ccs_handshake.supportedAppProtocolReq.AppProtocol)
 
 #define GPIO_SYS_DIR 		       "/sys/class/gpio"
 #define GPIO_2_23_AM_IO_1          87
@@ -187,6 +204,7 @@ enum EV_STOP_TYPE
 #define EVSE_STATUS_READY_FOR_PRECHARGE             2   //DC+ Relay: OFF, Precharge Relay: ON
 #define EVSE_STATUS_READY_FOR_ENERGY_TRANSFER       3   //DC+ Relay: ON, Precharge Relay: OFF
 
+
 /**************************************************************************************/
 /**************************share memory key information***************************/
 /**************************************************************************************/
@@ -194,8 +212,7 @@ enum EV_STOP_TYPE
 #define ShmCcsCommKey               3004    //0xBBC
 #define ShmStatusCodeKey            3005    //0xBBD
 #define ShmInternalCommKey          3009    //0xBC1
-
-#define ShmInternalCommACKey        2001    //0x7D1
+#define ShmInternalCommACKey        3007    //0x7D1
 
 /**************************************************************************************/
 /****structure SysConfigData => shall store the data to NAND flash****************/

EVSE/Projects/AW-CCS/Apps/CCS/exi_engine/Makefile

@@ -0,0 +1,46 @@
+#===========================================================================
+#                    Combined Charging System (CCS): SECC
+#                                 Makefile
+
+#                            initiated by Joseph
+#                            (since 2019/08/07)
+#=============================================================================
+
+-include ../Rules.make
+export PATH=/bin:/sbin:/usr/bin:$(SDK_PATH_TARGET)/usr/bin:$PATH
+
+LIBS = -lm
+OBJS = 	test/main.o \
+		test/main_example.o \
+		test/main_databinder.o \
+		api/api.o \
+		appHandshake/appHandEXIDatatypes.o \
+		appHandshake/appHandEXIDatatypesDecoder.o \
+		appHandshake/appHandEXIDatatypesEncoder.o \
+		codec/BitInputStream.o \
+		codec/BitOutputStream.o \
+		codec/ByteStream.o \
+		codec/DecoderChannel.o \
+		codec/EncoderChannel.o \
+		codec/EXIHeaderDecoder.o \
+		codec/EXIHeaderEncoder.o \
+		codec/MethodsBag.o \
+		din/dinEXIDatatypes.o \
+		din/dinEXIDatatypesDecoder.o \
+		din/dinEXIDatatypesEncoder.o \
+		iso1/iso1EXIDatatypes.o \
+		iso1/iso1EXIDatatypesDecoder.o \
+		iso1/iso1EXIDatatypesEncoder.o \
+		iso2/iso2EXIDatatypes.o \
+		iso2/iso2EXIDatatypesDecoder.o \
+		iso2/iso2EXIDatatypesEncoder.o \
+		transport/v2gtp.o \
+		xmldsig/xmldsigEXIDatatypes.o \
+		xmldsig/xmldsigEXIDatatypesDecoder.o \
+		xmldsig/xmldsigEXIDatatypesEncoder.o
+
+main: ${OBJS}
+	$(CC) -o main ${OBJS} ${LIBS}
+
+clean:
+	rm -rfv main ${OBJS}

EVSE/Projects/AW-CCS/Apps/CCS/v2g/api/api.c → EVSE/Projects/AW-CCS/Apps/CCS/exi_engine/api/api.c

@@ -1,5081 +1,5148 @@
-/*===========================================================================
-                    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);
-}
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                 api.c
+
+                          initiated by Joseph
+                           (since 2019/08/07)
+=============================================================================*/
+#include <netinet/ip.h>
+#include <arpa/inet.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <linux/termios.h>
+#include <stdio.h>
+#include <string.h>
+#include <time.h>
+#include <stdlib.h>
+#include <sys/ipc.h>
+#include <sys/shm.h>
+#include <sys/mman.h>
+#include <linux/sockios.h>
+#include <linux/socket.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <sys/time.h>
+#include <sys/timeb.h>
+#include <math.h>//for pow
+#include <unistd.h>
+#include <linux/if_packet.h>
+#include <netinet/if_ether.h>
+#include <net/if.h>
+#include <netinet/ether.h>
+#include <linux/can.h>
+#include <linux/can/raw.h>
+
+#include "api.h"
+#include "../../SeccComm.h"
+//#include "../../CsuComm.h"
+#include "../../define.h"
+#include "../codec/EXITypes.h"
+
+/* Activate support for DIN */
+#include "../din/dinEXIDatatypes.h"
+#if DEPLOY_DIN_CODEC == SUPPORT_YES
+#include "../din/dinEXIDatatypesEncoder.h"
+#include "../din/dinEXIDatatypesDecoder.h"
+#endif /* DEPLOY_DIN_CODEC == SUPPORT_YES */
+
+/* Activate support for XMLDSIG */
+#include "../xmldsig/xmldsigEXIDatatypes.h"
+#if DEPLOY_XMLDSIG_CODEC == SUPPORT_YES
+#include "../xmldsig/xmldsigEXIDatatypesEncoder.h"
+#include "../xmldsig/xmldsigEXIDatatypesDecoder.h"
+#endif /* DEPLOY_XMLDSIG_CODEC == SUPPORT_YES */
+
+/* Activate support for ISO1 */
+#include "../iso1/iso1EXIDatatypes.h"
+#if DEPLOY_ISO1_CODEC == SUPPORT_YES
+#include "../iso1/iso1EXIDatatypesEncoder.h"
+#include "../iso1/iso1EXIDatatypesDecoder.h"
+#endif /* DEPLOY_ISO1_CODEC == SUPPORT_YES */
+
+/* Activate support for ISO2 */
+#include "../iso2/iso2EXIDatatypes.h"
+#if DEPLOY_ISO2_CODEC == SUPPORT_YES
+#include "../iso2/iso2EXIDatatypesEncoder.h"
+#include "../iso2/iso2EXIDatatypesDecoder.h"
+#endif /* DEPLOY_ISO2_CODEC == SUPPORT_YES */
+
+#include "../transport/v2gtp.h"
+
+extern struct SysConfigAndInfo *ShmSysConfigAndInfo;
+extern struct StatusCodeData *ShmStatusCodeData;
+extern struct CcsData *ShmCcsData;
+extern struct InternalComm *ShmInternalComm;
+//extern struct InternalCommAC *ShmInternalCommAC;
+
+/*Preserve V2GTP Rx and Tx Buffer*/
+//unsigned char V2GTP_Rx_buf[V2GTP_MSG_RX_BUFFER_SIZE];	//(64*1024)   //65,536 = 65.5KB
+unsigned char V2GTP_Tx_buf[V2GTP_MSG_TX_BUFFER_SIZE];		//(64*1024)   //65,536 = 65.5KB
+
+
+bitstream_t iStream;	//for V2GTP Message
+struct appHandEXIDocument exiDoc;	//for decoded V2GTP messages, i.e. EXI DOC (XML)
+
+unsigned char buf_log_exi_api[256];
+
+
+/*===========================================================================
+FUNCTION: printASCIIString
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+			1. exi_doc_DIN
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+static void printASCIIString(exi_string_character_t* string, uint16_t len)
+{
+	unsigned int i = 0;
+
+	for(i = 0; i < len; i++)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("%c", (char)string[i]);
+	}
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n");
+}
+
+/*===========================================================================
+FUNCTION: writeStringToEXIString
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+			1. exi_doc_DIN
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+static int writeStringToEXIString(char* string, exi_string_character_t* exiString)
+{
+	int pos = 0;
+	while(string[pos]!='\0')
+	{
+		exiString[pos] = string[pos];
+		pos++;
+	}
+
+	return pos;
+}
+
+/*===========================================================================
+FUNCTION: PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+			1. exi_doc_DIN
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Check_V2G_Rx_Msg_Name_din(struct dinEXIDocument *exi_doc_DIN)
+{
+	int errn = 0;
+
+	//Session Setup (0a ⇄ 0b)
+	if (exi_doc_DIN->V2G_Message.Body.SessionSetupReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] SessionSetupReq_isUsed: YES (0a ⇄ 0b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = SessionSetupRequest;
+	}
+	//Service Discovery (1a ⇄ 1b)
+	else if (exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] ServiceDiscoveryReq_isUsed: YES (1a ⇄ 1b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceDiscoveryRequest;
+	}
+	//Service Payment Selection (2a ⇄ 2b)
+	else if (exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] ServicePaymentSelectionReq_isUsed: YES (2a ⇄ 2b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceAndPaymentSelectionRequest;
+	}
+	//Contract Contract Authentication (Xa ⇄ Xb)
+	else if (exi_doc_DIN->V2G_Message.Body.ContractAuthenticationReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] ContractAuthenticationReq_isUsed: YES (Xa ⇄ Xb)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = AuthorizationRequest;
+	}
+	//Charge Parameter Discovery (3a ⇄ 3b)
+	else if (exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] ChargeParameterDiscoveryReq_isUsed: YES (3a ⇄ 3b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = ChargeParameterDiscoveryRequest;
+	}
+	//Cable Check (4a ⇄ 4b)
+	else if (exi_doc_DIN->V2G_Message.Body.CableCheckReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] CableCheckReq_isUsed: YES (4a ⇄ 4b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = CableCheckRequest;
+	}
+	//Precharge (5a ⇄ 5b)
+	else if (exi_doc_DIN->V2G_Message.Body.PreChargeReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] PreChargeReq_isUsed: YES (5a ⇄ 5b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = PreChargeRequest;
+	}
+	//Power Delivery (6a ⇄ 6b)
+	else if (exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] PowerDeliveryReq_isUsed: YES (6a ⇄ 6b)\n");
+
+		if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre == PreChargeRequest)
+		{
+			EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStart;
+		}
+		else
+		{
+			EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStop;
+		}
+	}
+	//Current Demand (7a ⇄ 7b)
+	else if (exi_doc_DIN->V2G_Message.Body.CurrentDemandReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] CurrentDemandReq_isUsed: YES (7a ⇄ 7b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = CurrentDemandRequest;
+	}
+	//Welding Detection (9a ⇄ 9b)
+	else if (exi_doc_DIN->V2G_Message.Body.WeldingDetectionReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] WeldingDetectionReq_isUsed: YES (9a ⇄ 9b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = WeldingDetectionRequest;
+	}
+	//Session Stop (10a ⇄ 10b)
+	else if (exi_doc_DIN->V2G_Message.Body.SessionStopReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_DIN] SessionStopReq_isUsed: YES (10a ⇄ 10b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = SessionStopRequest;
+	}
+	else
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]unidentified V2G_Rx_Msg\n");
+		errn = -1;
+	}
+
+	//Compare with the previous Message
+	if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre != EVCOMM_SYS_INFO.V2G_Rx_Msg)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[V2G_RX_MSG]%d >> %d\n",
+										EVCOMM_SYS_INFO.V2G_Rx_Msg_pre,
+										EVCOMM_SYS_INFO.V2G_Rx_Msg);
+		EVCOMM_SYS_INFO.V2G_Rx_Msg_pre = EVCOMM_SYS_INFO.V2G_Rx_Msg;
+	}
+
+	return errn;
+}
+
+/*===========================================================================
+FUNCTION: PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+			1. exi_doc_ISO1
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Check_V2G_Rx_Msg_Name_iso1(struct iso1EXIDocument *exi_doc_ISO1)
+{
+	int errn = 0;
+
+	//Session Setup (0a ⇄ 0b)
+	if (exi_doc_ISO1->V2G_Message.Body.SessionSetupReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] SessionSetupReq_isUsed: YES (0a ⇄ 0b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = SessionSetupRequest;
+	}
+	//Service Discovery (1a ⇄ 1b)
+	else if (exi_doc_ISO1->V2G_Message.Body.ServiceDiscoveryReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] ServiceDiscoveryReq_isUsed: YES (1a ⇄ 1b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceDiscoveryRequest;
+	}
+	//Service Detail
+	else if (exi_doc_ISO1->V2G_Message.Body.ServiceDetailReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] ServiceDetailReq_isUsed: YES\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceDetailRequest;
+	}
+	//Payment Service Selection (2a ⇄ 2b)
+	else if (exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] PaymentServiceSelectionReq_isUsed: YES (2a ⇄ 2b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceAndPaymentSelectionRequest;
+	}
+	//Payment Details
+	else if (exi_doc_ISO1->V2G_Message.Body.PaymentDetailsReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] PaymentDetailsReq_isUsed: YES\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = PaymentDetailsRequest;
+	}
+	//Authorization (Xa ⇄ Xb)
+	else if (exi_doc_ISO1->V2G_Message.Body.AuthorizationReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] AuthorizationReq_isUsed: YES (Xa ⇄ Xb)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = AuthorizationRequest;
+	}
+	//Certificate Update
+	else if (exi_doc_ISO1->V2G_Message.Body.CertificateUpdateReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] CertificateUpdateReq_isUsed: YES\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = CertificateUpdateRequest;
+	}
+	//Certificate Installation
+	else if (exi_doc_ISO1->V2G_Message.Body.CertificateInstallationReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] CertificateInstallationReq_isUsed: YES\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = CertificateInstallationRequest;
+	}
+	//Charge Parameter Discovery (3a ⇄ 3b)
+	else if (exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] ChargeParameterDiscoveryReq_isUsed: YES (3a ⇄ 3b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = ChargeParameterDiscoveryRequest;
+	}
+	//Cable Check (4a ⇄ 4b)
+	else if (exi_doc_ISO1->V2G_Message.Body.CableCheckReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] CableCheckReq_isUsed: YES (4a ⇄ 4b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = CableCheckRequest;
+	}
+	//Precharge (5a ⇄ 5b)
+	else if (exi_doc_ISO1->V2G_Message.Body.PreChargeReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] PreChargeReq_isUsed: YES (5a ⇄ 5b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = PreChargeRequest;
+	}
+	//Power Delivery (6a ⇄ 6b)
+	else if (exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] PowerDeliveryReq_isUsed: YES (6a ⇄ 6b)\n");
+
+		//For DC
+		if (CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED)
+		{
+			if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre == PreChargeRequest)
+			{
+				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStart;
+			}
+			else
+			{
+				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStop;
+			}
+		}
+		//For AC
+		else if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
+		{
+			if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre == ChargeParameterDiscoveryRequest)
+			{
+				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStart;
+			}
+			else
+			{
+				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStop;
+			}
+		}
+		else
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]unexpected CCS_ENERGY_TRANSFER_MODE(%d)\n", CCS_ENERGY_TRANSFER_MODE);
+			errn = -2;
+		}
+	}
+	//Current Demand (7a ⇄ 7b)
+	else if (exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] CurrentDemandReq_isUsed: YES (7a ⇄ 7b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = CurrentDemandRequest;
+	}
+	//Charging Status
+	else if (exi_doc_ISO1->V2G_Message.Body.ChargingStatusReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] ChargingStatusReq_isUsed: YES (7a ⇄ 7b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = ChargingStatusRequest;
+	}
+	//Metering Receipt
+	else if (exi_doc_ISO1->V2G_Message.Body.MeteringReceiptReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] MeteringReceiptReq_isUsed: YES\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = MeteringReceiptRequest;
+	}
+	//Welding Detection (9a ⇄ 9b)
+	else if (exi_doc_ISO1->V2G_Message.Body.WeldingDetectionReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] WeldingDetectionReq_isUsed: YES (9a ⇄ 9b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = WeldingDetectionRequest;
+	}
+	//Session Stop (10a ⇄ 10b)
+	else if (exi_doc_ISO1->V2G_Message.Body.SessionStopReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO1] SessionStopReq_isUsed: YES (10a ⇄ 10b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = SessionStopRequest;
+	}
+	else
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]unidentified V2G_Rx_Msg\n");
+		errn = -1;
+	}
+
+	//Compare with the previous Message
+	if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre != EVCOMM_SYS_INFO.V2G_Rx_Msg)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[V2G_RX_MSG]%d >> %d\n",
+										EVCOMM_SYS_INFO.V2G_Rx_Msg_pre,
+										EVCOMM_SYS_INFO.V2G_Rx_Msg);
+		EVCOMM_SYS_INFO.V2G_Rx_Msg_pre = EVCOMM_SYS_INFO.V2G_Rx_Msg;
+	}
+
+	return errn;
+}
+
+/*===========================================================================
+FUNCTION: PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+			1. exi_doc_ISO2
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Check_V2G_Rx_Msg_Name_iso2(struct iso2EXIDocument *exi_doc_ISO2)
+{
+	int errn = 0;
+
+	//V2GRequest_isUsed
+	if (exi_doc_ISO2->V2G_Message.Body.V2GRequest_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] V2GRequest_isUsed: YES\n");
+		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
+	}
+	//DisconnectChargingDeviceReq_isUsed
+	else if (exi_doc_ISO2->V2G_Message.Body.DisconnectChargingDeviceReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] DisconnectChargingDeviceReq_isUsed: YES\n");
+		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
+	}
+	//ConnectChargingDeviceReq_isUsed
+	else if (exi_doc_ISO2->V2G_Message.Body.ConnectChargingDeviceReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] ConnectChargingDeviceReq_isUsed: YES\n");
+		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
+	}
+	//SystemStatusReq_isUsed
+	else if (exi_doc_ISO2->V2G_Message.Body.SystemStatusReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] SystemStatusReq_isUsed: YES\n");
+		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
+	}
+	//DC_BidirectionalControlReq_isUsed
+	else if (exi_doc_ISO2->V2G_Message.Body.DC_BidirectionalControlReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] DC_BidirectionalControlReq_isUsed: YES\n");
+		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
+	}
+	//AC_BidirectionalControlReq_isUsed
+	else if (exi_doc_ISO2->V2G_Message.Body.AC_BidirectionalControlReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] AC_BidirectionalControlReq_isUsed: YES\n");
+		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
+	}
+	//VehicleCheckOutReq_isUsed
+	else if (exi_doc_ISO2->V2G_Message.Body.VehicleCheckOutReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] VehicleCheckOutReq_isUsed: YES\n");
+		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
+	}
+	//VehicleCheckInReq_isUsed
+	else if (exi_doc_ISO2->V2G_Message.Body.VehicleCheckInReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] VehicleCheckInReq_isUsed: YES\n");
+		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
+	}
+	//PowerDemandReq_isUsed
+	else if (exi_doc_ISO2->V2G_Message.Body.PowerDemandReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] PowerDemandReq_isUsed: YES\n");
+		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
+	}
+	//PairingReq_isUsed
+	else if (exi_doc_ISO2->V2G_Message.Body.PairingReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] PairingReq_isUsed: YES\n");
+		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
+	}
+	//AlignmentCheckReq_isUsed
+	else if (exi_doc_ISO2->V2G_Message.Body.AlignmentCheckReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] AlignmentCheckReq_isUsed: YES\n");
+		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
+	}
+	//FinePositioningReq_isUsed
+	else if (exi_doc_ISO2->V2G_Message.Body.FinePositioningReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] FinePositioningReq_isUsed: YES\n");
+		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
+	}
+	//FinePositioningSetupReq_isUsed
+	else if (exi_doc_ISO2->V2G_Message.Body.FinePositioningSetupReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] FinePositioningSetupReq_isUsed: YES\n");
+		//EVCOMM_SYS_INFO.V2G_Rx_Msg = ;
+	}
+	//Session Setup (0a ⇄ 0b)
+	else if (exi_doc_ISO2->V2G_Message.Body.SessionSetupReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] SessionSetupReq_isUsed: YES (0a ⇄ 0b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = SessionSetupRequest;
+	}
+	//Service Discovery (1a ⇄ 1b)
+	else if (exi_doc_ISO2->V2G_Message.Body.ServiceDiscoveryReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] ServiceDiscoveryReq_isUsed: YES (1a ⇄ 1b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceDiscoveryRequest;
+	}
+	//Service Detail
+	else if (exi_doc_ISO2->V2G_Message.Body.ServiceDetailReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] ServiceDetailReq_isUsed: YES\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceDetailRequest;
+	}
+	//Payment Service Selection (2a ⇄ 2b)
+	else if (exi_doc_ISO2->V2G_Message.Body.PaymentServiceSelectionReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] PaymentServiceSelectionReq_isUsed: YES (2a ⇄ 2b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = ServiceAndPaymentSelectionRequest;
+	}
+	//Payment Details
+	else if (exi_doc_ISO2->V2G_Message.Body.PaymentDetailsReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] PaymentDetailsReq_isUsed: YES\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = PaymentDetailsRequest;
+	}
+	//Authorization (Xa ⇄ Xb)
+	else if (exi_doc_ISO2->V2G_Message.Body.AuthorizationReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] AuthorizationReq_isUsed: YES (Xa ⇄ Xb)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = AuthorizationRequest;
+	}
+	//Certificate Update
+	else if (exi_doc_ISO2->V2G_Message.Body.CertificateUpdateReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] CertificateUpdateReq_isUsed: YES\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = CertificateUpdateRequest;
+	}
+	//Certificate Installation
+	else if (exi_doc_ISO2->V2G_Message.Body.CertificateInstallationReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] CertificateInstallationReq_isUsed: YES\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = CertificateInstallationRequest;
+	}
+	//Charge Parameter Discovery (3a ⇄ 3b)
+	else if (exi_doc_ISO2->V2G_Message.Body.ChargeParameterDiscoveryReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] ChargeParameterDiscoveryReq_isUsed: YES (3a ⇄ 3b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = ChargeParameterDiscoveryRequest;
+	}
+	//Cable Check (4a ⇄ 4b)
+	else if (exi_doc_ISO2->V2G_Message.Body.CableCheckReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] CableCheckReq_isUsed: YES (4a ⇄ 4b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = CableCheckRequest;
+	}
+	//Precharge (5a ⇄ 5b)
+	else if (exi_doc_ISO2->V2G_Message.Body.PreChargeReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] PreChargeReq_isUsed: YES (5a ⇄ 5b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = PreChargeRequest;
+	}
+	//Power Delivery (6a ⇄ 6b)
+	else if (exi_doc_ISO2->V2G_Message.Body.PowerDeliveryReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] PowerDeliveryReq_isUsed: YES (6a ⇄ 6b)\n");
+
+		//For DC
+		if (CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED)
+		{
+			if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre == PreChargeRequest)
+			{
+				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStart;
+			}
+			else
+			{
+				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStop;
+			}
+		}
+		//For AC
+		else if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) || (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
+		{
+			if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre == ChargeParameterDiscoveryRequest)
+			{
+				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStart;
+			}
+			else
+			{
+				EVCOMM_SYS_INFO.V2G_Rx_Msg = PowerDeliveryRequestStop;
+			}
+		}
+		else
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]unexpected CCS_ENERGY_TRANSFER_MODE(%d)\n", CCS_ENERGY_TRANSFER_MODE);
+			errn = -2;
+		}
+	}
+	//Current Demand (7a ⇄ 7b)
+	else if (exi_doc_ISO2->V2G_Message.Body.CurrentDemandReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] CurrentDemandReq_isUsed: YES (7a ⇄ 7b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = CurrentDemandRequest;
+	}
+	//Charging Status
+	else if (exi_doc_ISO2->V2G_Message.Body.ChargingStatusReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] ChargingStatusReq_isUsed: YES (7a ⇄ 7b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = ChargingStatusRequest;
+	}
+	//Metering Receipt
+	else if (exi_doc_ISO2->V2G_Message.Body.MeteringReceiptReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] MeteringReceiptReq_isUsed: YES\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = MeteringReceiptRequest;
+	}
+	//Welding Detection (9a ⇄ 9b)
+	else if (exi_doc_ISO2->V2G_Message.Body.WeldingDetectionReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] WeldingDetectionReq_isUsed: YES (9a ⇄ 9b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = WeldingDetectionRequest;
+	}
+	//Session Stop (10a ⇄ 10b)
+	else if (exi_doc_ISO2->V2G_Message.Body.SessionStopReq_isUsed == 1u)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][PRINT_V2GTP_MSG_RX_REQUEST_NAME_ISO2] SessionStopReq_isUsed: YES (10a ⇄ 10b)\n");
+		EVCOMM_SYS_INFO.V2G_Rx_Msg = SessionStopRequest;
+	}
+	else
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]unidentified V2G_Rx_Msg\n");
+		errn = -1;
+	}
+
+	//Compare with the previous Message
+	if (EVCOMM_SYS_INFO.V2G_Rx_Msg_pre != EVCOMM_SYS_INFO.V2G_Rx_Msg)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[V2G_RX_MSG]%d >> %d\n",
+										EVCOMM_SYS_INFO.V2G_Rx_Msg_pre,
+										EVCOMM_SYS_INFO.V2G_Rx_Msg);
+		EVCOMM_SYS_INFO.V2G_Rx_Msg_pre = EVCOMM_SYS_INFO.V2G_Rx_Msg;
+	}
+
+	return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: SAVE_PhysicalValueType_DIN70121
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SAVE_PhysicalValueType_DIN70121(struct PhysicalValueType_DIN70121 *out, int in_value, unsigned char unit)
+{
+    out->Value = in_value;
+    out->Unit = unit;
+
+    switch (unit)
+    {
+        case H_DIN70121:
+        case M_DIN70121:
+        case S_DIN70121:
+        case A_DIN70121:
+        case V_DIN70121:
+        case AH_DIN70121:
+        case VA_DIN70121:
+            out->Multiplier = -1;
+            break;    //KW
+
+        case W_DIN70121:
+        case WH_DIN70121:
+			out->Value = in_value/10;//in_value * 10;
+            out->Multiplier = 3;
+            break;    //KWh
+    }
+    //H_DIN70121 = 0,
+    //M_DIN70121 = 1,
+    //S_DIN70121 = 2,
+    //A_DIN70121 = 3,
+    //AH_DIN70121 = 4,
+    //V_DIN70121 = 5,
+    //VA_DIN70121 = 6,
+    //W_DIN70121 = 7,
+    //WS_DIN70121 = 8,
+    //WH_DIN70121 = 9};
+}
+
+/*===========================================================================
+FUNCTION: SAVE_PhysicalValueType_ISO15118_2014
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SAVE_PhysicalValueType_ISO15118_2014(struct PhysicalValueType_ISO15118_2014 *out, int in_value, unsigned char unit)
+{
+    out->Value = in_value;
+    out->Unit = unit;
+
+    switch (unit)
+    {
+        case h_ISO15118_2014:
+        case m_ISO15118_2014:
+        case s_ISO15118_2014:
+        case A_ISO15118_2014:
+        case V_ISO15118_2014:
+            out->Multiplier = -1;
+            break;    //KW
+
+        case W_ISO15118_2014:
+        case Wh_ISO15118_2014:
+			out->Value = in_value/10;//in_value * 10;
+            out->Multiplier = 3;
+            break;    //KWh
+    }
+    //H_DIN70121 = 0,
+    //M_DIN70121 = 1,
+    //S_DIN70121 = 2,
+    //A_DIN70121 = 3,
+    //AH_DIN70121 = 4,
+    //V_DIN70121 = 5,
+    //VA_DIN70121 = 6,
+    //W_DIN70121 = 7,
+    //WS_DIN70121 = 8,
+    //WH_DIN70121 = 9};
+}
+
+
+/*===========================================================================
+FUNCTION: DIN70121PhyValDecode
+DESCRIPTION:
+        Output Unit: 1V, 1A, 1S, etc.
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+float DIN70121PhyValDecode(struct PhysicalValueType_DIN70121 PhysicalData)
+{
+    short DataValue;
+    int DataMultiplier;
+    float Rtn;
+
+    DataValue = PhysicalData.Value;
+    DataMultiplier = PhysicalData.Multiplier;
+
+    switch(PhysicalData.Unit)
+    {
+        case H_DIN70121:
+            Rtn = (DataValue * pow(10, DataMultiplier) * 60 * 60);
+            return Rtn;
+
+        case M_DIN70121:
+            Rtn = (DataValue * pow(10, DataMultiplier) * 60);
+            return Rtn;
+
+        case S_DIN70121:
+        case A_DIN70121:
+        case V_DIN70121:
+            Rtn = (DataValue * pow(10, DataMultiplier));
+            return Rtn;     //S, A, V
+
+        case AH_DIN70121:
+            Rtn = (DataValue * pow(10, DataMultiplier));
+            return Rtn;
+
+        case VA_DIN70121:
+        case W_DIN70121:
+            Rtn = (DataValue * pow(10, DataMultiplier)) / 1000;
+            return Rtn;    //kW
+
+        case WS_DIN70121:
+            Rtn = (DataValue * pow(10, DataMultiplier)) / 1000;    //[Joseph] TBD
+            return Rtn;
+
+        case WH_DIN70121:
+            Rtn = (DataValue * pow(10, DataMultiplier)) / 1000;
+            return Rtn;    //kWh
+    }
+}
+
+/*===========================================================================
+FUNCTION: ISO151182014PhyValDecode
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+float ISO151182014PhyValDecode(struct PhysicalValueType_ISO15118_2014 PhysicalData)
+{
+    short DataValue;
+    int DataMultiplier;
+    float Rtn;
+
+    DataValue = PhysicalData.Value;
+    DataMultiplier = PhysicalData.Multiplier;
+
+    switch(PhysicalData.Unit)
+    {
+        case h_ISO15118_2014:
+            Rtn = (DataValue * pow(10, DataMultiplier) * 60 * 60);
+            return Rtn;
+
+        case m_ISO15118_2014:
+            Rtn = (DataValue * pow(10, DataMultiplier) * 60);
+            return Rtn;
+
+        case s_ISO15118_2014:
+        case A_ISO15118_2014:
+        case V_ISO15118_2014:
+            Rtn = (DataValue * pow(10, DataMultiplier));
+            return Rtn;
+
+        case W_ISO15118_2014:
+            Rtn = (DataValue * pow(10, DataMultiplier)) / 1000;
+            return Rtn;    //kW
+
+        case Wh_ISO15118_2014:
+            Rtn = (DataValue * pow(10, DataMultiplier)) / 1000;
+            return Rtn;    //kWh
+    }
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Read_dinPhysicalValueType
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. in
+OUTPUT:
+		2. out
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_dinPhysicalValueType(struct dinPhysicalValueType *out, struct PhysicalValueType_DIN70121 *in)
+{
+	out->Value = (short) in->Value;
+	out->Multiplier = (char) in->Multiplier;
+	out->Unit_isUsed = 1u;	//[CAUTION] Remember to put Uinit, since here we set it as 1 as default.
+	out->Unit = (unsigned char) in->Unit;
+	//	dinunitSymbolType_h = 0,
+	//	dinunitSymbolType_m = 1,
+	//	dinunitSymbolType_s = 2,
+	//	dinunitSymbolType_A = 3,
+	//	dinunitSymbolType_Ah = 4,
+	//	dinunitSymbolType_V = 5,
+	//	dinunitSymbolType_VA = 6,
+	//	dinunitSymbolType_W = 7,
+	//	dinunitSymbolType_W_s = 8,
+	//	dinunitSymbolType_Wh = 9
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_iso1PhysicalValueType
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. in
+OUTPUT:
+		2. out
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_iso1PhysicalValueType(struct iso1PhysicalValueType *out, struct PhysicalValueType_ISO15118_2014 *in)
+{
+	out->Value = (short) in->Value;
+	out->Multiplier = (char) in->Multiplier;
+	//out->Unit_isUsed = 1u;	//[CAUTION] Remember to put Uinit, since here we set it as 1 as default.
+	out->Unit = (unsigned char) in->Unit;
+	//iso1unitSymbolType_h = 0,
+	//iso1unitSymbolType_m = 1,
+	//iso1unitSymbolType_s = 2,
+	//iso1unitSymbolType_A = 3,
+	//iso1unitSymbolType_V = 4,
+	//iso1unitSymbolType_W = 5,
+	//iso1unitSymbolType_Wh = 6
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Read_dinDC_EVSEStatusType
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. in
+OUTPUT:
+		2. out
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_dinDC_EVSEStatusType(struct dinDC_EVSEStatusType *out, struct DC_EVSEStatusType_DIN70121 *in)
+{
+	out->EVSEIsolationStatus_isUsed = 1u;
+	out->EVSEIsolationStatus = (unsigned char) in->EVSEIsolationStatus;
+	//	dinisolationLevelType_Invalid = 0, (default)
+	//	dinisolationLevelType_Valid = 1,
+	//	dinisolationLevelType_Warning = 2,
+	//	dinisolationLevelType_Fault = 3
+
+	out->EVSEStatusCode = (unsigned char) in->EVSEStatusCode;
+	// dinDC_EVSEStatusCodeType_EVSE_NotReady = 0,
+	// dinDC_EVSEStatusCodeType_EVSE_Ready = 1, (default)
+	// dinDC_EVSEStatusCodeType_EVSE_Shutdown = 2,
+	// dinDC_EVSEStatusCodeType_EVSE_UtilityInterruptEvent = 3,
+	// dinDC_EVSEStatusCodeType_EVSE_IsolationMonitoringActive = 4,
+	// dinDC_EVSEStatusCodeType_EVSE_EmergencyShutdown = 5,
+	// dinDC_EVSEStatusCodeType_EVSE_Malfunction = 6,
+	// dinDC_EVSEStatusCodeType_Reserved_8 = 7,
+	// dinDC_EVSEStatusCodeType_Reserved_9 = 8,
+	// dinDC_EVSEStatusCodeType_Reserved_A = 9,
+	// dinDC_EVSEStatusCodeType_Reserved_B = 10,
+	// dinDC_EVSEStatusCodeType_Reserved_C = 11
+
+	out->NotificationMaxDelay = 0u;
+
+	out->EVSENotification = (unsigned char) in->EVSENotification;
+	// dinEVSENotificationType_None = 0, (default)
+	// dinEVSENotificationType_StopCharging = 1,
+	// dinEVSENotificationType_ReNegotiation = 2
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_iso1DC_EVSEStatusType
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. in
+OUTPUT:
+		2. out
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_iso1DC_EVSEStatusType(struct iso1DC_EVSEStatusType *out, struct DC_EVSEStatusType_ISO15118_2014 *in)
+{
+	out->EVSEIsolationStatus_isUsed = 1u;
+	out->EVSEIsolationStatus = (unsigned char) in->EVSEIsolationStatus;
+	//iso1isolationLevelType_Invalid = 0,
+	//iso1isolationLevelType_Valid = 1,
+	//iso1isolationLevelType_Warning = 2,
+	//iso1isolationLevelType_Fault = 3,
+	//iso1isolationLevelType_No_IMD = 4
+
+	out->EVSEStatusCode = (unsigned char) in->DC_EVSEStatusCode;
+	//iso1DC_EVSEStatusCodeType_EVSE_NotReady = 0,
+	//iso1DC_EVSEStatusCodeType_EVSE_Ready = 1,
+	//iso1DC_EVSEStatusCodeType_EVSE_Shutdown = 2,
+	//iso1DC_EVSEStatusCodeType_EVSE_UtilityInterruptEvent = 3,
+	//iso1DC_EVSEStatusCodeType_EVSE_IsolationMonitoringActive = 4,
+	//iso1DC_EVSEStatusCodeType_EVSE_EmergencyShutdown = 5,
+	//iso1DC_EVSEStatusCodeType_EVSE_Malfunction = 6,
+	//iso1DC_EVSEStatusCodeType_Reserved_8 = 7,
+	//iso1DC_EVSEStatusCodeType_Reserved_9 = 8,
+	//iso1DC_EVSEStatusCodeType_Reserved_A = 9,
+	//iso1DC_EVSEStatusCodeType_Reserved_B = 10,
+	//iso1DC_EVSEStatusCodeType_Reserved_C = 11
+
+	out->NotificationMaxDelay = 0u;
+
+	out->EVSENotification = (unsigned char) in->EVSENotification;
+	//iso1EVSENotificationType_None = 0, (default)
+	//iso1EVSENotificationType_StopCharging = 1,
+	//iso1EVSENotificationType_ReNegotiation = 2
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_iso1AC_EVSEStatusType
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. in
+OUTPUT:
+		2. out
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_iso1AC_EVSEStatusType(struct iso1AC_EVSEStatusType *out, struct AC_EVSEStatusType_ISO15118_2014 *in)
+{
+	out->RCD = (int)in->RCD;	
+	//0: no error is detected
+	//1: an error is detected
+
+	out->NotificationMaxDelay = (unsigned short)in->NotificationMaxDelay;	
+	//unit: 1s
+	//The time SECC expects EVCC to perform EVSENotification
+
+	out->EVSENotification = (unsigned char)in->EVSENotification;
+	//iso1EVSENotificationType_None = 0,
+	//iso1EVSENotificationType_StopCharging = 1,
+	//iso1EVSENotificationType_ReNegotiation = 2
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_iso1MeterInfo
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. in
+OUTPUT:
+		2. out
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_iso1MeterInfo(struct iso1MeterInfoType *out, struct MeterInfoType_ISO15118_2014 *in)
+{
+	int i = 0;
+
+	//[1/5] MeterID
+	out->MeterID.charactersLen = strlen(in->MeterID);
+	for (i = 0; i < out->MeterID.charactersLen; i++)
+	{
+		out->MeterID.characters[i] = (unsigned char)in->MeterID[i];
+	}
+
+	//[2/5] MeterReading
+	out->MeterReading_isUsed = 1u;
+	out->MeterReading = (unsigned long)in->MeterReading;
+
+	//[3/5] SigMeterReading
+	out->SigMeterReading_isUsed = 0u;
+	/*out->SigMeterReading.bytesLen = 64;
+	for (i = 0; i < out->SigMeterReading.bytesLen; i++)
+	{
+		out->SigMeterReading.bytes[i] = (unsigned char)in->SigMeterReading[i];
+	}*/
+
+	//[4/5] MeterStatus
+	out->MeterStatus_isUsed = 1u;
+	out->MeterStatus = (short)in->MeterStatus;
+
+	//[5/5] TMeter
+	out->TMeter_isUsed = 1u;
+	out->TMeter = (long)in->TMeter;		//[CAUTION] data type
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_din_supportedAppProtocolReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_din_supportedAppProtocolReq(struct CcsData *shm_ccs, struct appHandEXIDocument *buf, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    int j = 0;
+    struct SupportedAppProtocolRequest_DIN70121 *shm_msg;
+    struct appHandAnonType_supportedAppProtocolReq *exi;
+
+    shm_msg = &shm_ccs->V2GMessage_DIN70121.SupportedAppProtocolRequest;
+    exi = &buf->supportedAppProtocolReq;
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    for (i = 0; i < exi->AppProtocol.arrayLen ; i++)
+    {
+        //ProtocolNamespace
+        shm_msg->AppProtocol[i].ProtocolNamespaceLen = (unsigned int) exi->AppProtocol.array[i].ProtocolNamespace.charactersLen;
+
+        for (j = 0; j< shm_msg->AppProtocol[i].ProtocolNamespaceLen; j++)
+        {
+            shm_msg->AppProtocol[i].ProtocolNamespace[j] = (unsigned char) exi->AppProtocol.array[i].ProtocolNamespace.characters[j];
+        }
+
+        //Version (Major, Minor)
+        shm_msg->AppProtocol[i].VersionNumberMajor = (unsigned int) exi->AppProtocol.array[i].VersionNumberMajor;
+        shm_msg->AppProtocol[i].VersionNumberMinor = (unsigned int) exi->AppProtocol.array[i].VersionNumberMinor;
+
+        //SchemaID
+        shm_msg->AppProtocol[i].SchemaID = (unsigned char) exi->AppProtocol.array[i].SchemaID;
+
+        //Priority
+        shm_msg->AppProtocol[i].Priority = (unsigned char) exi->AppProtocol.array[i].Priority;
+    }
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_din_SessionSetupReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_din_SessionSetupReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct SessionSetupRequest_DIN70121 *shm_msg;
+    struct dinSessionSetupReqType *exi;
+
+    shm_msg = &shm_ccs->V2GMessage_DIN70121.SessionSetupRequest;
+    exi = &exi_doc_DIN->V2G_Message.Body.SessionSetupReq;
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_din_V2GMSG_Header(buf);
+
+	//EVCCID Length
+	EVCOMM_SYS_INFO.EVCCID_length = (unsigned char)exi->EVCCID.bytesLen;
+	//EVCCID
+	for (i = 0; i < exi->EVCCID.bytesLen; i++)
+	{
+		shm_msg->EVCCID[i] = (unsigned char) exi->EVCCID.bytes[i];
+		EVCOMM_SYS_INFO.EVCCID[i] = (unsigned char) exi->EVCCID.bytes[i];
+	}
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_iso1_SessionSetupReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_iso1_SessionSetupReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct SessionSetupRequest_ISO15118_2014 *shm_msg;
+    struct iso1SessionSetupReqType *exi;
+
+    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.SessionSetupRequest;
+    exi = &exi_doc_ISO1->V2G_Message.Body.SessionSetupReq;
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_din_V2GMSG_Header(buf);
+
+	//EVCCID Length
+	EVCOMM_SYS_INFO.EVCCID_length = (unsigned char)exi->EVCCID.bytesLen;
+
+	//EVCCID
+	for (i = 0; i < exi->EVCCID.bytesLen; i++)
+	{
+		shm_msg->EVCCID[i] = (unsigned char) exi->EVCCID.bytes[i];
+		EVCOMM_SYS_INFO.EVCCID[i] = (unsigned char) exi->EVCCID.bytes[i];
+	}
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_iso2_SessionSetupReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_iso2_SessionSetupReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct SessionSetupRequest_ISO15118_2018 *shm_msg;
+    struct iso2SessionSetupReqType *exi;
+
+    shm_msg = &shm_ccs->V2GMessage_ISO15118_2018.SessionSetupRequest;
+    exi = &exi_doc_ISO2->V2G_Message.Body.SessionSetupReq;
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_din_V2GMSG_Header(buf);
+
+	//EVCCID Length
+	EVCOMM_SYS_INFO.EVCCID_length = (unsigned char)exi->EVCCID.bytesLen;
+
+
+	//EVCCID
+	for (i = 0; i < exi->EVCCID.bytesLen; i++)
+	{
+		shm_msg->EVCCID[i] = (unsigned char) exi->EVCCID.bytes[i];
+		EVCOMM_SYS_INFO.EVCCID[i] = (unsigned char) exi->EVCCID.bytes[i];
+	}
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_din_ServiceDiscoveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_din_ServiceDiscoveryReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct ServiceDiscoveryRequest_DIN70121 *shm_msg;
+    struct dinServiceDiscoveryReqType *exi;
+
+    shm_msg = &shm_ccs->V2GMessage_DIN70121.ServiceDiscoveryRequest;
+    exi = &exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq;
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_din_V2GMSG_Header(buf);
+
+	//ServiceScope
+	shm_msg->ServiceScopeLen = (unsigned int) exi->ServiceScope.charactersLen;
+    for (i = 0; i <shm_msg->ServiceScopeLen ; i++)
+    {
+        shm_msg->ServiceScope[i] = (unsigned char) exi->ServiceScope.characters[i];
+    }
+
+    //ServiceCategory
+    shm_msg->ServiceCategory = (unsigned int) exi->ServiceCategory;
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_iso1_ServiceDiscoveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_iso1_ServiceDiscoveryReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct ServiceDiscoveryRequest_ISO15118_2014 *shm_msg;
+    struct iso1ServiceDiscoveryReqType *exi;
+
+    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.ServiceDiscoveryRequest;
+    exi = &exi_doc_ISO1->V2G_Message.Body.ServiceDiscoveryReq;
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_iso1_V2GMSG_Header(buf);
+
+	//ServiceScope
+	shm_msg->ServiceScopeLen = (unsigned int) exi->ServiceScope.charactersLen;
+    for (i = 0; i <shm_msg->ServiceScopeLen ; i++)
+    {
+        shm_msg->ServiceScope[i] = (unsigned char) exi->ServiceScope.characters[i];
+    }
+
+    //ServiceCategory
+    shm_msg->ServiceCategory = (unsigned int) exi->ServiceCategory;
+}
+
+
+void SHM_Save_iso1_ServiceDetailReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct ServiceDetailRequest_ISO15118_2014 *shm_msg;
+    struct iso1ServiceDetailReqType *exi;
+
+    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.ServiceDetailRequest;
+    exi = &exi_doc_ISO1->V2G_Message.Body.ServiceDetailReq;
+
+	//ServiceScope
+	shm_msg->ServiceID = (unsigned int) exi->ServiceID;
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Save_din_ServiceAndPaymentSelectionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_din_ServiceAndPaymentSelectionReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct ServiceAndPaymentSelectionRequest_DIN70121 *shm_msg;
+    struct dinServicePaymentSelectionReqType *exi;
+
+    shm_msg = &shm_ccs->V2GMessage_DIN70121.ServiceAndPaymentSelectionRequest;
+    exi = &exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq;
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_din_V2GMSG_Header(buf);
+
+	//[1/2] SelectedPaymentOption
+	shm_msg->SelectedPaymentOption = (unsigned char) exi->SelectedPaymentOption;
+
+	//[2/2] SelectedServiceList
+    shm_msg->SelectedServiceList.SelectedServiceLen = (unsigned int) exi->SelectedServiceList.SelectedService.arrayLen;
+    for (i = 0; i< shm_msg->SelectedServiceList.SelectedServiceLen; i++)
+    {
+        shm_msg->SelectedServiceList.SelectedService[i].ServiceID =
+				(unsigned short) exi->SelectedServiceList.SelectedService.array[i].ServiceID;
+
+        shm_msg->SelectedServiceList.SelectedService[i].ParameterSetID =
+				(short) exi->SelectedServiceList.SelectedService.array[i].ParameterSetID;
+    }
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_iso1_ServiceAndPaymentSelectionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_iso1_ServiceAndPaymentSelectionReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct ServiceAndPaymentSelectionRequest_ISO15118_2014 *shm_msg;
+    struct iso1PaymentServiceSelectionReqType *exi;
+
+    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.ServiceAndPaymentSelectionRequest;
+    exi = &exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq;
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_iso1_V2GMSG_Header(buf);
+
+	//[1/2] SelectedPaymentOption
+	shm_msg->SelectedPaymentOption = (unsigned char) exi->SelectedPaymentOption;
+
+	//[2/2] SelectedServiceList
+    shm_msg->SelectedServiceList.SelectedServiceLen = (unsigned int) exi->SelectedServiceList.SelectedService.arrayLen;
+    for (i = 0; i< shm_msg->SelectedServiceList.SelectedServiceLen; i++)
+    {
+        shm_msg->SelectedServiceList.SelectedService[i].ServiceID =
+				(unsigned short) exi->SelectedServiceList.SelectedService.array[i].ServiceID;
+
+        shm_msg->SelectedServiceList.SelectedService[i].ParameterSetID =
+				(short) exi->SelectedServiceList.SelectedService.array[i].ParameterSetID;
+    }
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Save_din_ContractAuthenticationReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_din_ContractAuthenticationReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct ContractAuthenticationRequest_DIN70121 *shm_msg;
+    struct dinContractAuthenticationReqType *exi;
+
+    shm_msg = &shm_ccs->V2GMessage_DIN70121.ContractAuthenticationRequest;
+    exi = &exi_doc_DIN->V2G_Message.Body.ContractAuthenticationReq;
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_din_V2GMSG_Header(buf);
+
+	//none
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_iso1_AuthorizationReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_iso1_AuthorizationReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct AuthorizationRequest_ISO15118_2014 *shm_msg;
+    struct iso1AuthorizationReqType *exi;
+
+    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.AuthorizationRequest;
+    exi = &exi_doc_ISO1->V2G_Message.Body.AuthorizationReq;
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_iso1_V2GMSG_Header(buf);
+
+	//none
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_din_ChargeParameterDiscoveryReq
+DESCRIPTION: Save into share memories
+			(1) ShmCcsData (shm_ccs)
+			(2) ShmSysConfigAndInfo (shm_sys)
+
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_din_ChargeParameterDiscoveryReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct ChargeParameterDiscoveryRequest_DIN70121 *shm_msg;
+    struct dinChargeParameterDiscoveryReqType *exi;
+	struct ChargingInfoData *sys;
+
+    shm_msg = &shm_ccs->V2GMessage_DIN70121.ChargeParameterDiscoveryRequest;
+    exi = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq;
+	sys = &shm_sys->SysInfo.CcsChargingData[0];
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_din_V2GMSG_Header(buf);
+
+	//===== [BODY (1/9)] EVRequestedEnergyTransferType =====
+	shm_msg->EVRequestedEnergyTransferType = (unsigned char) exi->EVRequestedEnergyTransferType;
+
+	//===== [BODY (2/9)] DC_EVChargeParameter of EVChargeParameter =====
+    //DC_EVStatus
+    shm_msg->DC_EVChargeParameter.DC_EVStatus.EVReady = (BOOL) exi->DC_EVChargeParameter.DC_EVStatus.EVReady;
+	shm_msg->DC_EVChargeParameter.DC_EVStatus.EVCabinConditioning = (BOOL) exi->DC_EVChargeParameter.DC_EVStatus.EVCabinConditioning;
+	shm_msg->DC_EVChargeParameter.DC_EVStatus.EVRESSConiditioning = (BOOL) exi->DC_EVChargeParameter.DC_EVStatus.EVRESSConditioning;
+	shm_msg->DC_EVChargeParameter.DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVChargeParameter.DC_EVStatus.EVErrorCode;
+	shm_msg->DC_EVChargeParameter.DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVChargeParameter.DC_EVStatus.EVRESSSOC;
+	sys->EvBatterySoc = (int) shm_msg->DC_EVChargeParameter.DC_EVStatus.EVRESSSOC;
+
+    //[BODY (3/9)] EVMaximumCurrentLimit
+    shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Multiplier =
+			(int) exi->DC_EVChargeParameter.EVMaximumCurrentLimit.Multiplier;
+	//shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Unit = (unsigned char) exi->DC_EVChargeParameter.EVMaximumCurrentLimit.Unit;
+	shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Unit = A_DIN70121;
+	shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Value =
+			(short) exi->DC_EVChargeParameter.EVMaximumCurrentLimit.Value;
+	sys->EvBatteryMaxCurrent = DIN70121PhyValDecode(shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit);
+
+    //[BODY (4/9)] EVMaximumPowerLimit
+	shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Multiplier =
+			(int) exi->DC_EVChargeParameter.EVMaximumPowerLimit.Multiplier;
+	//shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Unit = (unsigned char) exi->DC_EVChargeParameter.EVMaximumPowerLimit.Unit;
+	shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Unit = W_DIN70121;
+	shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Value =
+			(short) exi->DC_EVChargeParameter.EVMaximumPowerLimit.Value;
+	sys->EvBatteryMaxPower = DIN70121PhyValDecode(shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit);
+
+    //[BODY (5/9)] EVMaximumVoltageLimit
+	shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Multiplier =
+			(int) exi->DC_EVChargeParameter.EVMaximumVoltageLimit.Multiplier;
+	//shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Unit = (unsigned char) exi->DC_EVChargeParameter.EVMaximumVoltageLimit.Unit;
+	shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Unit = V_DIN70121;
+	shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Value =
+			(short) exi->DC_EVChargeParameter.EVMaximumVoltageLimit.Value;
+	sys->EvBatteryMaxVoltage = DIN70121PhyValDecode(shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit);
+
+    //[BODY (6/9)] EVEnergyCapacity
+	shm_msg->DC_EVChargeParameter.EVEnergyCapacity.Multiplier =
+			(int) exi->DC_EVChargeParameter.EVEnergyCapacity.Multiplier;
+	shm_msg->DC_EVChargeParameter.EVEnergyCapacity.Unit = WH_DIN70121;
+	shm_msg->DC_EVChargeParameter.EVEnergyCapacity.Value =
+			(short) exi->DC_EVChargeParameter.EVEnergyCapacity.Value;
+	sys->EvBatteryCapacity = DIN70121PhyValDecode(shm_msg->DC_EVChargeParameter.EVEnergyCapacity);
+
+    //[BODY (7/9)] EVEnergyRequest
+	shm_msg->DC_EVChargeParameter.EVEnergyRequest.Multiplier =
+			(int) exi->DC_EVChargeParameter.EVEnergyRequest.Multiplier;
+	shm_msg->DC_EVChargeParameter.EVEnergyRequest.Unit = WH_DIN70121;
+	shm_msg->DC_EVChargeParameter.EVEnergyRequest.Value =
+			(short) exi->DC_EVChargeParameter.EVEnergyRequest.Value;
+	sys->EvBatteryEngergyRequest = DIN70121PhyValDecode(shm_msg->DC_EVChargeParameter.EVEnergyRequest);
+
+    //[BODY (8/9)] FullSOC
+	if (exi->DC_EVChargeParameter.FullSOC_isUsed != 0 && exi->DC_EVChargeParameter.FullSOC != 0)
+	{
+		shm_msg->DC_EVChargeParameter.FullSOC = (unsigned char) exi->DC_EVChargeParameter.FullSOC;
+	}
+	else
+	{
+		shm_msg->DC_EVChargeParameter.FullSOC = (unsigned char) exi->DC_EVChargeParameter.BulkSOC;
+	}
+
+    //[BODY (9/9)] BulkSOC
+    shm_msg->DC_EVChargeParameter.BulkSOC = (unsigned char) exi->DC_EVChargeParameter.BulkSOC;
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_iso1_ChargeParameterDiscoveryReq
+DESCRIPTION: Save into share memories
+			(1) ShmCcsData (shm_ccs)
+			(2) ShmSysConfigAndInfo (shm_sys)
+
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_iso1_ChargeParameterDiscoveryReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct ChargeParameterDiscoveryRequest_ISO15118_2014 *shm_msg;
+    struct iso1ChargeParameterDiscoveryReqType *exi;
+	struct ChargingInfoData *sys;
+
+    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryRequest;
+    exi = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq;
+	sys = &shm_sys->SysInfo.CcsChargingData[0];
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_iso1_V2GMSG_Header(buf);
+
+	//===== [BODY (1/9)] EVRequestedEnergyTransferType =====
+	shm_msg->RequestedEnergyTransferMode = (unsigned char) exi->RequestedEnergyTransferMode;
+
+	//===== [BODY (2/9)] DC_EVChargeParameter of EVChargeParameter =====
+	//AC_EVChargeParameter
+	if(exi->RequestedEnergyTransferMode <= 1)//0 for 1P, 1 for 3P
+	{	
+		if(exi->AC_EVChargeParameter.DepartureTime_isUsed != 0)
+		 	shm_msg->AC_EVChargeParameter.DepartureTime =  exi->AC_EVChargeParameter.DepartureTime;
+		 
+		 shm_msg->AC_EVChargeParameter.EAmount.Multiplier =  (int) exi->AC_EVChargeParameter.EAmount.Multiplier;
+		 shm_msg->AC_EVChargeParameter.EAmount.Unit = exi->AC_EVChargeParameter.EAmount.Unit;
+		 shm_msg->AC_EVChargeParameter.EAmount.Value = (short)exi->AC_EVChargeParameter.EAmount.Value;
+	 
+		 shm_msg->AC_EVChargeParameter.EVMaxVoltage.Multiplier =  (int) exi->AC_EVChargeParameter.EVMaxVoltage.Multiplier;
+		 shm_msg->AC_EVChargeParameter.EVMaxVoltage.Unit = exi->AC_EVChargeParameter.EVMaxVoltage.Unit;
+		 shm_msg->AC_EVChargeParameter.EVMaxVoltage.Value = (short)exi->AC_EVChargeParameter.EVMaxVoltage.Value;
+	 
+		 shm_msg->AC_EVChargeParameter.EVMaxCurrent.Multiplier =  (int) exi->AC_EVChargeParameter.EVMaxCurrent.Multiplier;
+		 shm_msg->AC_EVChargeParameter.EVMaxCurrent.Unit = exi->AC_EVChargeParameter.EVMaxCurrent.Unit;
+		 shm_msg->AC_EVChargeParameter.EVMaxCurrent.Value = (short)exi->AC_EVChargeParameter.EVMaxCurrent.Value;
+		 
+		 shm_msg->AC_EVChargeParameter.EVMinCurrent.Multiplier =  (int) exi->AC_EVChargeParameter.EVMinCurrent.Multiplier;
+		 shm_msg->AC_EVChargeParameter.EVMinCurrent.Unit = exi->AC_EVChargeParameter.EVMinCurrent.Unit;
+		 shm_msg->AC_EVChargeParameter.EVMinCurrent.Value = (short)exi->AC_EVChargeParameter.EVMinCurrent.Value;
+	 
+	}
+	else
+	{	
+	    //DC_EVStatus
+	    shm_msg->DC_EVChargeParameter.DC_EVStatus.EVReady = (BOOL) exi->DC_EVChargeParameter.DC_EVStatus.EVReady;
+		shm_msg->DC_EVChargeParameter.DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVChargeParameter.DC_EVStatus.EVErrorCode;
+		shm_msg->DC_EVChargeParameter.DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVChargeParameter.DC_EVStatus.EVRESSSOC;
+		sys->EvBatterySoc = (int) shm_msg->DC_EVChargeParameter.DC_EVStatus.EVRESSSOC;
+
+	    //[BODY (3/9)] EVMaximumCurrentLimit
+	    shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Multiplier =
+				(int) exi->DC_EVChargeParameter.EVMaximumCurrentLimit.Multiplier;
+		//shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Unit = (unsigned char) exi->DC_EVChargeParameter.EVMaximumCurrentLimit.Unit;
+		shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Unit = A_ISO15118_2014;
+		shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit.Value =
+				(short) exi->DC_EVChargeParameter.EVMaximumCurrentLimit.Value;
+		sys->EvBatteryMaxCurrent = ISO151182014PhyValDecode(shm_msg->DC_EVChargeParameter.EVMaximumCurrentLimit);
+
+	    //[BODY (4/9)] EVMaximumPowerLimit
+		shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Multiplier =
+				(int) exi->DC_EVChargeParameter.EVMaximumPowerLimit.Multiplier;
+		//shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Unit = (unsigned char) exi->DC_EVChargeParameter.EVMaximumPowerLimit.Unit;
+		shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Unit = W_ISO15118_2014;
+		shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit.Value =
+				(short) exi->DC_EVChargeParameter.EVMaximumPowerLimit.Value;
+		sys->EvBatteryMaxPower = ISO151182014PhyValDecode(shm_msg->DC_EVChargeParameter.EVMaximumPowerLimit);
+
+	    //[BODY (5/9)] EVMaximumVoltageLimit
+		shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Multiplier =
+				(int) exi->DC_EVChargeParameter.EVMaximumVoltageLimit.Multiplier;
+		//shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Unit = (unsigned char) exi->DC_EVChargeParameter.EVMaximumVoltageLimit.Unit;
+		shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Unit = V_ISO15118_2014;
+		shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit.Value =
+				(short) exi->DC_EVChargeParameter.EVMaximumVoltageLimit.Value;
+		sys->EvBatteryMaxVoltage = ISO151182014PhyValDecode(shm_msg->DC_EVChargeParameter.EVMaximumVoltageLimit);
+
+	    //[BODY (6/9)] EVEnergyCapacity
+		shm_msg->DC_EVChargeParameter.EVEnergyCapacity.Multiplier =
+				(int) exi->DC_EVChargeParameter.EVEnergyCapacity.Multiplier;
+		shm_msg->DC_EVChargeParameter.EVEnergyCapacity.Unit = Wh_ISO15118_2014;
+		shm_msg->DC_EVChargeParameter.EVEnergyCapacity.Value =
+				(short) exi->DC_EVChargeParameter.EVEnergyCapacity.Value;
+		sys->EvBatteryCapacity = ISO151182014PhyValDecode(shm_msg->DC_EVChargeParameter.EVEnergyCapacity);
+
+	    //[BODY (7/9)] EVEnergyRequest
+		shm_msg->DC_EVChargeParameter.EVEnergyRequest.Multiplier =
+				(int) exi->DC_EVChargeParameter.EVEnergyRequest.Multiplier;
+		shm_msg->DC_EVChargeParameter.EVEnergyRequest.Unit = Wh_ISO15118_2014;
+		shm_msg->DC_EVChargeParameter.EVEnergyRequest.Value =
+				(short) exi->DC_EVChargeParameter.EVEnergyRequest.Value;
+		sys->EvBatteryEngergyRequest = ISO151182014PhyValDecode(shm_msg->DC_EVChargeParameter.EVEnergyRequest);
+
+	    //[BODY (8/9)] FullSOC
+		if (exi->DC_EVChargeParameter.FullSOC_isUsed != 0 && exi->DC_EVChargeParameter.FullSOC != 0)
+		{
+			shm_msg->DC_EVChargeParameter.FullSOC = (unsigned char) exi->DC_EVChargeParameter.FullSOC;
+		}
+		else
+		{
+			shm_msg->DC_EVChargeParameter.FullSOC = (unsigned char) exi->DC_EVChargeParameter.BulkSOC;
+		}
+
+	    //[BODY (9/9)] BulkSOC
+	    shm_msg->DC_EVChargeParameter.BulkSOC = (unsigned char) exi->DC_EVChargeParameter.BulkSOC;
+	  }
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Save_din_CableCheckReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_din_CableCheckReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    struct CableCheckRequest_DIN70121 *shm_msg;
+    struct dinCableCheckReqType *exi;
+	struct ChargingInfoData *sys;
+
+    shm_msg = &shm_ccs->V2GMessage_DIN70121.CableCheckRequest;
+    exi = &exi_doc_DIN->V2G_Message.Body.CableCheckReq;
+	sys = &shm_sys->SysInfo.CcsChargingData[0];
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_din_V2GMSG_Header(buf);
+
+
+	//===== [BODY (1/1)] DC_EVStatus =====
+    //DC_EVStatus
+    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
+	shm_msg->DC_EVStatus.EVCabinConditioning = (BOOL) exi->DC_EVStatus.EVCabinConditioning;
+	shm_msg->DC_EVStatus.EVRESSConiditioning = (BOOL) exi->DC_EVStatus.EVRESSConditioning;
+	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
+	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
+	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;
+
+	//Check for EVReady
+	//if (shm_msg->DC_EVStatus.EVReady == TRUE && shm_msg->DC_EVStatus.EVErrorCode == NO_ERROR)
+	//{
+		//sys->ConnectorLocked = TRUE;    //Inicating EVSE that the CCS Connector is Locked.
+	//}
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_iso1_CableCheckReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_iso1_CableCheckReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    struct CableCheckRequest_ISO15118_2014 *shm_msg;
+    struct iso1CableCheckReqType *exi;
+	struct ChargingInfoData *sys;
+
+    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.CableCheckRequest;
+    exi = &exi_doc_ISO1->V2G_Message.Body.CableCheckReq;
+	sys = &shm_sys->SysInfo.CcsChargingData[0];
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_iso1_V2GMSG_Header(buf);
+
+
+	//===== [BODY (1/1)] DC_EVStatus =====
+    //DC_EVStatus
+    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
+	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
+	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
+	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;
+
+	//Check for EVReady
+	//if (shm_msg->DC_EVStatus.EVReady == TRUE && shm_msg->DC_EVStatus.EVErrorCode == NO_ERROR)
+	//{
+		//sys->ConnectorLocked = TRUE;    //Inicating EVSE that the CCS Connector is Locked.
+	//}
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Save_din_PreChargeReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_din_PreChargeReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    struct PreChargeRequest_DIN70121 *shm_msg;
+    struct dinPreChargeReqType *exi;
+	struct ChargingInfoData *sys;
+
+    shm_msg = &shm_ccs->V2GMessage_DIN70121.PreChargeRequest;
+    exi = &exi_doc_DIN->V2G_Message.Body.PreChargeReq;
+	sys = &shm_sys->SysInfo.CcsChargingData[0];
+
+	shm_msg->cnt++;
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_din_V2GMSG_Header(buf);
+
+
+	//===== [BODY (1/3)] DC_EVStatus =====
+    //DC_EVStatus
+    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
+	shm_msg->DC_EVStatus.EVCabinConditioning = (BOOL) exi->DC_EVStatus.EVCabinConditioning;
+	shm_msg->DC_EVStatus.EVRESSConiditioning = (BOOL) exi->DC_EVStatus.EVRESSConditioning;
+	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
+	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
+	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;
+
+	//[BODY (2/3)] EVTargetVoltage
+    shm_msg->EVTargetVoltage.Multiplier = (int) exi->EVTargetVoltage.Multiplier;
+	//shm_msg->EVTargetVoltage.Unit = (unsigned char) exi->EVTargetVoltage.Unit;
+	shm_msg->EVTargetVoltage.Unit = V_DIN70121;
+	shm_msg->EVTargetVoltage.Value = (short) exi->EVTargetVoltage.Value;
+	if ((sys->EVSEPrechargeStatus == EVSE_STATUS_NOT_READY_FOR_PRECHARGE) || (shm_msg->cnt <= 2)) //0
+	{
+		sys->EvBatterytargetVoltage = 0;	//0V, in order to avoid of turning off relay when D+/D- owns voltage.
+	}
+	else if (sys->EVSEPrechargeStatus == EVSE_STATUS_READY_FOR_PRECHARGE) //2
+	{
+		sys->EvBatterytargetVoltage = DIN70121PhyValDecode(shm_msg->EVTargetVoltage);
+		//sys->EvBatterytargetVoltage = DIN70121PhyValDecode(shm_msg->EVTargetVoltage) + 5;	//for test, add 10V
+	}
+
+	//[BODY (3/3)] EVTargetCurrent
+    shm_msg->EVTargetCurrent.Multiplier = (int) exi->EVTargetCurrent.Multiplier;
+	//shm_msg->EVTargetCurrent.Unit = (unsigned char) exi->EVTargetCurrent.Unit;
+	shm_msg->EVTargetCurrent.Unit = A_DIN70121;
+	shm_msg->EVTargetCurrent.Value = (short) exi->EVTargetCurrent.Value;
+	if (sys->EVSEPrechargeStatus == EVSE_STATUS_READY_FOR_PRECHARGE) //2
+	{
+		//sys->EvBatteryMaxCurrent = DIN70121PhyValDecode(shm_msg->EVTargetCurrent);
+		sys->EvBatterytargetCurrent = PRECHARGE_TARGET_CURRENT;	//for EVSE (default: 2A)
+	}
+	else
+	{
+		sys->EvBatterytargetCurrent = 0;	//0A
+	}
+	//printf("\n\n[%d-th]sys-EvBatterytargetVoltage = %.02f (ori = %d)\n\n", cnt, sys->EvBatterytargetVoltage, shm_msg->EVTargetVoltage.Value);
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_iso1_PreChargeReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_iso1_PreChargeReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    struct PreChargeRequest_ISO15118_2014 *shm_msg;
+    struct iso1PreChargeReqType *exi;
+	struct ChargingInfoData *sys;
+
+    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.PreChargeRequest;
+    exi = &exi_doc_ISO1->V2G_Message.Body.PreChargeReq;
+	sys = &shm_sys->SysInfo.CcsChargingData[0];
+
+	shm_msg->cnt++;
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_iso1_V2GMSG_Header(buf);
+
+
+	//===== [BODY (1/3)] DC_EVStatus =====
+    //DC_EVStatus
+    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
+	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
+	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
+	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;
+
+	//[BODY (2/3)] EVTargetVoltage
+    shm_msg->EVTargetVoltage.Multiplier = (int) exi->EVTargetVoltage.Multiplier;
+	//shm_msg->EVTargetVoltage.Unit = (unsigned char) exi->EVTargetVoltage.Unit;
+	shm_msg->EVTargetVoltage.Unit = V_ISO15118_2014;
+	shm_msg->EVTargetVoltage.Value = (short) exi->EVTargetVoltage.Value;
+	if ((sys->EVSEPrechargeStatus == EVSE_STATUS_NOT_READY_FOR_PRECHARGE) || (shm_msg->cnt <= 2)) //0
+	{
+		sys->EvBatterytargetVoltage = 0;	//0V, in order to avoid of turning off relay when D+/D- owns voltage.
+	}
+	else if (sys->EVSEPrechargeStatus == EVSE_STATUS_READY_FOR_PRECHARGE) //2
+	{
+		sys->EvBatterytargetVoltage = ISO151182014PhyValDecode(shm_msg->EVTargetVoltage);
+	}
+
+	//[BODY (3/3)] EVTargetCurrent
+    shm_msg->EVTargetCurrent.Multiplier = (int) exi->EVTargetCurrent.Multiplier;
+	//shm_msg->EVTargetCurrent.Unit = (unsigned char) exi->EVTargetCurrent.Unit;
+	shm_msg->EVTargetCurrent.Unit = A_ISO15118_2014;
+	shm_msg->EVTargetCurrent.Value = (short) exi->EVTargetCurrent.Value;
+	if (sys->EVSEPrechargeStatus == EVSE_STATUS_READY_FOR_PRECHARGE) //2
+	{
+		//sys->EvBatteryMaxCurrent = ISO151182014PhyValDecode(shm_msg->EVTargetCurrent);
+		sys->EvBatterytargetCurrent = PRECHARGE_TARGET_CURRENT;	//for EVSE (default: 2A)
+	}
+	else
+	{
+		sys->EvBatterytargetCurrent = 0;	//0A
+	}
+	//printf("\n\n[%d-th]sys-EvBatterytargetVoltage = %.02f (ori = %d)\n\n", cnt, sys->EvBatterytargetVoltage, shm_msg->EVTargetVoltage.Value);
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Save_din_PowerDeliveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_din_PowerDeliveryReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct PowerDeliveryRequest_DIN70121 *shm_msg;
+    struct dinPowerDeliveryReqType *exi;
+	struct ChargingInfoData *sys;
+
+    shm_msg = &shm_ccs->V2GMessage_DIN70121.PowerDeliveryRequest;
+    exi = &exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq;
+	sys = &shm_sys->SysInfo.CcsChargingData[0];
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_din_V2GMSG_Header(buf);
+
+
+	//[BODY (1/3)] ReadyToChargeState
+	shm_msg->ReadyToChargeState = (BOOL) exi->ReadyToChargeState;
+
+	//[BODY (2/3)] ChargingProfile
+
+	//[BODY (3/3)] DC_EVPowerDeliveryParameters
+	//DC_EVStatus
+	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVReady = (BOOL) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVReady;
+	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVCabinConditioning = (BOOL) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVCabinConditioning;
+	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSConiditioning = (BOOL) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSConditioning;
+	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode;
+	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSSOC;
+	sys->EvBatterySoc = (int) shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSSOC;
+
+	//BulkChargingComplete
+	shm_msg->DC_EVPowerDeliveryParameter.BulkChargingComplete = (BOOL) exi->DC_EVPowerDeliveryParameter.BulkChargingComplete;
+
+	//ChargingComplete
+	shm_msg->DC_EVPowerDeliveryParameter.ChargingComplete = (BOOL) exi->DC_EVPowerDeliveryParameter.ChargingComplete;
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_iso1_PowerDeliveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_iso1_PowerDeliveryReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct PowerDeliveryRequest_ISO15118_2014 *shm_msg;
+    struct iso1PowerDeliveryReqType *exi;
+	struct ChargingInfoData *sys;
+
+    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.PowerDeliveryRequest;
+    exi = &exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq;
+	sys = &shm_sys->SysInfo.CcsChargingData[0];
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_iso1_V2GMSG_Header(buf);
+
+
+	//[BODY (1/3)] ChargeProgress
+	shm_msg->ChargeProgress = (BOOL) exi->ChargeProgress;
+
+	//[BODY (2/3)] ChargingProfile
+
+	//[BODY (3/3)] DC_EVPowerDeliveryParameters
+	//DC_EVStatus
+	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVReady = (BOOL) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVReady;
+	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVErrorCode;
+	shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSSOC;
+	sys->EvBatterySoc = (int) shm_msg->DC_EVPowerDeliveryParameter.DC_EVStatus.EVRESSSOC;
+
+	//BulkChargingComplete
+	shm_msg->DC_EVPowerDeliveryParameter.BulkChargingComplete = (BOOL) exi->DC_EVPowerDeliveryParameter.BulkChargingComplete;
+
+	//ChargingComplete
+	shm_msg->DC_EVPowerDeliveryParameter.ChargingComplete = (BOOL) exi->DC_EVPowerDeliveryParameter.ChargingComplete;
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Save_din_CurrentDemandReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_din_CurrentDemandReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    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))
+	{
+		/*+++ vern, itme 5 in V0.24.S0, +++*/
+		//sys->EvBatterytargetVoltage = (DIN70121PhyValDecode(shm_msg->EVTargetVoltage) + sys->EvBatteryMaxVoltage)/2;
+		if((DIN70121PhyValDecode(shm_msg->EVTargetVoltage)+10)>=sys->EvBatteryMaxVoltage)
+			sys->EvBatterytargetVoltage = (DIN70121PhyValDecode(shm_msg->EVTargetVoltage) + sys->EvBatteryMaxVoltage)/2;
+		else
+			sys->EvBatterytargetVoltage =  DIN70121PhyValDecode(shm_msg->EVTargetVoltage)+10;
+		/*--- vern, itme 5 in V0.24.S0, ---*/	
+	}
+	else
+	{
+		sys->EvBatterytargetVoltage = DIN70121PhyValDecode(shm_msg->EVTargetVoltage);
+	}
+
+	#if MANUAL_SET_EV_TARGET_FUNCTION == ENABLE
+	sys->EvBatterytargetVoltage = SUDO_EV_TARGET_VOLTAGE;	//for test (500V, unit: 1V)
+	#endif
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_iso1_CurrentDemandReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_iso1_CurrentDemandReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    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;
+		/*+++ vern, itme 5 in V0.24.S0, +++*/
+		//sys->EvBatterytargetVoltage = (DIN70121PhyValDecode(shm_msg->EVTargetVoltage) + sys->EvBatteryMaxVoltage)/2;
+		if((ISO151182014PhyValDecode(shm_msg->EVTargetVoltage)+10)>=sys->EvBatteryMaxVoltage)
+			sys->EvBatterytargetVoltage = (ISO151182014PhyValDecode(shm_msg->EVTargetVoltage) + sys->EvBatteryMaxVoltage)/2;
+		else
+			sys->EvBatterytargetVoltage =  ISO151182014PhyValDecode(shm_msg->EVTargetVoltage)+10;
+		/*--- vern, itme 5 in V0.24.S0, ---*/	
+	}
+	else
+	{
+		sys->EvBatterytargetVoltage = ISO151182014PhyValDecode(shm_msg->EVTargetVoltage);
+	}
+
+	/*
+	printf("[SeccComm] <V_ev_target> = %d, %d, %.02f\n",
+			exi->EVTargetVoltage.Value,
+			shm_msg->EVTargetVoltage.Value,
+			sys->EvBatterytargetVoltage
+		  );
+	*/
+
+	#if MANUAL_SET_EV_TARGET_FUNCTION == ENABLE
+	sys->EvBatterytargetVoltage = SUDO_EV_TARGET_VOLTAGE;	//for test (500V, unit: 1V)
+	#endif
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Save_iso1_ChargingStatusReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_iso1_ChargingStatusReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
+{
+	//no content for ISO1
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_din_WeldingDetectionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_din_WeldingDetectionReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct WeldingDetectionRequest_DIN70121 *shm_msg;
+    struct dinWeldingDetectionReqType *exi;
+	struct ChargingInfoData *sys;
+
+    shm_msg = &shm_ccs->V2GMessage_DIN70121.WeldingDetectionRequest;
+    exi = &exi_doc_DIN->V2G_Message.Body.WeldingDetectionReq;
+	sys = &shm_sys->SysInfo.CcsChargingData[0];
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_din_V2GMSG_Header(buf);
+
+
+	//===== [BODY (1/3)] DC_EVStatus =====
+    //DC_EVStatus
+    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
+	shm_msg->DC_EVStatus.EVCabinConditioning = (BOOL) exi->DC_EVStatus.EVCabinConditioning;
+	shm_msg->DC_EVStatus.EVRESSConiditioning = (BOOL) exi->DC_EVStatus.EVRESSConditioning;
+	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
+	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
+	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_iso1_WeldingDetectionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_iso1_WeldingDetectionReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+    int i = 0;
+    struct WeldingDetectionRequest_ISO15118_2014 *shm_msg;
+    struct iso1WeldingDetectionReqType *exi;
+	struct ChargingInfoData *sys;
+
+    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.WeldingDetectionRequest;
+    exi = &exi_doc_ISO1->V2G_Message.Body.WeldingDetectionReq;
+	sys = &shm_sys->SysInfo.CcsChargingData[0];
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_iso1_V2GMSG_Header(buf);
+
+
+	//===== [BODY (1/3)] DC_EVStatus =====
+    //DC_EVStatus
+    shm_msg->DC_EVStatus.EVReady = (BOOL) exi->DC_EVStatus.EVReady;
+	shm_msg->DC_EVStatus.EVErrorCode = (unsigned char) exi->DC_EVStatus.EVErrorCode;
+	shm_msg->DC_EVStatus.EVRESSSOC = (unsigned char) exi->DC_EVStatus.EVRESSSOC;
+	sys->EvBatterySoc = (int) shm_msg->DC_EVStatus.EVRESSSOC;
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Save_din_SessionStopReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_din_SessionStopReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+	/*
+    int i = 0;
+    struct SessionStopRequest_DIN70121 *shm_msg;
+    struct dinSessionStopReqType *exi;
+
+    shm_msg = &shm_ccs->V2GMessage_DIN70121.SessionStopRequest;
+    exi = &exi_doc_DIN->V2G_Message.Body.SessionStopReq;
+	*/
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_din_V2GMSG_Header(buf);
+
+	//null
+}
+
+/*===========================================================================
+FUNCTION: SHM_Save_iso1_SessionStopReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Save_iso1_SessionStopReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys)
+{
+    // ======== [STEP 1/3] Initialize ========
+	/*
+    int i = 0;
+    struct SessionStopRequest_ISO15118_2014 *shm_msg;
+    struct iso1SessionStopReqType *exi;
+
+    shm_msg = &shm_ccs->V2GMessage_ISO15118_2014.SessionStopRequest;
+    exi = &exi_doc_ISO1->V2G_Message.Body.SessionStopReq;
+	*/
+
+    // ======== [STEP 2/3] Update Flags ========
+
+    // ======== [STEP 3/3] Transfer Data ========
+    //SHM_Save_iso1_V2GMSG_Header(buf);
+
+	//null
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Read_din_SessionSetupRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_DIN
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_din_SessionSetupRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
+{
+	int i = 0;
+	struct dinSessionSetupResType *out;
+	struct SessionSetupResponse_DIN70121 *in;
+
+	out = &exi_doc_DIN->V2G_Message.Body.SessionSetupRes;
+	in = &shm_ccs->V2GMessage_DIN70121.SessionSetupResponse;
+
+	exi_doc_DIN->V2G_Message.Body.SessionSetupRes_isUsed = 1u;
+
+	// ====== [BODY (1/3) ResponseCode ======
+	out->ResponseCode = in->ResponseCode;
+
+	// ====== [BODY (2/3) EVSEID ======
+	out->EVSEID.bytesLen = 32;  //max = 32  bytes(DIN), all zero
+	for (i = 0; i< 32; i++)
+	{
+		out->EVSEID.bytes[i] = (unsigned char) in->EVSEID[i];
+	}
+
+	// ====== [BODY (3/3) DateTimeNow ======
+	out->DateTimeNow_isUsed = 1u;
+	out->DateTimeNow = (int64_t) in->EVSETimeStamp;   //Format: Unix Time Stamp
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_din_ContractAuthenticationRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_DIN
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_din_ContractAuthenticationRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
+{
+	struct dinContractAuthenticationResType *out;
+	struct ContractAuthenticationResponse_DIN70121 *in;
+
+	out = &exi_doc_DIN->V2G_Message.Body.ContractAuthenticationRes;
+	in = &shm_ccs->V2GMessage_DIN70121.ContractAuthenticationResponse;
+
+	//[BODY (2/2)] EVSEProcessing
+	out->EVSEProcessing = (BOOL)in->EVSEProcessing; //0(Finished) or 1(Ongoing)
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Read_din_ChargeParameterDiscoveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_DIN
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_din_ChargeParameterDiscoveryRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
+{
+	struct dinChargeParameterDiscoveryResType *out;
+	struct ChargeParameterDiscoveryResponse_DIN70121 *in;
+
+	out = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryRes;
+	in = &shm_ccs->V2GMessage_DIN70121.ChargeParameterDiscoveryResponse;
+
+	//Initialize
+	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
+	init_dinChargeParameterDiscoveryResType(out);
+	exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryRes_isUsed = 1u;
+
+	//----- [BODY (1/5)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+
+    //----- [BODY (2/5)] EVSEProcessing -----
+    out->EVSEProcessing = (BOOL) in->EVSEProcessing;
+    // 	dinEVSEProcessingType_Finished = 0,
+    //	dinEVSEProcessingType_Ongoing = 1
+
+    //----- [BODY (3/5)] SAScheduleList of SASchedules -----
+	//[Joseph] Here keep constant values and not copy from share memory, yet.
+    out->SAScheduleList_isUsed = 1u;
+    struct dinSAScheduleListType *list;
+    list = &out->SAScheduleList;
+    //
+    list->SAScheduleTuple.arrayLen = 1;
+    list->SAScheduleTuple.array[0].SAScheduleTupleID = 0;
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleID = 0;
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.arrayLen = 1;
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval_isUsed = 1u;
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.start = 0;
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.duration = 86400;	//24Hrs at least, unit:second
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.duration_isUsed = 1u;
+     /*+++ 20200808, vern, add Pmax parameters in chargeParameters discovery +++*/
+    //in->DC_EVSEChargeParameter.EVSEMaximumPowerLimit.Value*=10;
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax = in->DC_EVSEChargeParameter.EVSEMaximumPowerLimit.Value;
+       /*--- 20200808, vern, add Pmax parameters in chargeParameters discovery ---*/
+    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval_isUsed = 1u;
+    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval = 600;
+    //list->SAScheduleTuple.array[0].SalesTariff.xxx
+    //list->SAScheduleTuple.array[0].SalesTariff_isUsed = 0u;
+
+
+    //-----  [BODY (4/5)] AC_EVSEChargeParameter of EVSEChargeParameter -----
+    //ignore, since DIN doesn't support AC
+
+    //----- [BODY (5/5)] DC_EVSEChargeParameter of EVSEChargeParameter -----
+    out->DC_EVSEChargeParameter_isUsed = 1u;
+    struct dinDC_EVSEChargeParameterType *out_dc_para;
+	struct DC_EVSEChargeParameterType_DIN70121 *in_dc_para;
+    out_dc_para = &out->DC_EVSEChargeParameter;
+	in_dc_para = &in->DC_EVSEChargeParameter;
+
+    //DC_EVSEStatus
+	out_dc_para->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+	SHM_Read_dinDC_EVSEStatusType(&out_dc_para->DC_EVSEStatus, &in_dc_para->DC_EVSEStatus);
+
+    //EVSEMaximumCurrentLimit
+	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEMaximumCurrentLimit, &in_dc_para->EVSEMaximumCurrentLimit);
+
+    //EVSEMaximumPowerLimit
+	out_dc_para->EVSEMaximumPowerLimit_isUsed = 1u;
+	
+	//in_dc_para->EVSEMaximumPowerLimit.Value=360;
+	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEMaximumPowerLimit, &in_dc_para->EVSEMaximumPowerLimit);
+
+    //EVSEMaximumVoltageLimit
+	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEMaximumVoltageLimit, &in_dc_para->EVSEMaximumVoltageLimit);
+
+    //EVSEMinimumVoltageLimit
+	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEMinimumVoltageLimit, &in_dc_para->EVSEMinimumVoltageLimit);
+
+
+    //EVSEMinimumCurrentLimit
+	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEMinimumCurrentLimit, &in_dc_para->EVSEMinimumCurrentLimit);
+
+    //EVSECurrentRegulationTolerance_isUsed
+    out_dc_para->EVSECurrentRegulationTolerance_isUsed = 1u;
+    //EVSECurrentRegulationTolerance
+	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSECurrentRegulationTolerance, &in_dc_para->EVSECurrentRegulationTolerance);
+
+    //EVSEEnergyToBeDelivered_isUsed
+    out_dc_para->EVSEEnergyToBeDelivered_isUsed = 0u;
+	//EVSEEnergyToBeDelivered (optional)
+    //SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEEnergyToBeDelivered, &in_dc_para->EVSEEnergyToBeDelivered);
+
+    //EVSEPeakCurrentRipple
+	SHM_Read_dinPhysicalValueType(&out_dc_para->EVSEPeakCurrentRipple, &in_dc_para->EVSEPeakCurrentRipple);
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_iso1_ChargeParameterDiscoveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_ISO1
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_iso1_ChargeParameterDiscoveryRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
+{
+	struct iso1ChargeParameterDiscoveryResType *out;
+	struct ChargeParameterDiscoveryResponse_ISO15118_2014 *in;
+
+	out = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryRes;
+	in = &shm_ccs->V2GMessage_ISO15118_2014.ChargeParameterDiscoveryResponse;
+
+	//Initialize
+	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
+	init_iso1ChargeParameterDiscoveryResType(out);
+	exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryRes_isUsed = 1u;
+
+	//----- [BODY (1/5)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+
+    //----- [BODY (2/5)] EVSEProcessing -----
+    out->EVSEProcessing = (BOOL) in->EVSEProcessing;
+    // 	iso1EVSEProcessingType_Finished = 0,
+    //	iso1EVSEProcessingType_Ongoing = 1
+
+    //----- [BODY (3/5)] SAScheduleList of SASchedules -----
+	//[Joseph] Here keep constant values and not copy from share memory, yet.
+    out->SAScheduleList_isUsed = 1u;
+    struct iso1SAScheduleListType *list;
+    list = &out->SAScheduleList;
+    //
+    list->SAScheduleTuple.arrayLen = 1;
+    list->SAScheduleTuple.array[0].SAScheduleTupleID = 1;
+    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleID = 0;
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.arrayLen = 1;
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval_isUsed = 1u;
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.start = 0;
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.duration = 86400;	//24Hrs at least, unit:second
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].RelativeTimeInterval.duration_isUsed = 1u;
+    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval_isUsed = 1u;
+    //list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].TimeInterval = 86400;
+    /*+++ 20200808, vern, add Pmax parameters in chargeParameters discovery +++*/
+   // in->DC_EVSEChargeParameter.EVSEMaximumPowerLimit.Value*=10;   /*+++ 20200808, vern, lack one more 0 ---*/
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax.Unit = iso1unitSymbolType_W;	//iso1unitSymbolType_W
+    #if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) | (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax.Multiplier = 0;	//w
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax.Value =((unsigned int)in->AC_EVSEChargeParameter.EVSEMaxCurrent.Value*(unsigned int)in->AC_EVSEChargeParameter.EVSENominalVoltage.Value)/100;	
+    #else
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax.Multiplier = 3;	//kw
+    list->SAScheduleTuple.array[0].PMaxSchedule.PMaxScheduleEntry.array[0].PMax.Value =in->DC_EVSEChargeParameter.EVSEMaximumPowerLimit.Value;	//30000 if DW/DM product
+    #endif
+    /*--- 20200808, vern, add Pmax parameters in chargeParameters discovery ---*/
+    //list->SAScheduleTuple.array[0].SalesTariff.xxx
+    //list->SAScheduleTuple.array[0].SalesTariff_isUsed = 0u;
+
+
+	//-----  [BODY (4/5)] AC/DC EVSEChargeParameter -----
+	#if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) | (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
+	{
+		//-----  [BODY (4/5)] AC_EVSEChargeParameter -----
+		out->AC_EVSEChargeParameter_isUsed = 1u;
+		struct iso1AC_EVSEChargeParameterType *out_ac_para;
+		struct AC_EVSEChargeParameterType_ISO15118_2014 *in_ac_para;
+		out_ac_para = &out->AC_EVSEChargeParameter;
+		in_ac_para = &in->AC_EVSEChargeParameter;
+
+		//[1/3] AC_EVSEStatus
+		SHM_Read_iso1AC_EVSEStatusType(&out_ac_para->AC_EVSEStatus, &in_ac_para->AC_EVSEStatus);
+
+		//[2/3] EVSENominalVoltage
+		SHM_Read_iso1PhysicalValueType(&out_ac_para->EVSENominalVoltage, &in_ac_para->EVSENominalVoltage);
+
+		//[3/3] EVSEMaxCurrent
+		SHM_Read_iso1PhysicalValueType(&out_ac_para->EVSEMaxCurrent, &in_ac_para->EVSEMaxCurrent);
+	}
+	#else //CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED
+	{
+		//----- [BODY (5/5)] DC_EVSEChargeParameter -----
+		out->DC_EVSEChargeParameter_isUsed = 1u;
+		struct iso1DC_EVSEChargeParameterType *out_dc_para;
+		struct DC_EVSEChargeParameterType_ISO15118_2014 *in_dc_para;
+		out_dc_para = &out->DC_EVSEChargeParameter;
+		in_dc_para = &in->DC_EVSEChargeParameter;
+
+		//DC_EVSEStatus
+		out_dc_para->DC_EVSEStatus.EVSEIsolationStatus_isUsed = 1u;
+		SHM_Read_iso1DC_EVSEStatusType(&out_dc_para->DC_EVSEStatus, &in_dc_para->DC_EVSEStatus);
+
+		//EVSEMaximumCurrentLimit
+		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEMaximumCurrentLimit, &in_dc_para->EVSEMaximumCurrentLimit);
+
+		//EVSEMaximumPowerLimit
+		//in_dc_para->EVSEMaximumPowerLimit.Value=360;
+		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEMaximumPowerLimit, &in_dc_para->EVSEMaximumPowerLimit);
+		
+		//EVSEMaximumVoltageLimit
+		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEMaximumVoltageLimit, &in_dc_para->EVSEMaximumVoltageLimit);
+
+		//EVSEMinimumVoltageLimit
+		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEMinimumVoltageLimit, &in_dc_para->EVSEMinimumVoltageLimit);
+
+
+		//EVSEMinimumCurrentLimit
+		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEMinimumCurrentLimit, &in_dc_para->EVSEMinimumCurrentLimit);
+
+		//EVSECurrentRegulationTolerance_isUsed
+		out_dc_para->EVSECurrentRegulationTolerance_isUsed = 1u;
+		//EVSECurrentRegulationTolerance
+		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSECurrentRegulationTolerance, &in_dc_para->EVSECurrentRegulationTolerance);
+
+		//EVSEEnergyToBeDelivered_isUsed
+		out_dc_para->EVSEEnergyToBeDelivered_isUsed = 0u;
+		//EVSEEnergyToBeDelivered (optional)
+		//SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEEnergyToBeDelivered, &in_dc_para->EVSEEnergyToBeDelivered);
+
+		//EVSEPeakCurrentRipple
+		SHM_Read_iso1PhysicalValueType(&out_dc_para->EVSEPeakCurrentRipple, &in_dc_para->EVSEPeakCurrentRipple);
+	}
+	#endif
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Read_din_CableCheckRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_DIN
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_din_CableCheckRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
+{
+	struct dinCableCheckResType *out;
+	struct CableCheckResponse_DIN70121 *in;
+
+	out = &exi_doc_DIN->V2G_Message.Body.CableCheckRes;
+	in = &shm_ccs->V2GMessage_DIN70121.CableCheckResponse;
+
+	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
+    init_dinCableCheckResType(out);
+	exi_doc_DIN->V2G_Message.Body.CableCheckRes_isUsed = 1u;
+
+	//----- [BODY (1/3)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+
+    //----- [BODY (2/3)] EVSEProcessing -----
+	out->EVSEProcessing = (BOOL) in->EVSEProcessing;
+    // 	dinEVSEProcessingType_Finished = 0,
+    //	dinEVSEProcessingType_Ongoing = 1
+
+    //----- [BODY (3/3)] DC_EVSEStatus -----
+	SHM_Read_dinDC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_iso1_CableCheckRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_ISO1
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_iso1_CableCheckRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
+{
+	struct iso1CableCheckResType *out;
+	struct CableCheckResponse_ISO15118_2014 *in;
+
+	out = &exi_doc_ISO1->V2G_Message.Body.CableCheckRes;
+	in = &shm_ccs->V2GMessage_ISO15118_2014.CableCheckResponse;
+
+	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
+    init_iso1CableCheckResType(out);
+	exi_doc_ISO1->V2G_Message.Body.CableCheckRes_isUsed = 1u;
+
+	//----- [BODY (1/3)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+
+    //----- [BODY (2/3)] EVSEProcessing -----
+	out->EVSEProcessing = (BOOL) in->EVSEProcessing;
+    // 	iso1EVSEProcessingType_Finished = 0,
+    //	iso1EVSEProcessingType_Ongoing = 1
+
+    //----- [BODY (3/3)] DC_EVSEStatus -----
+	SHM_Read_iso1DC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Read_din_PreChargeRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_DIN
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_din_PreChargeRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
+{
+	struct dinPreChargeResType *out;
+	struct PreChargeResponse_DIN70121 *in;
+
+	out = &exi_doc_DIN->V2G_Message.Body.PreChargeRes;
+	in = &shm_ccs->V2GMessage_DIN70121.PreChargeResponse;
+	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
+    init_dinPreChargeResType(&exi_doc_DIN->V2G_Message.Body.PreChargeRes);
+	exi_doc_DIN->V2G_Message.Body.PreChargeRes_isUsed = 1u;
+
+
+	//----- [BODY (1/3)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+
+
+    //----- [BODY (2/3)] EVSEPresentVoltage -----
+	SHM_Read_dinPhysicalValueType(&out->EVSEPresentVoltage, &in->EVSEPresentVoltage);
+    //	dinunitSymbolType_h = 0,
+    //	dinunitSymbolType_m = 1,
+    //	dinunitSymbolType_s = 2,
+    //	dinunitSymbolType_A = 3,
+    //	dinunitSymbolType_Ah = 4,
+    //	dinunitSymbolType_V = 5,
+    //	dinunitSymbolType_VA = 6,
+    //	dinunitSymbolType_W = 7,
+    //	dinunitSymbolType_W_s = 8,
+    //	dinunitSymbolType_Wh = 9
+
+
+    //----- [BODY (3/3)] DC_EVSEStatus -----
+	SHM_Read_dinDC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_iso1_PreChargeRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_ISO1
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_iso1_PreChargeRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
+{
+	struct iso1PreChargeResType *out;
+	struct PreChargeResponse_ISO15118_2014 *in;
+
+	out = &exi_doc_ISO1->V2G_Message.Body.PreChargeRes;
+	in = &shm_ccs->V2GMessage_ISO15118_2014.PreChargeResponse;
+	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
+    init_iso1PreChargeResType(&exi_doc_ISO1->V2G_Message.Body.PreChargeRes);
+	exi_doc_ISO1->V2G_Message.Body.PreChargeRes_isUsed = 1u;
+
+
+	//----- [BODY (1/3)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+
+
+    //----- [BODY (2/3)] EVSEPresentVoltage -----
+	SHM_Read_iso1PhysicalValueType(&out->EVSEPresentVoltage, &in->EVSEPresentVoltage);
+	//iso1unitSymbolType_h = 0,
+	//iso1unitSymbolType_m = 1,
+	//iso1unitSymbolType_s = 2,
+	//iso1unitSymbolType_A = 3,
+	//iso1unitSymbolType_V = 4,
+	//iso1unitSymbolType_W = 5,
+	//iso1unitSymbolType_Wh = 6
+
+
+    //----- [BODY (3/3)] DC_EVSEStatus -----
+	SHM_Read_iso1DC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Read_din_PowerDeliveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_DIN
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_din_PowerDeliveryRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
+{
+	struct dinPowerDeliveryResType *out;
+	struct PowerDeliveryResponse_DIN70121 *in;
+	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
+	init_dinPowerDeliveryResType(&exi_doc_DIN->V2G_Message.Body.PowerDeliveryRes);
+
+	out = &exi_doc_DIN->V2G_Message.Body.PowerDeliveryRes;
+	in = &shm_ccs->V2GMessage_DIN70121.PowerDeliveryResponse;
+	exi_doc_DIN->V2G_Message.Body.PowerDeliveryRes_isUsed = 1u;
+
+	//----- [BODY (1/3)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+
+
+    //----- [BODY (2/3)] AC_EVSEStatus -----
+    //ignore, since DIN 70121 doesn't support AC, yet.
+
+
+    //----- [BODY (2/3)] DC_EVSEStatus -----
+	out->DC_EVSEStatus_isUsed = 1u;
+	SHM_Read_dinDC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_iso1_PowerDeliveryRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_ISO1
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_iso1_PowerDeliveryRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
+{
+	struct iso1PowerDeliveryResType *out;
+	struct PowerDeliveryResponse_ISO15118_2014 *in;
+	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
+	init_iso1PowerDeliveryResType(&exi_doc_ISO1->V2G_Message.Body.PowerDeliveryRes);
+
+	out = &exi_doc_ISO1->V2G_Message.Body.PowerDeliveryRes;
+	in = &shm_ccs->V2GMessage_ISO15118_2014.PowerDeliveryResponse;
+	exi_doc_ISO1->V2G_Message.Body.PowerDeliveryRes_isUsed = 1u;
+
+	//----- [BODY (1/3)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+
+
+    //----- [BODY (2/3)] AC_EVSEStatus -----
+    //ignore, since our ISO1 70121 doesn't support AC, yet.
+
+
+    //----- [BODY (2/3)] DC_EVSEStatus -----
+	#if ((CCS_ENERGY_TRANSFER_MODE == MODE_AC_SINGLE_PHASE_CORE) | (CCS_ENERGY_TRANSFER_MODE == MODE_AC_THREE_PHASE_CORE))
+	{
+		out->DC_EVSEStatus_isUsed = 0u;
+		out->AC_EVSEStatus_isUsed = 1u;
+		SHM_Read_iso1AC_EVSEStatusType(&out->AC_EVSEStatus, &in->AC_EVSEStatus);
+	}
+	#else //CCS_ENERGY_TRANSFER_MODE == MODE_DC_EXTENDED
+	{
+		out->DC_EVSEStatus_isUsed = 1u;
+		SHM_Read_iso1DC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
+	}
+	#endif
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Read_din_CurrentDemandRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_DIN
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_din_CurrentDemandRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
+{
+	struct dinCurrentDemandResType *out;
+	struct CurrentDemandResponse_DIN70121 *in;
+	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
+	init_dinCurrentDemandResType(&exi_doc_DIN->V2G_Message.Body.CurrentDemandRes);
+
+	out = &exi_doc_DIN->V2G_Message.Body.CurrentDemandRes;
+	in = &shm_ccs->V2GMessage_DIN70121.CurrentDemandResponse;
+	exi_doc_DIN->V2G_Message.Body.CurrentDemandRes_isUsed = 1u;
+
+
+	//----- [BODY (1/10)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+
+    //----- [BODY (2/10)] DC_EVSEStatus -----
+    SHM_Read_dinDC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
+
+    //----- [BODY (3/10)] EVSEPresentVoltage -----
+	SHM_Read_dinPhysicalValueType(&out->EVSEPresentVoltage, &in->EVSEPresentVoltage);
+
+
+    //----- [BODY (4/10)] EVSEPresentCurrent -----
+	SHM_Read_dinPhysicalValueType(&out->EVSEPresentCurrent, &in->EVSEPresentCurrent);
+
+
+    //----- [BODY (5/10)] EVSECurrentLimitAchieved -----
+    out->EVSECurrentLimitAchieved = in->EVSECurrentLimitAchieved;
+
+    //----- [BODY (6/10)] EVSEVoltageLimitAchieved -----
+    out->EVSEVoltageLimitAchieved = in->EVSEVoltageLimitAchieved;
+
+    //----- [BODY (7/10)] EVSEPowerLimitAchieved -----
+    out->EVSEPowerLimitAchieved = in->EVSEPowerLimitAchieved;
+
+    //----- [BODY (8/10)] EVSEMaximumVoltageLimit -----
+    out->EVSEMaximumVoltageLimit_isUsed = 1u;
+	SHM_Read_dinPhysicalValueType(&out->EVSEMaximumVoltageLimit, &in->EVSEMaximumVoltageLimit);
+
+    //----- [BODY (9/10)] EVSEMaximumCurrentLimit -----
+    out->EVSEMaximumCurrentLimit_isUsed = 1u;
+	SHM_Read_dinPhysicalValueType(&out->EVSEMaximumCurrentLimit, &in->EVSEMaximumCurrentLimit);
+
+    //----- [BODY (10/10)] EVSEMaximumPowerLimit -----
+    out->EVSEMaximumPowerLimit_isUsed = 1u;
+	SHM_Read_dinPhysicalValueType(&out->EVSEMaximumPowerLimit, &in->EVSEMaximumPowerLimit);
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_iso1_CurrentDemandRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_ISO1
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_iso1_CurrentDemandRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
+{
+	struct iso1CurrentDemandResType *out;
+	struct CurrentDemandResponse_ISO15118_2014 *in;
+	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
+	init_iso1CurrentDemandResType(&exi_doc_ISO1->V2G_Message.Body.CurrentDemandRes);
+
+	out = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandRes;
+	in = &shm_ccs->V2GMessage_ISO15118_2014.CurrentDemandResponse;
+	exi_doc_ISO1->V2G_Message.Body.CurrentDemandRes_isUsed = 1u;
+
+	//vern, fill up necessary 
+	 out->EVSEID.charactersLen=7;
+	 out->EVSEID.characters[0]='Z';
+	 out->EVSEID.characters[1]='Z';
+	 out->EVSEID.characters[2]='0';
+	 out->EVSEID.characters[3]='0';
+	 out->EVSEID.characters[4]='0';
+	 out->EVSEID.characters[5]='0';
+	 out->EVSEID.characters[6]='0';
+	out->SAScheduleTupleID=1;
+	out->MeterInfo_isUsed=0u;
+	out->ReceiptRequired_isUsed=0u;
+	//----- [BODY (1/10)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+
+    //----- [BODY (2/10)] DC_EVSEStatus -----
+    SHM_Read_iso1DC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
+
+    //----- [BODY (3/10)] EVSEPresentVoltage -----
+	SHM_Read_iso1PhysicalValueType(&out->EVSEPresentVoltage, &in->EVSEPresentVoltage);
+
+
+    //----- [BODY (4/10)] EVSEPresentCurrent -----
+	SHM_Read_iso1PhysicalValueType(&out->EVSEPresentCurrent, &in->EVSEPresentCurrent);
+
+
+    //----- [BODY (5/10)] EVSECurrentLimitAchieved -----
+    out->EVSECurrentLimitAchieved = in->EVSECurrentLimitAchieved;
+
+    //----- [BODY (6/10)] EVSEVoltageLimitAchieved -----
+    out->EVSEVoltageLimitAchieved = in->EVSEVoltageLimitAchieved;
+
+    //----- [BODY (7/10)] EVSEPowerLimitAchieved -----
+    out->EVSEPowerLimitAchieved = in->EVSEPowerLimitAchieved;
+
+    //----- [BODY (8/10)] EVSEMaximumVoltageLimit -----
+    out->EVSEMaximumVoltageLimit_isUsed = 1u;
+	SHM_Read_iso1PhysicalValueType(&out->EVSEMaximumVoltageLimit, &in->EVSEMaximumVoltageLimit);
+
+    //----- [BODY (9/10)] EVSEMaximumCurrentLimit -----
+    out->EVSEMaximumCurrentLimit_isUsed = 1u;
+	SHM_Read_iso1PhysicalValueType(&out->EVSEMaximumCurrentLimit, &in->EVSEMaximumCurrentLimit);
+
+    //----- [BODY (10/10)] EVSEMaximumPowerLimit -----
+    out->EVSEMaximumPowerLimit_isUsed = 1u;
+	SHM_Read_iso1PhysicalValueType(&out->EVSEMaximumPowerLimit, &in->EVSEMaximumPowerLimit);
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_iso1_ChargingStatusRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_ISO1
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_iso1_ChargingStatusRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
+{
+	int i = 0;
+	struct iso1ChargingStatusResType *out;
+	struct ChargingStatusResponse_ISO15118_2014 *in;
+	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
+	init_iso1ChargingStatusResType(&exi_doc_ISO1->V2G_Message.Body.ChargingStatusRes);
+
+	out = &exi_doc_ISO1->V2G_Message.Body.ChargingStatusRes;
+	in = &shm_ccs->V2GMessage_ISO15118_2014.ChargingStatusResponse;
+	exi_doc_ISO1->V2G_Message.Body.ChargingStatusRes_isUsed = 1u;
+
+
+	//----- [BODY (1/10)] ResponseCode -----
+    out->ResponseCode = (unsigned char)in->ResponseCode;
+
+    //----- [BODY (2/10)] AC_EVSEStatus -----
+    SHM_Read_iso1AC_EVSEStatusType(&out->AC_EVSEStatus, &in->AC_EVSEStatus);
+
+    //----- [BODY (3/10)] EVSEMaxCurrent -----
+	out->EVSEMaxCurrent_isUsed = 1u;
+	SHM_Read_iso1PhysicalValueType(&out->EVSEMaxCurrent, &in->EVSEMaxCurrent);
+
+    //----- [BODY (4/10)] SAScheduleTupleID -----
+	out->SAScheduleTupleID = (unsigned char)in->SAScheduleTupleID;	//[CAUTION] data type
+
+    //----- [BODY (5/10)] EVSEID -----
+	out->EVSEID.charactersLen = 37;  //min length: 7, max length:37  bytes(ISO1, AC)
+	for (i = 0; i< out->EVSEID.charactersLen; i++)
+	{
+		out->EVSEID.characters[i] = (unsigned char)in->EVSEID[i];
+	}
+
+    //----- [BODY (6/10)] MeterInfo -----
+    out->MeterInfo_isUsed = 1u;
+	SHM_Read_iso1MeterInfo(&out->MeterInfo, &in->MeterInfo);
+
+    //----- [BODY (7/10)] ReceiptRequired -----
+    out->ReceiptRequired_isUsed = 1u;
+	out->ReceiptRequired = (int)in->ReceiptRequired;
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_din_WeldingDetectionRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_DIN
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_din_WeldingDetectionRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
+{
+	struct dinWeldingDetectionResType *out;
+	struct WeldingDetectionResponse_DIN70121 *in;
+	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
+	init_dinWeldingDetectionResType(&exi_doc_DIN->V2G_Message.Body.WeldingDetectionRes);
+
+
+	out = &exi_doc_DIN->V2G_Message.Body.WeldingDetectionRes;
+	in = &shm_ccs->V2GMessage_DIN70121.WeldingDetectionResponse;
+	exi_doc_DIN->V2G_Message.Body.WeldingDetectionRes_isUsed = 1u;
+
+
+	//----- [BODY (1/3)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+
+
+    //----- [BODY (2/3)] EVSEPresentVoltage -----
+	SHM_Read_dinPhysicalValueType(&out->EVSEPresentVoltage, &in->EVSEPresentVoltage);
+
+
+    //----- [BODY (3/3)] DC_EVSEStatus -----
+    SHM_Read_dinDC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_iso1_WeldingDetectionRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_ISO1
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_iso1_WeldingDetectionRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
+{
+	struct iso1WeldingDetectionResType *out;
+	struct WeldingDetectionResponse_ISO15118_2014 *in;
+	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
+	init_iso1WeldingDetectionResType(&exi_doc_ISO1->V2G_Message.Body.WeldingDetectionRes);
+
+
+	out = &exi_doc_ISO1->V2G_Message.Body.WeldingDetectionRes;
+	in = &shm_ccs->V2GMessage_ISO15118_2014.WeldingDetectionResponse;
+	exi_doc_ISO1->V2G_Message.Body.WeldingDetectionRes_isUsed = 1u;
+
+
+	//----- [BODY (1/3)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+
+
+    //----- [BODY (2/3)] EVSEPresentVoltage -----
+	SHM_Read_iso1PhysicalValueType(&out->EVSEPresentVoltage, &in->EVSEPresentVoltage);
+
+
+    //----- [BODY (3/3)] DC_EVSEStatus -----
+    SHM_Read_iso1DC_EVSEStatusType(&out->DC_EVSEStatus, &in->DC_EVSEStatus);
+}
+
+
+/*===========================================================================
+FUNCTION: SHM_Read_din_SessionStopRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_DIN
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_din_SessionStopRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs)
+{
+	struct dinSessionStopResType *out;
+	struct SessionStopResponse_DIN70121 *in;
+	init_dinBodyType(&exi_doc_DIN->V2G_Message.Body);
+	init_dinSessionStopResType(&exi_doc_DIN->V2G_Message.Body.SessionStopRes);
+
+	out = &exi_doc_DIN->V2G_Message.Body.SessionStopRes;
+	in = &shm_ccs->V2GMessage_DIN70121.SessionStopResponse;
+	exi_doc_DIN->V2G_Message.Body.SessionStopRes_isUsed = 1u;
+
+
+	//----- [BODY (1/3)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+}
+
+/*===========================================================================
+FUNCTION: SHM_Read_iso1_SessionStopRes
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+		1. shm_ccs
+OUTPUT:
+		2. exi_doc_ISO1
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void SHM_Read_iso1_SessionStopRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs)
+{
+	struct iso1SessionStopResType *out;
+	struct SessionStopResponse_ISO15118_2014 *in;
+	init_iso1BodyType(&exi_doc_ISO1->V2G_Message.Body);
+	init_iso1SessionStopResType(&exi_doc_ISO1->V2G_Message.Body.SessionStopRes);
+
+	out = &exi_doc_ISO1->V2G_Message.Body.SessionStopRes;
+	in = &shm_ccs->V2GMessage_ISO15118_2014.SessionStopResponse;
+	exi_doc_ISO1->V2G_Message.Body.SessionStopRes_isUsed = 1u;
+
+
+	//----- [BODY (1/3)] ResponseCode -----
+    out->ResponseCode = (unsigned char) in->ResponseCode;
+}
+
+
+/*===========================================================================
+FUNCTION: PRINT_V2G_MSG_din_Header
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_V2G_MSG_din_Header(struct dinEXIDocument *exi_doc_DIN)
+{
+    int i = 0;
+    int leng = 0;
+    leng = exi_doc_DIN->V2G_Message.Header.SessionID.bytesLen;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\t SessionID (%d Bytes) = ", leng);
+    for (i = 0; i <leng ; i++)
+    {
+        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_DIN->V2G_Message.Header.SessionID.bytes[i]);
+    }
+}
+
+/*===========================================================================
+FUNCTION: PRINT_V2G_MSG_iso1_Header
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_V2G_MSG_iso1_Header(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    int i = 0;
+    int leng = 0;
+    leng = exi_doc_ISO1->V2G_Message.Header.SessionID.bytesLen;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\t SessionID (%d Bytes) = ", leng);
+    for (i = 0; i <leng ; i++)
+    {
+        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_ISO1->V2G_Message.Header.SessionID.bytes[i]);
+    }
+}
+
+/*===========================================================================
+FUNCTION: PRINT_V2G_MSG_iso1_Header
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_V2G_MSG_iso2_Header(struct iso2EXIDocument *exi_doc_ISO2)
+{
+    int i = 0;
+    int leng = 0;
+    leng = exi_doc_ISO2->V2G_Message.Header.SessionID.bytesLen;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\t SessionID (%d Bytes) = ", leng);
+    for (i = 0; i <leng ; i++)
+    {
+        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_ISO2->V2G_Message.Header.SessionID.bytes[i]);
+    }
+}
+
+/*===========================================================================
+FUNCTION: DEBUG_PRINT_EXI_MSG_supportedAppProtocolReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_supportedAppProtocolReq(struct appHandEXIDocument *exi_doc)
+{
+	int i = 0;
+
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n EVSE side: List of application handshake protocols of the EV \n");
+
+	for(i = 0; i < exi_doc->supportedAppProtocolReq.AppProtocol.arrayLen; i++)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("\tProtocol entry #=%d\n",(i+1));
+
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\tProtocolNamespace=");
+		printASCIIString(
+			exi_doc->supportedAppProtocolReq.AppProtocol.array[i].ProtocolNamespace.characters,
+			exi_doc->supportedAppProtocolReq.AppProtocol.array[i].ProtocolNamespace.charactersLen
+			);
+
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\tVersion=%d.%d\n",
+			exi_doc->supportedAppProtocolReq.AppProtocol.array[i].VersionNumberMajor,
+			exi_doc->supportedAppProtocolReq.AppProtocol.array[i].VersionNumberMinor);
+
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\tSchemaID=%d\n", exi_doc->supportedAppProtocolReq.AppProtocol.array[i].SchemaID);
+
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\tPriority=%d\n", exi_doc->supportedAppProtocolReq.AppProtocol.array[i].Priority);
+	}
+
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_DIN_SessionSetupReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_DIN_SessionSetupReq(struct dinEXIDocument *exi_doc_DIN)
+{
+    int i = 0;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing SessionSetupReq ⨀⨀⨀⨀⨀⬇\n");
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_din_Header(exi_doc_DIN);
+
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tEVCCID (%d Bytes) = ", exi_doc_DIN->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen);
+    for (i = 0; i < exi_doc_DIN->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen; i++)
+    {
+        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_DIN->V2G_Message.Body.SessionSetupReq.EVCCID.bytes[i]);
+    }
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing SessionSetupReq ⨂⨂⨂⨂⨂⬆\n\n");
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_ISO1_SessionSetupReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_ISO1_SessionSetupReq(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    int i = 0;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing SessionSetupReq ⨀⨀⨀⨀⨀⬇\n");
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);
+
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tEVCCID (%d Bytes) = ", exi_doc_ISO1->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen);
+    for (i = 0; i < exi_doc_ISO1->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen; i++)
+    {
+        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_ISO1->V2G_Message.Body.SessionSetupReq.EVCCID.bytes[i]);
+    }
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing SessionSetupReq ⨂⨂⨂⨂⨂⬆\n\n");
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_ISO2_SessionSetupReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_ISO2_SessionSetupReq(struct iso2EXIDocument *exi_doc_ISO2)
+{
+    int i = 0;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing SessionSetupReq ⨀⨀⨀⨀⨀⬇\n");
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_iso2_Header(exi_doc_ISO2);
+
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tEVCCID (%d Bytes) = ", exi_doc_ISO2->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen);
+    for (i = 0; i < exi_doc_ISO2->V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen; i++)
+    {
+        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_ISO2->V2G_Message.Body.SessionSetupReq.EVCCID.bytes[i]);
+    }
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing SessionSetupReq ⨂⨂⨂⨂⨂⬆\n\n");
+}
+
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_DIN_ServiceDiscoveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_DIN_ServiceDiscoveryReq(struct dinEXIDocument *exi_doc_DIN)
+{
+    int i = 0;
+    int leng = 0;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ServiceDiscoveryReq ⨀⨀⨀⨀⨀⬇\n");
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_din_Header(exi_doc_DIN);
+
+    //[BODY(1/2)] Service Scope
+    leng = exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq.ServiceScope.charactersLen;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t ServiceScope (%d Bytes, optional) = ", leng);
+    for (i = 0; i <leng ; i++)
+    {
+        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq.ServiceScope.characters[i]);
+    }
+
+    //[BODY(2/2)] Service Category
+    int cat = 0;
+    cat = exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq.ServiceCategory;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t ServiceCategory = %d ", cat);
+    switch (cat)
+    {
+        case dinserviceCategoryType_EVCharging:             //0
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(EVCharging)");
+            break;
+        }
+        case dinserviceCategoryType_Internet:               //1
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Internet: not supported)");
+            break;
+        }
+        case dinserviceCategoryType_ContractCertificate:    //2
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ContractCertificate: not supported)");
+            break;
+        }
+        case dinserviceCategoryType_OtherCustom:            //3
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(OtherCustom: not supported)");
+            break;
+        }
+        default:
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([ERROR] Unexpected Service Category: %d)", cat);
+            break;
+        }
+
+    }
+    //DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t([0]EVCharging, [1]Internet, [2]ContractCertificate, [3]OtherCustom)\n");
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ServiceDiscoveryReq ⨂⨂⨂⨂⨂⬆\n\n");
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_ISO1_ServiceDiscoveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_ISO1_ServiceDiscoveryReq(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    int i = 0;
+    int leng = 0;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ServiceDiscoveryReq ⨀⨀⨀⨀⨀⬇\n");
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);
+
+    //[BODY(1/2)] Service Scope
+    leng = exi_doc_ISO1->V2G_Message.Body.ServiceDiscoveryReq.ServiceScope.charactersLen;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t ServiceScope (%d Bytes, optional) = ", leng);
+    for (i = 0; i <leng ; i++)
+    {
+        DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_doc_ISO1->V2G_Message.Body.ServiceDiscoveryReq.ServiceScope.characters[i]);
+    }
+
+    //[BODY(2/2)] Service Category
+    int cat = 0;
+    cat = exi_doc_ISO1->V2G_Message.Body.ServiceDiscoveryReq.ServiceCategory;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t ServiceCategory = %d ", cat);
+    switch (cat)
+    {
+        case iso1serviceCategoryType_EVCharging:             //0
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(EVCharging)");
+            break;
+        }
+        case iso1serviceCategoryType_Internet:               //1
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Internet: not supported)");
+            break;
+        }
+        case iso1serviceCategoryType_ContractCertificate:    //2
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ContractCertificate: not supported)");
+            break;
+        }
+        case iso1serviceCategoryType_OtherCustom:            //3
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(OtherCustom: not supported)");
+            break;
+        }
+        default:
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([ERROR] Unexpected Service Category)");
+            break;
+        }
+
+    }
+    //DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t([0]EVCharging, [1]Internet, [2]ContractCertificate, [3]OtherCustom)\n");
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ServiceDiscoveryReq ⨂⨂⨂⨂⨂⬆\n\n");
+}
+
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_DIN_ServiceAndPaymentSelectionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_DIN_ServiceAndPaymentSelectionReq(struct dinEXIDocument *exi_doc_DIN)
+{
+    int i = 0;
+    int leng = 0;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ServicePaymentSelectionReq ⨀⨀⨀⨀⨀⬇\n");
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_din_Header(exi_doc_DIN);
+
+
+    //[BODY(1/2)] SelectedPaymentOption
+    int opt = 0;
+    opt = exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq.SelectedPaymentOption;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tSelectedPaymentOption = %d ", opt);
+    switch (opt)
+    {
+        case dinpaymentOptionType_Contract:         //0
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Contract)");
+            break;
+        }
+
+        case dinpaymentOptionType_ExternalPayment:  //1
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ExternalPayment)");
+            break;
+        }
+        default:
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([ERROR] Unexpected SelectedPaymentOption)\n");
+            break;
+        }
+    }
+
+
+    //[BODY(2/2)] SelectedServiceList
+    leng = exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq.SelectedServiceList.SelectedService.arrayLen;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tSelectedServiceList (%d items) = \n", leng);
+    for (i = 0; i< leng; i++)
+    {
+        DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\t\t [%d-th](ServiceID, ParameterSetID, ParameterSetID_isUsed) = {%d, %d, %d}\n",
+            (i+1),
+            exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq.SelectedServiceList.SelectedService.array[i].ServiceID,
+            exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq.SelectedServiceList.SelectedService.array[i].ParameterSetID,
+            exi_doc_DIN->V2G_Message.Body.ServicePaymentSelectionReq.SelectedServiceList.SelectedService.array[i].ParameterSetID_isUsed);
+    }
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ServicePaymentSelectionReq ⨂⨂⨂⨂⨂⬆\n\n");
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_ISO1_ServiceAndPaymentSelectionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_ISO1_ServiceAndPaymentSelectionReq(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    int i = 0;
+    int leng = 0;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing PaymentServiceSelectionReq ⨀⨀⨀⨀⨀⬇\n");
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);
+
+
+    //[BODY(1/2)] SelectedPaymentOption
+    int opt = 0;
+    opt = exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq.SelectedPaymentOption;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tSelectedPaymentOption = %d ", opt);
+    switch (opt)
+    {
+        case iso1paymentOptionType_Contract:         //0
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Contract)");
+            break;
+        }
+
+        case iso1paymentOptionType_ExternalPayment:  //1
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ExternalPayment)");
+            break;
+        }
+        default:
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([ERROR] Unexpected SelectedPaymentOption)\n");
+            break;
+        }
+    }
+
+
+    //[BODY(2/2)] SelectedServiceList
+    leng = exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq.SelectedServiceList.SelectedService.arrayLen;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\tSelectedServiceList (%d items) = \n", leng);
+    for (i = 0; i< leng; i++)
+    {
+        DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t\t\t [%d-th](ServiceID, ParameterSetID, ParameterSetID_isUsed) = {%d, %d, %d}\n",
+            (i+1),
+            exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq.SelectedServiceList.SelectedService.array[i].ServiceID,
+            exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq.SelectedServiceList.SelectedService.array[i].ParameterSetID,
+            exi_doc_ISO1->V2G_Message.Body.PaymentServiceSelectionReq.SelectedServiceList.SelectedService.array[i].ParameterSetID_isUsed);
+    }
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing PaymentServiceSelectionReq ⨂⨂⨂⨂⨂⬆\n\n");
+}
+
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_DIN_ContractAuthenticationReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_DIN_ContractAuthenticationReq(struct dinEXIDocument *exi_doc_DIN)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ContractAuthenticationReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_din_Header(exi_doc_DIN);
+
+
+    //[BODY(1/2)] Id
+    //[Joseph, To-Do, not full implemented, yet]
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t Id_isUsed = %d ",
+        exi_doc_DIN->V2G_Message.Body.ContractAuthenticationReq.Id_isUsed);
+
+
+    //[BODY(2/2)] GenChallenge
+    //[Joseph, To-Do, not full implemented, yet]
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t GenChallenge_isUsed = %d ",
+        exi_doc_DIN->V2G_Message.Body.ContractAuthenticationReq.GenChallenge_isUsed);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ContractAuthenticationReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_ISO1_AuthorizationReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_ISO1_AuthorizationReq(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing AuthorizationReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);
+
+
+    //[BODY(1/2)] Id
+    //[Joseph, To-Do, not full implemented, yet]
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t Id_isUsed = %d ",
+        exi_doc_ISO1->V2G_Message.Body.AuthorizationReq.Id_isUsed);
+
+
+    //[BODY(2/2)] GenChallenge
+    //[Joseph, To-Do, not full implemented, yet]
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t GenChallenge_isUsed = %d ",
+        exi_doc_ISO1->V2G_Message.Body.AuthorizationReq.GenChallenge_isUsed);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing AuthorizationReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_DIN_ChargeParameterDiscoveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_DIN_ChargeParameterDiscoveryReq(struct dinEXIDocument *exi_doc_DIN)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ChargeParameterDiscoveryReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_din_Header(exi_doc_DIN);
+
+    //===== [BODY (1/3)] EVRequestedEnergyTransferType =====
+    int type = 0;
+    type = exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.EVRequestedEnergyTransferType;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVRequestedEnergyTransferType = %d ", type);
+    switch (type)
+    {
+        case dinEVRequestedEnergyTransferType_AC_single_phase_core:    //0,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(AC_single_phase_core)\n");
+            break;
+        }
+    	case dinEVRequestedEnergyTransferType_AC_three_phase_core:     //1,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(AC_three_phase_core)\n");
+            break;
+        }
+    	case dinEVRequestedEnergyTransferType_DC_core:                 //2,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_core)\n");
+            break;
+        }
+    	case dinEVRequestedEnergyTransferType_DC_extended:             //3,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_extended)\n");  //expected
+            //[Joseph, To-Do]
+            //If this parameter is different from previous message,
+            //a warning should be noted.
+            break;
+        }
+    	case dinEVRequestedEnergyTransferType_DC_combo_core:           //4,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_combo_core)\n");
+            break;
+        }
+    	case dinEVRequestedEnergyTransferType_DC_unique:               //5
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_unique)\n");
+            break;
+        }
+    }
+
+    //===== [BODY (2/3)] AC_EVChargeParameter of EVChargeParameter =====
+    //ignored, since DIN doesn't support AC.
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t AC_EVChargeParameter_isUsed = %d ",
+            exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter_isUsed);
+
+    //===== [BODY (3/3)] DC_EVChargeParameter of EVChargeParameter =====
+    int value = 0;
+    struct dinPhysicalValueType *obj;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
+            exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter_isUsed);
+
+    //DC_EVStatus
+    struct dinDC_EVStatusType *status;
+    status = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.DC_EVStatus;
+    PRINT_dinDC_EVStatusType(status);
+
+    //EVMaximumCurrentLimit
+    obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVMaximumCurrentLimit;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumCurrentLimit = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+    //EVMaximumPowerLimit
+    obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVMaximumPowerLimit;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumPowerLimit = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+    //EVMaximumVoltageLimit
+    obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVMaximumVoltageLimit;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumVoltageLimit = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+    //EVEnergyCapacity
+    obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVEnergyCapacity;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVEnergyCapacity = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+    //EVEnergyRequest
+    obj = &exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVEnergyRequest;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVEnergyRequest = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+    //FullSOC
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t FullSOC = %d \% (DEC)",
+            exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.FullSOC);
+
+    //BulkSOC
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkSOC = %d \% (DEC)",
+            exi_doc_DIN->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.BulkSOC);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ChargeParameterDiscoveryReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_ISO1_ChargeParameterDiscoveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_ISO1_ChargeParameterDiscoveryReq(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ChargeParameterDiscoveryReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);
+
+    //===== [BODY (1/3)] RequestedEnergyTransferMode =====
+    int type = 0;
+    type = exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.RequestedEnergyTransferMode;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t RequestedEnergyTransferMode = %d ", type);
+    switch (type)
+    {
+        case iso1EnergyTransferModeType_AC_single_phase_core:    //0,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(AC_single_phase_core)\n");
+            break;
+        }
+    	case iso1EnergyTransferModeType_AC_three_phase_core:     //1,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(AC_three_phase_core)\n");
+            break;
+        }
+    	case iso1EnergyTransferModeType_DC_core:                 //2,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_core)\n");
+            break;
+        }
+    	case iso1EnergyTransferModeType_DC_extended:             //3,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_extended)\n");  //expected
+            //[Joseph, To-Do]
+            //If this parameter is different from previous message,
+            //a warning should be noted.
+            break;
+        }
+    	case iso1EnergyTransferModeType_DC_combo_core:           //4,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_combo_core)\n");
+            break;
+        }
+    	case iso1EnergyTransferModeType_DC_unique:               //5
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(DC_unique)\n");
+            break;
+        }
+    }
+
+    //===== [BODY (2/3)] AC_EVChargeParameter of EVChargeParameter =====
+    //ignored, since our ISO1 doesn't support AC.
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t AC_EVChargeParameter_isUsed = %d ",
+            exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVChargeParameter_isUsed);
+
+    //===== [BODY (3/3)] DC_EVChargeParameter of EVChargeParameter =====
+    int value = 0;
+    struct iso1PhysicalValueType *obj;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
+            exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter_isUsed);
+
+    //DC_EVStatus
+    struct iso1DC_EVStatusType *status;
+    status = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.DC_EVStatus;
+    PRINT_iso1DC_EVStatusType(status);
+
+    //EVMaximumCurrentLimit
+    obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVMaximumCurrentLimit;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumCurrentLimit = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+    //EVMaximumPowerLimit
+    obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVMaximumPowerLimit;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumPowerLimit = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+    //EVMaximumVoltageLimit
+    obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVMaximumVoltageLimit;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumVoltageLimit = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+    //EVEnergyCapacity
+    obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVEnergyCapacity;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVEnergyCapacity = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+    //EVEnergyRequest
+    obj = &exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.EVEnergyRequest;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVEnergyRequest = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+    //FullSOC
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t FullSOC = %d \% (DEC)",
+            exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.FullSOC);
+
+    //BulkSOC
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkSOC = %d \% (DEC)",
+            exi_doc_ISO1->V2G_Message.Body.ChargeParameterDiscoveryReq.DC_EVChargeParameter.BulkSOC);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ChargeParameterDiscoveryReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_DIN_CableCheckReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_DIN_CableCheckReq(struct dinEXIDocument *exi_doc_DIN)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing CableCheckReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_din_Header(exi_doc_DIN);
+
+    //===== [BODY (1/1)] DC_EVStatus =====
+    struct dinDC_EVStatusType *status;
+    status = &exi_doc_DIN->V2G_Message.Body.CableCheckReq.DC_EVStatus;
+    PRINT_dinDC_EVStatusType(status);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing CableCheckReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_ISO1_CableCheckReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_ISO1_CableCheckReq(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing CableCheckReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);
+
+    //===== [BODY (1/1)] DC_EVStatus =====
+    struct iso1DC_EVStatusType *status;
+    status = &exi_doc_ISO1->V2G_Message.Body.CableCheckReq.DC_EVStatus;
+    PRINT_iso1DC_EVStatusType(status);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing CableCheckReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_DIN_PreChargeReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_DIN_PreChargeReq(struct dinEXIDocument *exi_doc_DIN)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing PreChargeReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_din_Header(exi_doc_DIN);
+
+    //===== [BODY (1/3)] DC_EVStatus =====
+    struct dinDC_EVStatusType *status;
+    status = &exi_doc_DIN->V2G_Message.Body.PreChargeReq.DC_EVStatus;
+    PRINT_dinDC_EVStatusType(status);
+
+    //===== [BODY (2/3)] EVTargetVoltage =====
+    int value = 0;
+    struct dinPhysicalValueType *obj;
+    obj = &exi_doc_DIN->V2G_Message.Body.PreChargeReq.EVTargetVoltage;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetVoltage = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+    //===== [BODY (3/3)] EVTargetCurrent =====
+    obj = &exi_doc_DIN->V2G_Message.Body.PreChargeReq.EVTargetCurrent;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetCurrent = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing PreChargeReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_ISO1_PreChargeReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_ISO1_PreChargeReq(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing PreChargeReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);
+
+    //===== [BODY (1/3)] DC_EVStatus =====
+    struct iso1DC_EVStatusType *status;
+    status = &exi_doc_ISO1->V2G_Message.Body.PreChargeReq.DC_EVStatus;
+    PRINT_iso1DC_EVStatusType(status);
+
+    //===== [BODY (2/3)] EVTargetVoltage =====
+    int value = 0;
+    struct iso1PhysicalValueType *obj;
+    obj = &exi_doc_ISO1->V2G_Message.Body.PreChargeReq.EVTargetVoltage;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetVoltage = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+    //===== [BODY (3/3)] EVTargetCurrent =====
+    obj = &exi_doc_ISO1->V2G_Message.Body.PreChargeReq.EVTargetCurrent;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetCurrent = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing PreChargeReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_DIN_PowerDeliveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_DIN_PowerDeliveryReq(struct dinEXIDocument *exi_doc_DIN)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing PowerDeliveryReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_din_Header(exi_doc_DIN);
+
+
+    //===== [BODY (1/3)] ReadyToChargeState =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ReadyToChargeState = %d (DEC)",
+            exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.ReadyToChargeState);
+
+
+    //===== [BODY (2/3)] ChargingProfile =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargingProfile_isUsed = %d (DEC)",
+            exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.ChargingProfile_isUsed);
+
+
+    //===== [BODY (3/3)] DC_EVPowerDeliveryParameter =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVPowerDeliveryParameter_isUsed = %d (DEC)",
+            exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter_isUsed);
+
+    //DC_EVStatus
+    struct dinDC_EVStatusType *status;
+    status = &exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.DC_EVStatus;
+    PRINT_dinDC_EVStatusType(status);
+
+    //BulkChargingComplete
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete = %d (DEC)",
+            exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.BulkChargingComplete);
+
+    //BulkChargingComplete_isUsed
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete_isUsed = %d (DEC)",
+            exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.BulkChargingComplete_isUsed);
+
+    //ChargingComplete
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargingComplete = %d (DEC)",
+            exi_doc_DIN->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.ChargingComplete);
+
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing PowerDeliveryReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_ISO1_PowerDeliveryReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_ISO1_PowerDeliveryReq(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing PowerDeliveryReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);
+
+
+    //===== [BODY (1/3)] ChargeProgress =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargeProgress = %d (DEC, 0:start, 1:stop, 2:renegotiate)",
+            exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.ChargeProgress);
+	//iso1chargeProgressType_Start = 0,
+	//iso1chargeProgressType_Stop = 1,
+	//iso1chargeProgressType_Renegotiate = 2
+
+
+    //===== [BODY (2/3)] ChargingProfile =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargingProfile_isUsed = %d (DEC)",
+            exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.ChargingProfile_isUsed);
+
+
+    //===== [BODY (3/3)] DC_EVPowerDeliveryParameter =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVPowerDeliveryParameter_isUsed = %d (DEC)",
+            exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter_isUsed);
+
+    //DC_EVStatus
+    struct iso1DC_EVStatusType *status;
+    status = &exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.DC_EVStatus;
+    PRINT_iso1DC_EVStatusType(status);
+
+    //BulkChargingComplete
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete = %d (DEC)",
+            exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.BulkChargingComplete);
+
+    //BulkChargingComplete_isUsed
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete_isUsed = %d (DEC)",
+            exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.BulkChargingComplete_isUsed);
+
+    //ChargingComplete
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargingComplete = %d (DEC)",
+            exi_doc_ISO1->V2G_Message.Body.PowerDeliveryReq.DC_EVPowerDeliveryParameter.ChargingComplete);
+
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing PowerDeliveryReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_DIN_CurrentDemandReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_DIN_CurrentDemandReq(struct dinEXIDocument *exi_doc_DIN)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing CurrentDemandReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_din_Header(exi_doc_DIN);
+
+    //===== [BODY (1/10)] DC_EVStatus =====
+    struct dinDC_EVStatusType *status;
+    status = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.DC_EVStatus;
+    PRINT_dinDC_EVStatusType(status);
+
+
+    //===== [BODY (2/10)] EVTargetCurrent =====
+    int value = 0;
+    struct dinPhysicalValueType *obj;
+    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVTargetCurrent;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetCurrent = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+
+    //===== [BODY (3/10)] EVMaximumVoltageLimit =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
+            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumVoltageLimit_isUsed);
+
+    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumVoltageLimit;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumVoltageLimit = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+
+
+    //===== [BODY (4/10)] EVMaximumCurrentLimit =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
+            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumCurrentLimit_isUsed);
+
+    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumCurrentLimit;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumCurrentLimit = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+
+    //===== [BODY (5/10)] EVMaximumPowerLimit =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
+            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumPowerLimit_isUsed);
+
+    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVMaximumPowerLimit;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumPowerLimit = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+
+    //===== [BODY (6/10)] BulkChargingComplete =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete_isUsed = %d \n",
+            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.BulkChargingComplete_isUsed);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete = %d \n",
+            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.BulkChargingComplete);
+
+
+    //===== [BODY (7/10)] ChargingComplete =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargingComplete = %d \n",
+            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.ChargingComplete);
+
+
+    //===== [BODY (8/10)] RemainingTimeToFullSoC =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
+            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.RemainingTimeToFullSoC_isUsed);
+
+    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.RemainingTimeToFullSoC;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t RemainingTimeToFullSoC = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+
+    //===== [BODY (9/10)] RemainingTimeToBulkSoC =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
+            exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.RemainingTimeToBulkSoC_isUsed);
+
+    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.RemainingTimeToBulkSoC;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t RemainingTimeToBulkSoC = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+
+    //===== [BODY (10/10)] EVTargetVoltage =====
+    obj = &exi_doc_DIN->V2G_Message.Body.CurrentDemandReq.EVTargetVoltage;
+    value = GetValue_dinPhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetVoltage = %d (DEC) ", value);
+    PRINT_dinPhysicalValueType_UNIT(obj);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing CurrentDemandReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_ISO1_CurrentDemandReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_ISO1_CurrentDemandReq(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing CurrentDemandReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);
+
+    //===== [BODY (1/10)] DC_EVStatus =====
+    struct iso1DC_EVStatusType *status;
+    status = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.DC_EVStatus;
+    PRINT_iso1DC_EVStatusType(status);
+
+
+    //===== [BODY (2/10)] EVTargetCurrent =====
+    int value = 0;
+    struct iso1PhysicalValueType *obj;
+    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVTargetCurrent;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetCurrent = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+
+    //===== [BODY (3/10)] EVMaximumVoltageLimit =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
+            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumVoltageLimit_isUsed);
+
+    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumVoltageLimit;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumVoltageLimit = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+
+
+    //===== [BODY (4/10)] EVMaximumCurrentLimit =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
+            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumCurrentLimit_isUsed);
+
+    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumCurrentLimit;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumCurrentLimit = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+
+    //===== [BODY (5/10)] EVMaximumPowerLimit =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
+            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumPowerLimit_isUsed);
+
+    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVMaximumPowerLimit;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVMaximumPowerLimit = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+
+    //===== [BODY (6/10)] BulkChargingComplete =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete_isUsed = %d \n",
+            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.BulkChargingComplete_isUsed);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t BulkChargingComplete = %d \n",
+            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.BulkChargingComplete);
+
+
+    //===== [BODY (7/10)] ChargingComplete =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t ChargingComplete = %d \n",
+            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.ChargingComplete);
+
+
+    //===== [BODY (8/10)] RemainingTimeToFullSoC =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
+            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToFullSoC_isUsed);
+
+    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToFullSoC;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t RemainingTimeToFullSoC = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+
+    //===== [BODY (9/10)] RemainingTimeToBulkSoC =====
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVChargeParameter_isUsed = %d \n",
+            exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToBulkSoC_isUsed);
+
+    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.RemainingTimeToBulkSoC;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t RemainingTimeToBulkSoC = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+
+    //===== [BODY (10/10)] EVTargetVoltage =====
+    obj = &exi_doc_ISO1->V2G_Message.Body.CurrentDemandReq.EVTargetVoltage;
+    value = GetValue_iso1PhysicalValueType(obj);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t EVTargetVoltage = %d (DEC) ", value);
+    PRINT_iso1PhysicalValueType_UNIT(obj);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing CurrentDemandReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_ISO1_ChargingStatusReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_ISO1_ChargingStatusReq(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing ChargingStatusReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);
+
+    //===== [BODY (0/0)] =====
+	//ISO1: no content
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t no content (ISO1)");
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing ChargingStatusReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_DIN_WeldingDetectionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_DIN_WeldingDetectionReq(struct dinEXIDocument *exi_doc_DIN)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing WeldingDetectionReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_din_Header(exi_doc_DIN);
+
+    //===== [BODY (1/3)] DC_EVStatus =====
+    struct dinDC_EVStatusType *status;
+    status = &exi_doc_DIN->V2G_Message.Body.WeldingDetectionReq.DC_EVStatus;
+    PRINT_dinDC_EVStatusType(status);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing WeldingDetectionReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_ISO1_WeldingDetectionReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_ISO1_WeldingDetectionReq(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing WeldingDetectionReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);
+
+    //===== [BODY (1/3)] DC_EVStatus =====
+    struct iso1DC_EVStatusType *status;
+    status = &exi_doc_ISO1->V2G_Message.Body.WeldingDetectionReq.DC_EVStatus;
+    PRINT_iso1DC_EVStatusType(status);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing WeldingDetectionReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_DIN_SessionStopReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_DIN_SessionStopReq(struct dinEXIDocument *exi_doc_DIN)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing SessionStopReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_din_Header(exi_doc_DIN);
+
+    //===== [BODY (0/0)] noContent =====
+
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing SessionStopReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+/*===========================================================================
+FUNCTION: PRINT_XML_DOC_ISO1_SessionStopReq
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_XML_DOC_ISO1_SessionStopReq(struct iso1EXIDocument *exi_doc_ISO1)
+{
+    int i = 0;
+    static int cnt = 0;
+    cnt++;
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n\t⬇⨀⨀⨀⨀⨀ [START] Parsing SessionStopReq (%d-th) ⨀⨀⨀⨀⨀⬇\n", cnt);
+
+    //===== [Header] SessionID =====
+    PRINT_V2G_MSG_iso1_Header(exi_doc_ISO1);
+
+    //===== [BODY (0/0)] noContent =====
+
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t⬆⨂⨂⨂⨂⨂ [END] Parsing SessionStopReq (%d-th) ⨂⨂⨂⨂⨂⬆\n\n", cnt);
+}
+
+
+/*===========================================================================
+FUNCTION: PRINT_V2GTP_STREAM
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_V2GTP_STREAM(bitstream_t *stream)
+{
+	#if (DEBUG_PRINTF_EXI_ENGINE_DETAIL_SHOW == ENABLE)
+	int i = 0;
+
+
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n ----- Got a new V2GTP Message -----\n\n");
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t SIZE: %d (Bytes, DEC)\n", (int)stream->size);
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t HEADER (HEX): ");
+	for (i = 0; i < stream->size; i++)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", stream->data[i]);
+		if (i == (V2GTP_HEADER_LENGTH - 1))
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t EXI (HEX): ");
+		}
+	}
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n");
+	#endif
+}
+
+
+/*===========================================================================
+FUNCTION: API_V2GMSG_EXI_Decoder_AppProtocol
+DESCRIPTION:
+PRE-CONDITION:
+        1. #define EXI_STREAM    BYTE_ARRAY
+
+INPUT:
+        1. V2GTP_msg
+        2. V2GTP_msg_length
+
+OUTPUT:
+        1. ccs_handshake       	//Share Memory
+        2. V2gFlowStatus   //Status Flag
+
+GLOBAL VARIABLES:
+		1. iStream
+		2. exiDoc
+=============================================================================*/
+int API_V2GMSG_EXI_Decoder_AppProtocol(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct appHandEXIDocument *exiDoc_handshake)
+{
+	int errn = 0;
+	size_t pos = 0;
+	uint32_t payloadLengthDec = 0;
+
+	//Initialize iStream
+	iStream.size = V2GTP_msg_length;	//V2GTP_MSG_RX_BUFFER_SIZE;	//64*1024 = 65,536
+	iStream.pos = &pos;
+	iStream.data = V2GTP_msg;
+
+	//Initialize exiDoc
+	init_appHandEXIDocument(exiDoc_handshake);
+
+	//Print the original EXI message
+	PRINT_V2GTP_STREAM(&iStream);
+
+	//STEP 1: Parsing Header
+	errn = read_v2gtpHeader(iStream.data, &payloadLengthDec);
+
+	//TC_SECC_VTB_V2GTPSessionSetup_004
+	if (payloadLengthDec == 0)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_AppProtocol]payloadLengthDec = 0\n");
+		errn = -1;
+	}
+
+	if (errn == 0)
+	{
+		//STEP 2: Parsing Payload EXI Message
+		*iStream.pos = V2GTP_HEADER_LENGTH;
+		errn = decode_appHandExiDocument(&iStream, exiDoc_handshake);
+		if(errn == 0)
+		{
+			//Print the decoded XML Document
+			PRINT_XML_DOC_supportedAppProtocolReq(exiDoc_handshake);
+
+			//errn = SupportedAppProtocolRequest;	//17 (define.h)
+		}
+		else
+		{
+			/* an error occured */
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_AppProtocol]decode_appHandExiDocument()\n");
+			errn = -1;
+		}
+	}
+
+	return errn;
+}
+
+
+int API_V2GMSG_EXI_Encoder_AppProtocol(struct appHandEXIDocument *exi_doc, bitstream_t *exi_packet)
+{
+	int i = 0;
+	int errn = 0;
+	size_t pos = 0;
+	exi_packet->pos = &pos;
+	//*exi_packet->pos = 0;
+	exi_packet->size = V2GTP_MSG_TX_BUFFER_SIZE;	//(64*1024)   //65,536 = 65.5KB
+	exi_packet->data = V2GTP_Tx_buf;
+
+	*exi_packet->pos = V2GTP_HEADER_LENGTH;
+	if( (errn = encode_appHandExiDocument(exi_packet, exi_doc)) == 0)
+	{
+		errn = write_v2gtpHeader(exi_packet->data, (*exi_packet->pos) - V2GTP_HEADER_LENGTH, V2GTP_EXI_TYPE);
+		//*exi_packet.pos = total length of the encoded V2GMSG.
+		//V2GTP_HEADER_LENGTH = 8 Bytes
+	}
+	exi_packet->size = *exi_packet->pos;	//total length of the encoded V2GMSG.
+
+
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n -----  supportedAppProtocolRes [START] -----\n\n");
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t SIZE: %d (Bytes, DEC)\n", (int)exi_packet->size);
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\t HEADER (HEX): ");
+	for (i = 0; i < (int)exi_packet->size; i++)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("%02X", exi_packet->data[i]);
+		if (i == (V2GTP_HEADER_LENGTH - 1)) DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t EXI (HEX): ");
+	}
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\n -----  supportedAppProtocolRes [END] -----\n\n");
+
+
+	return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: API_V2GMSG_EXI_Decoder_DIN
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int API_V2GMSG_EXI_Decoder_DIN(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct dinEXIDocument *exi_doc_DIN)
+{
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("API_V2GMSG_EXI_Decoder_DIN(): Entered!\n");
+
+	int errn = 0;
+	size_t pos = 0;
+	uint32_t payloadLengthDec = 0;
+
+	//Initialize iStream
+	iStream.size = V2GTP_msg_length;	//V2GTP_MSG_RX_BUFFER_SIZE;	//64*1024 = 65,536
+	iStream.pos = &pos;
+	iStream.data = V2GTP_msg;
+
+	iStream.buffer = 0;
+	iStream.capacity = 0;
+
+	//Print the original EXI message
+	PRINT_V2GTP_STREAM(&iStream);
+
+	//STEP 1: Parsing Header
+	errn = read_v2gtpHeader(iStream.data, &payloadLengthDec);
+
+	//TC_SECC_VTB_V2GTPSessionSetup_004
+	if (payloadLengthDec == 0)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][Error][API_V2GMSG_EXI_Decoder_DIN]payloadLengthDec = 0\n");
+		errn = -1;
+	}
+
+	if (errn == 0)
+	{
+		//STEP 2: Parsing Payload EXI Message
+		*iStream.pos = V2GTP_HEADER_LENGTH;
+		errn = decode_dinExiDocument(&iStream, exi_doc_DIN);
+		//The "eventcode" inside this function could present which kind of message it is.
+
+		if (errn == 0)
+		{
+			// successfully received and parsed.
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][API_V2GMSG_EXI_Decoder_DIN] decode_dinExiDocument: %d (DEC) => OK!\n", errn);
+			errn = Check_V2G_Rx_Msg_Name_din(exi_doc_DIN);
+			if (errn < 0)
+			{
+				DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]Check_V2G_Rx_Msg_Name_din: fail\n");
+			}
+		}
+		else
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_DIN] decode_dinExiDocument: %d (DEC)\n", errn);
+			errn = -1;
+		}
+	}
+	else
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_DIN] read_v2gtpHeader: %d (DEC)\n", errn);
+	}
+	return errn;
+}
+
+/*===========================================================================
+FUNCTION: API_V2GMSG_EXI_Decoder_ISO1
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int API_V2GMSG_EXI_Decoder_ISO1(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct iso1EXIDocument *exi_doc_ISO1)
+{
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("[API_V2GMSG_EXI_Decoder_ISO1] Entered!\n");
+
+	int errn = 0;
+	size_t pos = 0;
+	uint32_t payloadLengthDec = 0;
+
+	//Initialize iStream
+	iStream.size = V2GTP_msg_length;	//V2GTP_MSG_RX_BUFFER_SIZE;	//64*1024 = 65,536
+	iStream.pos = &pos;
+	iStream.data = V2GTP_msg;
+
+	iStream.buffer = 0;
+	iStream.capacity = 0;
+
+	//Print the original EXI message
+	PRINT_V2GTP_STREAM(&iStream);
+
+	//STEP 1: Parsing Header
+	errn = read_v2gtpHeader(iStream.data, &payloadLengthDec);
+
+	//TC_SECC_VTB_V2GTPSessionSetup_004
+	if (payloadLengthDec == 0)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][API_V2GMSG_EXI_Decoder_ISO1]payloadLengthDec = 0");
+		errn = -1;
+	}
+
+	if (errn == 0)
+	{
+		//STEP 2: Parsing Payload EXI Message
+		*iStream.pos = V2GTP_HEADER_LENGTH;
+		errn = decode_iso1ExiDocument(&iStream, exi_doc_ISO1);
+		//The "eventcode" inside this function could present which kind of message it is.
+
+		if (errn == 0)
+		{
+			// successfully received and parsed.
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][API_V2GMSG_EXI_Decoder_ISO1] decode_iso1ExiDocument: %d (DEC) => OK!\n", errn);
+			errn = Check_V2G_Rx_Msg_Name_iso1(exi_doc_ISO1);
+			if (errn < 0)
+			{
+				DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]Check_V2G_Rx_Msg_Name_din: fail\n");
+			}
+		}
+		else
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_ISO1] decode_iso1ExiDocument: %d (DEC)\n", errn);
+			errn = -1;
+		}
+	}
+	else
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_ISO1] read_v2gtpHeader: %d (DEC)\n", errn);
+	}
+	return errn;
+}
+
+/*===========================================================================
+FUNCTION: API_V2GMSG_EXI_Decoder_ISO2
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int API_V2GMSG_EXI_Decoder_ISO2(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct iso2EXIDocument *exi_doc_ISO2)
+{
+	DEBUG_PRINTF_EXI_ENGINE_DETAIL("[API_V2GMSG_EXI_Decoder_ISO2] Entered!\n");
+
+	int errn = 0;
+	size_t pos = 0;
+	uint32_t payloadLengthDec = 0;
+
+	//Initialize iStream
+	iStream.size = V2GTP_msg_length;	//V2GTP_MSG_RX_BUFFER_SIZE;	//64*1024 = 65,536
+	iStream.pos = &pos;
+	iStream.data = V2GTP_msg;
+
+	iStream.buffer = 0;
+	iStream.capacity = 0;
+
+	//Print the original EXI message
+	PRINT_V2GTP_STREAM(&iStream);
+
+	//STEP 1: Parsing Header
+	errn = read_v2gtpHeader(iStream.data, &payloadLengthDec);
+
+	//TC_SECC_VTB_V2GTPSessionSetup_004
+	if (payloadLengthDec == 0)
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][API_V2GMSG_EXI_Decoder_ISO2]payloadLengthDec = 0\n");
+		errn = -1;
+	}
+
+	if (errn == 0)
+	{
+		//STEP 2: Parsing Payload EXI Message
+		*iStream.pos = V2GTP_HEADER_LENGTH;
+		errn = decode_iso2ExiDocument(&iStream, exi_doc_ISO2);
+		//The "eventcode" inside this function could present which kind of message it is.
+
+		if (errn == 0)
+		{
+			// successfully received and parsed.
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[SeccComm][API_V2GMSG_EXI_Decoder_ISO2] decode_iso2ExiDocument: %d (DEC) => OK!\n", errn);
+			errn = Check_V2G_Rx_Msg_Name_iso2(exi_doc_ISO2);
+			if (errn < 0)
+			{
+				DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR]Check_V2G_Rx_Msg_Name_din: fail\n");
+			}
+		}
+		else
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_ISO2] decode_iso2ExiDocument: %d (DEC)\n", errn);
+		}
+	}
+	else
+	{
+		DEBUG_PRINTF_EXI_ENGINE_DETAIL("[ERROR][API_V2GMSG_EXI_Decoder_ISO2] read_v2gtpHeader: %d (DEC)\n", errn);
+	}
+	return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: PRINT_dinPhysicalValueType_UNIT
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_dinPhysicalValueType_UNIT(struct dinPhysicalValueType *obj)
+{
+    if (obj->Unit_isUsed == TRUE)
+    {
+        switch (obj->Unit)
+        {
+            case dinunitSymbolType_h:      // = 0,
+            {
+                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: h)");
+                break;
+            }
+        	case dinunitSymbolType_m:      // = 1,
+            {
+                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: m)");
+                break;
+            }
+        	case dinunitSymbolType_s:      // = 2,
+            {
+                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: s)");
+                break;
+            }
+        	case dinunitSymbolType_A:      // = 3,
+            {
+                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: A)");
+                break;
+            }
+        	case dinunitSymbolType_Ah:     // = 4,
+            {
+                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: Ah)");
+                break;
+            }
+        	case dinunitSymbolType_V:      // = 5,
+            {
+                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: V)");
+                break;
+            }
+        	case dinunitSymbolType_VA:     // = 6,
+            {
+                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: VA)");
+                break;
+            }
+        	case dinunitSymbolType_W:      // = 7,
+            {
+                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: W)");
+                break;
+            }
+        	case dinunitSymbolType_W_s:    // = 8,
+            {
+                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: W_s)");
+                break;
+            }
+        	case dinunitSymbolType_Wh:     // = 9
+            {
+                DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: Wh)");
+                break;
+            }
+            default:
+            {
+                DEBUG_PRINTF_EXI_ENGINE_DETAIL("([WARNING] unit: unexpected dinPhysicalValueType unit)");
+                break;
+            }
+        }
+    }
+    else
+    {
+        DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: null)");
+    }
+}
+
+/*===========================================================================
+FUNCTION: PRINT_iso1PhysicalValueType_UNIT
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_iso1PhysicalValueType_UNIT(struct iso1PhysicalValueType *obj)
+{
+	switch (obj->Unit)
+	{
+		case iso1unitSymbolType_h:      // = 0,
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: h)");
+			break;
+		}
+		case iso1unitSymbolType_m:      // = 1,
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: m)");
+			break;
+		}
+		case iso1unitSymbolType_s:      // = 2,
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: s)");
+			break;
+		}
+		case iso1unitSymbolType_A:      // = 3,
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: A)");
+			break;
+		}
+		case iso1unitSymbolType_V:      // = 4,
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: V)");
+			break;
+		}
+		case iso1unitSymbolType_W:      // = 5,
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: W)");
+			break;
+		}
+		case iso1unitSymbolType_Wh:     // = 6
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("(unit: Wh)");
+			break;
+		}
+		default:
+		{
+			DEBUG_PRINTF_EXI_ENGINE_DETAIL("([WARNING] unit: unexpected iso1PhysicalValueType unit)");
+			break;
+		}
+	}
+}
+
+/*===========================================================================
+FUNCTION: GetValue_dinPhysicalValueType
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int GetValue_dinPhysicalValueType(struct dinPhysicalValueType *obj)
+{
+    int result;
+    result = (obj->Value) * pow(10, obj->Multiplier);
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: GetValue_iso1PhysicalValueType
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int GetValue_iso1PhysicalValueType(struct iso1PhysicalValueType *obj)
+{
+    int result;
+    result = (obj->Value) * pow(10, obj->Multiplier);
+    return result;
+}
+
+/*===========================================================================
+FUNCTION: PRINT_dinDC_EVErrorCodeType
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_dinDC_EVErrorCodeType(struct dinDC_EVStatusType *status)
+{
+    switch (status->EVErrorCode)
+    {
+        case dinDC_EVErrorCodeType_NO_ERROR:                           // = 0,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(NO_ERROR)");
+            break;
+        }
+    	case dinDC_EVErrorCodeType_FAILED_RESSTemperatureInhibit:      // = 1,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_RESSTemperatureInhibit)");
+            break;
+        }
+    	case dinDC_EVErrorCodeType_FAILED_EVShiftPosition:             // = 2,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_EVShiftPosition)");
+            break;
+        }
+    	case dinDC_EVErrorCodeType_FAILED_ChargerConnectorLockFault:   // = 3,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ChargerConnectorLockFault)");
+            break;
+        }
+    	case dinDC_EVErrorCodeType_FAILED_EVRESSMalfunction:           // = 4,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_EVRESSMalfunction)");
+            break;
+        }
+    	case dinDC_EVErrorCodeType_FAILED_ChargingCurrentdifferential: // = 5,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingCurrentdifferential)");
+            break;
+        }
+    	case dinDC_EVErrorCodeType_FAILED_ChargingVoltageOutOfRange:   // = 6,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingVoltageOutOfRange)");
+            break;
+        }
+    	case dinDC_EVErrorCodeType_Reserved_A:                         // = 7,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_A)");
+            break;
+        }
+    	case dinDC_EVErrorCodeType_Reserved_B:                         // = 8,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_B)");
+            break;
+        }
+    	case dinDC_EVErrorCodeType_Reserved_C:                         // = 9,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_C)");
+            break;
+        }
+    	case dinDC_EVErrorCodeType_FAILED_ChargingSystemIncompatibility:// = 10,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingSystemIncompatibility)");
+            break;
+        }
+    	case dinDC_EVErrorCodeType_NoData:                             // = 11
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(NoData)");
+            break;
+        }
+        default:
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([WARNING] Unexpected din EVErrorCode)");
+            break;
+        }
+    }
+}
+
+/*===========================================================================
+FUNCTION: PRINT_iso1DC_EVErrorCodeType
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_iso1DC_EVErrorCodeType(struct iso1DC_EVStatusType *status)
+{
+    switch (status->EVErrorCode)
+    {
+        case iso1DC_EVErrorCodeType_NO_ERROR:                           // = 0,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(NO_ERROR)");
+            break;
+        }
+    	case iso1DC_EVErrorCodeType_FAILED_RESSTemperatureInhibit:      // = 1,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_RESSTemperatureInhibit)");
+            break;
+        }
+    	case iso1DC_EVErrorCodeType_FAILED_EVShiftPosition:             // = 2,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_EVShiftPosition)");
+            break;
+        }
+    	case iso1DC_EVErrorCodeType_FAILED_ChargerConnectorLockFault:   // = 3,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(ChargerConnectorLockFault)");
+            break;
+        }
+    	case iso1DC_EVErrorCodeType_FAILED_EVRESSMalfunction:           // = 4,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_EVRESSMalfunction)");
+            break;
+        }
+    	case iso1DC_EVErrorCodeType_FAILED_ChargingCurrentdifferential: // = 5,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingCurrentdifferential)");
+            break;
+        }
+    	case iso1DC_EVErrorCodeType_FAILED_ChargingVoltageOutOfRange:   // = 6,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingVoltageOutOfRange)");
+            break;
+        }
+    	case iso1DC_EVErrorCodeType_Reserved_A:                         // = 7,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_A)");
+            break;
+        }
+    	case iso1DC_EVErrorCodeType_Reserved_B:                         // = 8,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_B)");
+            break;
+        }
+    	case iso1DC_EVErrorCodeType_Reserved_C:                         // = 9,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(Reserved_C)");
+            break;
+        }
+    	case iso1DC_EVErrorCodeType_FAILED_ChargingSystemIncompatibility:// = 10,
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(FAILED_ChargingSystemIncompatibility)");
+            break;
+        }
+    	case iso1DC_EVErrorCodeType_NoData:                             // = 11
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("(NoData)");
+            break;
+        }
+        default:
+        {
+            DEBUG_PRINTF_EXI_ENGINE_DETAIL("([WARNING] Unexpected iso1 EVErrorCode)");
+            break;
+        }
+    }
+}
+
+
+/*===========================================================================
+FUNCTION: PRINT_dinDC_EVStatusType
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_dinDC_EVStatusType(struct dinDC_EVStatusType *status)
+{
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVStatus:");
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVReady = %d (DEC) ", status->EVReady);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVErrorCode = %d (DEC) ", status->EVErrorCode);
+    PRINT_dinDC_EVErrorCodeType(status);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVRESSSOC = %d \%(DEC) \n", status->EVRESSSOC);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVCabinConditioning = %d (DEC) ", status->EVCabinConditioning);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVCabinConditioning_isUsed = %d (DEC) ", status->EVCabinConditioning_isUsed);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVRESSConditioning = %d (DEC) ", status->EVRESSConditioning);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVRESSConditioning_isUsed = %d (DEC) \n", status->EVRESSConditioning_isUsed);
+}
+
+/*===========================================================================
+FUNCTION: PRINT_iso1DC_EVStatusType
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void PRINT_iso1DC_EVStatusType(struct iso1DC_EVStatusType *status)
+{
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t DC_EVStatus:");
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVReady = %d (DEC) ", status->EVReady);
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVErrorCode = %d (DEC) ", status->EVErrorCode);
+    PRINT_iso1DC_EVErrorCodeType(status);
+
+    DEBUG_PRINTF_EXI_ENGINE_DETAIL("\n\t\t\t\t- EVRESSSOC = %d \%(DEC) \n", status->EVRESSSOC);
+}

EVSE/Projects/AW-CCS/Apps/CCS/v2g/api/api.h → EVSE/Projects/AW-CCS/Apps/CCS/exi_engine/api/api.h

@@ -1,182 +1,180 @@
-/*===========================================================================
-                    Combined Charging System (CCS): SECC
-                                 api.h
-
-                          initiated by Joseph
-                           (since 2019/08/07)
-=============================================================================*/
-#include "define_ccs.h"
-
-#include "../appHandshake/appHandEXIDatatypes.h"
-#include "../appHandshake/appHandEXIDatatypesEncoder.h"
-#include "../appHandshake/appHandEXIDatatypesDecoder.h"
-
-#include "../din/dinEXIDatatypes.h"
-#include "../din/dinEXIDatatypesEncoder.h"
-#include "../din/dinEXIDatatypesDecoder.h"
-
-#include "../iso1/iso1EXIDatatypes.h"
-#include "../iso1/iso1EXIDatatypesEncoder.h"
-#include "../iso1/iso1EXIDatatypesDecoder.h"
-
-#include "../iso2/iso2EXIDatatypes.h"
-#include "../iso2/iso2EXIDatatypesEncoder.h"
-#include "../iso2/iso2EXIDatatypesDecoder.h"
-
-//Configuration for Debug Print Messages
-#if FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == ENABLE
-#define DEBUG_PRINTF_EXI_ENGINE_SHOW           DISABLE   //ENABLE, DISABLE
-#define DEBUG_PRINTF_EXI_ENGINE_BRIEF_SHOW     DISABLE   //ENABLE, DISABLE
-#define DEBUG_PRINTF_EXI_ENGINE_DETAIL_SHOW    DISABLE   //ENABLE, DISABLE
-#else   //debug mode
-#define DEBUG_PRINTF_EXI_ENGINE_SHOW           ENABLE   //ENABLE, DISABLE
-#define DEBUG_PRINTF_EXI_ENGINE_BRIEF_SHOW     ENABLE   //ENABLE, DISABLE
-#define DEBUG_PRINTF_EXI_ENGINE_DETAIL_SHOW    ENABLE   //ENABLE, DISABLE
-#endif
-
-void SHM_Save_din_supportedAppProtocolReq(struct CcsData *shm_ccs, struct appHandEXIDocument *buf, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_din_SessionSetupReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_din_ServiceDiscoveryReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_din_ServiceAndPaymentSelectionReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_din_ContractAuthenticationReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_din_ChargeParameterDiscoveryReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_din_CableCheckReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_din_PreChargeReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_din_PowerDeliveryReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_din_CurrentDemandReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_din_WeldingDetectionReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_din_SessionStopReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
-
-void SHM_Save_iso1_SessionSetupReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_iso1_ServiceDiscoveryReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_iso1_ServiceAndPaymentSelectionReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_iso1_AuthorizationReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_iso1_ChargeParameterDiscoveryReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_iso1_CableCheckReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_iso1_PreChargeReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_iso1_PowerDeliveryReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_iso1_CurrentDemandReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_iso1_ChargingStatusReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_iso1_WeldingDetectionReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
-void SHM_Save_iso1_SessionStopReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
-
-void SHM_Save_iso2_SessionSetupReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
-//void SHM_Save_iso2_ServiceDiscoveryReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
-//void SHM_Save_iso2_ServiceAndPaymentSelectionReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
-//void SHM_Save_iso2_ContractAuthenticationReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
-//void SHM_Save_iso2_ChargeParameterDiscoveryReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
-//void SHM_Save_iso2_CableCheckReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
-//void SHM_Save_iso2_PreChargeReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
-//void SHM_Save_iso2_PowerDeliveryReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
-//void SHM_Save_iso2_CurrentDemandReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
-//void SHM_Save_iso2_WeldingDetectionReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
-//void SHM_Save_iso2_SessionStopReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
-
-
-void SAVE_PhysicalValueType_DIN70121(struct PhysicalValueType_DIN70121 *out, int in_value, unsigned char unit);
-void SAVE_PhysicalValueType_ISO15118_2014(struct PhysicalValueType_ISO15118_2014 *out, int in_value, unsigned char unit);
-void SHM_Read_dinPhysicalValueType(struct dinPhysicalValueType *out, struct PhysicalValueType_DIN70121 *in);
-void SHM_Read_iso1PhysicalValueType(struct iso1PhysicalValueType *out, struct PhysicalValueType_ISO15118_2014 *in);
-void SHM_Read_dinDC_EVSEStatusType(struct dinDC_EVSEStatusType *out, struct DC_EVSEStatusType_DIN70121 *in);
-void SHM_Read_iso1DC_EVSEStatusType(struct iso1DC_EVSEStatusType *out, struct DC_EVSEStatusType_ISO15118_2014 *in);
-
-
-void SHM_Read_din_SessionSetupRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
-void SHM_Read_din_ContractAuthenticationRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
-void SHM_Read_din_ChargeParameterDiscoveryRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
-void SHM_Read_din_CableCheckRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
-void SHM_Read_din_PreChargeRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
-void SHM_Read_din_PowerDeliveryRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
-void SHM_Read_din_CurrentDemandRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
-void SHM_Read_din_WeldingDetectionRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
-void SHM_Read_din_SessionStopRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
-
-void SHM_Read_iso1_SessionSetupRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
-void SHM_Read_iso1_ContractAuthenticationRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
-void SHM_Read_iso1_ChargeParameterDiscoveryRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
-void SHM_Read_iso1_CableCheckRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
-void SHM_Read_iso1_PreChargeRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
-void SHM_Read_iso1_PowerDeliveryRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
-void SHM_Read_iso1_CurrentDemandRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
-void SHM_Read_iso1_ChargingStatusRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
-void SHM_Read_iso1_WeldingDetectionRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
-void SHM_Read_iso1_SessionStopRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
-
-int API_V2GMSG_EXI_Decoder_AppProtocol(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct appHandEXIDocument *ccs_data);
-int API_V2GMSG_EXI_Encoder_AppProtocol(struct appHandEXIDocument *exi_doc, bitstream_t *exi_packet);
-
-int API_V2GMSG_EXI_Decoder_DIN(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct dinEXIDocument *exi_doc_DIN);
-int API_V2GMSG_EXI_Decoder_ISO1(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct iso1EXIDocument *exi_doc_ISO1);
-int API_V2GMSG_EXI_Decoder_ISO2(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct iso2EXIDocument *exi_doc_ISO2);
-
-void PRINT_XML_DOC_supportedAppProtocolReq(struct appHandEXIDocument *exi_doc);
-void PRINT_XML_DOC_DIN_SessionSetupReq(struct dinEXIDocument *exi_doc_DIN);
-void PRINT_XML_DOC_DIN_ServiceDiscoveryReq(struct dinEXIDocument *exi_doc_DIN);
-void PRINT_XML_DOC_DIN_ServiceAndPaymentSelectionReq(struct dinEXIDocument *exi_doc_DIN);
-void PRINT_XML_DOC_DIN_ContractAuthenticationReq(struct dinEXIDocument *exi_doc_DIN);
-void PRINT_XML_DOC_DIN_ChargeParameterDiscoveryReq(struct dinEXIDocument *exi_doc_DIN);
-void PRINT_XML_DOC_DIN_CableCheckReq(struct dinEXIDocument *exi_doc_DIN);
-void PRINT_XML_DOC_DIN_PreChargeReq(struct dinEXIDocument *exi_doc_DIN);
-void PRINT_XML_DOC_DIN_PowerDeliveryReq(struct dinEXIDocument *exi_doc_DIN);
-void PRINT_XML_DOC_DIN_CurrentDemandReq(struct dinEXIDocument *exi_doc_DIN);
-void PRINT_XML_DOC_DIN_WeldingDetectionReq(struct dinEXIDocument *exi_doc_DIN);
-void PRINT_XML_DOC_DIN_SessionStopReq(struct dinEXIDocument *exi_doc_DIN);
-
-void PRINT_XML_DOC_ISO1_SessionSetupReq(struct iso1EXIDocument *exi_doc_ISO1);
-void PRINT_XML_DOC_ISO1_ServiceDiscoveryReq(struct iso1EXIDocument *exi_doc_ISO1);
-void PRINT_XML_DOC_ISO1_ServiceAndPaymentSelectionReq(struct iso1EXIDocument *exi_doc_ISO1);
-void PRINT_XML_DOC_ISO1_AuthorizationReq(struct iso1EXIDocument *exi_doc_ISO1);
-void PRINT_XML_DOC_ISO1_ChargeParameterDiscoveryReq(struct iso1EXIDocument *exi_doc_ISO1);
-void PRINT_XML_DOC_ISO1_CableCheckReq(struct iso1EXIDocument *exi_doc_ISO1);
-void PRINT_XML_DOC_ISO1_PreChargeReq(struct iso1EXIDocument *exi_doc_ISO1);
-void PRINT_XML_DOC_ISO1_PowerDeliveryReq(struct iso1EXIDocument *exi_doc_ISO1);
-void PRINT_XML_DOC_ISO1_CurrentDemandReq(struct iso1EXIDocument *exi_doc_ISO1);
-void PRINT_XML_DOC_ISO1_ChargingStatusReq(struct iso1EXIDocument *exi_doc_ISO1);
-void PRINT_XML_DOC_ISO1_WeldingDetectionReq(struct iso1EXIDocument *exi_doc_ISO1);
-void PRINT_XML_DOC_ISO1_SessionStopReq(struct iso1EXIDocument *exi_doc_ISO1);
-
-void PRINT_XML_DOC_ISO2_SessionSetupReq(struct iso2EXIDocument *exi_doc_ISO2);
-//void PRINT_XML_DOC_ISO2_ServiceDiscoveryReq(struct iso2EXIDocument *exi_doc_ISO2);
-//void PRINT_XML_DOC_ISO2_ServiceAndPaymentSelectionReq(struct iso2EXIDocument *exi_doc_ISO2);
-//void PRINT_XML_DOC_ISO2_ContractAuthenticationReq(struct iso2EXIDocument *exi_doc_ISO2);
-//void PRINT_XML_DOC_ISO2_ChargeParameterDiscoveryReq(struct iso2EXIDocument *exi_doc_ISO2);
-//void PRINT_XML_DOC_ISO2_CableCheckReq(struct iso2EXIDocument *exi_doc_ISO2);
-//void PRINT_XML_DOC_ISO2_PreChargeReq(struct iso2EXIDocument *exi_doc_ISO2);
-//void PRINT_XML_DOC_ISO2_PowerDeliveryReq(struct iso2EXIDocument *exi_doc_ISO2);
-//void PRINT_XML_DOC_ISO2_CurrentDemandReq(struct iso2EXIDocument *exi_doc_ISO2);
-//void PRINT_XML_DOC_ISO2_WeldingDetectionReq(struct iso2EXIDocument *exi_doc_ISO2);
-//void PRINT_XML_DOC_ISO2_SessionStopReq(struct iso2EXIDocument *exi_doc_ISO2);
-
-void PRINT_V2G_MSG_din_Header(struct dinEXIDocument *exi_doc_DIN);
-void PRINT_V2G_MSG_iso1_Header(struct iso1EXIDocument *exi_doc_ISO1);
-void PRINT_V2G_MSG_iso2_Header(struct iso2EXIDocument *exi_doc_ISO2);
-
-void PRINT_dinPhysicalValueType_UNIT(struct dinPhysicalValueType *obj);
-void PRINT_iso1PhysicalValueType_UNIT(struct iso1PhysicalValueType *obj);
-int GetValue_dinPhysicalValueType(struct dinPhysicalValueType *obj);
-int GetValue_iso1PhysicalValueType(struct iso1PhysicalValueType *obj);
-void PRINT_dinDC_EVStatusType(struct dinDC_EVStatusType *status);
-void PRINT_iso1DC_EVStatusType(struct iso1DC_EVStatusType *status);
-void PRINT_dinDC_EVErrorCodeType(struct dinDC_EVStatusType *status);
-void PRINT_iso1DC_EVErrorCodeType(struct iso1DC_EVStatusType *status);
-float DIN70121PhyValDecode(struct PhysicalValueType_DIN70121 PhysicalData);
-float ISO151182014PhyValDecode(struct PhysicalValueType_ISO15118_2014 PhysicalData);
-
-#if DEBUG_PRINTF_EXI_ENGINE_SHOW == ENABLE
-    #if DEBUG_PRINTF_EXI_ENGINE_BRIEF_SHOW == ENABLE
-        #define DEBUG_PRINTF_EXI_ENGINE_BRIEF(format, args...) StoreLogV2GMsg("[%s:%d][%s] "format, (strrchr((strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__), '/') ? strrchr((strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__), '/') + 1 : (strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__)), __LINE__, __FUNCTION__, ##args)
-    #else
-        #define DEBUG_PRINTF_EXI_ENGINE_BRIEF(...)
-    #endif
-
-    #if DEBUG_PRINTF_EXI_ENGINE_DETAIL_SHOW == ENABLE
-        #define DEBUG_PRINTF_EXI_ENGINE_DETAIL(format, args...) StoreLogV2GMsg("[%s:%d][%s] "format, (strrchr((strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__), '/') ? strrchr((strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__), '/') + 1 : (strrchr(__FILE__, '\\') ? strrchr(__FILE__, '\\') + 1 : __FILE__)), __LINE__, __FUNCTION__, ##args)
-    #else
-        #define DEBUG_PRINTF_EXI_ENGINE_DETAIL(...)
-    #endif
-#else
-    #define DEBUG_PRINTF_EXI_ENGINE_BRIEF(...)
-    #define DEBUG_PRINTF_EXI_ENGINE_DETAIL(...)
-#endif
-
-int StoreLogV2GMsg(const char *fmt, ...);
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                 api.h
+
+                          initiated by Joseph
+                           (since 2019/08/07)
+=============================================================================*/
+#include "../../define.h"
+
+#include "../appHandshake/appHandEXIDatatypes.h"
+#include "../appHandshake/appHandEXIDatatypesEncoder.h"
+#include "../appHandshake/appHandEXIDatatypesDecoder.h"
+
+#include "../din/dinEXIDatatypes.h"
+#include "../din/dinEXIDatatypesEncoder.h"
+#include "../din/dinEXIDatatypesDecoder.h"
+
+#include "../iso1/iso1EXIDatatypes.h"
+#include "../iso1/iso1EXIDatatypesEncoder.h"
+#include "../iso1/iso1EXIDatatypesDecoder.h"
+
+#include "../iso2/iso2EXIDatatypes.h"
+#include "../iso2/iso2EXIDatatypesEncoder.h"
+#include "../iso2/iso2EXIDatatypesDecoder.h"
+
+//Configuration for Debug Print Messages
+#if FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == ENABLE
+#define DEBUG_PRINTF_EXI_ENGINE_SHOW           DISABLE   //ENABLE, DISABLE
+#define DEBUG_PRINTF_EXI_ENGINE_BRIEF_SHOW     DISABLE   //ENABLE, DISABLE
+#define DEBUG_PRINTF_EXI_ENGINE_DETAIL_SHOW    DISABLE   //ENABLE, DISABLE
+#else   //debug mode
+#define DEBUG_PRINTF_EXI_ENGINE_SHOW           ENABLE   //ENABLE, DISABLE
+#define DEBUG_PRINTF_EXI_ENGINE_BRIEF_SHOW     DISABLE   //ENABLE, DISABLE
+#define DEBUG_PRINTF_EXI_ENGINE_DETAIL_SHOW    DISABLE   //ENABLE, DISABLE
+#endif
+
+void SHM_Save_din_supportedAppProtocolReq(struct CcsData *shm_ccs, struct appHandEXIDocument *buf, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_din_SessionSetupReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_din_ServiceDiscoveryReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_din_ServiceAndPaymentSelectionReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_din_ContractAuthenticationReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_din_ChargeParameterDiscoveryReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_din_CableCheckReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_din_PreChargeReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_din_PowerDeliveryReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_din_CurrentDemandReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_din_WeldingDetectionReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_din_SessionStopReq(struct CcsData *shm_ccs, struct dinEXIDocument *exi_doc_DIN, struct SysConfigAndInfo *shm_sys);
+
+void SHM_Save_iso1_SessionSetupReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_iso1_ServiceDiscoveryReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_iso1_ServiceAndPaymentSelectionReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_iso1_AuthorizationReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_iso1_ChargeParameterDiscoveryReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_iso1_CableCheckReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_iso1_PreChargeReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_iso1_PowerDeliveryReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_iso1_CurrentDemandReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_iso1_ChargingStatusReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_iso1_WeldingDetectionReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
+void SHM_Save_iso1_SessionStopReq(struct CcsData *shm_ccs, struct iso1EXIDocument *exi_doc_ISO1, struct SysConfigAndInfo *shm_sys);
+
+void SHM_Save_iso2_SessionSetupReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
+//void SHM_Save_iso2_ServiceDiscoveryReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
+//void SHM_Save_iso2_ServiceAndPaymentSelectionReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
+//void SHM_Save_iso2_ContractAuthenticationReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
+//void SHM_Save_iso2_ChargeParameterDiscoveryReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
+//void SHM_Save_iso2_CableCheckReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
+//void SHM_Save_iso2_PreChargeReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
+//void SHM_Save_iso2_PowerDeliveryReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
+//void SHM_Save_iso2_CurrentDemandReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
+//void SHM_Save_iso2_WeldingDetectionReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
+//void SHM_Save_iso2_SessionStopReq(struct CcsData *shm_ccs, struct iso2EXIDocument *exi_doc_ISO2, struct SysConfigAndInfo *shm_sys);
+
+
+void SAVE_PhysicalValueType_DIN70121(struct PhysicalValueType_DIN70121 *out, int in_value, unsigned char unit);
+void SAVE_PhysicalValueType_ISO15118_2014(struct PhysicalValueType_ISO15118_2014 *out, int in_value, unsigned char unit);
+void SHM_Read_dinPhysicalValueType(struct dinPhysicalValueType *out, struct PhysicalValueType_DIN70121 *in);
+void SHM_Read_iso1PhysicalValueType(struct iso1PhysicalValueType *out, struct PhysicalValueType_ISO15118_2014 *in);
+void SHM_Read_dinDC_EVSEStatusType(struct dinDC_EVSEStatusType *out, struct DC_EVSEStatusType_DIN70121 *in);
+void SHM_Read_iso1DC_EVSEStatusType(struct iso1DC_EVSEStatusType *out, struct DC_EVSEStatusType_ISO15118_2014 *in);
+
+
+void SHM_Read_din_SessionSetupRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
+void SHM_Read_din_ContractAuthenticationRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
+void SHM_Read_din_ChargeParameterDiscoveryRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
+void SHM_Read_din_CableCheckRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
+void SHM_Read_din_PreChargeRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
+void SHM_Read_din_PowerDeliveryRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
+void SHM_Read_din_CurrentDemandRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
+void SHM_Read_din_WeldingDetectionRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
+void SHM_Read_din_SessionStopRes(struct dinEXIDocument *exi_doc_DIN, struct CcsData *shm_ccs);
+
+void SHM_Read_iso1_SessionSetupRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
+void SHM_Read_iso1_ContractAuthenticationRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
+void SHM_Read_iso1_ChargeParameterDiscoveryRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
+void SHM_Read_iso1_CableCheckRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
+void SHM_Read_iso1_PreChargeRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
+void SHM_Read_iso1_PowerDeliveryRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
+void SHM_Read_iso1_CurrentDemandRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
+void SHM_Read_iso1_ChargingStatusRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
+void SHM_Read_iso1_WeldingDetectionRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
+void SHM_Read_iso1_SessionStopRes(struct iso1EXIDocument *exi_doc_ISO1, struct CcsData *shm_ccs);
+
+int API_V2GMSG_EXI_Decoder_AppProtocol(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct appHandEXIDocument *ccs_data);
+int API_V2GMSG_EXI_Encoder_AppProtocol(struct appHandEXIDocument *exi_doc, bitstream_t *exi_packet);
+
+int API_V2GMSG_EXI_Decoder_DIN(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct dinEXIDocument *exi_doc_DIN);
+int API_V2GMSG_EXI_Decoder_ISO1(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct iso1EXIDocument *exi_doc_ISO1);
+int API_V2GMSG_EXI_Decoder_ISO2(unsigned char *V2GTP_msg, unsigned int V2GTP_msg_length, struct iso2EXIDocument *exi_doc_ISO2);
+
+void PRINT_XML_DOC_supportedAppProtocolReq(struct appHandEXIDocument *exi_doc);
+void PRINT_XML_DOC_DIN_SessionSetupReq(struct dinEXIDocument *exi_doc_DIN);
+void PRINT_XML_DOC_DIN_ServiceDiscoveryReq(struct dinEXIDocument *exi_doc_DIN);
+void PRINT_XML_DOC_DIN_ServiceAndPaymentSelectionReq(struct dinEXIDocument *exi_doc_DIN);
+void PRINT_XML_DOC_DIN_ContractAuthenticationReq(struct dinEXIDocument *exi_doc_DIN);
+void PRINT_XML_DOC_DIN_ChargeParameterDiscoveryReq(struct dinEXIDocument *exi_doc_DIN);
+void PRINT_XML_DOC_DIN_CableCheckReq(struct dinEXIDocument *exi_doc_DIN);
+void PRINT_XML_DOC_DIN_PreChargeReq(struct dinEXIDocument *exi_doc_DIN);
+void PRINT_XML_DOC_DIN_PowerDeliveryReq(struct dinEXIDocument *exi_doc_DIN);
+void PRINT_XML_DOC_DIN_CurrentDemandReq(struct dinEXIDocument *exi_doc_DIN);
+void PRINT_XML_DOC_DIN_WeldingDetectionReq(struct dinEXIDocument *exi_doc_DIN);
+void PRINT_XML_DOC_DIN_SessionStopReq(struct dinEXIDocument *exi_doc_DIN);
+
+void PRINT_XML_DOC_ISO1_SessionSetupReq(struct iso1EXIDocument *exi_doc_ISO1);
+void PRINT_XML_DOC_ISO1_ServiceDiscoveryReq(struct iso1EXIDocument *exi_doc_ISO1);
+void PRINT_XML_DOC_ISO1_ServiceAndPaymentSelectionReq(struct iso1EXIDocument *exi_doc_ISO1);
+void PRINT_XML_DOC_ISO1_AuthorizationReq(struct iso1EXIDocument *exi_doc_ISO1);
+void PRINT_XML_DOC_ISO1_ChargeParameterDiscoveryReq(struct iso1EXIDocument *exi_doc_ISO1);
+void PRINT_XML_DOC_ISO1_CableCheckReq(struct iso1EXIDocument *exi_doc_ISO1);
+void PRINT_XML_DOC_ISO1_PreChargeReq(struct iso1EXIDocument *exi_doc_ISO1);
+void PRINT_XML_DOC_ISO1_PowerDeliveryReq(struct iso1EXIDocument *exi_doc_ISO1);
+void PRINT_XML_DOC_ISO1_CurrentDemandReq(struct iso1EXIDocument *exi_doc_ISO1);
+void PRINT_XML_DOC_ISO1_ChargingStatusReq(struct iso1EXIDocument *exi_doc_ISO1);
+void PRINT_XML_DOC_ISO1_WeldingDetectionReq(struct iso1EXIDocument *exi_doc_ISO1);
+void PRINT_XML_DOC_ISO1_SessionStopReq(struct iso1EXIDocument *exi_doc_ISO1);
+
+void PRINT_XML_DOC_ISO2_SessionSetupReq(struct iso2EXIDocument *exi_doc_ISO2);
+//void PRINT_XML_DOC_ISO2_ServiceDiscoveryReq(struct iso2EXIDocument *exi_doc_ISO2);
+//void PRINT_XML_DOC_ISO2_ServiceAndPaymentSelectionReq(struct iso2EXIDocument *exi_doc_ISO2);
+//void PRINT_XML_DOC_ISO2_ContractAuthenticationReq(struct iso2EXIDocument *exi_doc_ISO2);
+//void PRINT_XML_DOC_ISO2_ChargeParameterDiscoveryReq(struct iso2EXIDocument *exi_doc_ISO2);
+//void PRINT_XML_DOC_ISO2_CableCheckReq(struct iso2EXIDocument *exi_doc_ISO2);
+//void PRINT_XML_DOC_ISO2_PreChargeReq(struct iso2EXIDocument *exi_doc_ISO2);
+//void PRINT_XML_DOC_ISO2_PowerDeliveryReq(struct iso2EXIDocument *exi_doc_ISO2);
+//void PRINT_XML_DOC_ISO2_CurrentDemandReq(struct iso2EXIDocument *exi_doc_ISO2);
+//void PRINT_XML_DOC_ISO2_WeldingDetectionReq(struct iso2EXIDocument *exi_doc_ISO2);
+//void PRINT_XML_DOC_ISO2_SessionStopReq(struct iso2EXIDocument *exi_doc_ISO2);
+
+void PRINT_V2G_MSG_din_Header(struct dinEXIDocument *exi_doc_DIN);
+void PRINT_V2G_MSG_iso1_Header(struct iso1EXIDocument *exi_doc_ISO1);
+void PRINT_V2G_MSG_iso2_Header(struct iso2EXIDocument *exi_doc_ISO2);
+
+void PRINT_dinPhysicalValueType_UNIT(struct dinPhysicalValueType *obj);
+void PRINT_iso1PhysicalValueType_UNIT(struct iso1PhysicalValueType *obj);
+int GetValue_dinPhysicalValueType(struct dinPhysicalValueType *obj);
+int GetValue_iso1PhysicalValueType(struct iso1PhysicalValueType *obj);
+void PRINT_dinDC_EVStatusType(struct dinDC_EVStatusType *status);
+void PRINT_iso1DC_EVStatusType(struct iso1DC_EVStatusType *status);
+void PRINT_dinDC_EVErrorCodeType(struct dinDC_EVStatusType *status);
+void PRINT_iso1DC_EVErrorCodeType(struct iso1DC_EVStatusType *status);
+float DIN70121PhyValDecode(struct PhysicalValueType_DIN70121 PhysicalData);
+float ISO151182014PhyValDecode(struct PhysicalValueType_ISO15118_2014 PhysicalData);
+
+#if DEBUG_PRINTF_EXI_ENGINE_SHOW == ENABLE
+    #if DEBUG_PRINTF_EXI_ENGINE_BRIEF_SHOW == ENABLE
+        #define DEBUG_PRINTF_EXI_ENGINE_BRIEF      printf
+    #else
+        #define DEBUG_PRINTF_EXI_ENGINE_BRIEF(...)
+    #endif
+
+    #if DEBUG_PRINTF_EXI_ENGINE_DETAIL_SHOW == ENABLE
+        #define DEBUG_PRINTF_EXI_ENGINE_DETAIL     printf
+    #else
+        #define DEBUG_PRINTF_EXI_ENGINE_DETAIL(...)
+    #endif
+#else
+    #define DEBUG_PRINTF_EXI_ENGINE_BRIEF(...)
+    #define DEBUG_PRINTF_EXI_ENGINE_DETAIL(...)
+#endif

EVSE/Projects/AW-CCS/Apps/CCS/v2g/codec/EXIConfig.h → EVSE/Projects/AW-CCS/Apps/CCS/exi_engine/codec/EXIConfig.h

@@ -1,106 +1,106 @@
-/*
- * Copyright (C) 2007-2018 Siemens AG
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*******************************************************************
- *
- * @author Daniel.Peintner.EXT@siemens.com
- * @version 2017-03-23
- * @contact Richard.Kuntschke@siemens.com
- *
- * <p>Code generated by EXIdizer</p>
- * <p>Schema: V2G_CI_MsgDef.xsd</p>
- *
- *
- ********************************************************************/
-
-
-
-/**
- * \file 	EXIConfig.h
- * \brief 	EXI Configurations for the EXI Codec
- *
- */
-
-#ifndef EXI_CONFIG_H
-#define EXI_CONFIG_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/** EXI stream - Option Byte Array */
-#define BYTE_ARRAY 1
-/** EXI stream - Option File */
-#define FILE_STREAM 2
-/** \brief 	EXI stream
- *
- * 			Byte array or file
- * */
-#define EXI_STREAM BYTE_ARRAY
-
-
-
-
-
-/** Memory allocation - static */
-#define STATIC_ALLOCATION 1
-/** Memory allocation - dynamic */
-#define DYNAMIC_ALLOCATION  2
-/** */
-/** \brief 	Memory allocation mode
- *
- * 			static or dynamic memory allocation
- * */
-#define MEMORY_ALLOCATION STATIC_ALLOCATION
-
-
-
-/** String representation ASCII */
-#define STRING_REPRESENTATION_ASCII 1
-/** String representation Universal Character Set (UCS) */
-#define STRING_REPRESENTATION_UCS 2
-/** */
-/** \brief 	String representation mode
- *
- * 			ASCII or UCS
- * */
-#define STRING_REPRESENTATION STRING_REPRESENTATION_UCS
-
-
-/* in the case of ASCII an extra char (null terminator) for printf and other functions is useful */
-#if STRING_REPRESENTATION == STRING_REPRESENTATION_ASCII
-#define EXTRA_CHAR 1
-#endif /* STRING_REPRESENTATION_ASCII */
-#if STRING_REPRESENTATION == STRING_REPRESENTATION_UCS
-#define EXTRA_CHAR 0
-#endif /* STRING_REPRESENTATION_UCS */
-
-
-
-
-
-/** Maximum number of cascading elements, XML tree depth */
-#define EXI_ELEMENT_STACK_SIZE 24
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* EXI_CONFIG_H */
-
+/*
+ * Copyright (C) 2007-2018 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 2017-03-23
+ * @contact Richard.Kuntschke@siemens.com
+ *
+ * <p>Code generated by EXIdizer</p>
+ * <p>Schema: V2G_CI_MsgDef.xsd</p>
+ *
+ *
+ ********************************************************************/
+
+
+
+/**
+ * \file 	EXIConfig.h
+ * \brief 	EXI Configurations for the EXI Codec
+ *
+ */
+
+#ifndef EXI_CONFIG_H
+#define EXI_CONFIG_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** EXI stream - Option Byte Array */
+#define BYTE_ARRAY 1
+/** EXI stream - Option File */
+#define FILE_STREAM 2
+/** \brief 	EXI stream
+ *
+ * 			Byte array or file
+ * */
+#define EXI_STREAM BYTE_ARRAY
+
+
+
+
+
+/** Memory allocation - static */
+#define STATIC_ALLOCATION 1
+/** Memory allocation - dynamic */
+#define DYNAMIC_ALLOCATION  2
+/** */
+/** \brief 	Memory allocation mode
+ *
+ * 			static or dynamic memory allocation
+ * */
+#define MEMORY_ALLOCATION STATIC_ALLOCATION
+
+
+
+/** String representation ASCII */
+#define STRING_REPRESENTATION_ASCII 1
+/** String representation Universal Character Set (UCS) */
+#define STRING_REPRESENTATION_UCS 2
+/** */
+/** \brief 	String representation mode
+ *
+ * 			ASCII or UCS
+ * */
+#define STRING_REPRESENTATION STRING_REPRESENTATION_UCS
+
+
+/* in the case of ASCII an extra char (null terminator) for printf and other functions is useful */
+#if STRING_REPRESENTATION == STRING_REPRESENTATION_ASCII
+#define EXTRA_CHAR 1
+#endif /* STRING_REPRESENTATION_ASCII */
+#if STRING_REPRESENTATION == STRING_REPRESENTATION_UCS
+#define EXTRA_CHAR 0
+#endif /* STRING_REPRESENTATION_UCS */
+
+
+
+
+
+/** Maximum number of cascading elements, XML tree depth */
+#define EXI_ELEMENT_STACK_SIZE 24
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EXI_CONFIG_H */
+

EVSE/Projects/AW-CCS/Apps/CCS/v2g/codec/EXIOptions.h → EVSE/Projects/AW-CCS/Apps/CCS/exi_engine/codec/EXIOptions.h

@@ -1,93 +1,93 @@
-/*
- * Copyright (C) 2007-2018 Siemens AG
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published
- * by the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-
-/*******************************************************************
- *
- * @author Daniel.Peintner.EXT@siemens.com
- * @version 2017-03-02 
- * @contact Richard.Kuntschke@siemens.com
- *
- * <p>Code generated by EXIdizer</p>
- * <p>Schema: V2G_CI_MsgDef.xsd</p>
- *
- *
- ********************************************************************/
-
-
-
-/**
- * \file 	EXIOptions.h
- * \brief 	EXI Options for the EXI Codec
- *
- */
-
-#ifndef EXI_OPTIONS_H
-#define EXI_OPTIONS_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-/** EXI alignment - Option bit-packed */
-#define BIT_PACKED 1
-/** EXI alignment - Option byte-packed */
-#define BYTE_ALIGNMENT  2
-/** EXI alignment */
-/**
- * \brief 		EXI Option 'alignment'
- *
- *				The alignment option is used to control the alignment of event codes and content items.
- *				Default Value: bit-packed
- */
-#define EXI_OPTION_ALIGNMENT BIT_PACKED
-
-
-
-/**
- * \brief 		EXI Option 'strict'
- *
- *				Strict interpretation of schemas is used to achieve better compactness.
- *				Default Value: false
- */
-#define EXI_OPTION_STRICT 0
-
-
-/**
- * \brief 		EXI Option 'valueMaxLength'
- *
- *				Specifies the maximum string length of value content items to be
- *				considered for addition to the string table.
- *				Default Value: unbounded (-1)
- */
-#define EXI_OPTION_VALUE_MAX_LENGTH -1
-
-
-/**
- * \brief 		EXI Option 'valuePartitionCapacity'
- *
- *				Specifies the total capacity of value partitions in a string table.
- *				Default Value: unbounded (-1)
- */
-#define EXI_OPTION_VALUE_PARTITION_CAPACITY 0
-
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* EXI_OPTIONS_H */
+/*
+ * Copyright (C) 2007-2018 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 2017-03-02 
+ * @contact Richard.Kuntschke@siemens.com
+ *
+ * <p>Code generated by EXIdizer</p>
+ * <p>Schema: V2G_CI_MsgDef.xsd</p>
+ *
+ *
+ ********************************************************************/
+
+
+
+/**
+ * \file 	EXIOptions.h
+ * \brief 	EXI Options for the EXI Codec
+ *
+ */
+
+#ifndef EXI_OPTIONS_H
+#define EXI_OPTIONS_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+/** EXI alignment - Option bit-packed */
+#define BIT_PACKED 1
+/** EXI alignment - Option byte-packed */
+#define BYTE_ALIGNMENT  2
+/** EXI alignment */
+/**
+ * \brief 		EXI Option 'alignment'
+ *
+ *				The alignment option is used to control the alignment of event codes and content items.
+ *				Default Value: bit-packed
+ */
+#define EXI_OPTION_ALIGNMENT BIT_PACKED
+
+
+
+/**
+ * \brief 		EXI Option 'strict'
+ *
+ *				Strict interpretation of schemas is used to achieve better compactness.
+ *				Default Value: false
+ */
+#define EXI_OPTION_STRICT 0
+
+
+/**
+ * \brief 		EXI Option 'valueMaxLength'
+ *
+ *				Specifies the maximum string length of value content items to be
+ *				considered for addition to the string table.
+ *				Default Value: unbounded (-1)
+ */
+#define EXI_OPTION_VALUE_MAX_LENGTH -1
+
+
+/**
+ * \brief 		EXI Option 'valuePartitionCapacity'
+ *
+ *				Specifies the total capacity of value partitions in a string table.
+ *				Default Value: unbounded (-1)
+ */
+#define EXI_OPTION_VALUE_PARTITION_CAPACITY 0
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EXI_OPTIONS_H */

EVSE/Projects/AW-CCS/Apps/CCS/exi_engine/test/main.c

@@ -0,0 +1,55 @@
+/*
+ * Copyright (C) 2007-2018 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @author Sebastian.Kaebisch@siemens.com
+ * @version 0.9.4
+ * @contact Richard.Kuntschke@siemens.com
+ *
+ * <p>Switch for sample programs: EXI codec only or for entire V2G example</p>
+ *
+ ********************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/timeb.h>
+#include <time.h>
+#include "main.h"
+
+void JSPH_Test()
+{
+
+}
+
+int main(int argc, char *argv[])
+{
+    /* disable buffering of output, especially when piped or redirected */
+    setvbuf(stdout, NULL, _IONBF, 0);
+
+    JSPH_Test();
+
+#if CODE_VERSION == CODE_VERSION_EXI
+	/* EXI codec only */
+	return main_databinder(argc, argv);
+#elif CODE_VERSION == CODE_VERSION_SAMPLE
+	/* V2G client / service example  */
+	return main_example(argc, argv);
+#endif
+
+}

EVSE/Projects/AW-CCS/Apps/CCS/exi_engine/test/main.h

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2007-2018 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @author Sebastian.Kaebisch@siemens.com
+ * @version 0.9.4
+ * @contact Richard.Kuntschke@siemens.com
+ *
+ *
+ ********************************************************************/
+
+
+#define CODE_VERSION_EXI 1
+#define CODE_VERSION_SAMPLE 2
+#define CODE_VERSION CODE_VERSION_SAMPLE
+
+#ifndef MAIN_H_
+#define MAIN_H_
+
+#if CODE_VERSION == CODE_VERSION_EXI
+int main_databinder(int argc, char *argv[]);
+#elif CODE_VERSION == CODE_VERSION_SAMPLE
+int main_example(int argc, char *argv[]);
+#endif
+
+#endif

EVSE/Projects/AW-CCS/Apps/CCS/exi_engine/test/main_databinder.c

@@ -0,0 +1,178 @@
+/*
+ * Copyright (C) 2007-2018 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @version 0.9.4
+ * @contact Richard.Kuntschke@siemens.com
+ *
+ * <p>Code generated by EXIdizer</p>
+ * <p>Schema: V2G_CI_MsgDef.xsd</p>
+ *
+ *
+ ********************************************************************/
+
+
+
+/*******************************************************************
+ *
+ * <p>Sample program to illustrate how to read an EXI stream and
+ *  directly write it again to an output</p>
+ *
+ *  <p>e.g., <executable> in.exi out.exi</p>
+ ********************************************************************/
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+/* schema-dependent */
+#include "../iso1/iso1EXIDatatypes.h"
+#if DEPLOY_ISO1_CODEC == SUPPORT_YES
+#include "../iso1/iso1EXIDatatypesEncoder.h"
+#include "../iso1/iso1EXIDatatypesDecoder.h"
+#endif /* DEPLOY_ISO1_CODEC == SUPPORT_YES */
+#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 "../codec/ByteStream.h"
+
+/** EXI Debug mode */
+#define EXI_DEBUG 0
+
+#define BUFFER_SIZE 4096
+uint8_t bufferIn[BUFFER_SIZE];
+uint8_t bufferOut[BUFFER_SIZE];
+
+
+#if EXI_DEBUG == 1
+# define DEBUG_PRINTF(x) printf x
+#else
+# define DEBUG_PRINTF(x) do {} while (0)
+#endif
+
+
+int main_databinder(int argc, char *argv[]) {
+
+#if DEPLOY_DIN_CODEC == SUPPORT_YES
+	struct dinEXIDocument dinDoc;
+#endif /* DEPLOY_DIN_CODEC == SUPPORT_YES */
+#if DEPLOY_ISO1_CODEC == SUPPORT_YES
+	struct iso1EXIDocument exi1Doc;
+#endif /* DEPLOY_ISO1_CODEC == SUPPORT_YES */
+#if DEPLOY_ISO2_CODEC == SUPPORT_YES
+	struct iso2EXIDocument exi2Doc;
+#endif /* DEPLOY_ISO2_CODEC == SUPPORT_YES */
+	int errn = 0;
+
+	bitstream_t iStream, oStream;
+
+#if EXI_STREAM == BYTE_ARRAY
+	size_t posDecode;
+	size_t posEncode;
+#endif /* EXI_STREAM == BYTE_ARRAY */
+
+
+#if EXI_DEBUG == 1
+	/* The Eclipse console has buffering problems on Windows e.g, Debug mode */
+	setvbuf(stdout, NULL, _IONBF, 0);
+	setvbuf(stderr, NULL, _IONBF, 0);
+#endif /*EXI_DEBUG*/
+
+	if (argc != 3) {
+		printf("Usage: %s exiInput exiOutput\n", argv[0]);
+		return -1;
+	}
+
+#if EXI_STREAM == BYTE_ARRAY
+	/* input pos */
+	posDecode = 0;
+	/* parse EXI stream to internal byte structures  */
+	errn = readBytesFromFile(argv[1], bufferIn, BUFFER_SIZE, &posDecode);
+	if (errn != 0) {
+		printf("Problems while reading file into buffer, err==%d\n", errn);
+		return errn;
+	}
+	posDecode = 0; /* reset position */
+#endif /* EXI_STREAM == BYTE_ARRAY */
+
+	/* setup input stream */
+#if EXI_STREAM == BYTE_ARRAY
+	iStream.size = BUFFER_SIZE;
+	iStream.data = bufferIn;
+	iStream.pos = &posDecode;
+#endif /* EXI_STREAM == BYTE_ARRAY */
+
+	iStream.buffer = 0;
+	iStream.capacity = 0;
+
+
+	printf("Start decoding EXI stream to databinding layer \n");
+#if DEPLOY_DIN_CODEC == SUPPORT_YES
+	errn = decode_dinExiDocument(&iStream, &dinDoc);
+#endif /* DEPLOY_DIN_CODEC == SUPPORT_YES */
+#if DEPLOY_ISO1_CODEC == SUPPORT_YES
+	errn = decode_iso1ExiDocument(&iStream, &exi1Doc);
+#endif /* DEPLOY_ISO1_CODEC == SUPPORT_YES */
+#if DEPLOY_ISO2_CODEC == SUPPORT_YES
+	errn = decode_iso2ExiDocument(&iStream, &exi2Doc);
+#endif /* DEPLOY_ISO2_CODEC == SUPPORT_YES */
+	if (errn != 0) {
+		printf("Problems while decoding EXI stream, err==%d\n", errn);
+		return errn;
+	}
+
+#if EXI_STREAM == BYTE_ARRAY
+	/* setup output stream */
+	posEncode = 0;
+	oStream.size = BUFFER_SIZE;
+	oStream.data = bufferOut;
+	oStream.pos = &posEncode;
+#endif
+
+	oStream.buffer = 0;
+	oStream.capacity = 8;
+
+	printf("Start encoding databinding layer to EXI \n");
+
+#if DEPLOY_DIN_CODEC == SUPPORT_YES
+	errn = encode_dinExiDocument(&oStream, &dinDoc);
+#endif /* DEPLOY_DIN_CODEC == SUPPORT_YES */
+#if DEPLOY_ISO1_CODEC == SUPPORT_YES
+	errn = encode_iso1ExiDocument(&oStream, &exi1Doc);
+#endif /* DEPLOY_ISO1_CODEC == SUPPORT_YES */
+#if DEPLOY_ISO2_CODEC == SUPPORT_YES
+	errn = encode_iso2ExiDocument(&oStream, &exi2Doc);
+#endif /* DEPLOY_ISO2_CODEC == SUPPORT_YES */
+	if (errn != 0) {
+		printf("Problems while encoding databinding layer, err==%d\n", errn);
+		return errn;
+	}
+
+	printf("EXI roundtrip done with success\n");
+#if EXI_STREAM == BYTE_ARRAY
+	/* write to file */
+	writeBytesToFile(oStream.data, posEncode, argv[2]);
+#endif
+
+
+	return errn;
+}

EVSE/Projects/AW-CCS/Apps/CCS/exi_engine/test/main_example.c

@@ -0,0 +1,2749 @@
+/*
+ * Copyright (C) 2007-2018 Siemens AG
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published
+ * by the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/*******************************************************************
+ *
+ * @author Daniel.Peintner.EXT@siemens.com
+ * @author Sebastian.Kaebisch@siemens.com
+ * @version 0.9.4
+ * @contact Richard.Kuntschke@siemens.com
+ *
+ *
+ ********************************************************************/
+
+
+
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+#include <string.h>
+
+#include "../codec/EXITypes.h"
+
+#include "../appHandshake/appHandEXIDatatypes.h"
+#include "../appHandshake/appHandEXIDatatypesEncoder.h"
+#include "../appHandshake/appHandEXIDatatypesDecoder.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"
+
+//#include "../../SeccComm.h"
+
+#define BUFFER_SIZE 256
+uint8_t buffer1[BUFFER_SIZE];
+uint8_t buffer2[BUFFER_SIZE];
+
+
+#define ERROR_UNEXPECTED_REQUEST_MESSAGE -601
+#define ERROR_UNEXPECTED_SESSION_SETUP_RESP_MESSAGE -602
+#define ERROR_UNEXPECTED_SERVICE_DISCOVERY_RESP_MESSAGE -602
+#define ERROR_UNEXPECTED_SERVICE_DETAILS_RESP_MESSAGE -603
+#define ERROR_UNEXPECTED_PAYMENT_SERVICE_SELECTION_RESP_MESSAGE -604
+#define ERROR_UNEXPECTED_PAYMENT_DETAILS_RESP_MESSAGE -605
+#define ERROR_UNEXPECTED_AUTHORIZATION_RESP_MESSAGE -606
+#define ERROR_UNEXPECTED_CHARGE_PARAMETER_DISCOVERY_RESP_MESSAGE -607
+#define ERROR_UNEXPECTED_POWER_DELIVERY_RESP_MESSAGE -608
+#define ERROR_UNEXPECTED_CHARGING_STATUS_RESP_MESSAGE -609
+#define ERROR_UNEXPECTED_METERING_RECEIPT_RESP_MESSAGE -610
+#define ERROR_UNEXPECTED_SESSION_STOP_RESP_MESSAGE -611
+#define ERROR_UNEXPECTED_CABLE_CHECK_RESP_MESSAGE -612
+#define ERROR_UNEXPECTED_PRE_CHARGE_RESP_MESSAGE -612
+#define ERROR_UNEXPECTED_CURRENT_DEMAND_RESP_MESSAGE -613
+#define ERROR_UNEXPECTED_WELDING_DETECTION_RESP_MESSAGE -614
+
+/*===========================================================================
+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;
+    printf("\n\n⬇⨀⨀⨀⨀⨀ [START] Parsing ServiceDiscoveryReq ⨀⨀⨀⨀⨀⬇\n");
+
+    //Service Scope
+    int leng = 0;
+    leng = exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq.ServiceScope.charactersLen;
+    printf("\tServieScope (%d Bytes)= ", leng);
+    for (i = 0; i <leng ; i++)
+    {
+        printf("%02X", exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq.ServiceScope.characters[i]);
+    }
+
+    //Service Category
+    printf("\n\tServiceCategory = %d (DEC)",
+            exi_doc_DIN->V2G_Message.Body.ServiceDiscoveryReq.ServiceCategory);
+    printf("\n\t([1]EVCharging, [2]Internet, [3]ContractCertificate, [4]OtherCustom)\n");
+    printf("⬆⨂⨂⨂⨂⨂ [END] Parsing ServiceDiscoveryReq ⨂⨂⨂⨂⨂⬆\n\n");
+}
+
+
+static int writeStringToEXIString(char* string, exi_string_character_t* exiString) {
+	int pos = 0;
+	while(string[pos]!='\0')
+	{
+		exiString[pos] = string[pos];
+		pos++;
+	}
+
+	return pos;
+}
+
+static void printASCIIString(exi_string_character_t* string, uint16_t len) {
+	unsigned int i;
+	for(i=0; i<len; i++) {
+		printf("%c",(char)string[i]);
+	}
+	printf("\n");
+}
+
+
+static void printBinaryArray(uint8_t* byte, uint16_t len) {
+	unsigned int i;
+	for(i=0; i<len; i++) {
+		printf("%d ",byte[i]);
+	}
+	printf("\n");
+}
+
+static void copyBytes(uint8_t* from, uint16_t len, uint8_t* to) {
+	int i;
+	for(i=0; i<len; i++) {
+		to[i] = from[i];
+	}
+}
+
+
+/** Example implementation of the app handshake protocol for the EVSE side  */
+static int appHandshakeHandler(bitstream_t* iStream, bitstream_t* oStream) {
+	struct appHandEXIDocument appHandResp;
+	int i;
+	struct appHandEXIDocument exiDoc;
+	int errn = 0;
+	uint32_t payloadLengthDec;
+
+	#if 1
+	printf("\n\n -----------  Content of iStream [START]------------\n\n");
+	printf("\t size (DEC): %d\n", (int)iStream->size);
+	printf("\t pos  (DEC): %ld\n", *iStream->pos);
+	printf("\t data (HEX): ");
+	for (i=0; i<68; i++)	//0x44 = 68, i.e. the length of payload
+	{
+		printf("%02X", iStream->data[i+8]);	//V2GTP Payload without 8-Byte Header
+	}
+	printf("\n\n -----------  Content of iStream [END] ------------\n\n");
+	#endif
+
+	if ( (errn = read_v2gtpHeader(iStream->data, &payloadLengthDec)) == 0) {
+		*iStream->pos = V2GTP_HEADER_LENGTH;
+		printf("\t pos: %ld\n", *iStream->pos);	//added by Joseph
+		if( (errn = decode_appHandExiDocument(iStream, &exiDoc)) ) {
+			/* an error occured */
+			return errn;
+		}
+
+	}
+
+	printf("EVSE side: List of application handshake protocols of the EV \n");
+
+	for(i=0;i<exiDoc.supportedAppProtocolReq.AppProtocol.arrayLen;i++)
+	{
+		printf("\tProtocol entry #=%d\n",(i+1));
+		printf("\t\tProtocolNamespace=");
+		printASCIIString(exiDoc.supportedAppProtocolReq.AppProtocol.array[i].ProtocolNamespace.characters, exiDoc.supportedAppProtocolReq.AppProtocol.array[i].ProtocolNamespace.charactersLen);
+		printf("\t\tVersion=%d.%d\n", exiDoc.supportedAppProtocolReq.AppProtocol.array[i].VersionNumberMajor, exiDoc.supportedAppProtocolReq.AppProtocol.array[i].VersionNumberMinor);
+		printf("\t\tSchemaID=%d\n", exiDoc.supportedAppProtocolReq.AppProtocol.array[i].SchemaID);
+		printf("\t\tPriority=%d\n", exiDoc.supportedAppProtocolReq.AppProtocol.array[i].Priority);
+	}
+
+	/* prepare response handshake response:
+	 * it is assumed, we support the 15118 1.0 version :-) */
+	init_appHandEXIDocument(&appHandResp);
+	appHandResp.supportedAppProtocolRes_isUsed = 1u;
+	appHandResp.supportedAppProtocolRes.ResponseCode = appHandresponseCodeType_OK_SuccessfulNegotiation;
+	appHandResp.supportedAppProtocolRes.SchemaID = exiDoc.supportedAppProtocolReq.AppProtocol.array[0].SchemaID; /* signal the protocol by the provided schema id*/
+	appHandResp.supportedAppProtocolRes.SchemaID_isUsed = 1u;
+
+	*oStream->pos = V2GTP_HEADER_LENGTH;
+	if( (errn = encode_appHandExiDocument(oStream, &appHandResp)) == 0)
+	{
+		errn = write_v2gtpHeader(oStream->data, (*oStream->pos)-V2GTP_HEADER_LENGTH, V2GTP_EXI_TYPE);
+	}
+
+	return errn;
+}
+
+
+static int appHandshake()
+{
+	bitstream_t stream1;
+	bitstream_t stream2;
+
+	uint32_t payloadLengthDec;
+	size_t pos1 = V2GTP_HEADER_LENGTH; /* v2gtp header */
+	size_t pos2 = 0;
+
+	struct appHandEXIDocument handshake;
+	struct appHandEXIDocument handshakeResp;
+
+	int errn = 0;
+
+	char* ns0 = "urn:iso:15118:2:2010:MsgDef";
+	char* ns1 = "urn:din:70121:2012:MsgDef";
+
+	stream1.size = BUFFER_SIZE;
+	stream1.data = buffer1;
+	stream1.pos = &pos1;
+
+	stream2.size = BUFFER_SIZE;
+	stream2.data = buffer2;
+	stream2.pos = &pos2;
+
+	init_appHandEXIDocument(&handshake);
+
+	printf("EV side: setup data for the supported application handshake request message\n");
+
+	/* set up ISO/IEC 15118 Version 1.0 information */
+	handshake.supportedAppProtocolReq_isUsed = 1u;
+	handshake.supportedAppProtocolReq.AppProtocol.arrayLen = 2; /* we have only two protocols implemented */
+
+	handshake.supportedAppProtocolReq.AppProtocol.array[0].ProtocolNamespace.charactersLen =
+			writeStringToEXIString(ns0, handshake.supportedAppProtocolReq.AppProtocol.array[0].ProtocolNamespace.characters);
+	handshake.supportedAppProtocolReq.AppProtocol.array[0].SchemaID = 1;
+	handshake.supportedAppProtocolReq.AppProtocol.array[0].VersionNumberMajor = 1;
+	handshake.supportedAppProtocolReq.AppProtocol.array[0].VersionNumberMinor = 0;
+	handshake.supportedAppProtocolReq.AppProtocol.array[0].Priority = 1;
+
+	handshake.supportedAppProtocolReq.AppProtocol.array[1].ProtocolNamespace.charactersLen =
+			writeStringToEXIString(ns1, handshake.supportedAppProtocolReq.AppProtocol.array[1].ProtocolNamespace.characters);
+	handshake.supportedAppProtocolReq.AppProtocol.array[1].SchemaID = 2;
+	handshake.supportedAppProtocolReq.AppProtocol.array[1].VersionNumberMajor = 1;
+	handshake.supportedAppProtocolReq.AppProtocol.array[1].VersionNumberMinor = 0;
+	handshake.supportedAppProtocolReq.AppProtocol.array[1].Priority = 2;
+
+	/* send app handshake request */
+	if( (errn = encode_appHandExiDocument(&stream1, &handshake)) == 0) {
+		if ( write_v2gtpHeader(stream1.data, pos1-V2GTP_HEADER_LENGTH, V2GTP_EXI_TYPE) == 0 ) {
+			printf("EV side: send message to the EVSE\n");
+		}
+	}
+
+	if (errn == 0) {
+		/* read app handshake request & generate response */
+		errn = appHandshakeHandler(&stream1, &stream2);
+	}
+
+	if (errn == 0) {
+		/* check response */
+		if ( (errn = read_v2gtpHeader(stream2.data, &payloadLengthDec)) == 0) {
+			pos2 = V2GTP_HEADER_LENGTH;
+
+			if(decode_appHandExiDocument(&stream2, &handshakeResp) == 0) {
+				printf("EV side: Response of the EVSE \n");
+				if(handshakeResp.supportedAppProtocolRes.ResponseCode == appHandresponseCodeType_OK_SuccessfulNegotiation) {
+					printf("\t\tResponseCode=OK_SuccessfulNegotiation\n");
+					printf("\t\tSchemaID=%d\n",handshakeResp.supportedAppProtocolRes.SchemaID);
+				}
+			}
+		}
+
+	}
+
+	if (errn != 0) {
+		printf("appHandshake error %d \n", errn);
+	}
+
+
+	return errn;
+
+}
+
+
+
+
+
+#if DEPLOY_ISO2_CODEC == SUPPORT_YES
+
+static void printEVSEStatus2(struct iso2EVSEStatusType* status)
+{
+	printf("\tEVSEStatus:\n");
+	printf("\t\tEVSENotification=%d\n", status->EVSENotification);
+	printf("\t\tNotificationMaxDelay=%d\n", status->NotificationMaxDelay);
+}
+
+/* serializes EXI stream and adds V2G TP header */
+static int serialize2EXI2Stream(struct iso2EXIDocument* exiIn, bitstream_t* stream) {
+	int errn;
+	*stream->pos = V2GTP_HEADER_LENGTH;  /* v2gtp header */
+	if( (errn = encode_iso2ExiDocument(stream, exiIn)) == 0) {
+		errn = write_v2gtpHeader(stream->data, (*stream->pos)-V2GTP_HEADER_LENGTH, V2GTP_EXI_TYPE);
+	}
+	return errn;
+}
+
+
+/* deserializes V2G TP header and decodes right away EXI stream */
+static int deserialize2Stream2EXI(bitstream_t* streamIn, struct iso2EXIDocument* exi) {
+	int errn;
+	uint32_t payloadLength;
+
+	*streamIn->pos = 0;
+	if ( (errn = read_v2gtpHeader(streamIn->data, &payloadLength)) == 0) {
+		*streamIn->pos += V2GTP_HEADER_LENGTH;
+
+		errn = decode_iso2ExiDocument(streamIn, exi);
+	}
+	return errn;
+}
+
+static int sessionSetup2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+	printf("EVSE side: sessionSetup called\n"  );
+	printf("\tReceived data:\n");
+	printf("\tHeader SessionID=");
+	printBinaryArray(exiIn->V2G_Message.Header.SessionID.bytes, exiIn->V2G_Message.Header.SessionID.bytesLen);
+	printf("\t\t EVCCID=%d\n", exiIn->V2G_Message.Body.SessionSetupReq.EVCCID.bytes[0]);
+
+	exiOut->V2G_Message_isUsed = 1u;
+
+	/* generate an unique sessionID */
+	init_iso2MessageHeaderType(&exiOut->V2G_Message.Header);
+	exiOut->V2G_Message.Header.SessionID.bytes[0] = 1;
+	exiOut->V2G_Message.Header.SessionID.bytes[1] = 2;
+	exiOut->V2G_Message.Header.SessionID.bytes[2] = 3;
+	exiOut->V2G_Message.Header.SessionID.bytes[3] = 4;
+	exiOut->V2G_Message.Header.SessionID.bytes[4] = 5;
+	exiOut->V2G_Message.Header.SessionID.bytes[5] = 6;
+	exiOut->V2G_Message.Header.SessionID.bytes[6] = 7;
+	exiOut->V2G_Message.Header.SessionID.bytes[7] = 8;
+	exiOut->V2G_Message.Header.SessionID.bytesLen = 8;
+
+	/* Prepare data for EV */
+	init_iso2BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.SessionSetupRes_isUsed = 1u;
+	init_iso2SessionSetupResType(&exiOut->V2G_Message.Body.SessionSetupRes);
+
+	exiOut->V2G_Message.Body.SessionSetupRes.ResponseCode = iso2responseCodeType_OK;
+	exiOut->V2G_Message.Body.SessionSetupRes.EVSEID.characters[0] = 0;
+	exiOut->V2G_Message.Body.SessionSetupRes.EVSEID.characters[1] = 20;
+	exiOut->V2G_Message.Body.SessionSetupRes.EVSEID.charactersLen = 2;
+	exiOut->V2G_Message.Body.SessionSetupRes.EVSETimeStamp_isUsed = 1u;
+	exiOut->V2G_Message.Body.SessionSetupRes.EVSETimeStamp = 123456789;
+
+	return 0;
+}
+
+static int serviceDiscovery2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+	int i;
+
+	printf("EVSE side: serviceDiscovery called\n"  );
+	printf("\tReceived data:\n");
+	printf("\tHeader SessionID=");
+	printBinaryArray(exiIn->V2G_Message.Header.SessionID.bytes, exiIn->V2G_Message.Header.SessionID.bytesLen);
+	if(exiIn->V2G_Message.Body.ServiceDiscoveryReq.SupportedServiceIDs_isUsed) {
+		for(i=0;i<exiIn->V2G_Message.Body.ServiceDiscoveryReq.SupportedServiceIDs.ServiceID.arrayLen; i++) {
+			printf("\t\tSupportedServiceID=%d\n", exiIn->V2G_Message.Body.ServiceDiscoveryReq.SupportedServiceIDs.ServiceID.array[i]);
+		}
+	}
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso2BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.ServiceDiscoveryRes_isUsed = 1u;
+	init_iso2ServiceDiscoveryResType(&exiOut->V2G_Message.Body.ServiceDiscoveryRes);
+
+
+	exiOut->V2G_Message.Body.ServiceDiscoveryRes.VASList_isUsed = 0u;  /* we do not provide VAS */
+	exiOut->V2G_Message.Body.ServiceDiscoveryRes.ResponseCode = iso2responseCodeType_OK;
+
+	exiOut->V2G_Message.Body.ServiceDiscoveryRes.PaymentOptionList.PaymentOption.array[0] = iso2paymentOptionType_ExternalPayment; /* EVSE handles the payment */
+	exiOut->V2G_Message.Body.ServiceDiscoveryRes.PaymentOptionList.PaymentOption.array[1] = iso2paymentOptionType_Contract;
+	exiOut->V2G_Message.Body.ServiceDiscoveryRes.PaymentOptionList.PaymentOption.arrayLen = 2;
+
+	exiOut->V2G_Message.Body.ServiceDiscoveryRes.EnergyTransferServiceList.Service.arrayLen = 1;
+	exiOut->V2G_Message.Body.ServiceDiscoveryRes.EnergyTransferServiceList.Service.array[0].ServiceID = 1; /* ID of the charge service */
+	exiOut->V2G_Message.Body.ServiceDiscoveryRes.EnergyTransferServiceList.Service.array[0].FreeService = 1;
+
+	exiOut->V2G_Message.Body.ServiceDiscoveryRes.VASList_isUsed = 0u; /* no value added service requested */
+
+	return 0;
+}
+
+
+static int serviceDetail2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+
+	printf("EVSE side: serviceDetail called\n"  );
+	printf("\tReceived data:\n");
+	printf("\tHeader SessionID=");
+	printBinaryArray(exiIn->V2G_Message.Header.SessionID.bytes, exiIn->V2G_Message.Header.SessionID.bytesLen);
+	printf("\t\t ServiceDetailID=%d\n",exiIn->V2G_Message.Body.ServiceDetailReq.ServiceID);
+
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso2BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.ServiceDetailRes_isUsed= 1u;
+	init_iso2ServiceDetailResType(&exiOut->V2G_Message.Body.ServiceDetailRes);
+
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceID = 1234;
+
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList_isUsed = 1u;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.arrayLen = 2;
+
+	/* Parameter Set 1*/
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].ParameterSetID = 1;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.arrayLen = 2;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.charactersLen = 8;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[0] = 'P';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[1] = 'r';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[2] = 'o';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[3] = 't';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[4]= 'o';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[5] = 'c';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[6] = 'o';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[7] = 'l';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].intValue = 15119;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].intValue_isUsed = 1u;
+
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].Name.charactersLen = 4;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].Name.characters[0] = 'N';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].Name.characters[1] = 'a';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].Name.characters[2] = 'm';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].Name.characters[3] = 'e';
+
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].stringValue_isUsed = 1u;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].stringValue.charactersLen = 3;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].stringValue.characters[0] = 'V';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].stringValue.characters[1] = '2';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].stringValue.characters[2] = 'G';
+
+	/* Parameter Set 2 */
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].ParameterSetID = 2;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.arrayLen = 1;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.charactersLen = 7;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[0] = 'C';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[1] = 'h';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[2] = 'a';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[3] = 'n';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[4] = 'n';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[5] = 'e';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[6] = 'l';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].physicalValue_isUsed = 1u;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].physicalValue.Value = 1234;
+
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].physicalValue.Exponent = 1;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].physicalValue.Value = 2;
+
+	exiOut->V2G_Message.Body.ServiceDetailRes.ResponseCode = iso2responseCodeType_OK;
+
+	return 0;
+}
+
+
+static int paymentServiceSelection2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+	int i;
+
+	printf("EVSE side: paymentServiceSelection called\n"  );
+	printf("\tReceived data:\n");
+	printf("\tHeader SessionID=");
+	printBinaryArray(exiIn->V2G_Message.Header.SessionID.bytes, exiIn->V2G_Message.Header.SessionID.bytesLen);
+
+	if(exiIn->V2G_Message.Body.PaymentServiceSelectionReq.SelectedPaymentOption == iso2paymentOptionType_ExternalPayment)  {
+		printf("\t\t SelectedPaymentOption=ExternalPayment\n");
+	}
+
+	if(exiIn->V2G_Message.Body.PaymentServiceSelectionReq.SelectedVASList_isUsed) {
+		for(i=0; i<exiIn->V2G_Message.Body.PaymentServiceSelectionReq.SelectedVASList.SelectedService.arrayLen;i++)
+		{
+			printf("\t\t ServiceID=%d\n", exiIn->V2G_Message.Body.PaymentServiceSelectionReq.SelectedVASList.SelectedService.array[i].ServiceID);
+			printf("\t\t ParameterSetID=%d\n", exiIn->V2G_Message.Body.PaymentServiceSelectionReq.SelectedVASList.SelectedService.array[i].ParameterSetID);
+		}
+	}
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso2BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.PaymentServiceSelectionRes_isUsed= 1u;
+	init_iso2PaymentServiceSelectionResType(&exiOut->V2G_Message.Body.PaymentServiceSelectionRes);
+
+	exiOut->V2G_Message.Body.ServiceDetailRes.ResponseCode = iso2responseCodeType_OK;
+
+	return 0;
+}
+
+
+static int paymentDetails2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+
+	printf("EVSE side: paymentDetails called\n"  );
+	printf("\tReceived data:\n");
+
+	printf("\t\t eMAID=%d\n", exiIn->V2G_Message.Body.PaymentDetailsReq.eMAID.characters[0]);
+	printf("\t\t ID=%c%c\n", exiIn->V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.Id.characters[0], exiIn->V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.Id.characters[1]);
+	printf("\t\t Certificate=%c%c\n", exiIn->V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.Certificate.bytes[0],  exiIn->V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.Certificate.bytes[1]);
+	printf("\t\t SubCertificate 1=%c%c\n", exiIn->V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.SubCertificates.Certificate.array[0].bytes[0], exiIn->V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.SubCertificates.Certificate.array[0].bytes[1]);
+	printf("\t\t SubCertificate 2=%c%c\n", exiIn->V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.SubCertificates.Certificate.array[1].bytes[0], exiIn->V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.SubCertificates.Certificate.array[1].bytes[1]);
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso2BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.PaymentDetailsRes_isUsed = 1u;
+	init_iso2PaymentDetailsResType(&exiOut->V2G_Message.Body.PaymentDetailsRes);
+
+	exiOut->V2G_Message.Body.PaymentDetailsRes.ResponseCode = iso2responseCodeType_OK;
+	exiOut->V2G_Message.Body.PaymentDetailsRes.GenChallenge.bytesLen = 1;
+	exiOut->V2G_Message.Body.PaymentDetailsRes.GenChallenge.bytes[0] = 1;
+	exiOut->V2G_Message.Body.PaymentDetailsRes.EVSETimeStamp = 123456;
+
+	return 0;
+}
+
+
+static int authorization2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+
+	printf("EVSE: Authorization called\n"  );
+	printf("\tReceived data:\n");
+
+	if(exiIn->V2G_Message.Body.AuthorizationReq.GenChallenge_isUsed) {
+		printf("\t\t\t GenChallenge=%d\n", exiIn->V2G_Message.Body.AuthorizationReq.GenChallenge.bytes[0]);
+	}
+	if(exiIn->V2G_Message.Body.AuthorizationReq.Id_isUsed ) {
+		printf("\t\t\t ID=%c%c%c\n", exiIn->V2G_Message.Body.AuthorizationReq.Id.characters[0], exiIn->V2G_Message.Body.AuthorizationReq.Id.characters[1], exiIn->V2G_Message.Body.AuthorizationReq.Id.characters[2]);
+	}
+
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso2BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.AuthorizationRes_isUsed = 1u;
+	init_iso2AuthorizationResType(&exiOut->V2G_Message.Body.AuthorizationRes);
+
+	exiOut->V2G_Message.Body.AuthorizationRes.ResponseCode = iso2responseCodeType_OK;
+	exiOut->V2G_Message.Body.AuthorizationRes.EVSEProcessing = iso2EVSEProcessingType_Finished;
+
+	return 0;
+}
+
+
+static int chargeParameterDiscovery2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+
+	printf("EVSE side: chargeParameterDiscovery called\n"  );
+	printf("\tReceived data:\n");
+
+	if(exiIn->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter_isUsed) {
+		printf("\t\t DepartureTime=%d\n", exiIn->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.DepartureTime);
+		printf("\t\t EVMaximumChargeCurrent=%d\n", exiIn->V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMaximumChargeCurrent.Value);
+	}
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso2BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.ChargeParameterDiscoveryRes_isUsed = 1u;
+	init_iso2ChargeParameterDiscoveryResType(&exiOut->V2G_Message.Body.ChargeParameterDiscoveryRes);
+
+	exiOut->V2G_Message.Body.ChargeParameterDiscoveryRes.ResponseCode = iso2responseCodeType_OK_CertificateExpiresSoon;
+	exiOut->V2G_Message.Body.ChargeParameterDiscoveryRes.EVSEProcessing = iso2EVSEProcessingType_Ongoing;
+	exiOut->V2G_Message.Body.ChargeParameterDiscoveryRes.EVSEEnergyTransferParameter_isUsed = 1u;
+	/*exiOut->V2G_Message.Body.ChargeParameterDiscoveryRes.EVSEEnergyTransferParameter = 0;*/
+	return 0;
+}
+
+
+static int powerDelivery2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+	printf("EVSE side: powerDelivery called\n"  );
+	printf("\tReceived data:\n");
+
+	printf("\t\t  ChargeProgress=%d\n", exiIn->V2G_Message.Body.PowerDeliveryReq.ChargeProgress);
+	printf("\t\t  SAScheduleTupleID=%d\n", exiIn->V2G_Message.Body.PowerDeliveryReq.SAScheduleTupleID);
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso2BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.PowerDeliveryRes_isUsed = 1u;
+	init_iso2PowerDeliveryResType(&exiOut->V2G_Message.Body.PowerDeliveryRes);
+
+	exiOut->V2G_Message.Body.PowerDeliveryRes.ResponseCode = iso2responseCodeType_OK;
+
+	exiOut->V2G_Message.Body.PowerDeliveryRes.EVSEStatus_isUsed = 1;
+	exiOut->V2G_Message.Body.PowerDeliveryRes.EVSEStatus.EVSENotification = iso2EVSENotificationType_StopCharging;
+	exiOut->V2G_Message.Body.PowerDeliveryRes.EVSEStatus.NotificationMaxDelay=12;
+
+	exiOut->V2G_Message.Body.PowerDeliveryRes.EVSEProcessing = iso2EVSEProcessingType_Ongoing_WaitingForCustomerInteraction;
+
+	return 0;
+}
+
+
+static int chargingStatus2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+
+	printf("EVSE side: chargingStatus called\n"  );
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso2BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.ChargingStatusRes_isUsed = 1u;
+	init_iso2ChargingStatusResType(&exiOut->V2G_Message.Body.ChargingStatusRes);
+
+
+	exiOut->V2G_Message.Body.ChargingStatusRes.ResponseCode = iso2responseCodeType_OK;
+	exiOut->V2G_Message.Body.ChargingStatusRes.EVSEID.characters[0]= 'A';
+	exiOut->V2G_Message.Body.ChargingStatusRes.EVSEID.charactersLen =1;
+
+	exiOut->V2G_Message.Body.ChargingStatusRes.EVSEStatus.EVSENotification = iso2EVSENotificationType_ReNegotiation;
+	exiOut->V2G_Message.Body.ChargingStatusRes.EVSEStatus.NotificationMaxDelay=123;
+	exiOut->V2G_Message.Body.ChargingStatusRes.ReceiptRequired = 1;
+	exiOut->V2G_Message.Body.ChargingStatusRes.ReceiptRequired_isUsed = 1;
+
+	return 0;
+}
+
+
+static int meteringReceipt2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+
+	printf("EVSE side: meteringReceipt called\n"  );
+	printf("\tReceived data:\n");
+
+	printf("\t\t ID=%c%c%c\n", exiIn->V2G_Message.Body.MeteringReceiptReq.Id.characters[0], exiIn->V2G_Message.Body.MeteringReceiptReq.Id.characters[1], exiIn->V2G_Message.Body.MeteringReceiptReq.Id.characters[2]);
+	printf("\t\t SAScheduleTupleID=%d\n", exiIn->V2G_Message.Body.MeteringReceiptReq.SAScheduleTupleID);
+	printf("\t\t SessionID=%d\n", exiIn->V2G_Message.Body.MeteringReceiptReq.SessionID.bytes[1]);
+	printf("\t\t MeterInfo.MeterStatus=%d\n", exiIn->V2G_Message.Body.MeteringReceiptReq.MeterInfo.MeterStatus);
+	printf("\t\t MeterInfo.MeterID=%d\n",		exiIn->V2G_Message.Body.MeteringReceiptReq.MeterInfo.MeterID.characters[0]);
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso2BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.MeteringReceiptRes_isUsed = 1u;
+	init_iso2MeteringReceiptResType(&exiOut->V2G_Message.Body.MeteringReceiptRes);
+
+	exiOut->V2G_Message.Body.MeteringReceiptRes.ResponseCode = iso2responseCodeType_FAILED;
+
+	return 0;
+}
+
+static int sessionStop2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+
+	printf("EVSE side: sessionStop called\n"  );
+	printf("\tReceived data:\n");
+	printf("\tHeader SessionID=");
+	printBinaryArray(exiIn->V2G_Message.Header.SessionID.bytes, exiIn->V2G_Message.Header.SessionID.bytesLen);
+	printf("\t\t ChargingSession=%d\n", exiIn->V2G_Message.Body.SessionStopReq.ChargingSession);
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso2BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.SessionStopRes_isUsed = 1u;
+	init_iso2SessionStopResType(&exiOut->V2G_Message.Body.SessionStopRes);
+
+	exiOut->V2G_Message.Body.SessionStopRes.ResponseCode = iso2responseCodeType_OK;
+
+	return 0;
+}
+
+static int cableCheck2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+
+	printf("EVSE side: cableCheck called\n"  );
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso2BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.CableCheckRes_isUsed = 1u;
+	init_iso2CableCheckResType(&exiOut->V2G_Message.Body.CableCheckRes);
+
+	exiOut->V2G_Message.Body.CableCheckRes.ResponseCode = iso2responseCodeType_OK;
+
+	exiOut->V2G_Message.Body.CableCheckRes.EVSEStatus.NotificationMaxDelay = 1234;
+	exiOut->V2G_Message.Body.CableCheckRes.EVSEStatus.EVSENotification= iso2EVSENotificationType_ReNegotiation;
+
+	exiOut->V2G_Message.Body.CableCheckRes.EVSEProcessing = iso2EVSEProcessingType_Finished;
+
+	return 0;
+}
+
+static int preCharge2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+
+	printf("EVSE side: preCharge called\n"  );
+	printf("\tReceived data:\n");
+
+	printf("\t\t EVTargetCurrent=%d (%d)\n", exiIn->V2G_Message.Body.PreChargeReq.EVTargetCurrent.Value, exiIn->V2G_Message.Body.PreChargeReq.EVTargetCurrent.Exponent);
+	printf("\t\t EVTargetVoltage=%d (%d)\n", exiIn->V2G_Message.Body.PreChargeReq.EVTargetVoltage.Value, exiIn->V2G_Message.Body.PreChargeReq.EVTargetVoltage.Exponent);
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso2BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.PreChargeRes_isUsed = 1u;
+	init_iso2PreChargeResType(&exiOut->V2G_Message.Body.PreChargeRes);
+
+	exiOut->V2G_Message.Body.PreChargeRes.ResponseCode = iso2responseCodeType_OK;
+
+	exiOut->V2G_Message.Body.PreChargeRes.EVSEStatus.EVSENotification = iso2EVSENotificationType_StopCharging;
+	exiOut->V2G_Message.Body.PreChargeRes.EVSEStatus.NotificationMaxDelay= 1234;
+
+	exiOut->V2G_Message.Body.PreChargeRes.EVSEPresentVoltage.Exponent = 3;
+	exiOut->V2G_Message.Body.PreChargeRes.EVSEPresentVoltage.Value= 456;
+
+	return 0;
+}
+
+
+
+static int create_response_message2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+	int errn = ERROR_UNEXPECTED_REQUEST_MESSAGE;
+
+	/* create response message as EXI document */
+	if(exiIn->V2G_Message_isUsed) {
+		init_iso2EXIDocument(exiOut);
+		if (exiIn->V2G_Message.Body.SessionSetupReq_isUsed) {
+			errn = sessionSetup2(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.ServiceDiscoveryReq_isUsed) {
+			errn = serviceDiscovery2(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.ServiceDetailReq_isUsed) {
+			errn = serviceDetail2(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.PaymentServiceSelectionReq_isUsed) {
+			errn = paymentServiceSelection2(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.PaymentDetailsReq_isUsed) {
+			errn = paymentDetails2(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.AuthorizationReq_isUsed) {
+			errn = authorization2(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.ChargeParameterDiscoveryReq_isUsed) {
+			errn = chargeParameterDiscovery2(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.PowerDeliveryReq_isUsed) {
+			errn = powerDelivery2(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.ChargingStatusReq_isUsed) {
+			errn = chargingStatus2(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.MeteringReceiptReq_isUsed) {
+			errn = meteringReceipt2(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.SessionStopReq_isUsed) {
+			errn = sessionStop2(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.CableCheckReq_isUsed) {
+			errn = cableCheck2(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.PreChargeReq_isUsed) {
+			errn = preCharge2(exiIn, exiOut);
+		}
+	}
+
+	return errn;
+}
+
+/* Adapt this to your system setup! */
+/* In this situation EV and EVSE is the same party */
+static int request_response2(struct iso2EXIDocument* exiIn, struct iso2EXIDocument* exiOut) {
+	int errn;
+
+	bitstream_t stream1;
+	bitstream_t stream2;
+
+	size_t pos1;
+	size_t pos2;
+
+	stream1.size = BUFFER_SIZE;
+	stream1.data = buffer1;
+	stream1.pos = &pos1;
+
+	stream2.size = BUFFER_SIZE;
+	stream2.data = buffer2;
+	stream2.pos = &pos2;
+
+	/* EV side */
+	errn = serialize2EXI2Stream(exiIn, &stream1);
+
+	/* --> Start of EVSE side */
+	/* deserialize request message */
+	if (errn == 0) {
+		errn = deserialize2Stream2EXI(&stream1, exiOut);
+	}
+	/* create response message */
+	if (errn == 0) {
+		errn = create_response_message2(exiOut, exiIn);
+	}
+	/* serialize response message */
+	if (errn == 0) {
+		errn = serialize2EXI2Stream(exiIn, &stream2);
+	}
+	/* <-- End of EVSE side */
+
+
+	/* EV side */
+	/* deserialize response message */
+	if (errn == 0) {
+		errn = deserialize2Stream2EXI(&stream2, exiOut);
+	}
+
+	return errn;
+}
+
+
+static int charging2()
+{
+	int errn = 0;
+	int i, j;
+
+	struct iso2EXIDocument exiIn;
+	struct iso2EXIDocument exiOut;
+
+	struct iso2ServiceDetailResType serviceDetailRes;
+	struct iso2PaymentServiceSelectionResType paymentServiceSelectionRes;
+	struct iso2PaymentDetailsResType paymentDetailsRes;
+
+	/* setup header information */
+	init_iso2EXIDocument(&exiIn);
+	exiIn.V2G_Message_isUsed = 1u;
+	init_iso2MessageHeaderType(&exiIn.V2G_Message.Header);
+	exiIn.V2G_Message.Header.SessionID.bytes[0] = 0; /* sessionID is always '0' at the beginning (the response contains the valid sessionID)*/
+	exiIn.V2G_Message.Header.SessionID.bytes[1] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytes[2] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytes[3] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytes[4] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytes[5] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytes[6] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytes[7] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytesLen = 8;
+	exiIn.V2G_Message.Header.Signature_isUsed = 0u;
+
+
+	/************************
+	 * sessionSetup *
+	 ************************/
+	init_iso2BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.SessionSetupReq_isUsed = 1u;
+
+	init_iso2SessionSetupReqType(&exiIn.V2G_Message.Body.SessionSetupReq);
+
+	exiIn.V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen = 1;
+	exiIn.V2G_Message.Body.SessionSetupReq.EVCCID.bytes[0] = 10;
+
+	printf("EV side: call EVSE sessionSetup");
+
+	errn = request_response2(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.SessionSetupRes_isUsed) {
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\tResponseCode=%d\n", exiOut.V2G_Message.Body.SessionSetupRes.ResponseCode);
+			printf("\tEVSEID=%d\n",	exiOut.V2G_Message.Body.SessionSetupRes.EVSEID.characters[1]);
+			printf("\tEVSETimeStamp=%li\n", (long int)exiOut.V2G_Message.Body.SessionSetupRes.EVSETimeStamp);
+		} else {
+			errn = ERROR_UNEXPECTED_SESSION_SETUP_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+	/*******************************************
+	 * serviceDiscovery *
+	 *******************************************/
+	init_iso2BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.ServiceDiscoveryReq_isUsed = 1u;
+
+	init_iso2ServiceDiscoveryReqType(&exiIn.V2G_Message.Body.ServiceDiscoveryReq);
+
+	exiIn.V2G_Message.Body.ServiceDiscoveryReq.SupportedServiceIDs_isUsed = 1u;
+	exiIn.V2G_Message.Body.ServiceDiscoveryReq.SupportedServiceIDs.ServiceID.arrayLen = 1;
+	exiIn.V2G_Message.Body.ServiceDiscoveryReq.SupportedServiceIDs.ServiceID.array[0] = iso2serviceCategoryType_Internet;
+
+	printf("EV side: call EVSE serviceDiscovery");
+
+	errn = request_response2(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.ServiceDiscoveryRes_isUsed) {
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n",  exiOut.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode);
+
+			printf("\t Service ResponseCode=%d\n",	exiOut.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode);
+
+			/*printf("\t ServiceID=%d\n",	exiOut.V2G_Message.Body.ServiceDiscoveryRes.ChargeService.ServiceID);
+			printf("\t ServiceName=");
+			printASCIIString(serviceDiscoveryRes.ChargeService.ServiceName.characters, serviceDiscoveryRes.ChargeService.ServiceName.charactersLen);
+			if(serviceDiscoveryRes.PaymentOptionList.PaymentOption.array[1] == v2gpaymentOptionType_Contract) {
+				printf("\t PaymentOption=Contract_paymentOptionType\n");
+			}
+			if(serviceDiscoveryRes.ChargeService.FreeService==1) {
+				printf("\t ChargeService.FreeService=True\n");
+			}
+			if(serviceDiscoveryRes.ChargeService.SupportedEnergyTransferMode.EnergyTransferMode.array[0] == v2gEnergyTransferModeType_DC_combo_core) {
+				printf("\t EnergyTransferMode=AC_single_DC_core\n");
+			}
+			if(serviceDiscoveryRes.ChargeService.SupportedEnergyTransferMode.EnergyTransferMode.array[1] == v2gEnergyTransferModeType_AC_single_phase_core) {
+				printf("\t EnergyTransferMode=AC_single_phase_core_EnergyTransferModeType\n");
+			}
+			printf("\t Value added service list:\n");
+			for(i=0;i<serviceDiscoveryRes.ServiceList.Service.arrayLen;i++)
+			{
+				printf("\n\t\t ServiceID=%d\n",	serviceDiscoveryRes.ServiceList.Service.array[i].ServiceID);
+				printf("\t\t ServiceName=");
+				printASCIIString(serviceDiscoveryRes.ServiceList.Service.array[i].ServiceName.characters, exiOut.V2G_Message.Body.ServiceDiscoveryRes.ServiceList.Service.array[i].ServiceName.charactersLen );
+				if(serviceDiscoveryRes.ServiceList.Service.array[i].ServiceCategory == v2gserviceCategoryType_Internet) {
+					printf("\t\t ServiceCategory=Internet\n");
+				}
+				if(serviceDiscoveryRes.ServiceList.Service.array[i].FreeService==1) {
+					printf("\t\t FreeService=True\n");
+				}
+			}*/
+
+		} else {
+			errn = ERROR_UNEXPECTED_SERVICE_DISCOVERY_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+	/*********************************
+	 * ServiceDetails *
+	 *********************************/
+	init_iso2BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.ServiceDetailReq_isUsed = 1u;
+
+	init_iso2ServiceDetailReqType(&exiIn.V2G_Message.Body.ServiceDetailReq);
+
+	exiIn.V2G_Message.Body.ServiceDetailReq.ServiceID = 22; /* Value Added Server ID */
+
+	printf("EV side: call EVSE ServiceDetail \n");
+
+	errn = request_response2(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.ServiceDetailRes_isUsed) {
+			serviceDetailRes = exiOut.V2G_Message.Body.ServiceDetailRes;
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n",  exiOut.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode);
+			printf("\t ServiceID=%d\n",	exiOut.V2G_Message.Body.ServiceDetailRes.ServiceID);
+
+			if(serviceDetailRes.ServiceParameterList_isUsed) {
+				printf("\t\tLength=%d\n", serviceDetailRes.ServiceParameterList.ParameterSet.arrayLen );/*TEST*/
+
+				for(i=0; i<serviceDetailRes.ServiceParameterList.ParameterSet.arrayLen; i++)
+				{
+					printf("\t\tServiceSetID=%d\n", serviceDetailRes.ServiceParameterList.ParameterSet.array[i].ParameterSetID);
+					printf("\t\tParameters=%d\n", serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.arrayLen);
+
+					for(j=0; j<serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.arrayLen; j++)
+					{
+						printf("\t\t\t %d: ParameterName=", j+1);
+						printASCIIString(serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].Name.characters, exiOut.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].Name.charactersLen);
+
+						/*if(serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].shortValue_isUsed == 1u) {
+							printf("\t\t\t %d: StringValue=", j+1);
+							printASCIIString(serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].stringValue.characters, serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].stringValue.charactersLen);
+						} else if(serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].intValue_isUsed == 1u) {
+							printf("\t\t\t %d: IntValue=%d\n", j+1, serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].intValue);
+						} else if(serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].physicalValue_isUsed == 1u) {
+							printf("\t\t\t %d: PhysicalValue=%d (%d)\n",  j+1, serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].physicalValue.Value, serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].physicalValue.Multiplier);
+						}*/
+					}
+				}
+			}
+		} else {
+			errn = ERROR_UNEXPECTED_SERVICE_DETAILS_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+	/*******************************************
+	 * ServicePaymentSelection *
+	 *******************************************/
+	init_iso2BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.PaymentServiceSelectionReq_isUsed = 1u;
+
+	init_iso2PaymentServiceSelectionReqType(&exiIn.V2G_Message.Body.PaymentServiceSelectionReq);
+
+	exiIn.V2G_Message.Body.PaymentServiceSelectionReq.SelectedPaymentOption = iso2paymentOptionType_ExternalPayment;
+	exiIn.V2G_Message.Body.PaymentServiceSelectionReq.SelectedVASList_isUsed = 0u;
+	exiIn.V2G_Message.Body.PaymentServiceSelectionReq.SelectedEnergyTransferService.ServiceID = 1;
+	exiIn.V2G_Message.Body.PaymentServiceSelectionReq.SelectedEnergyTransferService.ParameterSetID = 4;
+
+	printf("EV side: call EVSE ServicePaymentSelection \n");
+
+	errn = request_response2(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.PaymentServiceSelectionRes_isUsed) {
+			paymentServiceSelectionRes = exiOut.V2G_Message.Body.PaymentServiceSelectionRes;
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			if(exiOut.V2G_Message.Body.PaymentServiceSelectionRes.EVSEStatus_isUsed) {
+				printf("\tHeader SessionID=");
+				printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			}
+			printf("\t ResponseCode=%d\n",  paymentServiceSelectionRes.ResponseCode);
+
+		} else {
+			errn = ERROR_UNEXPECTED_PAYMENT_SERVICE_SELECTION_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+	/**********************************
+	 * PaymentDetails *
+	 **********************************/
+	init_iso2BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.PaymentDetailsReq_isUsed = 1u;
+
+	init_iso2PaymentDetailsReqType(&exiIn.V2G_Message.Body.PaymentDetailsReq);
+
+	exiIn.V2G_Message.Body.PaymentDetailsReq.eMAID.characters[0] = 1;
+	exiIn.V2G_Message.Body.PaymentDetailsReq.eMAID.characters[1] = 123;
+	exiIn.V2G_Message.Body.PaymentDetailsReq.eMAID.charactersLen =2;
+
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.Certificate.bytes[0] = 'C';
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.Certificate.bytes[1] = 'e';
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.Certificate.bytesLen = 2;
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.SubCertificates_isUsed = 1u;
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.SubCertificates.Certificate.array[0].bytes[0] = 'S';
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.SubCertificates.Certificate.array[0].bytes[1] = 'u';
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.SubCertificates.Certificate.array[0].bytesLen = 2;
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.SubCertificates.Certificate.array[1].bytes[0] = 'S';
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.SubCertificates.Certificate.array[1].bytes[1] = 'u';
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.SubCertificates.Certificate.array[1].bytes[2] = '2';
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.SubCertificates.Certificate.array[1].bytesLen = 3;
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.SubCertificates.Certificate.arrayLen =2;
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.Id_isUsed = 1u;
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.Id.charactersLen = 2;
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.Id.characters[0] = 'I';
+	exiIn.V2G_Message.Body.PaymentDetailsReq.ContractSignatureCertChain.Id.characters[0] = 'd';
+
+	printf("EV side: call EVSE ServiceDetail \n");
+
+	errn = request_response2(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.PaymentDetailsRes_isUsed) {
+
+			paymentDetailsRes = exiOut.V2G_Message.Body.PaymentDetailsRes;
+
+			printf("EV side: received response message from EVSE\n");
+			/* show results of EVSEs answer message */
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n",  paymentDetailsRes.ResponseCode);
+			printf("\tEVSETimeStamp=%li\n",  (long int) paymentDetailsRes.EVSETimeStamp);
+			printf("\tGenChallenge=%d\n",   paymentDetailsRes.GenChallenge.bytes[0]);
+
+		} else {
+			errn = ERROR_UNEXPECTED_PAYMENT_DETAILS_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+
+	/*******************************************
+	 * Authorization *
+	 *******************************************/
+	init_iso2BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.AuthorizationReq_isUsed = 1u;
+
+	init_iso2AuthorizationReqType(&exiIn.V2G_Message.Body.AuthorizationReq);
+
+	copyBytes(paymentDetailsRes.GenChallenge.bytes, paymentDetailsRes.GenChallenge.bytesLen, exiIn.V2G_Message.Body.AuthorizationReq.GenChallenge.bytes);
+	exiIn.V2G_Message.Body.AuthorizationReq.GenChallenge.bytesLen = paymentDetailsRes.GenChallenge.bytesLen;
+	exiIn.V2G_Message.Body.AuthorizationReq.GenChallenge_isUsed = 1u; /* no challenge needed here*/
+	exiIn.V2G_Message.Body.AuthorizationReq.Id_isUsed = 1u; /* no signature needed here */
+	exiIn.V2G_Message.Body.AuthorizationReq.Id.charactersLen = 3;
+	exiIn.V2G_Message.Body.AuthorizationReq.Id.characters[0] = 'I';
+	exiIn.V2G_Message.Body.AuthorizationReq.Id.characters[1] = 'd';
+	exiIn.V2G_Message.Body.AuthorizationReq.Id.characters[2] = '2';
+
+	printf("EV side: call EVSE Authorization \n");
+
+
+	errn = request_response2(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.AuthorizationRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n",  exiOut.V2G_Message.Body.AuthorizationRes.ResponseCode);
+
+			if(exiOut.V2G_Message.Body.AuthorizationRes.EVSEProcessing == iso2EVSEProcessingType_Finished) {
+				printf("\t EVSEProcessing=Finished\n");
+			}
+		} else {
+			errn = ERROR_UNEXPECTED_AUTHORIZATION_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+
+	/*******************************************
+	 * chargeParameterDiscovery *
+	 *******************************************/
+	init_iso2BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq_isUsed = 1u;
+
+	init_iso2ChargeParameterDiscoveryReqType(&exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq);
+
+	/* we use here AC based charging parameters */
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.MaxSupportingPoints_isUsed = 1u;
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.MaxSupportingPoints = 1234;
+
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter_isUsed = 1u;
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.DepartureTime = 12345;
+
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMaximumChargePower.Exponent = 0;
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMaximumChargePower.Value = 100;
+
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMaximumChargeCurrent.Exponent = 0;
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMaximumChargeCurrent.Value = 400;
+
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMinimumChargeCurrent.Exponent = 0;
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMinimumChargeCurrent.Value = 200;
+
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMaximumVoltage.Exponent = 0;
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMaximumVoltage.Value = 400;
+
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMaximumDischargePower.Exponent = 0;
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMaximumDischargePower.Value = 200;
+
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMaximumDischargeCurrent.Exponent = 0;
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMaximumDischargeCurrent.Value = 400;
+
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMinimumDischargeCurrent.Exponent = 0;
+	exiIn.V2G_Message.Body.ChargeParameterDiscoveryReq.AC_EVBidirectionalParameter.EVMinimumDischargeCurrent.Value = 200;
+
+	printf("EV side: call EVSE chargeParameterDiscovery");
+
+	errn = request_response2(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.ChargeParameterDiscoveryRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n", exiOut.V2G_Message.Body.ChargeParameterDiscoveryRes.ResponseCode);
+
+			/*printACEVSEStatus(&(exiOut.V2G_Message.Body.ChargeParameterDiscoveryRes.AC_EVSEChargeParameter.AC_EVSEStatus));
+			printf("\t EVSEProcessing=%d\n", exiOut.V2G_Message.Body.ChargeParameterDiscoveryRes.EVSEProcessing);
+			printf("\t EVSEMaxCurrent=%d\n", exiOut.V2G_Message.Body.ChargeParameterDiscoveryRes.AC_EVSEChargeParameter.EVSEMaxCurrent.Value);
+			printf("\t EVSENominalVoltage=%d\n", exiOut.V2G_Message.Body.ChargeParameterDiscoveryRes.AC_EVSEChargeParameter.EVSENominalVoltage.Value);*/
+		} else {
+			errn = ERROR_UNEXPECTED_CHARGE_PARAMETER_DISCOVERY_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+
+
+	/*****************************
+	 * cableCheck *
+	 *****************************/
+	init_iso2BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.CableCheckReq_isUsed = 1u;
+
+	/*init_v2gCableCheckReqType(&exiIn.V2G_Message.Body.CableCheckReq);*/
+
+	printf("EV side: call EVSE cableCheck \n");
+
+	errn = request_response2(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.CableCheckRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n", exiOut.V2G_Message.Body.CableCheckRes.ResponseCode);
+
+			if(exiOut.V2G_Message.Body.CableCheckRes.EVSEProcessing==iso2EVSEProcessingType_Finished) {
+				printf("\tEVSEProcessing=Finished\n");
+			}
+
+			printEVSEStatus2(&(exiOut.V2G_Message.Body.CableCheckRes.EVSEStatus));
+		} else {
+			errn = ERROR_UNEXPECTED_CABLE_CHECK_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+	/*****************************
+	 * preCharge *
+	 *****************************/
+	init_iso2BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.PreChargeReq_isUsed = 1u;
+
+	init_iso2PreChargeReqType(&exiIn.V2G_Message.Body.PreChargeReq);
+
+	exiIn.V2G_Message.Body.PreChargeReq.EVTargetCurrent.Exponent = 1;
+	exiIn.V2G_Message.Body.PreChargeReq.EVTargetCurrent.Value = 234;
+
+	exiIn.V2G_Message.Body.PreChargeReq.EVTargetVoltage.Exponent = 1;
+	exiIn.V2G_Message.Body.PreChargeReq.EVTargetVoltage.Value = 100;
+
+	printf("EV side: call EVSE preCharge \n");
+
+	errn = request_response2(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.PreChargeRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n", exiOut.V2G_Message.Body.PreChargeRes.ResponseCode);
+
+			printEVSEStatus2(&exiOut.V2G_Message.Body.PreChargeRes.EVSEStatus);
+			printf("\tEVSEPresentVoltage=%d (%d %d)\n", exiOut.V2G_Message.Body.PreChargeRes.EVSEPresentVoltage.Value, exiOut.V2G_Message.Body.PreChargeRes.EVSEPresentVoltage.Value, exiOut.V2G_Message.Body.PreChargeRes.EVSEPresentVoltage.Exponent);
+
+		} else {
+			errn = ERROR_UNEXPECTED_PRE_CHARGE_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+	/*********************************
+	 * PowerDelivery *
+	 *********************************/
+
+	init_iso2BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.PowerDeliveryReq_isUsed = 1u;
+
+	init_iso2PowerDeliveryReqType(&exiIn.V2G_Message.Body.PowerDeliveryReq);
+
+	exiIn.V2G_Message.Body.PowerDeliveryReq.ChargeProgress = iso2chargeProgressType_Start;
+	exiIn.V2G_Message.Body.PowerDeliveryReq.SAScheduleTupleID_isUsed = 1u;
+	exiIn.V2G_Message.Body.PowerDeliveryReq.SAScheduleTupleID = exiOut.V2G_Message.Body.ChargeParameterDiscoveryRes.SAScheduleList.SAScheduleTuple.array[0].SAScheduleTupleID;
+
+	printf("EV side: call EVSE powerDelivery \n");
+
+	errn = request_response2(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.PowerDeliveryRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n", exiOut.V2G_Message.Body.PowerDeliveryRes.ResponseCode);
+
+			/*printACEVSEStatus(&(exiOut.V2G_Message.Body.PowerDeliveryRes.AC_EVSEStatus));*/
+		} else {
+			errn = ERROR_UNEXPECTED_POWER_DELIVERY_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+	/*********************************
+	 * Setup data for chargingStatus *
+	 *********************************/
+
+	init_iso2BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.ChargingStatusReq_isUsed = 1u;
+
+	init_iso2ChargingStatusReqType(&exiIn.V2G_Message.Body.ChargingStatusReq);
+	exiIn.V2G_Message.Body.ChargingStatusReq.EVTargetEnergyRequest.Exponent = 2;
+	exiIn.V2G_Message.Body.ChargingStatusReq.EVTargetEnergyRequest.Value = 100;
+
+	printf("EV side: call EVSE chargingStatus \n");
+
+	errn = request_response2(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.ChargingStatusRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n", exiOut.V2G_Message.Body.ChargingStatusRes.ResponseCode);
+
+			/*printACEVSEStatus(&(exiOut.V2G_Message.Body.ChargingStatusRes.AC_EVSEStatus));
+
+			printf("\tReceiptRequired=%d\n", exiOut.V2G_Message.Body.ChargingStatusRes.ReceiptRequired);
+			printf("\tEVSEID=%d\n", exiOut.V2G_Message.Body.ChargingStatusRes.EVSEID.characters[0]);
+			printf("\tSAScheduleTupleID=%d\n", exiOut.V2G_Message.Body.ChargingStatusRes.SAScheduleTupleID);
+			printf("\tEVSEMaxCurrent=%d (%d %d)\n", exiOut.V2G_Message.Body.ChargingStatusRes.EVSEMaxCurrent.Value, exiOut.V2G_Message.Body.ChargingStatusRes.EVSEMaxCurrent.Unit, exiOut.V2G_Message.Body.ChargingStatusRes.EVSEMaxCurrent.Multiplier);
+			printf("\tisused.MeterInfo=%d\n",		exiOut.V2G_Message.Body.ChargingStatusRes.MeterInfo_isUsed);
+			printf("\t\tMeterInfo.MeterID=%d\n",		exiOut.V2G_Message.Body.ChargingStatusRes.MeterInfo.MeterID.characters[0]);
+			printf("\t\tMeterInfo.MeterReading.Value=%li\n",		(long int)exiOut.V2G_Message.Body.ChargingStatusRes.MeterInfo.MeterReading);
+			printf("\t\tMeterInfo.MeterStatus=%d\n",		exiOut.V2G_Message.Body.ChargingStatusRes.MeterInfo.MeterStatus);
+			printf("\t\tMeterInfo.TMeter=%li\n",		(long int)exiOut.V2G_Message.Body.ChargingStatusRes.MeterInfo.TMeter);
+			printf("\t\tMeterInfo.SigMeterReading.data=%d\n",		exiOut.V2G_Message.Body.ChargingStatusRes.MeterInfo.SigMeterReading.bytes[0]);*/
+		} else {
+			errn = ERROR_UNEXPECTED_CHARGING_STATUS_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+
+	/***********************************
+	 * MeteringReceipt *
+	 ***********************************/
+
+	init_iso2BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.MeteringReceiptReq_isUsed = 1u;
+
+	init_iso2MeteringReceiptReqType(&exiIn.V2G_Message.Body.MeteringReceiptReq);
+
+
+	exiIn.V2G_Message.Body.MeteringReceiptReq.Id.characters[0]='I';
+	exiIn.V2G_Message.Body.MeteringReceiptReq.Id.characters[1]='d';
+	exiIn.V2G_Message.Body.MeteringReceiptReq.Id.characters[2]='3';
+	exiIn.V2G_Message.Body.MeteringReceiptReq.Id.charactersLen =3;
+
+	exiIn.V2G_Message.Body.MeteringReceiptReq.SessionID.bytes[0] = 22;
+	exiIn.V2G_Message.Body.MeteringReceiptReq.SessionID.bytesLen = 1;
+
+	init_iso2MeterInfoType(&exiIn.V2G_Message.Body.MeteringReceiptReq.MeterInfo);
+	exiIn.V2G_Message.Body.MeteringReceiptReq.MeterInfo.MeterID.characters[0] = 'M';
+	exiIn.V2G_Message.Body.MeteringReceiptReq.MeterInfo.MeterID.characters[1] = 'i';
+	exiIn.V2G_Message.Body.MeteringReceiptReq.MeterInfo.MeterID.characters[2] = 'd';
+	exiIn.V2G_Message.Body.MeteringReceiptReq.MeterInfo.MeterID.charactersLen = 3;
+
+	printf("EV side: call EVSE meteringReceipt \n");
+
+	errn = request_response2(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.MeteringReceiptRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n", exiOut.V2G_Message.Body.MeteringReceiptRes.ResponseCode);
+
+		} else {
+			errn = ERROR_UNEXPECTED_METERING_RECEIPT_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+	/***********************************
+	 * SessionStop *
+	 ***********************************/
+
+
+	init_iso2BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.SessionStopReq_isUsed = 1u;
+
+	init_iso2SessionStopReqType(&exiIn.V2G_Message.Body.SessionStopReq);
+	exiIn.V2G_Message.Body.SessionStopReq.ChargingSession = iso2chargingSessionType_Pause;
+
+	printf("EV side: call EVSE stopSession \n");
+
+	errn = request_response2(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.SessionStopRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n", exiOut.V2G_Message.Body.SessionStopRes.ResponseCode);
+
+		} else {
+			errn = ERROR_UNEXPECTED_SESSION_STOP_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+	return errn;
+
+}
+#endif /* DEPLOY_ISO2_CODEC == SUPPORT_YES */
+
+
+
+
+
+
+#if DEPLOY_ISO1_CODEC == SUPPORT_YES
+
+static void printEVSEStatus1(struct iso1DC_EVSEStatusType* status)
+{
+	printf("\tEVSEStatus:\n");
+	printf("\t\tEVSENotification=%d\n", status->EVSENotification);
+	printf("\t\tNotificationMaxDelay=%d\n", status->NotificationMaxDelay);
+}
+
+
+/* serializes EXI stream and adds V2G TP header */
+static int serialize1EXI2Stream(struct iso1EXIDocument* exiIn, bitstream_t* stream) {
+	int errn;
+	*stream->pos = V2GTP_HEADER_LENGTH;  /* v2gtp header */
+	if( (errn = encode_iso1ExiDocument(stream, exiIn)) == 0) {
+		errn = write_v2gtpHeader(stream->data, (*stream->pos)-V2GTP_HEADER_LENGTH, V2GTP_EXI_TYPE);
+	}
+	return errn;
+}
+
+
+
+/* deserializes V2G TP header and decodes right away EXI stream */
+static int deserialize1Stream2EXI(bitstream_t* streamIn, struct iso1EXIDocument* exi) {
+	int errn;
+	uint32_t payloadLength;
+
+	*streamIn->pos = 0;
+	if ( (errn = read_v2gtpHeader(streamIn->data, &payloadLength)) == 0) {
+		*streamIn->pos += V2GTP_HEADER_LENGTH;
+
+		errn = decode_iso1ExiDocument(streamIn, exi);
+	}
+	return errn;
+}
+
+
+
+static int sessionSetup1(struct iso1EXIDocument* exiIn, struct iso1EXIDocument* exiOut) {
+	printf("EVSE side: sessionSetup called\n"  );
+	printf("\tReceived data:\n");
+	printf("\tHeader SessionID=");
+	printBinaryArray(exiIn->V2G_Message.Header.SessionID.bytes, exiIn->V2G_Message.Header.SessionID.bytesLen);
+	printf("\t\t EVCCID=%d\n", exiIn->V2G_Message.Body.SessionSetupReq.EVCCID.bytes[0]);
+
+	exiOut->V2G_Message_isUsed = 1u;
+
+	/* generate an unique sessionID */
+	init_iso1MessageHeaderType(&exiOut->V2G_Message.Header);
+	exiOut->V2G_Message.Header.SessionID.bytes[0] = 1;
+	exiOut->V2G_Message.Header.SessionID.bytes[1] = 2;
+	exiOut->V2G_Message.Header.SessionID.bytes[2] = 3;
+	exiOut->V2G_Message.Header.SessionID.bytes[3] = 4;
+	exiOut->V2G_Message.Header.SessionID.bytes[4] = 5;
+	exiOut->V2G_Message.Header.SessionID.bytes[5] = 6;
+	exiOut->V2G_Message.Header.SessionID.bytes[6] = 7;
+	exiOut->V2G_Message.Header.SessionID.bytes[7] = 8;
+	exiOut->V2G_Message.Header.SessionID.bytesLen = 8;
+
+	/* Prepare data for EV */
+	init_iso1BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.SessionSetupRes_isUsed = 1u;
+	init_iso1SessionSetupResType(&exiOut->V2G_Message.Body.SessionSetupRes);
+
+	exiOut->V2G_Message.Body.SessionSetupRes.ResponseCode = iso1responseCodeType_OK;
+	exiOut->V2G_Message.Body.SessionSetupRes.EVSEID.characters[0] = 0;
+	exiOut->V2G_Message.Body.SessionSetupRes.EVSEID.characters[1] = 20;
+	exiOut->V2G_Message.Body.SessionSetupRes.EVSEID.charactersLen = 2;
+	exiOut->V2G_Message.Body.SessionSetupRes.EVSETimeStamp_isUsed = 1u;
+	exiOut->V2G_Message.Body.SessionSetupRes.EVSETimeStamp = 123456789;
+
+	return 0;
+}
+
+
+
+static int serviceDetail1(struct iso1EXIDocument* exiIn, struct iso1EXIDocument* exiOut) {
+
+	printf("EVSE side: serviceDetail called\n"  );
+	printf("\tReceived data:\n");
+	printf("\tHeader SessionID=");
+	printBinaryArray(exiIn->V2G_Message.Header.SessionID.bytes, exiIn->V2G_Message.Header.SessionID.bytesLen);
+	printf("\t\t ServiceDetailID=%d\n",exiIn->V2G_Message.Body.ServiceDetailReq.ServiceID);
+
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso1BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.ServiceDetailRes_isUsed= 1u;
+	init_iso1ServiceDetailResType(&exiOut->V2G_Message.Body.ServiceDetailRes);
+
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceID = 1234;
+
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList_isUsed = 1u;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.arrayLen = 2;
+
+	/* Parameter Set 1*/
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].ParameterSetID = 1;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.arrayLen = 2;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.charactersLen = 8;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[0] = 'P';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[1] = 'r';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[2] = 'o';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[3] = 't';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[4]= 'o';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[5] = 'c';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[6] = 'o';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].Name.characters[7] = 'l';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].intValue = 15119;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[0].intValue_isUsed = 1u;
+
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].Name.charactersLen = 4;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].Name.characters[0] = 'N';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].Name.characters[1] = 'a';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].Name.characters[2] = 'm';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].Name.characters[3] = 'e';
+
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].stringValue_isUsed = 1u;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].stringValue.charactersLen = 3;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].stringValue.characters[0] = 'V';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].stringValue.characters[1] = '2';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[0].Parameter.array[1].stringValue.characters[2] = 'G';
+
+	/* Parameter Set 2 */
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].ParameterSetID = 2;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.arrayLen = 1;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.charactersLen = 7;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[0] = 'C';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[1] = 'h';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[2] = 'a';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[3] = 'n';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[4] = 'n';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[5] = 'e';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].Name.characters[6] = 'l';
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].physicalValue_isUsed = 1u;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].physicalValue.Value = 1234;
+
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].physicalValue.Multiplier = 1;
+	exiOut->V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[1].Parameter.array[0].physicalValue.Value = 2;
+
+	exiOut->V2G_Message.Body.ServiceDetailRes.ResponseCode = iso1responseCodeType_OK;
+
+	return 0;
+}
+
+
+
+static int authorization1(struct iso1EXIDocument* exiIn, struct iso1EXIDocument* exiOut) {
+
+	printf("EVSE: Authorization called\n"  );
+	printf("\tReceived data:\n");
+
+	if(exiIn->V2G_Message.Body.AuthorizationReq.GenChallenge_isUsed) {
+		printf("\t\t\t GenChallenge=%d\n", exiIn->V2G_Message.Body.AuthorizationReq.GenChallenge.bytes[0]);
+	}
+	if(exiIn->V2G_Message.Body.AuthorizationReq.Id_isUsed ) {
+		printf("\t\t\t ID=%c%c%c\n", exiIn->V2G_Message.Body.AuthorizationReq.Id.characters[0], exiIn->V2G_Message.Body.AuthorizationReq.Id.characters[1], exiIn->V2G_Message.Body.AuthorizationReq.Id.characters[2]);
+	}
+
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso1BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.AuthorizationRes_isUsed = 1u;
+	init_iso1AuthorizationResType(&exiOut->V2G_Message.Body.AuthorizationRes);
+
+	exiOut->V2G_Message.Body.AuthorizationRes.ResponseCode = iso1responseCodeType_OK;
+	exiOut->V2G_Message.Body.AuthorizationRes.EVSEProcessing = iso1EVSEProcessingType_Finished;
+
+	return 0;
+}
+
+
+static int powerDelivery1(struct iso1EXIDocument* exiIn, struct iso1EXIDocument* exiOut) {
+	printf("EVSE side: powerDelivery called\n"  );
+	printf("\tReceived data:\n");
+
+	printf("\t\t  ChargeProgress=%d\n", exiIn->V2G_Message.Body.PowerDeliveryReq.ChargeProgress);
+	printf("\t\t  SAScheduleTupleID=%d\n", exiIn->V2G_Message.Body.PowerDeliveryReq.SAScheduleTupleID);
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso1BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.PowerDeliveryRes_isUsed = 1u;
+	init_iso1PowerDeliveryResType(&exiOut->V2G_Message.Body.PowerDeliveryRes);
+
+	exiOut->V2G_Message.Body.PowerDeliveryRes.ResponseCode = iso1responseCodeType_OK;
+
+	exiOut->V2G_Message.Body.PowerDeliveryRes.EVSEStatus_isUsed = 1;
+	exiOut->V2G_Message.Body.PowerDeliveryRes.EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
+	exiOut->V2G_Message.Body.PowerDeliveryRes.EVSEStatus.NotificationMaxDelay=12;
+
+	return 0;
+}
+
+
+static int chargingStatus1(struct iso1EXIDocument* exiIn, struct iso1EXIDocument* exiOut) {
+
+	printf("EVSE side: chargingStatus called\n"  );
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso1BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.ChargingStatusRes_isUsed = 1u;
+	init_iso1ChargingStatusResType(&exiOut->V2G_Message.Body.ChargingStatusRes);
+
+
+	exiOut->V2G_Message.Body.ChargingStatusRes.ResponseCode = iso1responseCodeType_OK;
+	exiOut->V2G_Message.Body.ChargingStatusRes.EVSEID.characters[0]= 'A';
+	exiOut->V2G_Message.Body.ChargingStatusRes.EVSEID.charactersLen =1;
+
+	exiOut->V2G_Message.Body.ChargingStatusRes.ReceiptRequired = 1;
+	exiOut->V2G_Message.Body.ChargingStatusRes.ReceiptRequired_isUsed = 1;
+
+	return 0;
+}
+
+
+static int meteringReceipt1(struct iso1EXIDocument* exiIn, struct iso1EXIDocument* exiOut) {
+
+	printf("EVSE side: meteringReceipt called\n"  );
+	printf("\tReceived data:\n");
+
+	printf("\t\t ID=%c%c%c\n", exiIn->V2G_Message.Body.MeteringReceiptReq.Id.characters[0], exiIn->V2G_Message.Body.MeteringReceiptReq.Id.characters[1], exiIn->V2G_Message.Body.MeteringReceiptReq.Id.characters[2]);
+	printf("\t\t SAScheduleTupleID=%d\n", exiIn->V2G_Message.Body.MeteringReceiptReq.SAScheduleTupleID);
+	printf("\t\t SessionID=%d\n", exiIn->V2G_Message.Body.MeteringReceiptReq.SessionID.bytes[1]);
+	printf("\t\t MeterInfo.MeterStatus=%d\n", exiIn->V2G_Message.Body.MeteringReceiptReq.MeterInfo.MeterStatus);
+	printf("\t\t MeterInfo.MeterID=%d\n",		exiIn->V2G_Message.Body.MeteringReceiptReq.MeterInfo.MeterID.characters[0]);
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso1BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.MeteringReceiptRes_isUsed = 1u;
+	init_iso1MeteringReceiptResType(&exiOut->V2G_Message.Body.MeteringReceiptRes);
+
+	exiOut->V2G_Message.Body.MeteringReceiptRes.ResponseCode = iso1responseCodeType_FAILED;
+
+	return 0;
+}
+
+static int sessionStop1(struct iso1EXIDocument* exiIn, struct iso1EXIDocument* exiOut) {
+
+	printf("EVSE side: sessionStop called\n"  );
+	printf("\tReceived data:\n");
+	printf("\tHeader SessionID=");
+	printBinaryArray(exiIn->V2G_Message.Header.SessionID.bytes, exiIn->V2G_Message.Header.SessionID.bytesLen);
+	printf("\t\t ChargingSession=%d\n", exiIn->V2G_Message.Body.SessionStopReq.ChargingSession);
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso1BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.SessionStopRes_isUsed = 1u;
+	init_iso1SessionStopResType(&exiOut->V2G_Message.Body.SessionStopRes);
+
+	exiOut->V2G_Message.Body.SessionStopRes.ResponseCode = iso1responseCodeType_OK;
+
+	return 0;
+}
+
+static int cableCheck1(struct iso1EXIDocument* exiIn, struct iso1EXIDocument* exiOut) {
+
+	printf("EVSE side: cableCheck called\n"  );
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso1BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.CableCheckRes_isUsed = 1u;
+	init_iso1CableCheckResType(&exiOut->V2G_Message.Body.CableCheckRes);
+
+	exiOut->V2G_Message.Body.CableCheckRes.ResponseCode = iso1responseCodeType_OK;
+
+	exiOut->V2G_Message.Body.CableCheckRes.DC_EVSEStatus.NotificationMaxDelay = 1234;
+	exiOut->V2G_Message.Body.CableCheckRes.DC_EVSEStatus.EVSENotification= iso1EVSENotificationType_ReNegotiation;
+
+	exiOut->V2G_Message.Body.CableCheckRes.EVSEProcessing = iso1EVSEProcessingType_Finished;
+
+	return 0;
+}
+
+static int preCharge1(struct iso1EXIDocument* exiIn, struct iso1EXIDocument* exiOut) {
+
+	printf("EVSE side: preCharge called\n"  );
+	printf("\tReceived data:\n");
+
+	printf("\t\t EVTargetCurrent=%d (%d)\n", exiIn->V2G_Message.Body.PreChargeReq.EVTargetCurrent.Value, exiIn->V2G_Message.Body.PreChargeReq.EVTargetCurrent.Multiplier);
+	printf("\t\t EVTargetVoltage=%d (%d)\n", exiIn->V2G_Message.Body.PreChargeReq.EVTargetVoltage.Value, exiIn->V2G_Message.Body.PreChargeReq.EVTargetVoltage.Multiplier);
+
+	/* Prepare data for EV */
+	exiOut->V2G_Message_isUsed = 1u;
+	init_iso1BodyType(&exiOut->V2G_Message.Body);
+
+	exiOut->V2G_Message.Body.PreChargeRes_isUsed = 1u;
+	init_iso1PreChargeResType(&exiOut->V2G_Message.Body.PreChargeRes);
+
+	exiOut->V2G_Message.Body.PreChargeRes.ResponseCode = iso1responseCodeType_OK;
+
+	exiOut->V2G_Message.Body.PreChargeRes.DC_EVSEStatus.EVSENotification = iso1EVSENotificationType_StopCharging;
+	exiOut->V2G_Message.Body.PreChargeRes.DC_EVSEStatus.NotificationMaxDelay= 1234;
+
+	exiOut->V2G_Message.Body.PreChargeRes.EVSEPresentVoltage.Multiplier = 3;
+	exiOut->V2G_Message.Body.PreChargeRes.EVSEPresentVoltage.Value= 456;
+
+	return 0;
+}
+
+
+
+
+
+static int create_response_message1(struct iso1EXIDocument* exiIn, struct iso1EXIDocument* exiOut) {
+	int errn = ERROR_UNEXPECTED_REQUEST_MESSAGE;
+
+	/* create response message as EXI document */
+	if(exiIn->V2G_Message_isUsed) {
+		init_iso1EXIDocument(exiOut);
+		if (exiIn->V2G_Message.Body.SessionSetupReq_isUsed) {
+			errn = sessionSetup1(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.ServiceDetailReq_isUsed) {
+			errn = serviceDetail1(exiIn, exiOut);
+		/*} else if (exiIn->V2G_Message.Body.PaymentDetailsReq_isUsed) {
+			errn = paymentDetails1(exiIn, exiOut);*/
+		} else if (exiIn->V2G_Message.Body.AuthorizationReq_isUsed) {
+			errn = authorization1(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.PowerDeliveryReq_isUsed) {
+			errn = powerDelivery1(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.ChargingStatusReq_isUsed) {
+			errn = chargingStatus1(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.MeteringReceiptReq_isUsed) {
+			errn = meteringReceipt1(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.SessionStopReq_isUsed) {
+			errn = sessionStop1(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.CableCheckReq_isUsed) {
+			errn = cableCheck1(exiIn, exiOut);
+		} else if (exiIn->V2G_Message.Body.PreChargeReq_isUsed) {
+			errn = preCharge1(exiIn, exiOut);
+		}
+	}
+
+	return errn;
+}
+
+
+/* Adapt this to your system setup! */
+/* In this situation EV and EVSE is the same party */
+static int request_response1(struct iso1EXIDocument* exiIn, struct iso1EXIDocument* exiOut) {
+	int errn;
+
+	bitstream_t stream1;
+	bitstream_t stream2;
+
+	size_t pos1;
+	size_t pos2;
+
+	stream1.size = BUFFER_SIZE;
+	stream1.data = buffer1;
+	stream1.pos = &pos1;
+
+	stream2.size = BUFFER_SIZE;
+	stream2.data = buffer2;
+	stream2.pos = &pos2;
+
+	/* EV side */
+	errn = serialize1EXI2Stream(exiIn, &stream1);
+
+	/* --> Start of EVSE side */
+	/* deserialize request message */
+	if (errn == 0) {
+		errn = deserialize1Stream2EXI(&stream1, exiOut);
+	}
+	/* create response message */
+	if (errn == 0) {
+		errn = create_response_message1(exiOut, exiIn);
+	}
+	/* serialize response message */
+	if (errn == 0) {
+		errn = serialize1EXI2Stream(exiIn, &stream2);
+	}
+	/* <-- End of EVSE side */
+
+
+	/* EV side */
+	/* deserialize response message */
+	if (errn == 0) {
+		errn = deserialize1Stream2EXI(&stream2, exiOut);
+	}
+
+	return errn;
+}
+
+static int charging1()
+{
+	int errn = 0;
+	int i, j;
+
+	struct iso1EXIDocument exiIn;
+	struct iso1EXIDocument exiOut;
+
+	struct iso1ServiceDetailResType serviceDetailRes;
+	struct iso1PaymentDetailsResType paymentDetailsRes;
+
+	/* setup header information */
+	init_iso1EXIDocument(&exiIn);
+	exiIn.V2G_Message_isUsed = 1u;
+	init_iso1MessageHeaderType(&exiIn.V2G_Message.Header);
+	exiIn.V2G_Message.Header.SessionID.bytes[0] = 0; /* sessionID is always '0' at the beginning (the response contains the valid sessionID)*/
+	exiIn.V2G_Message.Header.SessionID.bytes[1] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytes[2] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytes[3] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytes[4] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytes[5] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytes[6] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytes[7] = 0;
+	exiIn.V2G_Message.Header.SessionID.bytesLen = 8;
+	exiIn.V2G_Message.Header.Signature_isUsed = 0u;
+
+
+	/************************
+	 * sessionSetup *
+	 ************************/
+	init_iso1BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.SessionSetupReq_isUsed = 1u;
+
+	init_iso1SessionSetupReqType(&exiIn.V2G_Message.Body.SessionSetupReq);
+
+	exiIn.V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen = 1;
+	exiIn.V2G_Message.Body.SessionSetupReq.EVCCID.bytes[0] = 10;
+
+	printf("EV side: call EVSE sessionSetup");
+
+	errn = request_response1(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.SessionSetupRes_isUsed) {
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\tResponseCode=%d\n", exiOut.V2G_Message.Body.SessionSetupRes.ResponseCode);
+			printf("\tEVSEID=%d\n",	exiOut.V2G_Message.Body.SessionSetupRes.EVSEID.characters[1]);
+			printf("\tEVSETimeStamp=%li\n", (long int)exiOut.V2G_Message.Body.SessionSetupRes.EVSETimeStamp);
+		} else {
+			errn = ERROR_UNEXPECTED_SESSION_SETUP_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+	/*********************************
+	 * ServiceDetails *
+	 *********************************/
+	init_iso1BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.ServiceDetailReq_isUsed = 1u;
+
+	init_iso1ServiceDetailReqType(&exiIn.V2G_Message.Body.ServiceDetailReq);
+
+	exiIn.V2G_Message.Body.ServiceDetailReq.ServiceID = 22; /* Value Added Server ID */
+
+	printf("EV side: call EVSE ServiceDetail \n");
+
+	errn = request_response1(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.ServiceDetailRes_isUsed) {
+			serviceDetailRes = exiOut.V2G_Message.Body.ServiceDetailRes;
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n",  exiOut.V2G_Message.Body.ServiceDiscoveryRes.ResponseCode);
+			printf("\t ServiceID=%d\n",	exiOut.V2G_Message.Body.ServiceDetailRes.ServiceID);
+
+			if(serviceDetailRes.ServiceParameterList_isUsed) {
+				printf("\t\tLength=%d\n", serviceDetailRes.ServiceParameterList.ParameterSet.arrayLen );/*TEST*/
+
+				for(i=0; i<serviceDetailRes.ServiceParameterList.ParameterSet.arrayLen; i++)
+				{
+					printf("\t\tServiceSetID=%d\n", serviceDetailRes.ServiceParameterList.ParameterSet.array[i].ParameterSetID);
+					printf("\t\tParameters=%d\n", serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.arrayLen);
+
+					for(j=0; j<serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.arrayLen; j++)
+					{
+						printf("\t\t\t %d: ParameterName=", j+1);
+						printASCIIString(serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].Name.characters, exiOut.V2G_Message.Body.ServiceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].Name.charactersLen);
+
+						/*if(serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].shortValue_isUsed == 1u) {
+							printf("\t\t\t %d: StringValue=", j+1);
+							printASCIIString(serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].stringValue.characters, serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].stringValue.charactersLen);
+						} else if(serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].intValue_isUsed == 1u) {
+							printf("\t\t\t %d: IntValue=%d\n", j+1, serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].intValue);
+						} else if(serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].physicalValue_isUsed == 1u) {
+							printf("\t\t\t %d: PhysicalValue=%d (%d)\n",  j+1, serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].physicalValue.Value, serviceDetailRes.ServiceParameterList.ParameterSet.array[i].Parameter.array[j].physicalValue.Multiplier);
+						}*/
+					}
+				}
+			}
+		} else {
+			errn = ERROR_UNEXPECTED_SERVICE_DETAILS_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+
+	/*******************************************
+	 * Authorization *
+	 *******************************************/
+	init_iso1BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.AuthorizationReq_isUsed = 1u;
+
+	init_iso1AuthorizationReqType(&exiIn.V2G_Message.Body.AuthorizationReq);
+
+	copyBytes(paymentDetailsRes.GenChallenge.bytes, paymentDetailsRes.GenChallenge.bytesLen, exiIn.V2G_Message.Body.AuthorizationReq.GenChallenge.bytes);
+	exiIn.V2G_Message.Body.AuthorizationReq.GenChallenge.bytesLen = paymentDetailsRes.GenChallenge.bytesLen;
+	exiIn.V2G_Message.Body.AuthorizationReq.GenChallenge_isUsed = 1u; /* no challenge needed here*/
+	exiIn.V2G_Message.Body.AuthorizationReq.Id_isUsed = 1u; /* no signature needed here */
+	exiIn.V2G_Message.Body.AuthorizationReq.Id.charactersLen = 3;
+	exiIn.V2G_Message.Body.AuthorizationReq.Id.characters[0] = 'I';
+	exiIn.V2G_Message.Body.AuthorizationReq.Id.characters[1] = 'd';
+	exiIn.V2G_Message.Body.AuthorizationReq.Id.characters[2] = '2';
+
+	printf("EV side: call EVSE Authorization \n");
+
+
+	errn = request_response1(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.AuthorizationRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n",  exiOut.V2G_Message.Body.AuthorizationRes.ResponseCode);
+
+			if(exiOut.V2G_Message.Body.AuthorizationRes.EVSEProcessing == iso1EVSEProcessingType_Finished) {
+				printf("\t EVSEProcessing=Finished\n");
+			}
+		} else {
+			errn = ERROR_UNEXPECTED_AUTHORIZATION_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+
+
+	/*****************************
+	 * cableCheck *
+	 *****************************/
+	init_iso1BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.CableCheckReq_isUsed = 1u;
+
+	/*init_v2gCableCheckReqType(&exiIn.V2G_Message.Body.CableCheckReq);*/
+
+	printf("EV side: call EVSE cableCheck \n");
+
+	errn = request_response1(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.CableCheckRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n", exiOut.V2G_Message.Body.CableCheckRes.ResponseCode);
+
+			if(exiOut.V2G_Message.Body.CableCheckRes.EVSEProcessing==iso1EVSEProcessingType_Finished) {
+				printf("\tEVSEProcessing=Finished\n");
+			}
+
+			printEVSEStatus1(&(exiOut.V2G_Message.Body.CableCheckRes.DC_EVSEStatus));
+		} else {
+			errn = ERROR_UNEXPECTED_CABLE_CHECK_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+	/*****************************
+	 * preCharge *
+	 *****************************/
+	init_iso1BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.PreChargeReq_isUsed = 1u;
+
+	init_iso1PreChargeReqType(&exiIn.V2G_Message.Body.PreChargeReq);
+
+	exiIn.V2G_Message.Body.PreChargeReq.EVTargetCurrent.Multiplier = 1;
+	exiIn.V2G_Message.Body.PreChargeReq.EVTargetCurrent.Value = 234;
+
+	exiIn.V2G_Message.Body.PreChargeReq.EVTargetVoltage.Multiplier = 1;
+	exiIn.V2G_Message.Body.PreChargeReq.EVTargetVoltage.Value = 100;
+
+	printf("EV side: call EVSE preCharge \n");
+
+	errn = request_response1(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.PreChargeRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n", exiOut.V2G_Message.Body.PreChargeRes.ResponseCode);
+
+			printEVSEStatus1(&exiOut.V2G_Message.Body.PreChargeRes.DC_EVSEStatus);
+			printf("\tEVSEPresentVoltage=%d (%d %d)\n", exiOut.V2G_Message.Body.PreChargeRes.EVSEPresentVoltage.Value, exiOut.V2G_Message.Body.PreChargeRes.EVSEPresentVoltage.Value, exiOut.V2G_Message.Body.PreChargeRes.EVSEPresentVoltage.Multiplier);
+
+		} else {
+			errn = ERROR_UNEXPECTED_PRE_CHARGE_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+	/*********************************
+	 * PowerDelivery *
+	 *********************************/
+
+	init_iso1BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.PowerDeliveryReq_isUsed = 1u;
+
+	init_iso1PowerDeliveryReqType(&exiIn.V2G_Message.Body.PowerDeliveryReq);
+
+	exiIn.V2G_Message.Body.PowerDeliveryReq.ChargeProgress = iso1chargeProgressType_Start;
+	exiIn.V2G_Message.Body.PowerDeliveryReq.SAScheduleTupleID = exiOut.V2G_Message.Body.ChargeParameterDiscoveryRes.SAScheduleList.SAScheduleTuple.array[0].SAScheduleTupleID;
+
+	printf("EV side: call EVSE powerDelivery \n");
+
+	errn = request_response1(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.PowerDeliveryRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n", exiOut.V2G_Message.Body.PowerDeliveryRes.ResponseCode);
+
+			/*printACEVSEStatus(&(exiOut.V2G_Message.Body.PowerDeliveryRes.AC_EVSEStatus));*/
+		} else {
+			errn = ERROR_UNEXPECTED_POWER_DELIVERY_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+	/*********************************
+	 * Setup data for chargingStatus *
+	 *********************************/
+
+	init_iso1BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.ChargingStatusReq_isUsed = 1u;
+
+	init_iso1ChargingStatusReqType(&exiIn.V2G_Message.Body.ChargingStatusReq);
+
+	printf("EV side: call EVSE chargingStatus \n");
+
+	errn = request_response1(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.ChargingStatusRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n", exiOut.V2G_Message.Body.ChargingStatusRes.ResponseCode);
+
+			/*printACEVSEStatus(&(exiOut.V2G_Message.Body.ChargingStatusRes.AC_EVSEStatus));
+
+			printf("\tReceiptRequired=%d\n", exiOut.V2G_Message.Body.ChargingStatusRes.ReceiptRequired);
+			printf("\tEVSEID=%d\n", exiOut.V2G_Message.Body.ChargingStatusRes.EVSEID.characters[0]);
+			printf("\tSAScheduleTupleID=%d\n", exiOut.V2G_Message.Body.ChargingStatusRes.SAScheduleTupleID);
+			printf("\tEVSEMaxCurrent=%d (%d %d)\n", exiOut.V2G_Message.Body.ChargingStatusRes.EVSEMaxCurrent.Value, exiOut.V2G_Message.Body.ChargingStatusRes.EVSEMaxCurrent.Unit, exiOut.V2G_Message.Body.ChargingStatusRes.EVSEMaxCurrent.Multiplier);
+			printf("\tisused.MeterInfo=%d\n",		exiOut.V2G_Message.Body.ChargingStatusRes.MeterInfo_isUsed);
+			printf("\t\tMeterInfo.MeterID=%d\n",		exiOut.V2G_Message.Body.ChargingStatusRes.MeterInfo.MeterID.characters[0]);
+			printf("\t\tMeterInfo.MeterReading.Value=%li\n",		(long int)exiOut.V2G_Message.Body.ChargingStatusRes.MeterInfo.MeterReading);
+			printf("\t\tMeterInfo.MeterStatus=%d\n",		exiOut.V2G_Message.Body.ChargingStatusRes.MeterInfo.MeterStatus);
+			printf("\t\tMeterInfo.TMeter=%li\n",		(long int)exiOut.V2G_Message.Body.ChargingStatusRes.MeterInfo.TMeter);
+			printf("\t\tMeterInfo.SigMeterReading.data=%d\n",		exiOut.V2G_Message.Body.ChargingStatusRes.MeterInfo.SigMeterReading.bytes[0]);*/
+		} else {
+			errn = ERROR_UNEXPECTED_CHARGING_STATUS_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+	/***********************************
+	 * SessionStop *
+	 ***********************************/
+
+
+	init_iso1BodyType(&exiIn.V2G_Message.Body);
+	exiIn.V2G_Message.Body.SessionStopReq_isUsed = 1u;
+
+	init_iso1SessionStopReqType(&exiIn.V2G_Message.Body.SessionStopReq);
+	exiIn.V2G_Message.Body.SessionStopReq.ChargingSession = iso1chargingSessionType_Pause;
+
+	printf("EV side: call EVSE stopSession \n");
+
+	errn = request_response1(&exiIn, &exiOut);
+
+	if(errn == 0) {
+		/* check, if this is the right response message */
+		if(exiOut.V2G_Message.Body.SessionStopRes_isUsed) {
+
+			/* show results of EVSEs answer message */
+			printf("EV side: received response message from EVSE\n");
+			printf("\tHeader SessionID=");
+			printBinaryArray(exiOut.V2G_Message.Header.SessionID.bytes, exiOut.V2G_Message.Header.SessionID.bytesLen);
+			printf("\t ResponseCode=%d\n", exiOut.V2G_Message.Body.SessionStopRes.ResponseCode);
+
+		} else {
+			errn = ERROR_UNEXPECTED_SESSION_STOP_RESP_MESSAGE;
+			return errn;
+		}
+	} else {
+		return errn;
+	}
+
+
+
+	return errn;
+
+}
+#endif /* DEPLOY_ISO1_CODEC == SUPPORT_YES */
+
+
+/*===========================================================================
+FUNCTION: din_test_decode_SessionSetupReq
+DESCRIPTION:
+	The original V2GTP EXI stream is as below.
+		SIZE: 			20 (Bytes, DEC)
+		TOTAL: 			01fe80010000000c809a004011d0111d5d155800
+		HEADER (HEX): 	01FE80010000000C
+		EXI (HEX): 		809A004011D0111D5D155800
+
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int din_test_decode_SessionSetupReq()
+{
+	int errn = 0;
+	struct dinEXIDocument exiDin;
+	bitstream_t stream;
+	uint8_t buffer[] = {0x80, 0x9A, 0x00, 0x40, 0x11, 0xD0, 0x11, 0x1D, 0x5D, 0x15, 0x58, 0x00};
+	size_t pos = 0;
+	stream.size = BUFFER_SIZE;
+	stream.data = buffer;
+	stream.pos = &pos;
+
+	errn = decode_dinExiDocument(&stream, &exiDin);
+
+	if(errn != 0)
+	{
+		printf("\n\n[SessionSetupReq] DIN test error %d!\n", errn);
+		return errn;
+	}
+	else if (pos != 0x0C)	//[CAUTION] length
+	{
+		printf("\n\n[SessionSetupReq] DIN warning. not all bytes read! (pos = %ld)\n", pos);
+		errn = -1;
+		return errn;
+	}
+	else
+	{
+		unsigned int tmp = 0;
+		tmp = exiDin.V2G_Message.Body.SessionSetupReq_isUsed;
+		if (tmp == 1u)
+		{
+			printf("\n ---------- [din_test_decode_SessionSetupReq] ----------\n \
+				\t - SessionSetupReq is decoded OK!\n\
+				\t - SessionSetupReq_isUsed = %d\
+				\n", tmp);
+		}
+		else
+		{
+			printf("[ERROR][din_test_decode_SessionSetupReq] SessionSetupReq_isUsed = %d\n", tmp);
+		}
+
+	}
+	return errn;
+}
+
+
+/*===========================================================================
+FUNCTION: din_test_ServiceDiscoveryReq
+DESCRIPTION:
+	The original V2GTP EXI stream is as below.
+		SIZE: 			15 (Bytes, DEC)
+		TOTAL:			01fe800100000007809a0040119400
+		HEADER (HEX): 	01FE800100000007
+		EXI (HEX): 		809A0040119400
+
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int din_test_decode_ServiceDiscoveryReq()
+{
+	int errn = 0;
+	struct dinEXIDocument exiDin;
+	bitstream_t stream;
+	uint8_t buffer[] = {0x80, 0x9A, 0x00, 0x40, 0x11, 0x94, 0x00};
+	size_t pos = 0;
+	stream.size = BUFFER_SIZE;
+	stream.data = buffer;
+	stream.pos = &pos;
+
+	errn = decode_dinExiDocument(&stream, &exiDin);
+
+	if(errn != 0)
+	{
+		printf("\n\n[ServiceDiscoveryReq] DIN test error %d!\n", errn);
+		return errn;
+	}
+	else if (pos != 0x07) //[CAUTION] length
+	{
+		printf("\n\n[ServiceDiscoveryReq] DIN warning. not all bytes read! (pos = %ld)\n", pos);
+		errn = -1;
+		return errn;
+	}
+	else
+	{
+		unsigned int tmp = 0;
+		tmp = exiDin.V2G_Message.Body.ServiceDiscoveryReq_isUsed;
+		if (tmp == 1u)
+		{
+			printf("\n ---------- [din_test_decode_ServiceDiscoveryReq] ----------\n\
+			\t - ServiceDiscoveryReq is decoded OK!\n\
+			\t - ServiceDiscoveryReq_isUsed = %d\n", tmp);
+			PRINT_XML_DOC_DIN_ServiceDiscoveryReq(&exiDin);
+		}
+		else
+		{
+			printf("[ERROR][din_test_decode_ServiceDiscoveryReq] ServiceDiscoveryReq_isUsed = %d\n", tmp);
+		}
+
+	}
+
+	return errn;
+}
+
+#if DEPLOY_DIN_CODEC == SUPPORT_YES
+static int din_test()
+{
+	int errn = 0;
+
+	struct dinEXIDocument exiDin1;
+	struct dinEXIDocument exiDin2;
+
+	bitstream_t stream1;
+	bitstream_t stream2;
+
+	size_t pos1 = 0;
+	size_t pos2 = 0;
+
+	stream1.size = BUFFER_SIZE;
+	stream1.data = buffer1;
+	stream1.pos = &pos1;
+
+	stream2.size = BUFFER_SIZE;
+	stream2.data = buffer2;
+	stream2.pos = &pos2;
+
+	errn = din_test_decode_SessionSetupReq();		//added by Joseph
+	errn = din_test_decode_ServiceDiscoveryReq();	//added by Joseph
+
+	/* SetupSessionReq  */
+	/* BMW: 80 9A 00 11 D0 20 00 03 C1 FC 30 00 43 F8 00 */
+	buffer1[0] = 0x80;
+	buffer1[1] = 0x9A;
+	buffer1[2] = 0x00;
+	buffer1[3] = 0x11;
+	buffer1[4] = 0xD0;
+	buffer1[5] = 0x20;
+	buffer1[6] = 0x00;
+	buffer1[7] = 0x03;
+	buffer1[8] = 0xC1;
+	buffer1[9] = 0xFC;
+	buffer1[10] = 0x30;
+	buffer1[11] = 0x00;
+	buffer1[12] = 0x43;
+	buffer1[13] = 0xF8;
+	buffer1[14] = 0x00;
+
+	errn =  decode_dinExiDocument(&stream1, &exiDin1);
+
+	printf("\n\tSessionSetupReq_isUsed = %d\n", exiDin1.V2G_Message.Body.SessionSetupReq_isUsed);
+	printf("\t\tEVCCID Length= %d\n", exiDin1.V2G_Message.Body.SessionSetupReq.EVCCID.bytesLen);
+	printf("\t\tEVCCID = %02X%02X%02X%02X%02X%02X%02X%02X\n",
+			exiDin1.V2G_Message.Body.SessionSetupReq.EVCCID.bytes[0],
+			exiDin1.V2G_Message.Body.SessionSetupReq.EVCCID.bytes[1],
+			exiDin1.V2G_Message.Body.SessionSetupReq.EVCCID.bytes[2],
+			exiDin1.V2G_Message.Body.SessionSetupReq.EVCCID.bytes[3],
+			exiDin1.V2G_Message.Body.SessionSetupReq.EVCCID.bytes[4],
+			exiDin1.V2G_Message.Body.SessionSetupReq.EVCCID.bytes[5],
+			exiDin1.V2G_Message.Body.SessionSetupReq.EVCCID.bytes[6],
+			exiDin1.V2G_Message.Body.SessionSetupReq.EVCCID.bytes[7]
+		);
+
+
+	if(errn != 0)
+	{
+		printf("\n\nDIN test error %d!\n", errn);
+		return errn;
+	}
+	else if (pos1 != 15)
+	{
+		printf("\n\nDIN warning. not all bytes read!\n");
+		errn = -1;
+		return errn;
+	}
+
+
+	/* SetupSessionReq  */
+	/* Chevy: 80 9A 02 00 00 00 00 00 00 00 00 11 D0 18 00 60 8C 44 09 94 00 */
+	buffer2[0] = 0x80;
+	buffer2[1] = 0x9A;
+	buffer2[2] = 0x02;
+	buffer2[3] = 0x00;
+	buffer2[4] = 0x00;
+	buffer2[5] = 0x00;
+	buffer2[6] = 0x00;
+	buffer2[7] = 0x00;
+	buffer2[8] = 0x00;
+	buffer2[9] = 0x00;
+	buffer2[10] = 0x00;
+	buffer2[11] = 0x11;
+	buffer2[12] = 0xD0;
+	buffer2[13] = 0x18;
+	buffer2[14] = 0x00;
+	buffer2[15] = 0x60;
+	buffer2[16] = 0x8C;
+	buffer2[17] = 0x44;
+	buffer2[18] = 0x09;
+	buffer2[19] = 0x94;
+	buffer2[20] = 0x00;
+
+	errn =  decode_dinExiDocument(&stream2, &exiDin2);
+
+	if(errn != 0) {
+		printf("\n\nDIN test error %d!\n", errn);
+		return errn;
+	} else if (pos2 != 21) {
+		printf("\n\nDIN warning. not all bytes read!\n");
+		errn = -1;
+		return errn;
+	}
+
+
+	/* sessionStopReq  */
+	pos2 = 0; /* reset position */
+
+	/* V: 0x80, 0x9a, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x91, 0xf0  */
+	buffer2[0] = 0x80;
+	buffer2[1] = 0x9a;
+	buffer2[2] = 0x02;
+	buffer2[3] = 0x00;
+	buffer2[4] = 0x00;
+	buffer2[5] = 0x00;
+	buffer2[6] = 0x00;
+	buffer2[7] = 0x00;
+	buffer2[8] = 0x00;
+	buffer2[9] = 0x00;
+	buffer2[10] = 0x03;
+	buffer2[11] = 0x91;
+	buffer2[12] = 0xf0;
+
+	errn =  decode_dinExiDocument(&stream2, &exiDin2);
+
+	if(errn != 0) {
+		printf("\n\nDIN test error %d!\n", errn);
+		return errn;
+	} else if (pos2 != 13) {
+		printf("\n\nDIN warning. not all bytes read!\n");
+		errn = -1;
+		return errn;
+	} else if(exiDin2.V2G_Message_isUsed == 0 || exiDin2.V2G_Message.Body.SessionStopReq_isUsed == 0) {
+		printf("\n\nDIN warning. no sessionStopReq message!\n");
+		errn = -1;
+		return errn;
+	}
+
+
+	if(errn == 0) {
+		printf("DIN test passed\n");
+	} else {
+		printf("DIN test error %d!\n", errn);
+	}
+
+	return errn;
+}
+#endif /* DEPLOY_DIN_CODEC == SUPPORT_YES */
+
+
+
+#if DEPLOY_XMLDSIG_CODEC == SUPPORT_YES
+#if DEPLOY_ISO_CODEC_FRAGMENT == SUPPORT_YES
+static int xmldsig_test() {
+	int errn = 0, i;
+
+	bitstream_t stream1;
+	size_t pos1 = 0;
+	stream1.size = BUFFER_SIZE;
+	stream1.data = buffer1;
+	stream1.pos = &pos1;
+
+	bitstream_t stream2;
+	size_t pos2 = 0;
+	stream2.size = BUFFER_SIZE;
+	stream2.data = buffer2;
+	stream2.pos = &pos2;
+
+	struct iso2EXIFragment exiV2G_AR;
+	struct xmldsigEXIFragment exiXMLDSIG_SI;
+
+	int sizeIsoStream1 = 25;
+	int isoStream1[] = {0x80, 0x04, 0x01, 0x52, 0x51, 0x0C, 0x40, 0x82, 0x9B, 0x7B, 0x6B, 0x29, 0x02, 0x93, 0x0B, 0x73, 0x23, 0x7B, 0x69, 0x02, 0x23, 0x0B, 0xA3, 0x09, 0xE8};
+
+	int sizeIsoStream2 = 209;
+	int isoStream2[] = {0x80, 0x81, 0x12, 0xB4, 0x3A, 0x3A, 0x38, 0x1D, 0x17, 0x97, 0xBB, 0xBB, 0xBB, 0x97, 0x3B, 0x99, 0x97, 0x37, 0xB9, 0x33, 0x97, 0xAA, 0x29, 0x17, 0xB1, 0xB0, 0xB7, 0x37, 0xB7, 0x34, 0xB1, 0xB0, 0xB6, 0x16, 0xB2, 0xBC, 0x34, 0x97, 0xA1, 0xAB, 0x43, 0xA3, 0xA3, 0x81, 0xD1, 0x79, 0x7B, 0xBB, 0xBB, 0xB9, 0x73, 0xB9, 0x99, 0x73, 0x7B, 0x93, 0x39, 0x79, 0x91, 0x81, 0x81, 0x89, 0x79, 0x81, 0xA1, 0x7B, 0xC3, 0x6B, 0x63, 0x23, 0x9B, 0x4B, 0x39, 0x6B, 0x6B, 0x7B, 0x93, 0x29, 0x1B, 0x2B, 0x1B, 0x23, 0x9B, 0x09, 0x6B, 0x9B, 0x43, 0x09, 0x91, 0xA9, 0xB2, 0x20, 0x62, 0x34, 0x94, 0x43, 0x10, 0x25, 0x68, 0x74, 0x74, 0x70, 0x3A, 0x2F, 0x2F, 0x77, 0x77, 0x77, 0x2E, 0x77, 0x33, 0x2E, 0x6F, 0x72, 0x67, 0x2F, 0x54, 0x52, 0x2F, 0x63, 0x61, 0x6E, 0x6F, 0x6E, 0x69, 0x63, 0x61, 0x6C, 0x2D, 0x65, 0x78, 0x69, 0x2F, 0x48, 0x52, 0xD0, 0xE8, 0xE8, 0xE0, 0x74, 0x5E, 0x5E, 0xEE, 0xEE, 0xEE, 0x5C, 0xEE, 0x66, 0x5C, 0xDE, 0xE4, 0xCE, 0x5E, 0x64, 0x60, 0x60, 0x62, 0x5E, 0x60, 0x68, 0x5E, 0xF0, 0xDA, 0xD8, 0xCA, 0xDC, 0xC6, 0x46, 0xE6, 0xD0, 0xC2, 0x64, 0x6A, 0x6C, 0x84, 0x1A, 0x36, 0xBC, 0x07, 0xA0, 0x0C, 0xB7, 0xDC, 0xAD, 0x66, 0x2F, 0x30, 0x88, 0xA6, 0x0A, 0x3D, 0x6A, 0x99, 0x43, 0x1F, 0x81, 0xC1, 0x22, 0xC2, 0xE9, 0xF1, 0x67, 0x8E, 0xF5, 0x31, 0xE9, 0x55, 0x23, 0x70};
+
+
+	uint8_t digestValue[] = {0xD1, 0xB5, 0xE0, 0x3D, 0x00, 0x65, 0xBE, 0xE5, 0x6B, 0x31, 0x79, 0x84, 0x45, 0x30, 0x51, 0xEB, 0x54, 0xCA, 0x18, 0xFC, 0x0E, 0x09, 0x16, 0x17, 0x4F, 0x8B, 0x3C, 0x77, 0xA9, 0x8F, 0x4A, 0xA9}; /* 32 Bytes */
+
+
+	/*
+	<v2gci_b:AuthorizationReq xmlns:v2gci_b="urn:iso:15118:2:2013:MsgBody" v2gci_b:Id="ID1">
+	    <v2gci_b:GenChallenge>U29tZSBSYW5kb20gRGF0YQ==</v2gci_b:GenChallenge>
+	</v2gci_b:AuthorizationReq>
+	*/
+
+	init_iso2EXIFragment(&exiV2G_AR);
+	exiV2G_AR.AuthorizationReq_isUsed = 1u;
+	init_iso2AuthorizationReqType(&exiV2G_AR.AuthorizationReq);
+	exiV2G_AR.AuthorizationReq.Id_isUsed = 1;
+	exiV2G_AR.AuthorizationReq.Id.charactersLen = 3;
+	exiV2G_AR.AuthorizationReq.Id.characters[0] = 'I';
+	exiV2G_AR.AuthorizationReq.Id.characters[1] = 'D';
+	exiV2G_AR.AuthorizationReq.Id.characters[2] = '1';
+	exiV2G_AR.AuthorizationReq.GenChallenge_isUsed = 1;
+	/* base64 U29tZSBSYW5kb20gRGF0YQ== */
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytesLen = 16;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[0] = 0x53;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[1] = 0x6F;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[2] = 0x6D;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[3] = 0x65;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[4] = 0x20;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[5] = 0x52;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[6] = 0x61;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[7] = 0x6E;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[8] = 0x64;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[9] = 0x6F;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[10] = 0x6D;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[11] = 0x20;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[12] = 0x44;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[13] = 0x61;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[14] = 0x74;
+	exiV2G_AR.AuthorizationReq.GenChallenge.bytes[15] = 0x61;
+
+	/* encode fragment with ISO schema */
+	errn = encode_iso2ExiFragment(&stream1, &exiV2G_AR);
+
+	if((*stream1.pos) != sizeIsoStream1) {
+		errn = -1;
+		printf("EXI1 stream length does not match !\n");
+		return errn;
+	} else {
+		for(i=0; i<sizeIsoStream1; i++) {
+			if(stream1.data[i] != isoStream1[i]) {
+				errn = -1;
+				printf("EXI1 stream does not match at position %d !\n", i);
+				return errn;
+			}
+		}
+	}
+
+	/* TODO Create Hash for stream 1 etc ... */
+	/* SHA-256 is "0bXgPQBlvuVrMXmERTBR61TKGPwOCRYXT4s8d6mPSqk=" */
+
+	/*
+	<xmlsig:SignedInfo xmlns:xmlsig="http://www.w3.org/2000/09/xmldsig#" >
+	    <xmlsig:CanonicalizationMethod Algorithm="http://www.w3.org/TR/canonical-exi/"/>
+	    <xmlsig:SignatureMethod
+	        Algorithm="http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256"/>
+	    <xmlsig:Reference URI="#ID1">
+	        <xmlsig:Transforms>
+	            <xmlsig:Transform Algorithm="http://www.w3.org/TR/canonical-exi/"/>
+	        </xmlsig:Transforms>
+	        <xmlsig:DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/>
+	        <xmlsig:DigestValue>0bXgPQBlvuVrMXmERTBR61TK
+	            GPwOCRYXT4s8d6mPSqk=</xmlsig:DigestValue>
+	    </xmlsig:Reference>
+	</xmlsig:SignedInfo>
+	*/
+
+	/* encode SignedInfo element with xmldsig schema */
+
+	const char arrayCanonicalEXI[35] = {"http://www.w3.org/TR/canonical-exi/"};
+	const char arrayxmldsigSHA256[51] = {"http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256"};
+	const char arrayxmlencSHA256[39] = {"http://www.w3.org/2001/04/xmlenc#sha256"};
+
+	init_xmldsigEXIFragment(&exiXMLDSIG_SI);
+	exiXMLDSIG_SI.SignedInfo_isUsed = 1;
+	init_xmldsigSignedInfoType(&exiXMLDSIG_SI.SignedInfo);
+	{
+		init_xmldsigCanonicalizationMethodType(&exiXMLDSIG_SI.SignedInfo.CanonicalizationMethod);
+		exiXMLDSIG_SI.SignedInfo.CanonicalizationMethod.Algorithm.charactersLen = 35;
+		strncpy(exiXMLDSIG_SI.SignedInfo.CanonicalizationMethod.Algorithm.characters, arrayCanonicalEXI, 35);
+
+		exiXMLDSIG_SI.SignedInfo.SignatureMethod.HMACOutputLength_isUsed = 0;
+		exiXMLDSIG_SI.SignedInfo.SignatureMethod.Algorithm.charactersLen = 51;
+		strncpy(exiXMLDSIG_SI.SignedInfo.SignatureMethod.Algorithm.characters, arrayxmldsigSHA256, 51);
+
+		exiXMLDSIG_SI.SignedInfo.Reference.arrayLen = 1;
+		 /* "#ID1" */
+		exiXMLDSIG_SI.SignedInfo.Reference.array[0].URI_isUsed = 1;
+		exiXMLDSIG_SI.SignedInfo.Reference.array[0].URI.charactersLen = 4;
+		exiXMLDSIG_SI.SignedInfo.Reference.array[0].URI.characters[0] = '#';
+		exiXMLDSIG_SI.SignedInfo.Reference.array[0].URI.characters[1] = 'I';
+		exiXMLDSIG_SI.SignedInfo.Reference.array[0].URI.characters[2] = 'D';
+		exiXMLDSIG_SI.SignedInfo.Reference.array[0].URI.characters[3] = '1';
+		/* "http://www.w3.org/TR/canonical-exi/" */
+		exiXMLDSIG_SI.SignedInfo.Reference.array[0].Transforms_isUsed = 1;
+		exiXMLDSIG_SI.SignedInfo.Reference.array[0].Transforms.Transform.arrayLen = 1;
+		exiXMLDSIG_SI.SignedInfo.Reference.array[0].Transforms.Transform.array[0].Algorithm.charactersLen = 35;
+		strncpy(exiXMLDSIG_SI.SignedInfo.Reference.array[0].Transforms.Transform.array[0].Algorithm.characters, arrayCanonicalEXI, 35); /* Will copy 35 characters from arrayCanonicalEXI to characters */
+		exiXMLDSIG_SI.SignedInfo.Reference.array[0].Transforms.Transform.array[0].XPath.arrayLen = 0;
+
+		exiXMLDSIG_SI.SignedInfo.Reference.array[0].DigestMethod.Algorithm.charactersLen = 39;
+		strncpy(exiXMLDSIG_SI.SignedInfo.Reference.array[0].DigestMethod.Algorithm.characters, arrayxmlencSHA256, 39);
+
+		/* "0bXgPQBlvuVrMXmERTBR61TKGPwOCRYXT4s8d6mPSqk=" --> 16 Bytes 536F6D652052616E646F6D2044617461 */
+		exiXMLDSIG_SI.SignedInfo.Reference.array[0].DigestValue.bytesLen = 32;
+		memcpy(exiXMLDSIG_SI.SignedInfo.Reference.array[0].DigestValue.bytes, digestValue, 32);
+	}
+
+	errn = encode_xmldsigExiFragment(&stream2, &exiXMLDSIG_SI);
+
+	if((*stream2.pos) != sizeIsoStream2) {
+		errn = -1;
+		printf("EXI2 stream length does not match !\n");
+		return errn;
+	} else {
+		for(i=0; i<sizeIsoStream2; i++) {
+			if(stream2.data[i] != isoStream2[i]) {
+				errn = -1;
+				printf("EXI2 stream does not match at position %d !\n", i);
+				return errn;
+			}
+		}
+	}
+
+
+	if(errn == 0) {
+		printf("XMLDSIG test passed\n");
+	} else {
+		printf("XMLDSIG test error %d!\n", errn);
+	}
+
+	return errn;
+}
+#endif /* DEPLOY_ISO_CODEC_FRAGMENT */
+#endif /* DEPLOY_XMLDSIG_CODEC == SUPPORT_YES */
+
+
+int main_example(int argc, char *argv[]) {
+	int errn = 0;
+
+	printf("+++ Start application handshake protocol example +++\n\n");
+	errn = appHandshake();
+	printf("+++ Terminate application handshake protocol example with errn = %d +++\n\n", errn);
+
+	if(errn != 0) {
+		printf("\n\nHandshake error %d!\n", errn);
+		return errn;
+	}
+
+
+#if DEPLOY_ISO1_CODEC == SUPPORT_YES
+	printf("+++ Start V2G client / service example for charging (ISO1) +++\n\n");
+	errn = charging1();
+	printf("\n+++Terminate V2G Client / Service example for charging with errn = %d +++\n\n", errn);
+	if(errn != 0) {
+		printf("\n\ncharging error %d!\n", errn);
+		return errn;
+	}
+#endif /* DEPLOY_ISO1_CODEC == SUPPORT_YES */
+
+
+#if DEPLOY_ISO2_CODEC == SUPPORT_YES
+	printf("+++ Start V2G client / service example for charging (ISO2) +++\n\n");
+	errn = charging2();
+	printf("\n+++Terminate V2G Client / Service example for charging with errn = %d +++\n\n", errn);
+	if(errn != 0) {
+		printf("\n\ncharging error %d!\n", errn);
+		return errn;
+	}
+#endif /* DEPLOY_ISO2_CODEC == SUPPORT_YES */
+
+
+#if DEPLOY_DIN_CODEC == SUPPORT_YES
+	printf("+++ Start simple DIN test +++\n");
+	errn = din_test();
+	printf("+++ Terminate simple DIN test with errn = %d +++\n\n", errn);
+	if(errn != 0) {
+		printf("\nDIN test error %d!\n", errn);
+		return errn;
+	}
+#endif /* DEPLOY_DIN_CODEC == SUPPORT_YES */
+
+#if DEPLOY_XMLDSIG_CODEC == SUPPORT_YES
+#if DEPLOY_ISO_CODEC_FRAGMENT == SUPPORT_YES
+	printf("+++ Start simple XMLDSIG test +++\n");
+	errn = xmldsig_test();
+	printf("+++ Terminate simple XMLDSIG test with errn = %d +++\n\n", errn);
+	if(errn != 0) {
+		printf("\nXMLDSIG test error %d!\n", errn);
+		return errn;
+	}
+#endif /* DEPLOY_ISO_CODEC_FRAGMENT */
+#endif /* DEPLOY_XMLDSIG_CODEC == SUPPORT_YES */
+
+
+	return errn;
+}

EVSE/Projects/AW-CCS/Apps/CCS/main.c

@@ -0,0 +1,1009 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                 main.c
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+#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 "define.h"
+#include "main.h"
+
+
+struct SysConfigAndInfo     *ShmSysConfigAndInfo;
+struct StatusCodeData       *ShmStatusCodeData;
+struct CcsData              *ShmCcsData;
+struct InternalComm         *ShmInternalComm;
+//struct InternalCommAC       *ShmInternalCommAC;
+
+unsigned char buf_log_main[SIZE_OF_LOG_BUFFER];
+
+#if SAVE_SYS_LOG_MSG_MAIN_SWITCH == ENABLE
+int StoreLogMsg(unsigned char *DataString);
+#endif
+
+void System_Init();
+void CreateShareMemory_Init();
+void GPIO_Init();
+void PWM_Init();
+void Confinguration_Init();
+double DiffTimeb(struct timeb ST, struct timeb ET);
+int CreateShareMemory();
+int LoadSysConfigAndInfo(struct SysConfigData *ptr);
+int SpawnTask();
+int StoreUsrConfigData(struct SysConfigData *UsrData);
+
+
+unsigned int isKernelSupportNAT()
+{
+	unsigned int result = 0;
+	unsigned int version = 0;
+	FILE *fp;
+	char cmd[256];
+	char buf[512];
+
+	// Get IP address & net mask
+	strcpy(cmd, "uname -v");
+	fp = popen(cmd, "r");
+	if(fp != NULL)
+	{
+		if(fgets(buf, sizeof(buf), fp) != NULL)
+		{
+			sscanf(buf, "#%d", &version);
+		//	DEBUG_INFO("Kernel version: %d\n", version);
+
+			if(version >= 30)
+				result = 1;
+		}
+	}
+	pclose(fp);
+
+	return result;
+}
+
+float ReadAdcVolt(unsigned char AdcChannel)
+{
+    //AIN0=CCS GUN Temp 1
+    //AIN1=CCS GUN Temp 2
+    //AIN2=CCS_Proximity/2
+    //AIN3=pilot voltage
+
+	if(AdcChannel == 3)
+	{
+		int fd,count,AvgTimes;
+		unsigned char SampleBuf[4];
+		float TmpVolt, MinSample, AvgSample = 0;
+
+		fd = open("/sys/bus/iio/devices/iio\:device0/in_voltage3_raw", O_RDONLY);
+	        if(fd > 0)
+	        {
+	            //system("echo 1 > /sys/class/gpio/gpio89/value");    //for test
+	            for(AvgTimes = 0; AvgTimes < 3; AvgTimes++) //period = 60~91 ms(renice -10, , CurrentDemand()) /*+++ 20200909, vern, extend detection time for interference ---*/
+	            {
+	                count = 0;
+	                MinSample = 2306;
+	                //system("echo 1 > /sys/class/gpio/gpio89/value");    //for test
+	                while(count < 40)  //period = 21~42ms  (renice -10, CurrentDemand())/*+++ 20200909, vern, extend detection time for interference ---*/
+	                {
+	                    //re-sampling period = 3~13ms (renice -10, SLAC())
+	                    //system("echo 1 > /sys/class/gpio/gpio89/value");    //for test
+	                    read(fd, SampleBuf, 4); //period = 3.2~10ms (renice -10, SLAC())
+	                    //system("echo 0 > /sys/class/gpio/gpio89/value");    //for test
+	                    TmpVolt = atoi(SampleBuf);
+	
+	                    if((TmpVolt < 2306) && (TmpVolt > 0))//positive voltage
+	                    {
+	                        if(TmpVolt < MinSample)
+	                        {
+	                            MinSample = TmpVolt;
+	                        }
+	                        count++;
+	                    }
+	                    lseek(fd, 0, SEEK_SET);
+	                }
+	                //system("echo 0 > /sys/class/gpio/gpio89/value");    //for test
+	                AvgSample += MinSample;
+	            }
+	            AvgSample /= AvgTimes;
+	            close(fd);
+	            //system("echo 0 > /sys/class/gpio/gpio89/value");    //for test
+	            return ((0.954-(1.8*AvgSample/4095))/0.06);
+	        }
+		else
+		{
+			return -1;
+		}
+	}
+	else
+	{
+		FILE *fp;
+		unsigned char str[64];
+		unsigned char AdcValue[8];
+
+		if(AdcChannel > 7)
+		{
+		    return -1;
+		}
+
+		memset(str,0,sizeof(str));
+		memset(AdcValue,0,sizeof(AdcValue));
+		sprintf(str, "cat /sys/bus/iio/devices/iio\\:device0/in_voltage%d_raw", AdcChannel);
+		fp=popen(str, "r");
+		if(fgets(AdcValue,sizeof(AdcValue),fp) == NULL)
+		{
+		    pclose(fp);
+		    return -1;
+		}
+		pclose(fp);
+		//Vin =  Vref *D / (2^n - 1)
+		//printf("ADC[%d]=%d\n",AdcChannel,atoi(AdcValue));
+		return ((float)1.8*(float)atoi(AdcValue))/4095;
+	}
+
+}
+
+/*===========================================================================
+FUNCTION: main
+DESCRIPTION:
+    1. This main routine will be executed by the "rcS"  when linux is booting up.
+       /opt/ti-processor-sdk-linux-am335x-evm-04.02.00.09/EVSE/rootfs/etc/init.d/rcS
+
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int main(int argc, char *argv[])
+{
+    #ifdef CONNECTOR_TEMP_DETECTION
+    float CcsConnectorTemp1;
+    int CcsConnectorTemp;
+    #endif
+    SAVE_SYS_LOG_MSG_MAIN("ccs: on");
+    SAVE_SYS_LOG_MSG_MAIN("---------------------------------------------");
+    SAVE_SYS_LOG_MSG_MAIN("--                   MAIN                  --");
+    SAVE_SYS_LOG_MSG_MAIN("---------------------------------------------\n");
+
+    //int Rtn = 0;
+    //unsigned int StartTime;
+    //struct timeb StartChargingTime, CurrentChargingTime, ChargingLoopTime;
+    //float ChargingPower, ChargingEnergy;
+
+    //CSU Initialization
+    System_Init();
+
+    //task spawn
+    SpawnTask();
+    sleep(2);
+    system("killall ntpd");
+
+    /**************************************************************/
+    /************** main Loop********************************/
+    /*****************************************************************/
+
+    while(1)
+    {
+        //Sleep to reduce CPU power comsumption
+        sleep(5);
+      	#ifdef CONNECTOR_TEMP_DETECTION
+        CcsConnectorTemp=0;
+  	for(unsigned char i=0;i<=1;i++)
+  	{
+	  	CcsConnectorTemp1 = ReadAdcVolt(i);
+	    	if((CcsConnectorTemp1<=0.9)&&(CcsConnectorTemp1>=0.8))//0 ~ -40
+	    		CcsConnectorTemp1=(CcsConnectorTemp1-0.9)*500;
+	    	else if((CcsConnectorTemp1<=1.07)&&(CcsConnectorTemp1>0.9))	
+	    		CcsConnectorTemp1=(CcsConnectorTemp1-0.9)*705.88;
+	    	else	
+	    		CcsConnectorTemp1=195;//not available
+	    	CcsConnectorTemp|=((unsigned int)(CcsConnectorTemp1+60)&0xFF)<<(i*8); //0x00(-60)~0xFE(194)
+	    	//printf("CcsConnectorTemp1[%d]=%f\n ",i,CcsConnectorTemp1);
+	}
+	ShmSysConfigAndInfo->SysInfo.CcsConnectorTemp=CcsConnectorTemp;
+	//printf("CcsConnectorTemp=0x%x\n ",CcsConnectorTemp);
+	#endif
+    }//main while
+
+}
+
+/*===========================================================================
+FUNCTION: Eth0_PortSetting
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int Eth0_PortSetting_Base(unsigned char addr)
+{
+    SAVE_SYS_LOG_MSG_MAIN("[Eth0_PortSetting]start");
+
+    unsigned char cmd[128];
+    if ((addr >= 20) && (addr <= (255-20-1)))   //preserved for dynamic IP and QCA7000
+    {
+        //Step 0: shutdown eth0
+        #if 0
+        SAVE_SYS_LOG_MSG_MAIN("[Eth0_PortSetting][eth0]down");
+        system("/sbin/ifconfig eth0 down");
+        sleep(1);
+        #endif
+
+        //Step 1: eth0 setting
+        sprintf(buf_log_main,
+                "[Eth0_PortSetting][eth0]IP >> 192.168.0.%d(up)",
+                addr);
+        SAVE_SYS_LOG_MSG_MAIN(buf_log_main);
+        sprintf(cmd, "/sbin/ifconfig eth0 192.168.0.%d netmask 255.255.255.0 up", addr);
+        system(cmd);
+        memset(cmd, 0, sizeof(cmd));
+        sleep(1);
+
+        //Step 2: add route
+        system("/sbin/route add default gw 192.168.0.1");
+
+        //Step 3: done
+        sprintf(buf_log_main,
+                "[Eth0_PortSetting]done");
+        SAVE_SYS_LOG_MSG_MAIN(buf_log_main);
+        return PASS;
+    }
+    else
+    {
+        sprintf(buf_log_main,
+                "[Eth0_PortSetting][Error]addr(%d) is out of range(20~234)",
+                addr);
+        SAVE_SYS_LOG_MSG_MAIN(buf_log_main);
+        return FAIL;
+    }
+}
+
+
+/*===========================================================================
+FUNCTION: System_Init
+DESCRIPTION:
+PRE-CONDITION:
+    1. Pin Assignment Configuration
+       board-support/linux-4.9.59+gitAUTOINC+a75d8e9305-ga75d8e9305/
+       arch/arm/boot/dts/[CCS]am335x-evm.dts
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void System_Init()
+{
+    //RTC Update
+    time_t rtc_new;
+    rtc_new = RTC_DEFAULT_TIME; //Epoch time
+    stime(&rtc_new);
+    system("date");
+    sprintf(buf_log_main, "[RTC]%d (DEC)\n", rtc_new);
+    SAVE_SYS_LOG_MSG_MAIN(buf_log_main);
+
+    //-----------------------------------
+    //Print Linux Kernel Version
+    sprintf(buf_log_main, "\nLinux Image SHA1: %s\n", LINUX_IMAGE_VERSION);
+    SAVE_SYS_LOG_MSG_MAIN(buf_log_main);
+
+    //Print Hardware Version
+    sprintf(buf_log_main, "HW: %s\n", HARDWARE_VERSION);
+    SAVE_SYS_LOG_MSG_MAIN(buf_log_main);
+
+    //Print Firmware Version
+    sprintf(buf_log_main, "FW: %s\n", FIRMWARE_VERSION);
+    SAVE_SYS_LOG_MSG_MAIN(buf_log_main);
+
+    #if (FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == ENABLE)
+    {
+        //Print Linux Kernel Version
+        printf("\nLinux Image SHA1: %s\n", LINUX_IMAGE_VERSION);
+
+        //Print Hardware Version
+        printf("HW: %s\n", HARDWARE_VERSION);
+
+        //Print Firmware Version
+        printf("FW: %s\n", FIRMWARE_VERSION);
+    }
+    #endif
+
+    //Init Eth0
+    Eth0_PortSetting_Base(ETH0_PORT_BASE); //192.168.0.20
+
+    // ---------- Hardware Init ---------
+    if(isKernelSupportNAT() == 1)
+		system("/sbin/insmod /lib/qcaspi_nat.ko");
+	else
+		system("/sbin/insmod /lib/qcaspi.ko");
+   // system("/sbin/insmod /lib/qcaspi.ko");
+    sleep(2);
+    system("/sbin/ifconfig eth1 192.168.0.11 netmask 255.255.255.0 up");
+    sleep(1);
+
+    printf("Starting SSH            : \n");
+    system("/sbin/dropbear &");
+
+    printf("Starting FTPD           : \n");
+    system("/usr/bin/tcpsvd -vE 0.0.0.0 21 ftpd -w -t 30 / &");
+
+    //printf("Starting LIGHTTPD       : \n");
+    //system("/sbin/lighttpd -f /etc/lighttpd/lighttpd.conf  -m /lib");
+
+    //Init GPIO
+    GPIO_Init();
+
+    //Init ecap0
+    PWM_Init();
+
+    // ---------- Software Init ----------
+    //Create all share memory
+    CreateShareMemory_Init();
+
+    //Init System Confinguration
+    Confinguration_Init();
+
+
+    SAVE_SYS_LOG_MSG_MAIN("--------------------------");
+    SAVE_SYS_LOG_MSG_MAIN("System_Init(): DONE");
+
+}
+
+/*===========================================================================
+FUNCTION: CreateShareMemory_Init
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void CreateShareMemory_Init()
+{
+    if(CreateShareMemory() == 0)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("CreateShareMemory_Init(): NG");
+
+        if(ShmStatusCodeData != NULL)
+        {
+            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.FailToCreateShareMemory = 1;
+        }
+
+        sleep(5);
+        system("reboot -f");
+        sleep(5);
+        system("reboot -f");
+    }
+    else
+    {
+        SAVE_SYS_LOG_MSG_MAIN("CreateShareMemory_Init(): DONE");
+    }
+}
+
+/**************************************************************************************/
+/**************************Create all share memory *********************************/
+/**************************************************************************************/
+
+/*===========================================================================
+FUNCTION: CreateShareMemory
+
+DESCRIPTION:
+    There are 4 share memory created here, which are listed as below.
+    1) ShmSysConfigAndInfo
+    2) ShmStatusCodeData
+    3) ShmCcsData
+    4) ShmInternalComm
+
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int CreateShareMemory()
+{
+    int MeterSMId;
+
+    //create ShmSysConfigAndInfo
+    if((MeterSMId = shmget(ShmSysConfigAndInfoKey, sizeof(struct SysConfigAndInfo), IPC_CREAT | 0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("CreateShareMemory:shmget ShmSysConfigAndInfo NG");
+        return 0;
+    }
+    else if((ShmSysConfigAndInfo = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("CreateShareMemory:shmat ShmSysConfigAndInfo NG");
+        return 0;
+    }
+
+    memset(ShmSysConfigAndInfo, 0, sizeof(struct SysConfigAndInfo));
+
+
+    //create ShmStatusCodeData
+    if((MeterSMId = shmget(ShmStatusCodeKey, sizeof(struct StatusCodeData), IPC_CREAT | 0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("CreateShareMemory:shmget ShmStatusCodeData NG");
+        return 0;
+    }
+    else if((ShmStatusCodeData = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("CreateShareMemory:shmat ShmStatusCodeData NG");
+        return 0;
+    }
+
+    memset(ShmStatusCodeData, 0, sizeof(struct StatusCodeData));
+
+
+    //create ShmCcsData
+    if((MeterSMId = shmget(ShmCcsCommKey, sizeof(struct CcsData), IPC_CREAT | 0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("CreateShareMemory:shmget ShmCcsData NG");
+        return 0;
+    }
+    else if((ShmCcsData = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("CreateShareMemory:shmat ShmCcsData NG");
+        return 0;
+    }
+
+    memset(ShmCcsData, 0, sizeof(struct CcsData));
+
+
+    //create ShmInternalComm
+    if((MeterSMId = shmget(ShmInternalCommKey, sizeof(struct InternalComm),   IPC_CREAT | 0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("CreateShareMemory:shmget ShmInternalComm NG");
+        return 0;
+    }
+    else if((ShmInternalComm = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("CreateShareMemory:shmat ShmInternalComm NG");
+        return 0;
+    }
+    memset(ShmInternalComm, 0, sizeof(struct InternalComm));
+
+    #if 0
+    //create ShmInternalCommAC
+    if((MeterSMId = shmget(ShmInternalCommACKey, sizeof(struct InternalCommAC),   IPC_CREAT | 0777)) < 0)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("CreateShareMemory:shmget ShmInternalCommAC NG");
+        return 0;
+    }
+    else if((ShmInternalCommAC = shmat(MeterSMId, NULL, 0)) == (void *)-1)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("CreateShareMemory:shmat ShmInternalCommAC NG");
+        return 0;
+    }
+    //[To-Do] The reset here should be removed, since AW-CCS CSU will reset it in its main.c.
+    memset(ShmInternalCommAC, 0, sizeof(struct InternalCommAC)); 
+	#endif
+
+    return 1;
+}
+
+
+/*===========================================================================
+FUNCTION: GPIO_Init
+DESCRIPTION:
+    1. GPIO (input) x 1
+        * gpio2_0(gpio64): QCA7000 interrupt
+        * gpio2_23 (gpio87): CCS Board ID detection
+
+    2. GPIO (output) x 4
+        * gpio2_25 (gpio89): reserved                       (default = 0)
+        * gpio2_24 (gpio88): power reset QCA7000            (default = 0)
+        * gpio2_22 (gpio86): Pilot Status E control (0V)    (default = 0)
+
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void GPIO_Init()
+{
+    /*****************0~3, 4 bank, bank x 32+ num*********************/
+    /*****************************************************************/
+    /*************** INPUT PIN ***************************************/
+    /*****************************************************************/
+    /*GPIO2_0: QCA7000 interrupt */
+    system("echo 64 > /sys/class/gpio/export");
+    system("echo \"in\" > /sys/class/gpio/gpio64/direction");
+
+    //IO port for CCS Board ID detection
+    /*GPIO2_23: AM_IO_1, H: ?; L: ?*/
+    system("echo 87 > /sys/class/gpio/export");
+    system("echo \"in\" > /sys/class/gpio/gpio87/direction");
+
+
+    /***************************************************************/
+    /*************** OUTPUT PIN ************************************/
+    /***************************************************************/
+    //IO port for Communication Board.(reserved for emergency shutdown PSU, i.e. PSKILL)
+    /*GPIO2_25: AM_IO_2, H: ?; L: ?*/
+    system("echo 89 > /sys/class/gpio/export");
+    system("echo \"out\" > /sys/class/gpio/gpio89/direction");
+    system("echo 0 > /sys/class/gpio/gpio89/value");
+
+
+    //Power Reset QCA7000
+    /*GPIO2_24: AM_QCA_PWR_RST, H: reset, L: noraml*/
+    system("echo 88 > /sys/class/gpio/export");
+    system("echo \"out\" > /sys/class/gpio/gpio88/direction");
+    system("echo 0 > /sys/class/gpio/gpio88/value");
+
+    //Pilot Status E control (0V)
+    /*GPIO2_22: Pilot_state E, H: state E, L: normal*/
+    system("echo 86 > /sys/class/gpio/export");
+    system("echo \"out\" > /sys/class/gpio/gpio86/direction");
+    system("echo 0 > /sys/class/gpio/gpio86/value");
+
+    SAVE_SYS_LOG_MSG_MAIN("GPIO_Init(): DONE");
+}
+
+
+/*===========================================================================
+FUNCTION: PWM_Init
+DESCRIPTION:
+    - Initialize the PWM channel by the following configuration.
+        * Frequency = 1KHz
+        * Duty = 100%
+
+    - The default voltage should be as below.
+        * 12V: unplugged
+        * 9V: plugged
+
+    - Check Mechanism (to-do)
+        * Read CP Voltage and PWM by AIN3:
+          // cat /sys/bus/iio/devices/iio\\:device0/in_voltage3_raw;
+
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+    - PWM = 100% at 1KHz
+
+GLOBAL VARIABLES:
+=============================================================================*/
+void PWM_Init()
+{
+    //unsigned char str[256];
+
+    //init ecap0
+    //memset(str, 0, sizeof(str));
+    system("echo 0 > /sys/class/pwm/pwmchip0/export");
+    system("echo 1000000 > /sys/class/pwm/pwmchip0/pwm0/period");// nano seconds =>1k Hz
+    system("echo 1000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle"); //default 100%
+    system("echo 1 > /sys/class/pwm/pwmchip0/pwm0/enable");
+    //system("echo 1 > /sys /class/pwm/pwmchip0/pwm0/polarity");
+
+    //PWM_Init_Check(); //Checking if the PWM analog signal is well-initialized
+                        //as 1KHz,100%, and 12V/9V.
+
+    SAVE_SYS_LOG_MSG_MAIN("PWM_Init(): DONE");
+}
+
+/*===========================================================================
+FUNCTION:
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+void Confinguration_Init()
+{
+    //Load System Confinguration
+    LoadSysConfigAndInfo(&ShmSysConfigAndInfo->SysConfig);
+
+    SAVE_SYS_LOG_MSG_MAIN("Confinguration_Init(): DONE");
+}
+
+/*===========================================================================
+FUNCTION: StoreLogMsg
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+#if SAVE_SYS_LOG_MSG_MAIN_SWITCH == ENABLE
+int StoreLogMsg(unsigned char *DataString)
+{
+    static unsigned char Buf[1024];
+    static time_t CurrentTime;
+    static struct tm *tm;
+    static struct timeval tv;
+
+    memset(Buf, 0, sizeof(Buf));
+    CurrentTime = time(NULL);
+    tm = localtime(&CurrentTime);
+    gettimeofday(&tv, NULL); // get microseconds, 10^-6
+
+    sprintf(Buf, "echo \"[%04d%02d%02d: %02d:%02d:%02d.%06d][main]%s\" >> /Storage/SystemLog/[%04d.%02d]SystemLog",
+            tm->tm_year + 1900,
+            tm->tm_mon + 1,
+            tm->tm_mday,
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            DataString,
+            tm->tm_year + 1900,
+            tm->tm_mon + 1);
+    system(Buf);
+
+    DEBUG_PRINTF_MAIN_SYSTEM_LOG("[%02d:%02d:%02d.%06d][main]%s \n",
+            tm->tm_hour,
+            tm->tm_min,
+            tm->tm_sec,
+            tv.tv_usec,
+            DataString);
+
+    //Reset the buf_log_main Buffer, i.e. DataString
+    memset(buf_log_main, 0, SIZE_OF_LOG_BUFFER);
+}
+#endif
+
+/*===========================================================================
+FUNCTION: DiffTimeb
+DESCRIPTION:
+    Caculating the time difference in ms precision (milli-second).
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+double DiffTimeb(struct timeb ST, struct timeb ET)
+{
+    //return milli-second
+    double StartTime, EndTime;
+    double t_diff;
+
+    StartTime = ((double)ST.time)*1000 + (double)ST.millitm;
+    EndTime = ((double)ET.time)*1000 + (double)ET.millitm;
+    t_diff = EndTime - StartTime;
+
+    //printf("%.02lf - %.02lf = %.02lf\n", EndTime, StartTime, t_diff);
+
+    if (t_diff < 0)
+    {
+        #if 0
+        if (t_diff < -1000)   //1000ms
+        {
+            sprintf(buf_log_main,
+                    "[Warning]StartTime(%.02lf) > EndTime(%.02lf), d(%.02lf)",
+                    StartTime,
+                    EndTime,
+                    t_diff);
+            SAVE_SYS_LOG_MSG_MAIN(buf_log_main);
+        }
+        #endif
+
+        return -1;
+    }
+    return t_diff;
+}
+
+
+/**************************************************************************************/
+/****************Following functions are CSU initialization***************************/
+/**************************************************************************************/
+
+/*===========================================================================
+FUNCTION:
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int SpawnTask()
+{
+    //system("/root/EventLogging &");
+    system("/root/CsuComm &");
+    
+    usleep(50000);  //50ms
+    
+    //system("echo 50000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle"); //5%, for test.
+    system("/root/SeccComm &");
+}
+
+
+/*===========================================================================
+FUNCTION:
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int StoreUsrConfigData(struct SysConfigData *UsrData)
+{
+    int fd, wrd;
+    unsigned int i, Chk;
+    unsigned char *ptr;
+
+    Chk = 0;
+    ptr = (unsigned char *)UsrData;
+
+    for(i = 0; i < sizeof(struct SysConfigData) - 4; i++)
+    {
+        Chk += *(ptr + i);
+    }
+
+    UsrData->Checksum = Chk;
+
+    fd = open("/dev/mtdblock10", O_RDWR);
+
+    if(fd < 0)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("StoreUsrConfigData: open /dev/mtdblock10 NG");
+        return 0;
+    }
+
+    wrd = write(fd, UsrData, sizeof(struct SysConfigData));
+    close(fd);
+
+    if(wrd != (sizeof(struct SysConfigData)))
+    {
+        SAVE_SYS_LOG_MSG_MAIN("StoreUsrConfigData: write /dev/mtdblock10 NG");
+        return 0;
+    }
+
+    fd = open("/dev/mtdblock11", O_RDWR);
+
+    if(fd < 0)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("StoreUsrConfigData: open /dev/mtdblock11(backup) NG");
+
+        return 0;
+    }
+
+    wrd = write(fd, UsrData, sizeof(struct SysConfigData));
+    close(fd);
+
+    if(wrd != (sizeof(struct SysConfigData)))
+    {
+        SAVE_SYS_LOG_MSG_MAIN("StoreUsrConfigData: write /dev/mtdblock11(backup) NG");
+        return 0;
+    }
+
+    return 1;
+}
+
+/*===========================================================================
+FUNCTION: LoadSysConfigAndInfo
+DESCRIPTION:
+PRE-CONDITION:
+INPUT:
+OUTPUT:
+GLOBAL VARIABLES:
+=============================================================================*/
+int LoadSysConfigAndInfo(struct SysConfigData *ptr)
+{
+    int fd, wrd;
+    struct SysConfigData *buf;
+    unsigned char *PtrBuf;
+    unsigned int ChkSum, ChkSumOrg;
+
+    if((buf = malloc(sizeof(struct SysConfigData))) == NULL)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("LoadSysConfigAndInfo(): malloc buffer NG,rebooting..");
+
+        if(ShmStatusCodeData != NULL)
+        {
+            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
+        }
+
+        sleep(5);
+        system("reboot -f");
+        sleep(5);
+        system("reboot -f");
+    }
+
+    memset(buf, 0, sizeof(struct SysConfigData));
+    fd = open("/dev/mtdblock10", O_RDWR);
+
+    if(fd < 0)
+    {
+        free(buf);
+        SAVE_SYS_LOG_MSG_MAIN("LoadSysConfigAndInfo():open mtdblock10 NG,rebooting..");
+
+        if(ShmStatusCodeData != NULL)
+        {
+            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
+        }
+
+        sleep(5);
+        system("reboot -f");
+        sleep(5);
+        system("reboot -f");
+    }
+
+    wrd = read(fd, buf, sizeof(struct SysConfigData));
+    close(fd);
+
+    if(wrd != (sizeof(struct SysConfigData)))
+    {
+        free(buf);
+
+        SAVE_SYS_LOG_MSG_MAIN("LoadSysConfigAndInfo(): read SysConfigData data NG,rebooting..");
+
+        if(ShmStatusCodeData != NULL)
+        {
+            ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
+        }
+
+        sleep(5);
+        system("reboot -f");
+        sleep(5);
+        system("reboot -f");
+    }
+
+    PtrBuf = (unsigned char *)buf;
+    ChkSum = 0;
+
+    for(wrd = 0; wrd < (sizeof(struct SysConfigData) - 4); wrd++)
+    {
+        ChkSum += PtrBuf[wrd];
+    }
+
+    ChkSumOrg = buf->Checksum;
+
+    if(ChkSum != ChkSumOrg)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("LoadSysConfigAndInfo(): Primary SysConfigData checksum NG, read backup");
+
+        fd = open("/dev/mtdblock11", O_RDWR);
+
+        if(fd < 0)
+        {
+            free(buf);
+
+            SAVE_SYS_LOG_MSG_MAIN("LoadSysConfigAndInfo(): open mtdblock11 (backup) NG,rebooting..");
+
+            if(ShmStatusCodeData != NULL)
+            {
+                ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
+            }
+
+            sleep(5);
+            system("reboot -f");
+            sleep(5);
+            system("reboot -f");
+        }
+
+        memset(buf, 0, sizeof(struct SysConfigData));
+        wrd = read(fd, buf, sizeof(struct SysConfigData));
+        close(fd);
+
+        if(wrd != sizeof(struct SysConfigData))
+        {
+            free(buf);
+
+            SAVE_SYS_LOG_MSG_MAIN("LoadSysConfigAndInfo(): read backup SysConfigData data NG,rebooting..");
+
+
+            if(ShmStatusCodeData != NULL)
+            {
+                ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
+            }
+
+            sleep(5);
+            system("reboot -f");
+            sleep(5);
+            system("reboot -f");
+        }
+
+        PtrBuf = (unsigned char *)buf;
+        ChkSum = 0;
+
+        for(wrd = 0; wrd < (sizeof(struct SysConfigData) - 4); wrd++)
+        {
+            ChkSum += PtrBuf[wrd];
+        }
+
+        ChkSumOrg = buf->Checksum;
+
+        if(ChkSum != ChkSumOrg)
+        {
+
+            SAVE_SYS_LOG_MSG_MAIN("LoadSysConfigAndInfo(): backup SysConfigData checksum NG, read Factory default");
+
+            fd = open("/dev/mtdblock12", O_RDWR);
+
+            if(fd < 0)
+            {
+                free(buf);
+
+                SAVE_SYS_LOG_MSG_MAIN("LoadSysConfigAndInfo(): open mtdblock12 (Factory default) NG,rebooting..");
+
+
+                if(ShmStatusCodeData != NULL)
+                {
+                    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
+                }
+
+                sleep(5);
+                system("reboot -f");
+                sleep(5);
+                system("reboot -f");
+            }
+
+            memset(buf, 0, sizeof(struct SysConfigData));
+            wrd = read(fd, buf, sizeof(struct SysConfigData));
+            close(fd);
+
+            if(wrd != sizeof(struct SysConfigData))
+            {
+                free(buf);
+
+                SAVE_SYS_LOG_MSG_MAIN("LoadSysConfigAndInfo(): read factory default  SysConfigData data NG,rebooting..");
+
+
+                if(ShmStatusCodeData != NULL)
+                {
+                    ShmStatusCodeData->AlarmCode.AlarmEvents.bits.CsuInitFailed = 1;
+                }
+
+                sleep(5);
+                system("reboot -f");
+                sleep(5);
+                system("reboot -f");
+            }
+
+            PtrBuf = (unsigned char *)buf;
+            ChkSum = 0;
+
+            for(wrd = 0; wrd < (sizeof(struct SysConfigData) - 4); wrd++)
+            {
+                ChkSum += PtrBuf[wrd];
+            }
+
+            ChkSumOrg = buf->Checksum;
+
+            if(ChkSum != ChkSumOrg)
+            {
+
+                SAVE_SYS_LOG_MSG_MAIN("LoadSysConfigAndInfo(): factory default  SysConfigData checksum NG, restore factory default");
+
+                goto DefaultShm;
+            }
+        }
+    }
+
+    //load OK
+    memcpy((struct SysConfigData *)ptr, (struct SysConfigData *)buf, sizeof(struct SysConfigData));
+    free(buf);
+
+    SAVE_SYS_LOG_MSG_MAIN("LoadSysConfigAndInfo(): Load SysConfigData OK");
+
+    return 1;
+
+DefaultShm:
+    system("cd /root;./FactoryConfig");
+
+    #if (FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == DISABLE)
+    {
+        SAVE_SYS_LOG_MSG_MAIN("sync...");
+        system("sync");
+    }
+    #endif
+
+    sleep(5);
+    system("reboot -f");
+    sleep(5);
+    system("reboot -f");
+}

EVSE/Projects/AW-CCS/Apps/CCS/main.h

@@ -0,0 +1,62 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                 main.h
+
+                        initiated by Vern, Joseph
+                           (since 2019/07/19)
+=============================================================================*/
+#if FIRMWARE_VERSION_COMPILE_SETTING_RELEASE_MODE == ENABLE
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_MAIN_SWITCH        ENABLE  //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_MAIN_SHOW              DISABLE  //ENABLE, DISABLE
+#define DEBUG_PRINTF_MAIN_BRIEF_SHOW        DISABLE  //ENABLE, DISABLE
+#define DEBUG_PRINTF_MAIN_DETAIL_SHOW       DISABLE  //ENABLE, DISABLE
+#define DEBUG_PRINTF_MAIN_SYSTEM_LOG_SHOW   DISABLE  //ENABLE, DISABLE
+#else   //debug mode
+//Saving System Log
+#define SAVE_SYS_LOG_MSG_MAIN_SWITCH        ENABLE  //ENABLE, DISABLE
+
+//Configuration for Debug Print Messages
+#define DEBUG_PRINTF_MAIN_SHOW              ENABLE  //ENABLE, DISABLE
+#define DEBUG_PRINTF_MAIN_BRIEF_SHOW        ENABLE  //ENABLE, DISABLE
+#define DEBUG_PRINTF_MAIN_DETAIL_SHOW       ENABLE  //ENABLE, DISABLE
+#define DEBUG_PRINTF_MAIN_SYSTEM_LOG_SHOW   ENABLE  //ENABLE, DISABLE
+#endif
+
+//System Log
+#if SAVE_SYS_LOG_MSG_MAIN_SWITCH == ENABLE
+    #define SAVE_SYS_LOG_MSG_MAIN           StoreLogMsg
+#else
+    #define SAVE_SYS_LOG_MSG_MAIN(...)
+#endif
+
+
+//Debug Message
+#if DEBUG_PRINTF_MAIN_SHOW == ENABLE
+    //Brief Messages
+    #if DEBUG_PRINTF_MAIN_BRIEF_SHOW == ENABLE
+        #define DEBUG_PRINTF_MAIN_BRIEF      printf
+    #else
+        #define DEBUG_PRINTF_MAIN_BRIEF(...)
+    #endif
+
+    //Detail Messages
+    #if DEBUG_PRINTF_MAIN_DETAIL_SHOW == ENABLE
+        #define DEBUG_PRINTF_MAIN_DETAIL     printf
+    #else
+        #define DEBUG_PRINTF_MAIN_DETAIL(...)
+    #endif
+
+    //System Log Messages
+    #if DEBUG_PRINTF_MAIN_SYSTEM_LOG_SHOW == ENABLE
+        #define DEBUG_PRINTF_MAIN_SYSTEM_LOG    printf
+    #else
+        #define DEBUG_PRINTF_MAIN_SYSTEM_LOG(...)
+    #endif
+#else
+    #define DEBUG_PRINTF_MAIN_BRIEF(...)
+    #define DEBUG_PRINTF_MAIN_DETAIL(...)
+    #define DEBUG_PRINTF_MAIN_SYSTEM_LOG(...)
+#endif

EVSE/Projects/AW-CCS/Apps/CCS/rcS

@@ -0,0 +1,104 @@
+#! /bin/ash
+	
+#   ---------------------------------------------
+#   MDEV Support
+#   (Requires sysfs support in the kernel)
+#   ---------------------------------------------
+mount -n -t proc /proc /proc
+mount -n -t sysfs sysfs /sys
+mount -n -t tmpfs mdev /dev
+mkdir /dev/pts
+mount -t devpts devpts /dev/pts
+
+#echo -n " Enabling hot-plug          : "
+echo "/sbin/mdev" > /proc/sys/kernel/hotplug
+
+#echo -n " Populating /dev            : "
+mkdir /dev/input
+mkdir /dev/snd
+mdev -s
+
+#   ---------------------------------------------
+#   Disable power management
+#   (Requires sysfs support in the kernel)
+#   ---------------------------------------------
+# echo -n " Disabling Power mgmt       : "
+# echo -n "1" > /sys/power/cpuidle_deepest_state
+# status $? 1
+	
+
+#   ---------------------------------------------
+#   Mount the default file systems
+#   ---------------------------------------------
+#echo -n " Mounting other filesystems : "
+mount -a
+mount -t tmpfs tmpfs /mnt
+
+chmod 777 /Storage
+#mount -t jffs2 /dev/mtdblock13 /Storage
+ubiattach /dev/ubi_ctrl -m 13
+if [ "$?" -eq "0" ]
+then
+   echo "Success."
+else
+   echo "Erase /dev/mtd13 jffs2 block"
+   flash_eraseall /dev/mtd13
+   ubiattach /dev/ubi_ctrl -m 13
+fi
+ubimkvol /dev/ubi0 -N ubiNandFs -m
+mount -t ubifs ubi0:ubiNandFs /Storage
+mkdir -p /Storage/EventLog
+mkdir -p /Storage/ChargeLog
+mkdir -p /Storage/SystemLog
+mkdir -p /Storage/OCPP
+mkdir -p /UsbFlash	
+ln -s /mnt /var/www
+
+#   ---------------------------------------------
+#   Set PATH
+#   ---------------------------------------------
+export PATH=/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin
+
+#   ---------------------------------------------
+#   Start other daemons
+#   ---------------------------------------------
+#echo 110 > /sys/class/gpio/export
+#echo "out" > /sys/class/gpio/gpio110/direction
+#echo 1 > /sys/class/gpio/gpio110/value
+#sleep 2
+#/sbin/ifconfig eth0 192.168.1.10 netmask 255.255.255.0 
+#/sbin/ifconfig eth0 down
+#sleep 1
+#/sbin/ifconfig eth0 up
+#/sbin/route add default gw 192.168.1.1
+	
+#echo -n " Starting telnetd           	: "
+#/usr/sbin/telnetd -l /bin/login
+#status $? 0
+	
+echo -e " Starting SSH           	: \n"
+/sbin/dropbear
+echo -e " Starting FTPD	  		: \n"
+tcpsvd -vE 0.0.0.0 21 ftpd -w -t 30 / &
+echo -e " Starting LIGHTTPD		: \n"
+/sbin/lighttpd -f /etc/lighttpd/lighttpd.conf -m /lib
+
+cp /root/.tmate.conf /
+/usr/sbin/crond &
+
+id=CSU3_$(cat /sys/class/net/eth0/address)
+echo $id > /etc/hostname
+hostname -F /etc/hostname
+
+#status $? 0
+
+#   ---------------------------------------------
+#   Softlink
+#   ---------------------------------------------		
+cd lib
+ln -sf libbz2.so.1.0.6 libbz2.so.1
+	
+#   ---------------------------------------------
+#   Start demo app
+#   ---------------------------------------------
+/root/main &

EVSE/Projects/AW-CCS/Apps/CCS/reset_soft.sh

@@ -0,0 +1,16 @@
+#killall main
+killall SeccComm
+#killall EvccComm
+#killall CsuComm
+#killall FactoryConfig
+#killall EventLogging
+#killall FWMaker
+#killall NidNmk
+#killall FWUpdate
+#killall candump
+echo 1000000 > /sys/class/pwm/pwmchip0/pwm0/duty_cycle
+sleep 2
+cd /root/
+#./main &
+./SeccComm &
+#./EvccComm &

EVSE/Projects/AW-CCS/Apps/CCS/version.h

@@ -0,0 +1,798 @@
+/*===========================================================================
+                    Combined Charging System (CCS): SECC
+                                 version.h
+
+                     initiated by Joseph D. Anderson
+                           (since 2019/12/03)
+=============================================================================*/
+#define FIRMWARE_VERSION            "V0.27.S0"   //8-Byte(ASCII Code), “tx.yz.ab.cd”
+#define HARDWARE_VERSION            "CCS_8.0x"      //8-Byte(ASCII Code): CSU-03-RW, CCS_Board, REV:5.0
+#define LINUX_IMAGE_VERSION         "dd2da761d59f2cdd4064c9d95f8c302a442d33f3 (2019-01-04)"
+#define RTC_DEFAULT_TIME            1595486300      //Epoch time (decimal)
+//https://git.phihong.com.tw:30000/System_Integration/CSU3_AM335x/commit/SHA1
+#define FIRMWARE_VERSION_LENGTH     8               //unit: byte, max = 8, due to CAN bus payload.
+#define HARDWARE_VERSION_LENGTH     8               //unit: byte, max = 8, due to CAN bus payload.
+/*
+================================================================================
+==================== [Software] Version Naming Rule (2020) =====================
+================================================================================
+
+The firmware version consists of 8 bytes ASCII characters and be separated by
+dot symbol per coupling bytes as the format:
+
+                “tx.yz.ab”
+
+Following table describes the version naming rule.
+
+- BYTE 0: t (Stage)
+One ASCII character to indicate the firmware maturity according to project stage.
+D: development stage (under developing)
+B: verification stage (under QE verification)
+V: manufacture stage (after QE verified and release to factory)
+
+
+- BYTE 1: x (Major)
+Increased with major changes, e.g., hardware change, incompatible change, etc.
+It should be more than or equal to 1 if the first character t is ‘V’
+Only numerical values 0 ~ 9 can be used.
+
+
+- BYTE 2,3: yz (Minor)
+Increased with iterant changes, e.g., new functions, bug fix and so on.
+Two numerical values 00 ~ 99 can be used.
+
+
+- BYTE 4: a (Project)
+Abbreviation for Firmware Projects
+R: Relay Control Board
+F: Fan Control Board
+C: CHAdeMO Board
+D: DC Main Board
+G: GB Board
+L: LED Bar Board
+S: CCS Board
+
+
+- BYTE 5: b (reserved)
+
+================================================================================
+====================== [Software] Version History (2020) =======================
+================================================================================
+[VERSION] V0.27.S0
+* Release Date: 2020-08-
+* Change:
+  1. change Isolation test state to valid if recevied invalid during precharge and charging
+  2. Add CM_AMP_MAP message 
+  3. change isolation status to valid if recevie invalid from CSU in WeldingDetectionRes
+  4. remove extra I_NOW information if no output voltage
+  5. support TLS connection 
+  6. Intergrate to AC EVSE
+* File
+  1. SeccComm.c
+  2. SeccComm.*
+  3. SeccComm.c
+  4. CsuComm.c
+  5. define.h SeccComm.c NidNmk.h cakey.pem cacert.pem
+  	  exi_engine\api\api.c
+      EVSE/GPL/Makefile
+      EVSE/Projects/CCS/Apps/Makefile
+  6. AW-CCS\Apps\Makefile
+  	  AW-CCS\Apps\main.c	
+  	  AW-CCS\Apps\CCS\version.h
+  	  AW-CCS\Apps\CCS\Makefile
+  	  AW-CCS\Apps\CCS\define.h
+  	  AW-CCS\Apps\CCS\CsuComm.*
+  	  AW-CCS\Apps\CCS\SeccComm.c
+  
+[VERSION] V0.26.S0
+* Release Date: 2020-08-
+* Change:
+  1. Support BCB toggle
+  2. killall ntpd
+  3. set all stop reason to emergency stop , except 023979
+* File
+  1. SeccComm.c
+  2. main.c
+  3. SeccComm.c CsuComm.c
+  
+  
+[VERSION] V0.25.S0
+* Release Date: 2020-07-21
+* Change:
+  1. reset PLC chip after session terminated
+  2. set MIN_SUPPORTED_CURRENT =5
+* File
+  1. SeccComm.c
+  2. define.h
+
+
+[VERSION] V0.24.S0
+* Release Date: 2020-07-20
+* Change:
+  1. Fix Pmax in SAschedule less than 0 issue
+  2. ignore sequence error when receive session stop at any command
+  3. fix 10 times of max charging power issue in ChargeParamaterDiscovery.conf 
+  4. reduce 2 seconds after reset SeccComm
+  5. set output voltage = target voltage +10 if not over than max voltage
+* File
+  1. SeccComm.c, exi_engine\api\api.c
+  2. SeccComm.c     
+  3. SeccComm.c     
+  4. EVSE/rootfs/root/reset_soft.sh
+  5. exi_engine\api\api.c
+
+
+
+[VERSION] V0.13.S0 (sync with D0.63.13.1D)
+* Release Date: 2020-07-27
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV8.0)
+* Minor Version: 13
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+  1. Adding response to isolation status in WeldingDetectionRes.
+    (1) DIN: DONE
+    (2) ISO1: DONE
+
+
+[VERSION] V0.12.S0
+* Release Date: 2020-07-20
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV8.0)
+* Minor Version: 12
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+  1. Abandoning previous version name of D1.00.S0 and changing it to V0.12.S0.
+     to be the 1st MP version.
+
+
+[VERSION] D1.00.S0
+* Release Date: 2020-07-20
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV8.0)
+* Minor Version: 12
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+  1. Chaning the version name from D0.12.S0 to D1.00.S0
+     to be the 1st CE pass version.
+
+
+[VERSION] D0.12.S0
+* Release Date: 2020-07-20
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV8.0)
+* Minor Version: 12
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+	1. Sync with D0.62.13.1D (2020-07-03), 
+	   => final version verified at DEKRA for CE (60KW)
+
+
+[VERSION] D0.11.S0
+* Release Date: 2020-05-14
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 11
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Sync with D0.43.13.1D
+
+
+[VERSION] D0.10.S0
+* Release Date: 2020-04-27
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 10
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Removing redundant debug message and code.
+
+    2. Adding error codes for the following situations.
+       (1) CCS_SECC_TIMEOUT_SLACC_SDP_UDP_TT_match_join (023823)
+       (2) CCS_SECC_TIMEOUT_SLACC_SDP_TCP_TT_match_join (023824)
+
+
+[VERSION] D0.09.S0
+* Release Date: 2020-04-23
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 09
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Merging D0.08.13.1D to here.
+
+[VERSION] D0.08.S0
+* Release Date: 2020-04-13
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 08
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Disabling "Check for ChargingPermission" when CP state is between 3 and 5,
+       which is a new function in D0.07.S0.
+
+    2. Disabling RTC function.
+
+[VERSION] D0.07.S0
+* Release Date: 2020-04-09
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 07
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Adding response to "ChargingPermission off" before V2G messages.
+       => End_Process()
+
+    2. Modifying the EVSEStatusCode status to be TRUE in the following 2 messages.
+       (1) din_ChargeParameterDiscoveryRes
+       (2) iso1_ChargeParameterDiscoveryRes
+
+[VERSION] D0.06.S0
+* Release Date: 2020-03-17
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 06
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Adding "CSUCOMM_TASK_FLAG.EV_Stop_Type_Emergency" flag to handle CAN Stop
+       command type to CSU.
+
+    2. Adding error code to the following situation.
+       (1) CCS_SECC_TIMEOUT_SLAC_TT_EVSE_SLAC_init (023809)
+           SlacComm: Wait CM_SLAC_PARM_REQ Timeout - TT_EVSE_SLAC_init (50s)
+
+[VERSION] D0.05.S0
+* Release Date: 2020-03-17
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 05
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Sync with D0.20.11.1D.
+
+
+[VERSION] D0.04.S0
+* Release Date: 2020-03-13
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 04
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Adding error code of the following two situation.
+       - CCS_SECC_CP_State_Error (023889)
+       - CCS_SECC_TIMEOUT_V2G_Sequence_Time (023844)
+
+[VERSION] D0.03.S0
+* Release Date: 2020-03-13
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 03
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Merging D0.16.11.1D to here.
+
+[VERSION] D0.02.S0
+* Release Date: 2020-03-04
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 02
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Changing the default CAN bus firmware update method of ramdisk to
+       root_app process.
+
+[VERSION] D0.01.S0
+* Release Date: 2020-03-02
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 01
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2(default: DISABLE)
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Merging D0.12.11.1D of branch ISO_15118 to master.
+
+    2. Limiting the Supported CCS protocols to DIN 70121 only. (Disabling ISO1)
+       => #define V2GT_MSG_PROTOCOL_PREFERENCE  V2GT_MSG_PROTOCOL_DIN70121
+
+    3. Changing the firmware naming rule.
+
+
+
+================================================================================
+=================== [Software] Version Naming Rule (2019)=======================
+================================================================================
+
+The firmware version consists of 8 bytes ASCII characters and be separated by
+dot symbol per coupling bytes as the format:
+
+                “tx.yz.ab.cd”.
+
+Following table describes the version naming rule.
+
+- BYTE 0: t (Stage)
+One ASCII character to indicate the firmware maturity according to project stage.
+D: development stage (under developing)
+B: verification stage (under QE verification)
+V: manufacture stage (after QE verified and release to factory)
+
+
+- BYTE 1: x (Major)
+Increased with major changes, e.g., hardware change, incompatible change, etc.
+It should be more than or equal to 1 if the first character t is ‘V’
+Only numerical values 0 ~ 9 can be used.
+
+
+- BYTE 2,3: yz (Minor)
+Increased with iterant changes, e.g., new functions, bug fix and so on.
+Two numerical values 00 ~ 99 can be used.
+
+
+- BYTE 4: a (Comm Method)
+Supported HLC Communication Methods
+bit 7   bit 6   bit 5   bit 4   bit 3   bit 2   bit 1   bit 0
+|------------------ reserved ----------------|	Wi-Fi    PLC
+1: PLC only
+2: Wi-Fi only
+3: PLC + Wi-Fi
+others: reserved
+
+
+- BYTE 5: b (Charging Type)
+Supported Charging Types
+bit 7   bit 6   bit 5   bit 4   bit 3   bit 2   bit 1   bit 0
+|-------- reserved  --------|    BPT     WPT     AC      DC
+1: DC only
+2: AC only
+3: DC + AC
+4: WPT: Wireless Power Transfer
+8: BPT: Bidirectional Power Transfer, etc
+others: reserved
+
+
+- BYTE 6: c (Supported Features)
+bit 7   bit 6   bit 5   bit 4   bit 3   bit 2   bit 1   bit 0
+|-------------- reserved -----------|    ACD     PnC     EIM
+1: EIM
+2: PnC
+4: ACD (Automatic Connection Device), etc
+Others: reserved
+
+
+- BYTE 7: d (Supported Protocols)
+bit 7       bit 6       bit 5       bit 4       bit 3       bit 2       bit 1       bit 0
+|--------- reserved --------------------|   ISO 15118-20  ISO 15118-2  SAE J2847  DIN 70121
+1: DIN SPEC 70121
+2: SAE J2847
+3: DIN SPEC 70121 + SAE J2847
+4: ISO/IEC 15118-2
+8: ISO/IEC 15118-20, etc
+others: reserved
+
+================================================================================
+========================= [Software] Version History ===========================
+================================================================================
+[VERSION] D0.12.11.1D
+* Release Date: 2020-02-24
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 11
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2, ISO 15118-20
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Checking EVMaximumVoltageLimit_isUsed flag when using decoded
+       EVMaximumVoltageLimit value.
+
+    2. Extending V2G_SECC_WeldingDetection_Performance_Time from 2s to 20s.
+    -
+
+[VERSION] D0.10.11.1D
+* Release Date: 2020-02-24
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 10
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2, ISO 15118-20
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Adding Check_CP_State_Error() function in the forked EvComm task.
+    2. Updating the log mechanism of present EVSE V/I information.
+
+
+[VERSION] D0.09.11.1D
+* Release Date: 2020-02-20
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 09
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2, ISO 15118-20
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Adding Tx timeout for RawSock (100ms, SO_SNDTIMEO)
+
+    2. Replacing the original "static variable" of counter of iso1_CableCheckRes and iso1_PreChargeReq
+       with another new variable inside CcsData structure.
+
+[VERSION] D0.08.11.1D
+* Release Date: 2020-02-20
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 08
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2, ISO 15118-20
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Modifying the state machine to let state return back to IDLE(0)
+       once the set key process of QCA7000 is completed.
+
+[VERSION] D0.07.11.1D
+* Release Date: 2020-02-20
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 07
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2, ISO 15118-20
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    1. Modifying 5% PWM start timing as below. (requested by Diamler)
+       (1) Start 5% PWM once receiving CM_SLAC_PARM_REQ from EV.
+           => The Charging Permission status from CSU doesn't have to be TRUE
+       (2) Start 5% once QCA7000 finishs setting key (CM_SET_KEY_CNF) and
+           detecting both of
+           "CheckConnectorPlugIn()" and
+           "Charging Permission status from CSU" are TRUE.
+           => The Charging Permission status from CSU have to be TRUE
+
+    2. Adding the following system reset methods for the selection.
+       (1) #define RESET_MECHANISM_SOFT_RESET_KILLALL_EVCOMM       0  (default)
+       (2) #define RESET_MECHANISM_HARD_RESET                      1
+       (3) #define RESET_MECHANISM_SOFT_RESET_INTERNAL_RESUME      2
+
+    2. Adding check mechanism for Charging Permission in all V2G message process
+       after ChargeParameterDiscoveryReq.
+       => if (ShmInternalComm->ChargingPermission == FALSE)
+
+    3. Printing states on the following task log. (via Check_V2G_Flow_Status())
+       (1) EvComm
+       (2) CsuComm
+
+    4. Adding Check_V2G_Flow_Status_pre() function to check previous status.
+
+
+[VERSION] D0.06.11.1D
+* Release Date: 2020-02-19
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 06
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2, ISO 15118-20
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+  - Fixing the issue of Shutdown by EVSE Mechanism in D0.05.11.1D.
+
+[VERSION] D0.05.11.1D
+* Release Date: 2020-02-19
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 05
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2, ISO 15118-20
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+  - Merging D1.19.11.11 to here.
+
+[VERSION] D0.04.11.1D
+* Release Date: 2020-02-11
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 04
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2, ISO 15118-20
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+  - Fixing the software CP protection mechanism,
+    which won't be triggered in previous version.
+
+[VERSION] D0.03.11.1D
+* Release Date: 2020-02-11
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 03
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2, ISO 15118-20
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    - [ISO1] The first successful version for ISO15118_2014
+    - Verification:
+      -- Emulator: Gridwiz Simplemint (ISO 15118, ISO1)
+         => Normal Stop by EVSE during CurrentDemand(): PASS
+      -- EVSE: to be verified
+    - [ISO2] paused on development
+
+
+[VERSION] D0.02.11.1D
+* Release Date: 2020-02-06
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 02
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2, ISO 15118-20
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    - [ISO1] SessionSetupReq: done
+    - [ISO1] SessionSetupRes: done
+    - [ISO2] SessionSetupReq: done
+    - [ISO2] SessionSetupRes: done
+
+
+[VERSION] D0.01.11.1D
+* Release Date: 2020-02-03
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV5.0)
+* Minor Version: 01
+* Supported Protocol(1101b): DIN 70121, ISO 15118-2, ISO 15118-20
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    - kick-off of ISO 15118-2 and 15118-20
+    - supportedAppProtocolReq: done
+
+*--------------------------- start of ISO 15118 --------------------------------
+
+[VERSION] D1.09.11.11
+* Release Date: 2020-01-17
+* Stage: D (development)
+* Major Version: 1 (Compliant HW Version: REV5.0)
+* Minor Version: 09
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    - Adding Update_Module.c (not be enabled, yet).
+    - Updating the "NAND flash mapping table" of Firmware Design SPEC
+
+
+[VERSION] D1.08.11.11
+* Release Date: 2020-01-15
+* Stage: D (development)
+* Major Version: 1 (Compliant HW Version: REV5.0)
+* Minor Version: 08
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    - Fixing CAN Bus firmware image update function.
+      -- ramdisk, configuration
+
+
+[VERSION] D1.07.11.11
+* Release Date: 2020-01-15
+* Stage: D (development)
+* Major Version: 1 (Compliant HW Version: REV5.0)
+* Minor Version: 07
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    - Adding CAN Bus firmware image update function.
+      -- supporting MLO, uboot, zImage, ramdisk, configuration
+
+
+[VERSION] D1.06.11.11
+* Release Date: 2020-01-10
+* Stage: D (development)
+* Major Version: 1 (Compliant HW Version: REV5.0)
+* Minor Version: 06
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    - Adding CAN Bus firmware image update function.
+      -- supporting ramdisk_app (type = 5)
+
+[VERSION] D1.05.11.11
+* Release Date: 2020-01-07
+* Stage: D (development)
+* Major Version: 1 (Compliant HW Version: REV5.0)
+* Minor Version: 05
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    - Enabling the CP_PROTECTION_MECHANISM.
+
+
+[VERSION] D1.04.11.11
+* Release Date: 2020-01-07
+* Stage: D (development)
+* Major Version: 1 (Compliant HW Version: REV5.0)
+* Minor Version: 04
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    - Adding auto detection of CCS Board ID pin. (AM_IO_1)
+    - Adding dts files for linux and uboot.
+      By executing auto_win.sh or auto_mac.sh, it will update dts into linux
+      kernel and compile.
+
+
+[VERSION] D1.03.11.11
+* Release Date: 2020-01-06
+* Stage: D (development)
+* Major Version: 1 (Compliant HW Version: REV5.0)
+* Minor Version: 03
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+    - Fixing all shell script "Next Line" error
+      * "CRLF" ==> "LF"
+    - Adding scripts for auto compile and data moving.
+
+
+[VERSION] D1.02.11.11
+* Release Date: 2020-01-06
+* Stage: D (development)
+* Major Version: 1 (Compliant HW Version: REV5.0)
+* Minor Version: 02
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+  - Canceling "LIGHTTPD" (web server) when Linux is booting up.
+    Purpose: Reduce the CPU resource to enhance the CCS tasks performance.
+
+
+[VERSION] D1.01.11.11
+* Release Date: 2020-01-06
+* Stage: D (development)
+* Major Version: 1 (Compliant HW Version: REV5.0)
+* Minor Version: 01
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+  - The first version for CCS Board HW 5.0,
+    which supports Ethernet(eth0) and higher ADC sampling rate.
+
+
+[VERSION] D0.04.11.11
+* Release Date: 2019-12-23
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV2.0, REV4.0)
+* Minor Version: 04
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+  - CCS Board ID = 2. (can_tx_payload[4] = 0x02)
+
+[VERSION] D0.04.11.11
+* Release Date: 2019-12-05
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV2.0, REV4.0)
+* Minor Version: 03
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+  - CCS Board ID = 2.
+
+
+[VERSION] D0.03.11.11
+* Release Date: 2019-12-05
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV2.0, REV4.0)
+* Minor Version: 03
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+  - RTC time byte sequence inside CAN msg is modified to [0] [1] [2] [3]
+    from [3] [2] [1] [0].
+
+
+[VERSION] D0.02.11.11
+* Release Date: 2019-12-04
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV2.0, REV4.0)
+* Minor Version: 02
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note:
+  - Adding RTC update function (via CAN message)
+
+
+[VERSION] D0.01.11.11
+* Release Date: 2019-12-04
+* Stage: D (development)
+* Major Version: 0 (Compliant HW Version: REV2.0, REV4.0)
+* Minor Version: 01
+* Supported Protocol: DIN 70121
+* Supported Feature: EIM
+* Charging Type: DC
+* Comm Method: PLC
+* Note: -
+
+
+================================================================================
+======================== [Hardware] Version Naming Rule ========================
+================================================================================
+
+
+
+================================================================================
+========================== [Software] Version History ==========================
+================================================================================
+
+*/

EVSE/Projects/AW-CCS/Apps/Makefile

@@ -8,37 +8,12 @@ Lib_Module_RatedCurrent = "-L../../../Modularization" -lm -lModule_RatedCurrent
 Lib_SQLite3 = "-L../../../Modularization/ocppfiles" -lsqlite3
 Lib_JSONC = "-L../../../GPL/json-c-json-c-0.13.1-20180305/release/lib" -ljson-c
 
-EXI_ENGINE= CCS/v2g/api/api.c \
-	    CCS/v2g/appHandshake/appHandEXIDatatypes.c \
-	    CCS/v2g/appHandshake/appHandEXIDatatypesDecoder.c \
-	    CCS/v2g/appHandshake/appHandEXIDatatypesEncoder.c \
-	    CCS/v2g/codec/BitInputStream.c \
-	    CCS/v2g/codec/BitOutputStream.c \
-	    CCS/v2g/codec/ByteStream.c \
-	    CCS/v2g/codec/DecoderChannel.c \
-	    CCS/v2g/codec/EncoderChannel.c \
-	    CCS/v2g/codec/EXIHeaderDecoder.c \
-	    CCS/v2g/codec/EXIHeaderEncoder.c \
-	    CCS/v2g/codec/MethodsBag.c \
-	    CCS/v2g/din/dinEXIDatatypes.c \
-	    CCS/v2g/din/dinEXIDatatypesDecoder.c \
-	    CCS/v2g/din/dinEXIDatatypesEncoder.c \
-	    CCS/v2g/iso1/iso1EXIDatatypes.c \
-	    CCS/v2g/iso1/iso1EXIDatatypesDecoder.c \
-	    CCS/v2g/iso1/iso1EXIDatatypesEncoder.c \
-	    CCS/v2g/iso2/iso2EXIDatatypes.c \
-	    CCS/v2g/iso2/iso2EXIDatatypesDecoder.c \
-	    CCS/v2g/iso2/iso2EXIDatatypesEncoder.c \
-	    CCS/v2g/transport/v2gtp.c \
-	    CCS/v2g/xmldsig/xmldsigEXIDatatypes.c \
-	    CCS/v2g/xmldsig/xmldsigEXIDatatypesDecoder.c \
-	    CCS/v2g/xmldsig/xmldsigEXIDatatypesEncoder.c \
-	    CCS/NidNmk.c \
-	    CCS/SystemLogMessage.c \
-	    CCS/Module_CCS.c
 
 all: CopyFile apps
-apps: Module_InternalComm_Task Module_FactoryConfig_Task Module_AlarmDetect_Task Module_CSU_Task Module_Speaker_Task Module_CCS_Task Module_LcmControl_Task Module_ConfigTools_Task Module_Debug_Task Module_PowerSharing_Task
+apps: CCS_Task Module_InternalComm_Task Module_FactoryConfig_Task Module_AlarmDetect_Task Module_CSU_Task Module_Speaker_Task Module_CCS_Task Module_LcmControl_Task Module_ConfigTools_Task Module_Debug_Task Module_PowerSharing_Task
+
+CCS_Task:
+	cd CCS;make CCSType=$(Project) all
 
 Module_ConfigTools_Task:
 	@echo "===== Module_ConfigTools_Task  ==================================="
@@ -76,6 +51,7 @@ Module_FactoryConfig_Task:
 	mkdir -p /Storage/SystemLog	
 	./Module_FactoryConfig -f;true
 	cp /mnt/FactoryDefaultConfig.bin ../Images 
+	rm /mnt/FactoryDefaultConfig.bin	
 	rm -f Module_FactoryConfig 
 	$(CC) -D $(Project) "-I../../" -O0  -Wall -c -fmessage-length=0 -o Module_FactoryConfig.o "./Module_FactoryConfig.c"
 	$(CC) -o Module_FactoryConfig Module_FactoryConfig.o 
@@ -121,10 +97,10 @@ Module_Speaker_Task:
 
 Module_CCS_Task:
 	@echo "===== Module_CCS_Task =========================================="
-	rm -f Module_CCS
-	$(CC) -D $(Project) "-I../../../Modularization/ocppfiles/" "-ICCS/v2g/api" "-ICCS/v2g/appHandshake" "-ICCS/v2g/codec" "-ICCS/v2g/din" "-ICCS/v2g/iso1" "-ICCS/v2g/iso2" "-ICCS/v2g/transport" "-ICCS/v2g/xmldsig" "-ICCS/" "-I./" -O0  -Wall -fmessage-length=0 -lm  ${EXI_ENGINE} -o Module_CCS
-	rm -f *.o
-	mv -f Module_CCS ../Images/root
+#	rm -f Module_CCS
+#	$(CC) -D $(Project) "-I../../../Modularization/ocppfiles/" "-ICCS/v2g/api" "-ICCS/v2g/appHandshake" "-ICCS/v2g/codec" "-ICCS/v2g/din" "-ICCS/v2g/iso1" "-ICCS/v2g/iso2" "-ICCS/v2g/transport" "-ICCS/v2g/xmldsig" "-ICCS/" "-I./" -O0 -g3 -Wall -fmessage-length=0 -lm  ${EXI_ENGINE} -o Module_CCS
+#	rm -f *.o
+#	mv -f Module_CCS ../Images/root
 
 Module_LcmControl_Task:
 	@echo "===== Module_LcmControl_Task ==================================="

EVSE/Projects/AW-CCS/Apps/Module_InternalComm.c

@@ -763,7 +763,7 @@ unsigned char Query_AC_MCU_Status(unsigned char fd, unsigned char targetAddr, Ac
 		{
 			Ret_Buf->cp_state = rx[6];
 			Ret_Buf->current_limit = rx[7] | (rx[8]<<0x08);
-			Ret_Buf->cp_voltage_positive = (rx[9] | (rx[10]<<0x08))/100.0;
+			Ret_Buf->cp_voltage_positive = (rx[9] | (rx[10]<<0x08))/100.0;		
 			Ret_Buf->cp_voltage_negtive = (rx[11] | (rx[12]<<0x08))/100.0;
 			Ret_Buf->locker_state = rx[13];
 			Ret_Buf->relay_state = rx[14];
@@ -1537,6 +1537,7 @@ unsigned char Config_AC_MaxCurrent_And_CpPwmDuty(unsigned char fd, unsigned char
 	tx[4] = 0x01;
 	tx[5] = 0x00;
 	tx[6] = Set_Buf->max_current;
+		DEBUG_WARN("Config_AC_MaxCurrent_And_CpPwmDuty...%d\n", Set_Buf->max_current);
 
 	for(int idx=0;idx<(tx[4] | tx[5]<<8);idx++)
 			chksum ^= tx[6+idx];
@@ -2160,6 +2161,7 @@ int main(void)
 				//===============================
 				if(ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty == ON)
 				{
+					DEBUG_WARN("Case 8 : Config primary set CP PWN duty...%d\n", ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty);
 					if(Config_AC_MaxCurrent_And_CpPwmDuty(Uart1Fd, (gun_index>0?ADDR_AC_PRIMARY_2:ADDR_AC_PRIMARY_1), &ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty))
 					{
 						failCount[gun_index] = 0;

EVSE/Projects/AW-CCS/Apps/main.c

@@ -2296,7 +2296,9 @@ int LoadSysConfigAndInfo(struct SysConfigData *ptr)
 		if(ShmSysConfigAndInfo->SysConfig.ModelName[7+idx] == '7')
 			ShmCharger->isCcsEnable = ON;
 	}
-
+         #ifdef ENABLE_CCS
+	ShmCharger->isCcsEnable = ON;
+	#endif
 	RatedCurrentParsing((char*)ShmSysConfigAndInfo->SysConfig.ModelName, &modelnameInfo);
 
 	return PASS;
@@ -2615,6 +2617,14 @@ int SpawnTask(uint8_t gun_index)
 		system ("/root/Module_Speaker &");
 		system ("/root/Module_ProduceUtils &");
 		system ("/root/Module_LcmControl &");
+		/*+++Vern, for CCS +++*/
+		if(ShmCharger->isCcsEnable == ON)
+		{	
+			system ("/root/CsuComm &");
+			sleep(3);
+			system ("/root/SeccComm &");
+		}
+		/*---Vern, for CCS ---*/
 	}
 
 	return PASS;
@@ -2631,7 +2641,10 @@ int InitQca7000()
 		system("/sbin/insmod /lib/qcaspi.ko");
 
 	sleep(2);
-	system("/sbin/ifconfig eth1 192.168.253.11 netmask 255.255.255.0 up");
+	/*+++ vern, for CCS +++*/
+	//system("/sbin/ifconfig eth1 192.168.253.11 netmask 255.255.255.0 up");
+    system("/sbin/ifconfig eth1 192.168.0.11 netmask 255.255.255.0 up");
+    /*--- vern, for CCS ---*/
 	sleep(1);
 
 	return result;
@@ -4318,10 +4331,8 @@ void checkChargingProfileLimit(uint8_t gun_index, uint8_t system_mode)
 				ShmCharger->gun_info[gun_index].targetCurrent = ((ShmCharger->gun_info[gun_index].targetCurrent > ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent)?ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent:ShmCharger->gun_info[gun_index].targetCurrent);
 				ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = ((ShmCharger->gun_info[gun_index].targetCurrent > ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent)?ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent:ShmCharger->gun_info[gun_index].targetCurrent);
 				ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = ((1 <= ShmCharger->gun_info[gun_index].targetCurrent) && (ShmCharger->gun_info[gun_index].targetCurrent <= 5)? 6:((ShmCharger->gun_info[gun_index].targetCurrent == 0)? 100:ShmCharger->gun_info[gun_index].targetCurrent));
-
 			}
 			ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = YES;
-
 			break;
 		case SYS_MODE_CHARGING:
 		case SYS_MODE_TERMINATING:
@@ -5319,7 +5330,7 @@ int main(void)
 						ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
 						ShmCharger->gun_info[gun_index].isDoEvReadyOnce = OFF;
 						ShmCharger->gun_info[gun_index].resultAuthorization = DEFAULT_RFID;
-						if(ShmCharger->isCcsEnable)system("pkill Module_CCS");
+						//if(ShmCharger->isCcsEnable)system("pkill Module_CCS");
 						DB_Check_Record_Buf(localDb, gun_index);
 					}
 					
@@ -5451,6 +5462,7 @@ int main(void)
 											DEBUG_INFO("Authorize pass.\n");
 											setSpeaker(ON,SPEAKER_SHORT);
 											setLedMotion(gun_index,LED_ACTION_RFID_PASS);
+											#if 0
 											if(ShmCharger->isCcsEnable)
 											{
 												ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = CCS_PWM_DUTY_CP_STATE_F;
@@ -5458,9 +5470,10 @@ int main(void)
 												sleep(4);
 												ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = CCS_PWM_DUTY_100;
 												ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
-												system("/root/Module_CCS &");
+												//system("/root/Module_CCS &");
 											}
 											else
+											#endif	
 												sleep(4);
 
 											setChargerMode(gun_index, SYS_MODE_PREPARING);
@@ -5481,12 +5494,12 @@ int main(void)
 								{
 									if(ShmCharger->isCcsEnable)
 									{
-										ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = CCS_PWM_DUTY_CP_STATE_F;
-										ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
-										sleep(4);
-										ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = CCS_PWM_DUTY_100;
-										ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
-										system("/root/Module_CCS &");
+										//ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = CCS_PWM_DUTY_CP_STATE_F;
+										//ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
+										//sleep(4);
+										//ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = CCS_PWM_DUTY_100;
+										//ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
+										//system("/root/Module_CCS &");
 									}
 
 									setChargerMode(gun_index, SYS_MODE_PREPARING);
@@ -5498,12 +5511,12 @@ int main(void)
 							default:
 								if(ShmCharger->isCcsEnable)
 								{
-									ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = CCS_PWM_DUTY_CP_STATE_F;
-									ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
-									sleep(4);
-									ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = CCS_PWM_DUTY_100;
-									ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
-									system("/root/Module_CCS &");
+									//ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = CCS_PWM_DUTY_CP_STATE_F;
+									//ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
+									//sleep(4);
+									//ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = CCS_PWM_DUTY_100;
+									//ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
+									//system("/root/Module_CCS &");
 								}
 								setChargerMode(gun_index, SYS_MODE_PREPARING);
 								break;
@@ -5521,6 +5534,7 @@ int main(void)
 						if(ShmCharger->isCcsEnable)
 						{
 							ShmCharger->gun_info[gun_index].ccsHandshakeState = HANDSHAKE_DUTY_5;
+							DEBUG_INFO("ccsHandshakeState = HANDSHAKE_DUTY_5\n");
 						}
 						else
 						{
@@ -5553,11 +5567,12 @@ int main(void)
 
 
 								// Set CCS 5% PWM duty
-								if(ShmCharger->gun_info[gun_index].acCcsInfo.CpSetPWMDuty == CCS_PWM_DUTY_5)
+								if(ShmCharger->gun_info[gun_index].acCcsInfo.CpSetPWMDuty == CCS_PWM_DUTY_5)//set 5% by SeccComm.c
 								{
 									ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = CCS_PWM_DUTY_5;
 									ShmCharger->gun_info[gun_index].ccsHandshakeState = HANDSHAKE_DUTY_5_CHECK;
 									ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
+									DEBUG_INFO("ccsHandshakeState = HANDSHAKE_DUTY_5_CHECK\n");
 								}
 								break;
 							case HANDSHAKE_DUTY_5_CHECK:
@@ -5566,16 +5581,30 @@ int main(void)
 									//2 secs timeout
 									refreshStartTimer(&startTime[gun_index][TMR_IDX_BS_HLC_HANDSHAKE]);
 									ShmCharger->gun_info[gun_index].ccsHandshakeState = HANDSHAKE_CCS;
+									DEBUG_INFO("ccsHandshakeState = HANDSHAKE_CCS\n");
 								}
 								break;
 							case HANDSHAKE_CCS:
 								//CCS handshake timeout
 								if(getDiffSecNow(startTime[gun_index][TMR_IDX_BS_HLC_HANDSHAKE]) > TIMEOUT_SPEC_BS_HLC_HANDSHAKE)
 								{
-									ShmCharger->gun_info[gun_index].acCcsInfo.ChargingPermission = OFF;
-									ShmCharger->gun_info[gun_index].acCcsInfo.EVSENotification = NOTIFICATION_STOP;
-									DEBUG_INFO("BS/HLC %d secs handshake timeout.\n", TIMEOUT_SPEC_BS_HLC_HANDSHAKE);
-								}
+									if(ShmCharger->isCcsEnable)
+									{
+										DEBUG_INFO("TIMEOUT_SPEC_BS_HLC_HANDSHAKE.\n");
+										ShmCharger->gun_info[gun_index].acCcsInfo.ChargingPermission = OFF;
+										ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = CCS_PWM_DUTY_CP_STATE_F;
+										ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
+										ShmCharger->gun_info[gun_index].ccsHandshakeState = HANDSHAKE_CP_STATE_E;
+										ShmCharger->gun_info[gun_index].chargingMode = CHARGING_MODE_BS;
+										break;
+									}
+									else
+									{
+										ShmCharger->gun_info[gun_index].acCcsInfo.ChargingPermission = OFF;
+										ShmCharger->gun_info[gun_index].acCcsInfo.EVSENotification = NOTIFICATION_STOP;
+										DEBUG_INFO("BS/HLC %d secs handshake timeout.\n", TIMEOUT_SPEC_BS_HLC_HANDSHAKE);
+									}
+								 }
 
 								if((ShmCharger->gun_info[gun_index].acCcsInfo.ChargingPermission == OFF) && (ShmCharger->gun_info[gun_index].acCcsInfo.CpSetPWMDuty != CCS_PWM_DUTY_5))
 								{
@@ -5587,6 +5616,7 @@ int main(void)
 								}
 
 								//CCS status check
+								#if 0
 								if((16 < ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus) && (ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus < 254))
 								{
 									ShmCharger->gun_info[gun_index].chargingMode = CHARGING_MODE_HLC;
@@ -5594,7 +5624,43 @@ int main(void)
 									ShmCharger->gun_info[gun_index].ccsHandshakeState = HANDSHAKE_HLC_MODE;
 									refreshStartTimer(&startTime[gun_index][TMR_IDX_HANDSHAKING]);
 								}
-
+								#else
+								 if((16 <= ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus) && (ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus < 253))
+								{
+									//chang PWM duty to BS
+									if((ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty == OFF)&&(ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current!=CCS_PWM_DUTY_5))
+									{	
+										ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current =CCS_PWM_DUTY_5; //((ShmCharger->gun_info[gun_index].targetCurrent > ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent)?ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent:ShmCharger->gun_info[gun_index].targetCurrent);
+										ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
+										DEBUG_INFO("ccsHandshakeState = HANDSHAKE_CCS (set 5% duty)\n");
+									}
+									//ShmCharger->gun_info[gun_index].chargingMode = CHARGING_MODE_HLC;
+									//ShmCharger->gun_info[gun_index].ccsHandshakeState = HANDSHAKE_HLC_MODE;
+									refreshStartTimer(&startTime[gun_index][TMR_IDX_HANDSHAKING]);
+								}
+								if((37 <= ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus) && (ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus < 49))
+								{
+									//chang PWM duty to BS
+									if((ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty == OFF)&&(ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current!=CCS_PWM_DUTY_5))
+									{	
+										ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current =CCS_PWM_DUTY_5; //((ShmCharger->gun_info[gun_index].targetCurrent > ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent)?ShmSysConfigAndInfo->SysConfig.MaxChargingCurrent:ShmCharger->gun_info[gun_index].targetCurrent);
+										ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
+									}
+									ShmCharger->gun_info[gun_index].chargingMode = CHARGING_MODE_HLC;
+									ShmCharger->gun_info[gun_index].ccsHandshakeState = HANDSHAKE_HLC_MODE;
+									//refreshStartTimer(&startTime[gun_index][TMR_IDX_HANDSHAKING]);
+									DEBUG_INFO("ccsHandshakeState = HANDSHAKE_HLC_MODE\n");
+								}
+								else if((54 < ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus) && (ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus <= 255))
+								{
+									DEBUG_INFO("ccsHandshakeState = CHARGING_MODE_BS, CCS terminated\n");
+									ShmCharger->gun_info[gun_index].acCcsInfo.ChargingPermission = OFF;
+									ShmCharger->gun_info[gun_index].primaryMcuCp_Pwn_Duty.max_current = CCS_PWM_DUTY_CP_STATE_F;
+									ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty = ON;
+									ShmCharger->gun_info[gun_index].ccsHandshakeState = HANDSHAKE_CP_STATE_E;
+									ShmCharger->gun_info[gun_index].chargingMode = CHARGING_MODE_BS;
+								}	
+								#endif
 								break;
 							case HANDSHAKE_CP_STATE_E:
 								if(ShmCharger->gun_info[gun_index].mcuFlag.isSetCpPwmDuty == OFF)
@@ -5603,7 +5669,7 @@ int main(void)
 									{
 										DEBUG_INFO("Change to CP STATE E for 4 secs.\n");
 										//CP STATE E for 4 secs
-										sleep(4);
+										sleep(3);
 									}
 
 									//restore normal CP PWM duty
@@ -5730,15 +5796,20 @@ int main(void)
 
 								break;
 							case HANDSHAKE_HLC_MODE:
-								if(ShmCharger->gun_info[gun_index].acCcsInfo.EVChargeProgress == HLC_START_MODE)
+								if(ShmCharger->gun_info[gun_index].acCcsInfo.EVChargeProgress == HLC_START_MODE)//powerDelivery
 								{
-									setRelay(gun_index,ON);
-									ShmCharger->gun_info[gun_index].isCCSStartTransation = ON;
+									if(ShmCharger->gun_info[gun_index].legacyRequest.isRelayOn == OFF)
+									{	
+										setRelay(gun_index,ON);
+										ShmCharger->gun_info[gun_index].isCCSStartTransation = ON;
+										DEBUG_INFO("HANDSHAKE_HLC_MODE:setRelay ON\n");
+									}
 								}
 
 								if((ShmCharger->gun_info[gun_index].primaryMcuState.relay_state == ON) &&
 									(ShmCharger->gun_info[gun_index].isCCSStartTransation == ON))
 								{
+									DEBUG_INFO("HANDSHAKE_HLC_MODE:Relay ON done\n");
 									ocpp_set_unlocker_req(gun_index, OFF);
 									presentChargedEnergyClear(gun_index);
 									getDateTimeString((char*)ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].StartDateTime);
@@ -5760,6 +5831,7 @@ int main(void)
 									ocpp_set_starttransaction_req(gun_index, ON);
 									ShmCharger->gun_info[gun_index].isCCSStartTransation = OFF;
 									setChargerMode(gun_index, SYS_MODE_CHARGING);
+									DEBUG_INFO("set SYS_MODE_CHARGING\n");
 									refreshStartTimer(&startChargingTime[gun_index]);
 									refreshStartTimer(&startTime[gun_index][TMR_IDX_CCS_HEARTBEAT_COUNT_RESET]);
 								}
@@ -5871,13 +5943,12 @@ int main(void)
 						ShmCharger->gun_info[gun_index].isChargerStopByCondition = NO;
 						ShmCharger->gun_info[gun_index].resultAuthorization = DEFAULT_RFID;
 					}
-
 					//if time up, clear CCS MSG count
 					if((ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC) &&
 					   (getDiffSecNow(startTime[gun_index][TMR_IDX_CCS_HEARTBEAT_COUNT_RESET]) > TIMEOUT_SPEC_CCS_HEARTBEAT_COUNT_RESET))
 					{
 						refreshStartTimer(&startTime[gun_index][TMR_IDX_CCS_HEARTBEAT_COUNT_RESET]);
-						if(ShmCharger->gun_info[gun_index].acCcsInfo.CcsHeartBeat > 0)
+						/*if(ShmCharger->gun_info[gun_index].acCcsInfo.CcsHeartBeat > 0)
 						{
 							ShmCharger->gun_info[gun_index].acCcsInfo.CcsHeartBeat = 0;
 						}
@@ -5887,7 +5958,7 @@ int main(void)
 
 							//setChargerMode(gun_index, SYS_MODE_TERMINATING);
 							//setRelay(gun_index, OFF);
-						}
+						}*/
 					}
 
 					if((ShmCharger->gun_info[gun_index].rfidReq == ON) ||
@@ -5900,9 +5971,12 @@ int main(void)
 					   ocpp_get_unlocker_req(gun_index) ||
 					   (ShmSysConfigAndInfo->SysInfo.AcChargingData[gun_index].schedule.isTriggerStop == ON) ||
 					   ((ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC) && (ShmCharger->gun_info[gun_index].acCcsInfo.EVChargeProgress == HLC_STOP_MODE)) ||
-					   ((ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC) && ShmCharger->gun_info[gun_index].acCcsInfo.EVChargeProgress == HLC_RENEGOTIATE_MODE) ||
-					   ((ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC) && ShmCharger->gun_info[gun_index].acCcsInfo.EVChargeProgress == HLC_STANDBY_MODE))
+					   ((ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC) && (ShmCharger->gun_info[gun_index].acCcsInfo.EVChargeProgress == HLC_RENEGOTIATE_MODE)) ||
+					   ((ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC) && (ShmCharger->gun_info[gun_index].acCcsInfo.EVChargeProgress == HLC_STANDBY_MODE)) ||
+					   ((ShmCharger->gun_info[gun_index].chargingMode == CHARGING_MODE_HLC) && ((49 <= ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus) && (ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus <= 255)))		   
+					   )
 					{
+						//printf("EVChargeProgress=0x%x, PresentMsgFlowStatus=0x%x\n",ShmCharger->gun_info[gun_index].acCcsInfo.EVChargeProgress,ShmCharger->gun_info[gun_index].acCcsInfo.PresentMsgFlowStatus);
 						setChargerMode(gun_index, SYS_MODE_TERMINATING);
 					}
 					else

EVSE/Projects/AW-CCS/Apps/main.h

@@ -41,6 +41,9 @@
 #include	<stdint.h>
 #include	<sqlite3.h>
 
+
+#define ENABLE_CCS
+
 //===================================
 // Define Alarm code constant
 //===================================
@@ -203,8 +206,8 @@ enum CHARGING_MODE
 
 enum HLC_MODE
 {
-	HLC_STOP_MODE=0,
-	HLC_START_MODE,
+	HLC_START_MODE=0,
+	HLC_STOP_MODE,
 	HLC_RENEGOTIATE_MODE,
 	HLC_STANDBY_MODE
 };