From 947c78887e791596d4a5ec2d1079f8b1a049628b Mon Sep 17 00:00:00 2001 From: takeshi_hoshina Date: Tue, 27 Oct 2020 11:16:21 +0900 Subject: basesystem 0.1 --- .../server/src/Sensor/VehicleSens_DeliveryCtrl.cpp | 2243 ++++++++++++++++++++ 1 file changed, 2243 insertions(+) create mode 100644 vehicleservice/positioning/server/src/Sensor/VehicleSens_DeliveryCtrl.cpp (limited to 'vehicleservice/positioning/server/src/Sensor/VehicleSens_DeliveryCtrl.cpp') diff --git a/vehicleservice/positioning/server/src/Sensor/VehicleSens_DeliveryCtrl.cpp b/vehicleservice/positioning/server/src/Sensor/VehicleSens_DeliveryCtrl.cpp new file mode 100644 index 00000000..15aabffe --- /dev/null +++ b/vehicleservice/positioning/server/src/Sensor/VehicleSens_DeliveryCtrl.cpp @@ -0,0 +1,2243 @@ +/* + * @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 +#include +#include +#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(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(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(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(g_stdelivery_ctrl_tbl.us_dnum - 1); + /* Ignore->MISRA-C++:2008 Rule 5-0-5 */ + pst_ctrl_mng_data->us_end_idx = static_cast(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(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(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(us_next_offset & ~us_boundary_adj); + us_next_offset = static_cast(us_next_offset + (u_int16)VEHICLESENS_BIT2); /* Add numbers */ + } + us_size = static_cast(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(&st_delivery_entry), + static_cast(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( + (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(&delivery_data), + reinterpret_cast(&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(&delivery_data); + /* Acquire the applicable data information from the data master..*/ + VehicleSensGetDataMaster(ul_did, uc_current_get_method, stmaster); + (void)memcpy(reinterpret_cast(&(plonlat_msg->data)), + reinterpret_cast(&(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(&delivery_data); + /* Acquire the applicable data information from the data master..*/ + VehicleSensGetDataMaster(ul_did, uc_get_method, stmaster); + (void)memcpy(reinterpret_cast(&(paltitude_msg->data)), + reinterpret_cast(&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(&delivery_data); + /* Acquire the applicable data information from the data master..*/ + VehicleSensGetDataMaster(ul_did, uc_get_method, stmaster); + (void)memcpy(reinterpret_cast(&(pheading_msg->data)), + reinterpret_cast(&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(&delivery_data.data[0]), + reinterpret_cast(&gps_master.uc_data[0]), + (size_t)delivery_data.header.size); + + length = static_cast((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), + 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(&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(&(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(&st_master_fst), + 0, + sizeof(VEHICLESENS_DATA_MASTER_FST)); + (void)memset(reinterpret_cast(&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(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(&(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(&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(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(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(&(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(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(&(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(&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(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(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(&(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(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(&(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(&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(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(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(&(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(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(&(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(&(st_msg_gyro_trouble_info.gyro_trouble)), + reinterpret_cast(&(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(&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(&delivery_data.data[0]), + reinterpret_cast(&gps_antenna_status.uc_data), + (size_t)delivery_data.header.size); + + length = static_cast(static_cast(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(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), + (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(&(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(&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(&st_pkg_master.ucData[us_offset])); + } + else { + VehicleSensGetDataMaster(ul_pkg_did, uc_current_get_method, + reinterpret_cast(&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(us_next_offset & ~us_boundary_adj); + /* Add numbers */ + us_next_offset = static_cast(us_next_offset + (u_int16) VEHICLESENS_BIT2); + } + us_offset = static_cast(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(&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(&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(&(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(stmaster_fst), 0, sizeof(VEHICLESENS_DATA_MASTER_FST)); + (void)memset(reinterpret_cast(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(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(&(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(&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(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(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(&(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(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(&(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(&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(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(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(&(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(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(&(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(&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(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(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(&(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(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(&(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(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), + (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(&(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(&delivery_data), + reinterpret_cast(&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(&delivery_data); + /* Acquire the applicable data information from the data master..*/ + VehicleSensGetDataMaster(ul_did, uc_get_method, &stmaster); + (void)memcpy(reinterpret_cast(&(pLonLatMsg->data)), + reinterpret_cast(&(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(&delivery_data); + /* Acquire the applicable data information from the data master..*/ + VehicleSensGetDataMaster(ul_did, uc_get_method, &stmaster); + (void)memcpy(reinterpret_cast(&(pAltitudeMsg->data)), + reinterpret_cast(&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(&delivery_data); + /* Acquire the applicable data information from the data master..*/ + VehicleSensGetDataMaster(ul_did, uc_get_method, &stmaster); + (void)memcpy(reinterpret_cast(&(pHeadingMsg->data)), + reinterpret_cast(&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(&delivery_data.data[0]), + reinterpret_cast(&gps_master.uc_data[0]), + (size_t)delivery_data.header.size); + + length = static_cast((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), + 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(&delivery_data), senslog_len, uc_result); + } else { + SensLogWriteOutputData(SENSLOG_DATA_O_UNSPECIFIED, ul_did, us_pno, + reinterpret_cast(&(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(&(st_msg_gyro_trouble_info.gyro_trouble)), + reinterpret_cast(&(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(&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(&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(&(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(&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(&st_pkg_master.ucData[us_offset])); + } else { + VehicleSensGetDataMaster(ul_pkg_did, + uc_get_method, + reinterpret_cast(&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(us_next_offset & ~us_boundary_adj); /* Mask Lower Bit */ + us_next_offset = static_cast(us_next_offset + (u_int16)VEHICLESENS_BIT2); /* Add numbers */ + } + us_offset = static_cast(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(&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(&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((usDataCnt[i] / VEHICLESENS_PKG_EXT_SEND_MAX_10DATA) + 1); + } else { + ucDivide100Cnt = static_cast(usDataCnt[i] / VEHICLESENS_PKG_EXT_SEND_MAX_10DATA); + } + } + } + } + /* All-data undelivered flag holding Ignore->MISRA-C ++: 2008 Rule 5-0-5 */ + ucDataBreak = static_cast(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((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(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(&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(&stPkgMaster.ucData[usOffset]), + reinterpret_cast(&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)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(&stPkgMaster.ucData[usOffset + 8]), + reinterpret_cast(&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(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)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(&stPkgMaster.ucData[usOffset + 8]), + reinterpret_cast(&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)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(&stPkgMaster.ucData[usOffset + 8]), + reinterpret_cast(&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(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)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(&stPkgMaster.ucData[usOffset + 8]), + reinterpret_cast(&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(usNextOffset & ~usBoundaryAdj); + usNextOffset = static_cast(usNextOffset + (u_int16)VEHICLESENS_BIT2); /* Add numbers */ + } + usOffset = static_cast(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(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(&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( + (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(&g_stdelivery_pno_tbl_dr), + static_cast(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(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(g_stdelivery_ctrl_tbl_dr.us_dnum - 1); + pst_ctrl_mng_data->us_end_idx = static_cast(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(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(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(&(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(&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(&buf[0]), reinterpret_cast(&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(&(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(&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(&buf[0]), reinterpret_cast(&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(&(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(&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(&buf[0]), reinterpret_cast(&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(&(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(&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(&buf[0]), reinterpret_cast(&bufTmp[0]), sizeof(bufTmp)); + } + memcpy(pbuf, &buf[0], sizeof(buf)); + return; +} +// LCOV_EXCL_STOP +/* -- PastModel002 support DR */ -- cgit 1.2.3-korg