video_in_hal/vehicleservice/positioning/server/src/Sensor/DeadReckoning_main.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  :DeadReckoning_Main.cpp
  19  *  System name  :_CWORD107_
  20  *  Subsystem name :DeadReckoning Mains
  21  *  Program name :DeadReckoning Mains
  22  *  Module configuration :DeadReckoningInit()   Guessed navigation initialization processing
  23  *                  :DeadReckoningRcvMsg()  DR Component MSG Receive Processing
  24  ******************************************************************************/
  25
  26 #include <positioning_hal.h>
  27
  28 #include "DeadReckoning_main.h"
  29
  30 #include "Sensor_Common_API.h"
  31 #include "DeadReckoning_DataMaster.h"
  32 #include "Dead_Reckoning_Local_Api.h"
  33
  34 #include "DeadReckoning_DbgLogSim.h"
  35
  36 #include "POS_private.h"
  37
  38 static RET_API DeadReckoningWriteSharedMemory(VEHICLEDEBUG_MSG_LOGINFO_DAT* loginfo);
  39 static void DeadReckoningSetEvent(PNO pno, RET_API ret);
  40 static void DeadReckoningLinkSharedMemory(char *shared_memory_name, void **share_addr);
  41
  42 #define DEAD_RECKONING_MAIN_DEBUG 0
  43 #define DR_DEBUG 0
  44 #define DR_DEBUG_ENG_MODE 0
  45
  46 /*************************************************/
  47 /*                      Constant                     */
  48 /*************************************************/
  49
  50 #define DEAD_RECKONING_BUF_SIZE 7
  51 #define DR_MASK_WORD_L 0x00FF
  52 #define DR_MASK_WORD_U 0xFF00
  53
  54 /*************************************************/
  55 /*                Global variable                 */
  56 /*************************************************/
  57
  58 /* Data receive confirmation flag */
  59 BOOL g_gps_data_get_flg = FALSE;
  60 BOOL g_sens_data_get_flg = FALSE;
  61 BOOL g_fst_sens_data_get_flg = FALSE;
  62
  63 /* Reception flag for each data */
  64 BOOL g_sens_data_get_sns_cnt_flg    = FALSE;
  65 BOOL g_sens_data_get_gyro_x_flg   = FALSE;
  66 BOOL g_sens_data_get_gyro_y_flg   = FALSE;
  67 BOOL g_sens_data_get_gyro_z_flg   = FALSE;
  68 BOOL g_sens_data_get_rev_flg     = FALSE;
  69 BOOL g_sens_data_get_spdpulse_flg    = FALSE;
  70 BOOL g_sens_data_get_spdpulse_chk_flg  = FALSE;
  71
  72 BOOL g_sens_data_get_gyro_x_fst_flg  = FALSE;
  73 BOOL g_sens_data_get_gyro_y_fst_flg  = FALSE;
  74 BOOL g_sens_data_get_gyro_z_fst_flg  = FALSE;
  75 BOOL g_sens_data_get_rev_fst_flg    = FALSE;
  76 BOOL g_sens_data_get_spdpulse_fst_flg   = FALSE;
  77 BOOL g_sens_data_get_spdpulse_chk_fst_flg  = FALSE;
  78
  79 /* Receive data storage buffer */
  80 /* [0]:SNS_COUNTER [1]:REV [2]:SPEED_PULSE_FLAG [3]:SPEED_PULSE [4]:GYRO_X [5]:GYRO_Y [6]:GYRO_Z */
  81 DEAD_RECKONING_RCVDATA_SENSOR   g_sns_buf[DEAD_RECKONING_BUF_SIZE];
  82 DEAD_RECKONING_SAVEDATA_SENSOR_FIRST g_fst_sns_buf;
  83
  84 /*******************************************************************************
  85  * MODULE    : DeadReckoningInit
  86  * ABSTRACT  : Guessed navigation initialization processing
  87  * FUNCTION  : Initialize inferred navigation processing
  88  * ARGUMENT  : None
  89  * NOTE      :
  90  * RETURN    : RET_NORMAL :Success in initialization
  91  *      RET_ERROR :Master Clear failed
  92  ******************************************************************************/
  93 int32 DeadReckoningInit(void) {  // LCOV_EXCL_START 8: dead code.
  94     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
  95     return RET_NORMAL;
  96 }
  97
  98 /*******************************************************************************
  99  * MODULE    : DeadReckoningRcvMsg
 100  * ABSTRACT  : DR Component MSG Receive Processing
 101  * FUNCTION  : Receive the DR component MSG
 102  * ARGUMENT  : *msg  : message buffer
 103  * NOTE      :
 104  * RETURN    : None
 105  ******************************************************************************/
 106 void DeadReckoningRcvMsg(const DEAD_RECKONING_RCVDATA *msg, DEAD_RECKONING_LONLAT_INFO *location_info) {
 107     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 108     if ((msg == NULL) || (location_info == NULL)) {
 109         FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "msg == NULL\r\n");
 110     } else {
 111         const SENSOR_MSG_GPSDATA_DAT   *rcv_gps_msg   = NULL;
 112         const VEHICLESENS_DATA_MASTER   *rcv_sensor_msg  = NULL;
 113         const VEHICLESENS_DATA_MASTER_FST  *rcv_sensor_msg_fst = NULL;
 114
 115         Struct_GpsData      send_gps_msg;
 116         Struct_SensData      send_sensor_msg;
 117
 118         /* Initialization */
 119         (void)memset(reinterpret_cast<void *>(&send_gps_msg),  0, sizeof(Struct_GpsData));
 120         (void)memset(reinterpret_cast<void *>(&send_sensor_msg), 0, sizeof(Struct_SensData));
 121
 122         /* Flag is set to FALSE */
 123         location_info->calc_called = static_cast<u_int8>(FALSE);
 124         location_info->available = static_cast<u_int8>(FALSE);
 125
 126         if (CID_DEAD_RECKONING_GPS_DATA == msg->hdr.hdr.cid) {
 127             rcv_gps_msg = (const SENSOR_MSG_GPSDATA_DAT *)(&(msg->data[0]));
 128             /* #QAC confirmation Rule11.4 Use structure for member reference(Cast according to shared memory link IF) */
 129
 130             /* Receiving GPS Data for DR */
 131             switch (rcv_gps_msg->ul_did) {
 132                 case  VEHICLE_DID_GPS_UBLOX_NAV_POSLLH :
 133                 case  VEHICLE_DID_GPS_UBLOX_NAV_STATUS :
 134                 case  VEHICLE_DID_GPS_UBLOX_NAV_TIMEUTC :
 135                 case  VEHICLE_DID_GPS_UBLOX_NAV_VELNED :
 136                 case  VEHICLE_DID_GPS_UBLOX_NAV_DOP :
 137                 case  VEHICLE_DID_GPS_UBLOX_NAV_SVINFO :
 138                 case  VEHICLE_DID_GPS_UBLOX_NAV_CLOCK :
 139                 {
 140                     g_gps_data_get_flg = TRUE;
 141                     break;
 142                 }
 143                 default:
 144                     break;
 145             }
 146         } else if (CID_DEAD_RECKONING_SENS_DATA == msg->hdr.hdr.cid) {
 147             rcv_sensor_msg = (const VEHICLESENS_DATA_MASTER *)(&(msg->data[0]));
 148             /* #QAC confirmation Rule11.4 Use structure for member reference(Cast according to shared memory link IF) */
 149
 150             /* Sensor data reception for DR */
 151             switch (rcv_sensor_msg->ul_did) {
 152                 case  POSHAL_DID_SNS_COUNTER :
 153                 {
 154                     g_sns_buf[0].did = rcv_sensor_msg->ul_did;
 155                     g_sns_buf[0].size = static_cast<u_int8>(rcv_sensor_msg->us_size);
 156                     g_sns_buf[0].data[0] = rcv_sensor_msg->uc_data[0];
 157                     g_sens_data_get_sns_cnt_flg = TRUE;
 158                     break;
 159                 }
 160                 case  POSHAL_DID_REV :
 161                 {
 162                     g_sns_buf[1].did = rcv_sensor_msg->ul_did;
 163                     g_sns_buf[1].size = static_cast<u_int8>(rcv_sensor_msg->us_size);
 164                     (void)memcpy(reinterpret_cast<void *>(&(g_sns_buf[1].data[0])),
 165                                  (const void *)(&(rcv_sensor_msg->uc_data[0])), (size_t)rcv_sensor_msg->us_size);
 166                     g_sens_data_get_rev_flg = TRUE;
 167                     break;
 168                 }
 169                 case  POSHAL_DID_SPEED_PULSE_FLAG :
 170                 {
 171                     g_sns_buf[2].did = rcv_sensor_msg->ul_did;
 172                     g_sns_buf[2].size = static_cast<u_int8>(rcv_sensor_msg->us_size);
 173                     (void)memcpy(reinterpret_cast<void *>(&(g_sns_buf[2].data[0])),
 174                                  (const void *)(&(rcv_sensor_msg->uc_data[0])), (size_t)rcv_sensor_msg->us_size);
 175                     g_sens_data_get_spdpulse_chk_flg = TRUE;
 176                     break;
 177                 }
 178                 case  POSHAL_DID_SPEED_PULSE :
 179                 {
 180                     g_sns_buf[3].did = rcv_sensor_msg->ul_did;
 181                     g_sns_buf[3].size = static_cast<u_int8>(rcv_sensor_msg->us_size);
 182                     (void)memcpy(reinterpret_cast<void *>(&(g_sns_buf[3].data[0])),
 183                                  (const void *)(&(rcv_sensor_msg->uc_data[0])), (size_t)rcv_sensor_msg->us_size);
 184                     g_sens_data_get_spdpulse_flg = TRUE;
 185                     break;
 186                 }
 187                 case  POSHAL_DID_GYRO_X :
 188                 {
 189                     g_sns_buf[4].did = rcv_sensor_msg->ul_did;
 190                     g_sns_buf[4].size = static_cast<u_int8>(rcv_sensor_msg->us_size);
 191                     (void)memcpy(reinterpret_cast<void *>(&(g_sns_buf[4].data[0])),
 192                                  (const void *)(&(rcv_sensor_msg->uc_data[0])), (size_t)rcv_sensor_msg->us_size);
 193                     g_sens_data_get_gyro_x_flg = TRUE;
 194                     break;
 195                 }
 196                 case  POSHAL_DID_GYRO_Y :
 197                 {
 198                     g_sns_buf[5].did = rcv_sensor_msg->ul_did;
 199                     g_sns_buf[5].size = static_cast<u_int8>(rcv_sensor_msg->us_size);
 200                     (void)memcpy(reinterpret_cast<void *>(&(g_sns_buf[5].data[0])),
 201                                  (const void *)(&(rcv_sensor_msg->uc_data[0])), (size_t)rcv_sensor_msg->us_size);
 202                     g_sens_data_get_gyro_y_flg = TRUE;
 203                     break;
 204                 }
 205                 case  POSHAL_DID_GYRO_Z :
 206                 {
 207                     g_sns_buf[6].did = rcv_sensor_msg->ul_did;
 208                     g_sns_buf[6].size = static_cast<u_int8>(rcv_sensor_msg->us_size);
 209                     (void)memcpy(reinterpret_cast<void *>(&(g_sns_buf[6].data[0])),
 210                                  (const void *)(&(rcv_sensor_msg->uc_data[0])), (size_t)rcv_sensor_msg->us_size);
 211                     g_sens_data_get_gyro_z_flg = TRUE;
 212                     break;
 213                 }
 214                 default:
 215                     break;
 216             }
 217         } else if (CID_DEAD_RECKONING_SENS_FST_DATA == msg->hdr.hdr.cid) {
 218             u_int16 rev_data_size;
 219
 220             rcv_sensor_msg_fst = (const VEHICLESENS_DATA_MASTER_FST *)(&(msg->data[0]));
 221             /* #QAC confirmation Rule11.4 Use structure for member reference(Cast according to shared memory link IF) */
 222             rev_data_size = static_cast<u_int16>(msg->hdr.hdr.msgbodysize - VEHICLESENS_DELIVERY_FSTSNS_HDR_SIZE);
 223
 224 #if DEAD_RECKONING_MAIN_DEBUG
 225             FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " DID = %08X, rev_data_size = %d ",
 226                           rcv_sensor_msg_fst->ul_did, rev_data_size);
 227 #endif
 228
 229             /* Sensor data reception for DR */
 230             switch (rcv_sensor_msg_fst->ul_did) {
 231                 case  POSHAL_DID_REV_FST :
 232                 {
 233                     (void)memcpy(
 234                         reinterpret_cast<void *>(&(g_fst_sns_buf.rev_data[g_fst_sns_buf.rev_rcv_size
 235                                                                          / sizeof(g_fst_sns_buf.rev_data[0])])),
 236                                         (const void *)(&(rcv_sensor_msg_fst->uc_data[0])),
 237                                         (size_t)(rev_data_size));
 238
 239                     g_fst_sns_buf.rev_rcv_size = static_cast<u_int16>(
 240                         g_fst_sns_buf.rev_rcv_size + rev_data_size);
 241
 242                     if (g_fst_sns_buf.rev_rcv_size == rcv_sensor_msg_fst->us_size) {
 243                         g_sens_data_get_rev_fst_flg = TRUE;
 244 #if DEAD_RECKONING_MAIN_DEBUG
 245                         FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " REV receive flag = TRUE ");
 246 #endif
 247                     }
 248                     break;
 249                 }
 250                 case  POSHAL_DID_SPEED_PULSE_FLAG_FST :
 251                 {
 252                     (void)memcpy(
 253                     reinterpret_cast<void *>(&(g_fst_sns_buf.spd_pulse_check_data[g_fst_sns_buf.spd_pulse_check_rcv_size
 254                                                                    / sizeof(g_fst_sns_buf.spd_pulse_check_data[0])])),
 255                                         (const void *)(&(rcv_sensor_msg_fst->uc_data[0])),
 256                                         (size_t)(rev_data_size));
 257
 258                     g_fst_sns_buf.spd_pulse_check_rcv_size = static_cast<u_int16>(
 259                                     g_fst_sns_buf.spd_pulse_check_rcv_size + rev_data_size);
 260
 261                     if (g_fst_sns_buf.spd_pulse_check_rcv_size == rcv_sensor_msg_fst->us_size) {
 262                         g_sens_data_get_spdpulse_chk_fst_flg = TRUE;
 263 #if DEAD_RECKONING_MAIN_DEBUG
 264                         FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " SPF receive flag = TRUE ");
 265 #endif
 266                     }
 267                     break;
 268                 }
 269                 case  POSHAL_DID_SPEED_PULSE_FST :
 270                 {
 271                     (void)memcpy(
 272                         reinterpret_cast<void *>(&(g_fst_sns_buf.spd_pulse_data[g_fst_sns_buf.spd_pulse_rcv_size
 273                                                                         / sizeof(g_fst_sns_buf.spd_pulse_data[0])])),
 274                                         (const void *)(&(rcv_sensor_msg_fst->uc_data[0])),
 275                                         (size_t)(rev_data_size));
 276
 277                     g_fst_sns_buf.spd_pulse_rcv_size = static_cast<u_int16>(g_fst_sns_buf.spd_pulse_rcv_size + \
 278                                                                                     rev_data_size);
 279
 280                     if (g_fst_sns_buf.spd_pulse_rcv_size == rcv_sensor_msg_fst->us_size) {
 281                         g_sens_data_get_spdpulse_fst_flg = TRUE;
 282 #if DEAD_RECKONING_MAIN_DEBUG
 283                         FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " SP receive flag = TRUE ");
 284 #endif
 285                     }
 286                     break;
 287                 }
 288                 case  POSHAL_DID_GYRO_X_FST :
 289                 {
 290                     (void)memcpy(
 291                         reinterpret_cast<void *>(&(g_fst_sns_buf.gyro_x_data[g_fst_sns_buf.gyro_x_rcv_size
 292                                                                           / sizeof(g_fst_sns_buf.gyro_x_data[0])])),
 293                                         (const void *)(&(rcv_sensor_msg_fst->uc_data[0])),
 294                                         (size_t)(rev_data_size));
 295
 296                     g_fst_sns_buf.gyro_x_rcv_size = static_cast<u_int16>(g_fst_sns_buf.gyro_x_rcv_size + rev_data_size);
 297
 298 #if DEAD_RECKONING_MAIN_DEBUG
 299                     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
 300                          " g_fst_sns_buf.gyro_x_rcv_size = %d, rcv_sensor_msg_fst->us_size = %d ",
 301                         g_fst_sns_buf.gyro_x_rcv_size, rcv_sensor_msg_fst->us_size);
 302 #endif
 303                     if (g_fst_sns_buf.gyro_x_rcv_size == rcv_sensor_msg_fst->us_size) {
 304                         g_sens_data_get_gyro_x_fst_flg = TRUE;
 305 #if DEAD_RECKONING_MAIN_DEBUG
 306                         FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " GYRO_X receive flag = TRUE ");
 307 #endif
 308                     }
 309                     break;
 310                 }
 311                 case  POSHAL_DID_GYRO_Y_FST :
 312                 {
 313                     (void)memcpy(
 314                         reinterpret_cast<void *>(&(g_fst_sns_buf.gyro_y_data[g_fst_sns_buf.gyro_y_rcv_size
 315                                                                           / sizeof(g_fst_sns_buf.gyro_y_data[0])])),
 316                                         (const void *)(&(rcv_sensor_msg_fst->uc_data[0])),
 317                                         (size_t)(rev_data_size));
 318
 319                     g_fst_sns_buf.gyro_y_rcv_size = static_cast<u_int16>(g_fst_sns_buf.gyro_y_rcv_size + rev_data_size);
 320
 321 #if DEAD_RECKONING_MAIN_DEBUG
 322                     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
 323                          " g_fst_sns_buf.gyro_y_rcv_size = %d, rcv_sensor_msg_fst->us_size = %d ",
 324                         g_fst_sns_buf.gyro_y_rcv_size, rcv_sensor_msg_fst->us_size);
 325 #endif
 326                     if (g_fst_sns_buf.gyro_y_rcv_size == rcv_sensor_msg_fst->us_size) {
 327                         g_sens_data_get_gyro_y_fst_flg = TRUE;
 328 #if DEAD_RECKONING_MAIN_DEBUG
 329                         FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " GYRO_Y receive flag = TRUE ");
 330 #endif
 331                     }
 332                     break;
 333                 }
 334                 case  POSHAL_DID_GYRO_Z_FST :
 335                 {
 336                     (void)memcpy(
 337                         reinterpret_cast<void *>(&(g_fst_sns_buf.gyro_z_data[g_fst_sns_buf.gyro_z_rcv_size
 338                                                                           / sizeof(g_fst_sns_buf.gyro_z_data[0])])),
 339                                         (const void *)(&(rcv_sensor_msg_fst->uc_data[0])),
 340                                         (size_t)(rev_data_size));
 341
 342                     g_fst_sns_buf.gyro_z_rcv_size = static_cast<u_int16>(g_fst_sns_buf.gyro_z_rcv_size + rev_data_size);
 343
 344 #if DEAD_RECKONING_MAIN_DEBUG
 345                     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
 346                          " g_fst_sns_buf.gyro_z_rcv_size = %d, rcv_sensor_msg_fst->us_size = %d ",
 347                         g_fst_sns_buf.gyro_z_rcv_size, rcv_sensor_msg_fst->us_size);
 348 #endif
 349                     if (g_fst_sns_buf.gyro_z_rcv_size == rcv_sensor_msg_fst->us_size) {
 350                         g_sens_data_get_gyro_z_fst_flg = TRUE;
 351 #if DEAD_RECKONING_MAIN_DEBUG
 352                         FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " GYRO_Z receive flag = TRUE ");
 353 #endif
 354                     }
 355                     break;
 356                 }
 357                 default:
 358                     break;
 359             }
 360         } else {
 361             /* nop */
 362         }
 363
 364         /* 4 data received? */
 365         if ((g_sens_data_get_sns_cnt_flg == TRUE) &&
 366                 (g_sens_data_get_rev_flg == TRUE) &&
 367                 (g_sens_data_get_gyro_x_flg == TRUE) &&
 368                 (g_sens_data_get_gyro_y_flg == TRUE) &&
 369                 (g_sens_data_get_gyro_z_flg == TRUE) &&
 370                 (g_sens_data_get_spdpulse_flg == TRUE) &&
 371                 (g_sens_data_get_spdpulse_chk_flg == TRUE)) {
 372             /* Sensor data acquisition flag ON */
 373             g_sens_data_get_flg = TRUE;
 374
 375             /* Set all flags to FALSE */
 376             g_sens_data_get_sns_cnt_flg   = FALSE;
 377             g_sens_data_get_gyro_x_flg    = FALSE;
 378             g_sens_data_get_gyro_y_flg    = FALSE;
 379             g_sens_data_get_gyro_z_flg    = FALSE;
 380             g_sens_data_get_rev_flg    = FALSE;
 381             g_sens_data_get_spdpulse_flg   = FALSE;
 382             g_sens_data_get_spdpulse_chk_flg  = FALSE;
 383         }
 384
 385         /* 4 data received? */
 386         if ((g_sens_data_get_rev_fst_flg == TRUE) &&
 387                 (g_sens_data_get_gyro_x_fst_flg == TRUE) &&
 388                 (g_sens_data_get_gyro_y_fst_flg == TRUE) &&
 389                 (g_sens_data_get_gyro_z_fst_flg == TRUE) &&
 390                 (g_sens_data_get_spdpulse_fst_flg == TRUE) &&
 391                 (g_sens_data_get_spdpulse_chk_fst_flg == TRUE)) {
 392             /* Initial sensor data acquisition flag ON */
 393             g_fst_sens_data_get_flg = TRUE;
 394
 395             /* Set all flags to FALSE */
 396             g_sens_data_get_gyro_x_fst_flg  = FALSE;
 397             g_sens_data_get_gyro_y_fst_flg  = FALSE;
 398             g_sens_data_get_gyro_z_fst_flg  = FALSE;
 399             g_sens_data_get_rev_fst_flg    = FALSE;
 400             g_sens_data_get_spdpulse_fst_flg   = FALSE;
 401             g_sens_data_get_spdpulse_chk_fst_flg  = FALSE;
 402         }
 403
 404         DeadReckoningRcvMsgFstSens(msg, location_info, rcv_gps_msg, &send_gps_msg, &send_sensor_msg);
 405     }
 406 }
 407
 408 void  DeadReckoningRcvMsgFstSens(const DEAD_RECKONING_RCVDATA *msg, DEAD_RECKONING_LONLAT_INFO *location_info,
 409                             const SENSOR_MSG_GPSDATA_DAT  *rcv_gps_msg, Struct_GpsData* send_gps_msg,
 410                             Struct_SensData* send_sensor_msg) {
 411     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 412        /* Verifying Debug Log Simulator Mode
 413            Perform packet reading here to match some timing.
 414            However,,Differ between GPS and SENSOR.
 415         */
 416     u_int8 fst_sens_send_num = 0U;
 417     /* For GPS data */
 418     if (g_gps_data_get_flg == TRUE) {
 419 #if (DR_DEBUG == 1) /* PastModel002_DR_VEHICLE */
 420         FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
 421              "DeadReckoningRcvMsg SEND GPS_DATA: DID[0x%08X] DSIZE[%d] MSG_SIZE[%d] SNS_CNT[%d] \r\n",
 422             rcv_gps_msg.ulDid, rcv_gps_msg.ucData[4], msg->hdr.hdr.msgbodysize, rcv_gps_msg.ucSnsCnt);
 423 #endif
 424
 425         if (1) {
 426             rcv_gps_msg = (const SENSOR_MSG_GPSDATA_DAT *)(&(msg->data[0]));
 427             /* #QAC confirmation Rule11.4 Use structure for member reference(Cast according to shared memory link IF) */
 428
 429             /* Set and pass the data part except header/footer */
 430             send_gps_msg->sens_cnt   = rcv_gps_msg->uc_sns_cnt;
 431             send_gps_msg->sens_cnt_flag = rcv_gps_msg->uc_gps_cnt_flag;
 432             send_gps_msg->gps_data_size = rcv_gps_msg->us_size;
 433             send_gps_msg->did    = rcv_gps_msg->ul_did;
 434             send_gps_msg->gps_data   = (const void *)(&rcv_gps_msg->uc_data[0]);
 435         }
 436
 437         /* Providing GPS data to DR_Lib */
 438
 439         g_gps_data_get_flg = FALSE;
 440
 441     } else if (g_sens_data_get_flg == TRUE) {
 442         Struct_DR_DATA      rcv_dr_data;
 443         DR_CALC_INFO      rcv_dr_calc_info;
 444         DEADRECKONING_DATA_MASTER   send_data_master;
 445
 446         if (1) {
 447             /* Each data is stored in the data format for transmission. */
 448             send_sensor_msg->sens_cnt_flag = 1U;
 449             send_sensor_msg->sens_cnt = g_sns_buf[0].data[0];
 450             send_sensor_msg->pulse_rev_tbl.reverse_flag = g_sns_buf[1].data[0];
 451             send_sensor_msg->pulse_rev_tbl.pulse_flag = g_sns_buf[2].data[0];
 452             send_sensor_msg->pulse_rev_tbl.pulse_sum_cyclic = static_cast<u_int16>(
 453                     ((((u_int16)g_sns_buf[3].data[0] << 0) & DR_MASK_WORD_L) |
 454                     (((u_int16)g_sns_buf[3].data[1] << 8) & DR_MASK_WORD_U)));
 455             /* ToDo */
 456             (void)memcpy(reinterpret_cast<void *>(&(send_sensor_msg->gyro_x_tbl.gyro_data[0])),
 457                          (const void *)(&(g_sns_buf[4].data[0])), sizeof(u_int16) * NUM_OF_100msData);
 458             (void)memcpy(reinterpret_cast<void *>(&(send_sensor_msg->gyro_y_tbl.gyro_data[0])),
 459                          (const void *)(&(g_sns_buf[5].data[0])), sizeof(u_int16) * NUM_OF_100msData);
 460             (void)memcpy(reinterpret_cast<void *>(&(send_sensor_msg->gyro_z_tbl.gyro_data[0])),
 461                          (const void *)(&(g_sns_buf[6].data[0])), sizeof(u_int16) * NUM_OF_100msData);
 462         }
 463
 464 #if (DR_DEBUG == 1) /* PastModel002_DR_VEHICLE */
 465         FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "DeadReckoningRcvMsg SEND SENSOR_COUNTER %d \r\n",
 466                        send_sensor_msg->sens_cnt);
 467 #endif
 468
 469         /* When the sensor data are ready, Call the DR-calculation process. */
 470         memset(&rcv_dr_data, 0x00, sizeof(rcv_dr_data));   /* Coverity CID:18805 compliant */
 471         memset(&rcv_dr_calc_info, 0x00, sizeof(rcv_dr_calc_info)); /* Coverity CID:18806 compliant */
 472
 473         location_info->calc_called = static_cast<u_int8>(TRUE);
 474         location_info->lonlat.latitude = static_cast<int32>(rcv_dr_data.latitude);
 475         location_info->lonlat.longitude = static_cast<int32>(rcv_dr_data.longitude);
 476
 477         if (rcv_dr_data.dr_status != static_cast<u_int8>(SENSORLOCATION_DRSTATUS_INVALID)) {
 478             location_info->available = static_cast<u_int8>(TRUE);
 479         } else {
 480             location_info->available = static_cast<u_int8>(FALSE);
 481         }
 482
 483         /* Changing the order of registration and delivery of the out structure to the data master for DR */
 484
 485         send_data_master.ul_did = VEHICLE_DID_DR_SNS_COUNTER;
 486         send_data_master.us_size = VEHICLE_DSIZE_DR_SNS_COUNTER;
 487         send_data_master.uc_rcv_flag = 1;
 488         send_data_master.dr_status = rcv_dr_data.dr_status;
 489         (void)memcpy(reinterpret_cast<void *>(&(send_data_master.uc_data[0])),
 490                      (const void *)(&(rcv_dr_data.positioning_time)), (size_t)VEHICLE_DSIZE_DR_SNS_COUNTER);
 491         DeadReckoningSetDataMaster(&send_data_master, (PFUNC_DR_DMASTER_SET_N)DeadReckoningDeliveryProc);
 492
 493         send_data_master.ul_did = VEHICLE_DID_DR_LONGITUDE;
 494         send_data_master.us_size = VEHICLE_DSIZE_LONGITUDE;
 495         send_data_master.uc_rcv_flag = 1;
 496         send_data_master.dr_status = rcv_dr_data.dr_status;
 497         (void)memcpy(reinterpret_cast<void *>(&(send_data_master.uc_data[0])),
 498                      (const void *)(&(rcv_dr_data.longitude)), (size_t)VEHICLE_DSIZE_LONGITUDE);
 499         DeadReckoningSetDataMaster(&send_data_master, (PFUNC_DR_DMASTER_SET_N)DeadReckoningDeliveryProc);
 500
 501         send_data_master.ul_did = VEHICLE_DID_DR_LATITUDE;
 502         send_data_master.us_size = VEHICLE_DSIZE_LATITUDE;
 503         send_data_master.uc_rcv_flag = 1;
 504         send_data_master.dr_status = rcv_dr_data.dr_status;
 505         (void)memcpy(reinterpret_cast<void *>(&(send_data_master.uc_data[0])),
 506                      (const void *)(&(rcv_dr_data.latitude)), (size_t)VEHICLE_DSIZE_LATITUDE);
 507         DeadReckoningSetDataMaster(&send_data_master, (PFUNC_DR_DMASTER_SET_N)DeadReckoningDeliveryProc);
 508
 509         send_data_master.ul_did = VEHICLE_DID_DR_ALTITUDE;
 510         send_data_master.us_size = VEHICLE_DSIZE_ALTITUDE;
 511         send_data_master.uc_rcv_flag = 1;
 512         send_data_master.dr_status = rcv_dr_data.dr_status;
 513         (void)memcpy(reinterpret_cast<void *>(&(send_data_master.uc_data[0])),
 514                      (const void *)(&(rcv_dr_data.altitude)), (size_t)VEHICLE_DSIZE_ALTITUDE);
 515         DeadReckoningSetDataMaster(&send_data_master, (PFUNC_DR_DMASTER_SET_N)DeadReckoningDeliveryProc);
 516
 517         send_data_master.ul_did = VEHICLE_DID_DR_SPEED;
 518         send_data_master.us_size = VEHICLE_DSIZE_SPEED;
 519         send_data_master.uc_rcv_flag = 1;
 520         send_data_master.dr_status = rcv_dr_data.dr_status;
 521         (void)memcpy(reinterpret_cast<void *>(&(send_data_master.uc_data[0])),
 522                      (const void *)(&(rcv_dr_data.rate)), (size_t)VEHICLE_DSIZE_SPEED);
 523         DeadReckoningSetDataMaster(&send_data_master, (PFUNC_DR_DMASTER_SET_N)DeadReckoningDeliveryProc);
 524
 525         send_data_master.ul_did = VEHICLE_DID_DR_HEADING;
 526         send_data_master.us_size = VEHICLE_DSIZE_HEADING;
 527         send_data_master.uc_rcv_flag = 1;
 528         send_data_master.dr_status = rcv_dr_data.dr_status;
 529         (void)memcpy(reinterpret_cast<void *>(&(send_data_master.uc_data[0])),
 530                      (const void *)(&(rcv_dr_data.heading)), (size_t)VEHICLE_DSIZE_HEADING);
 531         DeadReckoningSetDataMaster(&send_data_master, (PFUNC_DR_DMASTER_SET_N)DeadReckoningDeliveryProc);
 532
 533         /* Data master setting,Data delivery(GyroParameter)           */
 534         /* As it is registered for delivery with DID = VEHICLE_DID_DR_GYRO_SCALE_FACTOR_LEVEL    */
 535         /* Process in GyroOffset-> GyroScaleFactor-> GyroScelFactorLevel order(Processing order cannot be changed.) */
 536         send_data_master.ul_did = VEHICLE_DID_DR_GYRO_OFFSET;
 537         send_data_master.us_size = VEHICLE_DSIZE_GYRO_OFFSET;
 538         send_data_master.uc_rcv_flag = DEADRECKONING_RCVFLAG_ON;
 539         send_data_master.dr_status = 0U;       /* Not used */
 540         (void)memcpy(reinterpret_cast<void *>(&(send_data_master.uc_data[0])),
 541                      reinterpret_cast<void *>(&(rcv_dr_calc_info.gyro_offset)), (size_t)send_data_master.us_size);
 542         DeadReckoningSetDataMaster(&send_data_master, (PFUNC_DR_DMASTER_SET_N)DeadReckoningDeliveryProc);
 543
 544         send_data_master.ul_did = VEHICLE_DID_DR_GYRO_SCALE_FACTOR;
 545         send_data_master.us_size = VEHICLE_DSIZE_GYRO_SCALE_FACTOR;
 546         send_data_master.uc_rcv_flag = DEADRECKONING_RCVFLAG_ON;
 547         send_data_master.dr_status = 0U;       /* Not used */
 548         (void)memcpy(reinterpret_cast<void *>(&(send_data_master.uc_data[0])),
 549                      reinterpret_cast<void *>(&(rcv_dr_calc_info.gyro_scale_factor)),
 550                      (size_t)send_data_master.us_size);
 551         DeadReckoningSetDataMaster(&send_data_master, (PFUNC_DR_DMASTER_SET_N)DeadReckoningDeliveryProc);
 552
 553         send_data_master.ul_did = VEHICLE_DID_DR_GYRO_SCALE_FACTOR_LEVEL;
 554         send_data_master.us_size = VEHICLE_DSIZE_GYRO_SCALE_FACTOR_LEVEL;
 555         send_data_master.uc_rcv_flag = DEADRECKONING_RCVFLAG_ON;
 556         send_data_master.dr_status = 0U;       /* Not used */
 557         (void)memcpy(reinterpret_cast<void *>(&(send_data_master.uc_data[0])),
 558                      reinterpret_cast<void *>(&(rcv_dr_calc_info.gyro_scale_factor_level)),
 559                      (size_t)(send_data_master.us_size));
 560         DeadReckoningSetDataMaster(&send_data_master, (PFUNC_DR_DMASTER_SET_N)DeadReckoningDeliveryProc);
 561
 562         /* Data master setting,Data delivery(SpeedPulseParameter)         */
 563         /* As it is registered for delivery with DID = VEHICLE_DID_DR_SPEED_PULSE_SCALE_FACTOR_LEVEL   */
 564         /* Process in SpeedPulseScaleFactor-> SpeedPulseScaleFactorLevel order(Processing order cannot be changed.)  */
 565         send_data_master.ul_did = VEHICLE_DID_DR_SPEED_PULSE_SCALE_FACTOR;
 566         send_data_master.us_size = VEHICLE_DSIZE_SPEED_PULSE_SCALE_FACTOR;
 567         send_data_master.uc_rcv_flag = DEADRECKONING_RCVFLAG_ON;
 568         send_data_master.dr_status = 0U;       /* Not used */
 569         (void)memcpy(reinterpret_cast<void *>(&(send_data_master.uc_data[0])),
 570                      reinterpret_cast<void *>(&(rcv_dr_calc_info.speed_pulse_scale_factor)),
 571                      (size_t)(send_data_master.us_size));
 572         DeadReckoningSetDataMaster(&send_data_master, (PFUNC_DR_DMASTER_SET_N)DeadReckoningDeliveryProc);
 573
 574         send_data_master.ul_did = VEHICLE_DID_DR_SPEED_PULSE_SCALE_FACTOR_LEVEL;
 575         send_data_master.us_size = VEHICLE_DSIZE_SPEED_PULSE_SCALE_FACTOR_LEVEL;
 576         send_data_master.uc_rcv_flag = DEADRECKONING_RCVFLAG_ON;
 577         send_data_master.dr_status = 0U;       /* Not used */
 578         (void)memcpy(reinterpret_cast<void *>(&(send_data_master.uc_data[0])),
 579                      reinterpret_cast<void *>(&(rcv_dr_calc_info.speed_pulse_scale_factor_level)),
 580                      (size_t)(send_data_master.us_size));
 581         DeadReckoningSetDataMaster(&send_data_master, (PFUNC_DR_DMASTER_SET_N)DeadReckoningDeliveryProc);
 582
 583         g_sens_data_get_flg = FALSE;
 584     } else if (g_fst_sens_data_get_flg == TRUE) {
 585 #if (DR_DEBUG == 1) /* PastModel002_DR_VEHICLE */
 586         FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "DeadReckoningRcvMsg FstSnsData -> DeadReckoningLibrary. \r\n");
 587 #endif
 588         for (fst_sens_send_num = 0; fst_sens_send_num < g_fst_sns_buf.data_num; fst_sens_send_num++) {
 589             /* Each data is stored in the data format for transmission. */
 590             send_sensor_msg->sens_cnt_flag  = 0U;
 591             send_sensor_msg->sens_cnt   = 0U;
 592             send_sensor_msg->pulse_rev_tbl.reverse_flag  = g_fst_sns_buf.rev_data[fst_sens_send_num];
 593             send_sensor_msg->pulse_rev_tbl.pulse_flag   = g_fst_sns_buf.spd_pulse_check_data[fst_sens_send_num];
 594             send_sensor_msg->pulse_rev_tbl.pulse_sum_cyclic = g_fst_sns_buf.spd_pulse_data[fst_sens_send_num];
 595             (void)memcpy(reinterpret_cast<void *>(&(send_sensor_msg->gyro_x_tbl.gyro_data[0])),
 596                          (const void *)(&(g_fst_sns_buf.gyro_x_data[fst_sens_send_num * NUM_OF_100msData])),
 597                          (size_t)((sizeof(g_fst_sns_buf.gyro_x_data[fst_sens_send_num])) * NUM_OF_100msData));
 598             (void)memcpy(reinterpret_cast<void *>(&(send_sensor_msg->gyro_y_tbl.gyro_data[0])),
 599                          (const void *)(&(g_fst_sns_buf.gyro_y_data[fst_sens_send_num * NUM_OF_100msData])),
 600                          (size_t)((sizeof(g_fst_sns_buf.gyro_y_data[fst_sens_send_num])) * NUM_OF_100msData));
 601             (void)memcpy(reinterpret_cast<void *>(&(send_sensor_msg->gyro_z_tbl.gyro_data[0])),
 602                          (const void *)(&(g_fst_sns_buf.gyro_z_data[fst_sens_send_num * NUM_OF_100msData])),
 603                          (size_t)((sizeof(g_fst_sns_buf.gyro_z_data[fst_sens_send_num])) * NUM_OF_100msData));
 604
 605 #if (DR_DEBUG == 1) /* PastModel002_DR_VEHICLE */
 606             FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "DeadReckoningRcvMsg send_sensor_msg.sens_cnt_flag %d \r\n",
 607                           send_sensor_msg->sens_cnt_flag);
 608             FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "DeadReckoningRcvMsg SEND SENSOR_COUNTER %d \r\n",
 609                           send_sensor_msg->sens_cnt);
 610 #endif
 611
 612             /* Sleep to reduce CPU load */
 613             MilliSecSleep(DR_FST_SENS_CALC_SLEEP_TIME);
 614
 615             /* When the sensor data are ready, Call the DR-calculation process. */
 616         }
 617
 618         g_sens_data_get_flg = FALSE;
 619
 620         g_fst_sens_data_get_flg = FALSE;
 621
 622     } else {
 623         /* nop */
 624     }
 625 }
 626
 627 /*******************************************************************************
 628 * MODULE    : DeadReckoningGetDRData
 629 * ABSTRACT  : Vehicle sensor information acquisition
 630 * FUNCTION  :
 631 * ARGUMENT  : *msg : message buffer
 632 * NOTE      :
 633 * RETURN    : void
 634 ******************************************************************************/
 635 void DeadReckoningGetDRData(const DEADRECKONING_MSG_GET_DR_DATA *msg) {
 636     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 637     void  *share_top;      /* Start address of shared memory */
 638     u_int32  share_size;     /* Size of shared memory area */
 639     RET_API  ret_api;
 640     int32  ret;
 641     int32  event_val = VEHICLE_RET_NORMAL;
 642     EventID  event_id;
 643     DEADRECKONING_DATA_MASTER  dr_master; /* GPS Data Master */
 644
 645     DEADRECKONING_MSG_GET_DR_DATA msg_buf;
 646
 647     /* Defines the data master for each API. */
 648     SENSORLOCATION_MSG_LONLATINFO_DAT msg_lonlat_info;
 649     SENSORLOCATION_MSG_ALTITUDEINFO_DAT msg_altitude_info;
 650     SENSORMOTION_MSG_SPEEDINFO_DAT  msg_speed_info;
 651     SENSORMOTION_MSG_HEADINGINFO_DAT msg_heading_info;
 652
 653     (void)memset(reinterpret_cast<void *>(&msg_buf), 0, sizeof(DEADRECKONING_MSG_GET_DR_DATA));
 654     memcpy(&(msg_buf), msg, sizeof(DEADRECKONING_MSG_GET_DR_DATA));
 655
 656     /* Check the DID */
 657     ret = DeadReckoningCheckDid(msg_buf.data.did);
 658
 659     if (VEHICLESENS_INVALID != ret) {
 660         /* DID normal */
 661
 662         /* Link to shared memory */
 663         ret_api = _pb_LinkShareData(const_cast<char *>(VEHICLE_SHARE_NAME), &share_top, &share_size);
 664         if (RET_NORMAL == ret_api) {
 665             /* Acquire the specified data from the data master. */
 666             (void)memset(reinterpret_cast<void *>(&dr_master), 0, sizeof(DEADRECKONING_DATA_MASTER));
 667             DeadReckoningGetDataMaster(msg_buf.data.did, &dr_master);
 668
 669             /* Align data from the data master for API I/F */
 670             switch ((u_int32)(msg_buf.data.did)) {
 671                     /* Describes the process for each DID. */
 672                 case VEHICLE_DID_DR_LATITUDE:
 673                 {
 674                     (void)memset(reinterpret_cast<void *>(&msg_lonlat_info),
 675                                  0, sizeof(SENSORLOCATION_MSG_LONLATINFO_DAT));
 676
 677                     /* Size storage(LATITUDE)  */
 678                     msg_lonlat_info.size = static_cast<u_int16>(sizeof(SENSORLOCATION_MSG_LONLATINFO_DAT));
 679
 680                     /* DR status setting */
 681                     msg_lonlat_info.dr_status = dr_master.dr_status;
 682
 683                     /* The DR enable flag is set to DR status. */
 684                     msg_lonlat_info.is_exist_dr = dr_master.dr_status;
 685
 686                     /* Set the Latitude */
 687                     memcpy(&(msg_lonlat_info.latitude), &(dr_master.uc_data[0]), dr_master.us_size);
 688
 689                     /* Obtain the data master Longitude */
 690                     (void)memset(reinterpret_cast<void *>(&dr_master), 0, sizeof(DEADRECKONING_DATA_MASTER));
 691                     DeadReckoningGetDataMaster(VEHICLE_DID_DR_LONGITUDE, &dr_master);
 692
 693                     /* Set the Longitude */
 694                     memcpy(&(msg_lonlat_info.longitude), &(dr_master.uc_data[0]), dr_master.us_size);
 695
 696                     /* Acquire data master SensorCnt */
 697                     (void)memset(reinterpret_cast<void *>(&dr_master), 0, sizeof(DEADRECKONING_DATA_MASTER));
 698                     DeadReckoningGetDataMaster(VEHICLE_DID_DR_SNS_COUNTER, &dr_master);
 699
 700                     /* Set the SensorCnt */
 701                     memcpy(&(msg_lonlat_info.sensor_cnt), &(dr_master.uc_data[0]), dr_master.us_size);
 702
 703                     /* Write data master to shared memory */
 704                     PosSetShareData(share_top,
 705                                     msg_buf.data.offset,
 706                                     (const void *)&msg_lonlat_info,
 707                                     sizeof(msg_lonlat_info));
 708
 709                     /* Set Successful Completion */
 710                     event_val = VEHICLE_RET_NORMAL;
 711
 712                     break;
 713                 }
 714                 case VEHICLE_DID_DR_ALTITUDE:
 715                 {
 716                     (void)memset(reinterpret_cast<void *>(&msg_altitude_info),
 717                                  0, sizeof(SENSORLOCATION_MSG_ALTITUDEINFO_DAT));
 718
 719                     msg_altitude_info.size = static_cast<u_int16>(sizeof(SENSORLOCATION_MSG_ALTITUDEINFO_DAT));
 720                     /* The DR enable flag is set to DR status. */
 721                     msg_altitude_info.is_exist_dr = dr_master.dr_status;
 722                     msg_altitude_info.dr_status = dr_master.dr_status;
 723
 724                     /* Set the Speed */
 725                     memcpy(&(msg_altitude_info.altitude), &(dr_master.uc_data[0]), dr_master.us_size);
 726
 727                     /* Acquire data master SensorCnt */
 728                     (void)memset(reinterpret_cast<void *>(&dr_master), 0, sizeof(DEADRECKONING_DATA_MASTER));
 729                     DeadReckoningGetDataMaster(VEHICLE_DID_DR_SNS_COUNTER, &dr_master);
 730
 731                     /* Set the SensorCnt */
 732                     memcpy(&(msg_altitude_info.sensor_cnt), &(dr_master.uc_data[0]), dr_master.us_size);
 733
 734                     /* Write data master to shared memory */
 735                     PosSetShareData(share_top,
 736                                     msg_buf.data.offset,
 737                                     (const void *)&msg_altitude_info,
 738                                     sizeof(msg_altitude_info));
 739
 740                     /* Set Successful Completion */
 741                     event_val = VEHICLE_RET_NORMAL;
 742
 743                     break;
 744                 }
 745                 case VEHICLE_DID_DR_SPEED:
 746                 {
 747                     (void)memset(reinterpret_cast<void *>(&msg_speed_info),
 748                                  0, sizeof(SENSORMOTION_MSG_SPEEDINFO_DAT));
 749
 750                     msg_speed_info.size = static_cast<u_int16>(sizeof(SENSORMOTION_MSG_SPEEDINFO_DAT));
 751                     /* The DR enable flag is set to DR status. */
 752                     msg_speed_info.is_exist_dr = dr_master.dr_status;
 753                     msg_speed_info.dr_status = dr_master.dr_status;
 754
 755                     /* Set the Speed */
 756                     memcpy(&(msg_speed_info.speed), &(dr_master.uc_data[0]), dr_master.us_size);
 757
 758                     /* Acquire data master SensorCnt */
 759                     (void)memset(reinterpret_cast<void *>(&dr_master), 0, sizeof(DEADRECKONING_DATA_MASTER));
 760                     DeadReckoningGetDataMaster(VEHICLE_DID_DR_SNS_COUNTER, &dr_master);
 761                     /* Set the SensorCnt */
 762                     memcpy(&(msg_speed_info.sensor_cnt), &(dr_master.uc_data[0]), dr_master.us_size);
 763
 764                     /* Write data master to shared memory */
 765                     PosSetShareData(share_top,
 766                                           msg_buf.data.offset,
 767                                           (const void *)&msg_speed_info,
 768                                           sizeof(msg_speed_info));
 769
 770                     /* Set Successful Completion */
 771                     event_val = VEHICLE_RET_NORMAL;
 772
 773                     break;
 774                 }
 775                 case VEHICLE_DID_DR_HEADING:
 776                 {
 777                     (void)memset(reinterpret_cast<void *>(&msg_heading_info),
 778                                  0, sizeof(SENSORMOTION_MSG_HEADINGINFO_DAT));
 779
 780                     msg_heading_info.size = static_cast<u_int16>(sizeof(SENSORMOTION_MSG_HEADINGINFO_DAT));
 781                     /* The DR enable flag is set to DR status. */
 782                     msg_heading_info.is_exist_dr = dr_master.dr_status;
 783                     msg_heading_info.dr_status = dr_master.dr_status;
 784
 785                     /* Set the Heading */
 786                     memcpy(&(msg_heading_info.heading), &(dr_master.uc_data[0]), dr_master.us_size);
 787
 788                     /* Acquire data master SensorCnt */
 789                     (void)memset(reinterpret_cast<void *>(&dr_master), 0, sizeof(DEADRECKONING_DATA_MASTER));
 790                     DeadReckoningGetDataMaster(VEHICLE_DID_DR_SNS_COUNTER, &dr_master);
 791                     /* Set the SensorCnt */
 792                     memcpy(&(msg_heading_info.sensor_cnt), &(dr_master.uc_data[0]), dr_master.us_size);
 793
 794                     /* Write data master to shared memory */
 795                     PosSetShareData(share_top,
 796                                           msg_buf.data.offset,
 797                                           (const void *)&msg_heading_info,
 798                                           sizeof(msg_heading_info));
 799                     /* Set Successful Completion */
 800                     event_val = VEHICLE_RET_NORMAL;
 801
 802                     break;
 803                 }
 804                 /* Other than the above */
 805                 default:
 806                     /* Do not edit. */
 807                     break;
 808             }
 809
 810             /* Check the data size */
 811             if (msg_buf.data.size < dr_master.us_size) {
 812                 /* Shared memory error(Insufficient storage size) */
 813                 event_val = VEHICLE_RET_ERROR_OUTOF_MEMORY;
 814             }
 815         } else {
 816             /* Shared memory error */
 817             event_val = VEHICLE_RET_ERROR_OUTOF_MEMORY;
 818         }
 819     } else {
 820         /* DID error */
 821         event_val = VEHICLE_RET_ERROR_DID;
 822     }
 823
 824     /* Event Generation */
 825     event_id = VehicleCreateEvent(msg_buf.data.pno);
 826
 827     /* Publish Events */
 828     ret_api = _pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, event_val);
 829 }
 830
 831 /*******************************************************************************
 832 * MODULE    : DeadReckoningSetMapMatchingData
 833 * ABSTRACT  : Map-Matching information setting
 834 * FUNCTION  : Setting Map-Matching Information
 835 * ARGUMENT  : *msg : message buffer
 836 * NOTE      :
 837 * RETURN    : void
 838 ******************************************************************************/
 839 void DeadReckoningSetMapMatchingData(const DR_MSG_MAP_MATCHING_DATA *msg) {
 840     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 841 }
 842
 843 /*******************************************************************************
 844 * MODULE    : DeadReckoningClearBackupData
 845 * ABSTRACT  : Backup data clear function CALL
 846 * FUNCTION  : Call the backup data clear function.
 847 * ARGUMENT  : *msg : message buffer
 848 * NOTE      :
 849 * RETURN    : None
 850 ******************************************************************************/
 851 void DeadReckoningClearBackupData(const DR_MSG_CLEAR_BACKUP_DATA *msg) {
 852     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 853     char  event_name[32]; /* Event name character string buffer */
 854     EventID  event_id;   /* Event ID */
 855     int32  event_val;   /* Event value to set*/
 856     RET_API  ret_api;   /* System API return value */
 857
 858     if (msg != NULL) {
 859         /* DR backup data initialization function call */
 860         event_val = RET_NORMAL;
 861
 862         /* Initialization of event name character string buffer */
 863         (void)memset(reinterpret_cast<void *>(event_name), 0, sizeof(event_name));
 864
 865         /* Event name creation */
 866         snprintf(event_name, sizeof(event_name), "DR_API_%X", msg->hdr.hdr.sndpno);
 867         /* Match DR_API.cpp side with name */
 868
 869         /* Event Generation */
 870         event_id = _pb_CreateEvent(_CWORD64_EVENT_MANUALRESET_OFF, DR_EVENT_VAL_INIT, event_name);
 871
 872         if (event_id != 0) {
 873             /* For successful event generation */
 874             /* Set the event */
 875             ret_api = _pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, event_val);
 876
 877             if (ret_api == RET_NORMAL) {
 878                 /* Successful event set */
 879             } else {
 880                 /* Event set failed */
 881                 /* Delete Event and Return Event Generation Failed */
 882                 ret_api = _pb_DeleteEvent(event_id);
 883                 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_SetEvent Failed\r\n");
 884             }
 885         }
 886     }
 887 }
 888
 889 /*******************************************************************************
 890 * MODULE    : DeadReckoningSetEvent
 891 * ABSTRACT  : Set of events
 892 * FUNCTION  : Set event to return successful or unsuccessful log configuration retrieval
 893 * ARGUMENT  : PNO     pno  : Caller Pno
 894 *           : RET_API ret : Log setting acquisition Success/Fail
 895 *           :                RET_NORMAL: Log setting acquisition success
 896 *           :                RET_ERROR: Log setting acquisition failure
 897 * NOTE      :
 898 * RETURN    : None
 899 ******************************************************************************/
 900 static void DeadReckoningSetEvent(PNO pno, RET_API ret) {
 901     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 902     char  event_name[32]; /* Event name character string buffer */
 903     EventID  event_id;   /* Event ID */
 904     RET_API  ret_api;   /* System API return value */
 905
 906     /* Initialization of event name character string buffer */
 907     (void)memset(reinterpret_cast<void *>(event_name), 0, sizeof(event_name));
 908
 909     /* Event name creation */
 910     snprintf(event_name, sizeof(event_name), "VehicleDebug_%X", pno);
 911     /* Event name should match VehicleDebug_API.cpp */
 912
 913     /* Event Generation */
 914     event_id = _pb_CreateEvent(_CWORD64_EVENT_MANUALRESET_OFF, VEHICLEDEBUG_EVENT_VAL_INIT, event_name);
 915
 916     if (event_id != 0) {
 917         /* For successful event generation */
 918         /* Set the event */
 919         ret_api = _pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, ret);
 920
 921         if (ret_api == RET_NORMAL) {
 922             /* Successful event set */
 923         } else {
 924             /* Event set failed */
 925             /* Delete Event */
 926             ret_api = _pb_DeleteEvent(event_id);
 927             FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_SetEvent Failed\r\n");
 928         }
 929     }
 930 }
 931
 932 /*******************************************************************************
 933 * MODULE    : DeadReckoningLinkSharedMemory
 934 * ABSTRACT  : Shared memory link
 935 * FUNCTION  : Link to shared memory
 936 * ARGUMENT  : char *shared_memory_name : Name of shared memory to link
 937 *           : void **share_addr        : Pointer to a variable that stores the address of the linked shared memory.
 938 * NOTE      :
 939 * RETURN    : None
 940 ******************************************************************************/
 941 static void DeadReckoningLinkSharedMemory(char *shared_memory_name, void **share_addr) {
 942     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 943     RET_API ret_api;
 944     void *pv_share_mem; /* Store Shared Memory Address */
 945     u_int32 share_mem_size; /* Size of the linked shared memory */
 946
 947     if ((shared_memory_name != NULL) && (share_addr != NULL)) {
 948         /* Link to the handle storage area */
 949         ret_api = _pb_LinkShareData(shared_memory_name, &pv_share_mem, &share_mem_size);
 950
 951         if (ret_api == RET_NORMAL) {
 952             /* If the link is successful */
 953             if (share_mem_size == VEHICLEDEBUG_MSGBUF_DSIZE) {
 954                 /* When the size of the linked shared memory is correct */
 955                 *share_addr = pv_share_mem; /* Set the address */
 956             } else {
 957                 /* The size of the linked shared memory is incorrect. */
 958                 *share_addr = NULL;
 959                 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Bad shared memory size\r\n");
 960             }
 961         } else {
 962             /* If the link fails */
 963             *share_addr = NULL;
 964             FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't link shared memory\r\n");
 965         }
 966     }
 967 }
 968
 969 /*******************************************************************************
 970 * MODULE    : DeadReckoningWriteSharedMemory
 971 * ABSTRACT  : Write Shared Memory
 972 * FUNCTION  : Write Shared Memory
 973 * ARGUMENT  : VEHICLEDEBUG_MSG_LOGINFO_DAT* loginfo : Logging information
 974 * RETURN    : RET_API : Whether writing to shared memory was successful
 975 *           :         : RET_NORMAL Success
 976 *           :         : RET_ERROR Failed
 977 * NOTE      :
 978 ******************************************************************************/
 979 static RET_API DeadReckoningWriteSharedMemory(VEHICLEDEBUG_MSG_LOGINFO_DAT* loginfo) {
 980     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 981     static VEHICLEDEBUG_MSG_LOGINFO_DAT *share_addr = NULL; /* Store Shared Memory Address */
 982     static SemID   sem_id = 0;      /* ID of shared memory exclusive semaphore */
 983
 984     RET_API ret = RET_NORMAL; /* Return of the functions */
 985     RET_API ret_api;    /* Return of the functions */
 986
 987 #if DEAD_RECKONING_MAIN_DEBUG
 988     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Call %s\r\n", __func__);
 989 #endif
 990
 991     /* Get Semaphore ID */
 992     if (sem_id == 0) {
 993         sem_id = _pb_CreateSemaphore(const_cast<char *>(SENSOR_LOG_SETTING_SEMAPHO_NAME));
 994     }
 995
 996     if (sem_id != 0) {
 997         /* Semaphore ID successfully acquired */
 998         ret_api = _pb_SemLock(sem_id); /* Semaphore Lock */
 999
1000         if (ret_api == RET_NORMAL) {
1001             /* Semaphore lock successful */
1002
1003             /* When the shared memory is not linked */
1004             if (share_addr == NULL) {
1005                 /* Link to shared memory */
1006                 DeadReckoningLinkSharedMemory(const_cast<char *>(LOG_SETTING_SHARE_MEMORY_NAME),
1007                                               reinterpret_cast<void **>(&share_addr));
1008                 /* #QAC confirmation Rule11.4 Use structure for member reference(Cast according to shared memory link IF) */
1009             }
1010
1011             if (share_addr != NULL) {
1012                 /* The link to shared memory is successful. */
1013                 /* Writing Data to Shared Memory */
1014                 share_addr->log_sw = loginfo->log_sw;
1015                 (void)memcpy(reinterpret_cast<void *>(share_addr->severity),
1016                              (const void *)(loginfo->severity), sizeof(share_addr->severity));
1017             } else {
1018                 /* Failed to link to shared memory */
1019                 ret = RET_ERROR;
1020                 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "DeadReckoningLinkSharedMemory Failed");
1021             }
1022             /* Semaphore unlock */
1023             (void)_pb_SemUnlock(sem_id);
1024         } else {
1025             /* Semaphore lock failed */
1026             ret = RET_ERROR;
1027             FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_SemLock Failed");
1028         }
1029     } else {
1030         ret = RET_ERROR;
1031         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "sem_id == 0");
1032     }
1033
1034     return ret;
1035 }
1036
1037 /*******************************************************************************
1038 * MODULE    : DeadReckoningGetLocationLogStatus
1039 * ABSTRACT  : CALL of functions for acquiring logging settings
1040 * FUNCTION  : Call the log setting acquisition function.
1041 * ARGUMENT  : None
1042 * NOTE      :
1043 * RETURN    : void
1044 ******************************************************************************/
1045 void DeadReckoningGetLocationLogStatus(PNO pno) {
1046     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1047     RET_API       ret_api; /* System API return value */
1048     RET_API       ret;
1049     VEHICLEDEBUG_MSG_LOGINFO_DAT loginfo; /* Logging information */
1050     BOOL log_sw = FALSE;
1051
1052     /* CALL of functions for acquiring logging settings */
1053     ret_api = RET_NORMAL;
1054
1055     if (ret_api == RET_NORMAL) {
1056         /* Log setting acquisition function succeeded */
1057         loginfo.log_sw = (u_int32)(log_sw);
1058
1059         /* Write to shared memory */
1060         ret = DeadReckoningWriteSharedMemory(&loginfo);
1061
1062         /* Event publishing */
1063         DeadReckoningSetEvent(pno, ret);
1064     } else {
1065         /* Log setting acquisition function failed */
1066         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "GetLocationLogSetting Failed");
1067
1068         /* Event publishing */
1069         DeadReckoningSetEvent(pno, RET_ERROR);
1070     }
1071 }
1072
1073 /*******************************************************************************
1074 * MODULE    : DeadReckoningSetLocationLogStatus
1075 * ABSTRACT  : CALL of log-setting-request-function
1076 * FUNCTION  : Call the log setting request function.
1077 * ARGUMENT  : u_int32 log_sw : Log type
1078 *           : u_int8 severity : Output level
1079 * NOTE      :
1080 * RETURN    : void
1081 ******************************************************************************/
1082 void DeadReckoningSetLocationLogStatus(BOOL log_sw, u_int8 severity) {
1083     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
1084 }
1085
1086 // LCOV_EXCL_STOP