--- /dev/null
+/*
+ * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*******************************************************************************
+ * File name :VehicleSens_DeliveryCtrl.cpp
+ * System name :GPF
+ * Subsystem name :Vehicle sensor process
+ * Program name :Vehicle Sensor Destination Management
+ * Module configuration VehicleSensInitDeliveryCtrlTbl() Vehicle sensor delivery destination management table initialization function
+ * VehicleSensInitDeliveryCtrlTblMng() Vehicle sensor delivery destination management table management area initialization function
+ * VehicleSensInitPkgDeliveryTblMng() Vehicle Sensor Package Delivery Management Table Initialization Function
+ * VehicleSensEntryDeliveryCtrl() Vehicle sensor delivery destination management registration function
+ * VehicleSensAddDeliveryCtrlTbl() Vehicle sensor delivery destination management table addition function
+ * VehicleSensUpdateDeliveryCtrlTbl() Vehicle sensor delivery destination management table update function
+ * VehicleSensUpdatePkgDeliveryCtrlTbl() Vehicle Sensor Delivery Destination Management Table Package Delivery Data Update Function
+ * VehicleSensAddDeliveryCtrlTblMng() Vehicle sensor delivery destination management table management addition function
+ * VehicleSensUpdateDeliveryCtrlTblMng() Vehicle sensor delivery destination management table management update function
+ * VehicleSensAddPkgDeliveryTblMng() Vehicle Sensor Package Delivery Management Table Additional Function
+ * VehicleSensEntryPkgDeliveryCtrl() Vehicle sensor package delivery management registration function
+ * VehicleSensMakeDeliveryPnoTbl() Vehicle Sensor Destination PNO Table Creation Function
+ * VehicleSensAddPnoTbl() Vehicle Sensor Destination PNO Table Addition Function
+ * VehicleSensDeliveryProc() Vehicle Sensor Data Delivery Process
+ * VehicleSensFirstDelivery() Vehicle Sensor Initial Data Delivery Process
+ * VehicleSensFirstPkgDelivery() Vehicle Sensor Initial Package Data Delivery Process
+ ******************************************************************************/
+
+#include <vehicle_service/positioning_base_library.h>
+#include <vehicle_service/POS_common_API.h>
+#include <vehicle_service/POS_gps_API.h>
+#include "VehicleSens_DeliveryCtrl.h"
+#include "Dead_Reckoning_Local_Api.h"
+#include "SensorLog.h"
+#include "POS_private.h"
+
+#define VEHICLE_SENS_DELIVERY_CTRL_DEBUG 0
+#define VEHICLE_SENS_DELIVERY_CTRL_DEBUG_DIAG 0
+
+#define GYRO_NORMAL (0U)
+#define GYRO_ERROR (1U)
+#define GYRO_UNFIXED (2U)
+
+#define _pb_strcat(pdest, psrc, size) (strncat(pdest, psrc, size) , (0))
+
+/*************************************************/
+/* Global variable */
+/*************************************************/
+static VEHICLESENS_DELIVERY_CTRL_TBL g_stdelivery_ctrl_tbl;
+static VEHICLESENS_DELIVERY_CTRL_TBL_MNG g_stdelivery_ctrl_tbl_mng;
+static VEHICLESENS_PKG_DELIVERY_TBL_MNG g_stpkgdelivery_tbl_mng;
+static VEHICLESENS_DELIVERY_PNO_TBL g_stdelivery_pno_tbl;
+
+/* ++ PastModel002 response DR */
+static VEHICLESENS_DELIVERY_CTRL_TBL g_stdelivery_ctrl_tbl_dr;
+static VEHICLESENS_DELIVERY_CTRL_TBL_MNG g_stdelivery_ctrl_tbl_mng_dr;
+static VEHICLESENS_DELIVERY_PNO_TBL g_stdelivery_pno_tbl_dr;
+
+/* -- PastModel002 response DR */
+
+#if CONFIG_HW_PORTSET_TYPE_C
+u_int16 gusSeqNum; /* Sequence number for split transmission */
+#endif
+
+/*******************************************************************************
+* MODULE : VehicleSensInitDeliveryCtrlTbl
+* ABSTRACT : Vehicle sensor delivery destination management table initialization function
+* FUNCTION : Delivery destination management table initialization processing
+* ARGUMENT : void
+* NOTE :
+******************************************************************************/
+void VehicleSensInitDeliveryCtrlTbl(void) {
+ memset(&g_stdelivery_ctrl_tbl, 0x00, sizeof(VEHICLESENS_DELIVERY_CTRL_TBL));
+}
+
+/*******************************************************************************
+* MODULE : VehicleSensInitDeliveryCtrlTblMng
+* ABSTRACT : Vehicle Sensor DR Internal Delivery Destination Management Table Management Area Initialization Function
+* FUNCTION : Delivery destination management table management area initialization processing
+* ARGUMENT : void
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensInitDeliveryCtrlTblMng(void) {
+ memset(&g_stdelivery_ctrl_tbl_mng, 0x00, sizeof(VEHICLESENS_DELIVERY_CTRL_TBL_MNG));
+}
+
+/* ++ PastModel002 response DR */
+/*******************************************************************************
+* MODULE : VehicleSensInitDeliveryCtrlTblDR
+* ABSTRACT : Vehicle sensor delivery destination management table initialization function
+* FUNCTION : DR distribution target management table initialization processing
+* ARGUMENT : void
+* NOTE :
+******************************************************************************/
+void VehicleSensInitDeliveryCtrlTblDR(void) { // LCOV_EXCL_START 8: dead code.
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ memset(&g_stdelivery_ctrl_tbl_dr, 0x00, sizeof(VEHICLESENS_DELIVERY_CTRL_TBL));
+}
+// LCOV_EXCL_STOP
+
+/*******************************************************************************
+* MODULE : VehicleSensInitDeliveryCtrlTblMngDR
+* ABSTRACT : Vehicle sensor delivery destination management table management area initialization function
+* FUNCTION : Initialization processing for the management table area of the delivery destination management table for DR
+* ARGUMENT : void
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensInitDeliveryCtrlTblMngDR(void) { // LCOV_EXCL_START 8 : dead code
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ memset(&g_stdelivery_ctrl_tbl_mng_dr, 0x00, sizeof(VEHICLESENS_DELIVERY_CTRL_TBL_MNG));
+}
+// LCOV_EXCL_STOP
+
+/* -- PastModel002 response DR */
+
+/*******************************************************************************
+* MODULE : VehicleSensInitPkgDeliveryTblMng
+* ABSTRACT : Vehicle Sensor Package Delivery Management Table Initialization Function
+* FUNCTION : Delivery Package Management Table Initialization Processing
+* ARGUMENT : void
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensInitPkgDeliveryTblMng(void) {
+ memset(&g_stpkgdelivery_tbl_mng, 0x00, sizeof(VEHICLESENS_PKG_DELIVERY_TBL_MNG));
+}
+
+#if CONFIG_HW_PORTSET_TYPE_C
+/*******************************************************************************
+* MODULE : VehicleSensInitSeqNum
+* ABSTRACT : Sequence number initialization function for split transmission
+* FUNCTION : Sequence number initialization processing for split transmission
+* ARGUMENT : void
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensInitSeqNum(void) {
+ gusSeqNum = 0;
+}
+#endif
+
+/*******************************************************************************
+* MODULE : VehicleSensEntryDeliveryCtrl
+* ABSTRACT : Vehicle sensor delivery destination management registration function
+* FUNCTION : Shipping management table,Update the shipping management table management.
+* ARGUMENT : pst_delivery_entry : Pointer to the delivery registration information
+* NOTE :
+* RETURN : VEHICLE_RET_NORMAL :Successful registration
+******************************************************************************/
+VEHICLE_RET_API VehicleSensEntryDeliveryCtrl(const VEHICLE_MSG_DELIVERY_ENTRY *pst_delivery_entry) {
+ int32 i;
+ u_int8 uc_action_type = VEHICLESENS_ACTION_TYPE_ADD;
+ int32 uc_did_flag;
+ DID ulentry_did = pst_delivery_entry->data.did;
+ VEHICLESENS_DELIVERY_CTRL_TBL_MNG_DATA *pst_existing_mng_data = NULL;
+ VEHICLE_RET_API ret = VEHICLE_RET_NORMAL; /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ BOOL bexist_flag = FALSE;
+
+ /* Check if the data ID exists. */
+ uc_did_flag = VehicleSensCheckDid(ulentry_did);
+ if (uc_did_flag == 0) { // LCOV_EXCL_BR_LINE 6:alway be 1
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+
+ ret = VEHICLE_RET_ERROR_DID; /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */ // LCOV_EXCL_LINE 8: dead code // NOLINT(whitespace/line_length)
+ }
+
+ /* Check the number of registered shipments. */
+ if ((ret == VEHICLE_RET_NORMAL) && /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ (g_stdelivery_ctrl_tbl.us_dnum >= VEHICLESENS_DELIVERY_INFO_MAX)) {
+ /* Return the FULL of delivery registrations*/
+ ret = VEHICLE_RET_ERROR_BUFFULL; /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ }
+
+ if (ret == VEHICLE_RET_NORMAL) { /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ /* Duplicate delivery registration check*/
+ for (i = 0; i < g_stdelivery_ctrl_tbl.us_dnum; i++) {
+ if ((g_stdelivery_ctrl_tbl.st_ctrl_data[i].ul_did == ulentry_did) &&
+ (g_stdelivery_ctrl_tbl.st_ctrl_data[i].us_pno == pst_delivery_entry->data.pno) &&
+ (g_stdelivery_ctrl_tbl.st_ctrl_data[i].uc_method == VEHICLESENS_DELIVERY_METHOD_NORMAL)) {
+ /* When the same shipping address (PNO) and shipping DID are already registered,Update registration information and exit */
+ g_stdelivery_ctrl_tbl.st_ctrl_data[i].uc_chg_type = pst_delivery_entry->data.delivery_timing;
+ bexist_flag = TRUE;
+ break;
+ }
+ }
+
+ if (bexist_flag == TRUE) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ "Duplicate DID=0x%x PNO=0x%x ChgType=%d",
+ ulentry_did,
+ pst_delivery_entry->data.pno,
+ pst_delivery_entry->data.delivery_timing);
+ } else {
+ /* By searching for the delivery registration of the relevant DID,Hold the address. */
+ for (i = 0; i < g_stdelivery_ctrl_tbl_mng.us_dnum; i++) {
+ if (g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data[i].ul_did == ulentry_did) {
+ uc_action_type = VEHICLESENS_ACTION_TYPE_UPDATE;
+ pst_existing_mng_data = &g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data[i];
+ }
+ }
+ /* Add to the shipping management table.*/
+ VehicleSensAddDeliveryCtrlTbl(pst_delivery_entry);
+
+ /* Processing when updating existing data*/
+ if (uc_action_type == VEHICLESENS_ACTION_TYPE_UPDATE) {
+ /* Update the shipping management table.*/
+ VehicleSensUpdateDeliveryCtrlTbl(pst_existing_mng_data);
+
+ /* Update the shipping destination management table management information.*/
+ VehicleSensUpdateDeliveryCtrlTblMng(pst_existing_mng_data);
+ } else { /* Newly added processing*/
+ /* Add to the shipping management table management information.*/
+ VehicleSensAddDeliveryCtrlTblMng(pst_delivery_entry);
+ }
+ }
+ }
+ return ret; /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+}
+
+/*******************************************************************************
+* MODULE : VehicleSensAddDeliveryCtrlTbl
+* ABSTRACT : Vehicle sensor delivery destination management table addition function
+* FUNCTION : Add to the shipping management table.
+* ARGUMENT : *pst_delivery_entry : Pointer to the delivery registration information
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensAddDeliveryCtrlTbl(const VEHICLE_MSG_DELIVERY_ENTRY *pst_delivery_entry) {
+ VEHICLESENS_DELIVERY_CTRL_TBL_DATA *pst_ctrl_data;
+
+ pst_ctrl_data = &g_stdelivery_ctrl_tbl.st_ctrl_data[g_stdelivery_ctrl_tbl.us_dnum];
+ pst_ctrl_data->ul_did = pst_delivery_entry->data.did;
+ pst_ctrl_data->us_pno = pst_delivery_entry->data.pno;
+ pst_ctrl_data->uc_chg_type = pst_delivery_entry->data.delivery_timing;
+ pst_ctrl_data->uc_ctrl_flg = pst_delivery_entry->data.ctrl_flg;
+ pst_ctrl_data->us_link_idx = VEHICLESENS_LINK_INDEX_END;
+ pst_ctrl_data->us_pkg_start_idx = VEHICLESENS_LINK_INDEX_END;
+ pst_ctrl_data->us_pkg_end_idx = VEHICLESENS_LINK_INDEX_END;
+ pst_ctrl_data->uc_method = VEHICLESENS_DELIVERY_METHOD_NORMAL;
+ g_stdelivery_ctrl_tbl.us_dnum = static_cast<u_int16>(g_stdelivery_ctrl_tbl.us_dnum + 1);
+}
+
+/*******************************************************************************
+* MODULE : VehicleSensUpdateDeliveryCtrlTbl
+* ABSTRACT : Vehicle sensor delivery destination management table update function
+* FUNCTION : Update the shipping management table.
+* ARGUMENT : *pstExistingMngData : Pointer to the previous data information with the same data ID
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensUpdateDeliveryCtrlTbl(VEHICLESENS_DELIVERY_CTRL_TBL_MNG_DATA *pst_existing_mng_data) {
+ /* Ignore->MISRA-C++:2008 Rule 7-1-2 */
+ /* Update Link Index Only.
+ For indexes of usEndIdx values matching the data IDs in the target management table
+ Making usLinkIdx an Index-Registered Index */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ g_stdelivery_ctrl_tbl.st_ctrl_data[pst_existing_mng_data->us_end_idx].us_link_idx =
+ static_cast<u_int16>(g_stdelivery_ctrl_tbl.us_dnum - 1); /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+}
+
+/*******************************************************************************
+* MODULE : VehicleSensUpdatePkgDeliveryCtrlTbl
+* ABSTRACT : Vehicle Sensor Delivery Destination Management Table Package Delivery Data Update Function
+* FUNCTION : Updating Package Delivery Data in the Destination Management Table.
+* ARGUMENT : us_dnum : Number of data items in the package delivery management table
+* : us_pkg_num : Number of packages to create
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensUpdatePkgDeliveryCtrlTbl(u_int16 us_dnum, u_int16 us_pkg_num) {
+ VEHICLESENS_DELIVERY_CTRL_TBL_DATA *pst_ctrl_data;
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ pst_ctrl_data = &g_stdelivery_ctrl_tbl.st_ctrl_data[g_stdelivery_ctrl_tbl.us_dnum - 1];
+ pst_ctrl_data->us_pkg_start_idx = us_dnum;
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ pst_ctrl_data->us_pkg_end_idx = static_cast<u_int16>(us_dnum + us_pkg_num - 1);
+ pst_ctrl_data->uc_method = VEHICLESENS_DELIVERY_METHOD_PACKAGE;
+}
+
+/*******************************************************************************
+* MODULE : VehicleSensAddDeliveryCtrlTblMng
+* ABSTRACT : Vehicle sensor delivery destination management table management addition function
+* FUNCTION : Add to the shipping management table management.
+* ARGUMENT : *pst_delivery_entry : Pointer to the delivery registration information
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensAddDeliveryCtrlTblMng(const VEHICLE_MSG_DELIVERY_ENTRY *pst_delivery_entry) {
+ VEHICLESENS_DELIVERY_CTRL_TBL_MNG_DATA *pst_ctrl_mng_data;
+
+ pst_ctrl_mng_data = &g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data[g_stdelivery_ctrl_tbl_mng.us_dnum];
+ pst_ctrl_mng_data->ul_did = pst_delivery_entry->data.did;
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ pst_ctrl_mng_data->us_start_idx = static_cast<u_int16>(g_stdelivery_ctrl_tbl.us_dnum - 1);
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ pst_ctrl_mng_data->us_end_idx = static_cast<u_int16>(g_stdelivery_ctrl_tbl.us_dnum - 1);
+ pst_ctrl_mng_data->usdlvry_entry_num++;
+ g_stdelivery_ctrl_tbl_mng.us_dnum++;
+}
+
+/*******************************************************************************
+* MODULE : VehicleSensUpdateDeliveryCtrlTblMng
+* ABSTRACT : Vehicle sensor delivery destination management table management update function
+* FUNCTION : Update the shipping management table management.
+* ARGUMENT : *pst_existing_mng_data : Pointer to the previous data information with the same data ID
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensUpdateDeliveryCtrlTblMng(VEHICLESENS_DELIVERY_CTRL_TBL_MNG_DATA *pst_existing_mng_data) {
+ /* Update only the end index and the number of registered shipping destinations. */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ pst_existing_mng_data->us_end_idx = static_cast<u_int16>(g_stdelivery_ctrl_tbl.us_dnum - 1);
+ pst_existing_mng_data->usdlvry_entry_num++;
+}
+
+/*******************************************************************************
+* MODULE : VehicleSensAddPkgDeliveryTblMng
+* ABSTRACT : Vehicle Sensor Package Delivery Management Table Additional Function
+* FUNCTION : Add to the shipping management table management.
+* ARGUMENT : *pst_pkg : Pointer to package delivery registration information
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensAddPkgDeliveryTblMng(const SENSOR_MSG_DELIVERY_ENTRY *pst_pkg) {
+ int32 i; /* Generic counters */
+
+ /* Data ID registration */
+ /* Registration of delivery data index */
+ for (i = 0; i < (pst_pkg->data.pkg_num); i++) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ g_stpkgdelivery_tbl_mng.st_pkg_data[g_stpkgdelivery_tbl_mng.us_dnum].ul_did = pst_pkg->data.did[i];
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ g_stpkgdelivery_tbl_mng.st_pkg_data[g_stpkgdelivery_tbl_mng.us_dnum].usdlvry_idx = \
+ static_cast<u_int16>(g_stpkgdelivery_tbl_mng.us_dnum + 1);
+ g_stpkgdelivery_tbl_mng.us_dnum++;
+ }
+ /* The final delivery data index overwrites the terminating code */
+ g_stpkgdelivery_tbl_mng.st_pkg_data[g_stpkgdelivery_tbl_mng.us_dnum - 1].usdlvry_idx = VEHICLESENS_LINK_INDEX_END;
+}
+
+/*******************************************************************************
+* MODULE : VehicleSensEntryPkgDeliveryCtrl
+* ABSTRACT : Vehicle sensor package delivery management registration function
+* FUNCTION : Shipping management table,Destination management table management,Update the package delivery management table.
+* ARGUMENT : *pst_pkg : Pointer to package delivery registration information
+* NOTE :
+* RETURN : VEHICLE_RET_NORMAL : Successful registration
+******************************************************************************/
+VEHICLE_RET_API VehicleSensEntryPkgDeliveryCtrl(const SENSOR_MSG_DELIVERY_ENTRY *pst_pkg ,
+ u_int8 uc_ext_chk) { /* Ignore->MISRA-C++:2008 Rule 6-6-5 */
+ int32 i;
+ u_int16 us_size = 0;
+ u_int8 uc_action_type = VEHICLESENS_ACTION_TYPE_ADD;
+ VEHICLESENS_DELIVERY_CTRL_TBL_MNG_DATA *pst_existing_mng_data = NULL;
+ VEHICLE_MSG_DELIVERY_ENTRY st_delivery_entry;
+ u_int16 us_boundary_adj; /* For boundary adjustment */
+ u_int16 us_next_offset; /* For size calculation */
+ VEHICLE_RET_API ret = VEHICLE_RET_NORMAL; /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ BOOL bexist_flag = FALSE;
+
+ /* Check if the data ID exists. */
+ for (i = 0; i < (pst_pkg->data.pkg_num); i++) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ if (VEHICLESENS_INVALID == VehicleSensCheckDid(pst_pkg->data.did[i])) { // LCOV_EXCL_BR_LINE 200: always Valid
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ ret = VEHICLE_RET_ERROR_DID; // // LCOV_EXCL_LINE 8 :dead code
+ /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ }
+ }
+
+ /* Check the number of registered shipments. */
+ if ((ret == VEHICLE_RET_NORMAL) && /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ (VEHICLESENS_DELIVERY_INFO_MAX <= g_stdelivery_ctrl_tbl.us_dnum)) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* Return the FULL of delivery registrations*/
+ ret = VEHICLE_RET_ERROR_BUFFULL; /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ }
+
+ /* Check the number of registered package shipments. */
+ if ((ret == VEHICLE_RET_NORMAL) && /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ (VEHICLESENS_PKG_DELIVERY_INFO_MAX < (g_stpkgdelivery_tbl_mng.us_dnum + pst_pkg->data.pkg_num))) {
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* Return the FULL of delivery registrations*/
+ ret = VEHICLE_RET_ERROR_BUFFULL; /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ }
+
+ if (ret == VEHICLE_RET_NORMAL) { /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ /* Check that the size of the buffer to be delivered does not exceed the maximum size. */
+ /* For boundary adjustment */
+ us_boundary_adj = (u_int16)VEHICLESENS_BIT1 | (u_int16)VEHICLESENS_BIT0;
+ for (i = 0; i < pst_pkg->data.pkg_num; i++) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+
+ /* Ignore->MISRA-C++:2008 Rule 2-7-2 */
+#if CONFIG_SENSOR_EXT_VALID /* Initial Sensor Support */
+ if (uc_ext_chk == VEHICLESENS_EXT_OFF) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */ // LCOV_EXCL_BR_LINE 200: VEHICLESENS_EXT_OFF passed in function is dead code // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ us_next_offset = VehicleSensGetDataMasterOffset(pst_pkg->data.did[i]); // LCOV_EXCL_LINE 8: dead code
+ } else {
+ us_next_offset = VehicleSensGetDataMasterExtOffset(pst_pkg->data.did[i]);
+ }
+#else
+ us_next_offset = VehicleSensGetDataMasterOffset(pst_pkg->data.did[i]);
+#endif
+ /* Ignore->MISRA-C++:2008 Rule 2-7-2 */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 Ignore->MISRA-C++:2008 Rule 5-0-13, 5-0-14, 5-3-1 */
+ if ((us_next_offset & us_boundary_adj) != 0) {
+ /* If you need to adjust */
+ /* Mask Lower Bit Ignore->MISRA-C++:2008 Rule 5-0-5 Ignore->MISRA-C++:2008 Rule 5-0-21 */
+ us_next_offset = static_cast<u_int16>(us_next_offset & ~us_boundary_adj);
+ us_next_offset = static_cast<u_int16>(us_next_offset + (u_int16)VEHICLESENS_BIT2); /* Add numbers */
+ }
+ us_size = static_cast<u_int16>(us_size + us_next_offset); /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ }
+ if (SENSOR_VSINFO_DSIZE < us_size) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* Return the FULL of delivery registrations(Exceed the size of the buffer to be delivered due to the combination of packages)*/
+ ret = VEHICLE_RET_ERROR_BUFFULL; /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ }
+ }
+
+ if (ret == VEHICLE_RET_NORMAL) { /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ for (i = 0; i < g_stdelivery_ctrl_tbl.us_dnum; i++) {
+ if ((g_stdelivery_ctrl_tbl.st_ctrl_data[i].us_pno == pst_pkg->data.pno) &&
+ (g_stdelivery_ctrl_tbl.st_ctrl_data[i].uc_method == VEHICLESENS_DELIVERY_METHOD_PACKAGE)) {
+ /* When the same shipping address (PNO) is already registered,Update registration information and exit */
+ g_stdelivery_ctrl_tbl.st_ctrl_data[i].uc_chg_type = pst_pkg->data.delivery_timing;
+ bexist_flag = TRUE;
+ break;
+ }
+ }
+
+ if (bexist_flag == TRUE) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "Duplicate PNO=0x%x ChgType=%d",
+ pst_pkg->data.pno, pst_pkg->data.delivery_timing);
+ } else {
+ /* By searching for the delivery registration of the relevant DID,Hold the address. */
+ for (i = 0; i < g_stdelivery_ctrl_tbl_mng.us_dnum; i++) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ if (g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data[i].ul_did == pst_pkg->data.did[0]) {
+ uc_action_type = VEHICLESENS_ACTION_TYPE_UPDATE;
+ pst_existing_mng_data = &g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data[i];
+ }
+ }
+ /* Type conversion,And copies of the data section(Because the header is unused,Not involved) */
+ memset(reinterpret_cast<void *>(&st_delivery_entry),
+ static_cast<int32>(0),
+ (size_t)sizeof(VEHICLE_MSG_DELIVERY_ENTRY));
+ st_delivery_entry.data.did = pst_pkg->data.did[0];
+ st_delivery_entry.data.pno = pst_pkg->data.pno;
+ st_delivery_entry.data.delivery_timing = pst_pkg->data.delivery_timing;
+ st_delivery_entry.data.ctrl_flg = pst_pkg->data.ctrl_flg;
+ st_delivery_entry.data.event_id = pst_pkg->data.event_id;
+ /* Add to the shipping management table.*/
+ VehicleSensAddDeliveryCtrlTbl(&st_delivery_entry);
+
+ /* Processing when updating existing data*/
+ /* Ignore->MISRA-C++:2008 Rule 5-0-13, 5-0-14, 5-3-1 */
+ if (uc_action_type == VEHICLESENS_ACTION_TYPE_UPDATE) {
+ /* Update the shipping management table.*/
+ VehicleSensUpdateDeliveryCtrlTbl(pst_existing_mng_data);
+
+ /* Update the shipping destination management table management information.*/
+ VehicleSensUpdateDeliveryCtrlTblMng(pst_existing_mng_data);
+ } else { /* Newly added processing*/
+ /* Add to the shipping management table management information.*/
+ VehicleSensAddDeliveryCtrlTblMng(&st_delivery_entry);
+ }
+
+ /* Updating Package Relationship Data in the Destination Management Table.*/
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ VehicleSensUpdatePkgDeliveryCtrlTbl(g_stpkgdelivery_tbl_mng.us_dnum, pst_pkg->data.pkg_num);
+ /* Add to the package delivery management table.*/
+ VehicleSensAddPkgDeliveryTblMng(pst_pkg);
+ }
+ }
+
+ return ret; /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+}
+
+/*******************************************************************************
+* MODULE : VehicleSensMakeDeliveryPnoTbl
+* ABSTRACT : Vehicle sensor delivery destination PNO table creation function
+* FUNCTION : Create the shipping destination PNO table
+* ARGUMENT : ul_did Data ID
+* Change_type Delivery Trigger
+* NOTE :
+* RETURN : VEHICLESENS_DELIVERY_PNO_TBL* Pointer to the shipping PNO table
+******************************************************************************/
+VEHICLESENS_DELIVERY_PNO_TBL* VehicleSensMakeDeliveryPnoTbl(DID ul_did, u_int8 change_type) {
+ int32 i;
+ u_int8 uc_ctrl_tbl_mng_data_list;
+ u_int16 us_index = 0;
+ u_int16 us_dnum = 0;
+
+ /* Get the start index and count of the corresponding data ID. */
+ uc_ctrl_tbl_mng_data_list = static_cast<u_int8>(
+ (sizeof(g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data)) /
+ (sizeof(g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data[0])));
+ for (i = 0; i < uc_ctrl_tbl_mng_data_list; i++) {
+ /* Stores the information of the corresponding DID.. */
+ if (g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data[i].ul_did == ul_did) {
+ us_index = g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data[i].us_start_idx;
+ us_dnum = g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data[i].usdlvry_entry_num;
+ break;
+ }
+ }
+
+ /* Create a PNO list */
+ g_stdelivery_pno_tbl.us_dnum = 0;
+ if (change_type == VEHICLESENS_CHGTYPE_CHG) {
+ /* Processing when delivery timing is changed*/
+ for (i = 0; i < us_dnum; i++) {
+ /* Functionalization by Increasing Structure Members */
+ VehicleSensAddPnoTbl(us_index);
+ us_index = g_stdelivery_ctrl_tbl.st_ctrl_data[us_index].us_link_idx;
+ }
+ } else {
+ /* Processing when delivery timing is update */
+ for (i = 0; i < us_dnum; i++) {
+ if (VEHICLE_DELIVERY_TIMING_UPDATE == g_stdelivery_ctrl_tbl.st_ctrl_data[us_index].uc_chg_type) {
+ /* Functionalization by Increasing Structure Members */
+ VehicleSensAddPnoTbl(us_index);
+ }
+ us_index = g_stdelivery_ctrl_tbl.st_ctrl_data[us_index].us_link_idx;
+ }
+ }
+ return(&g_stdelivery_pno_tbl);
+}
+
+/*******************************************************************************
+* MODULE : VehicleSensAddPnoTbl
+* ABSTRACT : Vehicle Sensor Destination PNO Table Addition Function
+* FUNCTION : Add to the shipping PNO table.
+* ARGUMENT : us_index : Index of the referenced destination management table
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensAddPnoTbl(u_int16 us_index) {
+ u_int16 us_pno_tbl_idx;
+
+ us_pno_tbl_idx = g_stdelivery_pno_tbl.us_dnum;
+ g_stdelivery_pno_tbl.st_pno_data[us_pno_tbl_idx].us_pno = \
+ g_stdelivery_ctrl_tbl.st_ctrl_data[us_index].us_pno;
+ g_stdelivery_pno_tbl.st_pno_data[us_pno_tbl_idx].us_pkg_start_idx = \
+ g_stdelivery_ctrl_tbl.st_ctrl_data[us_index].us_pkg_start_idx;
+ g_stdelivery_pno_tbl.st_pno_data[us_pno_tbl_idx].us_pkg_end_idx = \
+ g_stdelivery_ctrl_tbl.st_ctrl_data[us_index].us_pkg_end_idx;
+ g_stdelivery_pno_tbl.st_pno_data[us_pno_tbl_idx].uc_method = \
+ g_stdelivery_ctrl_tbl.st_ctrl_data[us_index].uc_method;
+ g_stdelivery_pno_tbl.us_dnum++;
+}
+
+/*******************************************************************************
+* MODULE : VehicleSensDeliveryGPS
+* ABSTRACT : Vehicle Sensor Data Delivery Process
+* FUNCTION : Deliver data to a destination.
+* ARGUMENT : ul_did :Data ID
+* uc_chg_type :Delivery timing
+* uc_get_method :Acquisition method
+* NOTE :
+* RETURN : void
+******************************************************************************/
+u_int8 VehicleSensDeliveryGPS(DID ul_did, u_int8 uc_get_method, u_int8 uc_current_get_method, int32 pno_index,
+ u_int32* cid,
+ VEHICLESENS_DATA_MASTER* stmaster,
+ const VEHICLESENS_DELIVERY_PNO_TBL *pst_pno_tbl) {
+#if CONFIG_SENSOR_EXT_VALID /* Initial Sensor Support */
+ SENSORLOCATION_MSG_LONLATINFO *plonlat_msg;
+ SENSORLOCATION_MSG_ALTITUDEINFO *paltitude_msg;
+ SENSORMOTION_MSG_HEADINGINFO *pheading_msg;
+#endif
+
+ SENSOR_MSG_GPSDATA_DAT gps_master;
+ VEHICLESENS_DELIVERY_FORMAT delivery_data;
+ u_int16 length;
+ u_int16 senslog_len;
+ RET_API ret = RET_NORMAL; /* API return value */
+ u_int8 uc_result = SENSLOG_RES_SUCCESS; /* Send/Receive result */
+
+ VehicleSensGetGpsDataMaster(ul_did, uc_current_get_method, &gps_master);
+
+ if (ul_did == POSHAL_DID_GPS_TIME) {
+ /* GPS time,Because there is no header in the message to be delivered,
+ Padding deliveryData headers */
+ (void)memcpy(reinterpret_cast<void*>(&delivery_data),
+ reinterpret_cast<void*>(&gps_master.uc_data[0]), gps_master.us_size);
+ length = gps_master.us_size;
+ senslog_len = length;
+ *cid = CID_VEHICLESENS_VEHICLE_INFO_GPS_TIME;
+ } else if (ul_did == VEHICLE_DID_LOCATION_LONLAT) {
+ plonlat_msg = reinterpret_cast<SENSORLOCATION_MSG_LONLATINFO*>(&delivery_data);
+ /* Acquire the applicable data information from the data master..*/
+ VehicleSensGetDataMaster(ul_did, uc_current_get_method, stmaster);
+ (void)memcpy(reinterpret_cast<void*>(&(plonlat_msg->data)),
+ reinterpret_cast<void*>(&(stmaster->uc_data[0])), stmaster->us_size);
+ length = (u_int16)(stmaster->us_size);
+ senslog_len = length;
+ *cid = CID_POSIF_REGISTER_LISTENER_LONLAT;
+ } else if (ul_did == VEHICLE_DID_LOCATION_ALTITUDE) {
+ paltitude_msg = reinterpret_cast<SENSORLOCATION_MSG_ALTITUDEINFO*>(&delivery_data);
+ /* Acquire the applicable data information from the data master..*/
+ VehicleSensGetDataMaster(ul_did, uc_get_method, stmaster);
+ (void)memcpy(reinterpret_cast<void*>(&(paltitude_msg->data)),
+ reinterpret_cast<void*>(&stmaster->uc_data[0]), stmaster->us_size);
+ length = (u_int16)(stmaster->us_size);
+ senslog_len = length;
+ *cid = CID_POSIF_REGISTER_LISTENER_ALTITUDE;
+ } else if (ul_did == VEHICLE_DID_MOTION_HEADING) {
+ pheading_msg = reinterpret_cast<SENSORMOTION_MSG_HEADINGINFO*>(&delivery_data);
+ /* Acquire the applicable data information from the data master..*/
+ VehicleSensGetDataMaster(ul_did, uc_get_method, stmaster);
+ (void)memcpy(reinterpret_cast<void*>(&(pheading_msg->data)),
+ reinterpret_cast<void*>(&stmaster->uc_data[0]), stmaster->us_size);
+ length = (u_int16)(stmaster->us_size);
+ senslog_len = length;
+ *cid = CID_POSIF_REGISTER_LISTENER_HEADING;
+ } else {
+ delivery_data.header.did = gps_master.ul_did;
+ delivery_data.header.size = gps_master.us_size;
+ delivery_data.header.rcv_flag = gps_master.uc_rcv_flag;
+ delivery_data.header.sensor_cnt = gps_master.uc_sns_cnt;
+ (void)memcpy(reinterpret_cast<void *>(&delivery_data.data[0]),
+ reinterpret_cast<void *>(&gps_master.uc_data[0]),
+ (size_t)delivery_data.header.size);
+
+ length = static_cast<u_int16>((u_int16)sizeof(delivery_data.header) + \
+ delivery_data.header.size);
+ senslog_len = delivery_data.header.size;
+ *cid = CID_VEHICLESENS_VEHICLE_INFO;
+ }
+
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ static_cast<CID>(*cid),
+ length,
+ (const void *)&delivery_data);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ if (*cid != CID_VEHICLESENS_VEHICLE_INFO) {
+ SensLogWriteOutputData(SENSLOG_DATA_O_UNSPECIFIED, ul_did,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ reinterpret_cast<uint8_t *>(&delivery_data),
+ senslog_len, uc_result);
+ } else {
+ SensLogWriteOutputData(SENSLOG_DATA_O_UNSPECIFIED, ul_did,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ reinterpret_cast<uint8_t *>(&(delivery_data.data[0])),
+ senslog_len, uc_result);
+ }
+ return uc_result;
+}
+
+u_int8 VehicleSensDeliveryFst(DID ul_did, u_int8 uc_get_method, int32 pno_index,
+ const VEHICLESENS_DELIVERY_PNO_TBL *pst_pno_tbl) {
+ VEHICLESENS_DATA_MASTER_FST st_master_fst; /* Master of initial sensor data */
+ VEHICLESENS_DATA_MASTER_FST st_master_fst_temp; /* For temporary storage */
+
+ RET_API ret = RET_NORMAL; /* API return value */
+ u_int8 uc_result = SENSLOG_RES_SUCCESS; /* Send/Receive result */
+ (void)memset(reinterpret_cast<void *>(&st_master_fst),
+ 0,
+ sizeof(VEHICLESENS_DATA_MASTER_FST));
+ (void)memset(reinterpret_cast<void *>(&st_master_fst_temp),
+ 0,
+ sizeof(VEHICLESENS_DATA_MASTER_FST));
+ VehicleSensGetDataMasterFst(ul_did, uc_get_method, &st_master_fst);
+ if (st_master_fst.partition_flg == 1) {
+ /* When the partitioning flag is enabled,Or exceeds the size that can be sent,Perform split transmission */
+ memcpy(&st_master_fst_temp, &st_master_fst, sizeof(VEHICLESENS_DATA_MASTER_FST));
+ if ((ul_did == POSHAL_DID_GYRO_X_FST) || /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ (ul_did == POSHAL_DID_GYRO_Y_FST) ||
+ (ul_did == POSHAL_DID_GYRO_Z_FST) ||
+ (ul_did == POSHAL_DID_GSNS_X_FST) ||
+ (ul_did == POSHAL_DID_GSNS_Y_FST) ||
+ (ul_did == POSHAL_DID_GSNS_Z_FST)) {
+ /* 1st session */
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ /* Size of data that can be transmitted in one division(Same size definition used)*/
+ st_master_fst_temp.us_size = LSDRV_FSTSNS_DSIZE_GYRO_X;
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(st_master_fst_temp.us_size + 8),
+ (const void *)&st_master_fst_temp);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS,
+ ul_did,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ reinterpret_cast<uint8_t *>(&(st_master_fst_temp.uc_data[0])),
+ st_master_fst_temp.us_size,
+ uc_result);
+
+ /* Second time */
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ (void)memset(reinterpret_cast<void *>(&st_master_fst_temp.uc_data[0]),
+ 0,
+ sizeof(u_int8) * VEHICLE_DSIZE_DATA_MASTER_FST);
+ /* Size of the data - Transmission size(Same size definition used)Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ st_master_fst_temp.us_size = static_cast<u_int16>(st_master_fst.us_size - \
+ LSDRV_FSTSNS_DSIZE_GYRO_X);
+ memcpy(&st_master_fst_temp.uc_data[0],
+ &st_master_fst.uc_data[LSDRV_FSTSNS_DSIZE_GYRO_X],
+ st_master_fst_temp.us_size);
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 #Coverity_19347 */
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(st_master_fst_temp.us_size + 8),
+ (const void *)&st_master_fst_temp);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS,
+ ul_did,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ reinterpret_cast<uint8_t *>(&(st_master_fst_temp.uc_data[0])),
+ st_master_fst_temp.us_size,
+ uc_result);
+ } else if (ul_did == POSHAL_DID_REV_FST) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* 1st session */
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ /* Size of data that can be transmitted in one division */
+ st_master_fst_temp.us_size = LSDRV_FSTSNS_DSIZE_REV;
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(st_master_fst_temp.us_size + 8),
+ (const void *)&st_master_fst_temp);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS,
+ ul_did,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ reinterpret_cast<uint8_t *>(&(st_master_fst_temp.uc_data[0])),
+ st_master_fst_temp.us_size,
+ uc_result);
+
+ /* Second time */
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ (void)memset(reinterpret_cast<void *>(&st_master_fst_temp.uc_data[0]),
+ 0,
+ sizeof(u_int8) * VEHICLE_DSIZE_DATA_MASTER_FST);
+ /* Size of the data - Transmission size Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ st_master_fst_temp.us_size = static_cast<u_int16>(st_master_fst.us_size - \
+ LSDRV_FSTSNS_DSIZE_REV);
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 #Coverity_19347 */
+ memcpy(&st_master_fst_temp.uc_data[0],
+ &st_master_fst.uc_data[LSDRV_FSTSNS_DSIZE_REV],
+ st_master_fst_temp.us_size);
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(st_master_fst_temp.us_size + 8),
+ (const void *)&st_master_fst_temp);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS,
+ ul_did,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ reinterpret_cast<uint8_t *>(&(st_master_fst_temp.uc_data[0])),
+ st_master_fst_temp.us_size,
+ uc_result);
+ } else {
+ /* 1st session */
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ /* Size of data that can be transmitted in one division(Same size definition used)*/
+ st_master_fst_temp.us_size = LSDRV_FSTSNS_DSIZE_GYRO_TEMP;
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(st_master_fst_temp.us_size + 8),
+ (const void *)&st_master_fst_temp);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS,
+ ul_did,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ reinterpret_cast<uint8_t *>(&(st_master_fst_temp.uc_data[0])),
+ st_master_fst_temp.us_size,
+ uc_result);
+ /* Second time */
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ (void)memset(reinterpret_cast<void *>(&st_master_fst_temp.uc_data[0]),
+ 0,
+ sizeof(u_int8) * VEHICLE_DSIZE_DATA_MASTER_FST);
+ /* Size of the data - Transmission size(Same size definition used)Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ st_master_fst_temp.us_size = static_cast<u_int16>(st_master_fst.us_size - \
+ LSDRV_FSTSNS_DSIZE_GYRO_TEMP);
+ memcpy(&st_master_fst_temp.uc_data[0],
+ &st_master_fst.uc_data[LSDRV_FSTSNS_DSIZE_GYRO_TEMP],
+ st_master_fst_temp.us_size); /* Ignore->MISRA-C++:2008 Rule 5-0-5 #Coverity_19347*/
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(st_master_fst_temp.us_size + 8),
+ (const void *)&st_master_fst_temp);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS,
+ ul_did,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ reinterpret_cast<uint8_t *>(&(st_master_fst_temp.uc_data[0])),
+ st_master_fst_temp.us_size,
+ uc_result);
+ }
+ } else {
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(st_master_fst.us_size + 8),
+ (const void *)&st_master_fst);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS,
+ ul_did,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ reinterpret_cast<uint8_t *>(&(st_master_fst.uc_data[0])),
+ st_master_fst.us_size,
+ uc_result);
+ }
+
+ return uc_result;
+}
+
+u_int8 VehicleSensDeliveryGyro(DID ul_did, u_int8 uc_current_get_method, int32 pno_index, const VEHICLESENS_DELIVERY_PNO_TBL *pst_pno_tbl) { // LCOV_EXCL_START 8: dead code // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ RET_API ret = RET_NORMAL; /* API return value */
+ u_int8 uc_result = SENSLOG_RES_SUCCESS; /* Send/Receive result */
+
+ VEHICLESENS_DATA_MASTER_GYRO_TROUBLE st_master_gyro_trouble;
+ SENSORMOTION_MSG_GYROTROUBLEINFO_DAT st_msg_gyro_trouble_info;
+
+ /* Initialization */
+ st_msg_gyro_trouble_info.reserve = 0;
+
+ VehicleSensGetDataMasterGyroTrouble(ul_did, uc_current_get_method, &st_master_gyro_trouble);
+
+ /* Size storage(GYROTROUBLE) */
+ st_msg_gyro_trouble_info.size = st_master_gyro_trouble.us_size;
+
+ /* Set the GyroTrouble */
+ (void)memcpy(reinterpret_cast<void *>(&(st_msg_gyro_trouble_info.gyro_trouble)),
+ reinterpret_cast<void *>(&(st_master_gyro_trouble.uc_data)),
+ sizeof(st_msg_gyro_trouble_info.gyro_trouble));
+
+#if VEHICLE_SENS_DELIVERY_CTRL_DEBUG_DIAG
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ "#[DIAG] ul_did = VEHICLE_DID_GYRO_TROUBLE");
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ "#[DIAG] st_msg_gyro_trouble_info.size = %d", st_msg_gyro_trouble_info.size);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ "#[DIAG] st_msg_gyro_trouble_info.gyro_trouble = 0x%08X \r\n",
+ st_msg_gyro_trouble_info.gyro_trouble);
+#endif /* VEHICLE_SENS_DELIVERY_CTRL_DEBUG_DIAG */
+ /* Since the undefined state is not a device specification,Do not deliver to the app side */
+ if (st_msg_gyro_trouble_info.gyro_trouble != GYRO_UNFIXED) {
+
+ /* Send GyroTrouble to API-caller */
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ CID_VEHICLE_SENSORMOTION_GYROTROUBLE,
+ sizeof(SENSORMOTION_MSG_GYROTROUBLEINFO_DAT),
+ (const void *)&st_msg_gyro_trouble_info);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS,
+ ul_did,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ reinterpret_cast<uint8_t *>(&st_msg_gyro_trouble_info),
+ sizeof(SENSORMOTION_MSG_GYROTROUBLEINFO_DAT),
+ uc_result);
+#if VEHICLE_SENS_DELIVERY_CTRL_DEBUG_DIAG
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "#[DIAG] GyroTrouble Delivery");
+#endif /* VEHICLE_SENS_DELIVERY_CTRL_DEBUG_DIAG */
+ }
+ return uc_result;
+}
+// LCOV_EXCL_STOP
+
+void VehicleSensDeliveryAntenna(DID ul_did, u_int8 uc_current_get_method, int32 pno_index, const VEHICLESENS_DELIVERY_PNO_TBL *pst_pno_tbl) { // LCOV_EXCL_START 8 : dead code // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ VEHICLESENS_DATA_MASTER_GPS_ANTENNA_STATUS gps_antenna_status;
+ VEHICLESENS_DELIVERY_FORMAT delivery_data;
+ u_int16 length;
+
+ VehicleSensGetDataMasterGpsAntennaStatus(ul_did, uc_current_get_method, &gps_antenna_status);
+
+ delivery_data.header.did = gps_antenna_status.ul_did;
+ delivery_data.header.size = gps_antenna_status.us_size;
+ delivery_data.header.rcv_flag = gps_antenna_status.uc_rcvflag;
+ delivery_data.header.sensor_cnt = gps_antenna_status.uc_sensor_cnt;
+ (void)memcpy(reinterpret_cast<void *>(&delivery_data.data[0]),
+ reinterpret_cast<void *>(&gps_antenna_status.uc_data),
+ (size_t)delivery_data.header.size);
+
+ length = static_cast<u_int16>(static_cast<u_int32>(sizeof(delivery_data.header)) + delivery_data.header.size);
+
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ (void)VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ length,
+ (const void *)&delivery_data);
+}
+// LCOV_EXCL_STOP
+
+u_int8 VehicleSensDeliveryOther(DID ul_did, u_int8 uc_current_get_method, int32 pno_index,
+ u_int32* cid, // NOLINT(readability/nolint)
+ VEHICLESENS_DATA_MASTER* stmaster, // NOLINT(readability/nolint)
+ const VEHICLESENS_DELIVERY_PNO_TBL *pst_pno_tbl) {
+ RET_API ret = RET_NORMAL; /* API return value */
+ u_int8 uc_result = SENSLOG_RES_SUCCESS; /* Send/Receive result */
+/* Determine CID */
+ if (ul_did == VEHICLE_DID_LOCATION_LONLAT_NAVI) {
+ *cid = CID_POSIF_REGISTER_LISTENER_LONLAT;
+ } else if (ul_did == VEHICLE_DID_LOCATION_ALTITUDE_NAVI) { // LCOV_EXCL_BR_LINE 6:VEHICLE_DID_LOCATION_ALTITUDE_NAVI no API to pass in // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ *cid = CID_POSIF_REGISTER_LISTENER_ALTITUDE; // LCOV_EXCL_LINE 8: dead code
+ } else if ((ul_did == VEHICLE_DID_MOTION_SPEED_NAVI) ||
+ (ul_did == VEHICLE_DID_MOTION_SPEED_INTERNAL)) {
+ *cid = CID_VEHICLE_SENSORMOTION_SPEED;
+ } else if (ul_did == VEHICLE_DID_MOTION_HEADING_NAVI) {
+ *cid = CID_POSIF_REGISTER_LISTENER_HEADING;
+ } else if (ul_did == VEHICLE_DID_SETTINGTIME) {
+ *cid = CID_POSIF_REGISTER_LISTENER_GPS_TIME_SET_REQ;
+ } else { // LCOV_EXCL_BR_LINE 6: cannot be this one
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ *cid = 0xFFFF; /* DID error */ // LCOV_EXCL_LINE 8: dead code
+ }
+
+ /* Send vehicle sensor information notification */
+ if (*cid == 0xFFFF) { // LCOV_EXCL_BR_LINE 6: cannot be this one
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ /* Error log */
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unknown DID [%d]", ul_did);
+ } else {
+ /* Acquire the applicable data information from the data master..*/
+ (void)memset(reinterpret_cast<void *>(stmaster), 0x00, sizeof(VEHICLESENS_DATA_MASTER));
+ VehicleSensGetDataMaster(ul_did, uc_current_get_method, stmaster);
+
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ static_cast<CID>(*cid),
+ (u_int16)(stmaster->us_size),
+ (const void *)&(stmaster->uc_data[0]));
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_UNSPECIFIED,
+ ul_did,
+ pst_pno_tbl->st_pno_data[pno_index].us_pno,
+ reinterpret_cast<uint8_t *>(&(stmaster->uc_data[0])),
+ stmaster->us_size,
+ uc_result);
+ }
+
+ return uc_result;
+}
+
+void VehicleSensDeliveryProc(DID ul_did, u_int8 uc_chg_type, u_int8 uc_get_method) {
+ VEHICLESENS_DATA_MASTER stmaster; /* Data master of normal data */
+ const VEHICLESENS_DELIVERY_PNO_TBL *pst_pno_tbl; /* Vehicle Sensor Destination PNO Table Pointer */
+ SENSOR_PKG_MSG_VSINFO st_pkg_master; /* Data master for package delivery */
+ uint32_t cid;
+ uint8_t uc_result = SENSLOG_RES_SUCCESS; /* Send/Receive result */
+
+ /* Obtain the data acquisition method from the Vehicle Selection Item List */
+ uint8_t uc_current_get_method = VehicleSensGetSelectionItemList(ul_did);
+
+ if (uc_current_get_method == uc_get_method) {
+ /* When the data acquisition methods match (= delivery target) */
+
+ /* Obtain the shipping destination PNO */
+ pst_pno_tbl = (const VEHICLESENS_DELIVERY_PNO_TBL *) VehicleSensMakeDeliveryPnoTbl(ul_did, uc_chg_type);
+
+ if ((pst_pno_tbl->us_dnum) > 0) {
+ /* When there is a shipping destination PNO registration */
+ /* For boundary adjustment */
+ uint16_t us_boundary_adj = (u_int16) VEHICLESENS_BIT1 | (u_int16) VEHICLESENS_BIT0; /* #012 */
+ /* Vehicle sensor information notification transmission process */
+ for (uint32_t i = 0; i < (pst_pno_tbl->us_dnum); i++) {
+ if (VEHICLESENS_DELIVERY_METHOD_PACKAGE == pst_pno_tbl->st_pno_data[i].uc_method) {
+ /* When the delivery method is the package method */
+ (void) memset(reinterpret_cast<void *>(&st_pkg_master), 0, sizeof(SENSOR_PKG_MSG_VSINFO));
+
+ uint16_t us_index = pst_pno_tbl->st_pno_data[i].us_pkg_start_idx;
+ uint8_t uc_data_cnt = 0U;
+ uint16_t us_offset = 0U;
+ for (uint32_t j = 0; j < SENSOR_PKG_DELIVERY_MAX; j++) {
+ DID ul_pkg_did = g_stpkgdelivery_tbl_mng.st_pkg_data[us_index].ul_did; /* Get DID */
+ st_pkg_master.usOffset[uc_data_cnt] = us_offset; /* Offset setting */
+ uc_current_get_method = VehicleSensGetSelectionItemList(ul_pkg_did); /* Data collection way */
+ if (VEHICLESENS_GETMETHOD_GPS == uc_current_get_method) {
+ VehicleSensGetGpsDataMaster(ul_pkg_did, uc_current_get_method,
+ reinterpret_cast<SENSOR_MSG_GPSDATA_DAT *>(&st_pkg_master.ucData[us_offset]));
+ }
+ else {
+ VehicleSensGetDataMaster(ul_pkg_did, uc_current_get_method,
+ reinterpret_cast<VEHICLESENS_DATA_MASTER *>(&st_pkg_master.ucData[us_offset]));
+ }
+ uc_data_cnt++; /* Data count increment */
+ if ((us_index == pst_pno_tbl->st_pno_data[i].us_pkg_end_idx)
+ || (VEHICLESENS_LINK_INDEX_END == g_stpkgdelivery_tbl_mng.st_pkg_data[us_index].usdlvry_idx)) {
+ st_pkg_master.ucDNum = uc_data_cnt; /* To save the number of data */
+ break;
+ }
+ else {
+ /* By creating the following processing contents,Need to obtain an offset value */
+ uint16_t us_next_offset = VehicleSensGetDataMasterOffset(ul_pkg_did); /* Next offset calculation */
+ /* Boundary adjustment of data size */
+ if ((us_next_offset & us_boundary_adj) != 0) {
+ /* If you need to adjust */
+ /* Mask Lower Bit */
+ us_next_offset = static_cast<u_int16>(us_next_offset & ~us_boundary_adj);
+ /* Add numbers */
+ us_next_offset = static_cast<u_int16>(us_next_offset + (u_int16) VEHICLESENS_BIT2);
+ }
+ us_offset = static_cast<u_int16>(us_offset + us_next_offset);
+ /* Get next index */
+ us_index = g_stpkgdelivery_tbl_mng.st_pkg_data[us_index].usdlvry_idx;
+ }
+ }
+ RET_API ret = PosSndMsg(PNO_VEHICLE_SENSOR, pst_pno_tbl->st_pno_data[i].us_pno,
+ CID_SENSOR_PKG_INFO, (u_int16) sizeof(SENSOR_PKG_MSG_VSINFO), (const void *) &st_pkg_master);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS_PKG, 0, pst_pno_tbl->st_pno_data[i].us_pno,
+ reinterpret_cast<uint8_t *>(&st_pkg_master), sizeof(SENSOR_PKG_MSG_VSINFO), uc_result);
+ }
+ else {
+ /* When the delivery system is normal */
+ /* Acquire the applicable data information from the data master..*/
+ if (VEHICLESENS_GETMETHOD_GPS == uc_current_get_method) {
+ uc_result = VehicleSensDeliveryGPS(ul_did, uc_get_method, uc_current_get_method, i, &cid, &stmaster,
+ pst_pno_tbl);
+ }
+ else if ((VEHICLESENS_GETMETHOD_NAVI == uc_get_method) || // NOLINT(readability/braces)
+ (VEHICLESENS_GETMETHOD_OTHER == uc_get_method) || (VEHICLESENS_GETMETHOD_INTERNAL == uc_get_method)) {
+ uc_result = VehicleSensDeliveryOther(ul_did, uc_current_get_method, i, &cid, &stmaster, pst_pno_tbl);
+ }
+
+#if CONFIG_SENSOR_EXT_VALID /* Initial Sensor Support */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ else if ((ul_did == POSHAL_DID_GYRO_X_FST) || // NOLINT(readability/braces)
+ (ul_did == POSHAL_DID_GYRO_Y_FST) || // NOLINT(readability/braces)
+ (ul_did == POSHAL_DID_GYRO_Z_FST) || // NOLINT(readability/braces)
+ (ul_did == POSHAL_DID_REV_FST) ||
+ (ul_did == POSHAL_DID_GYRO_TEMP_FST) ||
+ (ul_did == POSHAL_DID_GSNS_X_FST) ||
+ (ul_did == POSHAL_DID_GSNS_Y_FST) ||
+ (ul_did == POSHAL_DID_GSNS_Z_FST) ||
+ (ul_did == POSHAL_DID_SPEED_PULSE_FST)) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* Acquire the applicable data information from the data master for the initial sensor..*/
+ uc_result = VehicleSensDeliveryFst(ul_did, uc_get_method, i, pst_pno_tbl);
+ }
+#endif
+ else if (ul_did == VEHICLE_DID_GYRO_TROUBLE) { // LCOV_EXCL_BR_LINE 6:DID is not used
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ uc_result = VehicleSensDeliveryGyro(ul_did, uc_current_get_method, i, pst_pno_tbl); // LCOV_EXCL_LINE 8: dead code // NOLINT(whitespace/line_length)
+ }
+ else { // NOLINT(readability/braces)
+ (void) memset(reinterpret_cast<void *>(&stmaster), 0x00, sizeof(stmaster));
+ VehicleSensGetDataMaster(ul_did, uc_current_get_method, &stmaster);
+
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ RET_API ret = VehicleSndMsg(PNO_VEHICLE_SENSOR, pst_pno_tbl->st_pno_data[i].us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO, (u_int16) sizeof(VEHICLESENS_DATA_MASTER), (const void *) &stmaster);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS, ul_did, pst_pno_tbl->st_pno_data[i].us_pno,
+ reinterpret_cast<uint8_t *>(&(stmaster.uc_data[0])), stmaster.us_size, uc_result);
+ }
+ }
+ }
+ }
+ }
+}
+
+u_int8 VehicleSensFirstDeliverySens(PNO us_pno, DID ul_did, u_int8 uc_get_method,
+ VEHICLESENS_DATA_MASTER_FST* stmaster_fst,
+ VEHICLESENS_DATA_MASTER_FST* stmaster_fst_temp) {
+ RET_API ret = RET_NORMAL; /* API return value */
+ u_int8 uc_result = SENSLOG_RES_SUCCESS; /* Send/Receive result */
+ /* Acquire the applicable data information from the data master for the initial sensor..*/
+ (void)memset(reinterpret_cast<void *>(stmaster_fst), 0, sizeof(VEHICLESENS_DATA_MASTER_FST));
+ (void)memset(reinterpret_cast<void *>(stmaster_fst_temp), 0, sizeof(VEHICLESENS_DATA_MASTER_FST));
+ VehicleSensGetDataMasterFst(ul_did, uc_get_method, stmaster_fst);
+
+ /* Internal debug log output */
+ FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__,
+ "[LOG:POSHAL_DID_GYRO_FST,POSHAL_DID_SPEED_PULSE_FST]");
+
+ if (stmaster_fst->partition_flg == 1) {
+ /* When the partitioning flag is enabled,Or exceeds the size that can be sent,Perform split transmission */
+ memcpy(stmaster_fst_temp, stmaster_fst, sizeof(VEHICLESENS_DATA_MASTER_FST));
+ if ((ul_did == POSHAL_DID_GYRO_X_FST) || /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ (ul_did == POSHAL_DID_GYRO_Y_FST) ||
+ (ul_did == POSHAL_DID_GYRO_Z_FST) ||
+ (ul_did == POSHAL_DID_GSNS_X_FST) ||
+ (ul_did == POSHAL_DID_GSNS_Y_FST) ||
+ (ul_did == POSHAL_DID_GSNS_Z_FST)) {
+ /* Internal debug log output */
+ FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__,
+ "[CALL:VehicleSndMsg:INPOSHAL_DID_GYRO_FST Partition]");
+
+ /* 1st session */
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ /* Size of data that can be transmitted in one division(Same size definition used) */
+ stmaster_fst_temp->us_size = LSDRV_FSTSNS_DSIZE_GYRO_X;
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(stmaster_fst_temp->us_size + 8),
+ (const void *)stmaster_fst_temp);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS,
+ ul_did,
+ us_pno,
+ reinterpret_cast<uint8_t *>(&(stmaster_fst_temp->uc_data[0])),
+ stmaster_fst_temp->us_size,
+ uc_result);
+
+ /* Second time */
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ (void)memset(reinterpret_cast<void *>(&stmaster_fst_temp->uc_data[0]),
+ 0,
+ sizeof(u_int8) * VEHICLE_DSIZE_DATA_MASTER_FST);
+ /* Size of the data - Transmission size(Same size definition used) Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ stmaster_fst_temp->us_size = static_cast<u_int16>(stmaster_fst->us_size - LSDRV_FSTSNS_DSIZE_GYRO_X);
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ memcpy(&stmaster_fst_temp->uc_data[0],
+ &stmaster_fst->uc_data[LSDRV_FSTSNS_DSIZE_GYRO_X],
+ stmaster_fst_temp->us_size);
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(stmaster_fst_temp->us_size + 8),
+ (const void *)stmaster_fst_temp);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS, ul_did, us_pno,
+ reinterpret_cast<uint8_t *>(&(stmaster_fst_temp->uc_data[0])),
+ stmaster_fst_temp->us_size, uc_result);
+ } else if (ul_did == POSHAL_DID_REV_FST) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* Internal debug log output */
+ FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__,
+ "[CALL:VehicleSndMsg:INPOSHAL_DID_REV_FST Partition]");
+
+ /* 1st session */
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ stmaster_fst_temp->us_size = LSDRV_FSTSNS_DSIZE_REV; /* Size of data that can be transmitted in one division */
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(stmaster_fst_temp->us_size + 8),
+ (const void *)stmaster_fst_temp);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS, ul_did, us_pno,
+ reinterpret_cast<uint8_t *>(&(stmaster_fst_temp->uc_data[0])),
+ stmaster_fst_temp->us_size, uc_result);
+
+ /* Second time */
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ (void)memset(reinterpret_cast<void *>(&stmaster_fst_temp->uc_data[0]),
+ 0,
+ sizeof(u_int8) * VEHICLE_DSIZE_DATA_MASTER_FST);
+ /* Size of the data - Transmission size Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ stmaster_fst_temp->us_size = static_cast<u_int16>(stmaster_fst->us_size - LSDRV_FSTSNS_DSIZE_REV);
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ memcpy(&stmaster_fst_temp->uc_data[0],
+ &stmaster_fst->uc_data[LSDRV_FSTSNS_DSIZE_REV],
+ stmaster_fst_temp->us_size);
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(stmaster_fst_temp->us_size + 8),
+ (const void *)stmaster_fst_temp);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS, ul_did, us_pno,
+ reinterpret_cast<uint8_t *>(&(stmaster_fst_temp->uc_data[0])),
+ stmaster_fst_temp->us_size, uc_result);
+ } else {
+ /* Internal debug log output */
+ FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__,
+ "[CALL:Vehicle_SndMsg:POSHAL_DID_SPEED_PULSE_FST Partition]");
+
+ /* 1st session */
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ /* Size of data that can be transmitted in one division(Same size definition used) */
+ stmaster_fst_temp->us_size = LSDRV_FSTSNS_DSIZE_GYRO_TEMP;
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(stmaster_fst_temp->us_size + 8),
+ (const void *)stmaster_fst_temp);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS, ul_did, us_pno,
+ reinterpret_cast<uint8_t *>(&(stmaster_fst_temp->uc_data[0])),
+ stmaster_fst_temp->us_size, uc_result);
+
+ /* Second time */
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ (void)memset(reinterpret_cast<void *>(&stmaster_fst_temp->uc_data[0]),
+ 0,
+ sizeof(u_int8) * VEHICLE_DSIZE_DATA_MASTER_FST);
+ /* Size of the data - Transmission size(Same size definition used) Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ stmaster_fst_temp->us_size = static_cast<u_int16>(stmaster_fst->us_size - LSDRV_FSTSNS_DSIZE_GYRO_TEMP);
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ memcpy(&stmaster_fst_temp->uc_data[0],
+ &stmaster_fst->uc_data[LSDRV_FSTSNS_DSIZE_GYRO_TEMP],
+ stmaster_fst_temp->us_size);
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(stmaster_fst_temp->us_size + 8),
+ (const void *)stmaster_fst_temp);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS, ul_did, us_pno,
+ reinterpret_cast<uint8_t *>(&(stmaster_fst_temp->uc_data[0])),
+ stmaster_fst_temp->us_size, uc_result);
+ }
+ } else {
+ /* Internal debug log output */
+ FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "[CALL:VehicleSndMsg]");
+
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ /* Data size + data information Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ static_cast<u_int16>(stmaster_fst->us_size + 8),
+ (const void *)stmaster_fst);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS, ul_did, us_pno,
+ reinterpret_cast<uint8_t *>(&(stmaster_fst->uc_data[0])),
+ stmaster_fst->us_size, uc_result);
+ }
+
+ return uc_result;
+}
+
+u_int8 VehicleSensFirstDeliveryOther(PNO us_pno, DID ul_did, u_int8 uc_get_method,
+ u_int32* cid,
+ VEHICLESENS_DATA_MASTER* stmaster) {
+ RET_API ret = RET_NORMAL; /* API return value */
+ u_int8 uc_result = SENSLOG_RES_SUCCESS; /* Send/Receive result */
+ /* Determine CID */
+ if (ul_did == VEHICLE_DID_LOCATION_LONLAT_NAVI) {
+ *cid = CID_POSIF_REGISTER_LISTENER_LONLAT;
+ } else if (ul_did == VEHICLE_DID_LOCATION_ALTITUDE_NAVI) { // LCOV_EXCL_BR_LINE 6:VEHICLE_DID_LOCATION_ALTITUDE_NAVI no API to pass in // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ *cid = CID_POSIF_REGISTER_LISTENER_ALTITUDE; // LCOV_EXCL_LINE 8: dead code
+ } else if ((ul_did == VEHICLE_DID_MOTION_SPEED_NAVI) ||
+ (ul_did == VEHICLE_DID_MOTION_SPEED_INTERNAL)) {
+ *cid = CID_VEHICLE_SENSORMOTION_SPEED;
+ } else if (ul_did == VEHICLE_DID_MOTION_HEADING_NAVI) {
+ *cid = CID_POSIF_REGISTER_LISTENER_HEADING;
+ } else if (ul_did == VEHICLE_DID_SETTINGTIME) {
+ *cid = CID_POSIF_REGISTER_LISTENER_GPS_TIME_SET_REQ;
+ } else { // LCOV_EXCL_BR_LINE 6: cannot be this one
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ *cid = 0xFFFF; /* DID error */ // LCOV_EXCL_LINE 8: dead code
+ }
+
+ /* Vehicle sensor information notification transmission */
+ if (*cid == 0xFFFF) { // LCOV_EXCL_BR_LINE 6: cannot be this one
+ /* Error log */
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Unknown DID [%d]", ul_did); // LCOV_EXCL_LINE 8: dead code // NOLINT(whitespace/line_length)
+ } else {
+ /* Acquire the applicable data information from the data master..*/
+ (void)memset(reinterpret_cast<void *>(stmaster), 0x00, sizeof(VEHICLESENS_DATA_MASTER));
+ VehicleSensGetDataMaster(ul_did, uc_get_method, stmaster);
+
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ us_pno,
+ static_cast<CID>(*cid),
+ (u_int16)stmaster->us_size,
+ (const void *)&(stmaster->uc_data[0]));
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_UNSPECIFIED,
+ ul_did,
+ us_pno,
+ reinterpret_cast<uint8_t *>(&(stmaster->uc_data[0])),
+ stmaster->us_size,
+ uc_result);
+ }
+
+ return uc_result;
+}
+/*******************************************************************************
+* MODULE : VehicleSensFirstDelivery
+* ABSTRACT : Vehicle Sensor Initial Data Delivery Process
+* FUNCTION : Deliver the initial data to the destination.
+* ARGUMENT : us_pno :Addresses for delivery NO
+* ul_did :Data ID
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensFirstDelivery(PNO us_pno, DID ul_did) {
+ u_int8 uc_get_method;
+ VEHICLESENS_DATA_MASTER stmaster;
+#if CONFIG_SENSOR_EXT_VALID /* Initial Sensor Support */
+ VEHICLESENS_DATA_MASTER_FST stMasterFst; /* Master of initial sensor data */
+ VEHICLESENS_DATA_MASTER_FST stMasterFst_temp; /* For temporary storage */
+ u_int32 cid;
+ SENSORLOCATION_MSG_LONLATINFO *pLonLatMsg;
+ SENSORLOCATION_MSG_ALTITUDEINFO *pAltitudeMsg;
+ SENSORMOTION_MSG_HEADINGINFO *pHeadingMsg;
+ RET_API ret = RET_NORMAL; /* API return value */
+ u_int8 uc_result = SENSLOG_RES_SUCCESS; /* Send/Receive result */
+#endif
+
+ /* Internal debug log output */
+ FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "+ [ul_did = 0x%x us_pno:0x%x]", ul_did, us_pno);
+
+ /* Obtain the data acquisition method.*/
+ uc_get_method = VehicleSensGetSelectionItemList(ul_did);
+
+ if (VEHICLESENS_GETMETHOD_GPS == uc_get_method) {
+ SENSOR_MSG_GPSDATA_DAT gps_master;
+ VEHICLESENS_DELIVERY_FORMAT delivery_data;
+ u_int16 length;
+ u_int16 senslog_len;
+
+ VehicleSensGetGpsDataMaster(ul_did, uc_get_method, &gps_master);
+
+ if (ul_did == POSHAL_DID_GPS_TIME) {
+ /* GPS time,Because there is no header in the message to be delivered,Padding deliveryData headers */
+ (void)memcpy(reinterpret_cast<void*>(&delivery_data),
+ reinterpret_cast<void*>(&gps_master.uc_data[0]), gps_master.us_size);
+ length = gps_master.us_size;
+ senslog_len = length;
+ cid = CID_VEHICLESENS_VEHICLE_INFO_GPS_TIME;
+ } else if (ul_did == VEHICLE_DID_LOCATION_LONLAT) {
+ pLonLatMsg = reinterpret_cast<SENSORLOCATION_MSG_LONLATINFO*>(&delivery_data);
+ /* Acquire the applicable data information from the data master..*/
+ VehicleSensGetDataMaster(ul_did, uc_get_method, &stmaster);
+ (void)memcpy(reinterpret_cast<void*>(&(pLonLatMsg->data)),
+ reinterpret_cast<void*>(&(stmaster.uc_data[0])), stmaster.us_size);
+ length = (u_int16)stmaster.us_size;
+ senslog_len = length;
+ cid = CID_POSIF_REGISTER_LISTENER_LONLAT;
+ } else if (ul_did == VEHICLE_DID_LOCATION_ALTITUDE) {
+ pAltitudeMsg = reinterpret_cast<SENSORLOCATION_MSG_ALTITUDEINFO*>(&delivery_data);
+ /* Acquire the applicable data information from the data master..*/
+ VehicleSensGetDataMaster(ul_did, uc_get_method, &stmaster);
+ (void)memcpy(reinterpret_cast<void*>(&(pAltitudeMsg->data)),
+ reinterpret_cast<void*>(&stmaster.uc_data[0]), stmaster.us_size);
+ length = (u_int16)stmaster.us_size;
+ senslog_len = length;
+ cid = CID_POSIF_REGISTER_LISTENER_ALTITUDE;
+ } else if (ul_did == VEHICLE_DID_MOTION_HEADING) {
+ pHeadingMsg = reinterpret_cast<SENSORMOTION_MSG_HEADINGINFO*>(&delivery_data);
+ /* Acquire the applicable data information from the data master..*/
+ VehicleSensGetDataMaster(ul_did, uc_get_method, &stmaster);
+ (void)memcpy(reinterpret_cast<void*>(&(pHeadingMsg->data)),
+ reinterpret_cast<void*>(&stmaster.uc_data[0]), stmaster.us_size);
+ length = (u_int16)stmaster.us_size;
+ senslog_len = length;
+ cid = CID_POSIF_REGISTER_LISTENER_HEADING;
+ } else {
+
+ delivery_data.header.did = gps_master.ul_did;
+ delivery_data.header.size = gps_master.us_size;
+ delivery_data.header.rcv_flag = gps_master.uc_rcv_flag;
+ delivery_data.header.sensor_cnt = gps_master.uc_sns_cnt;
+ (void)memcpy(reinterpret_cast<void *>(&delivery_data.data[0]),
+ reinterpret_cast<void *>(&gps_master.uc_data[0]),
+ (size_t)delivery_data.header.size);
+
+ length = static_cast<u_int16>((u_int16)sizeof(delivery_data.header) + delivery_data.header.size);
+ senslog_len = delivery_data.header.size;
+ cid = CID_VEHICLESENS_VEHICLE_INFO;
+ }
+
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ us_pno,
+ static_cast<CID>(cid),
+ length,
+ (const void *)&delivery_data);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ if (cid != CID_VEHICLESENS_VEHICLE_INFO) {
+ SensLogWriteOutputData(SENSLOG_DATA_O_UNSPECIFIED, ul_did, us_pno,
+ reinterpret_cast<uint8_t *>(&delivery_data), senslog_len, uc_result);
+ } else {
+ SensLogWriteOutputData(SENSLOG_DATA_O_UNSPECIFIED, ul_did, us_pno,
+ reinterpret_cast<uint8_t *>(&(delivery_data.data[0])), senslog_len, uc_result);
+ }
+ }
+ else if ((VEHICLESENS_GETMETHOD_NAVI == uc_get_method) || // NOLINT(readability/braces)
+ (VEHICLESENS_GETMETHOD_OTHER == uc_get_method) ||
+ (VEHICLESENS_GETMETHOD_INTERNAL == uc_get_method)) {
+ uc_result = VehicleSensFirstDeliveryOther(us_pno, ul_did, uc_get_method, &cid, &stmaster);
+ }
+#if CONFIG_SENSOR_EXT_VALID /* Initial Sensor Support */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ else if ((ul_did == POSHAL_DID_GYRO_X_FST) || // NOLINT(readability/braces)
+ (ul_did == POSHAL_DID_GYRO_Y_FST) || // NOLINT(readability/braces)
+ (ul_did == POSHAL_DID_GYRO_Z_FST) || // NOLINT(readability/braces)
+ (ul_did == POSHAL_DID_REV_FST) ||
+ (ul_did == POSHAL_DID_GYRO_TEMP_FST) ||
+ (ul_did == POSHAL_DID_GSNS_X_FST) ||
+ (ul_did == POSHAL_DID_GSNS_Y_FST) ||
+ (ul_did == POSHAL_DID_GSNS_Z_FST) ||
+ (ul_did == POSHAL_DID_SPEED_PULSE_FST)) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* Acquire the applicable data information from the data master for the initial sensor..*/
+ uc_result = VehicleSensFirstDeliverySens(us_pno, ul_did, uc_get_method, &stMasterFst, &stMasterFst_temp);
+ }
+#endif
+ else if (ul_did == VEHICLE_DID_GYRO_TROUBLE) { // LCOV_EXCL_BR_LINE 8 : DID in not used
+ // LCOV_EXCL_START 8: DID is not used
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ VEHICLESENS_DATA_MASTER_GYRO_TROUBLE st_master_gyro_trouble;
+ SENSORMOTION_MSG_GYROTROUBLEINFO_DAT st_msg_gyro_trouble_info;
+
+ /* Initialization */
+ st_master_gyro_trouble.uc_reserve = 0;
+ st_msg_gyro_trouble_info.reserve = 0;
+
+ VehicleSensGetDataMasterGyroTrouble(ul_did, uc_get_method, &st_master_gyro_trouble);
+
+ /* Size storage(GYROTROUBLE) */
+ st_msg_gyro_trouble_info.size = st_master_gyro_trouble.us_size;
+
+ /* Set the GyroTrouble */
+ (void)memcpy(reinterpret_cast<void *>(&(st_msg_gyro_trouble_info.gyro_trouble)),
+ reinterpret_cast<void *>(&(st_master_gyro_trouble.uc_data)),
+ sizeof(st_msg_gyro_trouble_info.gyro_trouble));
+
+#if VEHICLE_SENS_DELIVERY_CTRL_DEBUG_DIAG
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "#[DIAG] ul_did = VEHICLE_DID_GYRO_TROUBLE");
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ "#[DIAG] st_msg_gyro_trouble_info.size = %d",
+ st_msg_gyro_trouble_info.size);
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__,
+ "#[DIAG] st_msg_gyro_trouble_info.gyro_trouble = 0x%08X \r\n",
+ st_msg_gyro_trouble_info.gyro_trouble);
+#endif /* VEHICLE_SENS_DELIVERY_CTRL_DEBUG_DIAG */
+ /* Since the undefined state is not a device specification,Do not deliver to the app for the first time */
+ if (st_msg_gyro_trouble_info.gyro_trouble != GYRO_UNFIXED) {
+
+ /* Send GyroTrouble to API-caller */
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ us_pno,
+ CID_VEHICLE_SENSORMOTION_GYROTROUBLE,
+ sizeof(SENSORMOTION_MSG_GYROTROUBLEINFO_DAT),
+ (const void *)&st_msg_gyro_trouble_info);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS, ul_did, us_pno,
+ reinterpret_cast<uint8_t *>(&st_msg_gyro_trouble_info),
+ sizeof(SENSORMOTION_MSG_GYROTROUBLEINFO_DAT),
+ uc_result);
+#if VEHICLE_SENS_DELIVERY_CTRL_DEBUG_DIAG
+ FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, "#[DIAG] GyroTrouble FirstDelivery");
+#endif /* VEHICLE_SENS_DELIVERY_CTRL_DEBUG_DIAG */
+ }
+ // LCOV_EXCL_STOP
+ }
+ else { // NOLINT(readability/braces)
+ (void)memset(reinterpret_cast<void *>(&stmaster), 0x00, sizeof(stmaster));
+ /* Acquire the applicable data information from the data master..*/
+ VehicleSensGetDataMaster(ul_did, uc_get_method, &stmaster);
+
+ /* Call Vehicle Sensor Information Notification Transmission Process.*/
+ ret = VehicleSndMsg(PNO_VEHICLE_SENSOR,
+ us_pno,
+ CID_VEHICLESENS_VEHICLE_INFO,
+ (u_int16)sizeof(VEHICLESENS_DATA_MASTER),
+ (const void *)&stmaster);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS, ul_did, us_pno,
+ reinterpret_cast<uint8_t *>(&(stmaster.uc_data[0])),
+ stmaster.us_size, uc_result);
+ }
+ /* Internal debug log output */
+ FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "-");
+}
+
+/*******************************************************************************
+* MODULE : VehicleSensFirstPkgDelivery
+* ABSTRACT : Vehicle Sensor Initial Package Data Delivery Process
+* FUNCTION : Deliver the initial package data to the destination.
+* ARGUMENT : *pst_data :Data portion pointer of the message buffer
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensFirstPkgDelivery(const SENSOR_MSG_DELIVERY_ENTRY_DAT *pst_data) { // LCOV_EXCL_START 8: dead code
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ u_int8 uc_get_method; /* Data collection way */
+ int32 i; /* Generic counters */
+ SENSOR_PKG_MSG_VSINFO st_pkg_master; /* Data master for package delivery */
+ DID ul_pkg_did; /* DID for package data acquisition */
+ u_int16 us_offset = 0; /* For offset calculation */
+ u_int16 us_next_offset; /* Next offset value */
+ u_int16 us_boundary_adj; /* For boundary adjustment */
+ RET_API ret = RET_NORMAL; /* API return value */
+ u_int8 uc_result = 0; /* Send/Receive result */
+
+ (void)memset(reinterpret_cast<void *>(&st_pkg_master), 0, sizeof(SENSOR_PKG_MSG_VSINFO));
+ /* For boundary adjustment */
+ us_boundary_adj = (u_int16)VEHICLESENS_BIT1 | (u_int16)VEHICLESENS_BIT0;
+ for (i = 0; i < pst_data->pkg_num; i++) {
+ ul_pkg_did = pst_data->did[i]; /* Get DID */
+ st_pkg_master.usOffset[i] = us_offset; /* Offset setting */
+ /* Data collection way */
+ uc_get_method = VehicleSensGetSelectionItemList(ul_pkg_did);
+ if (VEHICLESENS_GETMETHOD_GPS == uc_get_method) {
+ VehicleSensGetGpsDataMaster(ul_pkg_did,
+ uc_get_method,
+ reinterpret_cast<SENSOR_MSG_GPSDATA_DAT *>(&st_pkg_master.ucData[us_offset]));
+ } else {
+ VehicleSensGetDataMaster(ul_pkg_did,
+ uc_get_method,
+ reinterpret_cast<VEHICLESENS_DATA_MASTER *>(&st_pkg_master.ucData[us_offset]));
+ }
+ /* Next offset calculation */
+ /* Boundary adjustment of data size */
+ us_next_offset = VehicleSensGetDataMasterOffset(ul_pkg_did);
+ if ((us_next_offset & us_boundary_adj) != 0) {
+ /* If you need to adjust */
+ us_next_offset = static_cast<u_int16>(us_next_offset & ~us_boundary_adj); /* Mask Lower Bit */
+ us_next_offset = static_cast<u_int16>(us_next_offset + (u_int16)VEHICLESENS_BIT2); /* Add numbers */
+ }
+ us_offset = static_cast<u_int16>(us_offset + us_next_offset);
+ }
+
+ st_pkg_master.ucDNum = pst_data->pkg_num; /* To save the number of data */
+ ret = PosSndMsg(PNO_VEHICLE_SENSOR,
+ pst_data->pno,
+ CID_SENSOR_PKG_INFO,
+ (u_int16)sizeof(SENSOR_PKG_MSG_VSINFO),
+ (const void *)&st_pkg_master);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS_PKG, 0, pst_data->pno,
+ reinterpret_cast<uint8_t *>(&st_pkg_master),
+ sizeof(SENSOR_PKG_MSG_VSINFO),
+ uc_result);
+}
+// LCOV_EXCL_STOP
+
+/* Ignore->MISRA-C++:2008 Rule 2-7-2 */
+#if CONFIG_SENSOR_EXT_VALID /* Initial Sensor Support */
+/*******************************************************************************
+* MODULE : VehicleSensFirstPkgDeliveryExt
+* ABSTRACT : Vehicle Sensor Initial Expansion Package Data Delivery Process
+* FUNCTION : Deliver the initial expansion package data to the destination.
+* ARGUMENT : *pst_data :Data portion pointer of the message buffer
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensFirstPkgDeliveryExt(const SENSOR_MSG_DELIVERY_ENTRY_DAT *pst_data) {
+ u_int8 ucGetMethod; /* Data collection way */
+ int32 i; /* Generic counters */
+ static SENSOR_PKG_MSG_VSINFO stPkgMaster; /* Data master for package delivery */
+ DID ulPkgDid; /* DID for package data acquisition */
+ u_int16 usOffset = 0; /* For offset calculation */
+ u_int16 usNextOffset; /* Next offset value */
+ u_int16 usBoundaryAdj; /* For boundary adjustment */
+ static VEHICLESENS_DATA_MASTER_EXT stExtDataTemp[11];/* Extended data master temporary storage area */
+ u_int16 usDataCnt[11] = {0}; /* For storing the number of data items */
+ u_int8 ucDivideCnt; /* Total number of partitions */
+ u_int8 ucDivide100Cnt = 0; /* Total number of 100 partitions */
+ u_int8 ucDivideSendCnt; /* Number of divided transmissions */
+ u_int16 usDivideSendSize[11] = {0}; /* Split Send Size */
+ u_int16 ucDivideSendPoint; /* Split transmission data acquisition position */
+ u_int8 ucDataBreak; /* Storage area of all data undelivered flag */
+ RET_API ret = RET_NORMAL; /* API return value */
+ u_int8 uc_result = 0; /* Send/Receive result */
+
+ /* Internal debug log output */
+ FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "+");
+
+ /* For boundary adjustment */
+ usBoundaryAdj = (u_int16)VEHICLESENS_BIT1 | (u_int16)VEHICLESENS_BIT0;
+ /* #Polaris_004 START */ /* Ignore->MISRA-C++:2008 Rule 2-7-2 */
+ (void)memset(reinterpret_cast<void *>(&stExtDataTemp), 0, sizeof(stExtDataTemp));
+ for (i = 0; i < pst_data->pkg_num; i++) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ ulPkgDid = pst_data->did[i]; /* Get DID */
+ ucGetMethod = VehicleSensGetSelectionItemList(ulPkgDid); /* Data collection way */
+ if (VEHICLESENS_GETMETHOD_GPS < ucGetMethod) {
+ FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
+ "VEHICLESENS_DELIVERYCTRL: VehicleSensGetSelectionItemList error :%d\r\n", ucGetMethod);
+ }
+
+ if ((ulPkgDid == POSHAL_DID_GYRO_EXT) ||
+ (ulPkgDid == POSHAL_DID_GYRO_X) ||
+ (ulPkgDid == POSHAL_DID_GYRO_Y) ||
+ (ulPkgDid == POSHAL_DID_GYRO_Z) ||
+ (ulPkgDid == POSHAL_DID_GSNS_X) ||
+ (ulPkgDid == POSHAL_DID_GSNS_Y) ||
+ (ulPkgDid == POSHAL_DID_GSNS_Z) ||
+ (ulPkgDid == POSHAL_DID_SPEED_PULSE) ||
+ (ulPkgDid == POSHAL_DID_REV) ||
+ (ulPkgDid == POSHAL_DID_GYRO_TEMP) ||
+ (ulPkgDid == POSHAL_DID_PULSE_TIME) ||
+ (ulPkgDid == POSHAL_DID_SNS_COUNTER)) {
+ /* Store in the extended data master information buffer */
+ VehicleSensGetDataMasterExt(ulPkgDid, ucGetMethod, &stExtDataTemp[i]);
+ /* Obtain the number of data items */
+ if ((ulPkgDid == POSHAL_DID_SNS_COUNTER) ||
+ (ulPkgDid == POSHAL_DID_REV)) {
+ usDataCnt[i] = stExtDataTemp[i].us_size; /* 1data 1byte */
+ /* Store the transmission size for 10 items */
+ usDivideSendSize[i] = 10;
+ } else if (ulPkgDid == POSHAL_DID_GYRO_TEMP) {
+ usDataCnt[i] = stExtDataTemp[i].us_size / 2; /* 1data 2byte */
+ /* Store the transmission size for 10 items */
+ usDivideSendSize[i] = 20;
+ }
+ else if (ulPkgDid == POSHAL_DID_PULSE_TIME) { // NOLINT(readability/braces)
+ usDataCnt[i] = stExtDataTemp[i].us_size / 132; /* 1data 132byte */
+ /* Store the transmission size for 10 items */
+ usDivideSendSize[i] = 1320;
+ }
+ else { // NOLINT(readability/braces)
+ usDataCnt[i] = stExtDataTemp[i].us_size / 2; /* 1data 2byte Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* Store the transmission size for 100 items */
+ usDivideSendSize[i] = 200;
+
+ // divide cnt is 100
+ if (((usDataCnt[i] % VEHICLESENS_PKG_EXT_SEND_MAX_10DATA) > 0) || (usDataCnt[i] == 0)) {
+ ucDivide100Cnt = static_cast<u_int8>((usDataCnt[i] / VEHICLESENS_PKG_EXT_SEND_MAX_10DATA) + 1);
+ } else {
+ ucDivide100Cnt = static_cast<u_int8>(usDataCnt[i] / VEHICLESENS_PKG_EXT_SEND_MAX_10DATA);
+ }
+ }
+ }
+ }
+ /* All-data undelivered flag holding Ignore->MISRA-C ++: 2008 Rule 5-0-5 */
+ ucDataBreak = static_cast<u_int8>(gstPkgTempExt.data_break);
+
+ /* From the number of data items in the acquired buffer,Calculate the number of transmissions */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ if (((usDataCnt[0] % VEHICLESENS_PKG_EXT_SEND_MAX) > 0) || (usDataCnt[0] == 0)) {
+ /* If there is a remainder,,Division result + 1 */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ ucDivideCnt = static_cast<u_int8>((usDataCnt[0] / VEHICLESENS_PKG_EXT_SEND_MAX) + 1);
+ } else {
+ /* If there is no remainder,,The result of division is the total number of transmissions. */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ ucDivideCnt = static_cast<u_int8>(usDataCnt[0] / VEHICLESENS_PKG_EXT_SEND_MAX);
+ }
+
+ // if ucDivide100cnt is valid (greater than 0)
+ ucDivideCnt = (ucDivide100Cnt > 0) ? ucDivide100Cnt : ucDivideCnt;
+
+ ucDivideSendCnt = 0; /* Number of divided transmissions */
+ while (ucDivideSendCnt < ucDivideCnt) {
+ /* Clear send message buffer */
+ (void)memset(reinterpret_cast<void *>(&stPkgMaster), 0, sizeof(SENSOR_PKG_MSG_VSINFO));
+ usOffset = 0;
+ for (i = 0; i < pst_data->pkg_num; i++) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ ulPkgDid = pst_data->did[i]; /* Get DID */
+ stPkgMaster.usOffset[i] = usOffset; /* Offset setting */
+ /* copy Data ID of extended data master structure,Size of the data,Receive flag,Reserved */
+ memcpy(reinterpret_cast<void *>(&stPkgMaster.ucData[usOffset]),
+ reinterpret_cast<void *>(&stExtDataTemp[i]), 11);
+ if ((ulPkgDid == POSHAL_DID_SNS_COUNTER) ||
+ (ulPkgDid == POSHAL_DID_REV) ||
+ (ulPkgDid == POSHAL_DID_PULSE_TIME) ||
+ (ulPkgDid == POSHAL_DID_GYRO_TEMP)) {
+ if (usDataCnt[i] > VEHICLESENS_PKG_EXT_SEND_MAX) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* Calculate the data acquisition position */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ ucDivideSendPoint = static_cast<u_int16>((u_int16)ucDivideSendCnt * usDivideSendSize[i]);
+ /* Update the data size*/
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ stPkgMaster.ucData[usOffset + 4] = (u_int8)usDivideSendSize[i];
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ stPkgMaster.ucData[usOffset + 5] = (u_int8)(usDivideSendSize[i] >> 8);
+ /* Create 10 divided transmission data of sensor counters of extended data master structure */
+ memcpy(reinterpret_cast<void *>(&stPkgMaster.ucData[usOffset + 8]),
+ reinterpret_cast<void *>(&stExtDataTemp[i].uc_data[ucDivideSendPoint]),
+ usDivideSendSize[i]); /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* Subtract the number of created transmission data */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ usDataCnt[i] = static_cast<u_int16>(usDataCnt[i] - VEHICLESENS_PKG_EXT_SEND_MAX);
+ } else {
+ /* Calculate the data acquisition position */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ ucDivideSendPoint = static_cast<u_int16>((u_int16)ucDivideSendCnt * usDivideSendSize[i]);
+ /* Update the data size*/
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ stPkgMaster.ucData[usOffset + 4] = (u_int8)(stExtDataTemp[i].us_size - (u_int16)ucDivideSendPoint);
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 Ignore->MISRA-C++:2008 Rule 5-0-21 */
+ stPkgMaster.ucData[usOffset + 5] = \
+ (u_int8)((stExtDataTemp[i].us_size - (u_int16)ucDivideSendPoint) >> 8);
+ /* Create the remaining divided send data of sensor counter of extended data master structure */
+ memcpy(reinterpret_cast<void *>(&stPkgMaster.ucData[usOffset + 8]),
+ reinterpret_cast<void *>(&stExtDataTemp[i].uc_data[ucDivideSendPoint]),
+ stExtDataTemp[i].us_size - ucDivideSendPoint); /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* Since all buffers have been created, the number of data is set to 0. */
+ usDataCnt[i] = 0;
+ }
+ } else {
+ if (usDataCnt[i] > VEHICLESENS_PKG_EXT_SEND_MAX_10DATA) { /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* Calculate the data acquisition position */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ ucDivideSendPoint = static_cast<u_int16>((u_int16)ucDivideSendCnt * usDivideSendSize[i]);
+ /* Update the data size*/
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ stPkgMaster.ucData[usOffset + 4] = (u_int8)usDivideSendSize[i];
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ stPkgMaster.ucData[usOffset + 5] = (u_int8)(usDivideSendSize[i] >> 8);
+ /* Create 100 divided transmission data of vehicle sensor data of extended data master structure */
+ memcpy(reinterpret_cast<void *>(&stPkgMaster.ucData[usOffset + 8]),
+ reinterpret_cast<void *>(&stExtDataTemp[i].uc_data[ucDivideSendPoint]),
+ usDivideSendSize[i]); /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* Subtract the number of created transmission data */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ usDataCnt[i] = static_cast<u_int16>(usDataCnt[i] - VEHICLESENS_PKG_EXT_SEND_MAX_10DATA);
+ } else {
+ /* Calculate the data acquisition position */
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ ucDivideSendPoint = static_cast<u_int16>((u_int16)ucDivideSendCnt * usDivideSendSize[i]);
+ /* Update the data size*/
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ stPkgMaster.ucData[usOffset + 4] = \
+ (u_int8)(stExtDataTemp[i].us_size - (u_int16)ucDivideSendPoint);
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 Ignore->MISRA-C++:2008 Rule 5-0-21 */
+ stPkgMaster.ucData[usOffset + 5] = \
+ (u_int8)((stExtDataTemp[i].us_size - (u_int16)ucDivideSendPoint) >> 8);
+ /* Create the remaining divided transmission data of the vehicle sensor data of the extended data master structure. */
+ memcpy(reinterpret_cast<void *>(&stPkgMaster.ucData[usOffset + 8]),
+ reinterpret_cast<void *>(&stExtDataTemp[i].uc_data[ucDivideSendPoint]),
+ stExtDataTemp[i].us_size - ucDivideSendPoint); /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ /* Since all buffers have been created, the number of data is set to 0. */
+ usDataCnt[i] = 0;
+ }
+ }
+ /* Next offset calculation */
+ /* Boundary adjustment of data size */
+ usNextOffset = VehicleSensGetDataMasterExtOffset(ulPkgDid);
+ /* Ignore->MISRA-C++:2008 Rule 5-0-5 Ignore->MISRA-C++:2008 Rule 5-0-13, 5-0-14, 5-3-1 */
+ if ((usNextOffset & usBoundaryAdj) != 0) {
+ /* If you need to adjust */
+ /* Mask Lower Bit Ignore->MISRA-C++:2008 Rule 5-0-5 Ignore->MISRA-C++:2008 Rule 5-0-21 */
+ usNextOffset = static_cast<u_int16>(usNextOffset & ~usBoundaryAdj);
+ usNextOffset = static_cast<u_int16>(usNextOffset + (u_int16)VEHICLESENS_BIT2); /* Add numbers */
+ }
+ usOffset = static_cast<u_int16>(usOffset + usNextOffset); /* Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ }
+ stPkgMaster.ucDNum = pst_data->pkg_num; /* To save the number of data */
+ stPkgMaster.ucDataBreak = ucDataBreak; /* Set all data undelivered flag */
+ stPkgMaster.ucDivideCnt = ucDivideCnt; /* Set total number of partitions */
+ /* Division number setting Ignore->MISRA-C++:2008 Rule 5-0-5 */
+ stPkgMaster.ucDivideSendCnt = static_cast<uint8_t>(ucDivideSendCnt + 1);
+ ret = PosSndMsg(PNO_VEHICLE_SENSOR,
+ pst_data->pno,
+ CID_SENSOR_PKG_INFO,
+ (u_int16)sizeof(SENSOR_PKG_MSG_VSINFO),
+ (const void *)&stPkgMaster);
+ uc_result = SENSLOG_RES_SUCCESS;
+ if (ret != RET_NORMAL) {
+ uc_result = SENSLOG_RES_FAIL;
+ }
+ SensLogWriteOutputData(SENSLOG_DATA_O_SYS_PKG, 0, pst_data->pno,
+ reinterpret_cast<uint8_t *>(&stPkgMaster),
+ sizeof(SENSOR_PKG_MSG_VSINFO), uc_result);
+
+ ucDivideSendCnt++;
+
+ /* Package delivery (split) confirmation debug log output */
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__,
+ "### SENS RECV # FST PKG DELIVERY : cnt[%d/7]", ucDivideSendCnt);
+ if (7 <= ucDivideSendCnt) {
+ FRAMEWORKUNIFIEDLOG(ZONE_INIT, __FUNCTION__,
+ "### SENS RECV # FST PKG DELIVERY : last sns_cnt[%d][%d][%d][%d]",
+ stPkgMaster.ucData[8], stPkgMaster.ucData[9], stPkgMaster.ucData[10], stPkgMaster.ucData[11]);
+ }
+ }
+ /* Ignore->MISRA-C++:2008 Rule 2-7-2 */
+
+ /* Internal debug log output */
+ FRAMEWORKUNIFIEDLOG(ZONE_26, __FUNCTION__, "-");
+}
+#endif
+
+/* ++ PastModel002 response DR */
+
+/*******************************************************************************
+ * MODULE : VehicleSensEntryDeliveryCtrlDR
+ * ABSTRACT : Internal delivery destination management registration function for vehicle sensor DR
+ * FUNCTION : Internal distribution destination management table for DR,Update the shipping management table management.
+ * ARGUMENT : pst_delivery_entry : Pointer to the delivery registration information
+ * NOTE :
+ * RETURN : VEHICLE_RET_NORMAL :Successful registration
+ ******************************************************************************/
+VEHICLE_RET_API VehicleSensEntryDeliveryCtrlDR(const DEADRECKONING_MSG_DELIVERY_ENTRY *pst_delivery_entry) { // LCOV_EXCL_START 8 : dead code // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ int32 i;
+ u_int8 uc_action_type = VEHICLESENS_ACTION_TYPE_ADD;
+ int32 uc_did_flag;
+ DID ulentry_did = pst_delivery_entry->data.did;
+ VEHICLESENS_DELIVERY_CTRL_TBL_MNG_DATA *pst_existing_mng_data = NULL;
+ VEHICLE_RET_API ret = VEHICLE_RET_NORMAL; /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+
+ /* Check if the data ID exists. */
+ uc_did_flag = VehicleSensCheckDid(ulentry_did);
+ if (uc_did_flag == 0) {
+ ret = VEHICLE_RET_ERROR_DID; /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ }
+
+ /* Check the number of registered shipments. */
+ if ((ret == VEHICLE_RET_NORMAL) &&/* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ (g_stdelivery_ctrl_tbl_dr.us_dnum >= VEHICLESENS_DELIVERY_INFO_MAX)) {
+ /* Return the FULL of delivery registrations*/
+ ret = VEHICLE_RET_ERROR_BUFFULL; /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ }
+
+ if (ret == VEHICLE_RET_NORMAL) { /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+ /* By searching for the delivery registration of the relevant DID,Hold the address. */
+ for (i = 0; i < g_stdelivery_ctrl_tbl_mng_dr.us_dnum; i++) {
+ if (g_stdelivery_ctrl_tbl_mng_dr.st_ctrl_tbl_mng_data[i].ul_did == ulentry_did) {
+ uc_action_type = VEHICLESENS_ACTION_TYPE_UPDATE;
+ pst_existing_mng_data = &g_stdelivery_ctrl_tbl_mng_dr.st_ctrl_tbl_mng_data[i];
+ }
+ }
+
+ /* Add to the shipping management table.*/
+ VehicleSensAddDeliveryCtrlTblDR(pst_delivery_entry);
+ /* Processing when updating existing data*/
+ if (uc_action_type == VEHICLESENS_ACTION_TYPE_UPDATE) {
+ /* Update the shipping management table.*/
+ VehicleSensUpdateDeliveryCtrlTblDR(pst_existing_mng_data);
+
+ /* Update the shipping destination management table management information.*/
+ VehicleSensUpdateDeliveryCtrlTblMngDR(pst_existing_mng_data);
+ } else { /* Newly added processing*/
+ /* Add to the shipping management table management information.*/
+ VehicleSensAddDeliveryCtrlTblMngDR(pst_delivery_entry);
+ }
+ }
+ return ret; /* _CWORD71_:QAC++4020:Multiple exit points found. MISRA-C++ Rule 6-6-5 */
+}
+// LCOV_EXCL_STOP
+
+/*******************************************************************************
+* MODULE : VehicleSensMakeDeliveryPnoTblDR
+* ABSTRACT : Vehicle sensor internal delivery destination PNO table creation function for DR
+* FUNCTION : Create an internal delivery destination PNO table for DR
+* ARGUMENT : ul_did Data ID
+* Change_type Delivery Trigger
+* NOTE :
+* RETURN : VEHICLESENS_DELIVERY_PNO_TBL* Pointer to the shipping PNO table
+******************************************************************************/
+VEHICLESENS_DELIVERY_PNO_TBL* VehicleSensMakeDeliveryPnoTblDR(DID ul_did, u_int8 change_type) { // LCOV_EXCL_START 8 : dead code // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ int32 i;
+ u_int8 uc_ctrl_tbl_mng_data_list;
+ u_int16 us_index = 0;
+ u_int16 us_dnum = 0;
+
+ /* Get the start index and count of the corresponding data ID. */
+ uc_ctrl_tbl_mng_data_list = static_cast<u_int8>(
+ (sizeof(g_stdelivery_ctrl_tbl_mng_dr.st_ctrl_tbl_mng_data)) /
+ (sizeof(g_stdelivery_ctrl_tbl_mng_dr.st_ctrl_tbl_mng_data[0])));
+
+ for (i = 0; i < uc_ctrl_tbl_mng_data_list; i++) {
+ /* Stores the information of the corresponding DID.. */
+ if (g_stdelivery_ctrl_tbl_mng_dr.st_ctrl_tbl_mng_data[i].ul_did == ul_did) {
+ us_index = g_stdelivery_ctrl_tbl_mng_dr.st_ctrl_tbl_mng_data[i].us_start_idx;
+ us_dnum = g_stdelivery_ctrl_tbl_mng_dr.st_ctrl_tbl_mng_data[i].usdlvry_entry_num;
+ break;
+ }
+ }
+
+ /* Create a PNO list */
+ (void)memset(reinterpret_cast<void *>(&g_stdelivery_pno_tbl_dr),
+ static_cast<int32>(0),
+ (size_t)sizeof(g_stdelivery_pno_tbl_dr));
+ if (change_type == VEHICLESENS_CHGTYPE_CHG) {
+ /* Processing when delivery timing is changed*/
+ for (i = 0; i < us_dnum; i++) {
+ /* Functionalization by Increasing Structure Members */
+ VehicleSensAddPnoTblDR(us_index);
+ us_index = g_stdelivery_ctrl_tbl_dr.st_ctrl_data[us_index].us_link_idx;
+ }
+ } else {
+ /* Processing when delivery timing is update */
+ for (i = 0; i < us_dnum; i++) {
+ if (VEHICLE_DELIVERY_TIMING_UPDATE == g_stdelivery_ctrl_tbl_dr.st_ctrl_data[us_index].uc_chg_type) {
+ /* Functionalization by Increasing Structure Members */
+ VehicleSensAddPnoTblDR(us_index);
+ }
+ us_index = g_stdelivery_ctrl_tbl_dr.st_ctrl_data[us_index].us_link_idx;
+ }
+ }
+
+ return(&g_stdelivery_pno_tbl_dr);
+}
+// LCOV_EXCL_STOP
+
+/*******************************************************************************
+* MODULE : VehicleSensAddPnoTblDR
+* ABSTRACT : Vehicle sensor DR internal delivery destination PNO table addition function
+* FUNCTION : Add to the internal DR shipping destination PNO table.
+* ARGUMENT : us_index : Index of the referenced destination management table
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensAddPnoTblDR(u_int16 us_index) { // LCOV_EXCL_START 8: dead code
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ u_int16 us_pno_tbl_idx;
+
+ us_pno_tbl_idx = g_stdelivery_pno_tbl_dr.us_dnum;
+ g_stdelivery_pno_tbl_dr.st_pno_data[us_pno_tbl_idx].us_pno = \
+ g_stdelivery_ctrl_tbl_dr.st_ctrl_data[us_index].us_pno;
+ g_stdelivery_pno_tbl_dr.st_pno_data[us_pno_tbl_idx].us_pkg_start_idx = \
+ g_stdelivery_ctrl_tbl_dr.st_ctrl_data[us_index].us_pkg_start_idx;
+ g_stdelivery_pno_tbl_dr.st_pno_data[us_pno_tbl_idx].us_pkg_end_idx = \
+ g_stdelivery_ctrl_tbl_dr.st_ctrl_data[us_index].us_pkg_end_idx;
+ g_stdelivery_pno_tbl_dr.st_pno_data[us_pno_tbl_idx].uc_method = \
+ g_stdelivery_ctrl_tbl_dr.st_ctrl_data[us_index].uc_method;
+ g_stdelivery_pno_tbl_dr.us_dnum++;
+}
+// LCOV_EXCL_STOP
+
+/*******************************************************************************
+* MODULE : VehicleSensAddDeliveryCtrlTblDR
+* ABSTRACT : Vehicle sensor DR internal delivery destination management table addition function
+* FUNCTION : Add to the DR internal shipping management table.
+* ARGUMENT : *pst_delivery_entry : Pointer to the delivery registration information
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensAddDeliveryCtrlTblDR(const DEADRECKONING_MSG_DELIVERY_ENTRY *pst_delivery_entry) { // LCOV_EXCL_START 8: dead code // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ VEHICLESENS_DELIVERY_CTRL_TBL_DATA *pst_ctrl_data;
+
+ pst_ctrl_data = &g_stdelivery_ctrl_tbl_dr.st_ctrl_data[g_stdelivery_ctrl_tbl_dr.us_dnum];
+ pst_ctrl_data->ul_did = pst_delivery_entry->data.did;
+ pst_ctrl_data->us_pno = pst_delivery_entry->data.pno;
+ pst_ctrl_data->uc_chg_type = pst_delivery_entry->data.delivery_timing;
+ pst_ctrl_data->uc_ctrl_flg = pst_delivery_entry->data.ctrl_flg;
+ pst_ctrl_data->us_link_idx = VEHICLESENS_LINK_INDEX_END;
+ pst_ctrl_data->us_pkg_start_idx = VEHICLESENS_LINK_INDEX_END;
+ pst_ctrl_data->us_pkg_end_idx = VEHICLESENS_LINK_INDEX_END;
+ pst_ctrl_data->uc_method = VEHICLESENS_DELIVERY_METHOD_NORMAL;
+ g_stdelivery_ctrl_tbl_dr.us_dnum = static_cast<u_int16>(g_stdelivery_ctrl_tbl_dr.us_dnum + 1);
+}
+// LCOV_EXCL_STOP
+
+/*******************************************************************************
+* MODULE : VehicleSensAddDeliveryCtrlTblMngDR
+* ABSTRACT : Internal delivery destination management table management addition function for vehicle sensor DR
+* FUNCTION : Add to the DR internal shipping management table management.
+* ARGUMENT : *pst_delivery_entry : Pointer to the delivery registration information
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensAddDeliveryCtrlTblMngDR(const DEADRECKONING_MSG_DELIVERY_ENTRY *pst_delivery_entry) { // LCOV_EXCL_START 8: dead code // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ VEHICLESENS_DELIVERY_CTRL_TBL_MNG_DATA *pst_ctrl_mng_data;
+
+ pst_ctrl_mng_data = &g_stdelivery_ctrl_tbl_mng_dr.st_ctrl_tbl_mng_data[g_stdelivery_ctrl_tbl_mng_dr.us_dnum];
+ pst_ctrl_mng_data->ul_did = pst_delivery_entry->data.did;
+ pst_ctrl_mng_data->us_start_idx = static_cast<u_int16>(g_stdelivery_ctrl_tbl_dr.us_dnum - 1);
+ pst_ctrl_mng_data->us_end_idx = static_cast<u_int16>(g_stdelivery_ctrl_tbl_dr.us_dnum - 1);
+ pst_ctrl_mng_data->usdlvry_entry_num++;
+ g_stdelivery_ctrl_tbl_mng_dr.us_dnum++;
+}
+// LCOV_EXCL_STOP
+
+/*******************************************************************************
+ * MODULE : VehicleSensUpdateDeliveryCtrlTblMngDR
+ * ABSTRACT : Internal delivery destination management table management update function for vehicle sensor DR
+ * FUNCTION : Update the internal delivery destination management table management for DR.
+ * ARGUMENT : *pst_existing_mng_data : Pointer to the previous data information with the same data ID
+ * NOTE :
+ * RETURN : void
+ ******************************************************************************/
+void VehicleSensUpdateDeliveryCtrlTblMngDR(VEHICLESENS_DELIVERY_CTRL_TBL_MNG_DATA *pst_existing_mng_data) { // LCOV_EXCL_START 8: dead code // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ /* Update only the end index and the number of registered shipping destinations. */
+ pst_existing_mng_data->us_end_idx = static_cast<u_int16>(g_stdelivery_ctrl_tbl_dr.us_dnum - 1);
+ pst_existing_mng_data->usdlvry_entry_num++;
+}
+// LCOV_EXCL_STOP
+
+/*******************************************************************************
+* MODULE : VehicleSensUpdateDeliveryCtrlTblDR
+* ABSTRACT : Vehicle sensor DR internal delivery destination management table update function
+* FUNCTION : Update the internal distribution destination management table for DR.
+* ARGUMENT : *pst_existing_mng_data : Pointer to the previous data information with the same data ID
+* NOTE :
+* RETURN : void
+******************************************************************************/
+void VehicleSensUpdateDeliveryCtrlTblDR(VEHICLESENS_DELIVERY_CTRL_TBL_MNG_DATA *pst_existing_mng_data) { // LCOV_EXCL_START 8: dead code // NOLINT(whitespace/line_length)
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ /* Update Link Index Only.
+ For indexes of usEndIdx values matching the data IDs in the target management table
+ Making usLinkIdx an Index-Registered Index */
+ g_stdelivery_ctrl_tbl_dr.st_ctrl_data[pst_existing_mng_data->us_end_idx].us_link_idx =
+ static_cast<u_int16>(g_stdelivery_ctrl_tbl_dr.us_dnum - 1);
+}
+// LCOV_EXCL_STOP
+
+/*******************************************************************************
+ * MODULE : VehicleSensDeliveryProcDR
+ * ABSTRACT : Internal Data Delivery Process for Vehicle Sensor DR
+ * FUNCTION : Deliver data to internal DR destinations.
+ * ARGUMENT : ul_did :Data ID
+ * uc_chg_type :Delivery timing
+ * uc_get_method :Acquisition method
+ * NOTE :
+ * RETURN : void
+ ******************************************************************************/
+void VehicleSensDeliveryProcDR(DID ul_did, u_int8 uc_chg_type, u_int8 uc_get_method) {
+ return;
+}
+
+/**
+ * @brief
+ * Obtain dump info(g_stdelivery_ctrl_tbl)
+ *
+ * @param[out] pbuf Dump information
+ */
+void VehicleSensGetDebugDeliveryCtrlTbl(void* pbuf) { // LCOV_EXCL_START 7: uesd only in FrameworkunifiedOnDebugDump
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ static uint8_t buf[DEBUG_DUMP_MAX_SIZE];
+ static uint8_t bufTmp[256];
+ u_int16 i;
+
+ memset(&buf, 0x00, sizeof(buf));
+ snprintf(reinterpret_cast<char *>(&(buf)),
+ 32,
+ "Delivery-Tbl\n DNum:%d", g_stdelivery_ctrl_tbl.us_dnum);
+ for (i = 0; i < g_stdelivery_ctrl_tbl.us_dnum; i++) {
+ if (i >= 30) {
+ break;
+ }
+ memset(&bufTmp[0], 0x00, sizeof(bufTmp));
+ snprintf(reinterpret_cast<char *>(&bufTmp[0]), sizeof(bufTmp),
+ "\n [%02d] did:0x%08x, pno:0x%04x, chgT:0x%02x, ctrlFg:0x%02x, "\
+ "lnkidx:0x%04x, pkgSidx:0x%04x, pkgEidx:0x%04x, Mth:0x%02x",
+ i,
+ g_stdelivery_ctrl_tbl.st_ctrl_data[i].ul_did,
+ g_stdelivery_ctrl_tbl.st_ctrl_data[i].us_pno,
+ g_stdelivery_ctrl_tbl.st_ctrl_data[i].uc_chg_type,
+ g_stdelivery_ctrl_tbl.st_ctrl_data[i].uc_ctrl_flg,
+ g_stdelivery_ctrl_tbl.st_ctrl_data[i].us_link_idx,
+ g_stdelivery_ctrl_tbl.st_ctrl_data[i].us_pkg_start_idx,
+ g_stdelivery_ctrl_tbl.st_ctrl_data[i].us_pkg_end_idx,
+ g_stdelivery_ctrl_tbl.st_ctrl_data[i].uc_method);
+ _pb_strcat(reinterpret_cast<char *>(&buf[0]), reinterpret_cast<char *>(&bufTmp[0]), sizeof(bufTmp));
+ }
+ memcpy(pbuf, &buf[0], sizeof(buf));
+ return;
+}
+// LCOV_EXCL_STOP
+
+/**
+ * @brief
+ * Obtain dump info(g_stdelivery_ctrl_tbl_mng)
+ *
+ * @param[out] pbuf Dump information
+ */
+void VehicleSensGetDebugDeliveryCtrlTblMng(void* pbuf) { // LCOV_EXCL_START 7: uesd only in FrameworkunifiedOnDebugDump
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ static uint8_t buf[DEBUG_DUMP_MAX_SIZE];
+ static uint8_t bufTmp[256];
+ u_int16 i;
+
+ memset(&buf, 0x00, sizeof(buf));
+ snprintf(reinterpret_cast<char *>(&(buf)),
+ 32,
+ "Delivery-TblMng\n DNum:%d",
+ g_stdelivery_ctrl_tbl_mng.us_dnum);
+ for (i = 0; i < g_stdelivery_ctrl_tbl_mng.us_dnum; i++) {
+ if (i >= 60) {
+ break;
+ }
+ memset(&bufTmp[0], 0x00, sizeof(bufTmp));
+ snprintf(reinterpret_cast<char *>(&bufTmp[0]), sizeof(bufTmp),
+ "\n [%02d] did:0x%08x, Sidx:0x%04x, Eidx:0x%04x, EntNum:0x%04x",
+ i,
+ g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data[i].ul_did,
+ g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data[i].us_start_idx,
+ g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data[i].us_end_idx,
+ g_stdelivery_ctrl_tbl_mng.st_ctrl_tbl_mng_data[i].usdlvry_entry_num);
+ _pb_strcat(reinterpret_cast<char *>(&buf[0]), reinterpret_cast<char *>(&bufTmp[0]), sizeof(bufTmp));
+ }
+ memcpy(pbuf, &buf[0], sizeof(buf));
+ return;
+}
+// LCOV_EXCL_STOP
+
+/**
+ * @brief
+ * Obtain dump info(g_stpkgdelivery_tbl_mng)
+ *
+ * @param[out] pbuf Dump information
+ */
+void VehicleSensGetDebugPkgDeliveryTblMng(void* pbuf) { // LCOV_EXCL_START 7: uesd only in FrameworkunifiedOnDebugDump
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ static uint8_t buf[DEBUG_DUMP_MAX_SIZE];
+ static uint8_t bufTmp[256];
+ u_int16 i;
+
+ memset(&buf, 0x00, sizeof(buf));
+ snprintf(reinterpret_cast<char *>(&(buf)),
+ 32,
+ "Delivery-PkgTblMng\n DNum:%d",
+ g_stpkgdelivery_tbl_mng.us_dnum);
+ for (i = 0; i < g_stpkgdelivery_tbl_mng.us_dnum; i++) {
+ if (i >= 100) {
+ break;
+ }
+ memset(&bufTmp[0], 0x00, sizeof(bufTmp));
+ snprintf(reinterpret_cast<char *>(&bufTmp[0]), sizeof(bufTmp),
+ "\n [%02d] did:0x%08x, Didx:0x%04x",
+ i,
+ g_stpkgdelivery_tbl_mng.st_pkg_data[i].ul_did,
+ g_stpkgdelivery_tbl_mng.st_pkg_data[i].usdlvry_idx);
+ _pb_strcat(reinterpret_cast<char *>(&buf[0]), reinterpret_cast<char *>(&bufTmp[0]), sizeof(bufTmp));
+ }
+ memcpy(pbuf, &buf[0], sizeof(buf));
+ return;
+}
+// LCOV_EXCL_STOP
+
+/**
+ * @brief
+ * Obtain dump info(g_stdelivery_pno_tbl)
+ *
+ * @param[out] pbuf Dump information
+ */
+void VehicleSensGetDebugDeliveryPnoTbl(void* pbuf) { // LCOV_EXCL_START 7: uesd only in FrameworkunifiedOnDebugDump
+ AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert
+ static uint8_t buf[DEBUG_DUMP_MAX_SIZE];
+ static uint8_t bufTmp[256];
+ u_int16 i;
+
+ memset(&buf, 0x00, sizeof(buf));
+ snprintf(reinterpret_cast<char *>(&(buf)),
+ 32,
+ "Delivery-PnoTbl\n DNum:%d",
+ g_stdelivery_pno_tbl.us_dnum);
+ for (i = 0; i < g_stdelivery_pno_tbl.us_dnum; i++) {
+ if (i >= 60) {
+ break;
+ }
+ memset(&bufTmp[0], 0x00, sizeof(bufTmp));
+ snprintf(reinterpret_cast<char *>(&bufTmp[0]), sizeof(bufTmp),
+ "\n [%02d] pno:0x%04x, pkgSidx:0x%04x, pkgEidx:0x%04x, Mth:0x%02x",
+ i,
+ g_stdelivery_pno_tbl.st_pno_data[i].us_pno,
+ g_stdelivery_pno_tbl.st_pno_data[i].us_pkg_start_idx,
+ g_stdelivery_pno_tbl.st_pno_data[i].us_pkg_end_idx,
+ g_stdelivery_pno_tbl.st_pno_data[i].uc_method);
+ _pb_strcat(reinterpret_cast<char *>(&buf[0]), reinterpret_cast<char *>(&bufTmp[0]), sizeof(bufTmp));
+ }
+ memcpy(pbuf, &buf[0], sizeof(buf));
+ return;
+}
+// LCOV_EXCL_STOP
+/* -- PastModel002 support DR */
Code Review / staging / basesystem.git / blobdiff