diff options
author | takeshi_hoshina <takeshi_hoshina@mail.toyota.co.jp> | 2020-10-22 13:28:36 +0900 |
---|---|---|
committer | takeshi_hoshina <takeshi_hoshina@mail.toyota.co.jp> | 2020-10-22 13:28:36 +0900 |
commit | 211696c95c1ec3fc48e0096d47d4278910274195 (patch) | |
tree | f3e0a5461f83a0ec191b788070fe59639148fb17 /communication/server/src/CAN | |
parent | aacd1728939f2b6f4c811cd93502966265cd8203 (diff) |
ps-communication branch 0.1sandbox/ToshikazuOhiwa/ps-communication
Diffstat (limited to 'communication/server/src/CAN')
10 files changed, 887 insertions, 4639 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 diff --git a/communication/server/src/CAN/Command/CAN_Command.cpp b/communication/server/src/CAN/Command/CAN_Command.cpp deleted file mode 100644 index f7875362..00000000 --- a/communication/server/src/CAN/Command/CAN_Command.cpp +++ /dev/null @@ -1,319 +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. - */ - -/******************************************************************************* - * Module configuration :CANCommandTransmission() CAN command transmission processing - * :CANCommandTxRslt() CAN command transmission result notification processing - * :CANCommandDelivery() CAN command delivery process - ******************************************************************************/ -/*!----------------------------------------------------------------------------- - * @file CAN_Command.cpp - * @~english - * @brief CAN Command process - */ -#include "CAN_Command.h" - -#include <native_service/frameworkunified_types.h> // NOLINT (build/include) -#include <native_service/frameworkunified_framework_if.h> -#include <peripheral_service/Canif_API.h> -//#include <can_hal.h> -#include <string> -#include "CAN_Thread.h" -#include "CAN_Delivery.h" -#include "CAN_CommandData.h" -#include "CAN_TxMsg.h" -#include "ICR_Common.h" - -/*************************************************/ -/* Global variable */ -/*************************************************/ - -/******************************************************************************* - * MODULE : CANCommandTransmission - * ABSTRACT : CAN command transmission processing - * FUNCTION : Control the transmission of CAN commands - * ARGUMENT : pst_rcv_msg : Received Message Reference Pointer - * NOTE : - * RETURN : RET_CAN_NORMAL : Normal completion - * RET_CAN_ERROR_CREATE_EVENT : Event generation failure - * RET_CAN_ERROR_BUFFULL : Delivery registration FULL or result notification registration FULL - ******************************************************************************/ -EFrameworkunifiedStatus CANCommandTransmission(HANDLE h_app) { - RET_CAN ret = RET_CAN_NORMAL; /* Return value of this function */ - BOOL b_dlvry_flag = TRUE; /* Delivery registration flag */ - BOOL b_tx_rslt_flag = TRUE; /* Notification registration flag */ - BOOL b_com_flag = TRUE; /* Command transmission flag */ - BOOL b_snd_msg_flag = FALSE; /* RST request MSG send flag */ - uint8_t uc_can_rid = CAN_RID_NOTUSE_CODE; - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - CAN_CMD_CTRL_MSG_DAT rcv_msg; - - e_status = FrameworkunifiedGetMsgDataOfSize(h_app, &rcv_msg, sizeof(rcv_msg), eSMRRelease); - if (e_status != eFrameworkunifiedStatusOK) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# FrameworkunifiedGetMsgDataOfSize Error"); - if (e_status == eFrameworkunifiedStatusInvldBufSize) { - FrameworkunifiedClearMsgData(h_app); - } - ret = RET_CAN_ERROR_CANCEL; - goto exit; - } - - if ((uint8_t)CAN_CMDID_VERSION_REQ_TX == rcv_msg.ucCmdid) { - CAN_MSG_CANCMD data = {0x00}; - std::string version_info; -// CANHAL_RET_API ret; - -// ret = CanGetVersion(&version_info); -// if (CANHAL_RET_NORMAL != ret) { -// return eFrameworkunifiedStatusFail; -// } - - if (CAN_TX_CMD_VERSION_SIZE != version_info.length()) { - return eFrameworkunifiedStatusFail; - } - - memcpy(data.data.data, version_info.c_str(), CAN_TX_CMD_VERSION_SIZE); - -// data.hdr.hdr.cid = CID_CAN_CMD_DELIVERY; -// data.hdr.hdr.rid = 0; -// data.hdr.hdr.msgbodysize = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_VERSION_SIZE; - data.data.cmd_id = CAN_CMDID_VERSION_RESP_RX; - - HANDLE client = FrameworkunifiedMcOpenSender(h_app, rcv_msg.notifyName); // LCOV_EXCL_BR_LINE 11:except,C++ STL - if (NULL == client) { - return eFrameworkunifiedStatusFail; - } - - e_status = FrameworkunifiedSendMsg(client, CID_CAN_CMD_DELIVERY, sizeof(CAN_MSG_CANCMD), &data); // LCOV_EXCL_BR_LINE 200: unexpect branch //NOLINT (readability/naming) - if (eFrameworkunifiedStatusOK != e_status) { - return eFrameworkunifiedStatusFail; - } - - return eFrameworkunifiedStatusOK; - } - - /* Reset request delivery request */ - if ((uint8_t)CAN_CMDID_FUELCALC_RST_REQ_DELIVERY == rcv_msg.ucCmdid) { /* #104 */ - b_tx_rslt_flag = FALSE; - - /* Check reset reception status */ - if (TRUE == CANCommandFuelCalcRstReqCheck()) { - /* Cost reset request received in CAN section */ - b_dlvry_flag = FALSE; - b_snd_msg_flag = TRUE; - } else { - /* CAN section flammability reset request not received */ - b_com_flag = FALSE; - if (FALSE == CANCommandDeliveryEntryCheck(rcv_msg.notifyName, rcv_msg.ucCmdid)) { - ret = RET_CAN_ERROR_BUFFULL; /* CAN-command delivery control table FULL */ - goto exit; - } - } - } else { - /* Delivery Registration? */ - if ((uint8_t)CAN_CMDID_FUELCALC_REQ_TX == rcv_msg.ucCmdid) { /* #104 */ - /* Not registered for delivery */ - b_dlvry_flag = FALSE; - } else { - /* Register for delivery */ - if (FALSE == CANCommandDeliveryEntryCheck(rcv_msg.notifyName, rcv_msg.ucCmdid)) { - ret = RET_CAN_ERROR_BUFFULL; /* CAN-command delivery control table FULL */ - goto exit; - } - } - - /* Register transmission result notification? */ - if ((uint8_t)CAN_RID_NOTUSE_CODE == rcv_msg.ucRid) { /* #104 */ - /* Not to register transmission result notification */ - b_tx_rslt_flag = FALSE; - } else { - /* Register transmission result notification */ - if (FALSE == CANCommandTxRsltEntryCheck(rcv_msg.ucCmdid, &uc_can_rid)) { - ret = RET_CAN_ERROR_BUFFULL; /* CAN-command-send-result-management-table FULL */ - goto exit; - } - } - } - - if (TRUE == b_snd_msg_flag) { - /* CAN section flame reset request message transmission */ - CANCommandFuelCalcRstReqSndMsg(h_app, rcv_msg.notifyName); - } else { - if (TRUE == b_dlvry_flag) { - /* CAN command delivery registration */ - CANCommandDeliveryEntry(rcv_msg.notifyName, rcv_msg.ucCmdid); - } - if (TRUE == b_tx_rslt_flag) { - /* CAN command transmission result notification registration */ - CANCommandTxRsltEntry(uc_can_rid, rcv_msg.notifyName, rcv_msg.ucRid); - } - if (TRUE == b_com_flag) { -// CanMessage st_can_data; -// -// st_can_data.can_id = rcv_msg.ucCmdid; -// st_can_data.rid = uc_can_rid; -// st_can_data.dlc = (uint8_t)CAN_CMDSND_DATA_SIZE; - -// if (CANHAL_RET_NORMAL != CanSend(&st_can_data, CAN_HAL_TYPE_CAN)) { -// ret = RET_CAN_ERROR_PARAM; -// FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Transmission CANHAL Error"); // LCOV_EXCL_BR_LINE 15: marco defined in "native_service/ns_logger_if.h" // NOLINT (whitespace/line_length) -// } - } - } - -exit: - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "ret=%x", ret); // LCOV_EXCL_BR_LINE 15: marco defined in "native_service/ns_logger_if.h" // NOLINT (whitespace/line_length) - if (ret == RET_CAN_NORMAL) - return eFrameworkunifiedStatusOK; - else - return eFrameworkunifiedStatusFail; - // return RET_CAN_NORMAL; -} - -/******************************************************************************* - * MODULE : CANCommandTxRslt - *******************************************************************************/ -/*!----------------------------------------------------------------------------- - * @~english - * @brief CAN command transmission result notification processing - * - * CAN command transmission result notification processing - * - * Notify the result of CAN command transmission - * - * @~english - * @note - * -# Transmission result status acquisition - * -# Transmission result notification registration detection - * -# Message sending - * -# Result notification registration deletion - * - * @~english - * @return Transmission result - * @retval <RET_CAN_NORMAL> Normality - * @retval <RET_CAN_ERROR_CANCEL> Data annulment - * - * @~english - * @param[in] <pst_rcv_msg> Reception message reference pointer - */ -RET_CAN CANCommandTxRslt(HANDLE h_app, CAN_MSG_DATA *pst_rcv_msg) { // LCOV_EXCL_START 8:this IF is called in CANIcrSndStsProcess, and CAN command TX to can_hal, but not ICR // NOLINT (whitespace/line_length) - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - RET_CAN ret = RET_CAN_NORMAL; /* Return value of this function */ -// T_ICR_CMDSNDCNF_STS *pst_msg_data; /* Receive data structure pointer */ - uint8_t uc_status; /* Reception status */ - - /* Type conversion */ -// pst_msg_data = reinterpret_cast<T_ICR_CMDSNDCNF_STS *>(reinterpret_cast<void *>(&pst_rcv_msg->ucData[0])); - - /* Acquisition of transmission result status */ -// switch (pst_msg_data->cnf_sts) { -// case ICR_SND_SUCCESS: -// uc_status = CAN_SUCCESS; /* Transmission completion */ -// break; -// case ICR_SND_ERR_RETRYOUT: -// uc_status = CAN_RETRYOUT; /* Re-tryout */ -// FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Transmission SYSCOM Error"); -// CANDebugLogOut(CAN_TRANCE_SYSCOM_ERR, reinterpret_cast<void *>(pst_rcv_msg)); -// break; -// case ICR_SND_ERR_BUFFERFULL: -// uc_status = CAN_BUFFERFUL; /* Transmit Buffer Full */ -// FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Transmission SYSCOM Error"); -// CANDebugLogOut(CAN_TRANCE_SYSCOM_ERR, reinterpret_cast<void *>(pst_rcv_msg)); -// break; -// default: -// ret = RET_CAN_ERROR_CANCEL; /* Data destruction */ -// FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Transmission SYSCOM Error"); -// CANDebugLogOut(CAN_TRANCE_SYSCOM_ERR, reinterpret_cast<void *>(pst_rcv_msg)); -// break; -// } - - if (RET_CAN_NORMAL == ret) { - /* Send result notification registration detection */ -// if (FALSE == CANCommandTxRsltCheck(pst_rcv_msg->stHead.hdr.rid)) { -// ret = RET_CAN_ERROR_CANCEL; /* Data destruction */ -// } - } - - if (RET_CAN_NORMAL == ret) { - /* Send Result Notification Message */ -// CANCommandTxRsltSndMsg(h_app, pst_rcv_msg->stHead.hdr.rid, uc_status); - - /* Delete registered result notification */ -// CANCommandTxRsltDelete(pst_rcv_msg->stHead.hdr.rid); - } - - return (ret); -} -// LCOV_EXCL_STOP - -/******************************************************************************* - * MODULE : CANCommandDelivery - ******************************************************************************/ -/*!----------------------------------------------------------------------------- - * @~english - * @brief CAN command delivery processing - * - * CAN command delivery processing - * - * Deliver CAN commands - * - * @~english - * @note - * -# CAN command ID conversion - * -# Control flag operation (The reset demand is received). - * -# Message sending - * -# Delivery registration deletion - * - * @~english - * @return Delivery result - * @retval <RET_CAN_NORMAL> Normality - * @retval <RET_CAN_ERROR_CANCEL> Data annulment - * - * @~english - * @param[in] <pst_rcv_msg> Reception message reference pointer - */ -RET_CAN CANCommandDelivery(HANDLE h_app, CAN_MSG_DATA *pst_rcv_msg) { - RET_CAN ret = RET_CAN_NORMAL; /* Return value of this function */ -// T_ICR_CMD_DATA *pst_msg_data; /* Receive data structure pointer */ - uint8_t uc_cmd_id; /* Receive CAN command ID */ - - /* Type conversion */ -// pst_msg_data = reinterpret_cast<T_ICR_CMD_DATA *>(reinterpret_cast<void *>(&pst_rcv_msg->ucData[0])); - - /* OPC-> CAN command ID conversion */ -// if (FALSE == CANCommandidOpcToUserCvt(pst_msg_data->opc, &uc_cmd_id)) { // LCOV_EXCL_BR_LINE 6: double check -// AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert -// ret = RET_CAN_ERROR_CANCEL; /* Data destruction */ // LCOV_EXCL_LINE 6: double check -// } - - if (RET_CAN_NORMAL == ret) { // LCOV_EXCL_BR_LINE 200: ret will not assigned to other value forever - /* Set the control flag to received if CAN command section flagreset request */ - if ((uint8_t)CAN_CMDID_FUELCALC_RST_REQ_RX == uc_cmd_id) { - /* Receive Reset Request */ - (void)CANCommandFuelCalcRstReq(); - } - - /* Send Delivery Message */ -// if (!CANCommandDeliverySndMsg(h_app, uc_cmd_id, &pst_msg_data->data[0])) { -// ret = RET_CAN_ERROR_PARAM; -// } - - /* Delete Delivery Registration */ - CANCommandDeliveryDelete(uc_cmd_id); - } - - return (ret); -} diff --git a/communication/server/src/CAN/Command/CAN_CommandData.cpp b/communication/server/src/CAN/Command/CAN_CommandData.cpp deleted file mode 100644 index fe85ebfd..00000000 --- a/communication/server/src/CAN/Command/CAN_CommandData.cpp +++ /dev/null @@ -1,534 +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_CommandData.cpp - * SYSTEM :_CWORD107_ - * SUBSYSTEM :EXL process - * PROGRAM :CAN Thread CAN Command Control Data Management - * : - * Module configuration :CANCommandDeliveryEntryCheck() CAN command delivery management table registration status confirmation processing - * :CANCommandDeliveryEntry() CAN command delivery management table registration process - * :CANCommandDeliveryDataGet() CAN command delivery management table data acquisition processing - * :CANCommandDeliveryDelete() CAN command delivery management table deletion processing - * :CANCommandTxRsltEntryCheck() CAN command transmission result management table registration status confirmation processing - * :CANCommandTxRsltEntry() CAN command transmission result management table registration process - * :CANCommandTxRsltDataGet() CAN command transmission result management table data acquisition processing - * :CANCommandTxRsltDelete() CAN command transmission result management table deletion processing - * :CANCommandTxRsltCheck() CAN command transmission result management table notification registration confirmation processing - * :CANCommandFuelCalcRstReqCheck() CAN section flame reset request reception status confirmation processing - * :CANCommandFuelCalcRstReq() CAN section flammability reset request reception processing - * :CANCommandDataInit() CAN command management data initialization processing - * : - ******************************************************************************/ -#include "CAN_CommandData.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 variable */ -/*************************************************/ -static CAN_COMMAND_DELIVERY_LIST_DAT g_st_can_cmd_delivery_dat[CAN_COMMAND_DELIVERY_NUM]; /* CAN command delivery management table */ //NOLINT (readability/naming) -/* CAN command transmission result management table */ -static CAN_COMMAND_TXRSLT_LIST_DAT g_st_can_cmd_transrslt_dat[CAN_COMMAND_TXRSLT_NUM]; //NOLINT (readability/naming) - -/******************************************************************************* - * MODULE : CANCmdidConvertIndexTX - * ABSTRACT : CAN Command ID->Index conversion processing (during delivery) - * FUNCTION : Convert the CAN command ID to an index in the CAN command delivery management table - * ARGUMENT : uc_cmd_id : CAN command ID - * : *uc_index : Pointer to the index - * NOTE : - * RETURN : TRUE : Successful conversion - * : FALSE : Conversion failed - ******************************************************************************/ -static BOOL CANCmdidConvertIndexTX(uint8_t uc_cmd_id, uint8_t* uc_index) { - BOOL b_ret = TRUE; - - switch (uc_cmd_id) { - case CAN_CMDID_FUELCALC_RST_REQ_DELIVERY: /* Request for delivery of request for flame reset in CAN section */ - *uc_index = 0; - break; - - case CAN_CMDID_STARTUP_FIN_REQ_TX: /* CAN start completion notification request */ - *uc_index = 1; - break; - - case CAN_CMDID_MRST_INFO_REQ_TX: /* CAN Master Reset Information Notification Request */ - *uc_index = 2; - break; - - case CAN_CMDID_VERSION_REQ_TX: /* CAN version request */ - *uc_index = 3; - break; - - case CAN_CMDID_CONNECTION_NODE_REQ_TX: /* CAN Connection Node Notification Request */ - *uc_index = 4; - break; - - default: /* IDs that are not subject to undefined ID or registration */ - b_ret = FALSE; - break; - } - - return b_ret; -} - -/******************************************************************************* - * MODULE : CANCmdidConvertIndexRX - * ABSTRACT : CAN Command ID->Index conversion processing (at reception) - * FUNCTION : Convert the CAN command ID to an index in the CAN command delivery management table - * ARGUMENT : uc_cmd_id : CAN command ID - * *uc_index : Pointer to the index - * NOTE : - * RETURN : TRUE : Successful conversion - * FALSE : Conversion failed - ******************************************************************************/ -static BOOL CANCmdidConvertIndexRX(uint8_t uc_cmd_id, uint8_t* uc_index) { - BOOL b_ret = TRUE; - - switch (uc_cmd_id) { - case CAN_CMDID_FUELCALC_RST_REQ_RX: /* RECEIVE REQUEST FREE OF CAN SECTION */ - *uc_index = 0; - break; - - case CAN_CMDID_STARTUP_FIN_RESP_RX: /* CAN start completion notification request transmission */ - *uc_index = 1; - break; - - case CAN_CMDID_MRST_INFO_RESP_RX: /* CAN master reset information notification request transmission */ - *uc_index = 2; - break; - - case CAN_CMDID_VERSION_RESP_RX: /* CAN Version Request Send */ - *uc_index = 3; - break; - - case CAN_CMDID_CONNECTION_NODE_RESP_RX: /* CAN connection node notification request transmission */ - *uc_index = 4; - break; - - default: /* IDs that are not subject to undefined ID or registration */ - b_ret = FALSE; - break; - } - return b_ret; -} - -/******************************************************************************* - * MODULE : CANCommandDeliveryEntryCheck - * ABSTRACT : CAN command delivery management table registration status confirmation processing - * FUNCTION : Confirm whether registration is possible in the CAN command delivery management table. - * ARGUMENT : notifyId : Addresses for delivery ID - * uc_cmd_id : CAN command ID - * NOTE : - * RETURN : TRUE : Can be registered - * FALSE : Cannot be stored - ******************************************************************************/ -BOOL CANCommandDeliveryEntryCheck(PCSTR notify_name, uint8_t uc_cmd_id) { - BOOL ret = TRUE; /* Return value of this function */ - uint8_t uc_index; /* Index that references the delivery management table */ - int32_t l_cnt; /* Generic counters */ - CAN_COMMAND_DELIVERY_LIST_DAT* ptr; - - ret = CANCmdidConvertIndexTX(uc_cmd_id, &uc_index); - - if (TRUE == ret) { // LCOV_EXCL_BR_LINE 6: double check - ret = FALSE; - ptr = &g_st_can_cmd_delivery_dat[uc_index]; - /* Search destination */ - for (l_cnt = 0; l_cnt < CAN_COMMAND_DELIVERY_SNDID_NUM; l_cnt++) { - if ((strcmp(ptr->notify_name_list[l_cnt], notify_name) == 0) || - (ptr->notify_name_num == (uint8_t)l_cnt)) { - /* When overwriting or registering a new entry */ - ret = TRUE; - break; - } - } - } - return (ret); -} - -/******************************************************************************* - * MODULE : CANCommandDeliveryEntry - * ABSTRACT : CAN command delivery management table registration process - * FUNCTION : Register in the CAN command delivery management table - * ARGUMENT : notifyId : Addresses for delivery ID - * uc_cmd_id : CAN command ID - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANCommandDeliveryEntry(PCSTR notify_name, uint8_t uc_cmd_id) { - BOOL b_cont = TRUE; /* Processing Continuation Flag */ - uint8_t uc_index; /* Index that references the delivery management table */ - int32_t l_cnt; /* Generic counters */ - CAN_COMMAND_DELIVERY_LIST_DAT* ptr; - - b_cont = CANCmdidConvertIndexTX(uc_cmd_id, &uc_index); - - if (TRUE == b_cont) { // LCOV_EXCL_BR_LINE 6: double check - ptr = &g_st_can_cmd_delivery_dat[uc_index]; - /* Search destination */ - for (l_cnt = 0; (l_cnt < CAN_COMMAND_DELIVERY_SNDID_NUM); l_cnt++) { - if (strcmp(ptr->notify_name_list[l_cnt], notify_name) == 0) { - /* For overwriting */ - b_cont = FALSE; - } else if (ptr->notify_name_num == (uint8_t)l_cnt) { - /* For new entry */ - strlcpy(ptr->notify_name_list[l_cnt], notify_name, sizeof(ptr->notify_name_list[l_cnt])); - ptr->notify_name_num++; - b_cont = FALSE; - } else { - /* Do nothing */ - } - if (FALSE == b_cont) { - break; - } - } - } - return; -} - -/******************************************************************************* - * MODULE : CANCommandDeliveryDataGet - * ABSTRACT : CAN command delivery management table data acquisition processing - * FUNCTION : Retrieve registration data from CAN command delivery management table - * ARGUMENT : uc_cmd_id : CAN command ID - * pNotifyNameNum : Return Pointer to Number of Destination Registrations - * pNotifyIdList : Shipping list reference pointer - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANCommandDeliveryDataGet(uint8_t uc_cmd_id, CAN_COMMAND_DELIVERY_LIST_DAT* dst) { - BOOL b_cont; /* Processing Continuation Flag */ - uint8_t uc_index; /* Index that references the delivery management table */ - CAN_COMMAND_DELIVERY_LIST_DAT* src; - - b_cont = CANCmdidConvertIndexRX(uc_cmd_id, &uc_index); - - if (TRUE == b_cont) { /* For registration ID*/ // LCOV_EXCL_BR_LINE 6: double check - src = &g_st_can_cmd_delivery_dat[uc_index]; - dst->notify_name_num = src->notify_name_num; /* Number of registered delivery destination IDs */ - memcpy(dst->notify_name_list, src->notify_name_list, sizeof(dst->notify_name_list)); - } - return; -} - -/******************************************************************************* - * MODULE : CANCommandDeliveryDelete - * ABSTRACT : CAN command delivery management table deletion processing - * FUNCTION : Delete registered data from CAN command delivery management table - * ARGUMENT : uc_cmd_id : CAN command ID - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANCommandDeliveryDelete(uint8_t uc_cmd_id) { - BOOL b_cont = TRUE; /* Processing Continuation Flag */ - uint8_t uc_index; /* Index that references the delivery management table */ - CAN_COMMAND_DELIVERY_LIST_DAT* ptr; - - b_cont = CANCmdidConvertIndexRX(uc_cmd_id, &uc_index); - - if (TRUE == b_cont) { /* For registration ID */ // LCOV_EXCL_BR_LINE 6: double check - ptr = &g_st_can_cmd_delivery_dat[uc_index]; - /* Whether the control method is delivery control type or one-time communication type */ - if (((uint8_t)CAN_CMD_DELIVERY_CTRL == ptr->uc_ctrl) || - ((uint8_t)CAN_CMD_1TIME_TRANCE == ptr->uc_ctrl)) { - /* Delete registered data */ - ptr->notify_name_num = 0; /* Number of delivery destination ID registrations = 0 */ - memset((ptr->notify_name_list), 0x00, sizeof(ptr->notify_name_list)); /* Destination ID List = 0 */ - } - } - return; -} - -/******************************************************************************* - * MODULE : CANCommandDeliveryDeletesingle - * ABSTRACT : CAN command delivery management table deletion processing - * FUNCTION : Delete registered data from CAN command delivery management table - * ARGUMENT : uc_cmd_id : CAN command ID - * : notifyId : Service client ID - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANCommandDeliveryDeletesingle(uint8_t uc_cmd_id, PCSTR notify_name) { // LCOV_EXCL_START 4: only be executed when NSFW error // NOLINT (whitespace/line_length) - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - BOOL b_cont = TRUE; /* Processing Continuation Flag */ - uint8_t uc_index; /* Index that references the delivery management table */ - int i, j; - CAN_COMMAND_DELIVERY_LIST_DAT* ptr; - - b_cont = CANCmdidConvertIndexRX(uc_cmd_id, &uc_index); - - if (TRUE == b_cont) { // LCOV_EXCL_BR_LINE 6: double check - ptr = &g_st_can_cmd_delivery_dat[uc_index]; - /* Delete registered data */ - for (i = 0; i < ptr->notify_name_num; i++) { - if (strcmp(notify_name, ptr->notify_name_list[i]) != 0) { - continue; - } - for (j = i; j < ptr->notify_name_num - 1; j++) { - memmove(ptr->notify_name_list[j], ptr->notify_name_list[j + 1], sizeof(char) * MAX_NAME_SIZE_APP); - } - ptr->notify_name_num--; - } - } - return; -} -// LCOV_EXCL_STOP 8: only be executed when NSFW error - -/******************************************************************************* - * MODULE : CANCommandTxRsltEntryCheck - * ABSTRACT : CAN command transmission result management table registration status confirmation processing - * FUNCTION : Check that the CAN command can be registered in the transmission result management table. - * ARGUMENT : uc_cmd_id : CAN command ID - * pucCanRid : Resource ID return pointer from CAN - * NOTE : - * RETURN : TRUE : Can be registered - * FALSE : Cannot be stored - ******************************************************************************/ -BOOL CANCommandTxRsltEntryCheck(uint8_t uc_cmd_id, uint8_t* uc_can_rid) { - BOOL ret = FALSE; /* Return value of this function */ - uint8_t uc_index; /* Index that references the communication result management table */ - - /* CAN command transmission result management table retrieval */ - for (uc_index = 0; uc_index < (uint8_t)CAN_COMMAND_TXRSLT_NUM; uc_index++) { - /* CAN command ID match? */ - if (uc_cmd_id == g_st_can_cmd_transrslt_dat[uc_index].uc_cmd_id) { - /* RID = 0xFF (not registered)? */ - if ((uint8_t)CAN_RID_NOTUSE_CODE == g_st_can_cmd_transrslt_dat[uc_index].uc_rid) { - ret = TRUE; - *uc_can_rid = (uint8_t)(CAN_CMD_RID_MASK | (uint32_t)uc_index); - break; - } - } - } - - return (ret); -} - -/******************************************************************************* - * MODULE : CANCommandTxRsltEntry - * ABSTRACT : CAN command transmission result management table registration process - * FUNCTION : Register in the CAN command transmission result management table - * ARGUMENT : uc_can_rid : CAN_RID of registration destination - * notifyId : Process ID to register - * uc_rid : Resource ID to register - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANCommandTxRsltEntry(uint8_t uc_can_rid, PCSTR notify_name, uint8_t uc_rid) { - uint8_t uc_index; /* Index that references the communication result management table */ - - /* Table's registration index */ - uc_index = (uint8_t)((uint32_t)(~CAN_CMD_RID_MASK) & (uint32_t)uc_can_rid); - - /* Registration */ - strlcpy(g_st_can_cmd_transrslt_dat[uc_index].notify_name, notify_name, - sizeof(g_st_can_cmd_transrslt_dat[uc_index].notify_name)); - g_st_can_cmd_transrslt_dat[uc_index].uc_rid = uc_rid; - - return; -} - -/******************************************************************************* - * MODULE : CANCommandTxRsltDataGet - * ABSTRACT : CAN command transmission result management table data acquisition processing - * FUNCTION : Acquire registration data from CAN command transmission result management table - * ARGUMENT : uc_can_rid : CAN_RID - * pNotifyId : Destination ID Return Pointer - * pusRid : Resource ID return pointer - * pusCmdid : CAN command ID return pointer - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANCommandTxRsltDataGet(uint8_t uc_can_rid, char* p_notify_name, uint8_t* puc_rid, uint8_t* puc_cmd_id) { - uint8_t uc_index; /* Index that references the communication result management table */ - - /* Index from which to retrieve data for the table */ - uc_index = (uint8_t)((uint32_t)(~CAN_CMD_RID_MASK) & (uint32_t)uc_can_rid); - - /* Data acquisition */ - strncpy(p_notify_name, g_st_can_cmd_transrslt_dat[uc_index].notify_name, - sizeof(g_st_can_cmd_transrslt_dat[uc_index].notify_name)); - *puc_rid = g_st_can_cmd_transrslt_dat[uc_index].uc_rid; - *puc_cmd_id = g_st_can_cmd_transrslt_dat[uc_index].uc_cmd_id; - - return; -} - -/******************************************************************************* - * MODULE : CANCommandTxRsltDelete - * ABSTRACT : CAN command transmission result management table deletion processing - * FUNCTION : Delete registered data from the CAN command transmission result management table - * ARGUMENT : uc_can_rid : CAN_RID - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANCommandTxRsltDelete(uint8_t uc_can_rid) { - uint8_t uc_index; /* Index that references the communication result management table */ - - /* Drop index for the table */ - uc_index = (uint8_t)((uint32_t)(~CAN_CMD_RID_MASK) & (uint32_t)uc_can_rid); - - /* Delete */ - memset(g_st_can_cmd_transrslt_dat[uc_index].notify_name, 0x00, - sizeof(g_st_can_cmd_transrslt_dat[uc_index].notify_name)); - g_st_can_cmd_transrslt_dat[uc_index].uc_rid = CAN_RID_NOTUSE_CODE; - - return; -} - -/******************************************************************************* - * MODULE : CANCommandTxRsltCheck - * ABSTRACT : CAN command transmission result management table notification registration confirmation processing - * FUNCTION : Check if the notification is registered in the CAN command transmission result management table. - * ARGUMENT : uc_can_rid : CAN_RID - * NOTE : - * RETURN : TRUE : Registered - * FALSE : No registration - ******************************************************************************/ -BOOL CANCommandTxRsltCheck(uint8_t uc_can_rid) { // LCOV_EXCL_START 8: is called in CANCommandTxRslt, but CANCommandTxRslt is dead code // NOLINT (whitespace/line_length) - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - BOOL ret = FALSE; /* Return value of this function */ - uint8_t uc_index; /* Index that references the communication result management table */ - - /* Reference index of the table */ - uc_index = (uint8_t)((uint32_t)(~CAN_CMD_RID_MASK) & (uint32_t)uc_can_rid); - - /* Not out of range of the table */ - if (uc_index < (uint8_t)CAN_COMMAND_TXRSLT_NUM) { - /* Registered? */ - if ((uint8_t)CAN_RID_NOTUSE_CODE != g_st_can_cmd_transrslt_dat[uc_index].uc_rid) { - ret = TRUE; - } - } - - return (ret); -} -// LCOV_EXCL_STOP - -/******************************************************************************* - * MODULE : CANCommandFuelCalcRstReqCheck - * ABSTRACT : CAN section flame reset request reception status confirmation processing - * FUNCTION : Confirm whether or not a CAN section flame reset request has been received - * ARGUMENT : None - * NOTE : - * RETURN : TRUE : Registered - * FALSE : Unregistered - ******************************************************************************/ -BOOL CANCommandFuelCalcRstReqCheck(void) { - BOOL ret; /* Return value of this function */ - - if ((uint8_t)CAN_CMD_RST_RCV == g_st_can_cmd_delivery_dat[0].uc_flag) { - ret = TRUE; /* Registered */ - } else { - ret = FALSE; /* Unregistered */ - } - - return (ret); -} - -/******************************************************************************* - * MODULE : CANCommandFuelCalcRstReq - * ABSTRACT : CAN section flammability reset request reception processing - * FUNCTION : Set CAN section flame reset request as received - * ARGUMENT : None - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANCommandFuelCalcRstReq(void) { - /* Set the control flag (interval flammability reset) of the CAN command transmission result management table as received */ - g_st_can_cmd_delivery_dat[0].uc_flag = CAN_CMD_RST_RCV; - - return; -} - -/******************************************************************************* - * MODULE : CANCommandDataInit - * ABSTRACT : CAN command management data initialization processing - * FUNCTION : Initializing CAN Command Management Data - * ARGUMENT : None - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANCommandDataInit(void) { - int32_t l_cnt1 = 0; /* Counter */ - int32_t l_cnt2 = 0; - int32_t l_index = 0; - CAN_COMMAND_DELIVERY_LIST_DAT* ptr_dl; - CAN_COMMAND_TXRSLT_LIST_DAT* ptr_tl; - - /*** CAN command delivery management table initialization ***/ - /* Control method initialization */ - g_st_can_cmd_delivery_dat[0].uc_ctrl = CAN_CMD_DELIVERY_CTRL; /* Delivery control type */ - g_st_can_cmd_delivery_dat[1].uc_ctrl = CAN_CMD_1TIME_TRANCE; /* One-time communication */ - g_st_can_cmd_delivery_dat[2].uc_ctrl = CAN_CMD_1TIME_TRANCE; - g_st_can_cmd_delivery_dat[3].uc_ctrl = CAN_CMD_1TIME_TRANCE; - g_st_can_cmd_delivery_dat[4].uc_ctrl = CAN_CMD_TRANCE; /* Continuous communication type */ - g_st_can_cmd_delivery_dat[5].uc_ctrl = CAN_CMD_TRANCE; - for (l_cnt1 = 0; l_cnt1 < CAN_COMMAND_DELIVERY_NUM; l_cnt1++) { - ptr_dl = &g_st_can_cmd_delivery_dat[l_cnt1]; - /* Control flag initialization */ - ptr_dl->uc_flag = CAN_CMD_RST_NOT_RCV; - /* Initialization of number of registered delivery destination IDs */ - ptr_dl->notify_name_num = 0x00; - /* Delivery ID list initialization */ - memset((ptr_dl->notify_name_list), 0x00, (sizeof(ptr_dl->notify_name_list))); - } - - /*** Initialization of CAN command transmission result management table ***/ - for (l_cnt1 = 0; l_cnt1 < CAN_COMMAND_TXRSLT_NUM; l_cnt1++) { - ptr_tl = &g_st_can_cmd_transrslt_dat[l_cnt1]; - /* Initialization of delivery destination ID */ - memset(ptr_tl->notify_name, 0x00, sizeof(ptr_tl->notify_name)); - /* Resource ID Initialization */ - ptr_tl->uc_rid = CAN_RID_NOTUSE_CODE; - } - - /* CAN command ID initialization */ - for (l_cnt1 = 0; l_cnt1 < CAN_COMMAND_TXRSLT_NUM; l_cnt1++) { - ptr_tl = &g_st_can_cmd_transrslt_dat[l_cnt1]; - switch (l_index) { - case 0: /* CAN section flame reset response transmission */ - ptr_tl->uc_cmd_id = CAN_CMDID_FUELCALC_REQ_TX; - break; - case 1: /* CAN start completion notification request transmission */ - ptr_tl->uc_cmd_id = CAN_CMDID_STARTUP_FIN_REQ_TX; - break; - case 2: /* CAN master reset information notification request transmission */ - ptr_tl->uc_cmd_id = CAN_CMDID_MRST_INFO_REQ_TX; - break; - case 3: /* CAN Version Request Send */ - ptr_tl->uc_cmd_id = CAN_CMDID_VERSION_REQ_TX; - break; - case 4: /* CAN connection node notification request transmission */ - ptr_tl->uc_cmd_id = CAN_CMDID_CONNECTION_NODE_REQ_TX; - break; - } - l_cnt2++; - if (l_cnt2 == CAN_COMMAND_TXRSLT_SNDID_NUM) { - l_cnt2 = 0; - l_index++; - } - } - return; -} diff --git a/communication/server/src/CAN/Delivery/CAN_Delivery.cpp b/communication/server/src/CAN/Delivery/CAN_Delivery.cpp index f4ee1f82..b9914313 100644 --- a/communication/server/src/CAN/Delivery/CAN_Delivery.cpp +++ b/communication/server/src/CAN/Delivery/CAN_Delivery.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,336 +14,392 @@ * limitations under the License. */ -/******************************************************************************* - * Module configuration :CANDataReceiveMsg() CANDataProcess of Received Messages - * CANDlcCheck() DLC check process - * CANDeliveryEntryMsgCheck() CANDataDelivery registration message check process - * CAN_DeliveryCtrlMsg() CANDataDelivery control message processing Not mounted - * CAN_DeliveryCtrlMsgCheck() CANDataDelivery control message check processing Not mounted - * CANCanidIfToUserCvt() CAN ID Conversion Process 1 - ******************************************************************************/ -/*!----------------------------------------------------------------------------- - * @file CAN_Delivery.cpp - * @~english - * @brief CAN Delivery process - */ #include "CAN_Delivery.h" -#include <native_service/frameworkunified_types.h> // NOLINT(build/include) -#include <string.h> -#include "CAN_DeliveryData.h" -#include "CAN_CommWatch.h" + +#include <can_hal.h> +#include <native_service/frameworkunified_framework_if.h> +#include <peripheral_service/Canif_API.h> +#include <can_hal.h> +#include <utility> +#include <map> +#include <string> #include "CAN_TxMsg.h" +#include "CAN_CommWatch.h" +#include "Canif_API_Local.h" +#include "API_Local_Common.h" +#include "Thread_Common.h" -/*************************************************/ -/* Global variables */ -/*************************************************/ -const CANID kCulCanidCsumTbl[] = {/* CAN ID table that performs CSUM checks */ - (CANID)CAN_CSUM_CHECKTBL_STOP_CODE /* Stop code */ -}; - -CAN_MSG_CANGWDATA g_cangw_msg_data; /* CANdata to be sent to the CANGW */ -/******************************************************************************* - * MODULE : CANDataReceiveMsg - ******************************************************************************/ -/*!----------------------------------------------------------------------------- - * @~english - * @brief CAN data reply processing - * - * CAN data reply processing - * - * CANDataReceive processing - * - * @~english - * @note - * -# OPC check - * -# DLC check - * -# CSUM check - * -# Communication blackout clearness - * -# Filter processing - * -# ID list making for delivery - * -# Message sending - * - * @~english - * @return Data reception result - * @retval <RET_CAN_NORMAL> Normality - * @retval <RET_CAN_ERROR_CANCEL> Data annulment - * - * @~english - * @param[in] <pst_rcv_msg> Reception message - */ -RET_CAN CANDataReceiveMsg(HANDLE h_app, CAN_MSG_DATA *pst_rcv_msg) { - RET_CAN ret = RET_CAN_NORMAL; /* Return value of this function */ -// T_ICR_CMD_DATA *pst_msg_data; /* Data part structure pointer */ - CANID can_id; /* CAN ID */ - uint8_t n_ta = CAN_NTA_INVALID; /* N_TA */ - uint8_t uc_dlc; /* DLC */ - uint8_t *puc_data_pos; /* Data */ - uint8_t i; - -// pst_msg_data = reinterpret_cast<T_ICR_CMD_DATA *>(reinterpret_cast<void *>(&pst_rcv_msg->ucData[0])); - g_cangw_msg_data.num = 0; - - /****** OPC check process ******/ -// switch (pst_msg_data->opc) { -// case CAN_OPC_RX: /* CANData reception notice */ -#if 0 - /****** DLC check process ******/ - if (RET_CAN_NORMAL != (ret = CANDlcCheck(pst_msg_data))) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Delivery DLC Error"); - CANDebugLogOut(CAN_DELIVERY_DLCERR, reinterpret_cast<void *>(pst_rcv_msg)); +static CAN_DeliveryEntryList g_map_delivery_list_can; +// Member of g_msg_rx_msg exist as long as communication exists. +static std::map<CANID, CanMessage *> g_can_rx_msg; + +void CANDeliveryInit(void) { + g_map_delivery_list_can.clear(); + return; +} + +static CanMessage *CANMsgFind(CANID k) { + std::map<CANID, CanMessage *>::iterator it; + + it = g_can_rx_msg.find(k); + if (it == g_can_rx_msg.end()) + return NULL; + return it->second; +} + +static void CANMsgInsert(CANID k, CanMessage *msg) { + CanMessage *latest = CANMsgFind(k); + if (!latest) { + latest = new CanMessage(); + } + g_can_rx_msg[k] = latest; + memcpy(latest, msg, sizeof(CanMessage)); +} + +static CAN_DeliveryEntryListIt CANDeliveryFind(CANID canid, std::string s) { + std::pair<CAN_DeliveryEntryListIt, CAN_DeliveryEntryListIt> range; + CAN_DeliveryEntryListPair p = std::make_pair(canid, s); + CAN_DeliveryEntryListIt it; + bool found = false; + range = g_map_delivery_list_can.equal_range(canid); + for (it = range.first; it != range.second; ++it) { + if (*it == p) { + found = true; + break; + } + } + + if (!found) + it = g_map_delivery_list_can.end(); + + return it; +} + +bool CANDeliveryInsert(CANID canid, std::string s) { + CAN_DeliveryEntryListIt it = CANDeliveryFind(canid, s); + CAN_DeliveryEntryListPair p = std::make_pair(canid, s); + bool inserted = false; + + if (it == g_map_delivery_list_can.end()) { + g_map_delivery_list_can.insert(p); + inserted = true; + } + + return inserted; +} + +static EFrameworkunifiedStatus CANDeliverySndCmdSingle(HANDLE h_app, CANID cmd, + CanMessage *msg, std::string dest) { + CAN_MSG_CANCMD st_delivery_msg; + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; + HANDLE h_client; + uint16_t len = 0; + + // Create delivery data + memset(&st_delivery_msg, 0, sizeof(st_delivery_msg)); + switch (cmd) { + case CAN_CMDID_FUELCALC_RST_REQ_RX: + len = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_FUELCALC_RST_SIZE; + break; + case CAN_CMDID_STARTUP_FIN_RESP_RX: + len = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_STARTUP_FIN_SIZE; + break; + case CAN_CMDID_MRST_INFO_RESP_RX: + len = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_MRST_INFO_SIZE; + break; + case CAN_CMDID_VERSION_RESP_RX: + len = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_VERSION_SIZE; + break; + case CAN_CMDID_CONNECTION_NODE_RESP_RX: + len = (uint16_t)(CAN_TX_CMD_DELIVERY_SIZE + msg->data[0] + 1); + break; + default: + return e_status; + } + st_delivery_msg.hdr.hdr.rid = 0; + st_delivery_msg.hdr.hdr.cid = (uint16_t)CID_CAN_CMD_DELIVERY; + st_delivery_msg.hdr.hdr.msgbodysize = len; + st_delivery_msg.data.cmd_id = (uint8_t)cmd; + memcpy(&st_delivery_msg.data.data, msg->data, + (size_t)(len - CAN_TX_CMD_DELIVERY_SIZE)); + + h_client = CommonFindSender(h_app, dest); + if (!h_client) { + return e_status; + } + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "cid=%x msgbodysize=%x cmd_id=%x", + st_delivery_msg.hdr.hdr.cid, st_delivery_msg.hdr.hdr.msgbodysize, + st_delivery_msg.data.cmd_id); + FRAMEWORKUNIFIEDLOG(ZONE_DEBUG, __func__, "msg_data=%s", + MessageDataOutputLog(st_delivery_msg.data.data, len).c_str()); + + e_status = FrameworkunifiedSendMsg(h_client, CID_CAN_CMD_DELIVERY, + sizeof(st_delivery_msg), &st_delivery_msg); + if (e_status != eFrameworkunifiedStatusOK) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedSendMsg Error(e_status:%d to:%s)", + e_status, dest.c_str()); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, + "CAN Delivery : dst = %s, CMD = %x, DLC = %x", + dest.c_str(), cmd, msg->dlc); + } + return e_status; +} + +static EFrameworkunifiedStatus CANDeliverySndMsgSingle(HANDLE h_app, CANID ul_canid, + uint8_t uc_dlc, const uint8_t *puc_data, + enum CanIfEchoBackFlags flag, std::string dest) { + CAN_MSG_CANDATA st_delivery_msg; + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; + HANDLE h_client; + uint8_t uc_size = uc_dlc; + + // Create delivery data + memset(&st_delivery_msg, 0, sizeof(st_delivery_msg)); + st_delivery_msg.hdr.hdr.cid = CID_CAN_DATA_DELIVERY; + st_delivery_msg.hdr.hdr.msgbodysize = (uint16_t)(CAN_TRX_CANID_SIZE + + CAN_TRX_DLC_SIZE + + (uint32_t)uc_size); + st_delivery_msg.hdr.hdr.rid = 0; + st_delivery_msg.data.can_id = ul_canid; + st_delivery_msg.data.dlc = uc_size; + st_delivery_msg.echoback = flag; + if (uc_size > (uint8_t)CAN_DATA_SIZE) + uc_size = CAN_DATA_SIZE; + memcpy(st_delivery_msg.data.data, puc_data, (size_t)uc_size); + + h_client = CommonFindSender(h_app, dest); + if (!h_client) { + return e_status; + } + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "can_id=%x dlc=%x echoback=%d", + st_delivery_msg.data.can_id, st_delivery_msg.data.dlc, + st_delivery_msg.echoback); + FRAMEWORKUNIFIEDLOG(ZONE_DEBUG, __func__, "msg_data=%s", + MessageDataOutputLog(st_delivery_msg.data.data, uc_size).c_str()); + + e_status = FrameworkunifiedSendMsg(h_client, CID_CAN_DATA_DELIVERY, + sizeof(st_delivery_msg), &st_delivery_msg); + if (e_status != eFrameworkunifiedStatusOK) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedSendMsg Error(e_status:%d to:%s)", + e_status, dest.c_str()); + } else { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, + "CAN Delivery : dst = %s, CANID = %x, DLC = %x", + dest.c_str(), ul_canid, uc_dlc); + } + return e_status; +} + +EFrameworkunifiedStatus CANDeliveryEntry(HANDLE h_app) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __func__, "@@@ Start communication CanRecv"); + + uint16_t i; + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; + CAN_DELIVERY_ENTRY rcv_msg; + CAN_DeliveryEntryListIt it; + bool fail = false; + + memset(&rcv_msg, 0, sizeof(rcv_msg)); + e_status = FrameworkunifiedGetMsgDataOfSize(h_app, &rcv_msg, + sizeof(rcv_msg), eSMRRelease); + if (e_status != eFrameworkunifiedStatusOK) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, + "CAN DeliveryEntry FrameworkunifiedGetMsgDataOfSize Error(%d)", e_status); + if (e_status == eFrameworkunifiedStatusInvldBufSize) { + FrameworkunifiedClearMsgData(h_app); + } + goto cleanup; + } + + for (i = 0; i < rcv_msg.usCanNum; i++) { + CANID canid = rcv_msg.ulCanid[i]; + CanMessage *latest = CANMsgFind(canid); + + if (CANDeliveryInsert(canid, rcv_msg.notifyName)) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "(cnd:%lu) : CANID=0x%x, dst=%s", + g_map_delivery_list_can.size(), canid, rcv_msg.notifyName); + } + + if (latest) { + switch (canid) { + case CAN_CMDID_FUELCALC_RST_REQ_RX: + case CAN_CMDID_STARTUP_FIN_RESP_RX: + case CAN_CMDID_MRST_INFO_RESP_RX: + case CAN_CMDID_VERSION_RESP_RX: + case CAN_CMDID_CONNECTION_NODE_RESP_RX: + if (eFrameworkunifiedStatusOK != CANDeliverySndCmdSingle(h_app, canid, + latest, rcv_msg.notifyName)) { + fail = true; + } + break; + default: + if (eFrameworkunifiedStatusOK != CANDeliverySndMsgSingle(h_app, canid, + static_cast<uint8_t>(latest->dlc), + latest->data, CANIF_PURERECV, rcv_msg.notifyName)) { + fail = true; + } break; } -#endif - -// can_id = CANCanidIfToUserCvt(&(pst_msg_data->data[0])); - -// if (pst_msg_data->opc == CAN_OPC_RX) { -// uc_dlc = pst_msg_data->data[CAN_MSGBUF_DLC_POS]; -// puc_data_pos = &pst_msg_data->data[CAN_MSGBUF_DATA_POS]; -// } - -// ret = CANDeliveryRcvData(h_app, can_id, n_ta, uc_dlc, puc_data_pos, pst_msg_data->opc); -// if (ret != RET_CAN_NORMAL) { // LCOV_EXCL_BR_LINE 4: NSFW error case -// AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert -// FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Delivery Error"); // LCOV_EXCL_LINE 4: NSFW error case -// CANDebugLogOut(CAN_DELIVERY_ERR, reinterpret_cast<void *>(pst_rcv_msg)); /* Delivery destination unregistered log output */ // LCOV_EXCL_LINE 4: NSFW error case // NOLINT (whitespace/line_length) -// } -// break; -// case CAN_OPC_PAC_RX: - /* Check CAN Data num */ -// if (0 >= pst_msg_data->data[0] || CAN_EXRCV_DATA_NUM < pst_msg_data->data[0]) { -// FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Delivery CAN Data num Error CAN Data num=%02X", -// pst_msg_data->data[0]); // LCOV_EXCL_BR_LINE 15: marco defined in "native_service/ns_logger_if.h" // NOLINT (whitespace/line_length) -// break; -// } -#if 0 - /****** DLC check process ******/ - if (RET_CAN_NORMAL != (ret = CANDlcCheck(pst_msg_data))) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Delivery CAN Data size over"); - CANDebugLogOut(CAN_DELIVERY_DLCERR, reinterpret_cast<void *>(pst_rcv_msg)); - } - -#endif -// for (i = 0; i < pst_msg_data->data[0]; i++) { -// can_id = CANPacCanidIfToUserCvt(&pst_msg_data->data[i * CAN_EXRCV_DATA_SIZE + CAN_MSGBUF_PAC_CANID_POS]); - -// uc_dlc = pst_msg_data->data[i * CAN_EXRCV_DATA_SIZE + CAN_MSGBUF_PAC_DLC_POS]; -// puc_data_pos = &pst_msg_data->data[i * CAN_EXRCV_DATA_SIZE + CAN_MSGBUF_PAC_DATA_POS]; - -// if (RET_CAN_NORMAL != CANDeliveryRcvData(h_app, can_id, n_ta, uc_dlc, puc_data_pos, pst_msg_data->opc)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT (whitespace/line_length) -// AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert -// ret = RET_CAN_ERROR_CANCEL; // LCOV_EXCL_LINE 4: NSFW error case -// FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Delivery Error"); // LCOV_EXCL_LINE 4: NSFW error case -// CANDebugLogOut(CAN_DELIVERY_ERR, reinterpret_cast<void *>(pst_rcv_msg)); /* Delivery destination unregistered log output */ // LCOV_EXCL_LINE 4: NSFW error case // NOLINT (whitespace/line_length) -// } -// } -// break; -// default: -// ret = RET_CAN_ERROR_CANCEL; -// break; -// } - // When the number of data to be delivered to CANGW_M is 1 or more, the data is sent to CANGW_M by CANDeliverySndMsgToCANGW. - if (0 < g_cangw_msg_data.num) { - // Sending CAN-data delivery messages to the CANGW - if (FALSE == CANDeliverySndMsgToCANGW(h_app, &g_cangw_msg_data)) { // LCOV_EXCL_BR_LINE 4: NSFW error case - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Delivery Error"); // LCOV_EXCL_LINE 4: NSFW error case - ret = RET_CAN_ERROR_CANCEL; // LCOV_EXCL_LINE 4: NSFW error case } } - return (ret); + + if (fail) + e_status = eFrameworkunifiedStatusFail; + +cleanup: + return e_status; } -/*!----------------------------------------------------------------------------- - * @~english - * @brief Recieve data delivery before processing - * - * @~english - * @return Return value - * @retval <RET_CAN_NORMAL> OK - * @retval <RET_CAN_ERROR_CANCEL> Delivery Error - * - * @~english - * @param[in] <h_app> Application handle - * @param[in] <ul_canid> CAN ID - * @param[in] <n_ta> N_TA - * @param[in] <uc_dlc> DLC - * @param[in] <puc_data_pos> CAN Data - * @param[in] <opc> OPC - */ -RET_CAN CANDeliveryRcvData(HANDLE h_app, CANID ul_canid, uint8_t n_ta, - uint8_t uc_dlc, uint8_t *puc_data_pos, uint8_t opc) { - RET_CAN ret = RET_CAN_NORMAL; - - /****** Communication interruption clear processing ******/ - CANCommWatchClear(h_app, ul_canid); - - /****** CANDataSending a delivery message ******/ - if (FALSE == CANDeliverySndMsg(h_app, ul_canid, uc_dlc, puc_data_pos, opc, n_ta)) { // LCOV_EXCL_BR_LINE 4: NSFW error case // NOLINT (whitespace/line_length) - /* CANDataDelivery message transmission processing */ - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Delivery Error"); // LCOV_EXCL_LINE 4: NSFW error case - ret = RET_CAN_ERROR_CANCEL; // LCOV_EXCL_LINE 4: NSFW error case +static EFrameworkunifiedStatus CANDeliverySndMsgToClient(HANDLE h_app, CANID ul_canid, + void *data, size_t size, PS_CommunicationProtocol cid) { + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; + HANDLE h_client = NULL; + CAN_DeliveryEntryListIt it; + std::pair<CAN_DeliveryEntryListIt, CAN_DeliveryEntryListIt> range; + bool fail = false; + + it = g_map_delivery_list_can.find(ul_canid); + range = g_map_delivery_list_can.equal_range(ul_canid); + for (it = range.first; it != range.second; ++it) { + h_client = CommonFindSender(h_app, it->second); + if (!h_client) { + continue; + } + + e_status = FrameworkunifiedSendMsg(h_client, cid, (UI_32)size, data); + if (e_status != eFrameworkunifiedStatusOK) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedSendMsg Error(e_status:%d to:%s)", + e_status, it->second.c_str()); + fail = true; + } } + return fail ? eFrameworkunifiedStatusFail : eFrameworkunifiedStatusOK; +} + +EFrameworkunifiedStatus CANDeliverySndMsg(HANDLE h_app, CANID ul_canid, uint8_t n_ta, + uint8_t uc_dlc, const uint8_t *puc_data, + PS_CommunicationProtocol cid, enum CanIfEchoBackFlags flag) { + CAN_MSG_CANDATA st_delivery_msg; + uint8_t uc_size = uc_dlc; + + // Create delivery data + memset(&st_delivery_msg, 0, sizeof(st_delivery_msg)); + st_delivery_msg.hdr.hdr.cid = cid; + st_delivery_msg.hdr.hdr.msgbodysize = (uint16_t)(CAN_TRX_CANID_SIZE + + CAN_TRX_DLC_SIZE + + (uint32_t)uc_size); + st_delivery_msg.hdr.hdr.rid = 0; + st_delivery_msg.data.can_id = ul_canid; + st_delivery_msg.data.dlc = uc_size; + st_delivery_msg.echoback = flag; + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "can_id=%x dlc=%x echoback=%d", + st_delivery_msg.data.can_id, st_delivery_msg.data.dlc, + st_delivery_msg.echoback); + FRAMEWORKUNIFIEDLOG(ZONE_DEBUG, __func__, "msg_data=%s", + MessageDataOutputLog(st_delivery_msg.data.data, uc_size).c_str()); - return ret; + + if (uc_size > (uint8_t)CAN_DATA_SIZE) + uc_size = CAN_DATA_SIZE; + memcpy(st_delivery_msg.data.data, puc_data, (size_t)uc_size); + + return CANDeliverySndMsgToClient(h_app, ul_canid, &st_delivery_msg, + sizeof(st_delivery_msg), cid); } -/*!----------------------------------------------------------------------------- - * @~english - * @brief Recieve _CWORD29_ data delivery before processing - * - * @~english - * @return Return value - * @retval <RET_CAN_NORMAL> OK - * @retval <RET_CAN_ERROR_CANCEL> Delivery Error - * - * @~english - * @param[in] <h_app> Application handle - * @param[in] <us_opc> OPC - * @param[in] <uc_dlc> DLC - * @param[in] <puc_data_pos> CAN Data - */ -RET_CAN CANDeliveryRcv_CWORD29_Data(HANDLE h_app, const uint16_t us_opc, uint32_t uc_dlc, uint8_t *puc_data_pos) { - RET_CAN ret = RET_CAN_NORMAL; - - /****** CANDataSending a delivery message ******/ - if (FALSE == CANDelivery_CWORD29_SndMsg(h_app, us_opc, uc_dlc, puc_data_pos)) { - /* CANDataDelivery message transmission processing */ - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Delivery Error"); - ret = RET_CAN_ERROR_CANCEL; +EFrameworkunifiedStatus CANCommandDeliveryRcvProcess(HANDLE h_app, + CanMessage *msg, uint8_t cmd) { + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; + CAN_MSG_CANCMD st_delivery_msg; + uint16_t len = 0; + + memset(&st_delivery_msg, 0, sizeof(st_delivery_msg)); + switch (cmd) { + case CAN_CMDID_FUELCALC_RST_REQ_RX: + len = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_FUELCALC_RST_SIZE; + break; + case CAN_CMDID_STARTUP_FIN_RESP_RX: + len = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_STARTUP_FIN_SIZE; + break; + case CAN_CMDID_MRST_INFO_RESP_RX: + len = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_MRST_INFO_SIZE; + break; + case CAN_CMDID_VERSION_RESP_RX: + len = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_VERSION_SIZE; + break; + case CAN_CMDID_CONNECTION_NODE_RESP_RX: + len = (uint16_t)(CAN_TX_CMD_DELIVERY_SIZE + msg->data[0] + 1); + break; + default: + return e_status; } + st_delivery_msg.hdr.hdr.rid = 0; + st_delivery_msg.hdr.hdr.cid = (uint16_t)CID_CAN_CMD_DELIVERY; + st_delivery_msg.hdr.hdr.msgbodysize = len; + st_delivery_msg.data.cmd_id = cmd; + memcpy(&st_delivery_msg.data.data, msg->data, + (size_t)(len - CAN_TX_CMD_DELIVERY_SIZE)); + CANMsgInsert(cmd, msg); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "cid=%x msgbodysize=%x cmd_id=%x", + st_delivery_msg.hdr.hdr.cid, st_delivery_msg.hdr.hdr.msgbodysize, + st_delivery_msg.data.cmd_id); + FRAMEWORKUNIFIEDLOG(ZONE_DEBUG, __func__, "msg_data=%s", + MessageDataOutputLog(st_delivery_msg.data.data, len).c_str()); - return ret; + return CANDeliverySndMsgToClient(h_app, msg->can_id, &st_delivery_msg, + sizeof(st_delivery_msg), CID_CAN_CMD_DELIVERY); } -/******************************************************************************* - * MODULE : CANDlcCheck - ******************************************************************************/ -/*!----------------------------------------------------------------------------- - * @~english - * @brief DLC check processing - * - * DLC check processing of received CAN data - * - * CANDataCheck the PROCESS - * - * @~english - * @note - * -# Length acquisition of header - * -# Positional change of DLC - * -# Data length calculation - * -# Data length comparison - * - * @~english - * @param[in] <pst_msg_data> Pointer of reference to data division of reception message - */ -//RET_CAN CANDlcCheck(const T_ICR_CMD_DATA *pst_msg_data) { // LCOV_EXCL_START 8: dead code -// AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert -// RET_CAN ret = RET_CAN_NORMAL; /* Return value of this function */ -// int32_t l_len1; /* For data length calculation */ -// int32_t l_len2; /* For data length calculation */ -// uint8_t offset = 0; /* N_TA offset size */ -// uint8_t uc_dlc; /* DLC value */ - - /* Length collection of headers */ -// l_len1 = (int32_t)pst_msg_data->d_length; - -// if ((uint8_t)CAN_OPC_PAC_RX == pst_msg_data->opc) { -// l_len2 = (int32_t)(CAN_EXRCV_DATA_SIZE * pst_msg_data->data[0] + CAN_EXRCV_CANNUM_SIZE); - - /* DLC check of pacaging CAN data */ -// if (l_len1 != l_len2) { -// ret = RET_CAN_ERROR_CANCEL; /* DLC error */ -// } -// } else { -// uc_dlc = (uint8_t)pst_msg_data->data[CAN_MSGBUF_DLC_POS]; - /* Data length considered from the DLC */ -// l_len2 = (int32_t)CAN_TRX_CANID_SIZE /* CAN ID sizes */ -// + (int32_t)CAN_TRX_DLC_SIZE /* Size of the DLC */ -// + (int32_t)offset /* Size of N_TA */ -// + (int32_t)uc_dlc; /* CANDataLength: DLC content */ - - /* "Comparison of Length of headers and data length considered from DLCs */ - /* "Valid if the actual data length is equal to or less than the DLC */ -// if (l_len1 < l_len2) { -// ret = RET_CAN_ERROR_CANCEL; /* DLC error */ -// } else if (uc_dlc > (uint8_t)CAN_DATA_SIZE) { - /* CANDataDisabled when exceeding maximum size */ -// ret = RET_CAN_ERROR_CANCEL; /* DLC error */ -// } else { - /* No DLC error */ -// } -// } - -// return (ret); -//} -// LCOV_EXCL_STOP - -/******************************************************************************* - * MODULE : CANCanidIfToUserCvt - * ABSTRACT : CAN ID Conversion Process 1 - * FUNCTION : Convert CAN ID for interfaces to CAN ID for USER - * ARGUMENT : *puc_operand :Operand reference pointer - * NOTE : - * RETURN : CAN ID - ******************************************************************************/ -CANID CANCanidIfToUserCvt(uint8_t *puc_operand) { - CANID can_id = 0; /* CAN ID */ - uint8_t *puc; /* Generic pointer */ - uint32_t ul = 0; /* General Variables */ - - /* Concept of conversion - Input data format (8-bit data with the following structure) - Base Address +0 :ext_flag, CAN ID[10:4] - +1 :CAN ID[3:0], Empty[1:0], CAN ID[28:27] - +2 :CAN ID[26:19] - +3 :CAN ID[18:11] - Output data format (32-bit data) - Bit assignment [31:29] [28:0] - CAN ID Empty[2:0] CAN ID[28:0] -*/ - - puc = &puc_operand[CAN_MSGBUF_CANID_POS]; /* Get Base Address of CAN ID */ - ul = (uint32_t)puc[0] & 0x7F; /* Contain [10:4] data */ - ul <<= 4; - can_id |= (CANID)ul; - ul = (uint32_t)puc[1] & 0xF0; /* Insert data of [3:0] */ - ul >>= 4; - can_id |= (CANID)ul; - ul = (uint32_t)puc[1] & 0x03; /* Populate [28:27] */ - ul <<= 27; - can_id |= (CANID)ul; - ul = (uint32_t)puc[2]; /* Contain [26:19] data */ - ul <<= 19; - can_id |= (CANID)ul; - ul = (uint32_t)puc[3]; /* Populate [18:11] */ - ul <<= 11; - can_id |= (CANID)ul; - - return (can_id); +EFrameworkunifiedStatus CANDeliveryRcvProcess(HANDLE h_app, CanMessage *msg) { + if (!Canif_CheckCanID(msg->can_id)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "CANID is invalid (%x)", msg->can_id); + return eFrameworkunifiedStatusFail; + } + + CANCommWatchClear(h_app, msg->can_id); + CANMsgInsert(msg->can_id, msg); + if (eFrameworkunifiedStatusOK != CANDeliverySndMsg(h_app, msg->can_id, CAN_NTA_INVALID, + (uint8_t)msg->dlc, msg->data, CID_CAN_DATA_DELIVERY)) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "CAN Delivery Error"); + return eFrameworkunifiedStatusFail; + } + + return eFrameworkunifiedStatusOK; } -/******************************************************************************* - * MODULE : CANPacCanidIfToUserCvt - * ABSTRACT : CAN ID Conversion Process 1 - * FUNCTION : Convert CAN ID for interfaces to CAN ID for USER - * ARGUMENT : *puc_operand :Operand reference pointer - * NOTE : - * RETURN : CAN ID - ******************************************************************************/ -CANID CANPacCanidIfToUserCvt(uint8_t *puc_operand) { - CANID can_id = 0; - uint8_t *puc; - uint32_t ul = 0; - - puc = &puc_operand[0]; - ul = (uint32_t)puc[0] & 0x7F; - ul <<= 4; - can_id |= (CANID)ul; - ul = (uint32_t)puc[1] & 0xF0; - ul >>= 4; - can_id |= (CANID)ul; - - return (can_id); +EFrameworkunifiedStatus CANClearEntry(HANDLE h_app) { + char notify_name[CANIF_NOTIFY_NAME_MAX_SIZE + 1] = {0}; + CAN_DeliveryEntryListIt it; + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; + + e_status = FrameworkunifiedGetMsgDataOfSize(h_app, ¬ify_name, + CANIF_NOTIFY_NAME_MAX_SIZE, eSMRRelease); + if (e_status != eFrameworkunifiedStatusOK) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, + "#CAN thread# FrameworkunifiedGetMsgDataOfSize Error(%d)", e_status); + if (e_status == eFrameworkunifiedStatusInvldBufSize) { + FrameworkunifiedClearMsgData(h_app); + } + return e_status; + } + + FRAMEWORKUNIFIEDLOG(ZONE_DEBUG, __func__, "notify_name=%s", notify_name); + + // To avoid destruction of iterator. + it = g_map_delivery_list_can.begin(); + while (it != g_map_delivery_list_can.end()) { + size_t n = strnlen(it->second.c_str(), CANIF_NOTIFY_NAME_MAX_SIZE); + if (!strncmp(it->second.c_str(), notify_name, n)) { + g_map_delivery_list_can.erase(it++); + } else { + ++it; + } + } + + return eFrameworkunifiedStatusOK; } diff --git a/communication/server/src/CAN/Delivery/CAN_DeliveryData.cpp b/communication/server/src/CAN/Delivery/CAN_DeliveryData.cpp deleted file mode 100644 index a0bc1f0f..00000000 --- a/communication/server/src/CAN/Delivery/CAN_DeliveryData.cpp +++ /dev/null @@ -1,214 +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_DeliveryData.cpp - * SYSTEM :_CWORD107_ - * SUBSYSTEM :EXL process - * PROGRAM :CAN thread CAN data delivery data management - * Module configuration :CANDeliveryDataInit( ) CANDataDelivery Management Data Initialization Process - * CAN_DeliveryCanidCheck( ) CAN ID registration and delivery registration checking process - * CAN_DeliveryListCapacityCheck( ) CANDataDistribution destination management table free space confirmation processing - * CAN_DeliveryCanidEntryCheck( ) CANDataChecking the status of delivery CAN ID control table entries - * CANDeliveryEntry( ) CANDataDelivery registration process - * CAN_SndListGenerate( ) CANData ID List Creation Process for Delivery - ******************************************************************************/ -#include "CAN_DeliveryData.h" - -#include <string.h> // NOLINT(build/include) -#include <native_service/frameworkunified_framework_if.h> -#include <other_service/strlcpy.h> - -#include <utility> -#include <string> -#include <map> - -#include "CAN_Thread.h" -#include "CAN_Delivery.h" -#include "Canif_API_Local.h" -//#include "can_hal.h" - -/*************************************************/ -/* Global variables */ -/*************************************************/ -std::multimap<CANID, std::string> g_map_delivery_list; -std::multimap<uint16_t, std::string> g_map__CWORD29__delivery_list; - -/******************************************************************************* - * MODULE : CANDeliveryDataInit - * ABSTRACT : CANDataDelivery Management Data Initialization Process - * FUNCTION : CANDataInitialize delivery management data for - * ARGUMENT : void - * NOTE : - * RETURN : void - ******************************************************************************/ -void CANDeliveryDataInit(void) { - return; -} - -/******************************************************************************* - * MODULE : CANDeliveryEntry - * ABSTRACT : CANDataDelivery registration process - * FUNCTION : CANDataRegister delivery - * ARGUMENT : notifyId : Addresses for delivery ID - * usCanNum : Registered number - * *pulCanid : CAN ID array pointers - * NOTE : - * RETURN : void - ******************************************************************************/ -EFrameworkunifiedStatus CANDeliveryEntry(HANDLE h_app) { - uint16_t i; - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - CAN_DELIVERY_ENTRY rcv_msg; - std::string notify_name; - std::multimap<CANID, std::string>::iterator it; - - e_status = FrameworkunifiedGetMsgDataOfSize(h_app, &rcv_msg, sizeof(rcv_msg), eSMRRelease); // LCOV_EXCL_BR_LINE 200: unexpect branch // NOLINT (whitespace/line_length) - if (e_status != eFrameworkunifiedStatusOK) { // LCOV_EXCL_BR_LINE 4: NSFW error case - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN DeliveryEntry FrameworkunifiedGetMsgDataOfSize Error"); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT (whitespace/line_length) - goto exit; // LCOV_EXCL_LINE 4: NSFW error case - } - - for (i = 0; (i < rcv_msg.usCanNum) && (i < static_cast<uint16_t>(CAN_DELIVERY_CANID_ENTRY_MAX)); i++) { - // Check for duplicate data - // If the data to be registered is duplicated, an eFrameworkunifiedStatusOK is returned and the data is not registered. - bool isDuplication = false; - it = g_map_delivery_list.find(static_cast<std::multimap<CANID, std::string>::key_type>(rcv_msg.ulCanid[i])); - for (; it != g_map_delivery_list.end(); ++it) { - if (it->second == rcv_msg.notifyName) { - isDuplication = true; - break; - } - } - if (isDuplication) { - continue; - } - - if ((uint32_t)g_map_delivery_list.size() >= CAN_DELIVERY_LIST_NUM) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN DeliveryEntry Table MAX size over"); // LCOV_EXCL_BR_LINE 15: marco defined in "native_service/ns_logger_if.h" // NOLINT (whitespace/line_length) - e_status = eFrameworkunifiedStatusFail; - break; - } - FRAMEWORKUNIFIEDLOG(ZONE_ENTRY, "", "[CAN] %04x %s", rcv_msg.ulCanid[i], rcv_msg.notifyName); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT (whitespace/line_length) - notify_name = rcv_msg.notifyName; - g_map_delivery_list.insert(std::make_pair(rcv_msg.ulCanid[i], notify_name)); // LCOV_EXCL_BR_LINE 200: unexpect branch // NOLINT (whitespace/line_length) - } - -exit: - return e_status; -} - -/******************************************************************************* - * MODULE : CAN_CWORD29_DeliveryEntry - * ABSTRACT : Process of registering the delivery of _CWORD29_ data - * FUNCTION : Register the delivery of _CWORD29_ data - * ARGUMENT : h_app : HANDLE - * NOTE : - * RETURN : EFrameworkunifiedStatus - ******************************************************************************/ -EFrameworkunifiedStatus CAN_CWORD29_DeliveryEntry(HANDLE h_app) { - uint16_t i; - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - CAN__CWORD29__DELIVERY_ENTRY rcv_msg; - std::string notify_name; - std::multimap<uint16_t, std::string>::iterator it; - - if (reinterpret_cast<HANDLE>(NULL) == h_app) { - return eFrameworkunifiedStatusFail; - } - - e_status = FrameworkunifiedGetMsgDataOfSize(h_app, reinterpret_cast<PVOID>(&rcv_msg), - static_cast<UI_32>(sizeof(CAN__CWORD29__DELIVERY_ENTRY)), eSMRRelease); - if (e_status != eFrameworkunifiedStatusOK) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN DeliveryEntry FrameworkunifiedGetMsgDataOfSize Error"); - return e_status; - } - - if (CAN_DELIVERY_OPC_ENTRY_MAX <= rcv_msg.usOpcNum) { - e_status = eFrameworkunifiedStatusFail; - return e_status; - } - - for (i = 0; i < rcv_msg.usOpcNum; i++) { - // Check for duplicate data - // If the data to be registered is duplicated, an eFrameworkunifiedStatusOK is returned and the data is not registered. - bool isDuplication = false; - it = g_map__CWORD29__delivery_list.find(static_cast<std::multimap<uint16_t, std::string>::key_type>(rcv_msg.usOpc[i])); - for (; it != g_map__CWORD29__delivery_list.end(); ++it) { - if (it->second == rcv_msg.notifyName) { - isDuplication = true; - break; - } - } - if (isDuplication) { - continue; - } - - if (static_cast<uint32_t>(g_map__CWORD29__delivery_list.size()) >= CAN_DELIVERY_LIST_NUM) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# _CWORD29_DeliveryEntry Table MAX size over"); - e_status = eFrameworkunifiedStatusFail; - break; - } - FRAMEWORKUNIFIEDLOG(ZONE_ENTRY, "", "[OPC] %04x %s", rcv_msg.usOpc[i], rcv_msg.notifyName); - notify_name = rcv_msg.notifyName; - g_map__CWORD29__delivery_list.insert(std::make_pair(rcv_msg.usOpc[i], notify_name)); - } - - return e_status; -} - -/******************************************************************************* - * MODULE : CANDeliveryBufferOut - * ABSTRACT : CAN shipping table log output processing - * FUNCTION : Output the CAN shipping table log - * ARGUMENT : FILE *fp_log : File pointer of the log output file - * NOTE : - * RETURN : Thread ID - ******************************************************************************/ -void CANDeliveryBufferOut(FILE *fp_log) { // LCOV_EXCL_START 8:dead code - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - uint32_t usage_rate; - std::multimap<CANID, std::string>::iterator it; - - if (NULL != fp_log) { - /* Destination management table output */ - usage_rate = (((uint32_t)g_map_delivery_list.size() * 100) / CAN_DELIVERY_LIST_NUM); - (void)fprintf(fp_log, "CAN DeliveryList_Buffer \n"); - (void)fprintf(fp_log, "BUFFER_Use: %04zu BUFFER_Max: %04d Usage_Rate: %04u \n", - g_map_delivery_list.size(), CAN_DELIVERY_LIST_NUM, usage_rate); - if (usage_rate >= CAN_USAGE_RATE_THRESHOLD) { - (void)fprintf(fp_log, "Warning: Buffer utilization exceeds a threshold.\n"); - } - (void)fprintf(fp_log, "CanID: notifyId:\n"); - - for (it = g_map_delivery_list.begin(); it != g_map_delivery_list.end(); it++) { - (void)fprintf(fp_log, "%08x %s\n", - it->first, - it->second.c_str()); - } - } -} -// LCOV_EXCL_STOP - -#ifdef CAN_DEBUG -EFrameworkunifiedStatus CANAllDeleteDeliveryEntry(HANDLE h_app) { - g_map_delivery_list.clear(); - g_map__CWORD29__delivery_list.clear(); - - return eFrameworkunifiedStatusOK; -} // LCOV_EXCL_BR_LINE 10 last Line -#endif diff --git a/communication/server/src/CAN/TimerCtrl/CAN_TimerCtrl.cpp b/communication/server/src/CAN/TimerCtrl/CAN_TimerCtrl.cpp deleted file mode 100644 index 9e3ac384..00000000 --- a/communication/server/src/CAN/TimerCtrl/CAN_TimerCtrl.cpp +++ /dev/null @@ -1,405 +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_TimerCtrl.cpp - * SYSTEM :_CWORD107_ - * SUBSYSTEM :EXL process - * PROGRAM :CAN thread timer management processing - * Module configuration :CANFreqTransTimerStart() Periodic transmission timer start processing - * :CANFreqTransTimerStop() Periodic transmission timer stop processing - * :CANCommWatchTimerStart() Communication interruption monitoring timer start processing - * :CANCommWatchTimerStop() Communication interruption monitoring timer stop processing - * :CANCommWatchTimerRenewal() Communication interruption monitoring timer update processing - * :CANFreqTransTimeOut() CAN periodic transmission timeout confirmation processing - * :CANCommWatchTimeOut() CAN Communication Disruption Monitoring Timeout Confirmation Process - * :CANTimerStart() CAN Timer Master Processing - * :CANTimerTblInit() CAN timer table initialization processing - ******************************************************************************/ -#include "CAN_TimerCtrl.h" - -#include <string.h> // NOLINT (build/include) -#include <native_service/frameworkunified_types.h> -#include <peripheral_service/Canif_API.h> -#include <map> -#include "CAN_Thread.h" -#include "CAN_CommWatch.h" -#include "CAN_Transmission.h" -#include "CAN_TransmissionData.h" -#include "CAN_CommWatchData.h" - - -using std::map; - -/*************************************************/ -/* Global variable */ -/*************************************************/ -CAN_FREQTRANS_TIMER g_st_can_freq_trans_tim[CAN_PROTOCOL_TYPE_TERMINATE]; /* CAN Periodic Transmission Timer Management Table */ -CAN_COMMWATCH_TIMER g_st_can_comm_watch_tim[CAN_PROTOCOL_TYPE_TERMINATE]; /* CAN communication interruption monitoring timer management table */ -map<CANID, CAN_TIMER_CTRL_DATA> g_map_can_freq_trans_time; /* Periodic transmission CAN Command management table */ - -/******************************************************************************* - * MODULE : CANFreqTransTimerStart - * ABSTRACT : Periodic transmission timer start processing - * FUNCTION : Registering a Periodic Transmission Timer (Periodic Timer) - * ARGUMENT : uc_index : Indexed - * : us_time : Periodic send timer value - * NOTE : - * RETURN : RET_CAN_NORMAL : Normal completion - * RET_CAN_ERROR_TIMER : Timer acquisition failed - ******************************************************************************/ -RET_CAN CANFreqTransTimerStart(uint8_t uc_index, uint16_t us_time, CAN_PROTOCOL_TYPE type) { - RET_CAN ret = RET_CAN_NORMAL; /* Return value of this function */ - - /* Timer not started for specified index */ - if ((uint16_t)0 == g_st_can_freq_trans_tim[type].data[uc_index].us_set_tim) { - /* Updating the number of timer registrations */ - g_st_can_freq_trans_tim[type].us_num++; - } - /* Regular transmission interval timer registration */ - CANTimerStart(us_time, & g_st_can_freq_trans_tim[type].data[uc_index]); - - return (ret); -} - -/******************************************************************************* - * MODULE : CANFreqTransTimerStop - * ABSTRACT : Periodic transmission timer stop processing - * FUNCTION : Stops the periodic transmission timer (periodic timer). - * ARGUMENT : uc_index : Indexed - * NOTE : - * RETURN : RET_CAN_NORMAL : Normal completion - * RET_CAN_ERROR_TIMER : Failed to stop timer - ******************************************************************************/ -RET_CAN CANFreqTransTimerStop(uint8_t uc_index, CAN_PROTOCOL_TYPE type) { - RET_CAN ret = RET_CAN_NORMAL; /* Return value of this function */ - - if ((uint16_t)0 < g_st_can_freq_trans_tim[type].data[uc_index].us_set_tim) { - /* Stop the CAN periodic transmission timer. */ - g_st_can_freq_trans_tim[type].data[uc_index].us_set_tim = 0; - g_st_can_freq_trans_tim[type].data[uc_index].us_tim_cnt = 0; - g_st_can_freq_trans_tim[type].us_num--; - } - - return (ret); -} - -/******************************************************************************* - * MODULE : CANCommWatchTimerStart - * ABSTRACT : Communication interruption monitoring timer start processing - * FUNCTION : Register the communication interruption monitoring timer (single occurrence timer) - * ARGUMENT : uc_index : Indexed - * : usWatchTim : Communication interruption monitoring time - * NOTE : - * RETURN : RET_CAN_NORMAL : Normal completion - * RET_CAN_ERROR_TIMER : Timer acquisition failed - ******************************************************************************/ -RET_CAN CANCommWatchTimerStart(uint8_t uc_index, uint16_t us_watch_time, CAN_PROTOCOL_TYPE type) { - RET_CAN ret = RET_CAN_NORMAL; /* Return value of this function */ - uint16_t us_val; - uint16_t us_tim; - - /* Update Timer Sequence Number */ - CANCommWatchTimerSeqNoRenwal(uc_index, &us_val, type); - us_tim = (uint16_t)((uint32_t)us_watch_time + 1); - /* Registration of communication interruption monitoring timer */ - CANTimerStart(us_tim, &g_st_can_comm_watch_tim[type].data[uc_index]); - /* Updating the number of timer registrations */ - g_st_can_comm_watch_tim[type].us_num++; - - return (ret); -} - -/******************************************************************************* - * MODULE : CANCommWatchTimerStop - * ABSTRACT : Communication interruption monitoring timer stop processing - * FUNCTION : Stop the communication interruption monitoring timer (single occurrence timer) - * ARGUMENT : uc_index : Indexed - * NOTE : - * RETURN : RET_CAN_NORMAL : Normal completion - * RET_CAN_ERROR_TIMER : Failed to stop timer - ******************************************************************************/ -RET_CAN CANCommWatchTimerStop(uint8_t uc_index, CAN_PROTOCOL_TYPE type) { - RET_CAN ret = RET_CAN_NORMAL; /* Return value of this function */ - - if ((uint16_t)0 < g_st_can_comm_watch_tim[type].data[uc_index].us_set_tim) { - /* Timer stop */ - g_st_can_comm_watch_tim[type].data[uc_index].us_set_tim = 0; - g_st_can_comm_watch_tim[type].data[uc_index].us_tim_cnt = 0; - g_st_can_comm_watch_tim[type].us_num--; - } - - return (ret); -} - -/******************************************************************************* - * MODULE : CANCommWatchTimerRenewal - * ABSTRACT : Communication interruption monitoring timer update processing - * FUNCTION : Update communication interruption monitoring timer - * ARGUMENT : uc_index : Indexed - * NOTE : - * RETURN : RET_CAN_NORMAL : Normal completion - * RET_CAN_ERROR_TIMER : Timer acquisition or stop failed - ******************************************************************************/ -RET_CAN CANCommWatchTimerRenewal(uint8_t uc_index, CAN_PROTOCOL_TYPE type) { - RET_CAN ret = RET_CAN_NORMAL; /* Return value of this function */ - uint16_t us_time; /* Communication interruption time */ - - /* Stop timer during startup */ - ret = CANCommWatchTimerStop(uc_index, type); - /* Update Timer Sequence Number */ - (void)CANCommWatchTimerSeqNoRenwal(uc_index, &us_time, type); - /* Registration of communication interruption monitoring timer */ - CANTimerStart(us_time, &g_st_can_comm_watch_tim[type].data[uc_index]); - /* Updating the number of timer registrations */ - g_st_can_comm_watch_tim[type].us_num++; - - return (ret); -} - -/******************************************************************************* - * MODULE : CANFreqTransTimeOut - * ABSTRACT : CAN periodic transmission timeout confirmation processing - * FUNCTION : CAN periodic transmission timeout confirmation processing - * ARGUMENT : *pst_rcv_msg : Received Message Reference Pointer - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANFreqTransTimeOut(HANDLE h_app, uint16_t timer_seq, CAN_PROTOCOL_TYPE type) { - uint16_t us_tim_pos; - uint16_t us_tim_num; - - us_tim_num = g_st_can_freq_trans_tim[type].us_num; - /* Timer start */ - if ((uint16_t)0 < us_tim_num) { - /* Check the timeout of the CAN periodic transmission timer table */ - for (us_tim_pos = 0; us_tim_pos < (uint16_t)CAN_FREQTRANS_TIMER_DATA; us_tim_pos++) { - /* When the timer is starting */ - if ((uint16_t)0 < g_st_can_freq_trans_tim[type].data[us_tim_pos].us_tim_cnt) { - /* Decrement timer value */ - g_st_can_freq_trans_tim[type].data[us_tim_pos].us_tim_cnt--; - /* Detect timeouts */ - if ((uint16_t)0 == g_st_can_freq_trans_tim[type].data[us_tim_pos].us_tim_cnt) { - /* Execute the CAN periodic transmission timeout processing */ - if (type == CAN_PROTOCOL_TYPE_CAN) { - /* Setting data for timeout messages */ - timer_seq = (uint16_t)((uint32_t)us_tim_pos | FREQ_TRANS_SEQNO_CODE); - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "CANFreqTxTimeupMsg Execute(us_tim_pos=%d, TimerSeq=%x)", us_tim_pos, - timer_seq); - CANFreqTxTimeupMsg(h_app, timer_seq); - } - /* Reset timer value and continue timer operation */ - g_st_can_freq_trans_tim[type].data[us_tim_pos].us_tim_cnt = - g_st_can_freq_trans_tim[type].data[us_tim_pos].us_set_tim; - } - us_tim_num--; - /* Check completed for the number of timer entries */ - if ((uint16_t)0 == us_tim_num) { - break; - } - } - } - } -} - -/******************************************************************************* - * MODULE : CANCommWatchTimeOut - * ABSTRACT : CAN Communication Disruption Monitoring Timeout Confirmation Process - * FUNCTION : CAN Communication Disruption Monitoring Timeout Confirmation Process - * ARGUMENT : None - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANCommWatchTimeOut(HANDLE h_app, CAN_PROTOCOL_TYPE type) { - uint8_t us_tim_pos; - uint16_t us_tim_num; - uint16_t us_timer_seq_no; - RET_CAN ret; - - us_tim_num = g_st_can_comm_watch_tim[type].us_num; - /* Timer start */ - if ((uint16_t)0 < us_tim_num) { - /* Check timeout of CAN communication interruption monitoring timer table */ - for (us_tim_pos = 0; us_tim_pos < (uint8_t)CAN_COMMWATCH_TIMER_DATA; us_tim_pos++) { - /* When the timer is starting */ - if ((uint16_t)0 < g_st_can_comm_watch_tim[type].data[us_tim_pos].us_tim_cnt) { - /* Decrement timer value */ - g_st_can_comm_watch_tim[type].data[us_tim_pos].us_tim_cnt--; - /* Detect timeouts */ - if ((uint16_t)0 == g_st_can_comm_watch_tim[type].data[us_tim_pos].us_tim_cnt) { - /* Time-out detected */ - us_timer_seq_no = CANCommWatchTimerSeqNoGet(us_tim_pos, type); - - /* Execute CAN communication interruption monitoring timeout processing */ - switch (type) { - case CAN_PROTOCOL_TYPE_CAN: - ret = CANCommWatchTimeoutMsg(h_app, us_timer_seq_no); - if (RET_CAN_NORMAL != ret) { // LCOV_EXCL_BR_LINE 8: If us_timer_seq_no is valid, it will not return NON-RET_CAN_NORMAL // NOLINT (whitespace/line_length) - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 8: same with above // NOLINT (whitespace/line_length) - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN CommWatch TimeoutMsg Error"); // LCOV_EXCL_LINE 8: same with above // NOLINT (whitespace/line_length) - } - break; - default: - break; - } - - /* Deletes the CAN communication interruption monitoring timer table. */ - CANCommWatchTimerStop(us_tim_pos, type); - } - us_tim_num--; - /* Check completed for the number of timer entries */ - if (us_tim_num == (uint16_t)0) { - break; - } - } - } - } -} - -/******************************************************************************* - * MODULE : CANTimerStart - * ABSTRACT : CAN Timer Master Processing - * FUNCTION : CAN Timer Master Processing - * ARGUMENT : u_int16 us_time Setting timer value - * : CAN_TIMER_CTRL_DATA *pst_can_timer_tbl Timer table pointer to edit - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANTimerStart(uint16_t us_time, CAN_TIMER_CTRL_DATA *pst_can_timer_tbl) { - /* Update the timeout value */ - pst_can_timer_tbl->us_set_tim = us_time; - /* Begin detecting timeouts */ - pst_can_timer_tbl->us_tim_cnt = us_time; -} - -/******************************************************************************* - * MODULE : CANTimerTblInit - * ABSTRACT : CAN timer table initialization processing - * FUNCTION : CAN Timer Table Initialization Processing - * ARGUMENT : None - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANTimerTblInit(void) { - for (int i = 0; i < CAN_PROTOCOL_TYPE_TERMINATE; i++) { - /* Initialization of the CAN periodic transmission timer table */ - memset(& g_st_can_freq_trans_tim[i], 0, sizeof( g_st_can_freq_trans_tim[i])); - /* Initialization of CAN communication interruption monitoring timer table */ - memset(&g_st_can_comm_watch_tim[i], 0, sizeof(g_st_can_comm_watch_tim[i])); - } -} - -/*!----------------------------------------------------------------------------- - * @~english - * @brief Register Transmission Cycle - * - * @~english - * @return Return value - * @retval None - * - * @~english - * @param[in] <id> CAN ID - * @param[in] <freq> Transmission cycle - */ -void CANFreqTimerEntry(CANID id, uint32_t freq) { - CAN_TIMER_CTRL_DATA tmp_timer_data; - - tmp_timer_data.us_set_tim = (uint16_t)freq; - tmp_timer_data.us_tim_cnt = (uint16_t)freq; - - g_map_can_freq_trans_time[id] = tmp_timer_data; - - return; -} - -/*!----------------------------------------------------------------------------- - * @~english - * @brief Periodic trnasmission time out - * - * @~english - * @return Return value - * @retval None - * - * @~english - * @param[in] None - */ -void CANFreqTransTimeOutMap(HANDLE h_app) { - map<CANID, CAN_TIMER_CTRL_DATA>::iterator it; - CAN_TIMER_CTRL_DATA timer_data; - CANID id; - - for (it = g_map_can_freq_trans_time.begin(); it != g_map_can_freq_trans_time.end(); ++it) { - id = it->first; - timer_data = it->second; - - if (0 >= timer_data.us_tim_cnt) - continue; - - timer_data.us_tim_cnt--; - - if ((uint16_t)0 == timer_data.us_tim_cnt) { - CANTransStartTxMsg(h_app, id); - timer_data.us_tim_cnt = timer_data.us_set_tim; - } - - g_map_can_freq_trans_time[id] = timer_data; - } -} - -/*!----------------------------------------------------------------------------- - * @~english - * @brief Clear Transmission Cycle - * - * @~english - * @return Return value - * @retval None - * - * @~english - * @param[in] <id> CAN ID - */ -RET_CAN CANFreqTransTimerStopMap(CANID id) { - RET_CAN ret = RET_CAN_NORMAL; - CAN_TIMER_CTRL_DATA timer_data; - - timer_data.us_set_tim = 0; - timer_data.us_tim_cnt = 0; - - g_map_can_freq_trans_time[id] = timer_data; - - return (ret); -} - -/*!----------------------------------------------------------------------------- - * @~english - * @brief Reset Transmission Cycle - * - * @~english - * @return Return value - * @retval None - * - * @~english - * @param[in] <id> CAN ID - */ -void CANFreqTimerResetMap(CANID id) { - map<CANID, CAN_TIMER_CTRL_DATA>::iterator it; - - it = g_map_can_freq_trans_time.find(id); - if (it != g_map_can_freq_trans_time.end()) { - it->second.us_tim_cnt = it->second.us_set_tim; - } - - return; -} // LCOV_EXCL_BR_LINE 10: end of line unknown branch diff --git a/communication/server/src/CAN/Transmission/CAN_Transmission.cpp b/communication/server/src/CAN/Transmission/CAN_Transmission.cpp deleted file mode 100644 index 4be88578..00000000 --- a/communication/server/src/CAN/Transmission/CAN_Transmission.cpp +++ /dev/null @@ -1,603 +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. - */ - -/******************************************************************************* - * Module configuration :CANTxStart() CANDataTransmission start message processing - * CANTxStartMsgCheck() CANDataSend start message check processing - * CANFreqTxStop() CANDataPeriodic transmission stop message processing - * CANFreqTxTimeupMsg() CANDataPeriodic transmission time-up message processing - * CANTxRsltReceiveMsg() CANDataReceive message processing of transmission result - * CANTxRsltReceiveMsgCheck() CANDataSend result received message check processing - ******************************************************************************/ -/*!----------------------------------------------------------------------------- - * @file CAN_Transmission.cpp - * @~english - * @brief CAN Transmission process - */ -#include "CAN_Transmission.h" -#include <string.h> // NOLINT(build/include) -#include <fcntl.h> -#include "CAN_TransmissionData.h" -#include "CAN_TxMsg.h" -#include "CAN_TimerCtrl.h" -#include "CAN_Delivery.h" -#include "CAN_DeliveryData.h" -#include "Canif_API_Local.h" -#include "ICR_Common.h" -#include <native_service/frameworkunified_framework_if.h> -//#include "can_hal.h" - -/*************************************************/ -/* Global variable */ -/*************************************************/ - -/******************************************************************************* - * MODULE : CANTxStartMsg - * ABSTRACT : CANDataTransmission start message processing - * FUNCTION : CANDataStarting transmission when a transmission start message is received - * ARGUMENT : *pst_rcv_msg : Received Message Reference Pointer - * NOTE : - * RETURN : RET_CAN_NORMAL : Normal completion - * RET_CAN_ERROR_BUFFULL : Registered FULL - * RET_CAN_ERROR_TIMER : Timer acquisition failed - ******************************************************************************/ -EFrameworkunifiedStatus CANTxStart(HANDLE h_app) { - RET_CAN l_ret = RET_CAN_NORMAL; /* Return value of this function */ - uint8_t uc_index; /* Indexed */ - uint8_t uc_can_rid; /* CAN uint8_t */ - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - CAN_TRANSMISSION_START_MSG_DAT rcv_msg; - - 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) - - 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 == eFrameworkunifiedStatusInvldBufSize) { - FrameworkunifiedClearMsgData(h_app); - } - l_ret = RET_CAN_ERROR_CANCEL; - goto exit; - } - // LCOV_EXCL_STOP 4: NSFW error case. - - /****** Data section check ******/ - l_ret = CANTxStartMsgCheck(&rcv_msg, &uc_index); - if (RET_CAN_NORMAL != l_ret) { - goto exit; - } - - /****** Message processing ******/ - if ((uint16_t)0 != rcv_msg.usFreq) { - /* Periodic transmission */ - CANFreqTransEntry(uc_index, &rcv_msg); /* CANDataRegular transmission registration */ - if (FALSE == CANFreqTransStartTxMsg(h_app, uc_index)) { /* Periodic transmission start message transmission */ - l_ret = RET_CAN_ERROR_CREATE_EVENT; /* Event generation failure */ - goto exit; - } - } else { - if ((uint8_t)CAN_RID_NOTUSE_CODE == uc_index) { - uc_can_rid = (uint8_t)CAN_RID_NOTUSE_CODE; - } else { - uc_can_rid = (uint8_t)((uint32_t)uc_index + CAN_TXRSLT_CANRID_1TIME_START); - } - /* Send one transmission start message */ - if (FALSE == CAN1TimeTransStartTxMsg(h_app, uc_can_rid, &rcv_msg.stCandata)) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Transmission ICR Error"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - CANDebugLogOut(CAN_TRANCE_ICR_ERR, &rcv_msg); /* Transmission error log output */ - l_ret = RET_CAN_ERROR_CREATE_EVENT; - goto exit; - } - } - - /****** CANDataRegister one transmission result management table ******/ - if (((uint16_t)0 == rcv_msg.usFreq) && ((uint8_t)CAN_RID_NOTUSE_CODE != rcv_msg.ucRid)) { - e_status = CAN1TimeTransEntry(uc_index, &rcv_msg); /* CANDataRegister 1 transmission result */ - if (eFrameworkunifiedStatusOK != e_status) { // LCOV_EXCL_BR_LINE 8: uc_index can't GL CAN_1TIME_TRSNSMISSION_RSLT_NUM, so e_status is always eFrameworkunifiedStatusOK // NOLINT (whitespace/line_length) - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 8: same with above - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "ERROR !!! CAN1TimeTransEntry failed : e_status=%d, uc_index=%d", e_status, uc_index); // LCOV_EXCL_LINE 8: same with above //NOLINT (readability/naming) - l_ret = RET_CAN_ERROR_PARAM; // LCOV_EXCL_LINE 8: same with above - } - } - -exit: - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "END(l_ret=%x)", l_ret); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - if (l_ret == RET_CAN_NORMAL) - return eFrameworkunifiedStatusOK; - else - return eFrameworkunifiedStatusFail; - // return RET_CAN_NORMAL; -} - -/******************************************************************************* - * MODULE : CANTxStartMsgCheck - * ABSTRACT : CANDataSend start message check processing - * FUNCTION : CANDataCheck the data contents when a transmission start message is received - * ARGUMENT : *pst_msg_data : Receive message data section reference pointer - * *puc_index : Index (pointer output) - * NOTE : - * RETURN : RET_CAN_NORMAL :Normal completion - * RET_CAN_ERROR_BUFFULL :Registered FULL - * RET_CAN_ERROR_TIMER :Timer acquisition failure - ******************************************************************************/ -RET_CAN CANTxStartMsgCheck(const CAN_TRANSMISSION_START_MSG_DAT *pst_msg_data, uint8_t *puc_index) { - RET_CAN l_ret = RET_CAN_NORMAL; /* Return value of the function */ - uint8_t uc_index = 0; /* Indexed */ - - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### START #####"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - /* #106 Periodic transmission */ - if ((uint16_t)0 != pst_msg_data->usFreq) { - /* CANDataConfirmation of periodic transmission management table registration destination exists */ - if (TRUE == CANFreqTransEntryCheck(pst_msg_data->stCandata.can_id, &uc_index)) {/* Periodic transmission timer start */ - l_ret = CANFreqTransTimerStart(uc_index, pst_msg_data->usFreq, CAN_PROTOCOL_TYPE_CAN); - } else { /* No registration destination */ - l_ret = RET_CAN_ERROR_BUFFULL; /* Registered FULL */ - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN FreqTrans BufferFull"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - } - } else {/* One-time transmission */ - if ((uint8_t)CAN_RID_NOTUSE_CODE == pst_msg_data->ucRid) {/* When transmission results are unnecessary */ - uc_index = (uint8_t)CAN_RID_NOTUSE_CODE; /* Transmission result non-notification code */ - } else { /* When transmission result is required */ - if (FALSE == CAN1TimeTransEntryCheck(&uc_index)) { - l_ret = RET_CAN_ERROR_BUFFULL; /* One-time transmission results notification lists are FULL. */ - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN 1TimeTransRslt BufferFull"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - } - } - } - *puc_index = uc_index; - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### END #####"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - return (l_ret); -} - -/******************************************************************************* - * MODULE : CANFreqTxStop - * ABSTRACT : CANDataPeriodic transmission stop message processing - * FUNCTION : CANDataStop periodic transmission when a periodic transmission stop message is received - * ARGUMENT : *pst_rcv_msg : Received Message Reference Pointer - * NOTE : - * RETURN : RET_CAN_NORMAL : Parameter Normal - * RET_CAN_ERROR_UNDEF : Undefined ID - * RET_CAN_ERROR_PID : Thread ID mismatch - * RET_CAN_ERROR_TIMER : Failed to stop timer - * RET_CAN_ERROR_CREATE_EVENT : Event generation failure - ******************************************************************************/ -EFrameworkunifiedStatus CANFreqTxStop(HANDLE h_app) { - RET_CAN l_ret = RET_CAN_ERROR_UNDEF; /* Return value of this function */ - int32_t i; /* Generic counters */ - uint8_t uc_index = 0xFF; /* Indexed */ - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - CAN_FREQ_TRANS_STOP_MSG_DAT rcv_msg; - - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### START #####"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - 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 == eFrameworkunifiedStatusInvldBufSize) { - FrameworkunifiedClearMsgData(h_app); - } - l_ret = RET_CAN_ERROR_CANCEL; - goto exit; - } - // LCOV_EXCL_STOP 4: NSFW error case. - - /****** Data checking ******/ - for (i = 0; i < (int32_t)CAN_FREQ_TRSNSMISSION_LIST_NUM; i++) { - /* CANDataPeriodic transmission control table registration status checking process (CAN ID retrieval) */ - if (TRUE != CANFreqTransCanidEntryCheck((uint8_t)i, rcv_msg.ulCanid)) { - continue; - } - - if (TRUE == CANFreqTransIdEntryCheck((uint8_t)i, rcv_msg.notifyName)) { - l_ret = RET_CAN_NORMAL; /* Normal completion */ - uc_index = (uint8_t)i; /* Index acquisition */ - break; - } else { - l_ret = RET_CAN_ERROR_SNDID; /* Distribution destination ID mismatch */ - } - } - - if (l_ret == RET_CAN_ERROR_UNDEF) { /* CAN ID undefined */ - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN FreqTxStop CanID Error"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - goto exit; - } - if (l_ret == RET_CAN_ERROR_SNDID) { /* Distribution destination ID mismatch */ - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN FreqTxStop SNDID Error"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - goto exit; - } - - /****** Message processing ******/ - l_ret = CANFreqTransTimerStop(uc_index, CAN_PROTOCOL_TYPE_CAN); /* Periodic transmission timer stop */ - if (RET_CAN_NORMAL != l_ret) { // LCOV_EXCL_BR_LINE 200:the function is always returned to RET_CAN_NORMAL - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - goto exit; // LCOV_EXCL_LINE 200:the function is always returned to RET_CAN_NORMAL - } - - CANFreqTransStop(uc_index); /* CANDataPeriodic transmission stop */ - -exit: - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "END(l_ret=%x)", l_ret); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - if (l_ret == RET_CAN_NORMAL) - return eFrameworkunifiedStatusOK; - else - return eFrameworkunifiedStatusFail; -} -/******************************************************************************* - * MODULE : CANFreqTxTimeupMsg - * ABSTRACT : CANDataPeriodic transmission time-up message processing - * FUNCTION : Start transmission when the periodic timer for periodic transmission expires - * ARGUMENT : *pst_rcv_msg : Received Message Reference Pointer - * NOTE : - * RETURN : RET_CAN_NORMAL : Normal completion - * RET_CAN_ERROR_CANCEL : Data destruction - ******************************************************************************/ -RET_CAN CANFreqTxTimeupMsg(HANDLE h_app, uint16_t timer_seq) { - RET_CAN l_ret = RET_CAN_NORMAL; /* Return value of this function */ - uint8_t uc_index; /* Indexed */ - - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### START #####"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - /* Check Timer Sequence Range(0x8000 ~ 0x80FF) */ - if (FREQ_TRANS_SEQNO_CODE == (timer_seq & ~TIMER_SEQNO_MASK_CODE)) { - uc_index = (uint8_t)(timer_seq & TIMER_SEQNO_MASK_CODE); - if (FALSE == CANFreqTransIndexEntryCheck(uc_index)) { // LCOV_EXCL_BR_LINE 6:Double check code. in CANFreqTransEntryCheck //NOLINT (readability/naming) - l_ret = RET_CAN_ERROR_CANCEL; /* Data destruction */ - } else { - /* CANDataPeriodic transmission start message transmission */ - if (FALSE == CANFreqTransStartTxMsg(h_app, uc_index)) { - l_ret = RET_CAN_ERROR_CANCEL; /* Data destruction */ - } - } - } else { - l_ret = RET_CAN_ERROR_CANCEL; /* Data destruction */ - } - - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### END #####"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - return (l_ret); -} - -/******************************************************************************* - * MODULE : CANTxRsltReceiveMsg - ******************************************************************************/ -/*!----------------------------------------------------------------------------- - * @~english - * @brief CAN data transmission result reply processing - * - * It notifies the corresponding thread when the informative message - * of the CAN data transmission result is received. - * - * CANDataWhen a transmission result notification message is received, a notification is sent to the relevant thread... - * - * @~english - * @note - * -# Transmission result status check - * -# Transmission result notification registration check - * -# Transmission result table check - * -# Transmission result status acquisition - * -# Message sending - * -# Transmission result table deletion - * - * @~english - * @return Reception result - * @retval <RET_CAN_NORMAL> Normality - * @retval <RET_CAN_ERROR_CANCEL> Data annulment - * - * @~english - * @param[in] <pst_rcv_msg> Reception message reference pointer - */ -RET_CAN CANTxRsltReceiveMsg(HANDLE h_app, CAN_MSG_DATA *pst_rcv_msg) { // LCOV_EXCL_START 8:this IF is called in CANIcrSndStsProcess, which will not be called // NOLINT (whitespace/line_length) - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - RET_CAN l_ret = RET_CAN_NORMAL; /* Return value of this function */ - RET_CAN l_ret_func; /* Lower-order function return value */ - BOOL b_ret_func; /* Lower-order function return value */ -// T_ICR_CMDSNDCNF_STS *pst_msg_data; /* Receive data structure pointer */ - uint8_t us_sts; /* Status */ - - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### START #####"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) -// pst_msg_data = reinterpret_cast<T_ICR_CMDSNDCNF_STS *>(reinterpret_cast<void *>(&pst_rcv_msg->ucData[0])); - - /****** Transmission result status check ******/ - l_ret_func = CANTxRsltReceiveMsgCheck(pst_rcv_msg); /* Receive command (transmission result) check processing */ - - /****** Send result notification registration check ******/ - if (RET_CAN_NORMAL == l_ret_func) { -// b_ret_func = CANTxRsltEntryCheck(pst_rcv_msg->stHead.hdr.rid); - } - - /****** Message processing ******/ - if ((RET_CAN_NORMAL == l_ret_func) && (TRUE == b_ret_func)) { -// b_ret_func = CANTxRsltSndCheck(pst_rcv_msg->stHead.hdr.rid, (uint32_t)pst_msg_data->cnf_sts); - /* Determine whether to perform transmission result notification */ - if (TRUE == b_ret_func) { -// switch (pst_msg_data->cnf_sts) { -// case ICR_SND_SUCCESS: -// us_sts = CAN_SUCCESS; -// break; -// case ICR_SND_ERR_RETRYOUT: -// us_sts = CAN_RETRYOUT; -// FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Transmission SYSCOM Error"); -// CANDebugLogOut(CAN_TRANCE_SYSCOM_ERR, reinterpret_cast<void *>(pst_rcv_msg)); -// break; -// case ICR_SND_ERR_BUFFERFULL: -// us_sts = CAN_BUFFERFUL; -// FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Transmission SYSCOM Error"); -// CANDebugLogOut(CAN_TRANCE_SYSCOM_ERR, reinterpret_cast<void *>(pst_rcv_msg)); -// break; -// default: -// l_ret = RET_CAN_ERROR_CANCEL; /* Data destruction */ -// FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN Transmission SYSCOM Error"); -// CANDebugLogOut(CAN_TRANCE_SYSCOM_ERR, reinterpret_cast<void *>(pst_rcv_msg)); -// break; -// } - if (RET_CAN_NORMAL == l_ret) { -// b_ret_func = CANTxRsltSndMsg(h_app, pst_rcv_msg->stHead.hdr.rid, us_sts); - /* CANDataSend result notification message */ - /* Transmission result judgment */ - if (FALSE == b_ret_func) { - /* Transmission result notification transmission failure */ - l_ret = RET_CAN_ERROR_CANCEL; /* Data destruction */ - } - } - } else { - /* No need to send result notification */ - } - - /****** Delete various transmission results management tables ******/ - if (RET_CAN_NORMAL == l_ret) { -// CANTxRsltFin(pst_rcv_msg->stHead.hdr.rid); /* CANDataTransmission result notification completed */ - } - } else { - /* Transmission result status error */ - l_ret = RET_CAN_ERROR_CANCEL; /* Data destruction */ - } - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### END #####"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - return (l_ret); -} -// LCOV_EXCL_STOP 8 - -/******************************************************************************* - * MODULE : CANTxRsltReceiveMsgCheck - ******************************************************************************/ -/*!----------------------------------------------------------------------------- - * @~english - * @brief CAN data transmission result reception message check processing - * - * CAN data transmission result reception message check processing - * - * CANDataCheck the data contents when a transmission result notification message is received. - * - * @~english - * @note - * -# Transmission result status check - * -# RID abnormality check - * - * @~english - * @return Check result - * @retval <RET_CAN_NORMAL> Normality - * @retval <RET_CAN_ERROR_CANCEL> Data annulment - * - * @~english - * @param[in] <pst_rcv_msg> Reception message reference pointer - */ -/*------------------------------------------------------------------------------ - * RETURN : RET_CAN_NORMAL : Parameter Normal - * RET_CAN_ERROR_CANCEL : Data destruction - *----------------------------------------------------------------------------*/ -RET_CAN CANTxRsltReceiveMsgCheck(CAN_MSG_DATA *pst_rcv_msg) { // LCOV_EXCL_START 8:this IF is called in CANIcrSndStsProcess, which will not be called // NOLINT (whitespace/line_length) - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - RET_CAN l_ret = RET_CAN_NORMAL; /* Return value of this function */ -// T_ICR_CMDSNDCNF_STS *pst_msg_data; /* Receive data structure pointer */ - - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### START #####"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) -// pst_msg_data = reinterpret_cast<T_ICR_CMDSNDCNF_STS *>(reinterpret_cast<void *>(&pst_rcv_msg->ucData[0])); - /* Type conversion */ - - /****** Transmission result status check ******/ -// if ((ICR_SND_SUCCESS != pst_msg_data->cnf_sts) && -// (ICR_SND_ERR_RETRYOUT != pst_msg_data->cnf_sts) && -// (ICR_SND_ERR_BUFFERFULL != pst_msg_data->cnf_sts)) { -// l_ret = RET_CAN_ERROR_CANCEL; /* Data destruction */ -// } - /****** RID anomaly check ******/ - /* NG if the ID is out of the table to be searched */ - /* The table range is from 0 (periodic-transmission-management-table + number-of-transmission-results-once-management-tables). */ -// if (((uint8_t)CAN_TXRSLT_CANRID_END < pst_rcv_msg->stHead.hdr.rid)) { -// l_ret = RET_CAN_ERROR_CANCEL; /* Data destruction */ -// } - - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### END #####"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - return (l_ret); -} -// LCOV_EXCL_STOP 8 - -/******************************************************************************* - * MODULE : CAN_CWORD29_TxMsg - * ABSTRACT : CANData(_CWORD29_) outgoing message processing - * FUNCTION : CANData(_CWORD29_) Start sending a message when it is received - * ARGUMENT : *pst_rcv_msg : Received Message Reference Pointer - * NOTE : - * RETURN : RET_CAN_NORMAL : Normal completion - * RET_CAN_ERROR_BUFFULL : Registered FULL - ******************************************************************************/ -EFrameworkunifiedStatus CAN_CWORD29_TxMsg(HANDLE h_app) { - CAN__CWORD29__TRANS_MSG pst_msg_data; /* Pointer to send start data structure */ - uint8_t uc_can_rid; /* Send Resource ID */ - uint8_t uc_index; /* Indexed */ - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### CAN_CWORD29_TxMsg START #####"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - - e_status = FrameworkunifiedGetMsgDataOfSize(h_app, &pst_msg_data, sizeof(pst_msg_data), eSMRRelease); - if (e_status != eFrameworkunifiedStatusOK) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# FrameworkunifiedGetMsgDataOfSize Error"); - if (e_status == eFrameworkunifiedStatusInvldBufSize) { - FrameworkunifiedClearMsgData(h_app); - } - return eFrameworkunifiedStatusFail; - } - - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### Opc=%04x Name=%s Rid=%02x #####", pst_msg_data.opc, pst_msg_data.notifyName, pst_msg_data.ucRid); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - - /* Register transmission result notification? */ - if ((uint8_t)CAN_RID_NOTUSE_CODE == pst_msg_data.ucRid) {/* When transmission results are unnecessary */ - uc_index = (uint8_t)CAN_RID_NOTUSE_CODE; /* Transmission result non-notification code */ - } else { /* When transmission result is required */ - if (FALSE == CAN_CWORD29_TransEntryCheck(&uc_index)) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# CAN _CWORD29_TransRslt BufferFull"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - return eFrameworkunifiedStatusFail; - } - e_status = CAN_CWORD29_TransEntry(uc_index, &pst_msg_data); /* Save CAN_CWORD29_ Transmission Result */ - if (eFrameworkunifiedStatusOK != e_status) { // LCOV_EXCL_BR_LINE 6:Excluded due to value never returned at present - // LCOV_EXCL_START 6:Excluded due to value never returned at present - AGL_ASSERT_NOT_TESTED(); - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "ERROR !!! CAN_CWORD29_TransEntry failed : e_status=%d, uc_index=%d", e_status, uc_index); - return eFrameworkunifiedStatusFail; - // LCOV_EXCL_STOP 6:Excluded due to value never returned at present - } - } - - if ((uint8_t)CAN_RID_NOTUSE_CODE == uc_index) { - uc_can_rid = (uint8_t)CAN_RID_NOTUSE_CODE; - } else { - uc_can_rid = (uint8_t)((uint32_t)uc_index + CAN_TXRSLT_CANRID__CWORD29__START); - } - - /****** Message transmission processing ******/ -// CanMessage_CWORD29_ st_can_data; -// -// st_can_data.opc = pst_msg_data.opc; -// st_can_data.rid = uc_can_rid; -// st_can_data.dlc = (uint8_t)pst_msg_data.ulDataSize; -// memcpy(st_can_data.data, pst_msg_data.data, (st_can_data.dlc)); - -// if (CanSend_CWORD29_(&st_can_data) != CANHAL_RET_NORMAL) { -// return eFrameworkunifiedStatusFail; -// } - - return eFrameworkunifiedStatusOK; -} - -/*!----------------------------------------------------------------------------- - * @~english - * @brief Start transmission of CAN Command - * - * @~english - * @return Return value - * @retval <eFrameworkunifiedStatusOK> OK - * @retval <eFrameworkunifiedStatusFail> Abnormal termination - * - * @~english - * @param[in] <h_app> Application handle - */ -EFrameworkunifiedStatus CANTxBitStart(HANDLE h_app) { - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - CAN_TRANS_START_MSG_DAT rcv_msg; - - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### CANTxBitStart Start"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - - 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__, "FrameworkunifiedGetMsgDataOfSize Error eFrameworkunifiedStatus=%d", e_status); - if (e_status == eFrameworkunifiedStatusInvldBufSize) { - FrameworkunifiedClearMsgData(h_app); - } - goto exit; - } - // LCOV_EXCL_STOP 4: NSFW error case. - - /* Merge CAN Data and update Trnasmission management table */ - if (TRUE == CANTransDataEntry(&rcv_msg)) { - - /* Interval Data registered to Timer management table */ - if ((uint32_t)0 < rcv_msg.freq) { - CANFreqTimerEntry(rcv_msg.id, rcv_msg.freq); - } - - /* Transmission CAN Data */ - if (FALSE == CANTransStartTxMsg(h_app, rcv_msg.id)) { - e_status = eFrameworkunifiedStatusFail; - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "CANTransStartTxMsg Error CAN ID=0x%04X", rcv_msg.id); - goto exit; - } - - /* Reset Timer */ - if ((uint32_t)0 == rcv_msg.freq) { - CANFreqTimerResetMap(rcv_msg.id); - } - } else if (FALSE == CAN_SubIDTransStartTxMsg(h_app, &rcv_msg)) { - e_status = eFrameworkunifiedStatusFail; - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "Trans NG CAN ID=0x%04X DATA[0]=0x%02X", rcv_msg.id, (rcv_msg.dat.dat[0] & rcv_msg.mask.dat[0])); - } - -exit: - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "END(eFrameworkunifiedStatus=%x)", e_status); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - - return e_status; -} - -/*!----------------------------------------------------------------------------- - * @~english - * @brief Stop transmission CAN Command - * - * @~english - * @return Return value - * @retval <eFrameworkunifiedStatusOK> OK - * @retval <eFrameworkunifiedStatusFail> Abnormal termination - * - * @~english - * @param[in] <h_app> Application handle - */ -EFrameworkunifiedStatus CANTxBitStop(HANDLE h_app) { - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - CANID rcv_msg; - - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "##### CAN_FreqTxBitStop Start"); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - 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__, "FrameworkunifiedGetMsgDataOfSize Error eFrameworkunifiedStatus=%d", e_status); - if (e_status == eFrameworkunifiedStatusInvldBufSize) { - FrameworkunifiedClearMsgData(h_app); - } - e_status = eFrameworkunifiedStatusFail; - goto exit; - } - // LCOV_EXCL_STOP 4: NSFW error case. - - /* Check correct CAN ID */ - if (FALSE == CANEntryTransCanidCheck(rcv_msg)) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "CANEntryTransCanidCheck Error CAN ID=0x%04X", rcv_msg); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - e_status = eFrameworkunifiedStatusFail; - goto exit; - } - - /* Stop periodic transmission */ - if (RET_CAN_NORMAL != CANFreqTransTimerStopMap(rcv_msg)) { // LCOV_EXCL_BR_LINE 200:the function is always returned to RET_CAN_NORMAL //NOLINT (readability/naming) - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - e_status = eFrameworkunifiedStatusFail; // LCOV_EXCL_LINE 200:the function is always returned to RET_CAN_NORMAL - } - -exit: - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "END(eFrameworkunifiedStatus=%x)", e_status); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" //NOLINT (readability/naming) - - return e_status; -} -// LCOV_EXCL_BR_LINE 10:THE_END_LINE_OF_THE_FILE diff --git a/communication/server/src/CAN/Transmission/CAN_TransmissionData.cpp b/communication/server/src/CAN/Transmission/CAN_TransmissionData.cpp deleted file mode 100644 index 2858c196..00000000 --- a/communication/server/src/CAN/Transmission/CAN_TransmissionData.cpp +++ /dev/null @@ -1,713 +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_TransmissionData.cpp - * SYSTEM :_CWORD107_ - * SUBSYSTEM :EXL process - * PROGRAM :CAN Thread CAN Data Transmission Management Processing - * Module configuration :CANTransmissionDataInit( ) CANDataTransmission management data initialization processing - * CANFreqTransEntryCheck( ) CANDataPeriodic transmission management table registration destination confirmation processing - * CANFreqTransEntry() CANDataRegular transmission management table registration processing - * CANFreqTransDataGet( ) Periodic transmission data acquisition processing - * CANFreqTransCanidEntryCheck( ) CANDataPeriodic transmission control table registration status checking process (CAN ID retrieval) - * CANFreqTransIdEntryCheck( ) Periodic transmission management table send destination ID confirmation processing - * CANFreqTransStop( ) CANDataPeriodic transmission stop processing - * CANFreqTransIndexEntryCheck( ) CANDataPeriodic transmission control table registration status checking process (INDEX retrieval) - * CAN1TimeTransEntryCheck( ) CANDataConfirmation processing of the registration destination of the transmission result management table - * CAN1TimeTransEntry( ) CANDataOne-time transmission result management table registration processing - * CANTxRsltEntryCheck( ) CANDataTransmission result management table registration status confirmation processing - * CANTxRsltDataGet( ) Transmission result data acquisition processing - * CANTxRsltFin( ) CANDataTransmission result notification completion processing - ******************************************************************************/ -#include "CAN_TransmissionData.h" -#include <string.h> // NOLINT(build/include) -#include <other_service/strlcpy.h> -#include <map> -#include "CAN_Thread.h" -#include "CAN_TxMsg.h" -#include "communication_communicationlog.h" - -using std::map; - -/*************************************************/ -/* Global variable */ -/*************************************************/ -static CAN_FREQ_TRANSMISSION_DAT g_gst_freq_trans_dat[CAN_FREQ_TRSNSMISSION_LIST_NUM]; /* Periodic transmission management table */ - /* One-time transmission result management table */ -static CAN_1TIME_TXRSLT_DAT g_gst1_time_trans_rslt_dat[CAN_1TIME_TRSNSMISSION_RSLT_NUM]; //NOLINT (readability/naming) - /* _CWORD29_ send result control table */ -static CAN__CWORD29__TXRSLT_DAT g_gst__CWORD29__trans_rslt_dat[CAN__CWORD29__TRSNSMISSION_RSLT_NUM]; //NOLINT (readability/naming) -map<CANID, CAN_TRANS_START_TABLE_VAL *> g_map_trans_data; /* CAN Data management table */ -std::multimap<CANID, CAN_TRANS_START_TABLE_VAL *> mapSubIDTransData; /* CAN SubID Data management table */ -static CAN_INIT_TABLE Can_TransInitData_19PF[] = { - /* - * Note. - * This feature needs to be defined by the vendor. - */ - { (CANID)0x0000, (uint8_t)1, { 0x00 } } -}; - -/******************************************************************************* - * MODULE : :CANTransmissionDataInit - * ABSTRACT : CANDataTransmission management data initialization processing - * FUNCTION : CANDataInitializing Transmission Management Data - * ARGUMENT : void - * NOTE : - * RETURN : void - ******************************************************************************/ -void CANTransmissionDataInit(void) { - int32_t i; /* Generic counters */ - int32_t cntMaxData; - - (void)memset(reinterpret_cast<void *>(&g_gst_freq_trans_dat), (int32_t)0, (size_t)sizeof(g_gst_freq_trans_dat)); - /* Periodic transmission management table */ - (void)memset(reinterpret_cast<void *>(&g_gst1_time_trans_rslt_dat), - (int32_t)0, (size_t)sizeof(g_gst1_time_trans_rslt_dat)); - /* One-time transmission result management table */ - /* Fill the resource ID of the transmission result management table with an unused code */ - for (i = 0; i < (int32_t)CAN_1TIME_TRSNSMISSION_RSLT_NUM; i++) { - g_gst1_time_trans_rslt_dat[i].uc_rid = (uint8_t)CAN_RID_NOTUSE_CODE; - } - - (void)memset(reinterpret_cast<void *>(&g_gst__CWORD29__trans_rslt_dat), - (int32_t)0, (size_t)sizeof(g_gst__CWORD29__trans_rslt_dat)); - /* _CWORD29_ send result control table */ - /* Fill the resource ID of the Phase send result management table with an unused resource ID */ - for (i = 0; i < (int32_t)CAN__CWORD29__TRSNSMISSION_RSLT_NUM; i++) { - g_gst__CWORD29__trans_rslt_dat[i].uc_rid = (uint8_t)CAN_RID_NOTUSE_CODE; - } - - /* Initialize Transmission data management table */ - cntMaxData = (int32_t)(sizeof(Can_TransInitData_19PF) / sizeof(Can_TransInitData_19PF[0])); - for (i = 0; i < cntMaxData; i++) { - g_map_trans_data[ Can_TransInitData_19PF[i].canid ] = &Can_TransInitData_19PF[i].val; - } - - return; -} - -/******************************************************************************* - * MODULE : CANFreqTransEntryCheck - * ABSTRACT : CANDataPeriodic transmission management table registration destination confirmation processing - * FUNCTION : CANDataReturns whether or not the periodic transmission management table can be registered and the index. - * ARGUMENT : can_id : CAN ID - * *puc_index : Index (pointer output) - * NOTE : Can be overwritten with the same CAN ID - * RETURN : TRUE : Can be registered - * FALSE : Cannot be stored - ******************************************************************************/ -BOOL CANFreqTransEntryCheck(CANID can_id, uint8_t *puc_index) { - BOOL ret = FALSE; /* Return value of this function */ - int32_t i; /* Generic counters */ - - /* Can be overwritten by the same CAN ID detection */ - for (i = 0; i < (int32_t)CAN_FREQ_TRSNSMISSION_LIST_NUM; i++) { - if (g_gst_freq_trans_dat[i].st_can_data.can_id == can_id) { - ret = TRUE; /* Can be registered */ - *puc_index = (uint8_t)i; /* Index acquisition */ - break; - } - } - - if (FALSE == ret) { - /* If the same CAN ID is not found, free space is checked. */ - for (i = 0; i < (int32_t)CAN_FREQ_TRSNSMISSION_LIST_NUM; i++) { - if ((uint16_t)0 == g_gst_freq_trans_dat[i].us_freq) { - ret = TRUE; /* Can be registered */ - *puc_index = (uint8_t)i; /* Index acquisition */ - break; - } - } - } - - return (ret); -} - -/******************************************************************************* - * MODULE : CANFreqTransEntry - * ABSTRACT : CANDataRegular transmission management table registration processing - * FUNCTION : CANDataRegister in the periodic transmission management table - * ARGUMENT : uc_index : Indexed - * *pst_msg_data : Receive message data section reference pointer - * NOTE : - * RETURN : void - ******************************************************************************/ -void CANFreqTransEntry(uint8_t uc_index, const CAN_TRANSMISSION_START_MSG_DAT *pst_msg_data) { - strlcpy(g_gst_freq_trans_dat[uc_index].notify_name, pst_msg_data->notifyName, - sizeof(g_gst_freq_trans_dat[uc_index].notify_name)); - g_gst_freq_trans_dat[uc_index].us_freq = pst_msg_data->usFreq; /* Periodic transmission period (in 100ms) */ - g_gst_freq_trans_dat[uc_index].uc_rid = pst_msg_data->ucRid; /* Resources ID */ - if ((uint8_t)CAN_RID_NOTUSE_CODE == pst_msg_data->ucRid) { - g_gst_freq_trans_dat[uc_index].uc_resp_num = 0; /* Notification of transmission results is not required. */ - } else { - g_gst_freq_trans_dat[uc_index].uc_resp_num = (uint8_t)CAN_FREQ_TXRSLT_NUM; /* Number of transmission result notifications (number of remaining notifications) */ - } - g_gst_freq_trans_dat[uc_index].st_can_data = pst_msg_data->stCandata; /* Transmitted data */ - - return; -} - -/******************************************************************************* - * MODULE : CANFreqTransDataGet - * ABSTRACT : Periodic transmission data acquisition processing - * FUNCTION : CANDataRetrieves data for the specified index from the periodic transmission management table - * ARGUMENT : uc_index : Indexed - * *pst_data : Periodic transmission data - * NOTE : - * RETURN : void - ******************************************************************************/ -void CANFreqTransDataGet(uint8_t uc_index, CAN_FREQ_TRANSMISSION_DAT *pst_data) { - *pst_data = g_gst_freq_trans_dat[uc_index]; /* Copy to Output Pointer */ - return; -} - -/******************************************************************************* - * MODULE : CANFreqTransCanidEntryCheck - * ABSTRACT : CANDataPeriodic transmission control table registration status checking process (CAN ID retrieval) - * FUNCTION : CANDataCheck the registration status of the periodic transmission management table - * ARGUMENT : uc_index : Indexed - * : can_id : CAN ID - * NOTE : - * RETURN : TRUE : Registered - * FALSE : No registration - ******************************************************************************/ -BOOL CANFreqTransCanidEntryCheck(uint8_t uc_index, CANID can_id) { - BOOL ret = FALSE; /* Return value of this function */ - - if ((uint16_t)0 != g_gst_freq_trans_dat[uc_index].us_freq) { - if (can_id == g_gst_freq_trans_dat[uc_index].st_can_data.can_id) { - ret = TRUE; /* Registered */ - } - } - - return (ret); -} - -/******************************************************************************* - * MODULE : CANFreqTransIdEntryCheck - * ABSTRACT : Periodic transmission management table send destination ID confirmation processing - * FUNCTION : CANDataCheck the destination ID in the periodic transmission management table - * ARGUMENT : uc_index : Indexed - * : notifyId : Transfer to: ID - * NOTE : - * RETURN : TRUE : Match - * FALSE : Mismatched - ******************************************************************************/ -BOOL CANFreqTransIdEntryCheck(uint8_t uc_index, PCSTR notify_name) { - BOOL ret = FALSE; /* Return value of this function */ - - if (strcmp(notify_name, g_gst_freq_trans_dat[uc_index].notify_name) == 0) { - ret = TRUE; /* Match */ - } - - return (ret); -} - -/******************************************************************************* - * MODULE : CANFreqTransStop - * ABSTRACT : CANDataPeriodic transmission stop processing - * FUNCTION : CANDataClears the data of the specified index in the periodic transmission management table. - * ARGUMENT : uc_index : Indexed - * NOTE : - * RETURN : void - ******************************************************************************/ -void CANFreqTransStop(uint8_t uc_index) { - CAN_FREQ_TRANSMISSION_DAT *pst; /* Structure pointer */ - - pst = &g_gst_freq_trans_dat[uc_index]; - memset(reinterpret_cast<void *>(pst), 0x00, (size_t)sizeof(CAN_FREQ_TRANSMISSION_DAT)); - - return; -} - -/******************************************************************************* - * MODULE : CANFreqTransIndexEntryCheck - * ABSTRACT : CANDataPeriodic transmission control table registration status checking process (INDEX retrieval) - * FUNCTION : CANDataCheck the registration status of the specified index in the periodic transmission management table - * ARGUMENT : uc_index : Indexed - * NOTE : - * RETURN : TRUE : Registered - * FALSE : No registration - ******************************************************************************/ -BOOL CANFreqTransIndexEntryCheck(uint8_t uc_index) { - BOOL ret = FALSE; /* Return value of this function */ - - if ((uint16_t)0 != g_gst_freq_trans_dat[uc_index].us_freq) { // LCOV_EXCL_BR_LINE 6:Double check code. in CANFreqTransEntryCheck //NOLINT (readability/naming) - ret = TRUE; /* Registered */ - } - - return (ret); -} - -/******************************************************************************* - * MODULE : CAN1TimeTransEntryCheck - * ABSTRACT : CANDataConfirmation processing of the registration destination of the transmission result management table - * FUNCTION : CANDataWhether or not registration of the transmission results management table can be performed once, and the index is returned. - * ARGUMENT : *puc_index : Index (pointer output) - * NOTE : - * RETURN : TRUE : Can be registered - * FALSE : Cannot be stored - ******************************************************************************/ -BOOL CAN1TimeTransEntryCheck(uint8_t *puc_index) { - BOOL ret = FALSE; /* Return value of this function */ - int32_t i; /* Generic counters */ - - for (i = 0; i < (int32_t)CAN_1TIME_TRSNSMISSION_RSLT_NUM; i++) { - if ((uint8_t)CAN_RID_NOTUSE_CODE == g_gst1_time_trans_rslt_dat[i].uc_rid) { - /* If the resource ID is an unused code, it is not registered. */ - ret = TRUE; /* Can be registered */ - *puc_index = (uint8_t)i; - break; - } - } - - return (ret); -} - -/******************************************************************************* - * MODULE : CAN_CWORD29_TransEntryCheck - * ABSTRACT : CAN_CWORD29_ transmission-result-management-table-registration-destination-confirmation-processing - * FUNCTION : Returns whether or not the CAN_CWORD29_ send results control table can be registered and indexes. - * ARGUMENT : *puc_index : Index (pointer output) - * NOTE : - * RETURN : TRUE : Can be registered - * FALSE : Cannot be stored - ******************************************************************************/ -BOOL CAN_CWORD29_TransEntryCheck(uint8_t *puc_index) { - BOOL ret = FALSE; /* Return value of this function */ - int32_t i; /* Generic counters */ - - for (i = 0; i < (int32_t)CAN__CWORD29__TRSNSMISSION_RSLT_NUM; i++) { - if ((uint8_t)CAN_RID_NOTUSE_CODE == g_gst__CWORD29__trans_rslt_dat[i].uc_rid) { - /* If the resource ID is an unused code, it is not registered. */ - ret = TRUE; /* Can be registered */ - *puc_index = (uint8_t)i; - break; - } - } - - return (ret); -} - -/******************************************************************************* - * MODULE : CAN1TimeTransEntry - * ABSTRACT : CANDataOne-time transmission result management table registration processing - * FUNCTION : CANDataRegister in the transmission results management table once - * ARGUMENT : uc_index : Index to register - * *pst_msg_data : Receive message data section reference pointer - * NOTE : - * RETURN : EFrameworkunifiedStatus - * eFrameworkunifiedStatusOK : Success - * eFrameworkunifiedStatusInvldParam : uc_index is invalid - ******************************************************************************/ -EFrameworkunifiedStatus CAN1TimeTransEntry(uint8_t uc_index, const CAN_TRANSMISSION_START_MSG_DAT *pst_msg_data) { - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - /* Register one transmission result management table */ - if (CAN_1TIME_TRSNSMISSION_RSLT_NUM > uc_index) { // LCOV_EXCL_BR_LINE 6:Double check code. in CAN1TimeTransEntryCheck //NOLINT (readability/naming) - strlcpy(g_gst1_time_trans_rslt_dat[uc_index].notify_name, pst_msg_data->notifyName, - sizeof(g_gst1_time_trans_rslt_dat[uc_index].notify_name)); - g_gst1_time_trans_rslt_dat[uc_index].ul_canid = pst_msg_data->stCandata.can_id; - g_gst1_time_trans_rslt_dat[uc_index].uc_rid = pst_msg_data->ucRid; - } else { - e_status = eFrameworkunifiedStatusInvldParam; - } - return e_status; -} - -/******************************************************************************* - * MODULE : CAN_CWORD29_TransEntry - * ABSTRACT : CAN_CWORD29_ transmission-result-management-table-registration-process - * FUNCTION : Register in the CAN_CWORD29_ transmission result management table - * ARGUMENT : uc_index : Index to register - * *pst_msg_data : Receive message data section reference pointer - * NOTE : - * RETURN : EFrameworkunifiedStatus - * eFrameworkunifiedStatusOK : Success - * eFrameworkunifiedStatusInvldParam : uc_index is invalid - ******************************************************************************/ -EFrameworkunifiedStatus CAN_CWORD29_TransEntry(uint8_t uc_index, const CAN__CWORD29__TRANS_MSG *pst_msg_data) { - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - /* Register _CWORD29_ send result control table */ - if (CAN__CWORD29__TRSNSMISSION_RSLT_NUM > uc_index) { - strlcpy(g_gst__CWORD29__trans_rslt_dat[uc_index].notify_name, pst_msg_data->notifyName, - sizeof(g_gst__CWORD29__trans_rslt_dat[uc_index].notify_name)); - g_gst__CWORD29__trans_rslt_dat[uc_index].opc = pst_msg_data->opc; - g_gst__CWORD29__trans_rslt_dat[uc_index].uc_rid = pst_msg_data->ucRid; - } else { - e_status = eFrameworkunifiedStatusInvldParam; - } - return e_status; -} - -/******************************************************************************* - * MODULE : CANTxRsltEntryCheck - * ABSTRACT : CANDataTransmission result management table registration status confirmation processing - * FUNCTION : Periodic transmission, one transmission, result control for specified indexes - * Check the registration status of the table - * ARGUMENT : uc_can_rid : CAN RID (Resource-ID managed by the CAN thread) - * NOTE : - * RETURN : TRUE : Registered - * FALSE : No registration - ******************************************************************************/ -BOOL CANTxRsltEntryCheck(uint8_t uc_can_rid) { // LCOV_EXCL_START 8:this IF is called in CANIcrSndStsProcess, which will not be called // NOLINT (whitespace/line_length) - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - BOOL ret = FALSE; /* Return value of this function */ - uint8_t uc_index; /* Indexed */ - /*** Periodic transmission ***/ - if ((uint8_t)CAN_TXRSLT_CANRID_1TIME_START > uc_can_rid) { - uc_index = uc_can_rid; - /* Checking for User unset code */ - if ((uint8_t)CAN_RID_NOTUSE_CODE != g_gst_freq_trans_dat[uc_index].uc_rid) { - if ((uint8_t)0 != g_gst_freq_trans_dat[uc_index].uc_resp_num) { - ret = TRUE; /* Registered */ - } - } - } else if ((uint8_t)CAN_TXRSLT_CANRID__CWORD29__START > uc_can_rid) { /*** One-time transmission ***/ - uc_index = (uint8_t)((uint32_t)uc_can_rid - CAN_TXRSLT_CANRID_1TIME_START); - if ((uint8_t)CAN_RID_NOTUSE_CODE != g_gst1_time_trans_rslt_dat[uc_index].uc_rid) { - /* Checking for User unset code */ - ret = TRUE; /* Registered */ - } - } - - return (ret); -} -// LCOV_EXCL_STOP 8 - -/******************************************************************************* - * MODULE : CANTxRsltDataGet - * ABSTRACT : Transmission result data acquisition processing - * FUNCTION : Retrieves the send result data for the specified index - * ARGUMENT : uc_can_rid : CAN RID (Resource-ID managed by the CAN thread) - * *pst_data : Transmission result data (pointer output) - * NOTE : - * RETURN : void - ******************************************************************************/ -void CANTxRsltDataGet(uint8_t uc_can_rid, CAN_1TIME_TXRSLT_DAT *pst_data) { - uint8_t uc_index; /* Indexed */ - - if ((uint8_t)CAN_TXRSLT_CANRID_1TIME_START > uc_can_rid) { /*** Periodic transmission ***/ - uc_index = uc_can_rid; - strlcpy(pst_data->notify_name, g_gst_freq_trans_dat[uc_index].notify_name, sizeof(pst_data->notify_name)); - pst_data->ul_canid = g_gst_freq_trans_dat[uc_index].st_can_data.can_id; - pst_data->uc_rid = g_gst_freq_trans_dat[uc_index].uc_rid; - - } else if ((uint8_t)CAN_TXRSLT_CANRID__CWORD29__START > uc_can_rid) { /*** One-time transmission ***/ - uc_index = (uint8_t)((uint32_t)uc_can_rid - CAN_TXRSLT_CANRID_1TIME_START); - strlcpy(pst_data->notify_name, g_gst1_time_trans_rslt_dat[uc_index].notify_name, sizeof(pst_data->notify_name)); - pst_data->ul_canid = g_gst1_time_trans_rslt_dat[uc_index].ul_canid; - pst_data->uc_rid = g_gst1_time_trans_rslt_dat[uc_index].uc_rid; - - } - return; -} - -/******************************************************************************* - * MODULE : CAN_CWORD29_TxRsltDataGet - * ABSTRACT : Acquisition of _CWORD29_ Transmission Result Data - * FUNCTION : Retrieves the _CWORD29_ send results for the specified indexes - * ARGUMENT : uc_can_rid : CAN RID (Resource-ID managed by the CAN thread) - * *pst_data : Transmission result data (pointer output) - * NOTE : - * RETURN : void - ******************************************************************************/ -void CAN_CWORD29_TxRsltDataGet(const uint8_t uc_can_rid, CAN__CWORD29__TXRSLT_DAT* const pst_data) { - uint32_t ul_index; /* Indexed */ - - if (reinterpret_cast<CAN__CWORD29__TXRSLT_DAT *>(NULL) == pst_data) { - return; - } - - if (static_cast<uint32_t>(CAN_TXRSLT_CANRID__CWORD29__START) > uc_can_rid) { - return; - } - - ul_index = uc_can_rid - static_cast<uint32_t>(CAN_TXRSLT_CANRID__CWORD29__START); - if (static_cast<uint32_t>(CAN__CWORD29__TRSNSMISSION_RSLT_NUM) <= ul_index) { - return; - } - - strlcpy(reinterpret_cast<char *>(pst_data->notify_name), - reinterpret_cast<const char *>(g_gst__CWORD29__trans_rslt_dat[ul_index].notify_name), MAX_NAME_SIZE_APP); - pst_data->opc = g_gst__CWORD29__trans_rslt_dat[ul_index].opc; - pst_data->uc_rid = g_gst__CWORD29__trans_rslt_dat[ul_index].uc_rid; - - return; -} - -/******************************************************************************* - * MODULE : CANTxRsltFin - * ABSTRACT : CANDataTransmission result notification completion processing - * FUNCTION : Determine and clear the registration of the specified index. - * ARGUMENT : uc_can_rid : CAN RID (Resource-ID managed by the CAN thread) - * NOTE : - * RETURN : void - ******************************************************************************/ -void CANTxRsltFin(uint8_t uc_can_rid) { - uint8_t uc_index; /* Indexed */ - - if ((uint8_t)CAN_TXRSLT_CANRID_1TIME_START > uc_can_rid) { /*** Periodic transmission ***/ - uc_index = uc_can_rid; - if (g_gst_freq_trans_dat[uc_index].uc_resp_num > (uint8_t)0) { - g_gst_freq_trans_dat[uc_index].uc_resp_num--; /* Decrement the number of transmission result notifications */ - if ((uint8_t)0 == g_gst_freq_trans_dat[uc_index].uc_resp_num) { - g_gst_freq_trans_dat[uc_index].uc_rid = 0; - } - } - } else if ((uint8_t)CAN_TXRSLT_CANRID__CWORD29__START > uc_can_rid) { /*** One-time transmission ***/ - uc_index = (uint8_t)((uint32_t)uc_can_rid - CAN_TXRSLT_CANRID_1TIME_START); - memset(g_gst1_time_trans_rslt_dat[uc_index].notify_name, 0x00, - sizeof(g_gst1_time_trans_rslt_dat[uc_index].notify_name)); - g_gst1_time_trans_rslt_dat[uc_index].ul_canid = 0; - g_gst1_time_trans_rslt_dat[uc_index].uc_rid = (uint8_t)CAN_RID_NOTUSE_CODE; - /* Enter the User unset code */ - } - - return; -} - -/******************************************************************************* - * MODULE : CAN_CWORD29_TxRsltFin - * ABSTRACT : _CWORD29_ transmission result notification completion process - * FUNCTION : Clearing and clearing _CWORD29_ registrations of specified indexes - * ARGUMENT : uc_can_rid : CAN RID (Resource-ID managed by the CAN thread) - * NOTE : - * RETURN : void - ******************************************************************************/ -void CAN_CWORD29_TxRsltFin(const uint8_t uc_can_rid) { - uint32_t ul_index; /* Indexed */ - - if (static_cast<uint32_t>(CAN_TXRSLT_CANRID__CWORD29__START) > uc_can_rid) { - return; - } - - ul_index = uc_can_rid - static_cast<uint32_t>(CAN_TXRSLT_CANRID__CWORD29__START); - if (static_cast<uint32_t>(CAN__CWORD29__TRSNSMISSION_RSLT_NUM) <= ul_index) { - return; - } - - memset(reinterpret_cast<void *>(g_gst__CWORD29__trans_rslt_dat[ul_index].notify_name), 0x00, - MAX_NAME_SIZE_APP); - g_gst__CWORD29__trans_rslt_dat[ul_index].opc = 0; - - /* Enter the User unset code */ - g_gst__CWORD29__trans_rslt_dat[ul_index].uc_rid = (uint8_t)CAN_RID_NOTUSE_CODE; - - return; -} - -/******************************************************************************* - * MODULE : CANTxRsltSndCheck - * ABSTRACT : CANDataTransmission result notification determination processing - * FUNCTION : CANDataDetermine whether to perform transmission result notification - * ARGUMENT : uc_can_rid : CAN RID (Resource-ID managed by the CAN thread) - * ul_sts : Received transmission result status - * NOTE : - * RETURN : TRUE : Transmission result notification required - * FALSE : No need to send result notification - ******************************************************************************/ -BOOL CANTxRsltSndCheck(uint8_t uc_can_rid, uint32_t ul_sts) { // LCOV_EXCL_START 8:this IF is called in CANIcrSndStsProcess, which will not be called // NOLINT (whitespace/line_length) - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - BOOL ret = FALSE; /* Return value of this function */ - /*** Periodic transmission ***/ - if ((uint8_t)CAN_TXRSLT_CANRID_1TIME_START > uc_can_rid) { - /* Always send result notification */ - ret = TRUE; - } else if ((uint8_t)CAN_TXRSLT_CANRID__CWORD29__START > uc_can_rid) {/*** One-time transmission ***/ - /* Always send result notification */ - ret = TRUE; - } - - return (ret); -} -// LCOV_EXCL_STOP 8 - -/******************************************************************************* - * MODULE : CANCycleTransBufferOut - * ABSTRACT : CAN periodic transmission table log output processing - * FUNCTION : Output the CAN periodic transmission table log - * ARGUMENT : FILE *fp_log : File pointer of the log output file - * NOTE : - * RETURN : - ******************************************************************************/ -void CANCycleTransBufferOut(FILE *fp_log) { // LCOV_EXCL_START 8: for dead code - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - int32_t usage_rate; - uint16_t i; - uint16_t data_cnt = 0; - - if (NULL != fp_log) { - /* CAN periodic transmission table output */ - (void)fprintf(fp_log, "CAN CycleTrans Buffer \n"); - (void)fprintf(fp_log, "CanID: Freq: SndId: Rid: DLC:\n"); - for (i = 0; i < (uint16_t)CAN_FREQ_TRSNSMISSION_LIST_NUM; i++) { - /* Data Registration Max */ - if ((uint16_t)0 != g_gst_freq_trans_dat[i].us_freq) { - (void)fprintf(fp_log, "%08x %04x %s %04x %04x\n", - g_gst_freq_trans_dat[i].st_can_data.can_id, - g_gst_freq_trans_dat[i].us_freq, - g_gst_freq_trans_dat[i].notify_name, - g_gst_freq_trans_dat[i].uc_rid, - g_gst_freq_trans_dat[i].st_can_data.dlc); - data_cnt++; - } - } - usage_rate = (((int32_t)data_cnt * 100) / CAN_FREQ_TRSNSMISSION_LIST_NUM); - (void)fprintf(fp_log, "BUFFER_Use: %04d BUFFER_Max: %04d Usage_Rate: %04d \n", - data_cnt, CAN_FREQ_TRSNSMISSION_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 - -/*!----------------------------------------------------------------------------- - * @~english - * @brief Merge and Update CAN Data - * - * @~english - * @return Return value - * @retval <TURE> OK - * @retval <FALSE> Failure - * - * @~english - * @param[in] <rcv_msg> Start transmission message structure - */ -BOOL CANTransDataEntry(CAN_TRANS_START_MSG_DAT *rcv_msg) { - CAN_TRANS_START_TABLE_VAL *tmp_trans_data; - uint8_t mrg_data[CAN_TXDATA_SIZE] = {}; - CAN_DATA_BIT *mem_data; - int i; - BOOL ret = TRUE; - - ret = CANEntryTransCanidCheck(rcv_msg->id); - if (FALSE == ret) { - goto exit; - } - - /* Get transmission data of corresponding CAN ID */ - tmp_trans_data = g_map_trans_data[rcv_msg->id]; - mem_data = &tmp_trans_data->dat; - - /* Merge transmission data */ - for (i = 0; i < tmp_trans_data->dlc; i++) { - uint8_t mask = rcv_msg->mask.dat[i]; - uint8_t bit = rcv_msg->dat.dat[i]; - - mrg_data[i] = mask & bit; - mem_data->dat[i] = (uint8_t)((uint8_t)(mem_data->dat[i]) & (uint8_t)(~mask)); - mem_data->dat[i] |= mrg_data[i]; - } - - /* Update Transmission data management table */ - tmp_trans_data->dat = *mem_data; - -exit: - return ret; -} - -/*!----------------------------------------------------------------------------- - * @~english -* @brief Transmission CAN Data(SubID) with Marge and Update Data - * - * @~english - * @return Return value - * @retval <TURE> OK - * @retval <FALSE> Failure - * - * @~english - * @param[in] <rcvMsg> Start transmission message structure - *----------------------------------------------------------------------------*/ -BOOL CAN_SubIDTransStartTxMsg(HANDLE h_app, CAN_TRANS_START_MSG_DAT *rcvMsg) -{ - CAN_TRANS_START_TABLE_VAL *transData; - CAN_DATA_BIT *memData; - - std::multimap<CANID, CAN_TRANS_START_TABLE_VAL *>::iterator it; - // Find CANID Matching - for (it = mapSubIDTransData.find(rcvMsg->id); it != mapSubIDTransData.end(); it++) - { - transData = it->second; - - // SubID matches - if (transData->dat.dat[0] == (rcvMsg->dat.dat[0] & rcvMsg->mask.dat[0])) { - // CANData(The 1byte eye is fixed to the SubID, so it should not be changed.) - memData = &transData->dat; - for (int i = 1; i < transData->dlc; i++) { - memData->dat[i] &= ~rcvMsg->mask.dat[i]; - memData->dat[i] |= (rcvMsg->mask.dat[i] & rcvMsg->dat.dat[i]); - } - // CANDataSend - return CANTransStartTxMsgCore(h_app, rcvMsg->id, transData->dlc, &transData->dat); - } - } - - // No matching CAN ID-SubID - return FALSE; -} - -/*!----------------------------------------------------------------------------- - * @~english - * @brief Get Transmission data - * - * @~english - * @return Return value - * @retval <TRUE> Transmission success - * @retval <FALSE> Transmission failed - * - * @~english - * @param[in] <id> CAN ID - */ -BOOL CANTransStartTxMsg(HANDLE h_app, CANID id) { - map<CANID, CAN_TRANS_START_TABLE_VAL *>::iterator it; - CAN_TRANS_START_TABLE_VAL *trans_data; - - /* Get transmission data of corresponding CAN ID */ - it = g_map_trans_data.find(id); - if (it == g_map_trans_data.end()) { - return FALSE; - } - trans_data = it->second; - - /* Transmission CAN Data */ - return CANTransStartTxMsgCore(h_app, id, trans_data->dlc, &trans_data->dat); -} - -/*!----------------------------------------------------------------------------- - * @~english - * @brief Check invalid CAN ID - * - * @~english - * @return Return value - * @retval <TURE> OK - * @retval <FALSE> Invalid CAN ID - * - * @~english - * @param[in] <id> CAN ID - */ -BOOL CANEntryTransCanidCheck(CANID id) { - map<CANID, CAN_TRANS_START_TABLE_VAL *>::iterator it; - - /* Get transmission data of corresponding CAN ID */ - it = g_map_trans_data.find(id); - if (it == g_map_trans_data.end()) { - return FALSE; - } - - return TRUE; -} // LCOV_EXCL_BR_LINE 10:THE_END_LINE_OF_THE_FILE diff --git a/communication/server/src/CAN/TxMsg/CAN_TxMsg.cpp b/communication/server/src/CAN/TxMsg/CAN_TxMsg.cpp index 36ddc6d8..fa5d61d6 100644 --- a/communication/server/src/CAN/TxMsg/CAN_TxMsg.cpp +++ b/communication/server/src/CAN/TxMsg/CAN_TxMsg.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. @@ -13,949 +13,404 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - -/******************************************************************************* - * SYSTEM :_CWORD107_ - * SUBSYSTEM :EXL process - * Module configuration :CANDeliverySndMsg( ) CANDataDelivery message transmission processing - * CANFreqTransStartTxMsg( ) CANDataPeriodic transmission start message transmission processing - * CAN1TimeTransStartTxMsg( ) CANDataSend one transmission start message processing - * CANCommWatchSndMsg( ) CANDataTransmission of communication interruption detection/recovery message - * CANTxRsltSndMsg( ) CANDataTransmission result notification message transmission processing - * CANCanidUserToIfCvt( ) CAN ID Conversion Process 2 - * CANCommandDeliverySndMsg( ) CAN command delivery message transmission processing - * CANCommandTxRsltSndMsg( ) CAN command transmission result notification message transmission processing - * CANCommandTransmissionSndMsg( ) CAN command message transmission processing - * CANCommandFuelCalcRstReqSndMsg( ) CAN section flame reset request reception message transmission processing - * CANCommandidOpcToUserCvt( ) CAN Command ID Conversion Processing 1 - * CANCommandidUserToOpcCvt( ) CAN command ID conversion process 2 - ******************************************************************************/ -/*!----------------------------------------------------------------------------- - * @file CAN_TxMsg.cpp - * @~english - * @brief CAN Thread Message transmission process - */ #include "CAN_TxMsg.h" - -#include <string.h> // NOLINT (build/include) -#include <other_service/strlcpy.h> +#include "CAN_Delivery.h" +#include <string.h> #include <native_service/frameworkunified_types.h> -#include <agl_thread.h> #include <native_service/frameworkunified_framework_if.h> #include <peripheral_service/Canif_API.h> -//#include <can_hal.h> +#include <can_hal.h> #include <map> -#include <utility> #include <string> -#include "ICR_Common.h" - #include "CAN_Thread.h" -#include "CAN_DeliveryData.h" -#include "CAN_TransmissionData.h" -#include "CAN_CommWatchData.h" -#include "CAN_CommandData.h" - -/*************************************************/ -/* Prototype declaration */ -/*************************************************/ - -/*************************************************/ -/* Global variable */ -/*************************************************/ -static std::map<std::string, HANDLE_DAT> g_map_handler; -extern std::multimap<CANID, std::string> g_map_delivery_list; -extern std::multimap<uint16_t, std::string> g_map__CWORD29__delivery_list; -extern CAN_MSG_CANGWDATA g_cangw_msg_data; /* CANdata to be sent to the CANGW */ -extern BOOL g_isaccoff; // Declared in communication_application.cpp -/******************************************************************************* - * MODULE : CANDeliverySndMsg - * ABSTRACT : CANDataDelivery message transmission processing - * FUNCTION : CANDataSending a Delivery Message - * ARGUMENT : can_id : CAN ID - * uc_dlc : DLC - * *puc_data : CANDataPart pointer - * uc_opc : OPC - * n_ta : N_TA - * NOTE : - * RETURN : TRUE : Message transmission success - * FALSE : Message transmission failure - ******************************************************************************/ -BOOL CANDeliverySndMsg(HANDLE h_app, CANID can_id, uint8_t uc_dlc, - const uint8_t *puc_data, uint8_t uc_opc, uint8_t n_ta) { - BOOL ret = TRUE; - CAN_MSG_CANDATA st_delivery_msg; - uint8_t uc_size; - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - HANDLE h_client; - BOOL q_full = FALSE; - uint16_t can_id_shift = 0; - std::multimap<CANID, std::string>::iterator it; - std::pair<std::multimap<CANID, std::string>::iterator, std::multimap<CANID, std::string>::iterator> rang; - - /* Initialization of delivery-message-structure to user */ - (void)memset(reinterpret_cast<void *>(&st_delivery_msg), (int32_t)0, (size_t)sizeof(st_delivery_msg)); - - /****** Header section creation (excluding response destination process No.) ******/ - switch (uc_opc) { - default: /* CAN_OPC_RX */ -// st_delivery_msg.hdr.hdr.cid = (uint16_t)CID_CAN_DATA_DELIVERY; /* CANDataDelivery notice */ - break; - } - /* Message data size */ -// st_delivery_msg.hdr.hdr.msgbodysize = (uint16_t)(CAN_TRX_CANID_SIZE + CAN_TRX_DLC_SIZE + -// CAN_TRX_DLC_RESERVE_SIZE + (uint32_t)uc_dlc); -// st_delivery_msg.hdr.hdr.rid = 0; /* Resource ID (not used) */ - - /****** Creation of data section ******/ - st_delivery_msg.data.can_id = can_id; /* CAN ID */ - st_delivery_msg.data.dlc = uc_dlc; /* DLC */ - if ((uint8_t)CAN_DATA_SIZE < uc_dlc) { - AGL_ASSERT_NOT_TESTED(); - uc_size = (uint8_t)CAN_DATA_SIZE; - } else { - uc_size = uc_dlc; - } - memcpy(st_delivery_msg.data.data, puc_data, (size_t)uc_size); +#include "Thread_Common.h" +#include "Canif_API_Local.h" +#include "CAN_TxMsg.h" +#include "Canif_TransmissionData.h" - it = g_map_delivery_list.find(can_id); - if (it == g_map_delivery_list.end()) { - /* Delivery destination unregistered log output */ - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "#CAN_thread# CAN ID 0x%x not found in CAN Delivery entry table", can_id); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT (whitespace/line_length) - } +static std::map<CANID, CAN_SEND_STATUS_DAT> g_m_send_sts; +static bool can_cmd_rst_rcv = false; +static std::map<CANID, CAN_TRANS_START_TABLE_VAL *> g_map_trans_data; - /****** Messaging ******/ - rang = g_map_delivery_list.equal_range(can_id); - for (it = rang.first; it != rang.second; ++it) { - // If the delivery destination is other than CANGW, datum is sent. - if (TN_CANGW_M_RCV != it->second) { - if (g_map_handler.count(it->second) == 0) { - h_client = FrameworkunifiedMcOpenSender(h_app, it->second.c_str()); - if (h_client == NULL) { // LCOV_EXCL_BR_LINE 4: NSFW error case - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - ret = FALSE; // LCOV_EXCL_LINE 4: NSFW error case - continue; // LCOV_EXCL_LINE 4: NSFW error case - } - g_map_handler[it->second].handle = h_client; - g_map_handler[it->second].is_q_full = FALSE; - } else { - h_client = g_map_handler[it->second].handle; - q_full = g_map_handler[it->second].is_q_full; - } +void CANTxMsgInit(void) { + g_m_send_sts.clear(); + uint32_t i; - if (g_isaccoff && q_full) { - /* Once queue full has occured during ACC OFF, do nothing */ - } else { -// e_status = FrameworkunifiedSendMsg(h_client, st_delivery_msg.hdr.hdr.cid, sizeof(st_delivery_msg), &st_delivery_msg); - if (eFrameworkunifiedStatusMsgQFull == e_status) { // LCOV_EXCL_BR_LINE 4: NSFW error case - /* eFrameworkunifiedStatusMsgQFull */ - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - g_map_handler[it->second].is_q_full = TRUE; // LCOV_EXCL_LINE 4: NSFW error case - } - if (e_status != eFrameworkunifiedStatusOK) { // LCOV_EXCL_BR_LINE 4: NSFW error case - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - ret = FALSE; // LCOV_EXCL_LINE 4: NSFW error case - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# FrameworkunifiedSendMsg Error(e_status:%d to:%s)", e_status, it->second.c_str()); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT (whitespace/line_length) - } - } - } else { // If the destination is CANGW, the data is stored in the buffers. - can_id_shift = (uint16_t)(can_id << 4); - g_cangw_msg_data.data[g_cangw_msg_data.num].can_id_high = (uint8_t)(can_id_shift >> 8); - g_cangw_msg_data.data[g_cangw_msg_data.num].can_id_low = (uint8_t)(can_id_shift & 0xFF); - if (CANGW_DLC_MAX_SIZE < uc_dlc) { // LCOV_EXCL_BR_LINE 6: already checked in CANHalRcvProcess - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - g_cangw_msg_data.data[g_cangw_msg_data.num].dlc = CANGW_DLC_MAX_SIZE; // LCOV_EXCL_LINE 6: same as above - } else { - g_cangw_msg_data.data[g_cangw_msg_data.num].dlc = uc_dlc; - } - memcpy(g_cangw_msg_data.data[g_cangw_msg_data.num].data, puc_data, (size_t)CANGW_DLC_MAX_SIZE); - g_cangw_msg_data.num++; - } + for (i = 0; i < _countof(Can_TransInitData_21PF); i++) { + CANID canid = Can_TransInitData_21PF[i].canid; + CAN_TRANS_START_TABLE_VAL *val = &(Can_TransInitData_21PF[i].val); + g_map_trans_data[canid] = val; } - return (ret); + return; } -/******************************************************************************* - * MODULE : CANDelivery_CWORD29_SndMsg - * ABSTRACT : CAN_CWORD29_ delivery messaging process - * FUNCTION : Send CAN_CWORD29_ delivery messages - * ARGUMENT : h_app : HANDLE - * us_opc : OPC - * uc_dlc : DLC - * *puc_data : CANDataPart pointer - * NOTE : - * RETURN : TRUE : Message transmission success - * FALSE : Message transmission failure - ******************************************************************************/ -BOOL CANDelivery_CWORD29_SndMsg(HANDLE h_app, const uint16_t us_opc, uint32_t uc_dlc, const uint8_t *puc_data) { - BOOL ret = TRUE; - CAN_MSG_CAN__CWORD29_DATA st_delivery_msg; - uint32_t uc_size; - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - HANDLE h_client; - BOOL q_full = FALSE; - std::multimap<uint16_t, std::string>::iterator it; - std::pair<std::multimap<uint16_t, std::string>::iterator, std::multimap<uint16_t, std::string>::iterator> rang; - /* Initialization of delivery-message-structure to user */ - (void)memset(reinterpret_cast<void *>(&st_delivery_msg), (int32_t)0, (size_t)sizeof(st_delivery_msg)); - - /****** Creation of data section ******/ - st_delivery_msg.opc = us_opc; /* OPC */ - st_delivery_msg.dlc = uc_dlc; /* DLC */ - if ((uint32_t)CAN__CWORD29__MEM_SZ < uc_dlc) { - uc_size = (uint32_t)CAN__CWORD29__MEM_SZ; - } else { - uc_size = uc_dlc; - } - memcpy(st_delivery_msg.data, puc_data, (size_t)uc_size); - it = g_map__CWORD29__delivery_list.find(static_cast<const uint16_t>(us_opc)); - if (it == g_map__CWORD29__delivery_list.end()) { - /* Delivery destination unregistered log output */ - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "#CAN_thread# OPC 0x%x not found in CAN Delivery entry table", us_opc); - } +static bool CANCommandFuelCalcRstReqCheck(void) { + return can_cmd_rst_rcv; +} - /****** Messaging ******/ - rang = g_map__CWORD29__delivery_list.equal_range(static_cast<const uint16_t>(us_opc)); - for (it = rang.first; it != rang.second; ++it) { - if (g_map_handler.count(it->second) == 0) { - h_client = FrameworkunifiedMcOpenSender(h_app, it->second.c_str()); - if (h_client == NULL) { - ret = FALSE; - continue; - } - g_map_handler[it->second].handle = h_client; - g_map_handler[it->second].is_q_full = FALSE; - } else { - h_client = g_map_handler[it->second].handle; - q_full = g_map_handler[it->second].is_q_full; - } +void CANCommandSetFuelCalcRstReq(void) { + can_cmd_rst_rcv = true; +} - if (g_isaccoff && q_full) { - /* Once queue full has occured during ACC OFF, do nothing */ - } else { - e_status = FrameworkunifiedSendMsg(h_client, CID_CAN_DIAG_CWORD29__DELIVERY, sizeof(CAN_MSG_CAN__CWORD29_DATA), &st_delivery_msg); - if (eFrameworkunifiedStatusMsgQFull == e_status) { - /* eFrameworkunifiedStatusMsgQFull */ - g_map_handler[it->second].is_q_full = TRUE; - } - if (e_status != eFrameworkunifiedStatusOK) { - ret = FALSE; - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# FrameworkunifiedSendMsg Error(e_status:%d to:%s)", e_status, it->second.c_str()); // NOLINT (whitespace/line_length) - } - } - } - return (ret); +static void CANTxMsgErrorLog(const char *reason, const char *func, + CANID id, uint16_t len, HANDLE h_app) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, func, "%s Frame(0x%x) length=%hu from %s is ignored.", + reason, id, len, FrameworkunifiedGetMsgSrc(h_app)); } -/******************************************************************************* - * MODULE : CANDeliverySndMsgToCANGW - * ABSTRACT : CAN-data-delivery-messaging process to the CANGW - * FUNCTION : CANDataSending Delivery Messages to a CANGW - * ARGUMENT : h_app : HANDLE - * cangw_data : CAN_MSG_CANGWDATA - * NOTE : - * RETURN : TRUE : Message transmission success - * FALSE : Message transmission failure - ******************************************************************************/ -BOOL CANDeliverySndMsgToCANGW(HANDLE h_app, CAN_MSG_CANGWDATA *cangw_data) { - BOOL ret = TRUE; - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - HANDLE h_client; - BOOL q_full = FALSE; - uint8_t data_count; - - // Memset unused space - data_count = cangw_data->num; - memset(reinterpret_cast<void *>(&cangw_data->data[data_count]), (int32_t)0, - (size_t)sizeof(cangw_data->data[data_count]) * (CANGW_SND_NUM_MAX - data_count)); - - if (g_map_handler.count(TN_CANGW_M_RCV) == 0) { - h_client = FrameworkunifiedMcOpenSender(h_app, TN_CANGW_M_RCV); - if (h_client == NULL) { // LCOV_EXCL_BR_LINE 4: NSFW error case - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - ret = FALSE; // LCOV_EXCL_LINE 4: NSFW error case - goto exit; // LCOV_EXCL_LINE 4: NSFW error case - } - g_map_handler[TN_CANGW_M_RCV].handle = h_client; // LCOV_EXCL_BR_LINE 200 unexpect branch - g_map_handler[TN_CANGW_M_RCV].is_q_full = FALSE; // LCOV_EXCL_BR_LINE 200 unexpect branch - } else { - h_client = g_map_handler[TN_CANGW_M_RCV].handle; // LCOV_EXCL_BR_LINE 200 unexpect branch - q_full = g_map_handler[TN_CANGW_M_RCV].is_q_full; // LCOV_EXCL_BR_LINE 200 unexpect branch - } +static EFrameworkunifiedStatus CANCommandResponse(HANDLE h_app, CAN_MSG_CANCMD *msg, + size_t len, char *notifyName) { + HANDLE h_client = NULL; + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; - if (g_isaccoff && q_full) { - /* Once queue full has occured during ACC OFF, do nothing */ - } else { - e_status = FrameworkunifiedSendMsg(h_client, CID_CAN_CANGW_DELIVERY, sizeof(CAN_MSG_CANGWDATA), cangw_data); - if (eFrameworkunifiedStatusMsgQFull == e_status) { // LCOV_EXCL_BR_LINE 4: NSFW error case - /* eFrameworkunifiedStatusMsgQFull */ - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - g_map_handler[TN_CANGW_M_RCV].is_q_full = TRUE; // LCOV_EXCL_LINE 4: NSFW error case - } - if (e_status != eFrameworkunifiedStatusOK) { // LCOV_EXCL_BR_LINE 4: NSFW error case - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - ret = FALSE; // LCOV_EXCL_LINE 4: NSFW error case - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "#CAN_thread# FrameworkunifiedSendMsg Error(e_status:%d to:%s)", e_status, TN_CANGW_M_RCV); // LCOV_EXCL_LINE 4: NSFW error case // NOLINT (whitespace/line_length) - } + h_client = CommonFindSender(h_app, notifyName); + if (!h_client) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "Cannot open sender handle."); + return e_status; } -exit: - return (ret); + + msg->hdr.hdr.cid = (uint16_t)CID_CAN_CMD_DELIVERY; + e_status = FrameworkunifiedSendMsg(h_client, CID_CAN_CMD_DELIVERY, (uint32_t)len, msg); + if (e_status != eFrameworkunifiedStatusOK) + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedSendMsg is failed."); + + return e_status; } -/******************************************************************************* - * MODULE : CANFreqTransStartTxMsg - * ABSTRACT : CANDataPeriodic transmission start message transmission processing - * FUNCTION : CANDataSending Periodic Send Data as a Send Message - * ARGUMENT : uc_index : Indexed - * NOTE : - * RETURN : TRUE : Message transmission success - * FALSE : Message transmission failure - ******************************************************************************/ -BOOL CANFreqTransStartTxMsg(HANDLE h_app, uint8_t uc_index) { - BOOL ret = TRUE; /* Return value of this function */ - CAN_FREQ_TRANSMISSION_DAT st_data; /* Periodic send data acquisition buffer */ - - /****** Data acquisition ******/ - CANFreqTransDataGet(uc_index, &st_data); /* Periodic transmission data acquisition */ - - /****** Messaging ******/ - if ((uint8_t)0 == st_data.uc_resp_num) { - uc_index = (uint8_t)CAN_RID_NOTUSE_CODE; +static EFrameworkunifiedStatus CANCommandVersionReq(HANDLE h_app, char *notifyName) { + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; + CANHAL_RET_API ret = CANHAL_RET_NORMAL; + std::string version_info; + CAN_MSG_CANCMD msg; + + memset(&msg, 0, sizeof(msg)); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "@@@ Call CanGetVersion for can_hal"); + ret = CanGetVersion(h_app, &version_info); + if (ret != CANHAL_RET_NORMAL) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "Cannot get version from can_hal."); + return e_status; } - /* CANDataSend one transmission start message processing */ - if (FALSE == CAN1TimeTransStartTxMsg(h_app, uc_index, &st_data.st_can_data)) { - ret = FALSE; /* Return value of this function */ + if (CAN_TX_CMD_VERSION_SIZE != version_info.length()) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "Invalid length of version."); + return e_status; } - return (ret); + msg.hdr.hdr.rid = 0; + msg.hdr.hdr.msgbodysize = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_VERSION_SIZE; + msg.data.cmd_id = CAN_CMDID_VERSION_RESP_RX; + strncpy((char *)msg.data.data, version_info.c_str(), CAN_TX_CMD_VERSION_SIZE); + return CANCommandResponse(h_app, &msg, sizeof(msg), notifyName); } -/******************************************************************************* - * MODULE : CAN1TimeTransStartTxMsg - ******************************************************************************/ -/*!----------------------------------------------------------------------------- - * @~english - * @brief The transmission of CAN data transmission start message - * - * @~english - * The transmission of CAN data transmission start message - * - * @~english - * @note Details of process - * -# Creating of data division - * -# Message sending - * - * @~english - * @return Message transmission success/failure - * @retval <1> Message transmission success - * @retval <0> Message transmission failure - * - * @~english - * @param[in] <uc_can_rid> Index - * @param[in] <*pst_data> Pointer of transmission data - * @param[in] <uc_opc> Operation code - * @param[in] <n_ta> Target address - */ -BOOL CAN1TimeTransStartTxMsg(HANDLE h_app, uint8_t uc_can_rid, const CAN_DATA *pst_data) { - BOOL b_ret = TRUE; -// CanMessage st_can_data; -// -// if (pst_data != NULL) { // LCOV_EXCL_BR_LINE 200 (the caller always use the pointer of object) -// st_can_data.can_id = pst_data->can_id; -// st_can_data.dlc = pst_data->dlc; -// st_can_data.rid = uc_can_rid; -// if (pst_data->dlc < 8) { -// memcpy(st_can_data.data, pst_data->data, pst_data->dlc); -// } - -// if (CanSend(&st_can_data, CAN_HAL_TYPE_CAN) != CANHAL_RET_NORMAL) { -// b_ret = FALSE; -// } -// } - return b_ret; -} - -/******************************************************************************* - * MODULE : CANCommWatchSndMsg - * ABSTRACT : CANDataTransmission of communication interruption detection/recovery message - * FUNCTION : CANDataSend disconnection detection messages or recovery messages - * ARGUMENT : uc_index : Indexed - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANCommWatchSndMsg(HANDLE h_app, uint8_t uc_index) { - DID ul_did; /* Data ID */ - uint8_t uc_comm_stop; /* Communication status */ - CAN_MSG_COMM_WATCHSTS st_comm_watch_sts; /* Communication Disruption Detection/Recovery Message Structures to the user */ - // int32_t ret_api; /* Return Values of System API Functions */ - char notify_name[MAX_NAME_SIZE_APP]; - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - HANDLE h_client; - - /* Message structure initialization */ - memset(reinterpret_cast<void *>(&st_comm_watch_sts), (int32_t)0, (size_t)sizeof(st_comm_watch_sts)); - /* Buffer initialization */ - - /* Acquisition of the communication status of the target index */ - CANCommWatchDataGet(uc_index, notify_name, &ul_did, &uc_comm_stop, CAN_PROTOCOL_TYPE_CAN); - - /* Message creation */ - /* Creation of header part (CAN -> Monitoring Requester)*/ -// if ((uint8_t)CAN_COMM_NORMAL == uc_comm_stop) { /* Command ID */ - /* During communication -> Send data communication recovery notification message */ -// st_comm_watch_sts.hdr.hdr.cid = (uint16_t)CID_CAN_COMM_RESTORE; -// } else { - /* When communication is interrupted -> Send data communication interruption notification message */ -// st_comm_watch_sts.hdr.hdr.cid = (uint16_t)CID_CAN_COMM_STOP; -// } -// st_comm_watch_sts.hdr.hdr.msgbodysize = sizeof(CAN_MSG_COMM_WATCHSTS_DAT); /* Message data size */ -// st_comm_watch_sts.hdr.hdr.rid = 0; /* Resource ID (not used) */ - st_comm_watch_sts.data.ulDid = ul_did; /* Creation of data section */ - - if (g_map_handler.count(notify_name) == 0) { - h_client = FrameworkunifiedMcOpenSender(h_app, notify_name); - if (h_client == NULL) { // LCOV_EXCL_BR_LINE 4: NSFW error case - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - goto exit; // LCOV_EXCL_LINE 4: NSFW error case - } - g_map_handler[notify_name].handle = h_client; // LCOV_EXCL_BR_LINE 200 unexpect branch - g_map_handler[notify_name].is_q_full = FALSE; // LCOV_EXCL_BR_LINE 200 unexpect branch +static EFrameworkunifiedStatus CANCommandFuelcalcRstReq(HANDLE h_app, char *notifyName) { + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; + if (CANCommandFuelCalcRstReqCheck()) { + // CAN_CMDID_FUELCALC_RST_REQ_RX is already received from can_hal. + // so response it in direct. + CAN_MSG_CANCMD msg; + memset(&msg, 0, sizeof(msg)); + msg.hdr.hdr.rid = 0; + msg.hdr.hdr.msgbodysize = CAN_TX_CMD_DELIVERY_SIZE + + CAN_TX_CMD_FUELCALC_RST_SIZE; + msg.data.cmd_id = CAN_CMDID_FUELCALC_RST_REQ_RX; + e_status = CANCommandResponse(h_app, &msg, sizeof(msg), notifyName); } else { - h_client = g_map_handler[notify_name].handle; // LCOV_EXCL_BR_LINE 200 unexpect branch - } -// e_status = FrameworkunifiedSendMsg(h_client, st_comm_watch_sts.hdr.hdr.cid, sizeof(st_comm_watch_sts), &st_comm_watch_sts); - if (e_status != eFrameworkunifiedStatusOK) { // LCOV_EXCL_BR_LINE 4: NSFW error case - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - CANCommWatchDelete(uc_index, CAN_PROTOCOL_TYPE_CAN); // LCOV_EXCL_LINE 4: NSFW error case - goto exit; // LCOV_EXCL_LINE 4: NSFW error case + CANDeliveryInsert(CAN_CMDID_FUELCALC_RST_REQ_RX, notifyName); + e_status = eFrameworkunifiedStatusOK; } -exit: - return; + return e_status; } -/******************************************************************************* - * MODULE : CANTxRsltSndMsg - * ABSTRACT : CANDataTransmission result notification message transmission processing - * FUNCTION : CANDataSend a transmission result notification message - * ARGUMENT : uc_can_rid : Resource ID from CAN - * uc_status : Transmission result status - * NOTE : - * RETURN : TRUE : Message transmission success - * FALSE : Message transmission failure - ******************************************************************************/ -BOOL CANTxRsltSndMsg(HANDLE h_app, uint8_t uc_can_rid, uint8_t uc_status) { - BOOL ret = TRUE; /* Return value of this function */ - CAN_MSG_SENDSTS st_txrslt_msg; /* Transmission result notification message structure */ - CAN_1TIME_TXRSLT_DAT st_data; /* Transmission result data */ - int32_t ret_api = RET_NORMAL; /* Return Values of System API Functions */ - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - HANDLE h_client; +static EFrameworkunifiedStatus CANCommandOther(HANDLE h_app, char *notifyName, + uint8_t cmd, uint8_t rid) { + CanMessage msg; + CANID wait = 0; + CANID can_id = (CANID)cmd; + + memset(&msg, 0, sizeof(msg)); + switch (cmd) { + case CAN_CMDID_STARTUP_FIN_REQ_TX: + wait = CAN_CMDID_STARTUP_FIN_RESP_RX; + break; + case CAN_CMDID_MRST_INFO_REQ_TX: + wait = CAN_CMDID_MRST_INFO_RESP_RX; + break; + case CAN_CMDID_CONNECTION_NODE_REQ_TX: + wait = CAN_CMDID_CONNECTION_NODE_RESP_RX; + break; + case CAN_CMDID_FUELCALC_REQ_TX: + wait = CAN_CMDID_FUELCALC_RST_REQ_RX; + break; + default: + CANTxMsgErrorLog("Unsupported cmd requested", __func__, cmd, 0, h_app); + return eFrameworkunifiedStatusFail; + } - if (static_cast<const uint8_t>(CAN_TXRSLT_CANRID__CWORD29__START) <= uc_can_rid) { - return (FALSE); + if (cmd != CAN_CMDID_FUELCALC_REQ_TX) { + CANDeliveryInsert(wait, notifyName); } - memset(reinterpret_cast<void *>(&st_txrslt_msg), 0, sizeof(CAN_MSG_SENDSTS)); - /* Message structure initialization */ - /****** Data acquisition ******/ - CANTxRsltDataGet(uc_can_rid, &st_data); - - /****** Creation of header section ******/ -// st_txrslt_msg.hdr.hdr.cid = static_cast<uint16_t>(CID_CAN_TX_RESULT); /* Command ID */ -// st_txrslt_msg.hdr.hdr.msgbodysize = static_cast<uint16_t>(sizeof(CAN_MSG_SENDSTS_DAT)); /* Message data size */ - - /****** Creation of data section ******/ -// st_txrslt_msg.hdr.hdr.rid = st_data.uc_rid; /* Resources ID */ - st_txrslt_msg.data.ulCanid = st_data.ul_canid; /* CAN ID */ - st_txrslt_msg.data.ucStatus = uc_status; /* Transmission result status */ - - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "Rid:%02x Canid:%08x Status:%02x", st_data.uc_rid, st_data.ul_canid, uc_status); // LCOV_EXCL_BR_LINE 15:marco defined in "native_service/ns_logger_if.h" // NOLINT (whitespace/line_length) - /****** Messaging ******/ - if (g_map_handler.count(st_data.notify_name) == 0) { - h_client = FrameworkunifiedMcOpenSender(h_app, reinterpret_cast<const char *>(st_data.notify_name)); - if (h_client == reinterpret_cast<HANDLE>(NULL)) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedMcOpenSender Error(name=%s)", st_data.notify_name); - ret_api = RET_ERROR; + if (rid != CAN_RID_NOTUSE_CODE) { + // cmd can be assumed same as can_id. + if (0 < g_m_send_sts.count(can_id)) { + if (g_m_send_sts[can_id].notify_name[0] != 0x00) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, + "Not yet deliver SendSts but updated(SendID=%x, CAN ID=%x, Nane=%s)", + g_m_send_sts[can_id].rid, can_id, g_m_send_sts[can_id].notify_name); + } } - g_map_handler[st_data.notify_name].handle = h_client; // LCOV_EXCL_BR_LINE 200: unexpect branch - g_map_handler[st_data.notify_name].is_q_full = FALSE; // LCOV_EXCL_BR_LINE 200: unexpect branch - } else { - h_client = g_map_handler[st_data.notify_name].handle; // LCOV_EXCL_BR_LINE 200: unexpect branch + g_m_send_sts[can_id].rid = rid; + memcpy(g_m_send_sts[can_id].notify_name, notifyName, + sizeof(g_m_send_sts[can_id].notify_name)); } -// e_status = FrameworkunifiedSendMsg(h_client, st_txrslt_msg.hdr.hdr.cid, -// static_cast<UI_32>(sizeof(CAN_MSG_SENDSTS)), reinterpret_cast<PCVOID>(&st_txrslt_msg)); - if (e_status != eFrameworkunifiedStatusOK) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedSendMsg Error"); - ret_api = RET_ERROR; - } + msg.can_id = (CANID)cmd; + msg.rid = rid; + msg.dlc = (uint8_t)CAN_CMDSND_DATA_SIZE; - if (RET_NORMAL != ret_api) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedSendMsg Error(ret_api=%d)", ret_api); - /* Check for message transmission and reception errors */ - CANMsgErrChk(ret_api, 0); - ret = FALSE; /* Message transmission failure */ + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "@@@ Call CanSend for can_hal"); + if (CANHAL_RET_NORMAL != CanSend(h_app, &msg, CAN_HAL_TYPE_CAN)) { + CANTxMsgErrorLog("CAN CanSend failed", __func__, msg.can_id, + (uint16_t)msg.dlc, h_app); + return eFrameworkunifiedStatusFail; } - return (ret); + return eFrameworkunifiedStatusOK; } -/******************************************************************************* - * MODULE : CAN_CWORD29_TxRsltSndMsg - * ABSTRACT : _CWORD29_ data transmission result notification message transmission process - * FUNCTION : Send _CWORD29_ transmission result notification messages - * ARGUMENT : uc_can_rid : Resource ID from CAN - * uc_status : Transmission result status - * NOTE : - * RETURN : TRUE : Message transmission success - * FALSE : Message transmission failure - ******************************************************************************/ -BOOL CAN_CWORD29_TxRsltSndMsg(const HANDLE h_app, const uint8_t uc_can_rid, const uint8_t uc_status) { - BOOL ret = TRUE; /* Return value of this function */ - CAN_MSG__CWORD29__SENDSTS st_txrslt_msg; /* _CWORD29_ send result notification messaging structures */ - CAN__CWORD29__TXRSLT_DAT st_data; /* _CWORD29_ transmission result data */ - int32_t ret_api = RET_NORMAL; /* Return Values of System API Functions */ - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - HANDLE h_client; +EFrameworkunifiedStatus CANTxMsgCommand(HANDLE h_app) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __func__, "@@@ Start communication CanCommandCtl"); - if (reinterpret_cast<HANDLE>(NULL) == h_app) { - return (FALSE); - } + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; + CAN_CMD_CTRL_MSG_DAT rcv_msg; - memset(reinterpret_cast<void *>(&st_txrslt_msg), 0, sizeof(CAN_MSG__CWORD29__SENDSTS)); - /* Message structure initialization */ - /****** Data acquisition ******/ - CAN_CWORD29_TxRsltDataGet(uc_can_rid, &st_data); - - /****** Creation of header section ******/ -// st_txrslt_msg.hdr.hdr.cid = CID_CAN__CWORD29__TX_RESULT; /* Command ID */ - /* Message data size */ -// st_txrslt_msg.hdr.hdr.msgbodysize = static_cast<uint16_t>(sizeof(CAN_MSG__CWORD29__SENDSTS_DAT)); - - /****** Creation of data section ******/ -// st_txrslt_msg.hdr.hdr.rid = st_data.uc_rid; /* Resources ID */ - st_txrslt_msg.data.usOpc = st_data.opc; /* OPC */ - st_txrslt_msg.data.ucStatus = uc_status; /* Transmission result status */ - - FRAMEWORKUNIFIEDLOG(ZONE_CAN_DEBUG, __func__, "Rid:%02x OPC:%08x Status:%02x", st_data.uc_rid, st_data.opc, uc_status); - /****** Messaging ******/ - if (g_map_handler.count(reinterpret_cast<const char *>(st_data.notify_name)) == 0) { - h_client = FrameworkunifiedMcOpenSender(h_app, st_data.notify_name); - if (h_client == reinterpret_cast<HANDLE>(NULL)) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedMcOpenSender Error(name=%s)", st_data.notify_name); - ret_api = RET_ERROR; - } - g_map_handler[st_data.notify_name].handle = h_client; - g_map_handler[st_data.notify_name].is_q_full = FALSE; - } else { - h_client = g_map_handler[st_data.notify_name].handle; - } + memset(&rcv_msg, 0, sizeof(rcv_msg)); -// e_status = FrameworkunifiedSendMsg(h_client, static_cast<UI_32>(st_txrslt_msg.hdr.hdr.cid), sizeof(CAN_MSG__CWORD29__SENDSTS), -// &st_txrslt_msg); + e_status = FrameworkunifiedGetMsgDataOfSize(h_app, &rcv_msg, sizeof(rcv_msg), eSMRRelease); if (e_status != eFrameworkunifiedStatusOK) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedSendMsg Error"); - ret_api = RET_ERROR; + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedGetMsgDataOfSize Error(%d)", e_status); + if (e_status == eFrameworkunifiedStatusInvldBufSize) + FrameworkunifiedClearMsgData(h_app); + return e_status; } - /****** NSFW error case ******/ - if (RET_NORMAL != ret_api) { - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedSendMsg Error(ret_api=%d)", ret_api); - /* Check for message transmission and reception errors */ - CANMsgErrChk(ret_api, 0); - /* Message transmission failure */ - ret = FALSE; // LCOV_EXCL_LINE 8:Due to dead code + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "notify_name=%s ulEvtId=%x ucRid=%x ucCmdid=%x", + rcv_msg.notifyName, rcv_msg.ulEvtId, rcv_msg.ucRid, rcv_msg.ucCmdid); + + switch (rcv_msg.ucCmdid) { + case CAN_CMDID_VERSION_REQ_TX: + e_status = CANCommandVersionReq(h_app, rcv_msg.notifyName); + break; + case CAN_CMDID_FUELCALC_RST_REQ_DELIVERY: + e_status = CANCommandFuelcalcRstReq(h_app, rcv_msg.notifyName); + break; + default: + e_status = CANCommandOther(h_app, + rcv_msg.notifyName, rcv_msg.ucCmdid, rcv_msg.ucRid); + break; } + return e_status; +} - return (ret); +static CAN_TRANS_START_TABLE_VAL *CANTxMsgFindMap(CAN_TRANS_START_MSG_DAT *msg) { + std::map<CANID, CAN_TRANS_START_TABLE_VAL *>::iterator it; + it = g_map_trans_data.find(msg->id); + if (it == g_map_trans_data.end()) + return NULL; + return it->second; } -/******************************************************************************* - * MODULE : CANCanidUserToIfCvt - * ABSTRACT : CAN ID Conversion Process 2 - * FUNCTION : Convert CAN ID for USER to CAN ID for interfaces - * ARGUMENT : can_id : CAN ID - * *puc_buf : CAN ID Array Pointers (Data-Out) - * NOTE : - * RETURN : None - ******************************************************************************/ -void CANCanidUserToIfCvt(CANID can_id, uint8_t *puc_buf) { - int32_t i; /* Generic counters */ - uint8_t *puc; /* Generic pointer */ - uint32_t ul1; /* General Variables */ - uint32_t ul2; /* General Variables */ - uint32_t ul3; /* General Variables */ - - /* Concept of conversion - Input data format (32-bit data) - Bit assignment [31:29] [28:0] - CAN ID free [2:0] CAN ID [28:0] - Output data format (8-bit data with the following structure) - Base Address +0 :ext_flag, CAN ID[10:4] - +1 :CAN ID[3:0], Empty[1:0], CAN ID[28:27] - +2 :CAN ID[26:19] - +3 :CAN ID[18:11] -*/ - ul1 = (uint32_t)can_id; /* Type conversion */ - ul2 = (ul1 << 20) & 0x7FF00000; /* Insert data of [10:0] */ - ul3 = (ul1 >> 11) & 0x0003FFFF; /* Populate [28:11] */ - ul2 |= ul3; /* Combine */ - /* Check of ext_flag */ - if (0 != ul3) { - ul2 |= CAN_ID_EXT_FLAG; /* Add Extended Flag */ - } else { - /* Do nothing */ - } - puc = puc_buf; /* Get array pointers */ - for (i = 0; i < 4; i++) { - ul3 = ul2 >> (uint32_t)((3 - i) * 8); - *puc = (uint8_t)ul3; /* Data storage */ - puc++; - } - return; +static CAN_TRANS_START_TABLE_VAL *CanSendFind(CAN_TRANS_START_MSG_DAT *msg) { + return CANTxMsgFindMap(msg); } -/******************************************************************************* - * MODULE : CANCommandDeliverySndMsg - * ABSTRACT : CAN command delivery message transmission processing - * FUNCTION : CAN command delivery (CAN thread-> user) - * ARGUMENT : uc_cmd_id : CAN command ID - * puc_data : Receive data reference pointer - * NOTE : - * RETURN : TRUE : Message transmission success - * FALSE : Message transmission failure - ******************************************************************************/ -BOOL CANCommandDeliverySndMsg(HANDLE h_app, uint8_t uc_cmd_id, const uint8_t *puc_data) { - BOOL ret = TRUE; /* Return value of this function */ - CAN_MSG_CANCMD st_snd_msg; /* CAN Command Delivery Notification Message Structure */ - int32_t l_cnt = 0; /* Counter */ - uint32_t ul = 0; /* General Variables */ - // int32_t ret_api; /* Return Values of System API Functions */ - CAN_COMMAND_DELIVERY_LIST_DAT list; - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - HANDLE h_client; - - /* Get Shipping ID List */ - (void)CANCommandDeliveryDataGet(uc_cmd_id, &list); - - /* Messaging */ - for (l_cnt = 0; l_cnt < (int32_t)list.notify_name_num; l_cnt++) { - /* Data size setting */ - switch (uc_cmd_id) { // LCOV_EXCL_BR_LINE 6:Excluded because the value is not currently passed - case CAN_CMDID_FUELCALC_RST_REQ_RX: - ul = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_FUELCALC_RST_SIZE; - break; - case CAN_CMDID_STARTUP_FIN_RESP_RX: - ul = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_STARTUP_FIN_SIZE; - break; - case CAN_CMDID_MRST_INFO_RESP_RX: - ul = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_MRST_INFO_SIZE; - break; - case CAN_CMDID_VERSION_RESP_RX: - ul = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_VERSION_SIZE; - break; - case CAN_CMDID_CONNECTION_NODE_RESP_RX: - ul = CAN_TX_CMD_DELIVERY_SIZE + (uint32_t)puc_data[0] + 1; - break; - default: - // LCOV_EXCL_START 6 Excluded because the value is not currently passed - AGL_ASSERT_NOT_TESTED(); - ul = (uint32_t)sizeof(st_snd_msg.data); - break; - // LCOV_EXCL_STOP6 Excluded because the value is not currently passed - } +EFrameworkunifiedStatus CANTxMsgBit(HANDLE h_app) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __func__, "@@@ Start communication CanSend(bit)"); - (void)memset(reinterpret_cast<void *>(&st_snd_msg), (int32_t)0, (size_t)sizeof(st_snd_msg)); - /* Message structure initialization */ - /****** Creation of header section ******/ -// st_snd_msg.hdr.hdr.rid = 0; /* Resource ID (not used) */ -// st_snd_msg.hdr.hdr.cid = (uint16_t)CID_CAN_CMD_DELIVERY; /* Command ID */ -// st_snd_msg.hdr.hdr.msgbodysize = (uint16_t)ul; /* Message data size */ - - /****** Creation of data section ******/ - st_snd_msg.data.cmd_id = uc_cmd_id; /* CAN command ID */ - memcpy(&st_snd_msg.data.data[0], puc_data, (ul - CAN_TX_CMD_DELIVERY_SIZE)); /* Received data */ - - /****** Messaging ******/ - if (g_map_handler.count(list.notify_name_list[l_cnt]) == 0) { - h_client = FrameworkunifiedMcOpenSender(h_app, list.notify_name_list[l_cnt]); - if (h_client == NULL) { - ret = FALSE; - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedMcOpenSender Error(notify_name=%s)", list.notify_name_list[l_cnt]); - break; - } - g_map_handler[list.notify_name_list[l_cnt]].handle = h_client; - g_map_handler[list.notify_name_list[l_cnt]].is_q_full = FALSE; - } else { - h_client = g_map_handler[list.notify_name_list[l_cnt]].handle; - } - e_status = FrameworkunifiedSendMsg(h_client, CID_CAN_CMD_DELIVERY, sizeof(st_snd_msg), &st_snd_msg); - if (e_status != eFrameworkunifiedStatusOK) { - CANCommandDeliveryDeletesingle(uc_cmd_id, list.notify_name_list[l_cnt]); - ret = FALSE; - FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedSendMsg Error(e_status=%d)", e_status); - break; - } + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; + CAN_TRANS_START_MSG_DAT rcv_msg; + CanMessage snd_msg; + CAN_TRANS_START_TABLE_VAL *store; + int32_t i = 0; + uint8_t *store_p; + uint8_t *data_p; + uint8_t *mask_p; + + memset(&rcv_msg, 0, sizeof(rcv_msg)); + memset(&snd_msg, 0, sizeof(snd_msg)); + + e_status = FrameworkunifiedGetMsgDataOfSize(h_app, &rcv_msg, sizeof(rcv_msg), eSMRRelease); + if (e_status != eFrameworkunifiedStatusOK) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedGetMsgDataOfSize Error(%d)", e_status); + if (e_status == eFrameworkunifiedStatusInvldBufSize) + FrameworkunifiedClearMsgData(h_app); + goto cleanup; } - return (ret); -} + e_status = eFrameworkunifiedStatusFail; -/******************************************************************************* - * MODULE : CANCommandTxRsltSndMsg - * ABSTRACT : CAN command transmission result notification message transmission processing - * FUNCTION : Send CAN command send result notification (CAN thread-> user) - * ARGUMENT : uc_can_rid : Resource ID from CAN - * uc_status : Transmission result status - * NOTE : - * RETURN : - * RETURN : TRUE : Message transmission success - * FALSE : Message transmission failure - ******************************************************************************/ -BOOL CANCommandTxRsltSndMsg(HANDLE h_app, uint8_t uc_can_rid, uint8_t uc_status) { - BOOL ret = TRUE; /* Return value of this function */ - CAN_CMD_MSG_SENDSTS st_snd_msg; /* CAN command transmission result notification message structure */ - uint8_t uc_rid; /* Resources ID */ - uint8_t uc_cmd_id; /* CAN command ID */ - // int32_t ret_api; /* Return Values of System API Functions */ - char notify_name[MAX_NAME_SIZE_APP]; - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - HANDLE h_client; - - /* Data acquisition */ - CANCommandTxRsltDataGet(uc_can_rid, notify_name, &uc_rid, &uc_cmd_id); - - memset(reinterpret_cast<void *>(&st_snd_msg), (int32_t)0, (size_t)sizeof(st_snd_msg)); - /* Message structure initialization */ - /****** Creation of header section ******/ -// st_snd_msg.hdr.hdr.rid = uc_rid; /* Resources ID */ -// st_snd_msg.hdr.hdr.cid = (uint16_t)CID_CAN_CMD_TX_RESULT; /* Command ID */ -// st_snd_msg.hdr.hdr.msgbodysize = (size_t)sizeof(st_snd_msg.data); /* Message data size */ - - /****** Creation of data section ******/ - st_snd_msg.data.cmd_id = (uint32_t)uc_cmd_id; /* CAN command ID */ - st_snd_msg.data.status = uc_status; /* Transmission result status */ - - /****** Messaging ******/ - if (g_map_handler.count(notify_name) == 0) { - h_client = FrameworkunifiedMcOpenSender(h_app, notify_name); - if (h_client == NULL) { // LCOV_EXCL_BR_LINE 4: NSFW error case - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - ret = FALSE; // LCOV_EXCL_LINE 4: NSFW error case - return (ret); // LCOV_EXCL_LINE 4: NSFW error case - } - g_map_handler[notify_name].handle = h_client; // LCOV_EXCL_BR_LINE 200: unexpect branch - g_map_handler[notify_name].is_q_full = FALSE; // LCOV_EXCL_BR_LINE 200: unexpect branch - } else { - h_client = g_map_handler[notify_name].handle; // LCOV_EXCL_BR_LINE 200: unexpect branch + if (TRUE != CommGetAvailabilityCurrent(CAN_AVAILABILITY)) { + CANTxMsgErrorLog("CAN is not ready", __func__, 0, 0, h_app); + goto cleanup; } - e_status = FrameworkunifiedSendMsg(h_client, CID_CAN_CMD_TX_RESULT, sizeof(st_snd_msg), &st_snd_msg); - if (e_status != eFrameworkunifiedStatusOK) { // LCOV_EXCL_BR_LINE 4: NSFW error case - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - CANCommandTxRsltDelete(uc_can_rid); // LCOV_EXCL_LINE 4: NSFW error case - ret = FALSE; // LCOV_EXCL_LINE 4: NSFW error case - return (ret); // LCOV_EXCL_LINE 4: NSFW error case + + store = CanSendFind(&rcv_msg); + if (!store) { + CANTxMsgErrorLog("No initial value", __func__, + rcv_msg.id, sizeof(rcv_msg.dat), h_app); + goto cleanup; } - return (ret); -} -/******************************************************************************* - * MODULE : CANCommandTransmissionSndMsg - ******************************************************************************/ -/*!----------------------------------------------------------------------------- - * @~english - * @brief Transmission of CAN command - * - * @~english - * Transmission of CAN command (DISP Microcomputer -> SYS Microcomputer) - * - * @~english - * @note Details of process - * -# Creating of data division - * -# Message sending - * - * @~english - * @return Message transmission success/failure - * @retval <1> Message transmission success - * @retval <0> Message transmission failure - * - * @~english - * @param[in] <uc_opc> Operation code - * @param[in] <uc_can_rid> Resource ID - */ -BOOL CANCommandTransmissionSndMsg(uint8_t uc_opc, uint8_t uc_can_rid) { // LCOV_EXCL_START 8: dead code - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - BOOL ret = TRUE; /* Return value of this function */ -// T_ICR_CMD st_tx_can_data; /* Transmit data structure */ - -// (void)memset(reinterpret_cast<void *>(&st_tx_can_data), (int32_t)0, (size_t)sizeof(st_tx_can_data)); - /* Message structure initialization */ - /****** Creation of data section ******/ -// st_tx_can_data.cmd_data.phyadr_from = CAN_TX_PHYS_ADRS; /* Physical address */ -// st_tx_can_data.cmd_data.service_type = CAN_TX_COMM_KIND; /* Communication type 0x00: Individual */ -// st_tx_can_data.cmd_data.lgadr_from = CAN_TX_FROM_ADRS; /* Source Logical Address */ -// st_tx_can_data.cmd_data.lgadr_to = CAN_TX_TO_ADRS; /* Destination logical address */ -// st_tx_can_data.cmd_data.opc = uc_opc; /* Operation code */ -// st_tx_can_data.cmd_data.d_length = (uint16_t)CAN_CMDSND_DATA_SIZE; /* Data length (data section only) */ - - /****** Messaging ******/ - return (ret); -} -// LCOV_EXCL_STOP - -/******************************************************************************* - * MODULE : CANCommandFuelCalcRstReqSndMsg - * ABSTRACT : CAN section flame reset request reception message transmission processing - * FUNCTION : Send CAN interval flame reset request reception message (CAN thread-> user) - * ARGUMENT : notifyId : Message Destination ID - * NOTE : - * RETURN : TRUE : Message transmission success - * FALSE : Message transmission failure - ******************************************************************************/ -BOOL CANCommandFuelCalcRstReqSndMsg(HANDLE h_app, PCSTR notify_name) { - BOOL ret = TRUE; /* Return value of this function */ - CAN_MSG_CANCMD st_snd_msg; /* CAN Command Delivery Notification Message Structure */ - // int32_t ret_api = RET_NORMAL; /* Return Values of System API Functions */ - EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; - HANDLE h_client; - - (void)memset(reinterpret_cast<void *>(&st_snd_msg), (int32_t)0, (size_t)sizeof(st_snd_msg)); - /* Message structure initialization */ - /****** Creation of header section ******/ -// st_snd_msg.hdr.hdr.rid = 0; /* Resource ID (not used) */ -// st_snd_msg.hdr.hdr.cid = (uint16_t)CID_CAN_CMD_DELIVERY; /* Command ID */ -// st_snd_msg.hdr.hdr.msgbodysize = CAN_TX_CMD_DELIVERY_SIZE + CAN_TX_CMD_FUELCALC_RST_SIZE; /* Message data size */ - - /****** Creation of data section ******/ - st_snd_msg.data.cmd_id = CAN_CMDID_FUELCALC_RST_REQ_RX; /* CAN command ID */ - - if (g_map_handler.count(notify_name) == 0) { - h_client = FrameworkunifiedMcOpenSender(h_app, notify_name); - if (h_client == NULL) { // LCOV_EXCL_BR_LINE 4: NSFW error case - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - ret = FALSE; // LCOV_EXCL_LINE 4: NSFW error case - return (ret); // LCOV_EXCL_LINE 4: NSFW error case - } - g_map_handler[notify_name].handle = h_client; // LCOV_EXCL_BR_LINE 11:except,C++ STL - g_map_handler[notify_name].is_q_full = FALSE; // LCOV_EXCL_BR_LINE 11:except,C++ STL - } else { - h_client = g_map_handler[notify_name].handle; // LCOV_EXCL_BR_LINE 11:except,C++ STL + store_p = store->dat.dat; + data_p = rcv_msg.dat.dat; + mask_p = rcv_msg.mask.dat; + for (i = 0; i < store->dlc; i++) { + *store_p &= (uint8_t)(~(*mask_p)); + *store_p |= ((*mask_p) & (*data_p)); + ++store_p; + ++data_p; + ++mask_p; } - e_status = FrameworkunifiedSendMsg(h_client, CID_CAN_CMD_DELIVERY, sizeof(st_snd_msg), &st_snd_msg); - if (e_status != eFrameworkunifiedStatusOK) { // LCOV_EXCL_BR_LINE 4: NSFW error case - AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert - ret = FALSE; // LCOV_EXCL_LINE 4: NSFW error case - return (ret); // LCOV_EXCL_LINE 4: NSFW error case + + snd_msg.can_id = rcv_msg.id; + snd_msg.dlc = store->dlc; + snd_msg.rid = CAN_RID_NOTUSE_CODE; + memcpy(snd_msg.data, store->dat.dat, snd_msg.dlc); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, + "@@@ Call CanSend for can_hal : " + "can_id=%x dlc=%d rid=%x", snd_msg.can_id, snd_msg.dlc, snd_msg.rid); + FRAMEWORKUNIFIEDLOG(ZONE_DEBUG, __func__, "msg_data=%s", + MessageDataOutputLog(snd_msg.data, snd_msg.dlc).c_str()); + + if (CANHAL_RET_NORMAL != CanSend(h_app, &snd_msg, CAN_HAL_TYPE_CAN)) { + CANTxMsgErrorLog("CAN CanSend failed", __func__, snd_msg.can_id, + (uint16_t)snd_msg.dlc, h_app); + goto cleanup; } - return (ret); + // echoback + e_status = CANDeliverySndMsg(h_app, snd_msg.can_id, 0, (uint8_t)snd_msg.dlc, + (const uint8_t *)snd_msg.data, + CID_CAN_DATA_DELIVERY, CANIF_ECHOBACK); +cleanup: + return e_status; } -/******************************************************************************* - * MODULE : CANCommandidOpcToUserCvt - * ABSTRACT : CAN Command ID Conversion Processing 1 - * FUNCTION : Convert the opcode to the corresponding CAN command ID - * ARGUMENT : uc_opc : Opcode - * puc_cmd_id : CAN command ID return pointer - * NOTE : - * RETURN : TRUE : Predefined opcodes - * FALSE : Undefined opcode - ******************************************************************************/ -BOOL CANCommandidOpcToUserCvt(uint8_t uc_opc, uint8_t *puc_cmd_id) { - BOOL ret = TRUE; /* Return value of this function */ - - switch (uc_opc) { - case CAN_OPC_COMMAND_STARTUP_FIN_RESP_RX: /* CAN startup completion notice received */ - *puc_cmd_id = CAN_CMDID_STARTUP_FIN_RESP_RX; - break; - case CAN_OPC_COMMAND_MRST_INFO_RESP_RX: /* CAN Master Reset Information Notification Reception */ - *puc_cmd_id = CAN_CMDID_MRST_INFO_RESP_RX; - break; - case CAN_OPC_COMMAND_VERSION_RESP_RX: /* CAN Version Response Reception */ - *puc_cmd_id = CAN_CMDID_VERSION_RESP_RX; - break; - case CAN_OPC_COMMAND_CONNECTION_NODE_RESP_RX: /* Receive CAN Connection Node Notification Response */ - *puc_cmd_id = CAN_CMDID_CONNECTION_NODE_RESP_RX; - break; - case CAN_OPC_COMMAND_FUELCALC_RST_REQ_RX: /* RECEIVE REQUEST FREE OF CAN SECTION */ - *puc_cmd_id = CAN_CMDID_FUELCALC_RST_REQ_RX; - break; - default: - ret = FALSE; /* Undefined opcode */ - break; +EFrameworkunifiedStatus CANTxMsg(HANDLE h_app) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __func__, "@@@ Start communication CanSend"); + + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusFail; + CAN_TRANSMISSION_START_MSG_DAT rcv_msg; + CanMessage snd_msg; + memset(&rcv_msg, 0, sizeof(rcv_msg)); + memset(&snd_msg, 0, sizeof(snd_msg)); + + e_status = FrameworkunifiedGetMsgDataOfSize(h_app, &rcv_msg, sizeof(rcv_msg), eSMRRelease); + if (e_status != eFrameworkunifiedStatusOK) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedGetMsgDataOfSize Error(%d)", e_status); + if (e_status == eFrameworkunifiedStatusInvldBufSize) + FrameworkunifiedClearMsgData(h_app); + goto cleanup; } - return (ret); -} + e_status = eFrameworkunifiedStatusFail; -/******************************************************************************* - * MODULE : CANCommandidUserToOpcCvt - * ABSTRACT : CAN command ID conversion process 2 - * FUNCTION : Convert the CAN command ID to the corresponding opcode - * ARGUMENT : uc_cmd_id : CAN command ID - * puc_opc : Opcode return pointer - * NOTE : - * RETURN : TRUE : Predefined ID - * FALSE : Undefined ID - ******************************************************************************/ -BOOL CANCommandidUserToOpcCvt(uint8_t uc_cmd_id, uint8_t *puc_opc) { - BOOL ret = TRUE; /* Return value of this function */ - - switch (uc_cmd_id) { - case CAN_CMDID_STARTUP_FIN_REQ_TX: /* CAN start completion notification request transmission */ - *puc_opc = CAN_OPC_COMMAND_STARTUP_FIN_REQ_TX; - break; - case CAN_CMDID_MRST_INFO_REQ_TX: /* CAN master reset information notification request transmission */ - *puc_opc = CAN_OPC_COMMAND_MRST_INFO_REQ_TX; - break; - case CAN_CMDID_VERSION_REQ_TX: /* CAN Version Request Send */ - *puc_opc = CAN_OPC_COMMAND_VERSION_REQ_TX; - break; - case CAN_CMDID_CONNECTION_NODE_REQ_TX: /* CAN connection node notification request transmission */ - *puc_opc = CAN_OPC_COMMAND_CONNECTION_NODE_REQ_TX; - break; - case CAN_CMDID_FUELCALC_REQ_TX: /* CAN section flame reset response transmission */ - *puc_opc = CAN_OPC_COMMAND_FUELCALC_REQ_TX; - break; - default: - ret = FALSE; /* Undefined ID */ - break; + if (TRUE != CommGetAvailabilityCurrent(CAN_AVAILABILITY)) { + CANTxMsgErrorLog("CAN is not ready", __func__, 0, 0, h_app); + goto cleanup; } - return (ret); + snd_msg.can_id = rcv_msg.stCandata.can_id; + snd_msg.dlc = rcv_msg.stCandata.dlc; + snd_msg.rid = rcv_msg.ucRid; + memcpy(snd_msg.data, rcv_msg.stCandata.data, snd_msg.dlc); + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "@@@ Call CanSend for can_hal : " + "can_id=%x dlc=%d rid=%x", snd_msg.can_id, snd_msg.dlc, snd_msg.rid); + FRAMEWORKUNIFIEDLOG(ZONE_DEBUG, __func__, "msg_data=%s", + MessageDataOutputLog(snd_msg.data, snd_msg.dlc).c_str()); + + if (CANHAL_RET_NORMAL != CanSend(h_app, &snd_msg, CAN_HAL_TYPE_CAN)) { + CANTxMsgErrorLog("CAN CanSend failed", __func__, snd_msg.can_id, + (uint16_t)snd_msg.dlc, h_app); + goto cleanup; + } + + // echoback + e_status = CANDeliverySndMsg(h_app, snd_msg.can_id, 0, (uint8_t)snd_msg.dlc, + (const uint8_t *)snd_msg.data, + CID_CAN_DATA_DELIVERY, CANIF_ECHOBACK); + if (rcv_msg.ucRid == (uint8_t)CAN_RID_NOTUSE_CODE) + goto cleanup; + + if (0 < g_m_send_sts.count(snd_msg.can_id)) { + if (g_m_send_sts[snd_msg.can_id].notify_name[0] != 0x00) { + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, + "Not yet deliver SendSts but updated(SendID=%x, CAN ID=%x, Nane=%s)", + g_m_send_sts[snd_msg.can_id].rid, snd_msg.can_id, + g_m_send_sts[snd_msg.can_id].notify_name); + } + } + + g_m_send_sts[snd_msg.can_id].rid = rcv_msg.ucRid; + memcpy(g_m_send_sts[snd_msg.can_id].notify_name, + rcv_msg.notifyName, + sizeof(g_m_send_sts[snd_msg.can_id].notify_name)); +cleanup: + return e_status; } -/*!----------------------------------------------------------------------------- - * @~english - * @brief Transmission CAN Command - * - * @~english - * @return Return value - * @retval <TRUE> Transmission success - * @retval <FALSE> Transmission failed - * - * @~english - * @param[in] <id> CAN ID - * @param[in] <dlc> DLC - * @param[in] <pst_data> CAN Data structure - */ -BOOL CANTransStartTxMsgCore(HANDLE h_app, CANID id, uint8_t dlc, CAN_DATA_BIT *pst_data) { - BOOL b_ret = FALSE; -// CanMessage st_can_data; -// -// if (pst_data != NULL) { // LCOV_EXCL_BR_LINE 200: puc_data is a pointer of global variable -// st_can_data.can_id = id; -// st_can_data.rid = CAN_RID_NOTUSE_CODE; -// st_can_data.dlc = dlc; -// memcpy(st_can_data.data, pst_data->dat, dlc); - -// if (CanSend(&st_can_data, CAN_HAL_TYPE_CAN) != CANHAL_RET_NORMAL) { -// b_ret = FALSE; -// } else { -// b_ret = TRUE; -// } -// } - - return b_ret; -} // LCOV_EXCL_BR_LINE 10: end of line unknown branch +EFrameworkunifiedStatus CANSndStsProcess(HANDLE h_app, CanSendResult *rcv_msg, + PS_CommunicationProtocol cid) { + EFrameworkunifiedStatus e_status = eFrameworkunifiedStatusOK; + CAN_MSG_SENDSTS snd_msg; + CANID can_id = rcv_msg->can_id; + HANDLE sender = NULL; + memset(&snd_msg, 0, sizeof(snd_msg)); + + if (0 == g_m_send_sts.count(can_id)) + goto cleanup; + + if (0x00 == (g_m_send_sts[can_id].notify_name[0])) + goto cleanup; + + if (rcv_msg->rid != g_m_send_sts[can_id].rid) + goto cleanup; + + snd_msg.hdr.hdr.cid = (uint16_t)cid; + snd_msg.hdr.hdr.msgbodysize = (uint16_t)(sizeof(snd_msg.data)); + snd_msg.hdr.hdr.rid = rcv_msg->rid; + snd_msg.data.ulCanid = can_id; + snd_msg.data.ucStatus = + (CAN_SEND_RESULT_SUCCESS == rcv_msg->result) ? CAN_SUCCESS : CAN_RETRYOUT; + + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __func__, "cid=%x msgbodysize=%d rid=%x can_id=%x ucStatus=%x", + snd_msg.hdr.hdr.cid, snd_msg.hdr.hdr.msgbodysize, snd_msg.hdr.hdr.rid, + snd_msg.data.ulCanid, snd_msg.data.ucStatus); + + sender = CommonFindSender(h_app, g_m_send_sts[can_id].notify_name); + if (!sender) { + CANTxMsgErrorLog("Could not open sender.", __func__, can_id, + sizeof(snd_msg), h_app); + goto cleanup; + } + + e_status = FrameworkunifiedSendMsg(sender, cid, sizeof(snd_msg), &snd_msg); + if (eFrameworkunifiedStatusOK != e_status) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __func__, "FrameworkunifiedSendMsg Error(e_status:%d to:%s)", + e_status, g_m_send_sts[can_id].notify_name); + g_m_send_sts[can_id].notify_name[0] = 0x00; + g_m_send_sts[can_id].rid = 0x00; + goto cleanup; + } + g_m_send_sts[can_id].notify_name[0] = 0x00; + g_m_send_sts[can_id].rid = 0x00; + + e_status = eFrameworkunifiedStatusOK; +cleanup: + return e_status; +} |