path: root/positioning/server/src/Sensor/VehicleSens_Thread.cpp

/*
 * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*******************************************************************************
 *  File name    :VehicleSens_Thread.cpp
 *  System name    :GPF
 *  Subsystem name  :Vehicle sensor process
 *  Program name  :Vehicle sensor thread
 *  Module configuration  :VehicleSensThread()          Vehicle Sensor Thread Domain Functions
 *          :VehicleSensThreadInit()        Vehicle sensor thread initials
 *          :VehicleSensDeliveryEntry()      Vehicle sensor information delivery registration
 *          :VehicleSensGetVehicleData()      Vehicle sensor information acquisition
 *          :VehicleSensWatchStopPage()      Vehicle sensor interruption monitoring
 *          :VehicleSensPkgDeliveryEntry()    Vehicle sensor information package delivery registration
 *          :VehicleSensGetVehiclePkgData()    Vehicle sensor information package data acquisition
 *          :VehicleSensLineSensDataDelivery()  LineSensor Vehicle Signal Notification
 *          :VehicleSensGpsDataDelivery()      GPS data notification
 *          :VehicleSens_CanDataDelivery()      CAN data delivery notice
 *          :VehicleSensDataMasterSetN()      Data master set notification process(Callback function)
 *          :VehicleSensSetVehicleData()      GPS command request processing
 ******************************************************************************/
#include "VehicleSens_Thread.h"
#include <vehicle_service/positioning_base_library.h>
#include <other_service/VP_GetEnv.h>
#include "POS_private.h"
#include "positioning_common.h"
#include "SensorLog.h"
#include "VehicleUtility.h"
#include "VehicleSensor_Thread.h"

#include "VehicleIf.h"

/*************************************************/
/*           Global variable                      */
/*************************************************/
static VEHICLE_MSG_BUF      g_wait_for_resp_msg;  /* Message waiting to receive a response */
static PFUNC_DMASTER_SET_N  g_wait_for_resp_set_n;  /* Response waiting data master set */
static BOOL                 g_sent_fst_pkg_delivery_ext; /* Initial expansion package data delivery status */

static VEHICLESENS_VEHICLE_SPEED_INFO g_vehicle_speed_info;

uint32_t gPseudoSecClockCounter = 0u;

/*************************************************/
/*           Function prototype                    */
/*************************************************/
static void VehicleSensInitDataDisrptMonitor(void);
static void VehicleSensDataDisrptMonitorProc(DID did);
static void VehicleSensRcvMsgTout(TimerToutMsg* rcv_msg);

static void VehilceSens_InitVehicleSpeed(void);
static void VehicleSens_StoreVehicleSpeed(VEHICLESENS_VEHICLE_SPEED_DAT* pVehicleSpeed);
static void VehicleSens_LoadVehicleSpeed(VEHICLESENS_VEHICLE_SPEED_INFO* pVehicleSpeedInfo);
static RET_API VehicleSens_CatNmeaSentenceFieldWithDelimiter(char* str1, const size_t size, const char* str2, const size_t n);
static RET_API VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(char* str1, const size_t size, const char* str2, const size_t n);
static inline RET_API VehicleSens_GeneratePASCDFieldId(char* pascd, size_t size);
static inline RET_API VehicleSens_GeneratePASCDFieldTimestamp(char* pascd, size_t size);
static inline RET_API VehicleSens_GeneratePASCDFieldSensorType(char* pascd, size_t size);
static inline RET_API VehicleSens_GeneratePASCDFieldTransmissionState(char* pascd, size_t size);
static inline RET_API VehicleSens_GeneratePASCDFieldSlipDetect(char* pascd, size_t size);
static inline RET_API VehicleSens_GeneratePASCDFieldSampleCount(char* pascd, size_t size);
static inline RET_API VehicleSens_GeneratePASCDFieldTimeOffsetNSpeed(char* pascd, size_t size);
static inline RET_API VehicleSens_GeneratePASCDFieldChecksum(char* pascd, size_t size);
static inline RET_API VehicleSens_GeneratePASCDFieldCRLF(char* pascd, size_t size);
static RET_API VehicleSens_DeriveTransmissionStateFor_CWORD27_(VEHICLESENS_TRANSMISSION_PKG* pPkg);


/*******************************************************************************
* MODULE    : VehicleSensThread
* ABSTRACT  : Vehicle Sensor Thread Domain Functions
* FUNCTION  : Main processing
* ARGUMENT  : lpv_para  :
* NOTE      :
* RETURN    :
******************************************************************************/
EFrameworkunifiedStatus VehicleSensThread(HANDLE h_app) {
    RET_API  ret_api = RET_NORMAL;        /* Return Values of System API Functions  */
    T_APIMSG_MSGBUF_HEADER  *p;          /* Message header      */
    RET_API  ret_val;                /* Return value of initialization processing    */
    VEHICLE_MSG_DELIVERY_ENTRY  delivery_entry;

    static u_int8 msg_buf[MAX_MSG_BUF_SIZE]; /* message buffer  */

    void* p_msg_buf = &msg_buf;
    LSDRV_MSG_LSDATA_G** p_lsdrv_msg;
    VEHICLE_MSG_BUF** p_vehicle_msg;
    POS_MSGINFO *p_pos_msg;



    p_lsdrv_msg = reinterpret_cast<LSDRV_MSG_LSDATA_G**>(&p_msg_buf);
    p_vehicle_msg = reinterpret_cast<VEHICLE_MSG_BUF**>(&p_msg_buf);

    VehicleUtilityInitTimer();
    (void)PosSetupThread(h_app, ETID_POS_MAIN);

    memset(&(delivery_entry), 0, sizeof(VEHICLE_MSG_DELIVERY_ENTRY));

    /* Thread initialization process */
    ret_val = VehicleSensThreadInit();

    gPseudoSecClockCounter = 0u;

    if (RET_NORMAL == ret_val) {  // LCOV_EXCL_BR_LINE 6: always be RET_NORMAL
        while (1) {
            /* Message reception processing */
            p_msg_buf = &msg_buf;
            ret_api = _pb_RcvMsg(PNO_VEHICLE_SENSOR, sizeof(msg_buf), &p_msg_buf, RM_WAIT);

            /* Internal debug log output */
            FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, 
                          "[ret_api = 0x%x]",
                          ret_api);

            /* When the message is received successfully */
            if (ret_api == RET_RCVMSG) {
                p = reinterpret_cast<T_APIMSG_MSGBUF_HEADER *>(p_msg_buf);

                switch (p->hdr.cid) {  // LCOV_EXCL_BR_LINE 200: some DID is not used
                    case CID_VEHICLEIF_DELIVERY_ENTRY:
                    {
                        memcpy(&(delivery_entry), &(p_msg_buf), sizeof(VEHICLE_MSG_DELIVERY_ENTRY));

                        /* Sort by received DID */
                        switch (delivery_entry.data.did) {  // LCOV_EXCL_BR_LINE 200: DR DID is not used
                            case VEHICLE_DID_DR_ALTITUDE :
                            case VEHICLE_DID_DR_LATITUDE :
                            case VEHICLE_DID_DR_SPEED :
                            case VEHICLE_DID_DR_HEADING :
                            case VEHICLE_DID_DR_GYRO_SCALE_FACTOR_LEVEL :
                            case VEHICLE_DID_DR_SPEED_PULSE_SCALE_FACTOR_LEVEL :
                            {
                                // LCOV_EXCL_START 8: dead code
                                AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                                VehicleSensDrDeliveryEntry((const VEHICLE_MSG_DELIVERY_ENTRY *)p_msg_buf);
                                // LCOV_EXCL_STOP
                            }
                            break;
                            default:
                                /* Vehicle sensor information delivery registration */
                                VehicleSensDeliveryEntry((const VEHICLE_MSG_DELIVERY_ENTRY *)p_msg_buf);
                                break;
                        }
                        break;
                    }
                    case CID_VEHICLEIF_GET_VEHICLE_DATA:
                    {
                        /* Vehicle sensor information acquisition */
                        VehicleSensGetVehicleData((const VEHICLE_MSG_GET_VEHICLE_DATA *)p_msg_buf);
                        break;
                    }
                    case CID_LINESENS_VEHICLE_DATA:
                    {
                        /* LineSensor Vehicle Signal Notification */
                        VehicleSensLineSensDataDelivery((const LSDRV_MSG_LSDATA *)p_msg_buf,
                                                          (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN);
                        break;
                    }
                    case CID_LINESENS_VEHICLE_DATA_G:
                    {
                        /* Data disruption monitoring process */
                        VehicleSensDataDisrptMonitorProc(
                            (reinterpret_cast<LSDRV_MSG_LSDATA_G*>(*p_lsdrv_msg))->st_para.st_data[0].ul_did);
                        VehicleSensLineSensDataDeliveryG((const LSDRV_MSG_LSDATA_G *)p_msg_buf,
                                                            (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN);
                        break;
                    }
                    case CID_LINESENS_VEHICLE_DATA_GYRO_TROUBLE:
                    {
                        // LCOV_EXCL_START 8: dead code
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        /* Gyro Failure Status Notification */
                        VehicleSensLineSensDataDeliveryGyroTrouble((const LSDRV_MSG_LSDATA_GYRO_TROUBLE *)p_msg_buf,
                                (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN);
                        break;
                        // LCOV_EXCL_STOP
                    }
                    case CID_LINESENS_VEHICLE_DATA_SYS_GPS_INTERRUPT_SIGNAL:
                    {
                        // LCOV_EXCL_START 8: dead code
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        /* SYS GPS interrupt notification */
                        VehicleSensLineSensDataDeliverySysGpsInterruptSignal(
                            (const LSDRV_MSG_LSDATA_GPS_INTERRUPT_SIGNAL *)p_msg_buf,
                            (PFUNC_DMASTER_SET_SHARED_MEMORY)VehicleSensDataMasterSetSharedMemory);
                        break;
                        // LCOV_EXCL_STOP
                    }
                    case CID_LINESENS_VEHICLE_DATA_GYRO_CONNECT_STATUS:
                    {
                        // LCOV_EXCL_START 8: dead code
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        /* Gyro Failure Status Notification */
                        VehicleSensLineSensDataDeliveryGyroConnectStatus(
                            (const LSDRV_MSG_LSDATA_GYRO_CONNECT_STATUS *)p_msg_buf,
                            (PFUNC_DMASTER_SET_SHARED_MEMORY)VehicleSensDataMasterSetSharedMemory);
                        break;
                        // LCOV_EXCL_STOP
                    }
                    case CID_LINESENS_VEHICLE_DATA_GPS_ANTENNA_STATUS:
                    {
                        // LCOV_EXCL_START 8: dead code
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        /* GPS antenna failure status notification */
                        VehicleSensLineSensDataDeliveryGpsAntennaStatus(
                            (const LSDRV_MSG_LSDATA_GPS_ANTENNA_STATUS *)p_msg_buf,
                            (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN);
                        break;
                        // LCOV_EXCL_STOP
                    }
                    case CID_SENSORIF_PKG_DELIVERY_ENTRY_EXT:
                    {
                        /* Vehicle Sensor Information Extended Package Delivery Registration */
                        VehicleSensPkgDeliveryEntryExt((const SENSOR_MSG_DELIVERY_ENTRY *)p_msg_buf);
                        break;
                    }
                    case CID_LINESENS_VEHICLE_DATA_FST:
                    {
                        /* LineSensor Vehicle Initial Sensor Signal Notification */
                        VehicleSensLineSensDataDeliveryFstG((const LSDRV_MSG_LSDATA_FST *)p_msg_buf,
                                                            (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN);
                        break;
                    }
                    case CID_GPS_DATA:
                    {
                        /* GPS information notification */
                        VehicleSensGpsDataDelivery(reinterpret_cast<SENSOR_MSG_GPSDATA *>(p_msg_buf),
                            (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN,
                            (PFUNC_DMASTER_SET_SHARED_MEMORY)VehicleSensDataMasterSetSharedMemory);
                        break;
                    }
                    case CID_POSIF_SET_DATA:
                    {
                        p_pos_msg =
                        reinterpret_cast<POS_MSGINFO*>((reinterpret_cast<VEHICLE_MSG_BUF*>(*p_vehicle_msg))->data);
                        /* Data disruption monitoring process */
                        VehicleSensDataDisrptMonitorProc(p_pos_msg->did);

                        /* Data Setting Notification */
                        VehicleSensCommonDataDelivery((const VEHICLE_MSG_BUF *)p_msg_buf,
                                                      (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN);
                        break;
                    }
                    case CID_GPS_RETTIMESETTING:
                    {
                        /* GPS time setting result notification */
                        VehicleSensGpsTimeDelivery((const VEHICLE_MSG_BUF *)p_msg_buf);
                        break;
                    }
                    case CID_DEAD_RECKONING_GPS_DATA :  /* GPS data distribution for DR */
                    case CID_DEAD_RECKONING_SENS_DATA :  /* Sensor Data Delivery for DR */
                    case CID_DEAD_RECKONING_SENS_FST_DATA :  /* Initial Sensor Data Delivery for DR */
                    {
                        // LCOV_EXCL_START 8: dead code
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        VehicleSensDrRcvMsg((const DEAD_RECKONING_RCVDATA *)p_msg_buf);
                        break;
                        // LCOV_EXCL_STOP
                    }
                    case CID_VEHICLEIF_GET_DR_DATA :
                    {
                        // LCOV_EXCL_START 8: dead code
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        /* Vehicle sensor information acquisition */
                        DeadReckoningGetDRData((const DEADRECKONING_MSG_GET_DR_DATA *)p_msg_buf);
                        break;
                        // LCOV_EXCL_STOP
                    }
                    case CID_DR_MAP_MATCHING_DATA :  /* Map matching information */
                    {
                        // LCOV_EXCL_START 8: dead code
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        DeadReckoningSetMapMatchingData((const DR_MSG_MAP_MATCHING_DATA *)p_msg_buf);
                        break;
                        // LCOV_EXCL_STOP
                    }
                    case CID_DR_CLEAR_BACKUP_DATA :  /* Clear backup data */
                    {
                        // LCOV_EXCL_START 8: dead code
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        DeadReckoningClearBackupData((const DR_MSG_CLEAR_BACKUP_DATA*)p_msg_buf);
                        break;
                        // LCOV_EXCL_STOP
                    }
                    case CID_VEHICLEDEBUG_LOG_GET : /* Log acquisition request */
                    {
                        // LCOV_EXCL_START 8: dead code
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        VehicleSensGetLog((const VEHICLEDEBUG_MSG_BUF *)p_msg_buf);
                        break;
                        // LCOV_EXCL_STOP
                    }
                    case CID_VEHICLEDEBUG_LOG_SET :  /* Log Setting Request */
                    {
                        // LCOV_EXCL_START 8: dead code
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        VehicleSensSetLog((const VEHICLEDEBUG_MSG_BUF *)p_msg_buf);
                        break;
                        // LCOV_EXCL_STOP
                    }
                    case CANINPUT_CID_LOCALTIME_NOTIFICATION : /* CAN information acquisition */
                    {
                        // LCOV_EXCL_START 8: dead code
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        VehicleSensWriteLocalTime((const CANINPUT_MSG_INFO*)p_msg_buf);
                        break;
                        // LCOV_EXCL_STOP
                    }
                    case CID_EPH_NUM_NOTIFICATION :  /* Set effective ephemeris count at shutdown */
                    {
                        // LCOV_EXCL_START 8: dead code
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        VehicleSensSetEphNumSharedMemory((const SENSOR_MSG_GPSDATA *)p_msg_buf);
                        break;
                        // LCOV_EXCL_STOP
                    }
                    case CID_SENSORIF__CWORD82__REQUEST:
                    {
                        // LCOV_EXCL_START 8: dead code
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        /* Requests to send GPS _CWORD82_ commands */
                        VehicleSensSetVehicleData((const VEHICLE_MSG_SEND *)p_msg_buf);
                        break;
                        // LCOV_EXCL_STOP
                    }
                    case CID_THREAD_STOP_REQ:
                    {
                        /* Thread stop processing */
                        VehicleSensThreadStopProcess();
                        break;
                    }
                    case CID_TIMER_TOUT:
                    {
                        /* Timeout notification reception processing */
                        VehicleSensRcvMsgTout(reinterpret_cast<TimerToutMsg*>(p_msg_buf));
                        break;
                    }
                    default:
                        break;
                }
            } else {
                FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "ret_api != RET_RCVMSG\r\n");
            }
        }
    } else {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "VehicleSens: VehicleSens_MainThread Initial Error!! :%d", ret_val);
        _pb_Exit();
    }

    return eFrameworkunifiedStatusOK;
}

/*******************************************************************************
* MODULE    : VehicleSensThreadInit
* ABSTRACT  : Vehicle sensor thread initials
* FUNCTION  : Initial process
* ARGUMENT  : void
* NOTE      :
* RETURN    : CAN data delivery registration result
******************************************************************************/
RET_API VehicleSensThreadInit(void) {
    RET_API    ret_val = RET_NORMAL;

    /* Initialization of Vehicle Selection Item List Table */
    VehicleSensInitSelectionItemList();

    /* Vehicle sensor data master initialization */
    VehicleSensInitDataMaster();

    /* Initialization of shipping destination management table */
    VehicleSensInitDeliveryCtrlTbl();

    /* Initialization of shipping destination management table management information */
    VehicleSensInitDeliveryCtrlTblMng();

    /* Initialization of package delivery management table */
    VehicleSensInitPkgDeliveryTblMng();

    /* Initialization of non-volatile access function block */
    VehicleSensFromAccessInitialize();

    /* Clear message information waiting to receive a response */
    (void)memset(&g_wait_for_resp_msg, 0x00, sizeof(VEHICLE_MSG_BUF));
    g_wait_for_resp_set_n = NULL;
    g_sent_fst_pkg_delivery_ext = FALSE; /* Initial expansion package data undelivered */

    VehilceSens_InitVehicleSpeed(); /* for PASCD */

    /* Start of data interruption monitoring */
    VehicleSensInitDataDisrptMonitor();
    return ret_val;
}

/*******************************************************************************
 * MODULE    : VehicleSensDeliveryEntry
 * ABSTRACT  : Vehicle sensor information delivery registration
 * FUNCTION  :
 * ARGUMENT  : *msg  : message buffer
 * NOTE      :
 * RETURN    : void
 ******************************************************************************/
void VehicleSensDeliveryEntry(const VEHICLE_MSG_DELIVERY_ENTRY *msg) {
    int32  event_val;
    EventID  event_id;

    /* Call the process of creating the delivery destination management table */
    event_val = static_cast<int32>(VehicleSensEntryDeliveryCtrl(msg));

    /* Internal debug log output */
    FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "+");

    /* Event Generation */
    event_id = VehicleCreateEvent(msg->data.pno);

    /* Publish Events */
    (void)_pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, event_val);

    if (VEHICLE_RET_NORMAL == event_val) {
        /* Successful delivery registration */
        /* Deliver data for the first time */
        VehicleSensFirstDelivery((PNO)(msg->data.pno), (DID)(msg->data.did));
    }

    /* Event deletion */
    (void)VehicleDeleteEvent(event_id);

    /* Internal debug log output */
    FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "-");
}

/*******************************************************************************
* MODULE    : VehicleSensGetVehicleData
* ABSTRACT  : Vehicle sensor information acquisition
* FUNCTION  :
* ARGUMENT  : *msg  : message buffer
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensGetVehicleData(const VEHICLE_MSG_GET_VEHICLE_DATA *msg) {
    void    *share_top;            /* Start address of shared memory */
    u_int32    share_size;          /* Size of shared memory area */
    u_int8    get_method;          /* Data collection way */
    VEHICLESENS_DATA_MASTER    master;    /* Data master */
    RET_API    ret_api;
    int32    ret_val;
    int32    event_val;
    EventID    event_id;
    SENSOR_MSG_GPSDATA_DAT    gps_master;  /* GPS Data Master */

    /* Check the DID */
    ret_val = VehicleSensCheckDid(msg->data.did);
    if (VEHICLESENS_INVALID != ret_val) {  // LCOV_EXCL_BR_LINE 6:did always valid
        /* DID normal */

        /* Link to shared memory */
        ret_api = _pb_LinkShareData(const_cast<char *>(VEHICLE_SHARE_NAME), &share_top, &share_size);
        if (RET_NORMAL == ret_api) {
            /* Acquire the specified data from the data master. */
            get_method = VehicleSensGetSelectionItemList(msg->data.did);
            if ((VEHICLESENS_GETMETHOD_GPS == get_method) &&
                ((msg->data.did != VEHICLE_DID_LOCATION_LONLAT)   &&
                (msg->data.did != VEHICLE_DID_LOCATION_ALTITUDE) &&
                (msg->data.did != VEHICLE_DID_MOTION_HEADING))) {
                /* _CWORD71_ processing speed(Memset modification) */
                /* Retrieval of the data master fails.,Initialize size to 0 to prevent unauthorized writes */
                gps_master.us_size = 0;
                VehicleSensGetGpsDataMaster(msg->data.did, get_method, &gps_master);
                /* Check the data size */
                if (msg->data.size < gps_master.us_size) {
                    /* Shared memory error(Insufficient storage size) */
                    event_val = VEHICLE_RET_ERROR_OUTOF_MEMORY;
                } else {
                    /* Write data master to shared memory */
                    PosSetShareData(share_top,
                                    msg->data.offset, (const void *)&gps_master.uc_data, gps_master.us_size);

                    /* Set Successful Completion */
                    event_val = VEHICLE_RET_NORMAL;
                    SensLogWriteOutputData(SENSLOG_DATA_O_UNSPECIFIED,
                                            msg->data.did, msg->data.pno,
                                            reinterpret_cast<uint8_t *>(&(gps_master.uc_data[0])),
                                            gps_master.us_size, SENSLOG_RES_SUCCESS);
                }
            } else {
                (void)memset(reinterpret_cast<void *>(&master), 0, sizeof(VEHICLESENS_DATA_MASTER));
                VehicleSensGetDataMaster(msg->data.did, get_method, &master);

                /* Check the data size */
                if (msg->data.size < master.us_size) {
                    /* Shared memory error(Insufficient storage size) */
                    event_val = VEHICLE_RET_ERROR_OUTOF_MEMORY;
                } else {
                    /* Write data master to shared memory */
                    PosSetShareData(share_top,
                                    msg->data.offset, (const void *)master.uc_data, master.us_size);

                    /* Set Successful Completion */
                    event_val = VEHICLE_RET_NORMAL;
                    SensLogWriteOutputData(SENSLOG_DATA_O_UNSPECIFIED,
                                            msg->data.did, msg->data.pno,
                                            reinterpret_cast<uint8_t *>(&(master.uc_data[0])),
                                            master.us_size, SENSLOG_RES_SUCCESS);
                }
            }
        } else {
            /* Shared memory error */
            event_val = VEHICLE_RET_ERROR_OUTOF_MEMORY;
        }
    } else {
        /* DID error */
        event_val = VEHICLE_RET_ERROR_DID;
    }

    /* Event Generation */
    event_id = VehicleCreateEvent(msg->data.pno);

    /* Publish Events */
    ret_api = _pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, event_val);
    if (RET_NORMAL != ret_api) {
        /* Event issuance failure */
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_SetEvent ERROR!! [ret_api = %d]", ret_api);
    }

    /* Event deletion */
    (void)VehicleDeleteEvent(event_id);

    return;
}

/*******************************************************************************
* MODULE    : VehicleSensWatchStopPage
* ABSTRACT  : Vehicle sensor interruption monitoring
* FUNCTION  :
* ARGUMENT  : *msg  : message buffer
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensWatchStopPage(const VEHICLE_MSG_WATCH_STOPPAGE *msg) {  // LCOV_EXCL_START 8 : dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    /* Not used(Delete Used Functions After Investigation) */
}
// LCOV_EXCL_STOP

/*******************************************************************************
* MODULE    : VehicleSensPkgDeliveryEntry
* ABSTRACT  : Vehicle sensor information package delivery registration
* FUNCTION  :
* ARGUMENT  : *msg  : message buffer
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensPkgDeliveryEntry(const SENSOR_MSG_DELIVERY_ENTRY *msg) {  // LCOV_EXCL_START 8 : dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    int32  event_val;
    EventID  event_id;

    /* Call the process of creating the delivery destination management table */
    event_val = static_cast<int32>(VehicleSensEntryPkgDeliveryCtrl(msg , VEHICLESENS_EXT_OFF));
    /* #Polaris_003 */

    /* Event Generation */
    event_id = PosCreateEvent(msg->data.pno);

    /* Publish Events */
    (void)_pb_SetEvent(msg->data.event_id, SAPI_EVSET_ABSOLUTE, event_val);

    if (VEHICLE_RET_NORMAL == event_val) {
        /* Successful delivery registration */
        /* Deliver package data for the first time */
        VehicleSensFirstPkgDelivery(&msg->data);
    }

    /* Event deletion */
    (void)PosDeleteEvent(event_id);
}
// LCOV_EXCL_STOP

#if CONFIG_SENSOR_EXT_VALID        /* Initial Sensor Support */
/*******************************************************************************
* MODULE    : VehicleSensPkgDeliveryEntryExt
* ABSTRACT  : Vehicle Sensor Information Extended Package Delivery Registration
* FUNCTION  :
* ARGUMENT  : *msg  : message buffer
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensPkgDeliveryEntryExt(const SENSOR_MSG_DELIVERY_ENTRY *msg) {
    int32  event_val;

    /* Internal debug log output */
    FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "+");

    /* Call the process of creating the delivery destination management table */
    event_val = static_cast<int32>(VehicleSensEntryPkgDeliveryCtrl(msg , VEHICLESENS_EXT_ON));

    /* Event Generation */
    (void)PosCreateEvent(msg->data.pno);

    /* Publish Events */
    (void)_pb_SetEvent(msg->data.event_id, SAPI_EVSET_ABSOLUTE, event_val);

    if (VEHICLE_RET_NORMAL == event_val) {
        /* Successful delivery registration */
        /* Provide initial expansion package data delivery */
        VehicleSensFirstPkgDeliveryExt(&msg->data);

        /* Initial expansion package data delivered */
        g_sent_fst_pkg_delivery_ext = TRUE;

        FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, 
                      "FirstPkgDeliveryExt call.[%d]",
                      g_sent_fst_pkg_delivery_ext); /* TODO */
    }

    /* Internal debug log output */
    FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "-");
}

#else
/*******************************************************************************
* MODULE    : VehicleSensPkgDeliveryEntryError
* ABSTRACT  : Vehicle Sensor Information Extended Package Delivery Registration
* FUNCTION  :
* ARGUMENT  : *msg  : message buffer
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensPkgDeliveryEntryError(const SENSOR_MSG_DELIVERY_ENTRY *msg) {
    RET_API  ret_api;
    EventID  event_id;

    /* Event Generation */
    event_id = PosCreateEvent(msg->data.pno);

    /* Publish Event Set DID Error */
    ret_api = _pb_SetEvent(msg->data.event_id, SAPI_EVSET_ABSOLUTE, VEHICLE_RET_ERROR_DID);
}

#endif

/*******************************************************************************
* MODULE    : VehicleSensGetVehiclePkgData
* ABSTRACT  : Vehicle sensor information package data acquisition
* FUNCTION  :
* ARGUMENT  : *msg  : message buffer
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensGetVehiclePkgData(const SENSOR_MSG_GET_SENSOR_DATA *msg) {  // LCOV_EXCL_START 8 : dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
}
// LCOV_EXCL_STOP

/*******************************************************************************
* MODULE    : VehicleSensLineSensDataDelivery
* ABSTRACT  : LineSensor Vehicle Signal Notification
* FUNCTION  :
* ARGUMENT  : *msg      : message buffer
*           : p_datamaster_set_n  : Data Master Set Notification(Callback function)
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensLineSensDataDelivery(const LSDRV_MSG_LSDATA *msg, PFUNC_DMASTER_SET_N p_datamaster_set_n) {
    int32  i;
    BOOL  sens_ext;

    sens_ext = TRUE;

    for (i = 0; i < msg->st_para.uc_data_num; i++) {
        /* Setting Vehicle Signal Data from LineSensor as Data Master */
        VehicleSensSetDataMasterLineSens((const LSDRV_LSDATA *) & (msg->st_para.st_data[i]),
                                          p_datamaster_set_n, sens_ext);
    }
}

/*******************************************************************************
* MODULE    : VehicleSensLineSensDataDeliveryG
* ABSTRACT  : LineSensor Vehicle Signal Notification
* FUNCTION  :
* ARGUMENT  : *msg      : message buffer
*           : p_datamaster_set_n  : Data Master Set Notification(Callback function)
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensLineSensDataDeliveryG(const LSDRV_MSG_LSDATA_G *msg, PFUNC_DMASTER_SET_N p_datamaster_set_n) {
    int32  i;
    BOOL  sens_ext;

    sens_ext = TRUE;
    if (g_sent_fst_pkg_delivery_ext == TRUE) {
        /* Initial Expansion Package Data Delivery,Without storing extended data */
        sens_ext = FALSE;
    }

    for (i = 0; i < msg->st_para.uc_data_num; i++) {
        /* Setting Vehicle Signal Data from LineSensor as Data Master */
        VehicleSensSetDataMasterLineSensG((const LSDRV_LSDATA_G *) & (msg->st_para.st_data[i]),
                                              p_datamaster_set_n, sens_ext);
    }
}

/*******************************************************************************
* MODULE    : VehicleSensLineSensDataDeliveryGyroTrouble
* ABSTRACT  : Gyro Failure Status Notification
* FUNCTION  : Notify of a gyro failure condition
* ARGUMENT  : *msg      : message buffer
*           : p_datamaster_set_n  : Data Master Set Notification(Callback function)
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensLineSensDataDeliveryGyroTrouble(const LSDRV_MSG_LSDATA_GYRO_TROUBLE *msg, PFUNC_DMASTER_SET_N p_datamaster_set_n) {  // LCOV_EXCL_START 8 : dead code  // NOLINT(whitespace/line_length)
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    /* Setting Gyro Failure Status Data from LineSensor to Data Master */
    VehicleSensSetDataMasterGyroTrouble((const LSDRV_MSG_LSDATA_DAT_GYRO_TROUBLE *)&(msg->st_para),
                                           p_datamaster_set_n);
}
// LCOV_EXCL_STOP

/*******************************************************************************
* MODULE    : VehicleSensLineSensDataDeliverySysGpsInterruptSignal
* ABSTRACT  : SYS GPS interrupt notification
* FUNCTION  : Notify SYS GPS interrupt signals
* ARGUMENT  : *msg            : message buffer
*           : p_datamaster_set_sharedmemory  : Data Master Set Notification(Callback function)
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensLineSensDataDeliverySysGpsInterruptSignal(const LSDRV_MSG_LSDATA_GPS_INTERRUPT_SIGNAL *msg, PFUNC_DMASTER_SET_SHARED_MEMORY p_datamaster_set_sharedmemory) {  // LCOV_EXCL_START 8 :dead code  // NOLINT(whitespace/line_length)
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    /* Sets the SYS GPS interrupt data from the LineSensor to the data master. */
    VehicleSensSetDataMasterSysGpsInterruptSignal((const LSDRV_MSG_LSDATA_DAT_GPS_INTERRUPT_SIGNAL *)&(msg->st_para),
                                                    p_datamaster_set_sharedmemory);
}
// LCOV_EXCL_STOP

/*******************************************************************************
* MODULE    : VehicleSensLineSensDataDeliveryGyroConnectStatus
* ABSTRACT  : Gyro Connection Status Notification
* FUNCTION  : Notify the state of the gyro connection
* ARGUMENT  : *msg            : message buffer
*           : p_datamaster_set_sharedmemory  : Data Master Set Notification(Callback function)
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensLineSensDataDeliveryGyroConnectStatus(const LSDRV_MSG_LSDATA_GYRO_CONNECT_STATUS *msg, PFUNC_DMASTER_SET_SHARED_MEMORY p_datamaster_set_sharedmemory) {  // LCOV_EXCL_START 8 : dead code  // NOLINT(whitespace/line_length)
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    /* Setting Gyro Connection Status Data from LineSensor to Data Master */
    VehicleSensSetDataMasterGyroConnectStatus((const LSDRV_MSG_LSDATA_DAT_GYRO_CONNECT_STATUS *)&(msg->st_para),
                                                p_datamaster_set_sharedmemory);
}
// LCOV_EXCL_STOP

/*******************************************************************************
* MODULE    : VehicleSensLineSensDataDeliveryGpsAntennaStatus
* ABSTRACT  : GPS Antenna Connection Status Notification
* FUNCTION  : Notify the GPS antenna connection status
* ARGUMENT  : *msg      : message buffer
*           : p_datamaster_set_n  : Data Master Set Notification(Callback function)
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensLineSensDataDeliveryGpsAntennaStatus(const LSDRV_MSG_LSDATA_GPS_ANTENNA_STATUS *msg, PFUNC_DMASTER_SET_N p_datamaster_set_n) {  // LCOV_EXCL_START 8 : dead code  // NOLINT(whitespace/line_length)
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    /* Setting GPS Antenna Connection Status Data from LineSensor as Data Master */
    VehicleSensSetDataMasterGpsAntennaStatus((const LSDRV_MSG_LSDATA_DAT_GPS_ANTENNA_STATUS *)&(msg->st_para),
                                               p_datamaster_set_n);
}
// LCOV_EXCL_STOP

#if CONFIG_SENSOR_EXT_VALID        /* Initial Sensor Support */
/*******************************************************************************
* MODULE    : VehicleSensLineSensDataDeliveryFst
* ABSTRACT  : LineSensor Vehicle Signal Notification(Initial Sensor)
* FUNCTION  :
* ARGUMENT  : *msg      : message buffer
*           : p_datamaster_set_n  : Data Master Set Notification(Callback function)
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensLineSensDataDeliveryFst(const LSDRV_MSG_LSDATA_FST *msg, PFUNC_DMASTER_SET_N p_datamaster_set_n) {  // LCOV_EXCL_START 8 : dead code  // NOLINT(whitespace/line_length)
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
}
// LCOV_EXCL_STOP
#endif

#if CONFIG_SENSOR_EXT_VALID        /* Initial Sensor Support */
/*******************************************************************************
* MODULE    : VehicleSensLineSensDataDeliveryFstG
* ABSTRACT  : LineSensor Vehicle Signal Notification(Initial Sensor)
* FUNCTION  :
* ARGUMENT  : *msg      : message buffer
*           : p_datamaster_set_n  : Data Master Set Notification(Callback function)
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensLineSensDataDeliveryFstG(const LSDRV_MSG_LSDATA_FST *msg, PFUNC_DMASTER_SET_N p_datamaster_set_n) {
    /* Internal debug log output */
    FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "+");

    if (msg == NULL) {  // LCOV_EXCL_BR_LINE 6:msg cannot be null
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "msg == NULL\r\n");  // LCOV_EXCL_LINE 8: dead code
    } else {
        /* Set Vehicle Signal Data from LineSensor (Initial Sensor) as Data Master */
        VehicleSensSetDataMasterLineSensFstG((const LSDRV_MSG_LSDATA_DAT_FST *) & (msg->st_para),
                p_datamaster_set_n);
    }

    /* Internal debug log output */
    FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "-");
}
#endif

/*******************************************************************************
* MODULE    : VehicleSensGpsDataDelivery
* ABSTRACT  : GPS data notification
* FUNCTION  :
* ARGUMENT  : *msg            : message buffer
*           : p_datamaster_set_n        : For Data Master Set Notification(Callback function) delivery
*           : p_datamaster_set_sharedmemory  : Data Master Set Notification (Callback Function) Shared Memory Write
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensGpsDataDelivery(SENSOR_MSG_GPSDATA *msg,
                                PFUNC_DMASTER_SET_N p_datamaster_set_n,
                                PFUNC_DMASTER_SET_SHARED_MEMORY p_datamaster_set_sharedmemory) {
    /* Setting GPS Data as Data Master */
    if (msg->st_para.ul_did == VEHICLE_DID_MAIN_GPS_INTERRUPT_SIGNAL) {  // LCOV_EXCL_BR_LINE 6:DID is not used
        // LCOV_EXCL_START 8: dead code
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        /* [PastModel002 Specifications] GPS->_CWORD102_ interrupt or not is obtained from GPS */
        VehicleSensSetDataMasterMainGpsInterruptSignal((const SENSOR_MSG_GPSDATA_DAT *)&(msg->st_para),
                                                         p_datamaster_set_sharedmemory);
        // LCOV_EXCL_STOP
    } else {
        FRAMEWORKUNIFIEDLOG(ZONE_27, __FUNCTION__, 
                      "VehicleSensGpsDataDelivery VehicleSensSetDataMasterGps() -->");
        VehicleSensSetDataMasterGps(reinterpret_cast<SENSOR_MSG_GPSDATA_DAT *>(&(msg->st_para)),
                                      p_datamaster_set_n);
        FRAMEWORKUNIFIEDLOG(ZONE_27, __FUNCTION__, 
                      "VehicleSensGpsDataDelivery VehicleSensSetDataMasterGps() <--");
    }
}

/*******************************************************************************
* MODULE    : VehicleSensDataMasterSetN
* ABSTRACT  : Data master set notification process(Callback function)
* FUNCTION  : Call the data delivery process
* ARGUMENT  : did    : Data ID
*           : chg_type  : Change type(no change/with change)
*           : get_method  : Acquisition method(Direct Line/CAN)
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensDataMasterSetN(DID did, u_int8 chg_type, u_int8 get_method) {

  u_int8 chgType;

  chgType = chg_type;

  switch (did) {
    case POSHAL_DID_SPEED_KMPH:
    {
      if (ChkUnitType(UNIT_TYPE_GRADE1) == TRUE) {
        /* For creating PASCD Sentence of NMEA */

        int ret;
        VEHICLESENS_VEHICLE_SPEED_DAT stVehicleSpeed;

        ret = clock_gettime(CLOCK_MONOTONIC, &(stVehicleSpeed.ts));
        if (ret != 0) {
          FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "clock_gettime error:%m");
        } else {
          VEHICLESENS_DATA_MASTER stData;
          SENSORMOTION_SPEEDINFO_DAT* pSpdInfo;

          VehicleSensGetMotionSpeed(&stData, VEHICLESENS_GETMETHOD_INTERNAL);  // LCOV_EXCL_BR_LINE 6:unexpected branch  //NOLINT (whitespace/line_length)
          pSpdInfo = (SENSORMOTION_SPEEDINFO_DAT*)(stData.uc_data);

          stVehicleSpeed.speed = pSpdInfo->Speed;

          VehicleSens_StoreVehicleSpeed(&stVehicleSpeed);  // LCOV_EXCL_BR_LINE 6:unexpected branch  //NOLINT (whitespace/line_length)
        }
      }

      break;
    }
    case POSHAL_DID_GPS_NMEA:
    {
      VehilceSens_InitVehicleSpeed();

      break;
    }
    default:
      break;
  }

  /* Call the data delivery process */
  VehicleSensDeliveryProc( did, chgType, get_method );
}

/*******************************************************************************
* MODULE    : VehicleSensDataMasterSetSharedMemory
* ABSTRACT  : Data master set notification process(Callback function)
* FUNCTION  : Call Write Shared Memory
* ARGUMENT  : did    : Data ID
*           : chg_type  : Whether or not data is updated
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensDataMasterSetSharedMemory(DID did, u_int8 chg_type) {  // LCOV_EXCL_START 8: dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    /* When there is no change, the shared memory write process is not called. */
    if (chg_type == VEHICLESENS_NEQ) {
        VehicleSensWriteSharedMemory(did);
    }
}
// LCOV_EXCL_STOP

/* ++ GPS _CWORD82_ support */
/*******************************************************************************
* MODULE    : VehicleSensSetVehicleData
* ABSTRACT  : GPS command request processing
* FUNCTION  : Transfer a GPS command request
* ARGUMENT  : *msg  : message buffer
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensSetVehicleData(const VEHICLE_MSG_SEND *msg) {
    u_int16    size;            /* Data length setting          */
    u_int16    all_len;          /* Sent message length          */
    u_int16    mode;            /* Mode information            */
    RID      req_id = 0;          /* Resources ID            */

    T_APIMSG_MSGBUF_HEADER  header;      /* Message header          */
    TG_GPS_SND_DATA      data;      /* Message body          */
    u_int8  snd_buf[(sizeof(T_APIMSG_MSGBUF_HEADER) + sizeof(TG_GPS_SND_DATA))];

    /* Message header generation */
    size = sizeof(data);
    header.signo = 0;            /* Signal information        */
    header.hdr.sndpno = PNO_VEHICLE_SENSOR;  /* Source thread number      */
    header.hdr.respno = 0;          /* Destination process No.      */
    header.hdr.cid = CID_GPS__CWORD82__REQUEST;  /* Command ID          */
    header.hdr.msgbodysize = size;      /* Message data length setting    */
    header.hdr.rid = req_id;          /* Resource ID Setting        */
    header.hdr.reserve = 0;          /* Reserved Area Clear      */

    /* Message body generating */
    data.us_size = msg->data.size;
    memcpy(&(data.ub_data[0]), &(msg->data.data[0]), msg->data.size);

    /* Reserved Area Clear      */
    data.reserve[0] = 0;
    data.reserve[1] = 0;
    data.reserve[2] = 0;
    data.reserve[3] = 0;

    /* Message generation */
    (void)memcpy(&snd_buf[0], &header, sizeof(header));
    (void)memcpy(&snd_buf[sizeof(header)], &data, sizeof(data));
    all_len = static_cast<u_int16>(size + sizeof(header));
    mode    = 0;

    FRAMEWORKUNIFIEDLOG(ZONE_27, __FUNCTION__, "VehicleSensSetVehicleData NMEA = %s", data.ub_data);
    (void)_pb_SndMsg(PNO_NAVI_GPS_MAIN, all_len, reinterpret_cast<void *>(&snd_buf[0]), mode);
}

/*******************************************************************************
 * MODULE    : VehicleSensDrDeliveryEntry
 * ABSTRACT  : Sensor Internal Information Delivery Registration for DR
 * FUNCTION  :
 * ARGUMENT  : *msg  : message buffer
 * NOTE      :
 * RETURN    : void
 ******************************************************************************/
void VehicleSensDrDeliveryEntry(const VEHICLE_MSG_DELIVERY_ENTRY *msg) {  // LCOV_EXCL_START 8 : dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    int32  event_val;
    EventID  event_id;

    /* Call the process of creating the delivery destination management table */
    event_val = static_cast<int32>(DeadReckoningEntryDeliveryCtrl((const DEADRECKONING_MSG_DELIVERY_ENTRY*)msg));
    /* #QAC confirmation Rule11.4 Member reference to suppress address reference error in data R/W */

    /* Event Generation */
    event_id = VehicleCreateEvent(msg->data.pno);

    /* Publish Events */
    (void)_pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, event_val);

    if (VEHICLE_RET_NORMAL == event_val) {
        /* Successful delivery registration */
        /* Deliver data for the first time */
        DeadReckoningFirstDelivery((PNO)(msg->data.pno), (DID)(msg->data.did));
    }
}
// LCOV_EXCL_STOP

/*******************************************************************************
 * MODULE    : VehicleSensGetLog
 * ABSTRACT  : Log acquisition request
 * FUNCTION  :
 * ARGUMENT  : *msg  : message buffer
 * NOTE      :
 * RETURN    : void
 ******************************************************************************/
void VehicleSensGetLog(const VEHICLEDEBUG_MSG_BUF *msg) {  // LCOV_EXCL_START 8 : dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    DeadReckoningGetLocationLogStatus(msg->hdr.hdr.sndpno);
}
// LCOV_EXCL_STOP

/*******************************************************************************
 * MODULE    : VehicleSensSetLog
 * ABSTRACT  : Log Setting Request
 * FUNCTION  :
 * ARGUMENT  : *msg  : message buffer
 * NOTE      :
 * RETURN    : void
 ******************************************************************************/
void VehicleSensSetLog(const VEHICLEDEBUG_MSG_BUF* msg) {  // LCOV_EXCL_START 8 : dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    return;
}
// LCOV_EXCL_STOP

/*******************************************************************************
 * MODULE    : VehicleSensWriteLocalTime
 * ABSTRACT  : Set LOCALTIME to non-volatile
 * FUNCTION  :
 * ARGUMENT  : *msg  : message buffer
 * NOTE      :
 * RETURN    : void
 ******************************************************************************/
void VehicleSensWriteLocalTime(const CANINPUT_MSG_INFO *msg) {  // LCOV_EXCL_START 8 : dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    LOCALTIME  localtime = {0};
    int32    time_diff;
    RET_API    ret_write_api;
    static u_int8 cnt = 0U;    /* For update cycle count */
    if (msg != NULL) {
        memset(&time_diff, 0x00, sizeof(time_diff));  /* Coverity CID:18813 compliant */

        /* Determine that the 1s cycle (cnt == 1) has elapsed for 1 second.  */
        cnt++;

        /* When 5 seconds or more have elapsed since the last update    */
        /* Saving Time Information in Non-volatile Memory      */
        if (cnt >= NV_UPDATE_CYCLE_LOCALTIME) {
            /* Non-volatile write */
            ret_write_api = VehicleSensWriteNVLocaltime(&localtime, &time_diff);
            if (ret_write_api != RET_NORMAL) {
                FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "NV write error.");
            }
            cnt = 0U;
        }
    } else {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "ARGUMENT NULL");
    }
}
// LCOV_EXCL_STOP

/*******************************************************************************
* MODULE    : VehicleSensSetEphNumSharedMemory
* ABSTRACT  : Write effective ephemeris number to shared memory
* FUNCTION  :
* ARGUMENT  : *msg  : message buffer
* NOTE      :
* RETURN    : void
******************************************************************************/
void VehicleSensSetEphNumSharedMemory(const SENSOR_MSG_GPSDATA *msg) {  // LCOV_EXCL_START 8 : dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    RET_API    ret_api;
    u_int8    ephemeris_num;

    if (msg != NULL) {
        ephemeris_num = msg->st_para.uc_data[0];

        ret_api = VehicleSensWriteDataValidEphemerisNum(ephemeris_num);

        if (ret_api != RET_NORMAL) {
            FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Share Memory write error.");
        }
    }

    return;
}
// LCOV_EXCL_STOP

/*******************************************************************************
* MODULE    : VehicleSensDrRcvMsg
* ABSTRACT  : Data delivery for DR,Write location information to shared memory
* FUNCTION  :
* ARGUMENT  : const EPHEMERIS_NUM_DATA_DAT * : Incoming message
* NOTE      :
* RETURN    : void
******************************************************************************/
void  VehicleSensDrRcvMsg(const DEAD_RECKONING_RCVDATA * msg) {  // LCOV_EXCL_START 8 : dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    DEAD_RECKONING_LONLAT_INFO lonlat_info;

    if (msg != NULL) {
        DeadReckoningRcvMsg(msg, &lonlat_info);

        /* Process for storing location information in non-volatile memory during shutdown    */
        /* With a refresh interval of 1 second,Save only when location information is valid data    */
        if (lonlat_info.calc_called == TRUE) {
            static u_int8 cnt = 0U;  /* For update cycle count */

            /* Sensor data is 100ms cycle,Determine that (cnt == 10) has elapsed for 1 second  */
            /* Cnt increments to 10                  */
            if (cnt < NV_UPDATE_CYCLE_LONLAT) {
                cnt++;
            }

            /* When 1 second or more has elapsed since the last update and the location information is valid,    */
            /* Saving Location Information in Non-Volatile Memory                  */
            if ((cnt >= NV_UPDATE_CYCLE_LONLAT) && (lonlat_info.available == static_cast<u_int8>(TRUE))) {
                VehicleSensStoreLonlat(&(lonlat_info.lonlat));
                cnt = 0U;
            }
        }
    } else {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "ARGUMENT NULL");
    }

    return;
}
// LCOV_EXCL_STOP

/**
 * @brief
 *  Data setting process
 *
 *  Setting Specified Data to Data Master
 *
 * @param[in]   const VEHICLE_MSG_BUF *msg       : message buffer
 * @param[out]  PFUNC_DMASTER_SET_N p_datamaster_set_n : Data Master Set Notification(Callback function)
 * @return      none
 * @retval      none
 */
void VehicleSensCommonDataDelivery(const VEHICLE_MSG_BUF *msg, PFUNC_DMASTER_SET_N p_datamaster_set_n) {
    const POS_MSGINFO  *pstPosMsg = (const POS_MSGINFO *) & (msg->data[0]);

    /* Individual processing for each data ID */
    switch (pstPosMsg->did) {
        case VEHICLE_DID_SETTINGTIME:
        {
            /* By checking the evacuation message information,Determine whether the GPS time has already been set and requested */
            if (NULL == g_wait_for_resp_set_n) {
                /* GPS time settable */
                /* GPS time setting data transmission */
                VehicleSensGpsTimeSndMsg(pstPosMsg);

                /* Save message information(Used when a response is received.)*/
                (void)memcpy(&g_wait_for_resp_msg, msg, sizeof(VEHICLE_MSG_BUF));
                g_wait_for_resp_set_n = p_datamaster_set_n;
            } else {
                /* GPS time setting process is already in progress:Reply BUSY to requesting processes */
                FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SetGpsTime already.");
            }
            break;
        }
        default:
            /* Set the specified data in the data master */
            VehicleSensSetDataMasterData((const POS_MSGINFO *)msg->data, p_datamaster_set_n);
            break;
    }

    return;
}

/**
 * @brief
 *  GPS time setting data transmission process
 *
 *  Send the specified data to the GPS thread
 *
 * @param[in]   const POS_MSGINFO *pos_msg       : message buffer
 * @return      none
 * @retval      none
 */
void VehicleSensGpsTimeSndMsg(const POS_MSGINFO *pos_msg) {
    RET_API    ret_api = RET_NORMAL;    /* System API return value */
    u_int16    size = 0;          /* Data length setting */
    u_int16    all_len = 0;        /* Sent message length */
    u_int16    mode = 0;          /* Mode information */
    RID      req_id = 0;          /* Resources ID */
    T_APIMSG_MSGBUF_HEADER  header;      /* Message header */
    TG_GPS_SND_DATA      data;      /* Message body */
    u_int8    snd_buf[(sizeof(T_APIMSG_MSGBUF_HEADER) + sizeof(TG_GPS_SND_DATA))];

    memset(&header, 0x00, sizeof(T_APIMSG_MSGBUF_HEADER));
    memset(&data, 0x00, sizeof(TG_GPS_SND_DATA));

    /* Message header generation */
    size = sizeof(data);
    header.signo = 0;            /* Signal information          */
    header.hdr.sndpno = PNO_VEHICLE_SENSOR;  /* Source thread number      */
    header.hdr.respno = 0;          /* Destination process No.      */
    header.hdr.cid = CID_GPS_TIMESETTING;  /* Command ID          */
    header.hdr.msgbodysize = size;      /* Message data length setting  */
    header.hdr.rid = req_id;          /* Resource ID Setting        */

    /* Message body generating */
    data.us_size = pos_msg->size;
    memcpy(&(data.ub_data[0]), &(pos_msg->data[0]), pos_msg->size);

    /* Messaging */
    (void)memcpy(&snd_buf[0], &header, sizeof(header));
    (void)memcpy(&snd_buf[sizeof(header)], &data, sizeof(data));
    all_len = static_cast<u_int16>(size + sizeof(header));
    mode   = 0;
    ret_api = _pb_SndMsg(PNO_NAVI_GPS_MAIN, all_len, reinterpret_cast<void *>(&snd_buf[0]), mode);
    if (RET_NORMAL != ret_api) {
        /* Message transmission processing failed */
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "send Message failed.");
    }

    return;
}

/**
 * @brief
 *  GPS time setting result notification process
 *
 *  Setting Specified Data to Data Master
 *
 * @param[in]   const VEHICLE_MSG_BUF *msg       : message buffer
 * @return      none
 * @retval      none
 */
void VehicleSensGpsTimeDelivery(const VEHICLE_MSG_BUF *msg) {
    int32              event_val = POS_RET_ERROR_INNER;  /* Event value */
    const TG_GPS_RET_TIMESET_MSG  *gps_ret_time;            /* GPS time setting response message */

    /* Determine the GPS time setting result */
    gps_ret_time = (const TG_GPS_RET_TIMESET_MSG *)msg;

    if (GPS_SENDOK == gps_ret_time->status) {
        event_val = POS_RET_NORMAL;
    } else {
        event_val = POS_RET_ERROR_TIMEOUT;
    }

    /* Set the specified data in the data master */
    if (POS_RET_NORMAL == event_val) {
        VehicleSensSetDataMasterData((const POS_MSGINFO *)&g_wait_for_resp_msg.data, g_wait_for_resp_set_n);
    }
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, 
                  "SetGpsTime Result[%d] EventVal[%d]",
                  static_cast<uint32_t>(gps_ret_time->status), static_cast<uint32_t>(event_val));

    /* Clear saved message information */
    (void)memset(&g_wait_for_resp_msg, 0x00, sizeof(VEHICLE_MSG_BUF));
    g_wait_for_resp_set_n = NULL;

    return;
}

/**
 * @brief
 *  Specified process No. event transmission processing
 *
 *  Send an event to the specified process No.
 *
 * @param[in]   uint16_t snd_pno   : Destination process number
 * @param[in]   int32_t  event_val : Sent event value
 * @return      RET_API
 * @retval      RET_NORMAL      Normal completion<br>
 *              RET_ERROR       Event generation failure<br>
 *              RET_ERRPARAM    Configuration mode error<br>
 *              RET_EV_NONE     Specified event does not exist<br>
 *              RET_EV_MAX      The set event value exceeds the maximum value<br>
 *              RET_EV_MIN      The set event value is below the minimum value.
 */
RET_API VehicleSensSendEvent(uint16_t snd_pno, int32_t event_val) {  // LCOV_EXCL_START 8 : dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
    RET_API      ret_val = RET_ERROR;        /* Return value */
    EventID      event_id = 0;          /* Event ID */

    /* Event Generation */
    event_id = VehicleCreateEvent(snd_pno);
    if (0 != event_id) {
        /* Event publishing(Release Event Wait) */
        ret_val = _pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, event_val);
        if (RET_NORMAL != ret_val) {
            /* Event issuance failure */
            FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "set Event failed.");
        }

        /* Event deletion */
        (void)VehicleDeleteEvent(event_id);
    } else {
        /* Event generation failure */
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "create Event failed.");
    }

    return ret_val;
}
// LCOV_EXCL_STOP

/**
 * @brief
 *  Pos_Main thread stop processing
 */
void VehicleSensThreadStopProcess(void) {
    /* Exit Process Implementation Point >>> */


    /* <<< Exit Process Implementation Point */

    /* Thread stop processing */
    PosTeardownThread(ETID_POS_MAIN);

    /* don't arrive here */
    return;
}

/**
 * @brief
 *  Initialization of data interruption monitoring process<br>
 *  1.Initial data reception monitoring timer issuance
 */
static void VehicleSensInitDataDisrptMonitor(void) {

    /* Initial sensor data reception monitoring timer */
    VehicleUtilitySetTimer(SNS_FST_TIMER);

    return;
}

/**
 * @brief
 *  Data disruption monitoring process<br>
 *  1.Stop timer for monitoring initial data reception<br>
 *  2.Stop timer for periodic data reception monitoring<br>
 *  3.Periodic data reception monitoring timer issuance
 *
 * @param[in]   did  Data type
 */
static void VehicleSensDataDisrptMonitorProc(DID did) {
    static BOOL is_rcv_sns_data = FALSE;

    switch (did) {
        case POSHAL_DID_GYRO_X:
        case POSHAL_DID_GYRO_Y:
        case POSHAL_DID_GYRO_Z:
        case POSHAL_DID_GSNS_X:
        case POSHAL_DID_GSNS_Y:
        case POSHAL_DID_GSNS_Z:
        case POSHAL_DID_SPEED_PULSE:
        case POSHAL_DID_REV:
        case POSHAL_DID_GPS_ANTENNA:
        case POSHAL_DID_GYRO_EXT:
        case POSHAL_DID_GYRO_TEMP:
        case POSHAL_DID_PULSE_TIME:
        case POSHAL_DID_SNS_COUNTER:
        {
            if (is_rcv_sns_data == FALSE) {
                /* Initial sensor data reception monitoring timer */
                VehicleUtilityStopTimer(SNS_FST_TIMER);
                is_rcv_sns_data = TRUE;

                FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "is_rcv_sns_data=TRUE");
            }

            /* Cyclic sensor data reception monitoring timer stopped */
            VehicleUtilityStopTimer(SNS_CYCLE_TIMER);
            /* Cyclic sensor data reception monitoring timer setting */
            VehicleUtilitySetTimer(SNS_CYCLE_TIMER);
            /* Sensor data interruption log output timer */
            VehicleUtilityStopTimer(SNS_DISRPT_TIMER);

            break;
        }
        default:
        {
            /* nop */
        }
    }

    return;
}

/**
 * @brief
 *  Timeout message reception processing
 *
 * @param[in]   rcv_msg Incoming message
 */
static void VehicleSensRcvMsgTout(TimerToutMsg* rcv_msg) {
    uint8_t tim_kind = static_cast<uint8_t>(rcv_msg->TimerSeq >> 8);

    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+ ### TIMEOUT ### Seq=0x%04x", rcv_msg->TimerSeq);
    switch (tim_kind) {
        case SNS_FST_TIMER:
        case SNS_CYCLE_TIMER:
        case SNS_DISRPT_TIMER:
        {
            /* Sensor data interruption log output timer setting */
            VehicleUtilityStopTimer(SNS_DISRPT_TIMER);
            VehicleUtilitySetTimer(SNS_DISRPT_TIMER);
            break;
        }
        default:
        {
            /* nop */
        }
    }
    FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
    return;
}


/**
 * @brief
 *  Initialize Vehilce Speed Information
 *
 * @details  This is for creating PASCD Sentence of NMEA. <br>
 *           You can initialize the buffer of Vehicle Speed Information.
 */
static void VehilceSens_InitVehicleSpeed(void) {
  (void)memset(&g_vehicle_speed_info, 0x00, sizeof(g_vehicle_speed_info));
  return;
}

/**
 * @brief
 *  Store Vehilce Speed Data
 *
 * @details  This is for creating PASCD Sentence of NMEA. <br>
 *           You can store Vehicle Speed Information for a cycle.
 *
 * @param[in]   VEHICLESENS_VEHICLE_SPEED_DAT* pVehicleSpeed : Speed [m/s] and TimeSpec
 */
static void VehicleSens_StoreVehicleSpeed(VEHICLESENS_VEHICLE_SPEED_DAT* pVehicleSpeed) {
  VEHICLESENS_VEHICLE_SPEED_INFO* pInfo = &g_vehicle_speed_info;


//  if (pInfo->sampleCount < VEHICLESENS_NMEA_PASCD_SAMPLECOUNT_MAX) {
  if (pInfo->sampleCount == 0) {
    (void)memcpy((pInfo->listSpd) + (pInfo->sampleCount), pVehicleSpeed, sizeof(VEHICLESENS_VEHICLE_SPEED_DAT));
    pInfo->sampleCount++;

  } else if (pInfo->sampleCount < VEHICLESENS_NMEA_PASCD_SAMPLECOUNT_MAX) {
    (void)_pb_memcpy((pInfo->listSpd) + (pInfo->sampleCount), pVehicleSpeed, sizeof(VEHICLESENS_VEHICLE_SPEED_DAT));

    VEHICLESENS_VEHICLE_SPEED_DAT* pS0 = &(pInfo->listSpd[0]);
    VEHICLESENS_VEHICLE_SPEED_DAT* pS = &(pInfo->listSpd[pInfo->sampleCount]);
    uint32_t ts_i; /* Interger Part of timestamp [s] */
    if (pS->ts.tv_nsec - pS0->ts.tv_nsec >= 0) {  // LCOV_EXCL_BR_LINE 200: can not less than zero
      ts_i = (pS->ts.tv_sec - pS0->ts.tv_sec) % VEHICLESENS_NMEA_PASCD_TS_MAX;
    } else {
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      ts_i = (pS->ts.tv_sec - pS0->ts.tv_sec - 1) % VEHICLESENS_NMEA_PASCD_TS_MAX;  // LCOV_EXCL_LINE 8: invalid
    }
    if (ts_i == 0) { /* Offset is 0 to 1 second */
        pInfo->sampleCount++;
    }

  } else {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
                  "WARNING: Num of stored datas is over 50. (%ld.%ld spd = %d)",
                  pVehicleSpeed->ts.tv_sec, pVehicleSpeed->ts.tv_nsec, pVehicleSpeed->speed );
  }

  return;
}

/**
 * @brief
 *  Load Vehicle Speed Information (Vehicle Speed Data x 50(max))
 *
 * @details  This is for creating PASCD Sentence of NMEA. <br>
 *           You can load Vehicle Speed Informations from the last initialization.
 *
 * @param[in]   VEHICLESENS_VEHICLE_SPEED_INFO* pVehicleSpeedInfo : Speeds [m/s] and TimeSpecs
 */
static void VehicleSens_LoadVehicleSpeed(VEHICLESENS_VEHICLE_SPEED_INFO* pVehicleSpeedInfo) {
  (void)memcpy(pVehicleSpeedInfo, &g_vehicle_speed_info, sizeof(g_vehicle_speed_info));
  return;
}

/**
 * @brief
 *  Concatenate NMEA Sentence Fields with Delimiter
 *
 * @details  This is for creating NMEA Sentence. <br>
 *           You can concatenate the two strings given as arguments 'str1' and 'str2'. <br>
 *           And at the time, it puts the delimiter between 'str1' and 'str2' automaticaly.
 *
 * @param[in]   char* str1         : destination
 * @param[in]   const size_t size  : buffer size of destination
 * @param[in]   const char* str2   : source
 * @param[in]   const size_t n     : copy size of source
 *
 * @return      RET_NORMAL         : success
 * @return      RET_ERROR          : failed
 */
static RET_API VehicleSens_CatNmeaSentenceFieldWithDelimiter(char* str1, const size_t size,
                                                             const char* str2, const size_t n) {
  RET_API ret_api = RET_NORMAL;

  size_t len1 = strlen(str1);
  size_t len2 = strlen(str2);
  size_t len3 = strlen(VEHICLESENS_NMEA_FIELDDELIMITER);
  size_t sn = n;

  if (sn > len2) {  // LCOV_EXCL_BR_LINE 200: can not exceed size
    sn = len2;
  }

  if (len1 + len3 + sn <= size - 1) {
    (void)strncat(str1, VEHICLESENS_NMEA_FIELDDELIMITER, len3); /* Add Delimiter (,) */
    (void)strncat(str1, str2, sn);
  } else {
    ret_api = RET_ERROR;

    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "ERROR: Buffer size is too small to connatenate. len1:%d len2:%d len3:%d n:%d", len1, len2, len3, n);
  }

  return ret_api;
}

/**
 * @brief
 *  Concatenate NMEA Sentence Fields without Delimiter
 *
 * @details This is for creating NMEA Sentence. <br>
 *          You can concatenate the two strings given as arguments 'str1' and 'str2'.
 *
 * @param[in]   char* str1          : destination
 * @param[in]   const size_t size   : buffer size of destination
 * @param[in]   const char* str2    : source
 * @param[in]   const size_t n      : copy size of source
 *
 * @return      RET_NORMAL         : success
 * @return      RET_ERROR          : failed
 */
static RET_API VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(char* str1, const size_t size,
                                                                const char* str2, const size_t n) {
  RET_API ret_api = RET_NORMAL;

  size_t len1 = strlen(str1);
  size_t len2 = strlen(str2);
  size_t sn = n;

  if (sn > len2) {  // LCOV_EXCL_BR_LINE 200: can not exceed  size
    sn = len2;
  }

  if (len1 + sn <= size - 1) {
    (void)strncat(str1, str2, sn);
  } else {
    ret_api = RET_ERROR;

    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "ERROR: Buffer size is too small to connatenate. len1:%d len2:%d n:%d", len1, len2, n);
  }

  return ret_api;
}

/**
 * @brief
 *  Generate ID Field of PASCD Sentence
 *
 * @details  This is for creating PASCD Sentence of NMEA. <br>
 *           You can generate ID Field of PASCD Sentence and <br>
 *           concatenate it with the string given as argument 'pascd'. <br>
 *           It should be called in the specific order.
 *
 * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
 * @param[in]       size_t size : buffer size
 *
 * @return      RET_NORMAL         : success
 * @return      RET_ERROR          : failed
 */
static inline RET_API VehicleSens_GeneratePASCDFieldId(char* pascd, size_t size) {
  RET_API ret_api;

  ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_PASCD_ID, size);
  if (ret_api == RET_ERROR) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
  }

  return ret_api;
}

/**
 * @brief
 *  Generate Timestamp Field of PASCD Sentence
 *
 * @details  This is for creating PASCD Sentence of NMEA. <br>
 *           You can generate Timestamp Field of PASCD Sentence and <br>
 *           concatenate it with the string given as argument 'pascd'. <br>
 *           It should be called in the specific order.
 *
 * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
 * @param[in]       size_t size : buffer size
 *
 * @return      RET_NORMAL         : success
 * @return      RET_ERROR          : failed
 */
static inline RET_API VehicleSens_GeneratePASCDFieldTimestamp(char* pascd, size_t size) {
  RET_API ret_api;

  VEHICLESENS_VEHICLE_SPEED_INFO stVehicleSpeedInfo;

  uint32_t ts_i; /* Interger Part of timestamp [s] */
  uint32_t ts_f; /* Fractional Part of timestamp [ms] */
  char ts_ci[32]; /* ts_i in charactor */
  char ts_cf[32]; /* ts_f in charactor */

  VehicleSens_LoadVehicleSpeed(&stVehicleSpeedInfo);


#if 1 /* PASCD *//* Suppose that GPS NMEA data are updated 1 sec interval */
  ts_i = gPseudoSecClockCounter; /* Synchronize: GPS NMEA */
  ts_f = 0u;
  gPseudoSecClockCounter += 1u; /* PASCD *//* Suppose that GPS NMEA data are updated 1 sec interval */
  if (gPseudoSecClockCounter >= VEHICLESENS_NMEA_PASCD_TS_MAX) {
    gPseudoSecClockCounter = 0u;
  }
#else /* PASCD *//* Suppose that GPS NMEA data are updated 1 sec interval */

  ts_i = stVehicleSpeedInfo.listSpd[0].ts.tv_sec % VEHICLESENS_NMEA_PASCD_TS_MAX;
  ts_f = stVehicleSpeedInfo.listSpd[0].ts.tv_nsec;

#endif /* PASCD *//* Suppose that GPS NMEA data are updated 1 sec interval */

  (void)snprintf(ts_ci, sizeof(ts_ci), "%d", ts_i);
  (void)snprintf(ts_cf, sizeof(ts_cf), "%06d", ts_f);

  /* Integer Part */
  ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, ts_ci, VEHICLESENS_NMEA_PASCD_TS_INT_LEN_MAX);
  if (ret_api == RET_ERROR) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
  }

  /* Decimal Point */
  ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_DECIMALPOINT, size);
  if (ret_api == RET_ERROR) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
  }

  /* Fractional Part */
  ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size,
                                                             ts_cf, VEHICLESENS_NMEA_PASCD_TS_FRA_LEN_MAX);
  if (ret_api == RET_ERROR) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
  }

  return ret_api;
}

/**
 * @brief
 *  Generate SensorType Field of PASCD Sentence
 *
 * @details  This is for creating PASCD Sentence of NMEA. <br>
 *           You can generate SensorType Field of PASCD Sentence and <br>
 *           concatenate it with the string given as argument 'pascd'. <br>
 *           It should be called in the specific order.
 *
 * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
 * @param[in]       size_t size : buffer size
 *
 * @return      RET_NORMAL         : success
 * @return      RET_ERROR          : failed
 */
static inline RET_API VehicleSens_GeneratePASCDFieldSensorType(char* pascd, size_t size) {
  RET_API ret_api;

  ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, VEHICLESENS_NMEA_PASCD_SENSORTYPE_C, size);
  if (ret_api == RET_ERROR) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
  }

  return ret_api;
}

/**
 * @brief
 *  Generate TransmissionState Field of PASCD Sentence
 *
 * @details  This is for creating PASCD Sentence of NMEA. <br>
 *           You can generate TransmissionState Field of PASCD Sentence and <br>
 *           concatenate it with the string given as argument 'pascd'. <br>
 *           It should be called in the specific order.
 *
 * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
 * @param[in]       size_t size : buffer size
 *
 * @return      RET_NORMAL         : success
 * @return      RET_ERROR          : failed
 */
static inline RET_API VehicleSens_GeneratePASCDFieldTransmissionState(char* pascd, size_t size) {
  RET_API ret_api = RET_NORMAL;
  EFrameworkunifiedStatus eStatus;

  uint8_t ucType; /* type of transmission */
  uint8_t ucShift;

#if 1 /* For Plus _CWORD27_ Gear Data Support 180115 */
  uint8_t ucPkb; /* state of parking brake */
#endif /* For Plus _CWORD27_ Gear Data Support 180115 */

  BOOL bIsAvailable;

  /* Get Type of Transmission */

//  eStatus = VehicleIf_GetTypeOfTransmission(&ucType, &bIsAvailable);
  eStatus = VehicleIf_GetTypeOfTransmission(&ucType, &ucPkb, &bIsAvailable);
  if ((bIsAvailable != true) || (eStatus != eFrameworkunifiedStatusOK)) {
    if (bIsAvailable == TRUE) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
      "ERROR: VehicleIf_GetTypeOfTransmission:%d", eStatus);
    }
    ret_api = RET_ERROR;
  }

  if (ret_api != RET_ERROR) {
    /* Get Shift Position */
    eStatus = VehicleIf_GetShiftPosition(&ucShift, &bIsAvailable);
    if ((bIsAvailable != true) || (eStatus != eFrameworkunifiedStatusOK)) {
      if (bIsAvailable == TRUE) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
        "ERROR: VehicleIf_GetShiftPosition:%d", eStatus);
      }
      ret_api = RET_ERROR;
    }
  }

  if (ret_api != RET_ERROR) {
    VEHICLESENS_TRANSMISSION_PKG tsmPkg;

    tsmPkg.type = ucType;
    tsmPkg.shift = ucShift;

#if 1 /* For Plus _CWORD27_ Gear Data Support 180115 */
    tsmPkg.pkb = ucPkb;
#endif /* For Plus _CWORD27_ Gear Data Support 180115 */


    ret_api = VehicleSens_DeriveTransmissionStateFor_CWORD27_(&tsmPkg);
    if (ret_api != RET_NORMAL) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
      "ERROR: VehicleSensDeriveTransmissionStateFor_CWORD27_:%d", ret_api);
    } else {
      ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, tsmPkg.state, size);
      if (ret_api == RET_ERROR) {
        FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
        "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
      }
    }
  }

  return ret_api;
}

/**
 * @brief
 *  Generate SlipDetect Field of PASCD Sentence
 *
 * @details  This is for creating PASCD Sentence of NMEA. <br>
 *           You can generate SlipDetect Field of PASCD Sentence and <br>
 *           concatenate it with the string given as argument 'pascd'. <br>
 *           It should be called in the specific order.
 *
 * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
 * @param[in]       size_t size : buffer size
 *
 * @return      RET_NORMAL         : success
 * @return      RET_ERROR          : failed
 */
static inline RET_API VehicleSens_GeneratePASCDFieldSlipDetect(char* pascd, size_t size) {
  RET_API ret_api;

  ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, VEHICLESNES_NMEA_PASCD_NOSLIP, size);
  if (ret_api == RET_ERROR) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
  }

  return ret_api;
}

/**
 * @brief
 *  Generate SampleCount Field of PASCD Sentence
 *
 * @details  This is for creating PASCD Sentence of NMEA. <br>
 *           You can generate SampleCount Field of PASCD Sentence and <br>
 *           concatenate it with the string given as argument 'pascd'. <br>
 *           It should be called in the specific order.
 *
 * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
 * @param[in]       size_t size : buffer size
 */
static inline RET_API VehicleSens_GeneratePASCDFieldSampleCount(char* pascd, size_t size) {
  RET_API ret_api;

  VEHICLESENS_VEHICLE_SPEED_INFO stVehicleSpeedInfo;
  char cSampleCount[32];

  VehicleSens_LoadVehicleSpeed(&stVehicleSpeedInfo);
  (void)snprintf(cSampleCount, sizeof(cSampleCount), "%d", stVehicleSpeedInfo.sampleCount);

  ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, cSampleCount, size);
  if (ret_api == RET_ERROR) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
  }

  return ret_api;
}

/**
 * @brief
 *  Generate TimeOffset and Speed Field of PASCD Sentence
 *
 * @details  This is for creating PASCD Sentence of NMEA. <br>
 *           You can generate TimeOffset and Speed Field of PASCD Sentence and <br>
 *           concatenate it with the string given as argument 'pascd'. <br>
 *           It should be called in the specific order.
 *
 * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
 * @param[in]       size_t size : buffer size
 *
 * @return      RET_NORMAL         : success
 * @return      RET_ERROR          : failed
 */
static inline RET_API VehicleSens_GeneratePASCDFieldTimeOffsetNSpeed(char* pascd, size_t size) {
  RET_API ret_api = RET_ERROR;

  VEHICLESENS_VEHICLE_SPEED_INFO stVehicleSpeedInfo;
  VEHICLESENS_VEHICLE_SPEED_DAT *pS0 = &(stVehicleSpeedInfo.listSpd[0]);

  int32_t i;

  VehicleSens_LoadVehicleSpeed(&stVehicleSpeedInfo);

  for (i = 0; i < stVehicleSpeedInfo.sampleCount; i++) {
    VEHICLESENS_VEHICLE_SPEED_DAT *pS = &(stVehicleSpeedInfo.listSpd[i]);

    /* timeoffset */
    uint32_t ts_i; /* Interger Part of timestamp [s] */
    uint32_t ts_f; /* Fractional Part of timestamp [us] */
    char ts_ci[32]; /* ts_i in charactor */
    char ts_cf[32]; /* ts_f in charactor */

    if (pS->ts.tv_nsec - pS0->ts.tv_nsec >= 0) {  // LCOV_EXCL_BR_LINE 200: can not less than zero
      ts_i = (pS->ts.tv_sec - pS0->ts.tv_sec) % VEHICLESENS_NMEA_PASCD_TS_MAX;
      ts_f = (pS->ts.tv_nsec - pS0->ts.tv_nsec) / 1000; /* [ns] -> [us] */
    } else {
      // LCOV_EXCL_START 8: invalid
      AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      ts_i = (pS->ts.tv_sec - pS0->ts.tv_sec - 1) % VEHICLESENS_NMEA_PASCD_TS_MAX;
      ts_f = (1000000000 + pS->ts.tv_nsec - pS0->ts.tv_nsec) / 1000; /* [ns] -> [us] */
      // LCOV_EXCL_STOP
    }

    (void)snprintf(ts_ci, sizeof(ts_ci), "%d", ts_i);
    (void)snprintf(ts_cf, sizeof(ts_cf), "%06d", ts_f);

    /* Integer Part */
    ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, ts_ci, size);
    if (ret_api == RET_ERROR) {  // LCOV_EXCL_BR_LINE 200: can not exceed buffer size
    // LCOV_EXCL_START 8: invalid
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
      "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
      break;
    // LCOV_EXCL_STOP
    }

    /* Decimal Point */
    ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_DECIMALPOINT, size);
    if (ret_api == RET_ERROR) {  // LCOV_EXCL_BR_LINE 200: can not exceed buffer size
    // LCOV_EXCL_START 8: invalid
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
      "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
      break;
    // LCOV_EXCL_STOP
    }

    /* Fractional Part */
    ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size,
                                                               ts_cf, VEHICLESENS_NMEA_PASCD_TO_FRA_LEN_MAX);
    if (ret_api == RET_ERROR) {  // LCOV_EXCL_BR_LINE 200: can not exceed buffer size
    // LCOV_EXCL_START 8: invalid
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
      "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
      break;
    // LCOV_EXCL_STOP
    }

    /* speed */
    uint16_t spd_i; /* Interger Part of speed [m/s] */
    uint16_t spd_f; /* Fractional Part of speed [mm/s] */
    char spd_ci[32]; /* spd_i in charactor */
    char spd_cf[32]; /* spd_f in charactor */

    spd_i = pS->speed / 100; /* [0.01m/s] -> [m/s] */
    spd_f = (pS->speed % 100) * 10; /* [0.01m/s] -> [mm/s] */

    (void)snprintf(spd_ci, sizeof(spd_ci), "%d", spd_i);
    (void)snprintf(spd_cf, sizeof(spd_cf), "%03d", spd_f);

    /* Integer Part */
    ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, spd_ci, size);
    if (ret_api == RET_ERROR) {
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
      "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
      break;
    }

    /* Decimal Point */
    ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_DECIMALPOINT, size);
    if (ret_api == RET_ERROR) {  // LCOV_EXCL_BR_LINE 200: can not exceed buffer size
    // LCOV_EXCL_START 8: invalid
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
      "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
      break;
    // LCOV_EXCL_STOP
    }

    /* Fractional Part */
    ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size,
                                                               spd_cf, VEHICLESENS_NMEA_PASCD_SPD_FRA_LEN_MAX);
    if (ret_api == RET_ERROR) {  // LCOV_EXCL_BR_LINE 200: can not exceed buffer size
    // LCOV_EXCL_START 8: invalid
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
      FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
      "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
      break;
    // LCOV_EXCL_STOP
    }
  }

  return ret_api;
}

/**
 * @brief
 *  Generate Checksum Field of PASCD Sentence
 *
 * @details  This is for creating PASCD Sentence of NMEA. <br>
 *           You can generate Checksum Field of PASCD Sentence and <br>
 *           concatenate it with the string given as argument 'pascd'. <br>
 *           It should be called in the specific order.
 *
 * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
 * @param[in]       size_t size : buffer size
 *
 * @return      RET_NORMAL         : success
 * @return      RET_ERROR          : failed
 */
static inline RET_API VehicleSens_GeneratePASCDFieldChecksum(char* pascd, size_t size) {
  RET_API ret_api;

  size_t length;
  uint8_t chk = 0;
  char cChk[3];
  uint16_t i = 0;

  length = strnlen(pascd, size);

  /* Calculate Checksum (start with the 2th Bype except '$') */
  for (i = 1; i < length; i++) {
    chk ^= pascd[i];
  }
  (void)snprintf(cChk, sizeof(cChk), "%02X", chk);

  /* Set Astarisk before Checksum */
  ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_ASTARISK, size);
  if (ret_api == RET_ERROR) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
  }

  /* Set Checksum */
  ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, cChk, size);
  if (ret_api == RET_ERROR) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
  }

  return ret_api;
}

/**
 * @brief
 *  Generate CR & LF Field of PASCD Sentence
 *
 * @details  This is for creating PASCD Sentence of NMEA. <br>
 *           You can generate CRLF Field of PASCD Sentence and <br>
 *           concatenate it with the string given as argument 'pascd'. <br>
 *           It should be called in the specific order.
 *
 * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
 * @param[in]       size_t size : buffer size
 *
 * @return      RET_NORMAL         : success
 * @return      RET_ERROR          : failed
 */
static inline RET_API VehicleSens_GeneratePASCDFieldCRLF(char* pascd, size_t size) {
  RET_API ret_api;

  /* Set Carriage Return */
  ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_CR, size);
  if (ret_api == RET_ERROR) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
  }

  /* Set Line Feed */
  ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_LF, size);
  if (ret_api == RET_ERROR) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
  }

  return ret_api;
}

/**
 * @brief
 *  Derive Transmission State For _CWORD27_
 *
 * @details  This is for creating PASCD Sentence of NMEA. <br>
 *           You can derive transmissionState from the transmission type and <br>
 *           the shift positiong from Vehicle Service.
 *
 * @param[in/out] VEHICLESENS_TRANSMISSION_PKG* pPkg : source data set for Transmission State
 *
 * @return      RET_NORMAL         : success
 * @return      RET_ERROR          : failed
 */
static RET_API VehicleSens_DeriveTransmissionStateFor_CWORD27_(VEHICLESENS_TRANSMISSION_PKG* pPkg) {
  RET_API ret_api = RET_NORMAL;
  uint32_t i;

  static const VEHICLESENS_TRANSMISSION_PKG TmsLut[VEHICLEIF_TRANSMISSION_TYPE_NUM * VEHICLEIF_SHIFT_POSITION_NUM] = {

//    /* Transmission Type : MT */
//    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_U, VEHICLESENS_NMEA_PASCD_TMS_D },
//    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_R, VEHICLESENS_NMEA_PASCD_TMS_R },
//    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_P, VEHICLESENS_NMEA_PASCD_TMS_D },
//    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_N, VEHICLESENS_NMEA_PASCD_TMS_D },
//    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_D, VEHICLESENS_NMEA_PASCD_TMS_D },
//    /* Tranmission Type : AT */
//    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_U, VEHICLESENS_NMEA_PASCD_TMS_U },
//    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_R, VEHICLESENS_NMEA_PASCD_TMS_R },
//    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_P, VEHICLESENS_NMEA_PASCD_TMS_P },
//    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_N, VEHICLESENS_NMEA_PASCD_TMS_U },
//    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_D, VEHICLESENS_NMEA_PASCD_TMS_D },
//    /* Transmission Type : UNKNOWN */
//    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_U, VEHICLESENS_NMEA_PASCD_TMS_U },
//    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_R, VEHICLESENS_NMEA_PASCD_TMS_U },
//    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_P, VEHICLESENS_NMEA_PASCD_TMS_U },
//    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_N, VEHICLESENS_NMEA_PASCD_TMS_U },
//    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_D, VEHICLESENS_NMEA_PASCD_TMS_U },
    /* Transmission Type : MT */
    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_U, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_R, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_R },
    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_P, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_N, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_D, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
    /* Tranmission Type : AT */
#if 1 /* For Plus _CWORD27_ Gear Data Support 180115 */
    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_U, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_U },
#else /* For Plus _CWORD27_ Gear Data Support 180115 */
    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_U, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
#endif /* For Plus _CWORD27_ Gear Data Support 180115 */
    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_R, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_R },
    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_P, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_P },
    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_N, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_N }, /* However, the Vehicle does not notify you by Phase3. */
    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_D, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
    /* Transmission Type : UNKNOWN */
#if 1 /* For Plus _CWORD27_ Gear Data Support 180115 */
    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_U, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_U },
    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_R, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_U },
    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_P, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_U },
    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_N, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_U },
    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_D, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_U },
#else /* For Plus _CWORD27_ Gear Data Support 180115 */
    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_U, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_R, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_P, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_N, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_D, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
#endif /* For Plus _CWORD27_ Gear Data Support 180115 */

  };

  for (i = 0; i < VEHICLEIF_TRANSMISSION_TYPE_NUM * VEHICLEIF_SHIFT_POSITION_NUM; i++) {
    if ((pPkg->type == TmsLut[i].type) && (pPkg->shift == TmsLut[i].shift)) {
      strncpy(pPkg->state, TmsLut[i].state, sizeof(pPkg->state));
      break;
    }
  }


#if 1 /* For Plus _CWORD27_ Gear Data Support 180115 */
  if ((pPkg->type == VEHICLEIF_TRANSMISSION_TYPE_MT) && (pPkg->pkb == VEHICLEIF_PKB_ON)) {
    strncpy(pPkg->state, VEHICLESENS_NMEA_PASCD_TMS_P, sizeof(VEHICLESENS_NMEA_PASCD_TMS_P));
  }
#endif /* For Plus _CWORD27_ Gear Data Support 180115 */


  if (i == VEHICLEIF_TRANSMISSION_TYPE_NUM * VEHICLEIF_SHIFT_POSITION_NUM) {
    FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, 
    "FORBIDDEN ERROR: Can't find Transmission State. type:%d shift:%d", pPkg->type, pPkg->shift);
    ret_api = RET_ERROR;
  }

  return ret_api;
}