diff options
Diffstat (limited to 'communication/server/src/CAN/CommWatch')
-rw-r--r-- | communication/server/src/CAN/CommWatch/CAN_CommWatch.cpp | 406 | ||||
-rw-r--r-- | communication/server/src/CAN/CommWatch/CAN_CommWatchData.cpp | 447 |
2 files changed, 189 insertions, 664 deletions
diff --git a/communication/server/src/CAN/CommWatch/CAN_CommWatch.cpp b/communication/server/src/CAN/CommWatch/CAN_CommWatch.cpp index abb727bd..2ece1072 100644 --- a/communication/server/src/CAN/CommWatch/CAN_CommWatch.cpp +++ b/communication/server/src/CAN/CommWatch/CAN_CommWatch.cpp @@ -1,5 +1,5 @@ /* - * @copyright Copyright (c) 2016-2019 TOYOTA MOTOR CORPORATION. + * @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. @@ -14,255 +14,227 @@ * limitations under the License. */ -/******************************************************************************* - * FILE :CAN_CommWatch.cpp - * SYSTEM :_CWORD107_ - * SUBSYSTEM :EXL process - * PROGRAM :CAN Thread CAN Data Communication Disruption Monitoring Management Process - * Module configuration :CANCommWatchTimeoutMsg() CANDataCommunication Disruption Timeout Message Processing - * :CAN_CommWatch() CANDataCommunication Disruption Monitoring Message Processing - * :CANCommWatchClear() CANDataCommunication interruption clear processing - * :CANVehicleInfoMsg() Vehicle sensor information notification message processing - * :CANIgStatGet() IG reception status acquisition processing - ******************************************************************************/ #include "CAN_CommWatch.h" -#include <native_service/frameworkunified_types.h> // NOLINT (build/include) +#include <native_service/frameworkunified_types.h> #include <native_service/frameworkunified_framework_if.h> - #include <peripheral_service/Canif_API.h> +#include <utility> +#include <map> +#include <string> #include "CAN_Thread.h" -#include "CAN_CommWatchData.h" -#include "CAN_TxMsg.h" -#include "CAN_TimerCtrl.h" - -/*************************************************/ -/* Global variable */ -/*************************************************/ - -static uint8_t g_uc_comm_watch_ig_stat; /* IG receive mode */ - -/******************************************************************************* - * MODULE : CANCommWatchInit - * ABSTRACT : CANDataCommunication Disruption Monitoring Initialization Process - * FUNCTION : CANDataInitialize communication interruption monitoring - * ARGUMENT : void - * NOTE : - * RETURN : void - ******************************************************************************/ +#include "Thread_Common.h" + +static CAN_CommWatchTable g_map_comm_watch_list_can; + void CANCommWatchInit(void) { - g_uc_comm_watch_ig_stat = CAN_COMM_IG_NORCV; /* Initialization of IG reception status */ + g_map_comm_watch_list_can.clear(); + return; } -/******************************************************************************* - * MODULE : CANCommWatchTimeoutMsg - * ABSTRACT : CANDataCommunication Disruption Timeout Message Processing - * FUNCTION : Send communication interruption message when communication interruption of monitored CAN data is detected. - * ARGUMENT : us_timer_seq_no : Timer sequence number that timed out - * NOTE : - * RETURN : RET_CAN_NORMAL :Normal completion - * : RET_CAN_ERROR_CANCEL :Data destruction - ******************************************************************************/ -RET_CAN CANCommWatchTimeoutMsg(HANDLE h_app, uint16_t us_timer_seq_no) { - RET_CAN ret = RET_CAN_ERROR_CANCEL; /* Return value of this function */ - uint8_t uc_index; /* Index of the corresponding timer sequence number */ - uint8_t uc_comm_stop; /* Communication status of the corresponding timer sequence number */ - - /* Determine whether communication interruption monitoring of the corresponding sequence number is registered. */ - /* Timer Sequence Number Search*/ - if (TRUE == CANCommWatchTimerSeqNoEntryCheck(us_timer_seq_no, &uc_index, &uc_comm_stop, CAN_PROTOCOL_TYPE_CAN)) { - /* Determining whether communication is in progress */ - if ((uint8_t)CAN_COMM_NORMAL == uc_comm_stop) { - /* Change the communication status to "Communication interrupted" */ - (void)CANCommWatchCtrl(uc_index, CAN_COMM_STOP, CAN_PROTOCOL_TYPE_CAN); /* Communication interruption state control processing */ - - /* Send Communication Disruption Detection Message */ - (void)CANCommWatchSndMsg(h_app, uc_index); /* Transmission of communication interruption detection/recovery message */ - - ret = RET_CAN_NORMAL; +static CAN_CommWatchTableIt CANCommWatchFind(CANID k, CAN_COMM_WATCH_VAL *val) { + std::pair<CAN_CommWatchTableIt, CAN_CommWatchTableIt> range; + CAN_CommWatchTableIt it; + bool found = false; + + range = g_map_comm_watch_list_can.equal_range(k); + for (it = range.first; it != range.second; it++) { + if (!memcmp(&(it->second.notify_name), + val->notify_name, sizeof(val->notify_name))) { + found = true; + break; } } - return (ret); + if (!found) + it = g_map_comm_watch_list_can.end(); + + return it; } -/******************************************************************************* - * MODULE : CANCommWatch - * ABSTRACT : CANDataCommunication Disruption Monitoring Message Processing - * FUNCTION : CANDataRegister/delete communication disruption monitoring management table - * ARGUMENT : pst_rcv_msg :Received Message Reference Pointer - * NOTE : - * RETURN : RET_CAN_NORMAL :Normal completion - * : RET_CAN_ERROR_SNDID :Distribution destination ID mismatch - * : RET_CAN_ERROR_UNDEF :Unregistered ID - * : RET_CAN_ERROR_TIMER :Timer acquisition failed - * : RET_CAN_ERROR_BUFFULL :Communication Disruption Monitoring Registered Number FULL - ******************************************************************************/ -EFrameworkunifiedStatus CANCommWatch(HANDLE h_app) { - return CANCommWatchCore(h_app, CAN_PROTOCOL_TYPE_CAN); +static bool CANCommWatchInsert(CANID k, CAN_COMM_WATCH_VAL *val) { + CAN_CommWatchTableIt it = CANCommWatchFind(k, val); + CAN_CommWatchTablePair p = std::make_pair((const CANID)k, *val); + bool inserted = false; + + if (it == g_map_comm_watch_list_can.end()) { + g_map_comm_watch_list_can.insert(p); + inserted = true; + } + return inserted; } -EFrameworkunifiedStatus CANCommWatchCore(HANDLE h_app, CAN_PROTOCOL_TYPE mode) { - RET_CAN ret = RET_CAN_NORMAL; /* Return value of this function */ - uint8_t uc_cnt; /* Generic counters */ - uint8_t uc_index; /* Indexed */ - uint8_t uc_comm_stop = CAN_COMM_OFF; /* Communication status */ - BOOL b_id_flag = FALSE; /* Variables for Stopping Monitoring */ /* ID match flag */ - BOOL b_snd_id_flag = FALSE; /* Variables for Stopping Monitoring */ /* Destination ID match flag */ - uint16_t us_timer_seq_no; /* Variables for Starting Monitoring */ /* Acquisition Timer Sequence Number */ - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - CAN_COMM_WATCHEXT_MSG_DAT rcv_msg; +static void CANCommWatchUpdate(HANDLE h_app, CANID key, + CAN_COMM_WATCH_VAL *val) { + if (CANCommWatchInsert(key, val)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "Can CommWatch : " + "Entry (CANID=%x, DataID=%x, dst=%s, time=%d, cnt=%lu)", + key, val->data_id, + val->notify_name, val->set_time, + g_map_comm_watch_list_can.size()); + } else { + CAN_CommWatchTableIt it = CANCommWatchFind(key, val); + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "Can CommWatch : Update the time " + "(CANID=%x, DataID=%x, dst=%s, time:%d -> %d, cnt =%lu)", + key, val->data_id, val->notify_name, + it->second.set_time, val->set_time, + g_map_comm_watch_list_can.size()); + it->second.comm_watch_flag = val->comm_watch_flag; + it->second.set_time = val->set_time; + it->second.timer_cnt = val->timer_cnt; + it->second.data_id = val->data_id; + } + + return; +} + +static void CANCommWatchStop(HANDLE h_app, CANID key, + CAN_COMM_WATCH_VAL *val) { + CAN_CommWatchTableIt it = CANCommWatchFind(key, val); + if (it != g_map_comm_watch_list_can.end()) { + g_map_comm_watch_list_can.erase(it); + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "Can CommWatch : Stop the commwatch" + "(CANID=%x, dst=%s, cnt=%lu)", + key, val->notify_name, g_map_comm_watch_list_can.size()); + } + + return; +} - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### CAN COMMWATCH START #####"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) +EFrameworkunifiedStatus CANCommWatch(HANDLE h_app) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __func__, "@@@ Start communication CanCommWatch"); + + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; + CAN_COMM_WATCHEXT_MSG_DAT rcv_msg; + CANID key; + CAN_COMM_WATCH_VAL val; + CAN_CommWatchTableIt it; + memset(&rcv_msg, 0, sizeof(rcv_msg)); + memset(&val, 0, sizeof(val)); e_status = FrameworkunifiedGetMsgDataOfSize(h_app, &rcv_msg, sizeof(rcv_msg), eSMRRelease); - if (e_status != eFrameworkunifiedStatusOK) { // LCOV_EXCL_BR_LINE 4: NSFW error case. - // LCOV_EXCL_START 4: NSFW error case. - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# FrameworkunifiedGetMsgDataOfSize Error"); + if (e_status != eFrameworkunifiedStatusOK) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedGetMsgDataOfSize Error(%d)", e_status); if (e_status == eFrameworkunifiedStatusInvldBufSize) { FrameworkunifiedClearMsgData(h_app); } - ret = RET_CAN_ERROR_CANCEL; - goto exit; + goto cleanup; } - // LCOV_EXCL_STOP 4: NSFW error case. - - /* Monitor Registration/Suspension Determination */ - if ((uint16_t)0 == rcv_msg.usWatchTime) { /* Is the communication interruption time zero? */ - /*** Suspend Monitoring(Communication interruption time = 0) ***/ - - /* Is the delivery destination ID and CANID, DID registered in the disruption monitoring table? */ - for (uc_cnt = 0; uc_cnt < (uint8_t)COMM_WATCH_LIST_NUM; uc_cnt++) { - /* Are data with matching CANID and data IDs registered? ? */ - if (FALSE == CANCommWatchCanidDidEntryCheck(uc_cnt, rcv_msg.ulCanid, rcv_msg.ulDid, mode)) { - continue; - } - b_id_flag = TRUE; /* Set the ID match flag */ - - /* Does the shipping ID match? */ - if (FALSE == CANCommWatchSndCheck(uc_cnt, rcv_msg.notifyName, mode)) { - continue; - } - b_snd_id_flag = TRUE; /* Set the delivery destination ID match flag */ - uc_index = uc_cnt; /* Store the index subject to monitoring termination. */ - break; - } - if (TRUE != b_id_flag) { /* No matching data */ - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN CommWatchStop CanID Error"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - ret = RET_CAN_ERROR_UNDEF; /* Undefined ID error */ - goto exit; - } - if (TRUE != b_snd_id_flag) { /* Distribution destination ID mismatch */ - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN CommWatchStop SNDID Error"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - ret = RET_CAN_ERROR_SNDID; /* Distribution destination ID mismatch */ - goto exit; - } + // Create search data + key = rcv_msg.ulCanid; + snprintf(val.notify_name, sizeof(val.notify_name), "%s", rcv_msg.notifyName); + val.data_id = rcv_msg.ulDid; + val.comm_watch_flag = CAN_COMM_NORMAL; + val.set_time = rcv_msg.usWatchTime; + val.timer_cnt = rcv_msg.usWatchTime; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, + "CAN CommWatch : dst=%s, CANID=%x, dataID=%x, time=%d", + rcv_msg.notifyName, + rcv_msg.ulCanid, + rcv_msg.ulDid, rcv_msg.usWatchTime); + + if (0 == rcv_msg.usWatchTime) { + CANCommWatchStop(h_app, key, &val); + } else { + CANCommWatchUpdate(h_app, key, &val); + } + e_status = eFrameworkunifiedStatusOK; +cleanup: + return e_status; +} - /* Suspend Monitoring */ - /* Communication interruption timer stop processing */ - if (RET_CAN_NORMAL == CANCommWatchTimerStop(uc_index, mode)) { // LCOV_EXCL_BR_LINE 200:the function is always returned to RET_CAN_NORMAL //NOLINT (readability/naming) - /* Successful stop -> delete from communication disconnection monitoring management table */ - CANCommWatchDelete(uc_index, mode); - } +static EFrameworkunifiedStatus CANCommWatchSndMsg(HANDLE h_app, + CAN_COMM_WATCH_VAL *v, uint32_t cid) { + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; + CAN_MSG_COMM_WATCHSTS msg; + HANDLE h_client = NULL; + + memset(&msg, 0, sizeof(msg)); + msg.hdr.hdr.cid = (uint16_t)cid; + msg.hdr.hdr.msgbodysize = sizeof(CAN_MSG_COMM_WATCHSTS_DAT); + msg.hdr.hdr.rid = 0; + msg.data.ulDid = v->data_id; + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "cid=%x msgbodysize=%x ulDid=%x", + msg.hdr.hdr.cid, msg.hdr.hdr.msgbodysize, msg.data.ulDid); + + h_client = CommonFindSender(h_app, v->notify_name); + if (!h_client){ + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "CommonFindSender failed"); + goto cleanup; + } + + e_status = FrameworkunifiedSendMsg(h_client, cid, sizeof(msg), &msg); + if (e_status != eFrameworkunifiedStatusOK) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, + "FrameworkunifiedSendMSg Error(e_status:%d to %s)", + e_status, v->notify_name); + goto cleanup; + } + e_status = eFrameworkunifiedStatusOK; +cleanup: + return e_status; +} + +static void CANCommWatchTimeoutCore(HANDLE h_app, CAN_COMM_WATCH_VAL *v) { + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; + + if (CAN_COMM_NORMAL != v->comm_watch_flag) + return; + + if (v->timer_cnt != 0) + v->timer_cnt--; + + if (v->timer_cnt != 0) + return; + + e_status = CANCommWatchSndMsg(h_app, v, CID_CAN_COMM_STOP); + if (eFrameworkunifiedStatusOK == e_status) { + v->comm_watch_flag = CAN_COMM_STOP; } else { - /* Storage status can be checked? */ - /* No free space */ - if (TRUE != CANCommWatchEntryCheck(rcv_msg.ulCanid, rcv_msg.ulDid, rcv_msg.notifyName, &uc_index, mode)) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN CommWatch BufferFull"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - ret = RET_CAN_ERROR_BUFFULL; - goto exit; - } + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "CANCommWatchSndMsg failed"); + // retry at next timeout. + } +} - /* Timer stop */ - (void)CANCommWatchTimerStop(uc_index, mode); - - /* IG linkage OFF or IG linkage ON and IG reception in progress */ - if ((rcv_msg.ucIg == (uint8_t)CAN_IG_COOPERATION_OFF) || ((rcv_msg.ucIg == (uint8_t)CAN_IG_COOPERATION_ON) && (g_uc_comm_watch_ig_stat == (uint8_t)CAN_COMM_IG_ON))) { // LCOV_EXCL_BR_LINE 200: rcv_msg.ucIg is always be CAN_IG_COOPERATION_OFF //NOLINT (readability/naming) - /* Timer activation */ - /* Communication interruption monitoring timer start processing */ - if (RET_CAN_NORMAL != CANCommWatchTimerStart(uc_index, rcv_msg.usWatchTime, mode)) { // LCOV_EXCL_BR_LINE 200:the function is always returned to RET_CAN_NORMAL //NOLINT (readability/naming) - // LCOV_EXCL_START 200: the function is always returned to RET_CAN_NORMAL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - ret = RET_CAN_ERROR_TIMER; /* Timer start failure -> Return value setting: Timer acquisition error */ - goto exit; - } // LCOV_EXCL_STOP 200: the function is always returned to RET_CAN_NORMAL - /* Communication type = set during communication */ - uc_comm_stop = CAN_COMM_NORMAL; - } +EFrameworkunifiedStatus CANCommWatchTimeout(HANDLE h_app) { + CAN_CommWatchTableIt it; - /* Timer sequence number acquisition */ - us_timer_seq_no = CANCommWatchTimerSeqNoGet(uc_index, mode); - /* CANDataCommunication Disruption Monitoring Management Table Registration Process */ - CANCommWatchEntry(uc_index, &rcv_msg, us_timer_seq_no, uc_comm_stop, mode); + for (it = g_map_comm_watch_list_can.begin(); + it != g_map_comm_watch_list_can.end(); it++) { + CANCommWatchTimeoutCore(h_app, &(it->second)); } -exit: - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "END(ret=%x)", ret); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - if (ret == RET_CAN_NORMAL) - return eFrameworkunifiedStatusOK; - else - return eFrameworkunifiedStatusFail; - // return RET_CAN_NORMAL; + return eFrameworkunifiedStatusOK; } -/******************************************************************************* - * MODULE : CANCommWatchClear - * ABSTRACT : CANDataCommunication interruption clear processing - * FUNCTION : Sends a communication recovery message and restarts the timer. - * ARGUMENT : can_id :Received CAN ID - * NOTE : - * RETURN : void - ******************************************************************************/ -void CANCommWatchClear(HANDLE h_app, CANID can_id) { - uint8_t uc_cnt; /* Counter */ - uint8_t uc_comm_stop; /* Communication status */ - BOOL ret; - uint16_t us_tbl_chk_cnt = 0; /* Number of effective data checks for communication disruption table */ - - /* Corresponding CAN ID retrieval in communication interruption monitoring control table */ - for (uc_cnt = 0; uc_cnt < (uint8_t)COMM_WATCH_LIST_NUM; uc_cnt++) { - ret = CANCommWatchCanidEntryCheck(uc_cnt, can_id, &uc_comm_stop, &us_tbl_chk_cnt, CAN_PROTOCOL_TYPE_CAN); - /* CAN ID matching ? */ - if (TRUE == ret) { - /* Is communication interrupted? */ - if ((uint8_t)CAN_COMM_STOP == uc_comm_stop) { - /* Change the communication state to "Communicating" */ - (void)CANCommWatchCtrl(uc_cnt, CAN_COMM_NORMAL, CAN_PROTOCOL_TYPE_CAN); /* Communication interruption state control processing */ - uc_comm_stop = CAN_COMM_NORMAL; - /* Send communication disruption recovery message */ - (void)CANCommWatchSndMsg(h_app, uc_cnt); /* Transmission of communication interruption detection/recovery message */ - } - - /* Timer restart only when communication status is in progress */ - if (uc_comm_stop == (uint8_t)CAN_COMM_NORMAL) { - /* Timer restart */ - (void)CANCommWatchTimerRenewal(uc_cnt, CAN_PROTOCOL_TYPE_CAN); /* Communication interruption monitoring timer update processing */ - } - } - /* Check for completion of retrieval of all valid table data */ - if (us_tbl_chk_cnt >= g_us_comm_watch_dat_cnt[CAN_PROTOCOL_TYPE_CAN]) { - /* Completion of retrieval of all valid data for the table */ - break; - } - } +static void CANCommWatchClearCore(HANDLE h_app, CANID id, + CAN_COMM_WATCH_VAL *v) { + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; - return; + v->timer_cnt = v->set_time; + + if (CAN_COMM_STOP != v->comm_watch_flag) + return; + + e_status = CANCommWatchSndMsg(h_app, v, CID_CAN_COMM_RESTORE); + if (eFrameworkunifiedStatusOK == e_status) { + v->comm_watch_flag = CAN_COMM_NORMAL; + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "Can CommWatch Clear : CANID=%x", id); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "CANCommWatchSndMsg failed"); + // retry at next timeout. + } } -/******************************************************************************* - * MODULE : CANIgStatGet - * ABSTRACT : IG reception status acquisition processing - * FUNCTION : Obtain IG reception information - * ARGUMENT : void - * NOTE : - * RETURN : IG Information Received - ******************************************************************************/ - -uint8_t CANIgStatGet(void) { // LCOV_EXCL_START 8: for dead code - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - return (g_uc_comm_watch_ig_stat); +void CANCommWatchClear(HANDLE h_app, CANID id) { + std::pair<CAN_CommWatchTableIt, CAN_CommWatchTableIt> range; + CAN_CommWatchTableIt it; + + range = g_map_comm_watch_list_can.equal_range(id); + for (it = range.first; it != range.second; it++) { + CANCommWatchClearCore(h_app, id, &(it->second)); + } } -// LCOV_EXCL_STOP diff --git a/communication/server/src/CAN/CommWatch/CAN_CommWatchData.cpp b/communication/server/src/CAN/CommWatch/CAN_CommWatchData.cpp deleted file mode 100644 index 8b5a4681..00000000 --- a/communication/server/src/CAN/CommWatch/CAN_CommWatchData.cpp +++ /dev/null @@ -1,447 +0,0 @@ -/* - * @copyright Copyright (c) 2016-2019 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 :CAN_CommWatchData.cpp - * SYSTEM :_CWORD107_ - * SUBSYSTEM :EXL process - * PROGRAM :CAN thread CAN data communication interruption monitoring data management - * Module configuration :Can_CommWatchData_Init() CAN Data Communication Disruption Monitoring Management Data Initialization Process - * :CANCommWatchCanidDidEntryCheck() CANDataCommunication Disruption Monitoring Control Table Registration Status Checking Process (CAN ID and DataID Retrieval) - * :CANCommWatchTimerSeqNoEntryCheck() CANDataCommunication Disruption Monitoring Management Table Registration Status Checking Process (Timer Sequence Number Search) - * :CANCommWatchEntryCheck() CANDataCommunication Disruption Monitoring Management Table Registration Destination Confirmation Process - * :CANCommWatchEntry() CANDataCommunication Disruption Monitoring Management Table Registration Process - * :CANCommWatchDelete() CANDataCommunication Disruption Monitoring Management Table Deletion Processing - * :CANCommWatchCtrl() Communication interruption state control processing - * :CANCommWatchDataGet() Communication interruption data acquisition process - * :CANCommWatchTimerSeqNoGet() Acquisition of Communication Disruption Monitor Timer Sequence Number - * :CANCommWatchTimerSeqNoRenwal() Communication interruption monitoring timer sequence number update processing - * :CANCommWatchSndCheck() CANDataCommunication Disruption Monitoring Management Table Delivery Destination ID Confirmation Process - * :CANCommWatchIgcoopGet() IG linkage information acquisition processing of the communication disruption monitoring management table - ******************************************************************************/ -#include "CAN_CommWatchData.h" - -#include <string.h> // NOLINT (build/include) -#include <native_service/frameworkunified_types.h> -#include <other_service/strlcpy.h> - -#include <peripheral_service/Canif_API.h> -#include "CAN_Thread.h" - -/*************************************************/ -/* Global variables */ -/*************************************************/ -/* Timer sequence number increment counter */ -static uint16_t g_us_comm_watch_timer_seq_no = COMM_WATICH_TIMER_SEQ_NO_MIN; -CAN_COMM_WATCH_DAT g_st_comm_watch_dat[CAN_PROTOCOL_TYPE_TERMINATE][COMM_WATCH_LIST_NUM]; /* Communication disruption monitoring management table */ -uint16_t g_us_comm_watch_dat_cnt[CAN_PROTOCOL_TYPE_TERMINATE]; /* Number of effective registrations of communication disruption monitoring management table */ - -/******************************************************************************* - * MODULE : CANCommWatchDataInit - * ABSTRACT : CANDataCommunication Disruption Monitoring Management Data Initialization Process - * FUNCTION : CANDataInitializing management data for communication disruption monitoring - * ARGUMENT : void - * NOTE : - * RETURN : void - ******************************************************************************/ -void CANCommWatchDataInit(void) { - for (int i = 0; i < CAN_PROTOCOL_TYPE_TERMINATE; i++) { - /* Communication disruption monitoring management table */ - memset(g_st_comm_watch_dat[i], 0x00, sizeof(CAN_COMM_WATCH_DAT) * COMM_WATCH_LIST_NUM); - g_us_comm_watch_dat_cnt[i] = 0; /* Number of effective registrations of communication disruption monitoring management table */ - } - return; -} - -/******************************************************************************* - * MODULE : CAN_CommWatchCanidDidIDEntryCheck - * ABSTRACT : CANDataCommunication Disruption Monitoring Control Table Registration Status Checking Process (CAN ID and DataID Retrieval) - * FUNCTION : Compares the specified indexes of the communication interruption monitoring control table with the CAN ID and data IDs. - * ARGUMENT : uc_index :Indexed - * can_id :CAN ID - * ul_did :Data ID - * NOTE : - * RETURN : TRUE :Data consistency - * FALSE :Data mismatch - ******************************************************************************/ -BOOL CANCommWatchCanidDidEntryCheck(uint8_t uc_index, CANID can_id, DID ul_did, CAN_PROTOCOL_TYPE mode) { - BOOL ret = FALSE; - CAN_COMM_WATCH_DAT *ptr = &g_st_comm_watch_dat[mode][uc_index]; - - /* Is the specified index monitoring interrupted? */ - if ((uint16_t)0 != ptr->us_watch_time) { - /* The CANID and data identifier of the named index data matches the arguments? */ - if (can_id == ptr->ul_can_id) { - if (ul_did == ptr->ul_did) { - ret = TRUE; - } - } - } - - return (ret); -} - -/******************************************************************************* - * MODULE : CANCommWatchTimerSeqNoEntryCheck - * ABSTRACT : CANDataCommunication Disruption Monitoring Management Table Registration Status Checking Process (Timer Sequence Number Search) - * FUNCTION : Returns the index of the communication interruption monitoring management table with the specified timer sequence number - * ARGUMENT : us_timer_seq_no :Search timer sequence number - * puc_index :Index return pointer - * puc_comm_stop :Communication status return pointer - * NOTE : - * RETURN : TRUE :Registered - * FALSE :No registration - ******************************************************************************/ -BOOL CANCommWatchTimerSeqNoEntryCheck(uint16_t us_timer_seq_no, uint8_t *puc_index, - uint8_t *puc_comm_stop, CAN_PROTOCOL_TYPE mode) { - uint32_t ul_cnt; - BOOL ret = FALSE; - CAN_COMM_WATCH_DAT *ptr = &g_st_comm_watch_dat[mode][0]; - - /* Timer Sequence Number Search */ - for (ul_cnt = 0; ul_cnt < COMM_WATCH_LIST_NUM; ul_cnt++) { - /* Is monitoring interrupted? */ - if ((uint16_t)0 != ptr[ul_cnt].us_watch_time) { - /* Match Timer Sequence Number */ - if (us_timer_seq_no == ptr[ul_cnt].us_timer_seq_no) { - ret = TRUE; - *puc_index = (uint8_t)ul_cnt; - *puc_comm_stop = ptr[ul_cnt].uc_comm_stop; - - break; - } - } - } - - return (ret); -} - -/******************************************************************************* - * MODULE : CANCommWatchEntryCheck - * ABSTRACT : CANDataCommunication Disruption Monitoring Management Table Registration Destination Confirmation Process - * FUNCTION : Returns the registerable index in the communication disconnection monitoring management table - * ARGUMENT : can_id :CAN ID - * ul_did :Data ID - * notifyId :Addresses for delivery ID - * puc_index :Index return pointer - * NOTE : - * RETURN : TRUE :Can be registered - * FALSE :Unable to register - ******************************************************************************/ -BOOL CANCommWatchEntryCheck(CANID can_id, DID ul_did, PCSTR notify_name, uint8_t *puc_index, CAN_PROTOCOL_TYPE mode) { - uint32_t ul_cnt; - BOOL ret = FALSE; - CAN_COMM_WATCH_DAT *ptr = &g_st_comm_watch_dat[mode][0]; - - /* Search duplicate data */ - for (ul_cnt = 0; ul_cnt < COMM_WATCH_LIST_NUM; ul_cnt++) { - /* CANID, DataID, Shipping ID Matching? */ - if ((can_id == ptr[ul_cnt].ul_can_id) && - (ul_did == ptr[ul_cnt].ul_did) && - (strcmp(notify_name, ptr[ul_cnt].notify_name) == 0)) { - ret = TRUE; - *puc_index = (uint8_t)ul_cnt; - - break; - } - } - if (FALSE == ret) { - /* Search for free table */ - for (ul_cnt = 0; ul_cnt < COMM_WATCH_LIST_NUM; ul_cnt++) { - /* Free (communication interruption time = 0)? */ - if ((uint16_t)0 == ptr[ul_cnt].us_watch_time) { - ret = TRUE; - *puc_index = (uint8_t)ul_cnt; - break; - } - } - } - - return (ret); -} - -/******************************************************************************* - * MODULE : CANCommWatchEntry - * ABSTRACT : CANDataCommunication Disruption Monitoring Management Table Registration Process - * FUNCTION : Register data in the communication interruption monitoring management table - * ARGUMENT : uc_index :Index of registration destination - * ul_did :Data to register ID - * notifyId :Process ID to register - * ulCanid :CAN ID to register - * usWatchTime :Communication interruption time to register - * ucIg :IG linkage flag to be registered - * us_timer_seq_no :Timer sequence number to register - * NOTE : - * RETURN : void - ******************************************************************************/ -void CANCommWatchEntry(uint8_t uc_index, const CAN_COMM_WATCHEXT_MSG_DAT *pst_msg_data, - uint16_t us_timer_seq_no, uint8_t uc_comm_stop, CAN_PROTOCOL_TYPE mode) { - CAN_COMM_WATCH_DAT *ptr = &g_st_comm_watch_dat[mode][uc_index]; - - /* Confirm whether overwriting or addition of communication disruption monitoring management table */ - if ((uint16_t)0 == ptr->us_watch_time) { - /* In case of additional registration, update the number of registered data */ - g_us_comm_watch_dat_cnt[mode]++; - } - /* Register new monitoring data in communication interruption monitoring management table */ - strlcpy(ptr->notify_name, pst_msg_data->notifyName, sizeof(ptr->notify_name)); /* Store Destination Thread Name */ - ptr->ul_did = pst_msg_data->ulDid; /* Data ID storage */ - ptr->ul_can_id = pst_msg_data->ulCanid; /* CAN ID storage */ - ptr->us_watch_time = pst_msg_data->usWatchTime; /* Communication interruption time storage */ - ptr->uc_comm_stop = uc_comm_stop; /* Communication state storage */ - ptr->uc_ig = pst_msg_data->ucIg; /* IG linkage information storage */ - ptr->us_timer_seq_no = us_timer_seq_no; /* Store timer sequence number */ - /* Log output */ - // LCOV_EXCL_BR_START 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, - "##### COMMWaitTable [Index:0x%04x, SndId:0x%s, Did:0x%08x, CanID:0x%08x, Tim:0x%04x, Comm:0x%04x, IG:0x%04x, TimSeq:0x%04x] ##### ", // NOLINT (whitespace/line_length) - uc_index, ptr->notify_name, ptr->ul_did, ptr->ul_can_id, - ptr->us_watch_time, ptr->uc_comm_stop, ptr->uc_ig, ptr->us_timer_seq_no); - // LCOV_EXCL_BR_STOP 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - return; -} - -/******************************************************************************* - * MODULE : CANCommWatchDelete - * ABSTRACT : CANDataCommunication Disruption Monitoring Management Table Deletion Processing - * FUNCTION : Delete the data in the communication disconnection monitoring management table. - * ARGUMENT : uc_index :Destination index - * NOTE : - * RETURN : void - ******************************************************************************/ -void CANCommWatchDelete(uint8_t uc_index, CAN_PROTOCOL_TYPE mode) { - CAN_COMM_WATCH_DAT *ptr = &g_st_comm_watch_dat[mode][uc_index]; - - /* To 0 all members of the data for the specified index */ - memset(ptr->notify_name, 0x00, sizeof(ptr->notify_name)); /* Initialization of delivery destination thread name */ - ptr->ul_did = 0; /* Data ID initialization */ - ptr->ul_can_id = 0; /* CAN ID initialization */ - ptr->us_watch_time = 0; /* Communication interruption time initialization */ - ptr->uc_comm_stop = 0; /* Communication status initialization */ - ptr->uc_ig = 0; /* Initialization of IG linkage information */ - ptr->us_timer_seq_no = 0; /* Initialization of timer sequence number */ - - if ((uint16_t)0 != g_us_comm_watch_dat_cnt[mode]) { - g_us_comm_watch_dat_cnt[mode]--; /* Updating the number of registered data */ - } - /* Log output */ - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### COMMWaitTableDel [Index:0x%04x] #####", uc_index); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - - return; -} - -/******************************************************************************* - * MODULE : CANCommWatchCtrl - * ABSTRACT : Communication interruption state control processing - * FUNCTION : Setting communication interruption status - * ARGUMENT : uc_index :Index to set - * uc_comm_stop :Communication status to be set - * NOTE : - * RETURN : void - ******************************************************************************/ -void CANCommWatchCtrl(uint8_t uc_index, uint8_t uc_comm_stop, CAN_PROTOCOL_TYPE mode) { - CAN_COMM_WATCH_DAT *ptr = &g_st_comm_watch_dat[mode][uc_index]; - - /* Change communication status */ - ptr->uc_comm_stop = uc_comm_stop; - /* Log output */ - // LCOV_EXCL_BR_START 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, - "##### COMMWaitTable [Index:0x%04x, SndId:0x%s, Did:0x%08x, CanID:0x%08x, Tim:0x%04x, Comm:0x%04x, IG:0x%04x, TimSeq:0x%04x] #####", // NOLINT (whitespace/line_length) - uc_index, ptr->notify_name, ptr->ul_did, ptr->ul_can_id, - ptr->us_watch_time, ptr->uc_comm_stop, ptr->uc_ig, ptr->us_timer_seq_no); - // LCOV_EXCL_BR_STOP 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - return; -} - -/******************************************************************************* - * MODULE : CANCommWatchDataGet - * ABSTRACT : Communication interruption data acquisition process - * FUNCTION : Returns the disconnected data for the specified index - * ARGUMENT : uc_index :Indexed - * pNotifyId :Destination ID Return Pointer - * pul_did :Data ID return pointer - * puc_comm_stop :Communication status return pointer - * NOTE : - * RETURN : void - ******************************************************************************/ -void CANCommWatchDataGet(uint8_t uc_index, char *p_notify_name, DID *pul_did, - uint8_t *puc_comm_stop, CAN_PROTOCOL_TYPE mode) { - CAN_COMM_WATCH_DAT *ptr = &g_st_comm_watch_dat[mode][uc_index]; - - snprintf(p_notify_name, strlen(ptr->notify_name) + 1, "%s", ptr->notify_name); - *pul_did = ptr->ul_did; /* Data ID */ - *puc_comm_stop = ptr->uc_comm_stop; /* Communication status */ - - return; -} - -/******************************************************************************* - * MODULE : CANCommWatchTimerSeqNoGet - * ABSTRACT : Acquisition of Communication Disruption Monitor Timer Sequence Number - * FUNCTION : Returns the timer sequence number at the specified index - * ARGUMENT : uc_index :Indexed - * NOTE : - * RETURN : Timer Sequence Number - ******************************************************************************/ -uint16_t CANCommWatchTimerSeqNoGet(uint8_t uc_index, CAN_PROTOCOL_TYPE mode) { - uint16_t us_timer_seq_no; - CAN_COMM_WATCH_DAT *ptr = &g_st_comm_watch_dat[mode][uc_index]; - - /* Timer sequence number of the target index */ - us_timer_seq_no = ptr->us_timer_seq_no; - - return (us_timer_seq_no); -} - -/******************************************************************************* - * MODULE : CANCommWatchTimerSeqNoRenwal - * ABSTRACT : Communication interruption monitoring timer sequence number update processing - * FUNCTION : Updates the timer sequence number at the specified index - * ARGUMENT : uc_index :Indexed - * pus_watch_time :Communication interruption time return pointer - * NOTE : - * RETURN : Timer Sequence Number - ******************************************************************************/ -uint16_t CANCommWatchTimerSeqNoRenwal(uint8_t uc_index, uint16_t *pus_watch_time, CAN_PROTOCOL_TYPE mode) { - uint16_t us_timer_seq_no; - CAN_COMM_WATCH_DAT *ptr = &g_st_comm_watch_dat[mode][uc_index]; - - /* Updating the timer sequence number of the target index */ - ptr->us_timer_seq_no = g_us_comm_watch_timer_seq_no; - - /* Timer sequence number increment counter + 1 */ - g_us_comm_watch_timer_seq_no++; - - /* Check whether it is within the range of the sequence number used for communication interruption monitoring */ - if (g_us_comm_watch_timer_seq_no > (uint16_t)COMM_WATICH_TIMER_SEQ_NO_MAX) { - g_us_comm_watch_timer_seq_no = COMM_WATICH_TIMER_SEQ_NO_MIN; - } - - /* Return value setting */ - us_timer_seq_no = ptr->us_timer_seq_no; - *pus_watch_time = ptr->us_watch_time; - /* Log output */ - // LCOV_EXCL_BR_START 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, - "##### COMMWaitTable [Index:0x%04x, SndId:0x%s, Did:0x%08x, CanID:0x%08x, Tim:0x%04x, Comm:0x%04x, IG:0x%04x, TimSeq:0x%04x] #####", // NOLINT (whitespace/line_length) - uc_index, ptr->notify_name, ptr->ul_did, ptr->ul_can_id, - ptr->us_watch_time, ptr->uc_comm_stop, ptr->uc_ig, ptr->us_timer_seq_no); - // LCOV_EXCL_BR_STOP 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - return (us_timer_seq_no); -} - -/******************************************************************************* - * MODULE : CANCommWatchSndCheck - * ABSTRACT : CANDataCommunication Disruption Monitoring Management Table Delivery Destination ID Confirmation Process - * FUNCTION : Compare the specified index of the communication interruption monitoring management table with the delivery destination ID. - * ARGUMENT : uc_index :Indexed - * notifyId :Addresses for delivery ID - * NOTE : - * RETURN : TRUE :Data consistency - * FALSE :Data mismatch - ******************************************************************************/ -BOOL CANCommWatchSndCheck(uint8_t uc_index, PCSTR notify_name, CAN_PROTOCOL_TYPE mode) { - BOOL ret = FALSE; - CAN_COMM_WATCH_DAT *ptr = &g_st_comm_watch_dat[mode][uc_index]; - - /* Destination ID of specified index data matches argument? */ - if (strcmp(notify_name, ptr->notify_name) == 0) { - ret = TRUE; - } - return (ret); -} - -/******************************************************************************* - * MODULE : CANCommWatchIgcoopGet - * ABSTRACT : IG linkage information acquisition processing of the communication disruption monitoring management table - * FUNCTION : Returns the IG linkage value of the specified index - * ARGUMENT : uc_index :Indexed - * NOTE : - * RETURN : CAN_IG_COOPERATION_OFF :IG no collaboration - * CAN_IG_COOPERATION_ON :IG Has collaborations - ******************************************************************************/ - -uint8_t CANCommWatchIgcoopGet(uint8_t uc_index, CAN_PROTOCOL_TYPE mode) { // LCOV_EXCL_START 8:the function is not used - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - uint8_t uc_ig_cooperation; - CAN_COMM_WATCH_DAT *ptr = &g_st_comm_watch_dat[mode][uc_index]; - - /* IG linkage value of the target index */ - uc_ig_cooperation = ptr->uc_ig; - - return (uc_ig_cooperation); -} -// LCOV_EXCL_STOP - -/******************************************************************************* - * MODULE : CANCommWatchBufferOut - * ABSTRACT : CAN communication interruption table log output processing - * FUNCTION : Output CAN communication disruption table log - * ARGUMENT : FILE *fp_log : File pointer of the log output file - * NOTE : - * RETURN : - ******************************************************************************/ - -void CANCommWatchBufferOut(FILE *fp_log, CAN_PROTOCOL_TYPE mode) { // LCOV_EXCL_START 8:the function is not used - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - int32_t usage_rate; - uint16_t i; - uint16_t data_cnt = 0; - CAN_COMM_WATCH_DAT *ptr = &g_st_comm_watch_dat[mode][0]; - - if (NULL != fp_log) { - /* Output of communication disruption management table */ - (void)fprintf(fp_log, "CAN CommWatch Buffer \n"); - (void)fprintf(fp_log, "CanID: SNDID: DID: Time: State: IG_mode: TimeSeq:\n"); - for (i = 0; i < (uint16_t)COMM_WATCH_LIST_NUM; i++) { - /* Free (communication interruption time = 0)? */ - if ((uint16_t)0 != ptr[i].us_watch_time) { - (void)fprintf(fp_log, "%08x %s %08x %04x %04x %04x %04x\n", - ptr[i].ul_can_id, - ptr[i].notify_name, - ptr[i].ul_did, - ptr[i].us_watch_time, - ptr[i].uc_comm_stop, - ptr[i].uc_ig, - ptr[i].us_timer_seq_no); - data_cnt++; - } - } - usage_rate = (((int32_t)data_cnt * 100) / COMM_WATCH_LIST_NUM); - (void)fprintf(fp_log, "BUFFER_Use: %04d BUFFER_Max: %04d Usage_Rate: %04d \n", - data_cnt, COMM_WATCH_LIST_NUM, usage_rate); - if (usage_rate >= CAN_USAGE_RATE_THRESHOLD) { - (void)fprintf(fp_log, "Warning: Buffer utilization exceeds a threshold.\n"); - } - } -} -// LCOV_EXCL_STOP - -// LCOV_EXCL_START 7: debug code -EFrameworkunifiedStatus CANCommWatchAllClearDebug(HANDLE h_app) { - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - if (access("/tmp/communication_debug", F_OK) == 0) { - FRAMEWORKUNIFIEDLOG(ZONE_WARN, __func__, "g_st_comm_watch_dat[CAN]."); - /* Communication disruption monitoring management table */ - memset(g_st_comm_watch_dat[0], 0x00, sizeof(CAN_COMM_WATCH_DAT) * COMM_WATCH_LIST_NUM); - g_us_comm_watch_dat_cnt[0] = 0; /* Number of effective registrations of communication disruption monitoring management table */ - } else { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "/tmp/communication_debug Not found."); - } - return eFrameworkunifiedStatusOK; -} -// LCOV_EXCL_STOP 7: debug code |