2 * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
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 ******************************************************************************/
26 #include <positioning_hal.h>
28 #include "DeadReckoning_main.h"
30 #include "Sensor_Common_API.h"
31 #include "DeadReckoning_DataMaster.h"
32 #include "Dead_Reckoning_Local_Api.h"
34 #include "DeadReckoning_DbgLogSim.h"
36 #include "POS_private.h"
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);
42 #define DEAD_RECKONING_MAIN_DEBUG 0
44 #define DR_DEBUG_ENG_MODE 0
46 /*************************************************/
48 /*************************************************/
50 #define DEAD_RECKONING_BUF_SIZE 7
51 #define DR_MASK_WORD_L 0x00FF
52 #define DR_MASK_WORD_U 0xFF00
54 /*************************************************/
56 /*************************************************/
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;
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;
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;
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;
84 /*******************************************************************************
85 * MODULE : DeadReckoningInit
86 * ABSTRACT : Guessed navigation initialization processing
87 * FUNCTION : Initialize inferred navigation processing
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
98 /*******************************************************************************
99 * MODULE : DeadReckoningRcvMsg
100 * ABSTRACT : DR Component MSG Receive Processing
101 * FUNCTION : Receive the DR component MSG
102 * ARGUMENT : *msg : message buffer
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");
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;
115 Struct_GpsData send_gps_msg;
116 Struct_SensData send_sensor_msg;
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));
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);
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) */
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 :
140 g_gps_data_get_flg = TRUE;
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) */
150 /* Sensor data reception for DR */
151 switch (rcv_sensor_msg->ul_did) {
152 case POSHAL_DID_SNS_COUNTER :
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;
160 case POSHAL_DID_REV :
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;
169 case POSHAL_DID_SPEED_PULSE_FLAG :
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;
178 case POSHAL_DID_SPEED_PULSE :
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;
187 case POSHAL_DID_GYRO_X :
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;
196 case POSHAL_DID_GYRO_Y :
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;
205 case POSHAL_DID_GYRO_Z :
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;
217 } else if (CID_DEAD_RECKONING_SENS_FST_DATA == msg->hdr.hdr.cid) {
218 u_int16 rev_data_size;
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);
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);
229 /* Sensor data reception for DR */
230 switch (rcv_sensor_msg_fst->ul_did) {
231 case POSHAL_DID_REV_FST :
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));
239 g_fst_sns_buf.rev_rcv_size = static_cast<u_int16>(
240 g_fst_sns_buf.rev_rcv_size + rev_data_size);
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 ");
250 case POSHAL_DID_SPEED_PULSE_FLAG_FST :
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));
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);
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 ");
269 case POSHAL_DID_SPEED_PULSE_FST :
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));
277 g_fst_sns_buf.spd_pulse_rcv_size = static_cast<u_int16>(g_fst_sns_buf.spd_pulse_rcv_size + \
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 ");
288 case POSHAL_DID_GYRO_X_FST :
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));
296 g_fst_sns_buf.gyro_x_rcv_size = static_cast<u_int16>(g_fst_sns_buf.gyro_x_rcv_size + rev_data_size);
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);
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 ");
311 case POSHAL_DID_GYRO_Y_FST :
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));
319 g_fst_sns_buf.gyro_y_rcv_size = static_cast<u_int16>(g_fst_sns_buf.gyro_y_rcv_size + rev_data_size);
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);
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 ");
334 case POSHAL_DID_GYRO_Z_FST :
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));
342 g_fst_sns_buf.gyro_z_rcv_size = static_cast<u_int16>(g_fst_sns_buf.gyro_z_rcv_size + rev_data_size);
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);
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 ");
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;
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;
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;
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;
404 DeadReckoningRcvMsgFstSens(msg, location_info, rcv_gps_msg, &send_gps_msg, &send_sensor_msg);
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.
416 u_int8 fst_sens_send_num = 0U;
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);
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) */
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]);
437 /* Providing GPS data to DR_Lib */
439 g_gps_data_get_flg = FALSE;
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;
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)));
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);
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);
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 */
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);
477 if (rcv_dr_data.dr_status != static_cast<u_int8>(SENSORLOCATION_DRSTATUS_INVALID)) {
478 location_info->available = static_cast<u_int8>(TRUE);
480 location_info->available = static_cast<u_int8>(FALSE);
483 /* Changing the order of registration and delivery of the out structure to the data master for DR */
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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);
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");
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));
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);
612 /* Sleep to reduce CPU load */
613 MilliSecSleep(DR_FST_SENS_CALC_SLEEP_TIME);
615 /* When the sensor data are ready, Call the DR-calculation process. */
618 g_sens_data_get_flg = FALSE;
620 g_fst_sens_data_get_flg = FALSE;
627 /*******************************************************************************
628 * MODULE : DeadReckoningGetDRData
629 * ABSTRACT : Vehicle sensor information acquisition
631 * ARGUMENT : *msg : message buffer
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 */
641 int32 event_val = VEHICLE_RET_NORMAL;
643 DEADRECKONING_DATA_MASTER dr_master; /* GPS Data Master */
645 DEADRECKONING_MSG_GET_DR_DATA msg_buf;
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;
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));
657 ret = DeadReckoningCheckDid(msg_buf.data.did);
659 if (VEHICLESENS_INVALID != ret) {
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);
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:
674 (void)memset(reinterpret_cast<void *>(&msg_lonlat_info),
675 0, sizeof(SENSORLOCATION_MSG_LONLATINFO_DAT));
677 /* Size storage(LATITUDE) */
678 msg_lonlat_info.size = static_cast<u_int16>(sizeof(SENSORLOCATION_MSG_LONLATINFO_DAT));
680 /* DR status setting */
681 msg_lonlat_info.dr_status = dr_master.dr_status;
683 /* The DR enable flag is set to DR status. */
684 msg_lonlat_info.is_exist_dr = dr_master.dr_status;
686 /* Set the Latitude */
687 memcpy(&(msg_lonlat_info.latitude), &(dr_master.uc_data[0]), dr_master.us_size);
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);
693 /* Set the Longitude */
694 memcpy(&(msg_lonlat_info.longitude), &(dr_master.uc_data[0]), dr_master.us_size);
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);
700 /* Set the SensorCnt */
701 memcpy(&(msg_lonlat_info.sensor_cnt), &(dr_master.uc_data[0]), dr_master.us_size);
703 /* Write data master to shared memory */
704 PosSetShareData(share_top,
706 (const void *)&msg_lonlat_info,
707 sizeof(msg_lonlat_info));
709 /* Set Successful Completion */
710 event_val = VEHICLE_RET_NORMAL;
714 case VEHICLE_DID_DR_ALTITUDE:
716 (void)memset(reinterpret_cast<void *>(&msg_altitude_info),
717 0, sizeof(SENSORLOCATION_MSG_ALTITUDEINFO_DAT));
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;
725 memcpy(&(msg_altitude_info.altitude), &(dr_master.uc_data[0]), dr_master.us_size);
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);
731 /* Set the SensorCnt */
732 memcpy(&(msg_altitude_info.sensor_cnt), &(dr_master.uc_data[0]), dr_master.us_size);
734 /* Write data master to shared memory */
735 PosSetShareData(share_top,
737 (const void *)&msg_altitude_info,
738 sizeof(msg_altitude_info));
740 /* Set Successful Completion */
741 event_val = VEHICLE_RET_NORMAL;
745 case VEHICLE_DID_DR_SPEED:
747 (void)memset(reinterpret_cast<void *>(&msg_speed_info),
748 0, sizeof(SENSORMOTION_MSG_SPEEDINFO_DAT));
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;
756 memcpy(&(msg_speed_info.speed), &(dr_master.uc_data[0]), dr_master.us_size);
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);
764 /* Write data master to shared memory */
765 PosSetShareData(share_top,
767 (const void *)&msg_speed_info,
768 sizeof(msg_speed_info));
770 /* Set Successful Completion */
771 event_val = VEHICLE_RET_NORMAL;
775 case VEHICLE_DID_DR_HEADING:
777 (void)memset(reinterpret_cast<void *>(&msg_heading_info),
778 0, sizeof(SENSORMOTION_MSG_HEADINGINFO_DAT));
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;
785 /* Set the Heading */
786 memcpy(&(msg_heading_info.heading), &(dr_master.uc_data[0]), dr_master.us_size);
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);
794 /* Write data master to shared memory */
795 PosSetShareData(share_top,
797 (const void *)&msg_heading_info,
798 sizeof(msg_heading_info));
799 /* Set Successful Completion */
800 event_val = VEHICLE_RET_NORMAL;
804 /* Other than the above */
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;
816 /* Shared memory error */
817 event_val = VEHICLE_RET_ERROR_OUTOF_MEMORY;
821 event_val = VEHICLE_RET_ERROR_DID;
824 /* Event Generation */
825 event_id = VehicleCreateEvent(msg_buf.data.pno);
828 ret_api = _pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, event_val);
831 /*******************************************************************************
832 * MODULE : DeadReckoningSetMapMatchingData
833 * ABSTRACT : Map-Matching information setting
834 * FUNCTION : Setting Map-Matching Information
835 * ARGUMENT : *msg : message buffer
838 ******************************************************************************/
839 void DeadReckoningSetMapMatchingData(const DR_MSG_MAP_MATCHING_DATA *msg) {
840 AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
843 /*******************************************************************************
844 * MODULE : DeadReckoningClearBackupData
845 * ABSTRACT : Backup data clear function CALL
846 * FUNCTION : Call the backup data clear function.
847 * ARGUMENT : *msg : message buffer
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 */
859 /* DR backup data initialization function call */
860 event_val = RET_NORMAL;
862 /* Initialization of event name character string buffer */
863 (void)memset(reinterpret_cast<void *>(event_name), 0, sizeof(event_name));
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 */
869 /* Event Generation */
870 event_id = _pb_CreateEvent(_CWORD64_EVENT_MANUALRESET_OFF, DR_EVENT_VAL_INIT, event_name);
873 /* For successful event generation */
875 ret_api = _pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, event_val);
877 if (ret_api == RET_NORMAL) {
878 /* Successful event set */
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");
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
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 */
906 /* Initialization of event name character string buffer */
907 (void)memset(reinterpret_cast<void *>(event_name), 0, sizeof(event_name));
909 /* Event name creation */
910 snprintf(event_name, sizeof(event_name), "VehicleDebug_%X", pno);
911 /* Event name should match VehicleDebug_API.cpp */
913 /* Event Generation */
914 event_id = _pb_CreateEvent(_CWORD64_EVENT_MANUALRESET_OFF, VEHICLEDEBUG_EVENT_VAL_INIT, event_name);
917 /* For successful event generation */
919 ret_api = _pb_SetEvent(event_id, SAPI_EVSET_ABSOLUTE, ret);
921 if (ret_api == RET_NORMAL) {
922 /* Successful event set */
924 /* Event set failed */
926 ret_api = _pb_DeleteEvent(event_id);
927 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_SetEvent Failed\r\n");
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.
940 ******************************************************************************/
941 static void DeadReckoningLinkSharedMemory(char *shared_memory_name, void **share_addr) {
942 AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
944 void *pv_share_mem; /* Store Shared Memory Address */
945 u_int32 share_mem_size; /* Size of the linked shared memory */
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);
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 */
957 /* The size of the linked shared memory is incorrect. */
959 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Bad shared memory size\r\n");
962 /* If the link fails */
964 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Can't link shared memory\r\n");
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
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 */
984 RET_API ret = RET_NORMAL; /* Return of the functions */
985 RET_API ret_api; /* Return of the functions */
987 #if DEAD_RECKONING_MAIN_DEBUG
988 FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Call %s\r\n", __func__);
991 /* Get Semaphore ID */
993 sem_id = _pb_CreateSemaphore(const_cast<char *>(SENSOR_LOG_SETTING_SEMAPHO_NAME));
997 /* Semaphore ID successfully acquired */
998 ret_api = _pb_SemLock(sem_id); /* Semaphore Lock */
1000 if (ret_api == RET_NORMAL) {
1001 /* Semaphore lock successful */
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) */
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));
1018 /* Failed to link to shared memory */
1020 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "DeadReckoningLinkSharedMemory Failed");
1022 /* Semaphore unlock */
1023 (void)_pb_SemUnlock(sem_id);
1025 /* Semaphore lock failed */
1027 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "_pb_SemLock Failed");
1031 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "sem_id == 0");
1037 /*******************************************************************************
1038 * MODULE : DeadReckoningGetLocationLogStatus
1039 * ABSTRACT : CALL of functions for acquiring logging settings
1040 * FUNCTION : Call the log setting acquisition function.
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 */
1049 VEHICLEDEBUG_MSG_LOGINFO_DAT loginfo; /* Logging information */
1050 BOOL log_sw = FALSE;
1052 /* CALL of functions for acquiring logging settings */
1053 ret_api = RET_NORMAL;
1055 if (ret_api == RET_NORMAL) {
1056 /* Log setting acquisition function succeeded */
1057 loginfo.log_sw = (u_int32)(log_sw);
1059 /* Write to shared memory */
1060 ret = DeadReckoningWriteSharedMemory(&loginfo);
1062 /* Event publishing */
1063 DeadReckoningSetEvent(pno, ret);
1065 /* Log setting acquisition function failed */
1066 FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "GetLocationLogSetting Failed");
1068 /* Event publishing */
1069 DeadReckoningSetEvent(pno, RET_ERROR);
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
1081 ******************************************************************************/
1082 void DeadReckoningSetLocationLogStatus(BOOL log_sw, u_int8 severity) {
1083 AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert