video_in_hal/vehicleservice/positioning/server/src/Sensor/VehicleSens_Thread.cpp

   1 /*
   2  * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*******************************************************************************
  18  *  File name    :VehicleSens_Thread.cpp
  19  *  System name    :GPF
  20  *  Subsystem name  :Vehicle sensor process
  21  *  Program name  :Vehicle sensor thread
  22  *  Module configuration  :VehicleSensThread()          Vehicle Sensor Thread Domain Functions
  23  *          :VehicleSensThreadInit()        Vehicle sensor thread initials
  24  *          :VehicleSensDeliveryEntry()      Vehicle sensor information delivery registration
  25  *          :VehicleSensGetVehicleData()      Vehicle sensor information acquisition
  26  *          :VehicleSensWatchStopPage()      Vehicle sensor interruption monitoring
  27  *          :VehicleSensPkgDeliveryEntry()    Vehicle sensor information package delivery registration
  28  *          :VehicleSensGetVehiclePkgData()    Vehicle sensor information package data acquisition
  29  *          :VehicleSensLineSensDataDelivery()  LineSensor Vehicle Signal Notification
  30  *          :VehicleSensGpsDataDelivery()      GPS data notification
  31  *          :VehicleSens_CanDataDelivery()      CAN data delivery notice
  32  *          :VehicleSensDataMasterSetN()      Data master set notification process(Callback function)
  33  *          :VehicleSensSetVehicleData()      GPS command request processing
  34  ******************************************************************************/
  35 #include "VehicleSens_Thread.h"
  36 #include <vehicle_service/positioning_base_library.h>
  37 #include <other_service/VP_GetEnv.h>
  38 #include "POS_private.h"
  39 #include "positioning_common.h"
  40 #include "SensorLog.h"
  41 #include "VehicleUtility.h"
  42 #include "VehicleSensor_Thread.h"
  43
  44 #include "VehicleIf.h"
  45
  46 /*************************************************/
  47 /*           Global variable                      */
  48 /*************************************************/
  49 static VEHICLE_MSG_BUF      g_wait_for_resp_msg;  /* Message waiting to receive a response */
  50 static PFUNC_DMASTER_SET_N  g_wait_for_resp_set_n;  /* Response waiting data master set */
  51 static BOOL                 g_sent_fst_pkg_delivery_ext; /* Initial expansion package data delivery status */
  52
  53 static VEHICLESENS_VEHICLE_SPEED_INFO g_vehicle_speed_info;
  54
  55 uint32_t gPseudoSecClockCounter = 0u;
  56
  57 /*************************************************/
  58 /*           Function prototype                    */
  59 /*************************************************/
  60 static void VehicleSensInitDataDisrptMonitor(void);
  61 static void VehicleSensDataDisrptMonitorProc(DID did);
  62 static void VehicleSensRcvMsgTout(TimerToutMsg* rcv_msg);
  63
  64 static void VehilceSens_InitVehicleSpeed(void);
  65 static void VehicleSens_StoreVehicleSpeed(VEHICLESENS_VEHICLE_SPEED_DAT* pVehicleSpeed);
  66 static void VehicleSens_LoadVehicleSpeed(VEHICLESENS_VEHICLE_SPEED_INFO* pVehicleSpeedInfo);
  67 static RET_API VehicleSens_CatNmeaSentenceFieldWithDelimiter(char* str1, const size_t size, const char* str2, const size_t n);
  68 static RET_API VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(char* str1, const size_t size, const char* str2, const size_t n);
  69 static inline RET_API VehicleSens_GeneratePASCDFieldId(char* pascd, size_t size);
  70 static inline RET_API VehicleSens_GeneratePASCDFieldTimestamp(char* pascd, size_t size);
  71 static inline RET_API VehicleSens_GeneratePASCDFieldSensorType(char* pascd, size_t size);
  72 static inline RET_API VehicleSens_GeneratePASCDFieldTransmissionState(char* pascd, size_t size);
  73 static inline RET_API VehicleSens_GeneratePASCDFieldSlipDetect(char* pascd, size_t size);
  74 static inline RET_API VehicleSens_GeneratePASCDFieldSampleCount(char* pascd, size_t size);
  75 static inline RET_API VehicleSens_GeneratePASCDFieldTimeOffsetNSpeed(char* pascd, size_t size);
  76 static inline RET_API VehicleSens_GeneratePASCDFieldChecksum(char* pascd, size_t size);
  77 static inline RET_API VehicleSens_GeneratePASCDFieldCRLF(char* pascd, size_t size);
  78 static RET_API VehicleSens_DeriveTransmissionStateFor_CWORD27_(VEHICLESENS_TRANSMISSION_PKG* pPkg);
  79
  80
  81 /*******************************************************************************
  82 * MODULE    : VehicleSensThread
  83 * ABSTRACT  : Vehicle Sensor Thread Domain Functions
  84 * FUNCTION  : Main processing
  85 * ARGUMENT  : lpv_para  :
  86 * NOTE      :
  87 * RETURN    :
  88 ******************************************************************************/
  89 EFrameworkunifiedStatus VehicleSensThread(HANDLE h_app) {
  90     RET_API  ret_api = RET_NORMAL;        /* Return Values of System API Functions  */
  91     T_APIMSG_MSGBUF_HEADER  *p;          /* Message header      */
  92     RET_API  ret_val;                /* Return value of initialization processing    */
  93     VEHICLE_MSG_DELIVERY_ENTRY  delivery_entry;
  94
  95     static u_int8 msg_buf[MAX_MSG_BUF_SIZE]; /* message buffer  */
  96
  97     void* p_msg_buf = &msg_buf;
  98     LSDRV_MSG_LSDATA_G** p_lsdrv_msg;
  99     VEHICLE_MSG_BUF** p_vehicle_msg;
 100     POS_MSGINFO *p_pos_msg;
 101
 102
 103
 104     p_lsdrv_msg = reinterpret_cast<LSDRV_MSG_LSDATA_G**>(&p_msg_buf);
 105     p_vehicle_msg = reinterpret_cast<VEHICLE_MSG_BUF**>(&p_msg_buf);
 106
 107     VehicleUtilityInitTimer();
 108     (void)PosSetupThread(h_app, ETID_POS_MAIN);
 109
 110     memset(&(delivery_entry), 0, sizeof(VEHICLE_MSG_DELIVERY_ENTRY));
 111
 112     /* Thread initialization process */
 113     ret_val = VehicleSensThreadInit();
 114
 115     gPseudoSecClockCounter = 0u;
 116
 117     if (RET_NORMAL == ret_val) {  // LCOV_EXCL_BR_LINE 6: always be RET_NORMAL
 118         while (1) {
 119             /* Message reception processing */
 120             p_msg_buf = &msg_buf;
 121             ret_api = _pb_RcvMsg(PNO_VEHICLE_SENSOR, sizeof(msg_buf), &p_msg_buf, RM_WAIT);
 122
 123             /* Internal debug log output */
 124             FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__,
 125                           "[ret_api = 0x%x]",
 126                           ret_api);
 127
 128             /* When the message is received successfully */
 129             if (ret_api == RET_RCVMSG) {
 130                 p = reinterpret_cast<T_APIMSG_MSGBUF_HEADER *>(p_msg_buf);
 131
 132                 switch (p->hdr.cid) {  // LCOV_EXCL_BR_LINE 200: some DID is not used
 133                     case CID_VEHICLEIF_DELIVERY_ENTRY:
 134                     {
 135                         memcpy(&(delivery_entry), &(p_msg_buf), sizeof(VEHICLE_MSG_DELIVERY_ENTRY));
 136
 137                         /* Sort by received DID */
 138                         switch (delivery_entry.data.did) {  // LCOV_EXCL_BR_LINE 200: DR DID is not used
 139                             case VEHICLE_DID_DR_ALTITUDE :
 140                             case VEHICLE_DID_DR_LATITUDE :
 141                             case VEHICLE_DID_DR_SPEED :
 142                             case VEHICLE_DID_DR_HEADING :
 143                             case VEHICLE_DID_DR_GYRO_SCALE_FACTOR_LEVEL :
 144                             case VEHICLE_DID_DR_SPEED_PULSE_SCALE_FACTOR_LEVEL :
 145                             {
 146                                 // LCOV_EXCL_START 8: dead code
 147                                 AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 148                                 VehicleSensDrDeliveryEntry((const VEHICLE_MSG_DELIVERY_ENTRY *)p_msg_buf);
 149                                 // LCOV_EXCL_STOP
 150                             }
 151                             break;
 152                             default:
 153                                 /* Vehicle sensor information delivery registration */
 154                                 VehicleSensDeliveryEntry((const VEHICLE_MSG_DELIVERY_ENTRY *)p_msg_buf);
 155                                 break;
 156                         }
 157                         break;
 158                     }
 159                     case CID_VEHICLEIF_GET_VEHICLE_DATA:
 160                     {
 161                         /* Vehicle sensor information acquisition */
 162                         VehicleSensGetVehicleData((const VEHICLE_MSG_GET_VEHICLE_DATA *)p_msg_buf);
 163                         break;
 164                     }
 165                     case CID_LINESENS_VEHICLE_DATA:
 166                     {
 167                         /* LineSensor Vehicle Signal Notification */
 168                         VehicleSensLineSensDataDelivery((const LSDRV_MSG_LSDATA *)p_msg_buf,
 169                                                           (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN);
 170                         break;
 171                     }
 172                     case CID_LINESENS_VEHICLE_DATA_G:
 173                     {
 174                         /* Data disruption monitoring process */
 175                         VehicleSensDataDisrptMonitorProc(
 176                             (reinterpret_cast<LSDRV_MSG_LSDATA_G*>(*p_lsdrv_msg))->st_para.st_data[0].ul_did);
 177                         VehicleSensLineSensDataDeliveryG((const LSDRV_MSG_LSDATA_G *)p_msg_buf,
 178                                                             (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN);
 179                         break;
 180                     }
 181                     case CID_LINESENS_VEHICLE_DATA_GYRO_TROUBLE:
 182                     {
 183                         // LCOV_EXCL_START 8: dead code
 184                         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 185                         /* Gyro Failure Status Notification */
 186                         VehicleSensLineSensDataDeliveryGyroTrouble((const LSDRV_MSG_LSDATA_GYRO_TROUBLE *)p_msg_buf,
 187                                 (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN);
 188                         break;
 189                         // LCOV_EXCL_STOP
 190                     }
 191                     case CID_LINESENS_VEHICLE_DATA_SYS_GPS_INTERRUPT_SIGNAL:
 192                     {
 193                         // LCOV_EXCL_START 8: dead code
 194                         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 195                         /* SYS GPS interrupt notification */
 196                         VehicleSensLineSensDataDeliverySysGpsInterruptSignal(
 197                             (const LSDRV_MSG_LSDATA_GPS_INTERRUPT_SIGNAL *)p_msg_buf,
 198                             (PFUNC_DMASTER_SET_SHARED_MEMORY)VehicleSensDataMasterSetSharedMemory);
 199                         break;
 200                         // LCOV_EXCL_STOP
 201                     }
 202                     case CID_LINESENS_VEHICLE_DATA_GYRO_CONNECT_STATUS:
 203                     {
 204                         // LCOV_EXCL_START 8: dead code
 205                         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 206                         /* Gyro Failure Status Notification */
 207                         VehicleSensLineSensDataDeliveryGyroConnectStatus(
 208                             (const LSDRV_MSG_LSDATA_GYRO_CONNECT_STATUS *)p_msg_buf,
 209                             (PFUNC_DMASTER_SET_SHARED_MEMORY)VehicleSensDataMasterSetSharedMemory);
 210                         break;
 211                         // LCOV_EXCL_STOP
 212                     }
 213                     case CID_LINESENS_VEHICLE_DATA_GPS_ANTENNA_STATUS:
 214                     {
 215                         // LCOV_EXCL_START 8: dead code
 216                         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 217                         /* GPS antenna failure status notification */
 218                         VehicleSensLineSensDataDeliveryGpsAntennaStatus(
 219                             (const LSDRV_MSG_LSDATA_GPS_ANTENNA_STATUS *)p_msg_buf,
 220                             (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN);
 221                         break;
 222                         // LCOV_EXCL_STOP
 223                     }
 224                     case CID_SENSORIF_PKG_DELIVERY_ENTRY_EXT:
 225                     {
 226                         /* Vehicle Sensor Information Extended Package Delivery Registration */
 227                         VehicleSensPkgDeliveryEntryExt((const SENSOR_MSG_DELIVERY_ENTRY *)p_msg_buf);
 228                         break;
 229                     }
 230                     case CID_LINESENS_VEHICLE_DATA_FST:
 231                     {
 232                         /* LineSensor Vehicle Initial Sensor Signal Notification */
 233                         VehicleSensLineSensDataDeliveryFstG((const LSDRV_MSG_LSDATA_FST *)p_msg_buf,
 234                                                             (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN);
 235                         break;
 236                     }
 237                     case CID_GPS_DATA:
 238                     {
 239                         /* GPS information notification */
 240                         VehicleSensGpsDataDelivery(reinterpret_cast<SENSOR_MSG_GPSDATA *>(p_msg_buf),
 241                             (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN,
 242                             (PFUNC_DMASTER_SET_SHARED_MEMORY)VehicleSensDataMasterSetSharedMemory);
 243                         break;
 244                     }
 245                     case CID_POSIF_SET_DATA:
 246                     {
 247                         p_pos_msg =
 248                         reinterpret_cast<POS_MSGINFO*>((reinterpret_cast<VEHICLE_MSG_BUF*>(*p_vehicle_msg))->data);
 249                         /* Data disruption monitoring process */
 250                         VehicleSensDataDisrptMonitorProc(p_pos_msg->did);
 251
 252                         /* Data Setting Notification */
 253                         VehicleSensCommonDataDelivery((const VEHICLE_MSG_BUF *)p_msg_buf,
 254                                                       (PFUNC_DMASTER_SET_N)VehicleSensDataMasterSetN);
 255                         break;
 256                     }
 257                     case CID_GPS_RETTIMESETTING:
 258                     {
 259                         /* GPS time setting result notification */
 260                         VehicleSensGpsTimeDelivery((const VEHICLE_MSG_BUF *)p_msg_buf);
 261                         break;
 262                     }
 263                     case CID_DEAD_RECKONING_GPS_DATA :  /* GPS data distribution for DR */
 264                     case CID_DEAD_RECKONING_SENS_DATA :  /* Sensor Data Delivery for DR */
 265                     case CID_DEAD_RECKONING_SENS_FST_DATA :  /* Initial Sensor Data Delivery for DR */
 266                     {
 267                         // LCOV_EXCL_START 8: dead code
 268                         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 269                         VehicleSensDrRcvMsg((const DEAD_RECKONING_RCVDATA *)p_msg_buf);
 270                         break;
 271                         // LCOV_EXCL_STOP
 272                     }
 273                     case CID_VEHICLEIF_GET_DR_DATA :
 274                     {
 275                         // LCOV_EXCL_START 8: dead code
 276                         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 277                         /* Vehicle sensor information acquisition */
 278                         DeadReckoningGetDRData((const DEADRECKONING_MSG_GET_DR_DATA *)p_msg_buf);
 279                         break;
 280                         // LCOV_EXCL_STOP
 281                     }
 282                     case CID_DR_MAP_MATCHING_DATA :  /* Map matching information */
 283                     {
 284                         // LCOV_EXCL_START 8: dead code
 285                         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 286                         DeadReckoningSetMapMatchingData((const DR_MSG_MAP_MATCHING_DATA *)p_msg_buf);
 287                         break;
 288                         // LCOV_EXCL_STOP
 289                     }
 290                     case CID_DR_CLEAR_BACKUP_DATA :  /* Clear backup data */
 291                     {
 292                         // LCOV_EXCL_START 8: dead code
 293                         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 294                         DeadReckoningClearBackupData((const DR_MSG_CLEAR_BACKUP_DATA*)p_msg_buf);
 295                         break;
 296                         // LCOV_EXCL_STOP
 297                     }
 298                     case CID_VEHICLEDEBUG_LOG_GET : /* Log acquisition request */
 299                     {
 300                         // LCOV_EXCL_START 8: dead code
 301                         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 302                         VehicleSensGetLog((const VEHICLEDEBUG_MSG_BUF *)p_msg_buf);
 303                         break;
 304                         // LCOV_EXCL_STOP
 305                     }
 306                     case CID_VEHICLEDEBUG_LOG_SET :  /* Log Setting Request */
 307                     {
 308                         // LCOV_EXCL_START 8: dead code
 309                         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 310                         VehicleSensSetLog((const VEHICLEDEBUG_MSG_BUF *)p_msg_buf);
 311                         break;
 312                         // LCOV_EXCL_STOP
 313                     }
 314                     case CANINPUT_CID_LOCALTIME_NOTIFICATION : /* CAN information acquisition */
 315                     {
 316                         // LCOV_EXCL_START 8: dead code
 317                         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 318                         VehicleSensWriteLocalTime((const CANINPUT_MSG_INFO*)p_msg_buf);
 319                         break;
 320                         // LCOV_EXCL_STOP
 321                     }
 322                     case CID_EPH_NUM_NOTIFICATION :  /* Set effective ephemeris count at shutdown */
 323                     {
 324                         // LCOV_EXCL_START 8: dead code
 325                         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 326                         VehicleSensSetEphNumSharedMemory((const SENSOR_MSG_GPSDATA *)p_msg_buf);
 327                         break;
 328                         // LCOV_EXCL_STOP
 329                     }
 330                     case CID_SENSORIF__CWORD82__REQUEST:
 331                     {
 332                         // LCOV_EXCL_START 8: dead code
 333                         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 334                         /* Requests to send GPS _CWORD82_ commands */
 335                         VehicleSensSetVehicleData((const VEHICLE_MSG_SEND *)p_msg_buf);
 336                         break;
 337                         // LCOV_EXCL_STOP
 338                     }
 339                     case CID_THREAD_STOP_REQ:
 340                     {
 341                         /* Thread stop processing */
 342                         VehicleSensThreadStopProcess();
 343                         break;
 344                     }
 345                     case CID_TIMER_TOUT:
 346                     {
 347                         /* Timeout notification reception processing */
 348                         VehicleSensRcvMsgTout(reinterpret_cast<TimerToutMsg*>(p_msg_buf));
 349                         break;
 350                     }
 351                     default:
 352                         break;
 353                 }
 354             } else {
 355                 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "ret_api != RET_RCVMSG\r\n");
 356             }
 357         }
 358     } else {
 359         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "VehicleSens: VehicleSens_MainThread Initial Error!! :%d", ret_val);
 360         _pb_Exit();
 361     }
 362
 363     return eFrameworkunifiedStatusOK;
 364 }
 365
 366 /*******************************************************************************
 367 * MODULE    : VehicleSensThreadInit
 368 * ABSTRACT  : Vehicle sensor thread initials
 369 * FUNCTION  : Initial process
 370 * ARGUMENT  : void
 371 * NOTE      :
 372 * RETURN    : CAN data delivery registration result
 373 ******************************************************************************/
 374 RET_API VehicleSensThreadInit(void) {
 375     RET_API    ret_val = RET_NORMAL;
 376
 377     /* Initialization of Vehicle Selection Item List Table */
 378     VehicleSensInitSelectionItemList();
 379
 380     /* Vehicle sensor data master initialization */
 381     VehicleSensInitDataMaster();
 382
 383     /* Initialization of shipping destination management table */
 384     VehicleSensInitDeliveryCtrlTbl();
 385
 386     /* Initialization of shipping destination management table management information */
 387     VehicleSensInitDeliveryCtrlTblMng();
 388
 389     /* Initialization of package delivery management table */
 390     VehicleSensInitPkgDeliveryTblMng();
 391
 392     /* Initialization of non-volatile access function block */
 393     VehicleSensFromAccessInitialize();
 394
 395     /* Clear message information waiting to receive a response */
 396     (void)memset(&g_wait_for_resp_msg, 0x00, sizeof(VEHICLE_MSG_BUF));
 397     g_wait_for_resp_set_n = NULL;
 398     g_sent_fst_pkg_delivery_ext = FALSE; /* Initial expansion package data undelivered */
 399
 400     VehilceSens_InitVehicleSpeed(); /* for PASCD */
 401
 402     /* Start of data interruption monitoring */
 403     VehicleSensInitDataDisrptMonitor();
 404     return ret_val;
 405 }
 406
 407 /*******************************************************************************
 408  * MODULE    : VehicleSensDeliveryEntry
 409  * ABSTRACT  : Vehicle sensor information delivery registration
 410  * FUNCTION  :
 411  * ARGUMENT  : *msg  : message buffer
 412  * NOTE      :
 413  * RETURN    : void
 414  ******************************************************************************/
 415 void VehicleSensDeliveryEntry(const VEHICLE_MSG_DELIVERY_ENTRY *msg) {
 416     int32  event_val;
 417     EventID  event_id;
 418
 419     /* Call the process of creating the delivery destination management table */
 420     event_val = static_cast<int32>(VehicleSensEntryDeliveryCtrl(msg));
 421
 422     /* Internal debug log output */
 423     FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "+");
 424
 425     /* Event Generation */
 426     event_id = VehicleCreateEvent(msg->data.pno);
 427
 428     /* Publish Events */
 429     (void)_pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, event_val);
 430
 431     if (VEHICLE_RET_NORMAL == event_val) {
 432         /* Successful delivery registration */
 433         /* Deliver data for the first time */
 434         VehicleSensFirstDelivery((PNO)(msg->data.pno), (DID)(msg->data.did));
 435     }
 436
 437     /* Event deletion */
 438     (void)VehicleDeleteEvent(event_id);
 439
 440     /* Internal debug log output */
 441     FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "-");
 442 }
 443
 444 /*******************************************************************************
 445 * MODULE    : VehicleSensGetVehicleData
 446 * ABSTRACT  : Vehicle sensor information acquisition
 447 * FUNCTION  :
 448 * ARGUMENT  : *msg  : message buffer
 449 * NOTE      :
 450 * RETURN    : void
 451 ******************************************************************************/
 452 void VehicleSensGetVehicleData(const VEHICLE_MSG_GET_VEHICLE_DATA *msg) {
 453     void    *share_top;            /* Start address of shared memory */
 454     u_int32    share_size;          /* Size of shared memory area */
 455     u_int8    get_method;          /* Data collection way */
 456     VEHICLESENS_DATA_MASTER    master;    /* Data master */
 457     RET_API    ret_api;
 458     int32    ret_val;
 459     int32    event_val;
 460     EventID    event_id;
 461     SENSOR_MSG_GPSDATA_DAT    gps_master;  /* GPS Data Master */
 462
 463     /* Check the DID */
 464     ret_val = VehicleSensCheckDid(msg->data.did);
 465     if (VEHICLESENS_INVALID != ret_val) {  // LCOV_EXCL_BR_LINE 6:did always valid
 466         /* DID normal */
 467
 468         /* Link to shared memory */
 469         ret_api = _pb_LinkShareData(const_cast<char *>(VEHICLE_SHARE_NAME), &share_top, &share_size);
 470         if (RET_NORMAL == ret_api) {
 471             /* Acquire the specified data from the data master. */
 472             get_method = VehicleSensGetSelectionItemList(msg->data.did);
 473             if ((VEHICLESENS_GETMETHOD_GPS == get_method) &&
 474                 ((msg->data.did != VEHICLE_DID_LOCATION_LONLAT)   &&
 475                 (msg->data.did != VEHICLE_DID_LOCATION_ALTITUDE) &&
 476                 (msg->data.did != VEHICLE_DID_MOTION_HEADING))) {
 477                 /* _CWORD71_ processing speed(Memset modification) */
 478                 /* Retrieval of the data master fails.,Initialize size to 0 to prevent unauthorized writes */
 479                 gps_master.us_size = 0;
 480                 VehicleSensGetGpsDataMaster(msg->data.did, get_method, &gps_master);
 481                 /* Check the data size */
 482                 if (msg->data.size < gps_master.us_size) {
 483                     /* Shared memory error(Insufficient storage size) */
 484                     event_val = VEHICLE_RET_ERROR_OUTOF_MEMORY;
 485                 } else {
 486                     /* Write data master to shared memory */
 487                     PosSetShareData(share_top,
 488                                     msg->data.offset, (const void *)&gps_master.uc_data, gps_master.us_size);
 489
 490                     /* Set Successful Completion */
 491                     event_val = VEHICLE_RET_NORMAL;
 492                     SensLogWriteOutputData(SENSLOG_DATA_O_UNSPECIFIED,
 493                                             msg->data.did, msg->data.pno,
 494                                             reinterpret_cast<uint8_t *>(&(gps_master.uc_data[0])),
 495                                             gps_master.us_size, SENSLOG_RES_SUCCESS);
 496                 }
 497             } else {
 498                 (void)memset(reinterpret_cast<void *>(&master), 0, sizeof(VEHICLESENS_DATA_MASTER));
 499                 VehicleSensGetDataMaster(msg->data.did, get_method, &master);
 500
 501                 /* Check the data size */
 502                 if (msg->data.size < master.us_size) {
 503                     /* Shared memory error(Insufficient storage size) */
 504                     event_val = VEHICLE_RET_ERROR_OUTOF_MEMORY;
 505                 } else {
 506                     /* Write data master to shared memory */
 507                     PosSetShareData(share_top,
 508                                     msg->data.offset, (const void *)master.uc_data, master.us_size);
 509
 510                     /* Set Successful Completion */
 511                     event_val = VEHICLE_RET_NORMAL;
 512                     SensLogWriteOutputData(SENSLOG_DATA_O_UNSPECIFIED,
 513                                             msg->data.did, msg->data.pno,
 514                                             reinterpret_cast<uint8_t *>(&(master.uc_data[0])),
 515                                             master.us_size, SENSLOG_RES_SUCCESS);
 516                 }
 517             }
 518         } else {
 519             /* Shared memory error */
 520             event_val = VEHICLE_RET_ERROR_OUTOF_MEMORY;
 521         }
 522     } else {
 523         /* DID error */
 524         event_val = VEHICLE_RET_ERROR_DID;
 525     }
 526
 527     /* Event Generation */
 528     event_id = VehicleCreateEvent(msg->data.pno);
 529
 530     /* Publish Events */
 531     ret_api = _pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, event_val);
 532     if (RET_NORMAL != ret_api) {
 533         /* Event issuance failure */
 534         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_SetEvent ERROR!! [ret_api = %d]", ret_api);
 535     }
 536
 537     /* Event deletion */
 538     (void)VehicleDeleteEvent(event_id);
 539
 540     return;
 541 }
 542
 543 /*******************************************************************************
 544 * MODULE    : VehicleSensWatchStopPage
 545 * ABSTRACT  : Vehicle sensor interruption monitoring
 546 * FUNCTION  :
 547 * ARGUMENT  : *msg  : message buffer
 548 * NOTE      :
 549 * RETURN    : void
 550 ******************************************************************************/
 551 void VehicleSensWatchStopPage(const VEHICLE_MSG_WATCH_STOPPAGE *msg) {  // LCOV_EXCL_START 8 : dead code
 552     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 553     /* Not used(Delete Used Functions After Investigation) */
 554 }
 555 // LCOV_EXCL_STOP
 556
 557 /*******************************************************************************
 558 * MODULE    : VehicleSensPkgDeliveryEntry
 559 * ABSTRACT  : Vehicle sensor information package delivery registration
 560 * FUNCTION  :
 561 * ARGUMENT  : *msg  : message buffer
 562 * NOTE      :
 563 * RETURN    : void
 564 ******************************************************************************/
 565 void VehicleSensPkgDeliveryEntry(const SENSOR_MSG_DELIVERY_ENTRY *msg) {  // LCOV_EXCL_START 8 : dead code
 566     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 567     int32  event_val;
 568     EventID  event_id;
 569
 570     /* Call the process of creating the delivery destination management table */
 571     event_val = static_cast<int32>(VehicleSensEntryPkgDeliveryCtrl(msg , VEHICLESENS_EXT_OFF));
 572     /* #Polaris_003 */
 573
 574     /* Event Generation */
 575     event_id = PosCreateEvent(msg->data.pno);
 576
 577     /* Publish Events */
 578     (void)_pb_SetEvent(msg->data.event_id, SAPI_EVSET_ABSOLUTE, event_val);
 579
 580     if (VEHICLE_RET_NORMAL == event_val) {
 581         /* Successful delivery registration */
 582         /* Deliver package data for the first time */
 583         VehicleSensFirstPkgDelivery(&msg->data);
 584     }
 585
 586     /* Event deletion */
 587     (void)PosDeleteEvent(event_id);
 588 }
 589 // LCOV_EXCL_STOP
 590
 591 #if CONFIG_SENSOR_EXT_VALID        /* Initial Sensor Support */
 592 /*******************************************************************************
 593 * MODULE    : VehicleSensPkgDeliveryEntryExt
 594 * ABSTRACT  : Vehicle Sensor Information Extended Package Delivery Registration
 595 * FUNCTION  :
 596 * ARGUMENT  : *msg  : message buffer
 597 * NOTE      :
 598 * RETURN    : void
 599 ******************************************************************************/
 600 void VehicleSensPkgDeliveryEntryExt(const SENSOR_MSG_DELIVERY_ENTRY *msg) {
 601     int32  event_val;
 602
 603     /* Internal debug log output */
 604     FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "+");
 605
 606     /* Call the process of creating the delivery destination management table */
 607     event_val = static_cast<int32>(VehicleSensEntryPkgDeliveryCtrl(msg , VEHICLESENS_EXT_ON));
 608
 609     /* Event Generation */
 610     (void)PosCreateEvent(msg->data.pno);
 611
 612     /* Publish Events */
 613     (void)_pb_SetEvent(msg->data.event_id, SAPI_EVSET_ABSOLUTE, event_val);
 614
 615     if (VEHICLE_RET_NORMAL == event_val) {
 616         /* Successful delivery registration */
 617         /* Provide initial expansion package data delivery */
 618         VehicleSensFirstPkgDeliveryExt(&msg->data);
 619
 620         /* Initial expansion package data delivered */
 621         g_sent_fst_pkg_delivery_ext = TRUE;
 622
 623         FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__,
 624                       "FirstPkgDeliveryExt call.[%d]",
 625                       g_sent_fst_pkg_delivery_ext); /* TODO */
 626     }
 627
 628     /* Internal debug log output */
 629     FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "-");
 630 }
 631
 632 #else
 633 /*******************************************************************************
 634 * MODULE    : VehicleSensPkgDeliveryEntryError
 635 * ABSTRACT  : Vehicle Sensor Information Extended Package Delivery Registration
 636 * FUNCTION  :
 637 * ARGUMENT  : *msg  : message buffer
 638 * NOTE      :
 639 * RETURN    : void
 640 ******************************************************************************/
 641 void VehicleSensPkgDeliveryEntryError(const SENSOR_MSG_DELIVERY_ENTRY *msg) {
 642     RET_API  ret_api;
 643     EventID  event_id;
 644
 645     /* Event Generation */
 646     event_id = PosCreateEvent(msg->data.pno);
 647
 648     /* Publish Event Set DID Error */
 649     ret_api = _pb_SetEvent(msg->data.event_id, SAPI_EVSET_ABSOLUTE, VEHICLE_RET_ERROR_DID);
 650 }
 651
 652 #endif
 653
 654 /*******************************************************************************
 655 * MODULE    : VehicleSensGetVehiclePkgData
 656 * ABSTRACT  : Vehicle sensor information package data acquisition
 657 * FUNCTION  :
 658 * ARGUMENT  : *msg  : message buffer
 659 * NOTE      :
 660 * RETURN    : void
 661 ******************************************************************************/
 662 void VehicleSensGetVehiclePkgData(const SENSOR_MSG_GET_SENSOR_DATA *msg) {  // LCOV_EXCL_START 8 : dead code
 663     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 664 }
 665 // LCOV_EXCL_STOP
 666
 667 /*******************************************************************************
 668 * MODULE    : VehicleSensLineSensDataDelivery
 669 * ABSTRACT  : LineSensor Vehicle Signal Notification
 670 * FUNCTION  :
 671 * ARGUMENT  : *msg      : message buffer
 672 *           : p_datamaster_set_n  : Data Master Set Notification(Callback function)
 673 * NOTE      :
 674 * RETURN    : void
 675 ******************************************************************************/
 676 void VehicleSensLineSensDataDelivery(const LSDRV_MSG_LSDATA *msg, PFUNC_DMASTER_SET_N p_datamaster_set_n) {
 677     int32  i;
 678     BOOL  sens_ext;
 679
 680     sens_ext = TRUE;
 681
 682     for (i = 0; i < msg->st_para.uc_data_num; i++) {
 683         /* Setting Vehicle Signal Data from LineSensor as Data Master */
 684         VehicleSensSetDataMasterLineSens((const LSDRV_LSDATA *) & (msg->st_para.st_data[i]),
 685                                           p_datamaster_set_n, sens_ext);
 686     }
 687 }
 688
 689 /*******************************************************************************
 690 * MODULE    : VehicleSensLineSensDataDeliveryG
 691 * ABSTRACT  : LineSensor Vehicle Signal Notification
 692 * FUNCTION  :
 693 * ARGUMENT  : *msg      : message buffer
 694 *           : p_datamaster_set_n  : Data Master Set Notification(Callback function)
 695 * NOTE      :
 696 * RETURN    : void
 697 ******************************************************************************/
 698 void VehicleSensLineSensDataDeliveryG(const LSDRV_MSG_LSDATA_G *msg, PFUNC_DMASTER_SET_N p_datamaster_set_n) {
 699     int32  i;
 700     BOOL  sens_ext;
 701
 702     sens_ext = TRUE;
 703     if (g_sent_fst_pkg_delivery_ext == TRUE) {
 704         /* Initial Expansion Package Data Delivery,Without storing extended data */
 705         sens_ext = FALSE;
 706     }
 707
 708     for (i = 0; i < msg->st_para.uc_data_num; i++) {
 709         /* Setting Vehicle Signal Data from LineSensor as Data Master */
 710         VehicleSensSetDataMasterLineSensG((const LSDRV_LSDATA_G *) & (msg->st_para.st_data[i]),
 711                                               p_datamaster_set_n, sens_ext);
 712     }
 713 }
 714
 715 /*******************************************************************************
 716 * MODULE    : VehicleSensLineSensDataDeliveryGyroTrouble
 717 * ABSTRACT  : Gyro Failure Status Notification
 718 * FUNCTION  : Notify of a gyro failure condition
 719 * ARGUMENT  : *msg      : message buffer
 720 *           : p_datamaster_set_n  : Data Master Set Notification(Callback function)
 721 * NOTE      :
 722 * RETURN    : void
 723 ******************************************************************************/
 724 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)
 725     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 726     /* Setting Gyro Failure Status Data from LineSensor to Data Master */
 727     VehicleSensSetDataMasterGyroTrouble((const LSDRV_MSG_LSDATA_DAT_GYRO_TROUBLE *)&(msg->st_para),
 728                                            p_datamaster_set_n);
 729 }
 730 // LCOV_EXCL_STOP
 731
 732 /*******************************************************************************
 733 * MODULE    : VehicleSensLineSensDataDeliverySysGpsInterruptSignal
 734 * ABSTRACT  : SYS GPS interrupt notification
 735 * FUNCTION  : Notify SYS GPS interrupt signals
 736 * ARGUMENT  : *msg            : message buffer
 737 *           : p_datamaster_set_sharedmemory  : Data Master Set Notification(Callback function)
 738 * NOTE      :
 739 * RETURN    : void
 740 ******************************************************************************/
 741 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)
 742     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 743     /* Sets the SYS GPS interrupt data from the LineSensor to the data master. */
 744     VehicleSensSetDataMasterSysGpsInterruptSignal((const LSDRV_MSG_LSDATA_DAT_GPS_INTERRUPT_SIGNAL *)&(msg->st_para),
 745                                                     p_datamaster_set_sharedmemory);
 746 }
 747 // LCOV_EXCL_STOP
 748
 749 /*******************************************************************************
 750 * MODULE    : VehicleSensLineSensDataDeliveryGyroConnectStatus
 751 * ABSTRACT  : Gyro Connection Status Notification
 752 * FUNCTION  : Notify the state of the gyro connection
 753 * ARGUMENT  : *msg            : message buffer
 754 *           : p_datamaster_set_sharedmemory  : Data Master Set Notification(Callback function)
 755 * NOTE      :
 756 * RETURN    : void
 757 ******************************************************************************/
 758 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)
 759     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 760     /* Setting Gyro Connection Status Data from LineSensor to Data Master */
 761     VehicleSensSetDataMasterGyroConnectStatus((const LSDRV_MSG_LSDATA_DAT_GYRO_CONNECT_STATUS *)&(msg->st_para),
 762                                                 p_datamaster_set_sharedmemory);
 763 }
 764 // LCOV_EXCL_STOP
 765
 766 /*******************************************************************************
 767 * MODULE    : VehicleSensLineSensDataDeliveryGpsAntennaStatus
 768 * ABSTRACT  : GPS Antenna Connection Status Notification
 769 * FUNCTION  : Notify the GPS antenna connection status
 770 * ARGUMENT  : *msg      : message buffer
 771 *           : p_datamaster_set_n  : Data Master Set Notification(Callback function)
 772 * NOTE      :
 773 * RETURN    : void
 774 ******************************************************************************/
 775 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)
 776     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 777     /* Setting GPS Antenna Connection Status Data from LineSensor as Data Master */
 778     VehicleSensSetDataMasterGpsAntennaStatus((const LSDRV_MSG_LSDATA_DAT_GPS_ANTENNA_STATUS *)&(msg->st_para),
 779                                                p_datamaster_set_n);
 780 }
 781 // LCOV_EXCL_STOP
 782
 783 #if CONFIG_SENSOR_EXT_VALID        /* Initial Sensor Support */
 784 /*******************************************************************************
 785 * MODULE    : VehicleSensLineSensDataDeliveryFst
 786 * ABSTRACT  : LineSensor Vehicle Signal Notification(Initial Sensor)
 787 * FUNCTION  :
 788 * ARGUMENT  : *msg      : message buffer
 789 *           : p_datamaster_set_n  : Data Master Set Notification(Callback function)
 790 * NOTE      :
 791 * RETURN    : void
 792 ******************************************************************************/
 793 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)
 794     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 795 }
 796 // LCOV_EXCL_STOP
 797 #endif
 798
 799 #if CONFIG_SENSOR_EXT_VALID        /* Initial Sensor Support */
 800 /*******************************************************************************
 801 * MODULE    : VehicleSensLineSensDataDeliveryFstG
 802 * ABSTRACT  : LineSensor Vehicle Signal Notification(Initial Sensor)
 803 * FUNCTION  :
 804 * ARGUMENT  : *msg      : message buffer
 805 *           : p_datamaster_set_n  : Data Master Set Notification(Callback function)
 806 * NOTE      :
 807 * RETURN    : void
 808 ******************************************************************************/
 809 void VehicleSensLineSensDataDeliveryFstG(const LSDRV_MSG_LSDATA_FST *msg, PFUNC_DMASTER_SET_N p_datamaster_set_n) {
 810     /* Internal debug log output */
 811     FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "+");
 812
 813     if (msg == NULL) {  // LCOV_EXCL_BR_LINE 6:msg cannot be null
 814         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 815         FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "msg == NULL\r\n");  // LCOV_EXCL_LINE 8: dead code
 816     } else {
 817         /* Set Vehicle Signal Data from LineSensor (Initial Sensor) as Data Master */
 818         VehicleSensSetDataMasterLineSensFstG((const LSDRV_MSG_LSDATA_DAT_FST *) & (msg->st_para),
 819                 p_datamaster_set_n);
 820     }
 821
 822     /* Internal debug log output */
 823     FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "-");
 824 }
 825 #endif
 826
 827 /*******************************************************************************
 828 * MODULE    : VehicleSensGpsDataDelivery
 829 * ABSTRACT  : GPS data notification
 830 * FUNCTION  :
 831 * ARGUMENT  : *msg            : message buffer
 832 *           : p_datamaster_set_n        : For Data Master Set Notification(Callback function) delivery
 833 *           : p_datamaster_set_sharedmemory  : Data Master Set Notification (Callback Function) Shared Memory Write
 834 * NOTE      :
 835 * RETURN    : void
 836 ******************************************************************************/
 837 void VehicleSensGpsDataDelivery(SENSOR_MSG_GPSDATA *msg,
 838                                 PFUNC_DMASTER_SET_N p_datamaster_set_n,
 839                                 PFUNC_DMASTER_SET_SHARED_MEMORY p_datamaster_set_sharedmemory) {
 840     /* Setting GPS Data as Data Master */
 841     if (msg->st_para.ul_did == VEHICLE_DID_MAIN_GPS_INTERRUPT_SIGNAL) {  // LCOV_EXCL_BR_LINE 6:DID is not used
 842         // LCOV_EXCL_START 8: dead code
 843         AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 844         /* [PastModel002 Specifications] GPS->_CWORD102_ interrupt or not is obtained from GPS */
 845         VehicleSensSetDataMasterMainGpsInterruptSignal((const SENSOR_MSG_GPSDATA_DAT *)&(msg->st_para),
 846                                                          p_datamaster_set_sharedmemory);
 847         // LCOV_EXCL_STOP
 848     } else {
 849         FRAMEWORKUNIFIEDLOG(ZONE_27, __FUNCTION__,
 850                       "VehicleSensGpsDataDelivery VehicleSensSetDataMasterGps() -->");
 851         VehicleSensSetDataMasterGps(reinterpret_cast<SENSOR_MSG_GPSDATA_DAT *>(&(msg->st_para)),
 852                                       p_datamaster_set_n);
 853         FRAMEWORKUNIFIEDLOG(ZONE_27, __FUNCTION__,
 854                       "VehicleSensGpsDataDelivery VehicleSensSetDataMasterGps() <--");
 855     }
 856 }
 857
 858 /*******************************************************************************
 859 * MODULE    : VehicleSensDataMasterSetN
 860 * ABSTRACT  : Data master set notification process(Callback function)
 861 * FUNCTION  : Call the data delivery process
 862 * ARGUMENT  : did    : Data ID
 863 *           : chg_type  : Change type(no change/with change)
 864 *           : get_method  : Acquisition method(Direct Line/CAN)
 865 * NOTE      :
 866 * RETURN    : void
 867 ******************************************************************************/
 868 void VehicleSensDataMasterSetN(DID did, u_int8 chg_type, u_int8 get_method) {
 869
 870   u_int8 chgType;
 871
 872   chgType = chg_type;
 873
 874   switch (did) {
 875     case POSHAL_DID_SPEED_KMPH:
 876     {
 877       if (ChkUnitType(UNIT_TYPE_GRADE1) == TRUE) {
 878         /* For creating PASCD Sentence of NMEA */
 879
 880         int ret;
 881         VEHICLESENS_VEHICLE_SPEED_DAT stVehicleSpeed;
 882
 883         ret = clock_gettime(CLOCK_MONOTONIC, &(stVehicleSpeed.ts));
 884         if (ret != 0) {
 885           FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "clock_gettime error:%m");
 886         } else {
 887           VEHICLESENS_DATA_MASTER stData;
 888           SENSORMOTION_SPEEDINFO_DAT* pSpdInfo;
 889
 890           VehicleSensGetMotionSpeed(&stData, VEHICLESENS_GETMETHOD_INTERNAL);  // LCOV_EXCL_BR_LINE 6:unexpected branch  //NOLINT (whitespace/line_length)
 891           pSpdInfo = (SENSORMOTION_SPEEDINFO_DAT*)(stData.uc_data);
 892
 893           stVehicleSpeed.speed = pSpdInfo->Speed;
 894
 895           VehicleSens_StoreVehicleSpeed(&stVehicleSpeed);  // LCOV_EXCL_BR_LINE 6:unexpected branch  //NOLINT (whitespace/line_length)
 896         }
 897       }
 898
 899       break;
 900     }
 901     case POSHAL_DID_GPS_NMEA:
 902     {
 903       VehilceSens_InitVehicleSpeed();
 904
 905       break;
 906     }
 907     default:
 908       break;
 909   }
 910
 911   /* Call the data delivery process */
 912   VehicleSensDeliveryProc( did, chgType, get_method );
 913 }
 914
 915 /*******************************************************************************
 916 * MODULE    : VehicleSensDataMasterSetSharedMemory
 917 * ABSTRACT  : Data master set notification process(Callback function)
 918 * FUNCTION  : Call Write Shared Memory
 919 * ARGUMENT  : did    : Data ID
 920 *           : chg_type  : Whether or not data is updated
 921 * NOTE      :
 922 * RETURN    : void
 923 ******************************************************************************/
 924 void VehicleSensDataMasterSetSharedMemory(DID did, u_int8 chg_type) {  // LCOV_EXCL_START 8: dead code
 925     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 926     /* When there is no change, the shared memory write process is not called. */
 927     if (chg_type == VEHICLESENS_NEQ) {
 928         VehicleSensWriteSharedMemory(did);
 929     }
 930 }
 931 // LCOV_EXCL_STOP
 932
 933 /* ++ GPS _CWORD82_ support */
 934 /*******************************************************************************
 935 * MODULE    : VehicleSensSetVehicleData
 936 * ABSTRACT  : GPS command request processing
 937 * FUNCTION  : Transfer a GPS command request
 938 * ARGUMENT  : *msg  : message buffer
 939 * NOTE      :
 940 * RETURN    : void
 941 ******************************************************************************/
 942 void VehicleSensSetVehicleData(const VEHICLE_MSG_SEND *msg) {
 943     u_int16    size;            /* Data length setting          */
 944     u_int16    all_len;          /* Sent message length          */
 945     u_int16    mode;            /* Mode information            */
 946     RID      req_id = 0;          /* Resources ID            */
 947
 948     T_APIMSG_MSGBUF_HEADER  header;      /* Message header          */
 949     TG_GPS_SND_DATA      data;      /* Message body          */
 950     u_int8  snd_buf[(sizeof(T_APIMSG_MSGBUF_HEADER) + sizeof(TG_GPS_SND_DATA))];
 951
 952     /* Message header generation */
 953     size = sizeof(data);
 954     header.signo = 0;            /* Signal information        */
 955     header.hdr.sndpno = PNO_VEHICLE_SENSOR;  /* Source thread number      */
 956     header.hdr.respno = 0;          /* Destination process No.      */
 957     header.hdr.cid = CID_GPS__CWORD82__REQUEST;  /* Command ID          */
 958     header.hdr.msgbodysize = size;      /* Message data length setting    */
 959     header.hdr.rid = req_id;          /* Resource ID Setting        */
 960     header.hdr.reserve = 0;          /* Reserved Area Clear      */
 961
 962     /* Message body generating */
 963     data.us_size = msg->data.size;
 964     memcpy(&(data.ub_data[0]), &(msg->data.data[0]), msg->data.size);
 965
 966     /* Reserved Area Clear      */
 967     data.reserve[0] = 0;
 968     data.reserve[1] = 0;
 969     data.reserve[2] = 0;
 970     data.reserve[3] = 0;
 971
 972     /* Message generation */
 973     (void)memcpy(&snd_buf[0], &header, sizeof(header));
 974     (void)memcpy(&snd_buf[sizeof(header)], &data, sizeof(data));
 975     all_len = static_cast<u_int16>(size + sizeof(header));
 976     mode    = 0;
 977
 978     FRAMEWORKUNIFIEDLOG(ZONE_27, __FUNCTION__, "VehicleSensSetVehicleData NMEA = %s", data.ub_data);
 979     (void)_pb_SndMsg(PNO_NAVI_GPS_MAIN, all_len, reinterpret_cast<void *>(&snd_buf[0]), mode);
 980 }
 981
 982 /*******************************************************************************
 983  * MODULE    : VehicleSensDrDeliveryEntry
 984  * ABSTRACT  : Sensor Internal Information Delivery Registration for DR
 985  * FUNCTION  :
 986  * ARGUMENT  : *msg  : message buffer
 987  * NOTE      :
 988  * RETURN    : void
 989  ******************************************************************************/
 990 void VehicleSensDrDeliveryEntry(const VEHICLE_MSG_DELIVERY_ENTRY *msg) {  // LCOV_EXCL_START 8 : dead code
 991     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 992     int32  event_val;
 993     EventID  event_id;
 994
 995     /* Call the process of creating the delivery destination management table */
 996     event_val = static_cast<int32>(DeadReckoningEntryDeliveryCtrl((const DEADRECKONING_MSG_DELIVERY_ENTRY*)msg));
 997     /* #QAC confirmation Rule11.4 Member reference to suppress address reference error in data R/W */
 998
 999     /* Event Generation */
1000     event_id = VehicleCreateEvent(msg->data.pno);
1001
1002     /* Publish Events */
1003     (void)_pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, event_val);
1004
1005     if (VEHICLE_RET_NORMAL == event_val) {
1006         /* Successful delivery registration */
1007         /* Deliver data for the first time */
1008         DeadReckoningFirstDelivery((PNO)(msg->data.pno), (DID)(msg->data.did));
1009     }
1010 }
1011 // LCOV_EXCL_STOP
1012
1013 /*******************************************************************************
1014  * MODULE    : VehicleSensGetLog
1015  * ABSTRACT  : Log acquisition request
1016  * FUNCTION  :
1017  * ARGUMENT  : *msg  : message buffer
1018  * NOTE      :
1019  * RETURN    : void
1020  ******************************************************************************/
1021 void VehicleSensGetLog(const VEHICLEDEBUG_MSG_BUF *msg) {  // LCOV_EXCL_START 8 : dead code
1022     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1023     DeadReckoningGetLocationLogStatus(msg->hdr.hdr.sndpno);
1024 }
1025 // LCOV_EXCL_STOP
1026
1027 /*******************************************************************************
1028  * MODULE    : VehicleSensSetLog
1029  * ABSTRACT  : Log Setting Request
1030  * FUNCTION  :
1031  * ARGUMENT  : *msg  : message buffer
1032  * NOTE      :
1033  * RETURN    : void
1034  ******************************************************************************/
1035 void VehicleSensSetLog(const VEHICLEDEBUG_MSG_BUF* msg) {  // LCOV_EXCL_START 8 : dead code
1036     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1037     return;
1038 }
1039 // LCOV_EXCL_STOP
1040
1041 /*******************************************************************************
1042  * MODULE    : VehicleSensWriteLocalTime
1043  * ABSTRACT  : Set LOCALTIME to non-volatile
1044  * FUNCTION  :
1045  * ARGUMENT  : *msg  : message buffer
1046  * NOTE      :
1047  * RETURN    : void
1048  ******************************************************************************/
1049 void VehicleSensWriteLocalTime(const CANINPUT_MSG_INFO *msg) {  // LCOV_EXCL_START 8 : dead code
1050     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1051     LOCALTIME  localtime = {0};
1052     int32    time_diff;
1053     RET_API    ret_write_api;
1054     static u_int8 cnt = 0U;    /* For update cycle count */
1055     if (msg != NULL) {
1056         memset(&time_diff, 0x00, sizeof(time_diff));  /* Coverity CID:18813 compliant */
1057
1058         /* Determine that the 1s cycle (cnt == 1) has elapsed for 1 second.  */
1059         cnt++;
1060
1061         /* When 5 seconds or more have elapsed since the last update    */
1062         /* Saving Time Information in Non-volatile Memory      */
1063         if (cnt >= NV_UPDATE_CYCLE_LOCALTIME) {
1064             /* Non-volatile write */
1065             ret_write_api = VehicleSensWriteNVLocaltime(&localtime, &time_diff);
1066             if (ret_write_api != RET_NORMAL) {
1067                 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "NV write error.");
1068             }
1069             cnt = 0U;
1070         }
1071     } else {
1072         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "ARGUMENT NULL");
1073     }
1074 }
1075 // LCOV_EXCL_STOP
1076
1077 /*******************************************************************************
1078 * MODULE    : VehicleSensSetEphNumSharedMemory
1079 * ABSTRACT  : Write effective ephemeris number to shared memory
1080 * FUNCTION  :
1081 * ARGUMENT  : *msg  : message buffer
1082 * NOTE      :
1083 * RETURN    : void
1084 ******************************************************************************/
1085 void VehicleSensSetEphNumSharedMemory(const SENSOR_MSG_GPSDATA *msg) {  // LCOV_EXCL_START 8 : dead code
1086     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1087     RET_API    ret_api;
1088     u_int8    ephemeris_num;
1089
1090     if (msg != NULL) {
1091         ephemeris_num = msg->st_para.uc_data[0];
1092
1093         ret_api = VehicleSensWriteDataValidEphemerisNum(ephemeris_num);
1094
1095         if (ret_api != RET_NORMAL) {
1096             FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Share Memory write error.");
1097         }
1098     }
1099
1100     return;
1101 }
1102 // LCOV_EXCL_STOP
1103
1104 /*******************************************************************************
1105 * MODULE    : VehicleSensDrRcvMsg
1106 * ABSTRACT  : Data delivery for DR,Write location information to shared memory
1107 * FUNCTION  :
1108 * ARGUMENT  : const EPHEMERIS_NUM_DATA_DAT * : Incoming message
1109 * NOTE      :
1110 * RETURN    : void
1111 ******************************************************************************/
1112 void  VehicleSensDrRcvMsg(const DEAD_RECKONING_RCVDATA * msg) {  // LCOV_EXCL_START 8 : dead code
1113     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1114     DEAD_RECKONING_LONLAT_INFO lonlat_info;
1115
1116     if (msg != NULL) {
1117         DeadReckoningRcvMsg(msg, &lonlat_info);
1118
1119         /* Process for storing location information in non-volatile memory during shutdown    */
1120         /* With a refresh interval of 1 second,Save only when location information is valid data    */
1121         if (lonlat_info.calc_called == TRUE) {
1122             static u_int8 cnt = 0U;  /* For update cycle count */
1123
1124             /* Sensor data is 100ms cycle,Determine that (cnt == 10) has elapsed for 1 second  */
1125             /* Cnt increments to 10                  */
1126             if (cnt < NV_UPDATE_CYCLE_LONLAT) {
1127                 cnt++;
1128             }
1129
1130             /* When 1 second or more has elapsed since the last update and the location information is valid,    */
1131             /* Saving Location Information in Non-Volatile Memory                  */
1132             if ((cnt >= NV_UPDATE_CYCLE_LONLAT) && (lonlat_info.available == static_cast<u_int8>(TRUE))) {
1133                 VehicleSensStoreLonlat(&(lonlat_info.lonlat));
1134                 cnt = 0U;
1135             }
1136         }
1137     } else {
1138         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "ARGUMENT NULL");
1139     }
1140
1141     return;
1142 }
1143 // LCOV_EXCL_STOP
1144
1145 /**
1146  * @brief
1147  *  Data setting process
1148  *
1149  *  Setting Specified Data to Data Master
1150  *
1151  * @param[in]   const VEHICLE_MSG_BUF *msg       : message buffer
1152  * @param[out]  PFUNC_DMASTER_SET_N p_datamaster_set_n : Data Master Set Notification(Callback function)
1153  * @return      none
1154  * @retval      none
1155  */
1156 void VehicleSensCommonDataDelivery(const VEHICLE_MSG_BUF *msg, PFUNC_DMASTER_SET_N p_datamaster_set_n) {
1157     const POS_MSGINFO  *pstPosMsg = (const POS_MSGINFO *) & (msg->data[0]);
1158
1159     /* Individual processing for each data ID */
1160     switch (pstPosMsg->did) {
1161         case VEHICLE_DID_SETTINGTIME:
1162         {
1163             /* By checking the evacuation message information,Determine whether the GPS time has already been set and requested */
1164             if (NULL == g_wait_for_resp_set_n) {
1165                 /* GPS time settable */
1166                 /* GPS time setting data transmission */
1167                 VehicleSensGpsTimeSndMsg(pstPosMsg);
1168
1169                 /* Save message information(Used when a response is received.)*/
1170                 (void)memcpy(&g_wait_for_resp_msg, msg, sizeof(VEHICLE_MSG_BUF));
1171                 g_wait_for_resp_set_n = p_datamaster_set_n;
1172             } else {
1173                 /* GPS time setting process is already in progress:Reply BUSY to requesting processes */
1174                 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "SetGpsTime already.");
1175             }
1176             break;
1177         }
1178         default:
1179             /* Set the specified data in the data master */
1180             VehicleSensSetDataMasterData((const POS_MSGINFO *)msg->data, p_datamaster_set_n);
1181             break;
1182     }
1183
1184     return;
1185 }
1186
1187 /**
1188  * @brief
1189  *  GPS time setting data transmission process
1190  *
1191  *  Send the specified data to the GPS thread
1192  *
1193  * @param[in]   const POS_MSGINFO *pos_msg       : message buffer
1194  * @return      none
1195  * @retval      none
1196  */
1197 void VehicleSensGpsTimeSndMsg(const POS_MSGINFO *pos_msg) {
1198     RET_API    ret_api = RET_NORMAL;    /* System API return value */
1199     u_int16    size = 0;          /* Data length setting */
1200     u_int16    all_len = 0;        /* Sent message length */
1201     u_int16    mode = 0;          /* Mode information */
1202     RID      req_id = 0;          /* Resources ID */
1203     T_APIMSG_MSGBUF_HEADER  header;      /* Message header */
1204     TG_GPS_SND_DATA      data;      /* Message body */
1205     u_int8    snd_buf[(sizeof(T_APIMSG_MSGBUF_HEADER) + sizeof(TG_GPS_SND_DATA))];
1206
1207     memset(&header, 0x00, sizeof(T_APIMSG_MSGBUF_HEADER));
1208     memset(&data, 0x00, sizeof(TG_GPS_SND_DATA));
1209
1210     /* Message header generation */
1211     size = sizeof(data);
1212     header.signo = 0;            /* Signal information          */
1213     header.hdr.sndpno = PNO_VEHICLE_SENSOR;  /* Source thread number      */
1214     header.hdr.respno = 0;          /* Destination process No.      */
1215     header.hdr.cid = CID_GPS_TIMESETTING;  /* Command ID          */
1216     header.hdr.msgbodysize = size;      /* Message data length setting  */
1217     header.hdr.rid = req_id;          /* Resource ID Setting        */
1218
1219     /* Message body generating */
1220     data.us_size = pos_msg->size;
1221     memcpy(&(data.ub_data[0]), &(pos_msg->data[0]), pos_msg->size);
1222
1223     /* Messaging */
1224     (void)memcpy(&snd_buf[0], &header, sizeof(header));
1225     (void)memcpy(&snd_buf[sizeof(header)], &data, sizeof(data));
1226     all_len = static_cast<u_int16>(size + sizeof(header));
1227     mode   = 0;
1228     ret_api = _pb_SndMsg(PNO_NAVI_GPS_MAIN, all_len, reinterpret_cast<void *>(&snd_buf[0]), mode);
1229     if (RET_NORMAL != ret_api) {
1230         /* Message transmission processing failed */
1231         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "send Message failed.");
1232     }
1233
1234     return;
1235 }
1236
1237 /**
1238  * @brief
1239  *  GPS time setting result notification process
1240  *
1241  *  Setting Specified Data to Data Master
1242  *
1243  * @param[in]   const VEHICLE_MSG_BUF *msg       : message buffer
1244  * @return      none
1245  * @retval      none
1246  */
1247 void VehicleSensGpsTimeDelivery(const VEHICLE_MSG_BUF *msg) {
1248     int32              event_val = POS_RET_ERROR_INNER;  /* Event value */
1249     const TG_GPS_RET_TIMESET_MSG  *gps_ret_time;            /* GPS time setting response message */
1250
1251     /* Determine the GPS time setting result */
1252     gps_ret_time = (const TG_GPS_RET_TIMESET_MSG *)msg;
1253
1254     if (GPS_SENDOK == gps_ret_time->status) {
1255         event_val = POS_RET_NORMAL;
1256     } else {
1257         event_val = POS_RET_ERROR_TIMEOUT;
1258     }
1259
1260     /* Set the specified data in the data master */
1261     if (POS_RET_NORMAL == event_val) {
1262         VehicleSensSetDataMasterData((const POS_MSGINFO *)&g_wait_for_resp_msg.data, g_wait_for_resp_set_n);
1263     }
1264     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
1265                   "SetGpsTime Result[%d] EventVal[%d]",
1266                   static_cast<uint32_t>(gps_ret_time->status), static_cast<uint32_t>(event_val));
1267
1268     /* Clear saved message information */
1269     (void)memset(&g_wait_for_resp_msg, 0x00, sizeof(VEHICLE_MSG_BUF));
1270     g_wait_for_resp_set_n = NULL;
1271
1272     return;
1273 }
1274
1275 /**
1276  * @brief
1277  *  Specified process No. event transmission processing
1278  *
1279  *  Send an event to the specified process No.
1280  *
1281  * @param[in]   uint16_t snd_pno   : Destination process number
1282  * @param[in]   int32_t  event_val : Sent event value
1283  * @return      RET_API
1284  * @retval      RET_NORMAL      Normal completion<br>
1285  *              RET_ERROR       Event generation failure<br>
1286  *              RET_ERRPARAM    Configuration mode error<br>
1287  *              RET_EV_NONE     Specified event does not exist<br>
1288  *              RET_EV_MAX      The set event value exceeds the maximum value<br>
1289  *              RET_EV_MIN      The set event value is below the minimum value.
1290  */
1291 RET_API VehicleSensSendEvent(uint16_t snd_pno, int32_t event_val) {  // LCOV_EXCL_START 8 : dead code
1292     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1293     RET_API      ret_val = RET_ERROR;        /* Return value */
1294     EventID      event_id = 0;          /* Event ID */
1295
1296     /* Event Generation */
1297     event_id = VehicleCreateEvent(snd_pno);
1298     if (0 != event_id) {
1299         /* Event publishing(Release Event Wait) */
1300         ret_val = _pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, event_val);
1301         if (RET_NORMAL != ret_val) {
1302             /* Event issuance failure */
1303             FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "set Event failed.");
1304         }
1305
1306         /* Event deletion */
1307         (void)VehicleDeleteEvent(event_id);
1308     } else {
1309         /* Event generation failure */
1310         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "create Event failed.");
1311     }
1312
1313     return ret_val;
1314 }
1315 // LCOV_EXCL_STOP
1316
1317 /**
1318  * @brief
1319  *  Pos_Main thread stop processing
1320  */
1321 void VehicleSensThreadStopProcess(void) {
1322     /* Exit Process Implementation Point >>> */
1323
1324
1325     /* <<< Exit Process Implementation Point */
1326
1327     /* Thread stop processing */
1328     PosTeardownThread(ETID_POS_MAIN);
1329
1330     /* don't arrive here */
1331     return;
1332 }
1333
1334 /**
1335  * @brief
1336  *  Initialization of data interruption monitoring process<br>
1337  *  1.Initial data reception monitoring timer issuance
1338  */
1339 static void VehicleSensInitDataDisrptMonitor(void) {
1340
1341     /* Initial sensor data reception monitoring timer */
1342     VehicleUtilitySetTimer(SNS_FST_TIMER);
1343
1344     return;
1345 }
1346
1347 /**
1348  * @brief
1349  *  Data disruption monitoring process<br>
1350  *  1.Stop timer for monitoring initial data reception<br>
1351  *  2.Stop timer for periodic data reception monitoring<br>
1352  *  3.Periodic data reception monitoring timer issuance
1353  *
1354  * @param[in]   did  Data type
1355  */
1356 static void VehicleSensDataDisrptMonitorProc(DID did) {
1357     static BOOL is_rcv_sns_data = FALSE;
1358
1359     switch (did) {
1360         case POSHAL_DID_GYRO_X:
1361         case POSHAL_DID_GYRO_Y:
1362         case POSHAL_DID_GYRO_Z:
1363         case POSHAL_DID_GSNS_X:
1364         case POSHAL_DID_GSNS_Y:
1365         case POSHAL_DID_GSNS_Z:
1366         case POSHAL_DID_SPEED_PULSE:
1367         case POSHAL_DID_REV:
1368         case POSHAL_DID_GPS_ANTENNA:
1369         case POSHAL_DID_GYRO_EXT:
1370         case POSHAL_DID_GYRO_TEMP:
1371         case POSHAL_DID_PULSE_TIME:
1372         case POSHAL_DID_SNS_COUNTER:
1373         {
1374             if (is_rcv_sns_data == FALSE) {
1375                 /* Initial sensor data reception monitoring timer */
1376                 VehicleUtilityStopTimer(SNS_FST_TIMER);
1377                 is_rcv_sns_data = TRUE;
1378
1379                 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "is_rcv_sns_data=TRUE");
1380             }
1381
1382             /* Cyclic sensor data reception monitoring timer stopped */
1383             VehicleUtilityStopTimer(SNS_CYCLE_TIMER);
1384             /* Cyclic sensor data reception monitoring timer setting */
1385             VehicleUtilitySetTimer(SNS_CYCLE_TIMER);
1386             /* Sensor data interruption log output timer */
1387             VehicleUtilityStopTimer(SNS_DISRPT_TIMER);
1388
1389             break;
1390         }
1391         default:
1392         {
1393             /* nop */
1394         }
1395     }
1396
1397     return;
1398 }
1399
1400 /**
1401  * @brief
1402  *  Timeout message reception processing
1403  *
1404  * @param[in]   rcv_msg Incoming message
1405  */
1406 static void VehicleSensRcvMsgTout(TimerToutMsg* rcv_msg) {
1407     uint8_t tim_kind = static_cast<uint8_t>(rcv_msg->TimerSeq >> 8);
1408
1409     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "+ ### TIMEOUT ### Seq=0x%04x", rcv_msg->TimerSeq);
1410     switch (tim_kind) {
1411         case SNS_FST_TIMER:
1412         case SNS_CYCLE_TIMER:
1413         case SNS_DISRPT_TIMER:
1414         {
1415             /* Sensor data interruption log output timer setting */
1416             VehicleUtilityStopTimer(SNS_DISRPT_TIMER);
1417             VehicleUtilitySetTimer(SNS_DISRPT_TIMER);
1418             break;
1419         }
1420         default:
1421         {
1422             /* nop */
1423         }
1424     }
1425     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "-");
1426     return;
1427 }
1428
1429
1430 /**
1431  * @brief
1432  *  Initialize Vehilce Speed Information
1433  *
1434  * @details  This is for creating PASCD Sentence of NMEA. <br>
1435  *           You can initialize the buffer of Vehicle Speed Information.
1436  */
1437 static void VehilceSens_InitVehicleSpeed(void) {
1438   (void)memset(&g_vehicle_speed_info, 0x00, sizeof(g_vehicle_speed_info));
1439   return;
1440 }
1441
1442 /**
1443  * @brief
1444  *  Store Vehilce Speed Data
1445  *
1446  * @details  This is for creating PASCD Sentence of NMEA. <br>
1447  *           You can store Vehicle Speed Information for a cycle.
1448  *
1449  * @param[in]   VEHICLESENS_VEHICLE_SPEED_DAT* pVehicleSpeed : Speed [m/s] and TimeSpec
1450  */
1451 static void VehicleSens_StoreVehicleSpeed(VEHICLESENS_VEHICLE_SPEED_DAT* pVehicleSpeed) {
1452   VEHICLESENS_VEHICLE_SPEED_INFO* pInfo = &g_vehicle_speed_info;
1453
1454
1455 //  if (pInfo->sampleCount < VEHICLESENS_NMEA_PASCD_SAMPLECOUNT_MAX) {
1456   if (pInfo->sampleCount == 0) {
1457     (void)memcpy((pInfo->listSpd) + (pInfo->sampleCount), pVehicleSpeed, sizeof(VEHICLESENS_VEHICLE_SPEED_DAT));
1458     pInfo->sampleCount++;
1459
1460   } else if (pInfo->sampleCount < VEHICLESENS_NMEA_PASCD_SAMPLECOUNT_MAX) {
1461     (void)_pb_memcpy((pInfo->listSpd) + (pInfo->sampleCount), pVehicleSpeed, sizeof(VEHICLESENS_VEHICLE_SPEED_DAT));
1462
1463     VEHICLESENS_VEHICLE_SPEED_DAT* pS0 = &(pInfo->listSpd[0]);
1464     VEHICLESENS_VEHICLE_SPEED_DAT* pS = &(pInfo->listSpd[pInfo->sampleCount]);
1465     uint32_t ts_i; /* Interger Part of timestamp [s] */
1466     if (pS->ts.tv_nsec - pS0->ts.tv_nsec >= 0) {  // LCOV_EXCL_BR_LINE 200: can not less than zero
1467       ts_i = (pS->ts.tv_sec - pS0->ts.tv_sec) % VEHICLESENS_NMEA_PASCD_TS_MAX;
1468     } else {
1469       AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1470       ts_i = (pS->ts.tv_sec - pS0->ts.tv_sec - 1) % VEHICLESENS_NMEA_PASCD_TS_MAX;  // LCOV_EXCL_LINE 8: invalid
1471     }
1472     if (ts_i == 0) { /* Offset is 0 to 1 second */
1473         pInfo->sampleCount++;
1474     }
1475
1476   } else {
1477     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1478                   "WARNING: Num of stored datas is over 50. (%ld.%ld spd = %d)",
1479                   pVehicleSpeed->ts.tv_sec, pVehicleSpeed->ts.tv_nsec, pVehicleSpeed->speed );
1480   }
1481
1482   return;
1483 }
1484
1485 /**
1486  * @brief
1487  *  Load Vehicle Speed Information (Vehicle Speed Data x 50(max))
1488  *
1489  * @details  This is for creating PASCD Sentence of NMEA. <br>
1490  *           You can load Vehicle Speed Informations from the last initialization.
1491  *
1492  * @param[in]   VEHICLESENS_VEHICLE_SPEED_INFO* pVehicleSpeedInfo : Speeds [m/s] and TimeSpecs
1493  */
1494 static void VehicleSens_LoadVehicleSpeed(VEHICLESENS_VEHICLE_SPEED_INFO* pVehicleSpeedInfo) {
1495   (void)memcpy(pVehicleSpeedInfo, &g_vehicle_speed_info, sizeof(g_vehicle_speed_info));
1496   return;
1497 }
1498
1499 /**
1500  * @brief
1501  *  Concatenate NMEA Sentence Fields with Delimiter
1502  *
1503  * @details  This is for creating NMEA Sentence. <br>
1504  *           You can concatenate the two strings given as arguments 'str1' and 'str2'. <br>
1505  *           And at the time, it puts the delimiter between 'str1' and 'str2' automaticaly.
1506  *
1507  * @param[in]   char* str1         : destination
1508  * @param[in]   const size_t size  : buffer size of destination
1509  * @param[in]   const char* str2   : source
1510  * @param[in]   const size_t n     : copy size of source
1511  *
1512  * @return      RET_NORMAL         : success
1513  * @return      RET_ERROR          : failed
1514  */
1515 static RET_API VehicleSens_CatNmeaSentenceFieldWithDelimiter(char* str1, const size_t size,
1516                                                              const char* str2, const size_t n) {
1517   RET_API ret_api = RET_NORMAL;
1518
1519   size_t len1 = strlen(str1);
1520   size_t len2 = strlen(str2);
1521   size_t len3 = strlen(VEHICLESENS_NMEA_FIELDDELIMITER);
1522   size_t sn = n;
1523
1524   if (sn > len2) {  // LCOV_EXCL_BR_LINE 200: can not exceed size
1525     sn = len2;
1526   }
1527
1528   if (len1 + len3 + sn <= size - 1) {
1529     (void)strncat(str1, VEHICLESENS_NMEA_FIELDDELIMITER, len3); /* Add Delimiter (,) */
1530     (void)strncat(str1, str2, sn);
1531   } else {
1532     ret_api = RET_ERROR;
1533
1534     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1535     "ERROR: Buffer size is too small to connatenate. len1:%d len2:%d len3:%d n:%d", len1, len2, len3, n);
1536   }
1537
1538   return ret_api;
1539 }
1540
1541 /**
1542  * @brief
1543  *  Concatenate NMEA Sentence Fields without Delimiter
1544  *
1545  * @details This is for creating NMEA Sentence. <br>
1546  *          You can concatenate the two strings given as arguments 'str1' and 'str2'.
1547  *
1548  * @param[in]   char* str1          : destination
1549  * @param[in]   const size_t size   : buffer size of destination
1550  * @param[in]   const char* str2    : source
1551  * @param[in]   const size_t n      : copy size of source
1552  *
1553  * @return      RET_NORMAL         : success
1554  * @return      RET_ERROR          : failed
1555  */
1556 static RET_API VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(char* str1, const size_t size,
1557                                                                 const char* str2, const size_t n) {
1558   RET_API ret_api = RET_NORMAL;
1559
1560   size_t len1 = strlen(str1);
1561   size_t len2 = strlen(str2);
1562   size_t sn = n;
1563
1564   if (sn > len2) {  // LCOV_EXCL_BR_LINE 200: can not exceed  size
1565     sn = len2;
1566   }
1567
1568   if (len1 + sn <= size - 1) {
1569     (void)strncat(str1, str2, sn);
1570   } else {
1571     ret_api = RET_ERROR;
1572
1573     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1574     "ERROR: Buffer size is too small to connatenate. len1:%d len2:%d n:%d", len1, len2, n);
1575   }
1576
1577   return ret_api;
1578 }
1579
1580 /**
1581  * @brief
1582  *  Generate ID Field of PASCD Sentence
1583  *
1584  * @details  This is for creating PASCD Sentence of NMEA. <br>
1585  *           You can generate ID Field of PASCD Sentence and <br>
1586  *           concatenate it with the string given as argument 'pascd'. <br>
1587  *           It should be called in the specific order.
1588  *
1589  * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
1590  * @param[in]       size_t size : buffer size
1591  *
1592  * @return      RET_NORMAL         : success
1593  * @return      RET_ERROR          : failed
1594  */
1595 static inline RET_API VehicleSens_GeneratePASCDFieldId(char* pascd, size_t size) {
1596   RET_API ret_api;
1597
1598   ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_PASCD_ID, size);
1599   if (ret_api == RET_ERROR) {
1600     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1601     "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
1602   }
1603
1604   return ret_api;
1605 }
1606
1607 /**
1608  * @brief
1609  *  Generate Timestamp Field of PASCD Sentence
1610  *
1611  * @details  This is for creating PASCD Sentence of NMEA. <br>
1612  *           You can generate Timestamp Field of PASCD Sentence and <br>
1613  *           concatenate it with the string given as argument 'pascd'. <br>
1614  *           It should be called in the specific order.
1615  *
1616  * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
1617  * @param[in]       size_t size : buffer size
1618  *
1619  * @return      RET_NORMAL         : success
1620  * @return      RET_ERROR          : failed
1621  */
1622 static inline RET_API VehicleSens_GeneratePASCDFieldTimestamp(char* pascd, size_t size) {
1623   RET_API ret_api;
1624
1625   VEHICLESENS_VEHICLE_SPEED_INFO stVehicleSpeedInfo;
1626
1627   uint32_t ts_i; /* Interger Part of timestamp [s] */
1628   uint32_t ts_f; /* Fractional Part of timestamp [ms] */
1629   char ts_ci[32]; /* ts_i in charactor */
1630   char ts_cf[32]; /* ts_f in charactor */
1631
1632   VehicleSens_LoadVehicleSpeed(&stVehicleSpeedInfo);
1633
1634
1635 #if 1 /* PASCD *//* Suppose that GPS NMEA data are updated 1 sec interval */
1636   ts_i = gPseudoSecClockCounter; /* Synchronize: GPS NMEA */
1637   ts_f = 0u;
1638   gPseudoSecClockCounter += 1u; /* PASCD *//* Suppose that GPS NMEA data are updated 1 sec interval */
1639   if (gPseudoSecClockCounter >= VEHICLESENS_NMEA_PASCD_TS_MAX) {
1640     gPseudoSecClockCounter = 0u;
1641   }
1642 #else /* PASCD *//* Suppose that GPS NMEA data are updated 1 sec interval */
1643
1644   ts_i = stVehicleSpeedInfo.listSpd[0].ts.tv_sec % VEHICLESENS_NMEA_PASCD_TS_MAX;
1645   ts_f = stVehicleSpeedInfo.listSpd[0].ts.tv_nsec;
1646
1647 #endif /* PASCD *//* Suppose that GPS NMEA data are updated 1 sec interval */
1648
1649   (void)snprintf(ts_ci, sizeof(ts_ci), "%d", ts_i);
1650   (void)snprintf(ts_cf, sizeof(ts_cf), "%06d", ts_f);
1651
1652   /* Integer Part */
1653   ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, ts_ci, VEHICLESENS_NMEA_PASCD_TS_INT_LEN_MAX);
1654   if (ret_api == RET_ERROR) {
1655     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1656     "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
1657   }
1658
1659   /* Decimal Point */
1660   ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_DECIMALPOINT, size);
1661   if (ret_api == RET_ERROR) {
1662     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1663     "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
1664   }
1665
1666   /* Fractional Part */
1667   ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size,
1668                                                              ts_cf, VEHICLESENS_NMEA_PASCD_TS_FRA_LEN_MAX);
1669   if (ret_api == RET_ERROR) {
1670     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1671     "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
1672   }
1673
1674   return ret_api;
1675 }
1676
1677 /**
1678  * @brief
1679  *  Generate SensorType Field of PASCD Sentence
1680  *
1681  * @details  This is for creating PASCD Sentence of NMEA. <br>
1682  *           You can generate SensorType Field of PASCD Sentence and <br>
1683  *           concatenate it with the string given as argument 'pascd'. <br>
1684  *           It should be called in the specific order.
1685  *
1686  * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
1687  * @param[in]       size_t size : buffer size
1688  *
1689  * @return      RET_NORMAL         : success
1690  * @return      RET_ERROR          : failed
1691  */
1692 static inline RET_API VehicleSens_GeneratePASCDFieldSensorType(char* pascd, size_t size) {
1693   RET_API ret_api;
1694
1695   ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, VEHICLESENS_NMEA_PASCD_SENSORTYPE_C, size);
1696   if (ret_api == RET_ERROR) {
1697     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1698     "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
1699   }
1700
1701   return ret_api;
1702 }
1703
1704 /**
1705  * @brief
1706  *  Generate TransmissionState Field of PASCD Sentence
1707  *
1708  * @details  This is for creating PASCD Sentence of NMEA. <br>
1709  *           You can generate TransmissionState Field of PASCD Sentence and <br>
1710  *           concatenate it with the string given as argument 'pascd'. <br>
1711  *           It should be called in the specific order.
1712  *
1713  * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
1714  * @param[in]       size_t size : buffer size
1715  *
1716  * @return      RET_NORMAL         : success
1717  * @return      RET_ERROR          : failed
1718  */
1719 static inline RET_API VehicleSens_GeneratePASCDFieldTransmissionState(char* pascd, size_t size) {
1720   RET_API ret_api = RET_NORMAL;
1721   EFrameworkunifiedStatus eStatus;
1722
1723   uint8_t ucType; /* type of transmission */
1724   uint8_t ucShift;
1725
1726 #if 1 /* For Plus _CWORD27_ Gear Data Support 180115 */
1727   uint8_t ucPkb; /* state of parking brake */
1728 #endif /* For Plus _CWORD27_ Gear Data Support 180115 */
1729
1730   BOOL bIsAvailable;
1731
1732   /* Get Type of Transmission */
1733
1734 //  eStatus = VehicleIf_GetTypeOfTransmission(&ucType, &bIsAvailable);
1735   eStatus = VehicleIf_GetTypeOfTransmission(&ucType, &ucPkb, &bIsAvailable);
1736   if ((bIsAvailable != true) || (eStatus != eFrameworkunifiedStatusOK)) {
1737     if (bIsAvailable == TRUE) {
1738       FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1739       "ERROR: VehicleIf_GetTypeOfTransmission:%d", eStatus);
1740     }
1741     ret_api = RET_ERROR;
1742   }
1743
1744   if (ret_api != RET_ERROR) {
1745     /* Get Shift Position */
1746     eStatus = VehicleIf_GetShiftPosition(&ucShift, &bIsAvailable);
1747     if ((bIsAvailable != true) || (eStatus != eFrameworkunifiedStatusOK)) {
1748       if (bIsAvailable == TRUE) {
1749         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1750         "ERROR: VehicleIf_GetShiftPosition:%d", eStatus);
1751       }
1752       ret_api = RET_ERROR;
1753     }
1754   }
1755
1756   if (ret_api != RET_ERROR) {
1757     VEHICLESENS_TRANSMISSION_PKG tsmPkg;
1758
1759     tsmPkg.type = ucType;
1760     tsmPkg.shift = ucShift;
1761
1762 #if 1 /* For Plus _CWORD27_ Gear Data Support 180115 */
1763     tsmPkg.pkb = ucPkb;
1764 #endif /* For Plus _CWORD27_ Gear Data Support 180115 */
1765
1766
1767     ret_api = VehicleSens_DeriveTransmissionStateFor_CWORD27_(&tsmPkg);
1768     if (ret_api != RET_NORMAL) {
1769       FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1770       "ERROR: VehicleSensDeriveTransmissionStateFor_CWORD27_:%d", ret_api);
1771     } else {
1772       ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, tsmPkg.state, size);
1773       if (ret_api == RET_ERROR) {
1774         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1775         "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
1776       }
1777     }
1778   }
1779
1780   return ret_api;
1781 }
1782
1783 /**
1784  * @brief
1785  *  Generate SlipDetect Field of PASCD Sentence
1786  *
1787  * @details  This is for creating PASCD Sentence of NMEA. <br>
1788  *           You can generate SlipDetect Field of PASCD Sentence and <br>
1789  *           concatenate it with the string given as argument 'pascd'. <br>
1790  *           It should be called in the specific order.
1791  *
1792  * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
1793  * @param[in]       size_t size : buffer size
1794  *
1795  * @return      RET_NORMAL         : success
1796  * @return      RET_ERROR          : failed
1797  */
1798 static inline RET_API VehicleSens_GeneratePASCDFieldSlipDetect(char* pascd, size_t size) {
1799   RET_API ret_api;
1800
1801   ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, VEHICLESNES_NMEA_PASCD_NOSLIP, size);
1802   if (ret_api == RET_ERROR) {
1803     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1804     "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
1805   }
1806
1807   return ret_api;
1808 }
1809
1810 /**
1811  * @brief
1812  *  Generate SampleCount Field of PASCD Sentence
1813  *
1814  * @details  This is for creating PASCD Sentence of NMEA. <br>
1815  *           You can generate SampleCount Field of PASCD Sentence and <br>
1816  *           concatenate it with the string given as argument 'pascd'. <br>
1817  *           It should be called in the specific order.
1818  *
1819  * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
1820  * @param[in]       size_t size : buffer size
1821  */
1822 static inline RET_API VehicleSens_GeneratePASCDFieldSampleCount(char* pascd, size_t size) {
1823   RET_API ret_api;
1824
1825   VEHICLESENS_VEHICLE_SPEED_INFO stVehicleSpeedInfo;
1826   char cSampleCount[32];
1827
1828   VehicleSens_LoadVehicleSpeed(&stVehicleSpeedInfo);
1829   (void)snprintf(cSampleCount, sizeof(cSampleCount), "%d", stVehicleSpeedInfo.sampleCount);
1830
1831   ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, cSampleCount, size);
1832   if (ret_api == RET_ERROR) {
1833     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1834     "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
1835   }
1836
1837   return ret_api;
1838 }
1839
1840 /**
1841  * @brief
1842  *  Generate TimeOffset and Speed Field of PASCD Sentence
1843  *
1844  * @details  This is for creating PASCD Sentence of NMEA. <br>
1845  *           You can generate TimeOffset and Speed Field of PASCD Sentence and <br>
1846  *           concatenate it with the string given as argument 'pascd'. <br>
1847  *           It should be called in the specific order.
1848  *
1849  * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
1850  * @param[in]       size_t size : buffer size
1851  *
1852  * @return      RET_NORMAL         : success
1853  * @return      RET_ERROR          : failed
1854  */
1855 static inline RET_API VehicleSens_GeneratePASCDFieldTimeOffsetNSpeed(char* pascd, size_t size) {
1856   RET_API ret_api = RET_ERROR;
1857
1858   VEHICLESENS_VEHICLE_SPEED_INFO stVehicleSpeedInfo;
1859   VEHICLESENS_VEHICLE_SPEED_DAT *pS0 = &(stVehicleSpeedInfo.listSpd[0]);
1860
1861   int32_t i;
1862
1863   VehicleSens_LoadVehicleSpeed(&stVehicleSpeedInfo);
1864
1865   for (i = 0; i < stVehicleSpeedInfo.sampleCount; i++) {
1866     VEHICLESENS_VEHICLE_SPEED_DAT *pS = &(stVehicleSpeedInfo.listSpd[i]);
1867
1868     /* timeoffset */
1869     uint32_t ts_i; /* Interger Part of timestamp [s] */
1870     uint32_t ts_f; /* Fractional Part of timestamp [us] */
1871     char ts_ci[32]; /* ts_i in charactor */
1872     char ts_cf[32]; /* ts_f in charactor */
1873
1874     if (pS->ts.tv_nsec - pS0->ts.tv_nsec >= 0) {  // LCOV_EXCL_BR_LINE 200: can not less than zero
1875       ts_i = (pS->ts.tv_sec - pS0->ts.tv_sec) % VEHICLESENS_NMEA_PASCD_TS_MAX;
1876       ts_f = (pS->ts.tv_nsec - pS0->ts.tv_nsec) / 1000; /* [ns] -> [us] */
1877     } else {
1878       // LCOV_EXCL_START 8: invalid
1879       AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1880       ts_i = (pS->ts.tv_sec - pS0->ts.tv_sec - 1) % VEHICLESENS_NMEA_PASCD_TS_MAX;
1881       ts_f = (1000000000 + pS->ts.tv_nsec - pS0->ts.tv_nsec) / 1000; /* [ns] -> [us] */
1882       // LCOV_EXCL_STOP
1883     }
1884
1885     (void)snprintf(ts_ci, sizeof(ts_ci), "%d", ts_i);
1886     (void)snprintf(ts_cf, sizeof(ts_cf), "%06d", ts_f);
1887
1888     /* Integer Part */
1889     ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, ts_ci, size);
1890     if (ret_api == RET_ERROR) {  // LCOV_EXCL_BR_LINE 200: can not exceed buffer size
1891     // LCOV_EXCL_START 8: invalid
1892     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1893       FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1894       "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
1895       break;
1896     // LCOV_EXCL_STOP
1897     }
1898
1899     /* Decimal Point */
1900     ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_DECIMALPOINT, size);
1901     if (ret_api == RET_ERROR) {  // LCOV_EXCL_BR_LINE 200: can not exceed buffer size
1902     // LCOV_EXCL_START 8: invalid
1903     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1904       FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1905       "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
1906       break;
1907     // LCOV_EXCL_STOP
1908     }
1909
1910     /* Fractional Part */
1911     ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size,
1912                                                                ts_cf, VEHICLESENS_NMEA_PASCD_TO_FRA_LEN_MAX);
1913     if (ret_api == RET_ERROR) {  // LCOV_EXCL_BR_LINE 200: can not exceed buffer size
1914     // LCOV_EXCL_START 8: invalid
1915     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1916       FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1917       "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
1918       break;
1919     // LCOV_EXCL_STOP
1920     }
1921
1922     /* speed */
1923     uint16_t spd_i; /* Interger Part of speed [m/s] */
1924     uint16_t spd_f; /* Fractional Part of speed [mm/s] */
1925     char spd_ci[32]; /* spd_i in charactor */
1926     char spd_cf[32]; /* spd_f in charactor */
1927
1928     spd_i = pS->speed / 100; /* [0.01m/s] -> [m/s] */
1929     spd_f = (pS->speed % 100) * 10; /* [0.01m/s] -> [mm/s] */
1930
1931     (void)snprintf(spd_ci, sizeof(spd_ci), "%d", spd_i);
1932     (void)snprintf(spd_cf, sizeof(spd_cf), "%03d", spd_f);
1933
1934     /* Integer Part */
1935     ret_api = VehicleSens_CatNmeaSentenceFieldWithDelimiter(pascd, size, spd_ci, size);
1936     if (ret_api == RET_ERROR) {
1937       FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1938       "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
1939       break;
1940     }
1941
1942     /* Decimal Point */
1943     ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_DECIMALPOINT, size);
1944     if (ret_api == RET_ERROR) {  // LCOV_EXCL_BR_LINE 200: can not exceed buffer size
1945     // LCOV_EXCL_START 8: invalid
1946     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1947       FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1948       "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
1949       break;
1950     // LCOV_EXCL_STOP
1951     }
1952
1953     /* Fractional Part */
1954     ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size,
1955                                                                spd_cf, VEHICLESENS_NMEA_PASCD_SPD_FRA_LEN_MAX);
1956     if (ret_api == RET_ERROR) {  // LCOV_EXCL_BR_LINE 200: can not exceed buffer size
1957     // LCOV_EXCL_START 8: invalid
1958     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1959       FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
1960       "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
1961       break;
1962     // LCOV_EXCL_STOP
1963     }
1964   }
1965
1966   return ret_api;
1967 }
1968
1969 /**
1970  * @brief
1971  *  Generate Checksum Field of PASCD Sentence
1972  *
1973  * @details  This is for creating PASCD Sentence of NMEA. <br>
1974  *           You can generate Checksum Field of PASCD Sentence and <br>
1975  *           concatenate it with the string given as argument 'pascd'. <br>
1976  *           It should be called in the specific order.
1977  *
1978  * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
1979  * @param[in]       size_t size : buffer size
1980  *
1981  * @return      RET_NORMAL         : success
1982  * @return      RET_ERROR          : failed
1983  */
1984 static inline RET_API VehicleSens_GeneratePASCDFieldChecksum(char* pascd, size_t size) {
1985   RET_API ret_api;
1986
1987   size_t length;
1988   uint8_t chk = 0;
1989   char cChk[3];
1990   uint16_t i = 0;
1991
1992   length = strnlen(pascd, size);
1993
1994   /* Calculate Checksum (start with the 2th Bype except '$') */
1995   for (i = 1; i < length; i++) {
1996     chk ^= pascd[i];
1997   }
1998   (void)snprintf(cChk, sizeof(cChk), "%02X", chk);
1999
2000   /* Set Astarisk before Checksum */
2001   ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_ASTARISK, size);
2002   if (ret_api == RET_ERROR) {
2003     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
2004     "ERROR: VehicleSens_CatNmeaSentenceFieldWithoutDelimiter:%d", ret_api);
2005   }
2006
2007   /* Set Checksum */
2008   ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, cChk, size);
2009   if (ret_api == RET_ERROR) {
2010     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
2011     "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
2012   }
2013
2014   return ret_api;
2015 }
2016
2017 /**
2018  * @brief
2019  *  Generate CR & LF Field of PASCD Sentence
2020  *
2021  * @details  This is for creating PASCD Sentence of NMEA. <br>
2022  *           You can generate CRLF Field of PASCD Sentence and <br>
2023  *           concatenate it with the string given as argument 'pascd'. <br>
2024  *           It should be called in the specific order.
2025  *
2026  * @param[in/out]   char* pascd : buffer pointer for PASCD Sentence
2027  * @param[in]       size_t size : buffer size
2028  *
2029  * @return      RET_NORMAL         : success
2030  * @return      RET_ERROR          : failed
2031  */
2032 static inline RET_API VehicleSens_GeneratePASCDFieldCRLF(char* pascd, size_t size) {
2033   RET_API ret_api;
2034
2035   /* Set Carriage Return */
2036   ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_CR, size);
2037   if (ret_api == RET_ERROR) {
2038     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
2039     "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
2040   }
2041
2042   /* Set Line Feed */
2043   ret_api = VehicleSens_CatNmeaSentenceFieldWithoutDelimiter(pascd, size, VEHICLESENS_NMEA_LF, size);
2044   if (ret_api == RET_ERROR) {
2045     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
2046     "ERROR: VehicleSens_CatNmeaSentenceFieldWithDelimiter:%d", ret_api);
2047   }
2048
2049   return ret_api;
2050 }
2051
2052 /**
2053  * @brief
2054  *  Derive Transmission State For _CWORD27_
2055  *
2056  * @details  This is for creating PASCD Sentence of NMEA. <br>
2057  *           You can derive transmissionState from the transmission type and <br>
2058  *           the shift positiong from Vehicle Service.
2059  *
2060  * @param[in/out] VEHICLESENS_TRANSMISSION_PKG* pPkg : source data set for Transmission State
2061  *
2062  * @return      RET_NORMAL         : success
2063  * @return      RET_ERROR          : failed
2064  */
2065 static RET_API VehicleSens_DeriveTransmissionStateFor_CWORD27_(VEHICLESENS_TRANSMISSION_PKG* pPkg) {
2066   RET_API ret_api = RET_NORMAL;
2067   uint32_t i;
2068
2069   static const VEHICLESENS_TRANSMISSION_PKG TmsLut[VEHICLEIF_TRANSMISSION_TYPE_NUM * VEHICLEIF_SHIFT_POSITION_NUM] = {
2070
2071 //    /* Transmission Type : MT */
2072 //    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_U, VEHICLESENS_NMEA_PASCD_TMS_D },
2073 //    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_R, VEHICLESENS_NMEA_PASCD_TMS_R },
2074 //    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_P, VEHICLESENS_NMEA_PASCD_TMS_D },
2075 //    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_N, VEHICLESENS_NMEA_PASCD_TMS_D },
2076 //    { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_D, VEHICLESENS_NMEA_PASCD_TMS_D },
2077 //    /* Tranmission Type : AT */
2078 //    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_U, VEHICLESENS_NMEA_PASCD_TMS_U },
2079 //    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_R, VEHICLESENS_NMEA_PASCD_TMS_R },
2080 //    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_P, VEHICLESENS_NMEA_PASCD_TMS_P },
2081 //    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_N, VEHICLESENS_NMEA_PASCD_TMS_U },
2082 //    { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_D, VEHICLESENS_NMEA_PASCD_TMS_D },
2083 //    /* Transmission Type : UNKNOWN */
2084 //    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_U, VEHICLESENS_NMEA_PASCD_TMS_U },
2085 //    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_R, VEHICLESENS_NMEA_PASCD_TMS_U },
2086 //    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_P, VEHICLESENS_NMEA_PASCD_TMS_U },
2087 //    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_N, VEHICLESENS_NMEA_PASCD_TMS_U },
2088 //    { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_D, VEHICLESENS_NMEA_PASCD_TMS_U },
2089     /* Transmission Type : MT */
2090     { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_U, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
2091     { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_R, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_R },
2092     { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_P, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
2093     { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_N, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
2094     { VEHICLEIF_TRANSMISSION_TYPE_MT,      VEHICLEIF_SHIFT_POSITION_D, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
2095     /* Tranmission Type : AT */
2096 #if 1 /* For Plus _CWORD27_ Gear Data Support 180115 */
2097     { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_U, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_U },
2098 #else /* For Plus _CWORD27_ Gear Data Support 180115 */
2099     { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_U, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
2100 #endif /* For Plus _CWORD27_ Gear Data Support 180115 */
2101     { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_R, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_R },
2102     { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_P, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_P },
2103     { 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. */
2104     { VEHICLEIF_TRANSMISSION_TYPE_AT,      VEHICLEIF_SHIFT_POSITION_D, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
2105     /* Transmission Type : UNKNOWN */
2106 #if 1 /* For Plus _CWORD27_ Gear Data Support 180115 */
2107     { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_U, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_U },
2108     { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_R, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_U },
2109     { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_P, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_U },
2110     { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_N, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_U },
2111     { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_D, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_U },
2112 #else /* For Plus _CWORD27_ Gear Data Support 180115 */
2113     { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_U, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
2114     { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_R, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
2115     { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_P, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
2116     { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_N, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
2117     { VEHICLEIF_TRANSMISSION_TYPE_UNKNOWN, VEHICLEIF_SHIFT_POSITION_D, VEHICLEIF_PKB_UNKNOWN, VEHICLESENS_NMEA_PASCD_TMS_D },
2118 #endif /* For Plus _CWORD27_ Gear Data Support 180115 */
2119
2120   };
2121
2122   for (i = 0; i < VEHICLEIF_TRANSMISSION_TYPE_NUM * VEHICLEIF_SHIFT_POSITION_NUM; i++) {
2123     if ((pPkg->type == TmsLut[i].type) && (pPkg->shift == TmsLut[i].shift)) {
2124       strncpy(pPkg->state, TmsLut[i].state, sizeof(pPkg->state));
2125       break;
2126     }
2127   }
2128
2129
2130 #if 1 /* For Plus _CWORD27_ Gear Data Support 180115 */
2131   if ((pPkg->type == VEHICLEIF_TRANSMISSION_TYPE_MT) && (pPkg->pkb == VEHICLEIF_PKB_ON)) {
2132     strncpy(pPkg->state, VEHICLESENS_NMEA_PASCD_TMS_P, sizeof(VEHICLESENS_NMEA_PASCD_TMS_P));
2133   }
2134 #endif /* For Plus _CWORD27_ Gear Data Support 180115 */
2135
2136
2137   if (i == VEHICLEIF_TRANSMISSION_TYPE_NUM * VEHICLEIF_SHIFT_POSITION_NUM) {
2138     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
2139     "FORBIDDEN ERROR: Can't find Transmission State. type:%d shift:%d", pPkg->type, pPkg->shift);
2140     ret_api = RET_ERROR;
2141   }
2142
2143   return ret_api;
2144 }