diff options
Diffstat (limited to 'CAN-binder/low-can-binding/binding/low-can-cb.cpp')
| -rw-r--r-- | CAN-binder/low-can-binding/binding/low-can-cb.cpp | 310 |
1 files changed, 210 insertions, 100 deletions
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 d4cc5a1..5b7561f 100644 --- a/CAN-binder/low-can-binding/binding/low-can-cb.cpp +++ b/CAN-binder/low-can-binding/binding/low-can-cb.cpp @@ -19,7 +19,6 @@ #include "low-can-hat.hpp" #include <map> -#include <memory> #include <queue> #include <mutex> #include <vector> @@ -59,12 +58,6 @@ 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_t> 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_}, @@ -77,9 +70,14 @@ low_can_subscription_t::low_can_subscription_t( low_can_subscription_t&& s) return *this; } +low_can_subscription_t::~low_can_subscription_t() +{ + socket_.close(); +} + low_can_subscription_t::operator bool() const { - return ((can_signal_ != nullptr || diagnostic_message_ != nullptr) && afb_event_is_valid(event_)); + return ((can_signal_ != nullptr || ! diagnostic_message_.empty()) && afb_event_is_valid(event_)); } struct afb_event& low_can_subscription_t::get_event() @@ -97,17 +95,47 @@ const std::shared_ptr<can_signal_t> low_can_subscription_t::get_can_signal() con return can_signal_; } -const std::shared_ptr<diagnostic_message_t> low_can_subscription_t::get_diagnostic_message() const +const std::vector<std::shared_ptr<diagnostic_message_t> > low_can_subscription_t::get_diagnostic_message() const { return diagnostic_message_; } +const std::shared_ptr<diagnostic_message_t> 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; +} + +const std::shared_ptr<diagnostic_message_t> 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; +} + 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 ""; +} + +const std::string low_can_subscription_t::get_name(uint32_t pid) const +{ + if (!diagnostic_message_.empty()) + return get_diagnostic_message(pid)->get_name() ; return ""; } @@ -152,47 +180,75 @@ void low_can_subscription_t::set_max(float max) event_filter_.max = max; } +int low_can_subscription_t::open_socket() +{ + int ret = 0; + if(! socket_) + { + if( can_signal_ != nullptr) + {ret = socket_.open(can_signal_->get_message()->get_bus_device_name());} + else if (! diagnostic_message_ .empty()) + {ret = socket_.open(application_t::instance().get_diagnostic_manager().get_bus_device_name());} + index_ = (int)socket_.socket(); + } + return ret; +} + +struct utils::simple_bcm_msg low_can_subscription_t::make_bcm_head(uint32_t can_id, uint32_t flags, const struct timeval& timeout, const struct timeval& frequency_thinning) const +{ + struct utils::simple_bcm_msg bcm_msg; + + memset(&bcm_msg, 0, sizeof(bcm_msg)); + + bcm_msg.msg_head.opcode = RX_SETUP; + bcm_msg.msg_head.can_id = can_id; + bcm_msg.msg_head.flags = flags; + bcm_msg.msg_head.ival1.tv_sec = timeout.tv_sec ; + bcm_msg.msg_head.ival1.tv_usec = timeout.tv_usec; + bcm_msg.msg_head.ival2.tv_sec = frequency_thinning.tv_sec ; + bcm_msg.msg_head.ival2.tv_usec = frequency_thinning.tv_usec; + + return bcm_msg; +} + +void low_can_subscription_t::add_bcm_frame(const struct can_frame& cfd, struct utils::simple_bcm_msg& bcm_msg) const +{ + for(int i=0; i < CAN_MAX_DLEN; i++) + { + if(cfd.data[i] != 0) + { + bcm_msg.msg_head.nframes = 1; + bcm_msg.frames = cfd; + return; + } + } +} + /// @brief Create a RX_SETUP receive job used by the BCM socket. /// /// @return 0 if ok else -1 -int low_can_subscription_t::create_rx_filter(std::shared_ptr<can_signal_t> sig) +int low_can_subscription_t::create_rx_filter() { - can_signal_= sig; - return create_rx_filter(); + int ret = -1; + if ( can_signal_ != nullptr) + {ret = create_rx_filter(can_signal_);} + else if (! diagnostic_message_ .empty()) + {ret = create_rx_filter(diagnostic_message_.front());} + + return ret; } /// @brief Create a RX_SETUP receive job used by the BCM socket. /// /// @return 0 if ok else -1 -int low_can_subscription_t::create_rx_filter() +int low_can_subscription_t::create_rx_filter(std::shared_ptr<can_signal_t> sig) { - if (can_signal_ == nullptr) - {return -1;} - - // Make sure that socket has been opened. - if(! socket_) - { - socket_.open(can_signal_->get_message()->get_bus_device_name()); - index_ = (int)socket_.socket(); - } + can_signal_= sig; - struct utils::simple_bcm_msg bcm_msg; struct can_frame cfd; - memset(&cfd, 0, sizeof(cfd)); - memset(&bcm_msg.msg_head, 0, sizeof(bcm_msg.msg_head)); - float val = (float)(1 << can_signal_->get_bit_size()) - 1; - struct timeval freq; - 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; - bcm_msg.msg_head.can_id = can_signal_->get_message()->get_id(); - bcm_msg.msg_head.flags = SETTIMER|RX_NO_AUTOTIMER; - bcm_msg.msg_head.ival2.tv_sec = freq.tv_sec ; - bcm_msg.msg_head.ival2.tv_usec = freq.tv_usec; - bcm_msg.msg_head.nframes = 1; + float val = (float)(1 << can_signal_->get_bit_size()) - 1; bitfield_encode_float(val, can_signal_->get_bit_position(), can_signal_->get_bit_size(), @@ -201,11 +257,61 @@ int low_can_subscription_t::create_rx_filter() cfd.data, CAN_MAX_DLEN); - bcm_msg.frames = cfd; + struct timeval freq, timeout = {0, 0}; + 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(); + + utils::simple_bcm_msg bcm_msg = make_bcm_head(can_signal_->get_message()->get_id(), SETTIMER|RX_NO_AUTOTIMER, timeout, freq); + add_bcm_frame(cfd, bcm_msg); + + return create_rx_filter(bcm_msg); +} + +/// @brief Create a RX_SETUP receive job used by the BCM socket. +/// +/// @return 0 if ok else -1 +int low_can_subscription_t::create_rx_filter(std::shared_ptr<diagnostic_message_t> sig) +{ + diagnostic_message_.push_back(sig); + + struct timeval freq = frequency_clock_t(event_filter_.frequency).get_timeval_from_period(); + //struct timeval timeout = frequency_clock_t(10).get_timeval_from_period(); + struct timeval timeout = {0,0}; + + utils::simple_bcm_msg bcm_msg = make_bcm_head(OBD2_FUNCTIONAL_BROADCAST_ID, SETTIMER|RX_NO_AUTOTIMER|RX_FILTER_ID, timeout, freq); + return create_rx_filter(bcm_msg); +} + +/// @brief Create a RX_SETUP receive job used by the BCM socket. +/// +/// @return 0 if ok else -1 +int low_can_subscription_t::create_rx_filter(utils::simple_bcm_msg& bcm_msg) +{ + // Make sure that socket has been opened. + if(open_socket() < 0) + {return -1;} - if(socket_ << bcm_msg) - return 0; - return -1; + // If it isn't an OBD2 CAN ID then just add a simple RX_SETUP job + // else monitor all standard 8 CAN OBD2 ID response. + if(bcm_msg.msg_head.can_id != OBD2_FUNCTIONAL_BROADCAST_ID) + { + socket_ << bcm_msg; + if(! socket_) + return -1; + } + else + { + for(uint8_t i = 0; i < 8; i++) + { + bcm_msg.msg_head.can_id = OBD2_FUNCTIONAL_RESPONSE_START + i; + + socket_ << bcm_msg; + if(! socket_) + return -1; + } + } + + return 0; } ///****************************************************************************** @@ -214,66 +320,56 @@ int low_can_subscription_t::create_rx_filter() /// ///*******************************************************************************/ -void on_no_clients(const std::string& message) +void on_no_clients(std::shared_ptr<low_can_subscription_t> can_subscription, uint32_t pid) { - DiagnosticRequest* diag_req = application_t::instance().get_request_from_diagnostic_message(message); - if(diag_req != nullptr) + if( ! can_subscription->get_diagnostic_message().empty() && can_subscription->get_diagnostic_message(pid) != nullptr) { + DiagnosticRequest diag_req = can_subscription->get_diagnostic_message(pid)->build_diagnostic_request(); active_diagnostic_request_t* adr = application_t::instance().get_diagnostic_manager().find_recurring_request(diag_req); if( adr != nullptr) application_t::instance().get_diagnostic_manager().cleanup_request(adr, true); } - delete diag_req; - diag_req = nullptr; + + on_no_clients(can_subscription); +} + +void on_no_clients(std::shared_ptr<low_can_subscription_t> can_subscription) +{ + utils::signals_manager_t& sm = utils::signals_manager_t::instance(); + std::lock_guard<std::mutex> subscribed_signals_lock(sm.get_subscribed_signals_mutex()); + std::map<int, std::shared_ptr<low_can_subscription_t> >& s = sm.get_subscribed_signals(); + auto it = s.find(can_subscription->get_index()); + s.erase(it); } static void push_n_notify(const can_message_t& cm) { can_bus_t& cbm = application_t::instance().get_can_bus_manager(); - std::lock_guard<std::mutex> can_message_lock(cbm.get_can_message_mutex()); - { cbm.push_new_can_message(cm); } + { + std::lock_guard<std::mutex> can_message_lock(cbm.get_can_message_mutex()); + cbm.push_new_can_message(cm); + } cbm.get_new_can_message_cv().notify_one(); } -int read_message(sd_event_source *s, int fd, uint32_t revents, void *userdata) +int read_message(sd_event_source *event_source, int fd, uint32_t revents, void *userdata) { - can_message_t cm; - low_can_subscription_t* can_subscription; - diagnostic_manager_t& diag_m = application_t::instance().get_diagnostic_manager(); - - if(userdata != nullptr) + low_can_subscription_t* can_subscription = (low_can_subscription_t*)userdata; + if ((revents & EPOLLIN) != 0) { - can_subscription = (low_can_subscription_t*)userdata; + can_message_t cm; utils::socketcan_bcm_t& s = can_subscription->get_socket(); s >> cm; - } - else - { - utils::socketcan_bcm_t& s = diag_m.get_socket(); - s >> cm; - } - push_n_notify(cm); + push_n_notify(cm); + } /* check if error or hangup */ if ((revents & (EPOLLERR|EPOLLRDHUP|EPOLLHUP)) != 0) { - sd_event_source_unref(s); - if(userdata != nullptr) - { - 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_name().c_str()); - } - else - { - diag_m.get_socket().close(); - diag_m.cleanup_active_requests(true); - ERROR(binder_interface, "%s: Error on diagnostic manager socket, cancelling active requests.", __FUNCTION__); - } - return -1; + sd_event_source_unref(event_source); + can_subscription->get_socket().close(); } - return 0; } @@ -338,7 +434,18 @@ static int subscribe_unsubscribe_signal(struct afb_req request, bool subscribe, return make_subscription_unsubscription(request, can_subscription, s, subscribe); } -int subscribe_unsubscribe_diagnostic_messages(struct afb_req request, bool subscribe, std::vector<std::shared_ptr<diagnostic_message_t> > diagnostic_messages, struct event_filter_t& event_filter, std::map<int, std::shared_ptr<low_can_subscription_t> >& s) +static int add_to_event_loop(std::shared_ptr<low_can_subscription_t>& can_subscription) +{ + struct sd_event_source* event_source = nullptr; + return ( sd_event_add_io(afb_daemon_get_event_loop(binder_interface->daemon), + &event_source, + can_subscription->get_socket().socket(), + EPOLLIN, + read_message, + can_subscription.get())); +} + +static int subscribe_unsubscribe_diagnostic_messages(struct afb_req request, bool subscribe, std::vector<std::shared_ptr<diagnostic_message_t> > diagnostic_messages, struct event_filter_t& event_filter, std::map<int, std::shared_ptr<low_can_subscription_t> >& s) { int rets = 0; application_t& app = application_t::instance(); @@ -346,52 +453,55 @@ int subscribe_unsubscribe_diagnostic_messages(struct afb_req request, bool subsc for(const auto& sig : diagnostic_messages) { - 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; + DiagnosticRequest* diag_req = new DiagnosticRequest(sig->build_diagnostic_request()); + event_filter.frequency = std::isnan(event_filter.frequency) ? sig->get_frequency() : event_filter.frequency; std::shared_ptr<low_can_subscription_t> can_subscription; + auto it = std::find_if(s.begin(), s.end(), [&sig](std::pair<int, std::shared_ptr<low_can_subscription_t> > sub){ return (! sub.second->get_diagnostic_message().empty());}); + can_subscription = it != s.end() ? + it->second : + std::make_shared<low_can_subscription_t>(low_can_subscription_t(event_filter)); // 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) { - 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(), event_filter.frequency); + if(can_subscription->create_rx_filter(sig) < 0) + {return -1;} + DEBUG(binder_interface, "%s: Signal: %s subscribed", __FUNCTION__, sig->get_name().c_str()); + if(it == s.end() && add_to_event_loop(can_subscription) < 0) { - 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>(low_can_subscription_t(event_filter, sig)); - DEBUG(binder_interface, "%s: Signal: %s subscribed", __FUNCTION__, sig->get_name().c_str()); + 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()); + return -1; } } else { diag_m.cleanup_request( - diag_m.find_recurring_request(diag_req), true); - delete diag_req; - diag_req = nullptr; + diag_m.find_recurring_request(*diag_req), true); if(sig->get_supported()) + {DEBUG(binder_interface, "%s: %s cancelled due to unsubscribe", __FUNCTION__, sig->get_name().c_str());} + else { - 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; } - WARNING(binder_interface, "%s: signal: %s isn't supported. Canceling operation.", __FUNCTION__, sig->get_name().c_str()); - return -1; } int ret = subscribe_unsubscribe_signal(request, subscribe, can_subscription, s); if(ret < 0) return ret; + rets++; } return rets; } -int subscribe_unsubscribe_can_signals(struct afb_req request, bool subscribe, std::vector<std::shared_ptr<can_signal_t> > can_signals, struct event_filter_t& event_filter, std::map<int, std::shared_ptr<low_can_subscription_t> >& s) +static int subscribe_unsubscribe_can_signals(struct afb_req request, bool subscribe, std::vector<std::shared_ptr<can_signal_t> > can_signals, struct event_filter_t& event_filter, std::map<int, std::shared_ptr<low_can_subscription_t> >& s) { int rets = 0; for(const auto& sig: can_signals) @@ -412,8 +522,8 @@ int subscribe_unsubscribe_can_signals(struct afb_req request, bool subscribe, st if(subscribe_unsubscribe_signal(request, subscribe, can_subscription, s) < 0) {return -1;} - struct sd_event_source* e_source; - sd_event_add_io(afb_daemon_get_event_loop(binder_interface->daemon), &e_source, can_subscription->get_socket().socket(), EPOLLIN, read_message, can_subscription.get()); + if(add_to_event_loop(can_subscription) < 0) + {return -1;} rets++; DEBUG(binder_interface, "%s: signal: %s subscribed", __FUNCTION__, sig->get_name().c_str()); } |