X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=low-can-binding%2Fbinding%2Flow-can-subscription.cpp;h=99f209beeacdde75159b90f4a895f3ad8acb59be;hb=8c1df02d734676f79807e3a4682fb96ea88c5cb5;hp=6d02b101177440fcd4fec0832bac9e9834181071;hpb=b8e8186c95f50e76aa4d88c3c751053568ab7cdf;p=apps%2Fagl-service-can-low-level.git diff --git a/low-can-binding/binding/low-can-subscription.cpp b/low-can-binding/binding/low-can-subscription.cpp index 6d02b101..99f209be 100644 --- a/low-can-binding/binding/low-can-subscription.cpp +++ b/low-can-binding/binding/low-can-subscription.cpp @@ -102,12 +102,9 @@ int low_can_subscription_t::set_event() int low_can_subscription_t::subscribe(afb_req_t request) { if(! afb_event_is_valid(event_)) - { if(set_event() < 0) - { return -1; - } - } + return afb_req_subscribe(request, event_); } @@ -124,22 +121,45 @@ int low_can_subscription_t::unsubscribe(afb_req_t request) return afb_req_unsubscribe(request, event_); } +/** + * @brief Getter of index of subscription + * + * @return int Index + */ int low_can_subscription_t::get_index() const { return index_; } +/** + * @brief Getter of signal of subscription + * + * @return const std::shared_ptr A shared pointer of the signal + */ const std::shared_ptr low_can_subscription_t::get_signal() const { return signal_; } +/** + * @brief Check if the signal and event are the same that the subscription + * + * @param signal the signal compared + * @param event_filter the event_filter compared + * @return true if they are equal + * @return false if they are not equal + */ bool low_can_subscription_t::is_signal_subscription_corresponding(const std::shared_ptr signal, const struct event_filter_t& event_filter) const { return signal_ == signal && event_filter_ == event_filter; } -const std::vector > low_can_subscription_t::get_diagnostic_message() const +/** + * @brief Getter for diagnostic messages of subscription + * + * @return const vector_ptr_diag_msg_t Vector of pointer of diagnostic message + */ +const vect_ptr_diag_msg_t low_can_subscription_t::get_diagnostic_message() const { return diagnostic_message_; } @@ -152,12 +172,9 @@ const std::vector > low_can_subscription_t const std::shared_ptr low_can_subscription_t::get_diagnostic_message(uint32_t pid) const { for(const auto& diag: diagnostic_message_) - { if(diag->get_pid() == pid) - { return diag; - } - } + return nullptr; } @@ -167,12 +184,9 @@ const std::shared_ptr low_can_subscription_t::get_diagnost const std::shared_ptr low_can_subscription_t::get_diagnostic_message(const std::string& name) const { for(const auto& diag: diagnostic_message_) - { if(diag->get_name() == name) - { return diag; - } - } + return nullptr; } @@ -201,71 +215,155 @@ const std::string low_can_subscription_t::get_name(uint32_t pid) const return ""; } +/** + * @brief Getter of the frequency of the event_filter + * + * @return float The frequency + */ float low_can_subscription_t::get_frequency() const { return event_filter_.frequency; } +/** + * @brief Getter of the min of the event_filter + * + * @return float The min value filtered + */ float low_can_subscription_t::get_min() const { return event_filter_.min; } +/** + * @brief Getter of the max of the event_filter + * + * @return float The max value filtered + */ float low_can_subscription_t::get_max() const { return event_filter_.max; } +bool low_can_subscription_t::get_promisc() const +{ + return event_filter_.promisc; +} + +/** + * @brief Getter of the rx_id of the event_filter + * + * @return canid_t The rx_id value + */ canid_t low_can_subscription_t::get_rx_id() const { return event_filter_.rx_id; } +/** + * @brief Getter of the tx_id of the event_filter + * + * @return canid_t The tx_id value + */ canid_t low_can_subscription_t::get_tx_id() const { return event_filter_.tx_id; } +/** + * @brief Getter of the socket of the subscription + * + * @return std::shared_ptr Pointer of the socket object + */ std::shared_ptr low_can_subscription_t::get_socket() { return socket_; } +std::shared_ptr low_can_subscription_t::get_message_definition() +{ + return message_; +} + +/** + * @brief Setter for the frequency of the event_filter + * + * @param freq The new frequency + */ void low_can_subscription_t::set_frequency(float freq) { event_filter_.frequency = freq; } +/** + * @brief Setter for the min of the event_filter + * + * @param min The new min + */ void low_can_subscription_t::set_min(float min) { event_filter_.min = min; } +/** + * @brief Setter for the max of the event_filter + * + * @param max The new max + */ void low_can_subscription_t::set_max(float max) { event_filter_.max = max; } +void low_can_subscription_t::set_promisc(bool promisc) +{ + event_filter_.promisc = promisc; +} + +/** + * @brief Setter for the rx_id of the event_filter + * + * @param rx_id The new rx_id + */ void low_can_subscription_t::set_rx_id(canid_t rx_id) { event_filter_.rx_id = rx_id; } +/** + * @brief Setter for the tx_id of the event_filter + * + * @param tx_id The new tx_id + */ void low_can_subscription_t::set_tx_id(canid_t tx_id) { event_filter_.tx_id = tx_id; } +/** + * @brief Setter for the index of the subscription + * + * @param index The new index + */ void low_can_subscription_t::set_index(int index) { index_ = index; } +/** + * @brief Setter for the signal of the subscription + * + * @param signal The new signal + */ void low_can_subscription_t::set_signal(std::shared_ptr signal) { signal_ = signal; } +void low_can_subscription_t::set_message_definition(std::shared_ptr message) +{ + message_ = message; +} /// @brief Based upon which object is a subscribed CAN signal or diagnostic message /// it will open the socket with the required CAN bus device name. @@ -276,83 +374,75 @@ int low_can_subscription_t::open_socket(low_can_subscription_t &subscription, co int ret = -1; if(! subscription.socket_) { - if(flags&BCM_PROTOCOL) + if(flags & CAN_PROTOCOL) { - if( subscription.signal_ != nullptr) - { - subscription.socket_ = std::make_shared(); - ret = subscription.socket_->open(subscription.signal_->get_message()->get_bus_device_name()); - } - else if (! subscription.diagnostic_message_ .empty()) - { - subscription.socket_ = std::make_shared(); - ret = subscription.socket_->open(application_t::instance().get_diagnostic_manager().get_bus_device_name()); - } - else if ( !bus_name.empty()) - { - subscription.socket_ = std::make_shared(); - ret = subscription.socket_->open(bus_name); - } + subscription.socket_ = std::make_shared(); + if( subscription.signal_ ) + ret = subscription.socket_->open(subscription.signal_->get_message()->get_bus_device_name()); + else if(! subscription.diagnostic_message_.empty()) + ret = subscription.socket_->open(application_t::instance().get_diagnostic_manager().get_bus_device_name()); + else if(! bus_name.empty()) + ret = subscription.socket_->open(bus_name); + subscription.index_ = (int)subscription.socket_->socket(); } #ifdef USE_FEATURE_ISOTP - else if(flags&ISOTP_PROTOCOL) + else if(flags & ISOTP_PROTOCOL) { - if(subscription.signal_ != nullptr) + std::shared_ptr socket = std::make_shared(); + if(subscription.signal_ ) { canid_t rx = NO_CAN_ID; canid_t tx = NO_CAN_ID; - if(flags&ISOTP_SEND) + if(flags & ISOTP_SEND) { rx = subscription.get_rx_id(); tx = subscription.signal_->get_message()->get_id(); } - else if(flags&ISOTP_RECEIVE) + else if(flags & ISOTP_RECEIVE) { rx = subscription.signal_->get_message()->get_id(); tx = subscription.get_tx_id(); } - std::shared_ptr socket = std::make_shared(); - ret = socket->open(subscription.signal_->get_message()->get_bus_device_name(),rx,tx); + ret = socket->open(subscription.signal_->get_message()->get_bus_device_name(), rx, tx); subscription.socket_ = socket; } - else if(!bus_name.empty()) + else if(! bus_name.empty()) { - std::shared_ptr socket = std::make_shared(); - ret = socket->open(bus_name, subscription.get_rx_id(),subscription.get_tx_id()); + ret = socket->open(bus_name, subscription.get_rx_id(), subscription.get_tx_id()); subscription.socket_ = socket; } subscription.index_ = (int)subscription.socket_->socket(); } #endif #ifdef USE_FEATURE_J1939 - else if(flags&J1939_ADDR_CLAIM_PROTOCOL) + else if(flags & J1939_ADDR_CLAIM_PROTOCOL) { pgn_t pgn = J1939_NO_PGN; + std::shared_ptr socket = std::make_shared(); if(!bus_name.empty()) - { - std::shared_ptr socket = std::make_shared(); ret = socket->open(bus_name, pgn); - subscription.socket_ = socket; - } + subscription.socket_ = socket; subscription.index_ = (int)subscription.socket_->socket(); } - else if(flags&J1939_PROTOCOL) + else if(flags & J1939_PROTOCOL) { pgn_t pgn = J1939_NO_PGN; - if(subscription.signal_ != nullptr) + std::shared_ptr socket = std::make_shared(); + if(subscription.signal_) { pgn = subscription.signal_->get_message()->get_id(); - std::shared_ptr socket = std::make_shared(); ret = socket->open(subscription.signal_->get_message()->get_bus_device_name(), pgn); - subscription.socket_ = socket; } else if(!bus_name.empty()) { - std::shared_ptr socket = std::make_shared(); ret = socket->open(bus_name, pgn); - subscription.socket_ = socket; } + + if(ret) + socket->define_opt(!j1939_pgn_is_pdu1(pgn),subscription.event_filter_.promisc); + + subscription.socket_ = socket; subscription.index_ = (int)subscription.socket_->socket(); } #endif @@ -415,34 +505,46 @@ void low_can_subscription_t::add_one_bcm_frame(struct canfd_frame& cfd, struct b void low_can_subscription_t::remove_last_bcm_frame(struct bcm_msg& bcm_msg) { struct canfd_frame cf; - memset(&cf,0,sizeof(cf)); + memset(&cf, 0, sizeof(cf)); bcm_msg.fd_frames[bcm_msg.msg_head.nframes] = cf; bcm_msg.msg_head.nframes--; } #ifdef USE_FEATURE_J1939 +/** + * @brief Create a j1939 socket to read message + * + * @param subscription The subscription + * @param sig The signal subscribed + * @return int 0 if ok else -1 + */ int low_can_subscription_t::create_rx_filter_j1939(low_can_subscription_t &subscription, std::shared_ptr sig) { subscription.signal_= sig; // Make sure that socket is opened. - if(open_socket(subscription,"",J1939_PROTOCOL) < 0) - { + if(open_socket(subscription, "", J1939_PROTOCOL) < 0) return -1; - } + return 0; } #endif +/** + * @brief Create an iso tp socket to read message + * + * @param subscription The subscription + * @param sig The signal subscribed + * @return int 0 if ok else -1 + */ int low_can_subscription_t::create_rx_filter_isotp(low_can_subscription_t &subscription, std::shared_ptr sig) { subscription.signal_= sig; // Make sure that socket is opened. - if(open_socket(subscription,"",ISOTP_PROTOCOL|ISOTP_RECEIVE) < 0) - { + if(open_socket(subscription, "", ISOTP_PROTOCOL|ISOTP_RECEIVE) < 0) return -1; - } + return 0; } @@ -453,55 +555,42 @@ int low_can_subscription_t::create_rx_filter_isotp(low_can_subscription_t &subsc int low_can_subscription_t::create_rx_filter_can(low_can_subscription_t &subscription, std::shared_ptr sig) { uint32_t flags_bcm; - float val; struct timeval freq, timeout = {0, 0}; - struct canfd_frame cfd; subscription.signal_= sig; bool is_fd = sig->get_message()->is_fd(); + uint32_t max_dlen = 0; - std::vector data; uint32_t length_msg = sig->get_message()->get_length(); + std::vector data(length_msg); + can_message_t cm; - if(length_msg == 0) + if(! length_msg) { - AFB_ERROR("Error in the length of message with id %d",sig->get_message()->get_id()); + AFB_ERROR("Error in the length of message with id %d", sig->get_message()->get_id()); return -1; } - for(int i = 0; iget_message()->get_id(), - length_msg, - false, - sig->get_message()->get_flags(), - data, - 0); + max_dlen = CANFD_MAX_DLEN; } else { flags_bcm = SETTIMER|RX_NO_AUTOTIMER; - cfd.len = CAN_MAX_DLEN; - cm = can_message_t( CAN_MAX_DLEN, - sig->get_message()->get_id(), - length_msg, - false, - sig->get_message()->get_flags(), - data, - 0); + max_dlen = CAN_MAX_DLEN; } + cm = can_message_t( max_dlen, + sig->get_message()->get_id(), + length_msg, + false, + sig->get_message()->get_flags(), + data, + 0); + frequency_clock_t f = subscription.event_filter_.frequency == 0 ? subscription.signal_->get_frequency() : frequency_clock_t(subscription.event_filter_.frequency); freq = f.get_timeval_from_period(); @@ -516,12 +605,7 @@ int low_can_subscription_t::create_rx_filter_can(low_can_subscription_t &subscri } else if(cfd_vect.size() == 1) { - canfd_frame cf = cfd_vect[0]; - for(int i=0;i msg) +{ + std::shared_ptr signal_message = + std::make_shared(signal_t{msg->get_name(), + 0, + msg->get_length() * 8, + 1.00000f, + 0.00000f, + 0, + 0, + frequency_clock_t(0.00000f), + true, + false, + {}, + true, + nullptr, + nullptr, + false, + std::make_pair(false, 0), + static_cast(0), + -1, + ""}); + + signal_message->set_parent(msg); + return create_rx_filter(signal_message); +} + + +/** + * @brief Create the good socket to read message + * depending on the signal + * + * @param sig The signal subscribed + * @return 0 if ok else -1 + */ int low_can_subscription_t::create_rx_filter(std::shared_ptr sig) { if(!sig->get_message()->is_isotp() && !sig->get_message()->is_j1939()) - { return low_can_subscription_t::create_rx_filter_can(*this, sig); - } #ifdef USE_FEATURE_ISOTP else if(sig->get_message()->is_isotp()) - { - return low_can_subscription_t::create_rx_filter_isotp(*this,sig); - } + return low_can_subscription_t::create_rx_filter_isotp(*this, sig); #endif #ifdef USE_FEATURE_J1939 else if(sig->get_message()->is_j1939()) - { return low_can_subscription_t::create_rx_filter_j1939(*this, sig); - } #endif - else - { - AFB_ERROR("Signal can't be j1939 and isotp"); - return -1; - } + AFB_ERROR("Signal can't be created (check config)"); + return -1; } @@ -567,10 +678,9 @@ int low_can_subscription_t::create_rx_filter(std::shared_ptrwrite_message(msg); - if(! subscription.socket_) - return -1; + if(! subscription.socket_) + return -1; } else { for(uint8_t i = 0; i < 8; i++) { - bcm_msg.msg_head.can_id = OBD2_FUNCTIONAL_RESPONSE_START + i; + bcm_msg.msg_head.can_id = OBD2_FUNCTIONAL_RESPONSE_START + i; msg.set_bcm_msg(bcm_msg); subscription.socket_->write_message(msg); if(! subscription.socket_) @@ -623,20 +731,16 @@ int low_can_subscription_t::tx_send(low_can_subscription_t &subscription, messag { can_message_t *cm = static_cast(message); - struct bcm_msg bcm_msg = subscription.make_bcm_head(TX_SEND, cm->get_id(),cm->get_flags()|TX_CP_CAN_ID); // TX_CP_CAN_ID -> copy in cfd the id of bcm + struct bcm_msg bcm_msg = subscription.make_bcm_head(TX_SEND, cm->get_id(), cm->get_flags()|TX_CP_CAN_ID); // TX_CP_CAN_ID -> copy in cfd the id of bcm cm->set_bcm_msg(bcm_msg); std::vector cfd_vect = cm->convert_to_canfd_frame_vector(); - if(subscription.open_socket(subscription, bus_name, BCM_PROTOCOL) < 0) - { - return -1; - } + if(subscription.open_socket(subscription, bus_name, CAN_PROTOCOL) < 0) + return -1; struct bcm_msg &bcm_cm = cm->get_bcm_msg(); - - if(cfd_vect.size() > 1) { AFB_ERROR("Multi frame BCM not implemented"); @@ -648,7 +752,7 @@ int low_can_subscription_t::tx_send(low_can_subscription_t &subscription, messag if(subscription.socket_->write_message(*cm) < 0) { - AFB_ERROR("Error write message id : %d",cfd_vect[0].can_id); + AFB_ERROR("Error write message id : %d", cfd_vect[0].can_id); return -1; } } @@ -659,26 +763,30 @@ int low_can_subscription_t::tx_send(low_can_subscription_t &subscription, messag } if(! subscription.socket_.get()) - { - return -1; - } + return -1; return 0; } #ifdef USE_FEATURE_J1939 +/** + * @brief Allows to open socket j1939 and send j1939 messsage + * + * @param subscription The subscription + * @param message The j1939 message to send + * @param bus_name The bus name where to send message + * @return int 0 if ok else -1 + */ int low_can_subscription_t::j1939_send(low_can_subscription_t &subscription, message_t *message, const std::string& bus_name) { //struct bcm_msg bcm_msg = subscription.make_bcm_head(TX_SEND, cfd.can_id); //subscription.add_one_bcm_frame(cfd, bcm_msg); if(subscription.open_socket(subscription, bus_name, J1939_PROTOCOL) < 0) - { return -1; - } j1939_message_t *jm = static_cast(message); - jm->set_sockname(jm->get_pgn(),J1939_NO_NAME,J1939_NO_ADDR); + jm->set_sockname(jm->get_pgn(), J1939_NO_NAME, J1939_NO_ADDR); if(subscription.socket_->write_message(*jm) < 0) { AFB_ERROR("Error write j1939 message"); @@ -690,15 +798,21 @@ int low_can_subscription_t::j1939_send(low_can_subscription_t &subscription, mes #endif +/** + * @brief Allows to open socket isotp and send can messsage + * + * @param subscription The subscription + * @param message The can message to send + * @param bus_name The bus name where to send message + * @return int 0 if ok else -1 + */ int low_can_subscription_t::isotp_send(low_can_subscription_t &subscription, message_t *message, const std::string& bus_name) { //struct bcm_msg bcm_msg = subscription.make_bcm_head(TX_SEND, cfd.can_id); //subscription.add_one_bcm_frame(cfd, bcm_msg); if(subscription.open_socket(subscription, bus_name, ISOTP_PROTOCOL|ISOTP_SEND) < 0) - { return -1; - } can_message_t *cm = static_cast(message); if(subscription.socket_->write_message(*cm) < 0) @@ -708,4 +822,4 @@ int low_can_subscription_t::isotp_send(low_can_subscription_t &subscription, mes } return 0; -} \ No newline at end of file +}