X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=CAN-binder%2Flow-can-binding%2Fbinding%2Flow-can-cb.cpp;h=d4cc5a1155ffb22ab41b13279ea52e1bbf92eac3;hb=64f08bebe63e2b58102044ac02deac53bbec2d5f;hp=2e3a10fbb53717fc540c97170a993780dd32988f;hpb=84f7395a94048df10fe88a41d6a43fdbc8f5785c;p=apps%2Fagl-service-can-low-level.git diff --git a/CAN-binder/low-can-binding/binding/low-can-cb.cpp b/CAN-binder/low-can-binding/binding/low-can-cb.cpp index 2e3a10fb..d4cc5a11 100644 --- a/CAN-binder/low-can-binding/binding/low-can-cb.cpp +++ b/CAN-binder/low-can-binding/binding/low-can-cb.cpp @@ -19,6 +19,7 @@ #include "low-can-hat.hpp" #include +#include #include #include #include @@ -58,6 +59,12 @@ low_can_subscription_t::low_can_subscription_t(struct event_filter_t event_filte : event_filter_{event_filter} {} +low_can_subscription_t::low_can_subscription_t(struct event_filter_t event_filter, std::shared_ptr diagnostic_message) + : diagnostic_message_{diagnostic_message}, event_filter_{event_filter} +{ + index_ = diagnostic_message->get_pid(); +} + low_can_subscription_t::low_can_subscription_t( low_can_subscription_t&& s) : index_{s.index_}, event_filter_{s.event_filter_}, @@ -72,7 +79,12 @@ low_can_subscription_t::low_can_subscription_t( low_can_subscription_t&& s) low_can_subscription_t::operator bool() const { - return socket_.socket() != INVALID_SOCKET; + return ((can_signal_ != nullptr || diagnostic_message_ != nullptr) && afb_event_is_valid(event_)); +} + +struct afb_event& low_can_subscription_t::get_event() +{ + return event_; } int low_can_subscription_t::get_index() const @@ -85,9 +97,19 @@ const std::shared_ptr low_can_subscription_t::get_can_signal() con return can_signal_; } -const std::string low_can_subscription_t::get_sig_name() const +const std::shared_ptr low_can_subscription_t::get_diagnostic_message() const { - return can_signal_->get_name(); + return diagnostic_message_; +} + +const std::string low_can_subscription_t::get_name() const +{ + if (can_signal_ != nullptr) + return can_signal_->get_name(); + if (diagnostic_message_ != nullptr) + return diagnostic_message_->get_name() ; + + return ""; } float low_can_subscription_t::get_frequency() const @@ -110,6 +132,11 @@ utils::socketcan_bcm_t& low_can_subscription_t::get_socket() return socket_; } +void low_can_subscription_t::set_event(struct afb_event event) +{ + event_ = event; +} + void low_can_subscription_t::set_frequency(float freq) { event_filter_.frequency = freq; @@ -139,6 +166,9 @@ int low_can_subscription_t::create_rx_filter(std::shared_ptr sig) /// @return 0 if ok else -1 int low_can_subscription_t::create_rx_filter() { + if (can_signal_ == nullptr) + {return -1;} + // Make sure that socket has been opened. if(! socket_) { @@ -154,7 +184,7 @@ int low_can_subscription_t::create_rx_filter() float val = (float)(1 << can_signal_->get_bit_size()) - 1; struct timeval freq; - frequency_clock_t f(event_filter_.frequency); + frequency_clock_t f = std::isnan(event_filter_.frequency) ? can_signal_->get_frequency() : frequency_clock_t(event_filter_.frequency); freq = f.get_timeval_from_period(); bcm_msg.msg_head.opcode = RX_SETUP; @@ -233,7 +263,7 @@ int read_message(sd_event_source *s, int fd, uint32_t revents, void *userdata) { can_subscription->get_socket().close(); can_subscription->create_rx_filter(); - NOTICE(binder_interface, "%s: Recreated RX_SETUP BCM job for can_subscription: %s", __FUNCTION__, can_subscription->get_sig_name().c_str()); + NOTICE(binder_interface, "%s: Recreated RX_SETUP BCM job for can_subscription: %s", __FUNCTION__, can_subscription->get_name().c_str()); } else { @@ -253,25 +283,25 @@ int read_message(sd_event_source *s, int fd, uint32_t revents, void *userdata) /// ///*******************************************************************************/ -static int make_subscription_unsubscription(struct afb_req request, std::shared_ptr& can_subscription, std::map, struct afb_event> >& s, bool subscribe) +static int make_subscription_unsubscription(struct afb_req request, std::shared_ptr& can_subscription, std::map >& s, bool subscribe) { /* Make the subscription or unsubscription to the event */ - if (((subscribe ? afb_req_subscribe : afb_req_unsubscribe)(request, s[can_subscription->get_index()].second)) < 0) + if (((subscribe ? afb_req_subscribe : afb_req_unsubscribe)(request, s[can_subscription->get_index()]->get_event())) < 0) { - ERROR(binder_interface, "%s: Operation goes wrong for signal: %s", __FUNCTION__, can_subscription->get_sig_name().c_str()); + ERROR(binder_interface, "%s: Operation goes wrong for signal: %s", __FUNCTION__, can_subscription->get_name().c_str()); return -1; } return 0; } -static int create_event_handle(std::shared_ptr& can_subscription, std::map, struct afb_event> >& s) +static int create_event_handle(std::shared_ptr& can_subscription, std::map >& s) { int sub_index = can_subscription->get_index(); - struct afb_event event = afb_daemon_make_event(binder_interface->daemon, can_subscription->get_sig_name().c_str()); - s[sub_index] = std::make_pair(can_subscription, event); - if (!afb_event_is_valid(s[sub_index].second)) + can_subscription->set_event(afb_daemon_make_event(binder_interface->daemon, can_subscription->get_name().c_str())); + s[sub_index] = can_subscription; + if (!afb_event_is_valid(s[sub_index]->get_event())) { - ERROR(binder_interface, "%s: Can't create an event for %s, something goes wrong.", __FUNCTION__, can_subscription->get_sig_name().c_str()); + ERROR(binder_interface, "%s: Can't create an event for %s, something goes wrong.", __FUNCTION__, can_subscription->get_name().c_str()); return -1; } return 0; @@ -280,32 +310,24 @@ static int create_event_handle(std::shared_ptr& can_subs /// @brief Will determine if it is needed or not to create the event handle and checks it to be sure that /// we got a valid afb_event to get subscribe or unsubscribe. Then launch the subscription or unsubscription /// against the application framework using that event handle. -static int subscribe_unsubscribe_signal(struct afb_req request, bool subscribe, std::shared_ptr& can_subscription) +static int subscribe_unsubscribe_signal(struct afb_req request, bool subscribe, std::shared_ptr& can_subscription, std::map >& s) { int ret; int sub_index = can_subscription->get_index(); - utils::signals_manager_t& sm = utils::signals_manager_t::instance(); - std::lock_guard subscribed_signals_lock(sm.get_subscribed_signals_mutex()); - std::map, struct afb_event> >& s = sm.get_subscribed_signals(); if (can_subscription && s.find(sub_index) != s.end()) { - if (!afb_event_is_valid(s[sub_index].second) && !subscribe) + if (!afb_event_is_valid(s[sub_index]->get_event()) && !subscribe) { NOTICE(binder_interface, "%s: Event isn't valid, no need to unsubscribed.", __FUNCTION__); ret = -1; } - else - { - // Event it isn't valid anymore, recreate it - ret = create_event_handle(can_subscription, s); - } } else { /* Event doesn't exist , so let's create it */ - struct afb_event empty_event = {nullptr, nullptr}; - s[sub_index] = std::make_pair(can_subscription, empty_event); + can_subscription->set_event({nullptr, nullptr}); + s[sub_index] = can_subscription; ret = create_event_handle(can_subscription, s); } @@ -316,63 +338,78 @@ static int subscribe_unsubscribe_signal(struct afb_req request, bool subscribe, return make_subscription_unsubscription(request, can_subscription, s, subscribe); } -/// -/// @brief subscribe to all signals in the vector signals -/// -/// @param[in] afb_req request : contain original request use to subscribe or unsubscribe -/// @param[in] subscribe boolean value used to chose between a subscription operation or an unsubscription -/// @param[in] signals - struct containing vectors with can_signal_t and diagnostic_messages to subscribe -/// -/// @return Number of correctly subscribed signal -/// -static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, const struct utils::signals_found& signals, struct event_filter_t& event_filter) +int subscribe_unsubscribe_diagnostic_messages(struct afb_req request, bool subscribe, std::vector > diagnostic_messages, struct event_filter_t& event_filter, std::map >& s) { int rets = 0; + application_t& app = application_t::instance(); + diagnostic_manager_t& diag_m = app.get_diagnostic_manager(); - //TODO: Implement way to dynamically call the right function no matter - // how much signals types we have. - application_t& conf = application_t::instance(); - - for(const auto& sig : signals.diagnostic_messages) + for(const auto& sig : diagnostic_messages) { - int ret = 0; - diagnostic_manager_t& diag_m = conf.get_diagnostic_manager(); - DiagnosticRequest* diag_req = conf.get_request_from_diagnostic_message(sig->get_name()); + DiagnosticRequest* diag_req = app.get_request_from_diagnostic_message(sig->get_name()); + float frequency = std::isnan(event_filter.frequency) ? sig->get_frequency() : event_filter.frequency; + std::shared_ptr can_subscription; // If the requested diagnostic message isn't supported by the car then unsubcribe it // no matter what we want, worse case will be a fail unsubscription but at least we don't // poll a PID for nothing. + //TODO: Adding callback requesting ignition status: diag_req, sig.c_str(), false, diagnostic_message_t::decode_obd2_response, diagnostic_message_t::check_ignition_status, frequency); if(sig->get_supported() && subscribe) { - float frequency = std::isnan(event_filter.frequency) ? sig->get_frequency() : event_filter.frequency; - - diag_m.add_recurring_request(diag_req, sig->get_name().c_str(), false, sig->get_decoder(), sig->get_callback(), frequency); - //TODO: Adding callback requesting ignition status: diag_req, sig.c_str(), false, diagnostic_message_t::decode_obd2_response, diagnostic_message_t::check_ignition_status, frequency); + if (s.find(sig->get_pid()) != s.end()) + { + can_subscription = s[sig->get_pid()]; + DEBUG(binder_interface, "%s: Signal: %s already subscribed. Adding a new subscription", __FUNCTION__, sig->get_name().c_str()); + } + else + { + diag_m.add_recurring_request(diag_req, sig->get_name().c_str(), false, sig->get_decoder(), sig->get_callback(), frequency); + can_subscription = std::make_shared(low_can_subscription_t(event_filter, sig)); + DEBUG(binder_interface, "%s: Signal: %s subscribed", __FUNCTION__, sig->get_name().c_str()); + } } else { diag_m.cleanup_request( diag_m.find_recurring_request(diag_req), true); - WARNING(binder_interface, "%s: signal: %s isn't supported. Canceling operation.", __FUNCTION__, sig->get_name().c_str()); delete diag_req; diag_req = nullptr; + if(sig->get_supported()) + { + DEBUG(binder_interface, "%s: %s cancelled due to unsubscribe", __FUNCTION__, sig->get_name().c_str()); + return 0; + } + WARNING(binder_interface, "%s: signal: %s isn't supported. Canceling operation.", __FUNCTION__, sig->get_name().c_str()); return -1; } - - std::shared_ptr can_subscription(new low_can_subscription_t(event_filter)); - ret = subscribe_unsubscribe_signal(request, subscribe, can_subscription); + int ret = subscribe_unsubscribe_signal(request, subscribe, can_subscription, s); if(ret < 0) return ret; rets++; - DEBUG(binder_interface, "%s: Signal: %s subscribed", __FUNCTION__, sig->get_name().c_str()); } - for(const auto& sig: signals.can_signals) + return rets; +} + +int subscribe_unsubscribe_can_signals(struct afb_req request, bool subscribe, std::vector > can_signals, struct event_filter_t& event_filter, std::map >& s) +{ + int rets = 0; + for(const auto& sig: can_signals) { - std::shared_ptr can_subscription(new low_can_subscription_t(event_filter)); - if(can_subscription->create_rx_filter(sig) < 0) - {return -1;} - else if(subscribe_unsubscribe_signal(request, subscribe, can_subscription) < 0) + auto it = std::find_if(s.begin(), s.end(), [&sig](std::pair > sub){ return sub.second->get_can_signal() == sig; }); + std::shared_ptr can_subscription; + if(it != s.end()) + { + can_subscription = it->second; + } + else + { + can_subscription = std::make_shared(low_can_subscription_t(event_filter)); + if(can_subscription->create_rx_filter(sig) < 0) + {return -1;} + } + + if(subscribe_unsubscribe_signal(request, subscribe, can_subscription, s) < 0) {return -1;} struct sd_event_source* e_source; @@ -383,6 +420,29 @@ static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, return rets; } +/// +/// @brief subscribe to all signals in the vector signals +/// +/// @param[in] afb_req request : contain original request use to subscribe or unsubscribe +/// @param[in] subscribe boolean value used to chose between a subscription operation or an unsubscription +/// @param[in] signals - struct containing vectors with can_signal_t and diagnostic_messages to subscribe +/// +/// @return Number of correctly subscribed signal +/// +static int subscribe_unsubscribe_signals(struct afb_req request, bool subscribe, const struct utils::signals_found& signals, struct event_filter_t& event_filter) +{ + int rets = 0; + utils::signals_manager_t& sm = utils::signals_manager_t::instance(); + + std::lock_guard subscribed_signals_lock(sm.get_subscribed_signals_mutex()); + std::map >& s = sm.get_subscribed_signals(); + + rets += subscribe_unsubscribe_diagnostic_messages(request, subscribe, signals.diagnostic_messages, event_filter, s); + rets += subscribe_unsubscribe_can_signals(request, subscribe, signals.can_signals, event_filter, s); + + return rets; +} + static int one_subscribe_unsubscribe(struct afb_req request, bool subscribe, const std::string& tag, json_object* args) { int ret = 0;