X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fcan%2Fcan-bus.cpp;h=0c2337c5d0b062e0fb8c93f1a1d4089e73e087c3;hb=e6a4a15644b3e18232a48764aed32a9e13ec6a1f;hp=ebfd7cec026d9f443b7d7a00f1f1a03445538092;hpb=63d31e29e366fb9dd85debc897fdbc91d9cb2e42;p=apps%2Flow-level-can-service.git diff --git a/src/can/can-bus.cpp b/src/can/can-bus.cpp index ebfd7ce..0c2337c 100644 --- a/src/can/can-bus.cpp +++ b/src/can/can-bus.cpp @@ -29,6 +29,7 @@ #include "can-bus.hpp" +#include "can-signals.hpp" #include "can-decoder.hpp" #include "../configuration.hpp" #include "../utils/signals.hpp" @@ -50,7 +51,20 @@ can_bus_t::can_bus_t(int conf_file) { } +std::map> can_bus_t::can_devices_; +/** + * @brief Will make the decoding operation on a classic CAN message. It will not + * handle CAN commands nor diagnostic messages that have their own method to get + * this happens. + * + * It will add to the vehicle_message queue the decoded message and tell the event push + * thread to process it. + * + * @param[in] can_message - a single CAN message from the CAN socket read, to be decode. + * + * @return How many signals has been decoded. + */ int can_bus_t::process_can_signals(can_message_t& can_message) { int processed_signals = 0; @@ -60,7 +74,6 @@ int can_bus_t::process_can_signals(can_message_t& can_message) /* First we have to found which can_signal_t it is */ search_key = build_DynamicField((double)can_message.get_id()); - signals.clear(); configuration_t::instance().find_can_signals(search_key, signals); /* Decoding the message ! Don't kill the messenger ! */ @@ -74,11 +87,11 @@ int can_bus_t::process_can_signals(can_message_t& can_message) DEBUG(binder_interface, "Operator[] key string: %s, event valid? %d", sig.generic_name, afb_event_is_valid(s[std::string(sig.generic_name)])); DEBUG(binder_interface, "Nb elt matched char: %d", (int)s.count(sig.generic_name)); DEBUG(binder_interface, "Nb elt matched string: %d", (int)s.count(std::string(sig.generic_name)));*/ - if( s.find(sig->get_generic_name()) != s.end() && afb_event_is_valid(s[sig->get_generic_name()])) + if( s.find(sig->get_name()) != s.end() && afb_event_is_valid(s[sig->get_name()])) { decoded_message = decoder_t::translateSignal(*sig, can_message, configuration_t::instance().get_can_signals()); - openxc_SimpleMessage s_message = build_SimpleMessage(sig->get_generic_name(), decoded_message); + openxc_SimpleMessage s_message = build_SimpleMessage(sig->get_name(), decoded_message); vehicle_message = build_VehicleMessage(s_message); std::lock_guard decoded_can_message_lock(decoded_can_message_mutex_); @@ -92,41 +105,30 @@ int can_bus_t::process_can_signals(can_message_t& can_message) return processed_signals; } -int can_bus_t::process_diagnostic_signals(active_diagnostic_request_t* entry, const can_message_t& can_message) +/** + * @brief Will make the decoding operation on a diagnostic CAN message.It will add to + * the vehicle_message queue the decoded message and tell the event push thread to process it. + * + * @param[in] manager - the diagnostic manager object that handle diagnostic communication + * @param[in] can_message - a single CAN message from the CAN socket read, to be decode. + * + * @return How many signals has been decoded. + */ +int can_bus_t::process_diagnostic_signals(diagnostic_manager_t& manager, const can_message_t& can_message) { int processed_signals = 0; - openxc_VehicleMessage vehicle_message; - diagnostic_manager_t& manager = configuration_t::instance().get_diagnostic_manager(); - std::lock_guard subscribed_signals_lock(get_subscribed_signals_mutex()); std::map& s = get_subscribed_signals(); - if( s.find(entry->get_name()) != s.end() && afb_event_is_valid(s[entry->get_name()])) + openxc_VehicleMessage vehicle_message = manager.find_and_decode_adr(can_message); + if( (vehicle_message.has_simple_message && vehicle_message.simple_message.has_name) && + (s.find(vehicle_message.simple_message.name) != s.end() && afb_event_is_valid(s[vehicle_message.simple_message.name]))) { - if(manager.get_can_bus_dev() == entry->get_can_bus_dev() && entry->get_in_flight()) - { - DiagnosticResponse response = diagnostic_receive_can_frame( - // TODO: openXC todo task: eek, is bus address and array index this tightly coupled? - &manager.get_shims(), - entry->get_handle(), can_message.get_id(), can_message.get_data(), can_message.get_length()); - if(response.completed && entry->get_handle()->completed) - { - if(entry->get_handle()->success) - { - vehicle_message = manager.relay_diagnostic_response(entry, response); - std::lock_guard decoded_can_message_lock(decoded_can_message_mutex_); - push_new_vehicle_message(vehicle_message); - new_decoded_can_message_.notify_one(); - processed_signals++; - } - else - DEBUG(binder_interface, "Fatal error sending or receiving diagnostic request"); - } - else if(!response.completed && response.multi_frame) - // Reset the timeout clock while completing the multi-frame receive - entry->get_timeout_clock().tick(); - } + std::lock_guard decoded_can_message_lock(decoded_can_message_mutex_); + push_new_vehicle_message(vehicle_message); + new_decoded_can_message_.notify_one(); + processed_signals++; } return processed_signals; @@ -141,7 +143,7 @@ int can_bus_t::process_diagnostic_signals(active_diagnostic_request_t* entry, co * corresponding decoding function if there is one assigned for that signal. If not, it will be the default * noopDecoder function that will operate on it. * -* Depending on the nature of message, if id match a diagnostic request corresponding id for a response +* Depending on the nature of message, if id match a diagnostic request corresponding id for a response * then decoding a diagnostic message else use classic CAN signals decoding functions. * * TODO: make diagnostic messages parsing optionnal. @@ -156,9 +158,8 @@ void can_bus_t::can_decode_message() new_can_message_cv_.wait(can_message_lock); can_message = next_can_message(); - active_diagnostic_request_t* adr = configuration_t::instance().get_diagnostic_manager().is_diagnostic_response(can_message); - if(adr != nullptr) - process_diagnostic_signals(adr, can_message); + if(configuration_t::instance().get_diagnostic_manager().is_diagnostic_response(can_message)) + process_diagnostic_signals(configuration_t::instance().get_diagnostic_manager(), can_message); else process_can_signals(can_message); } @@ -195,9 +196,9 @@ void can_bus_t::can_event_push() } /** - * @brief Will initialize threads that will decode - * and push subscribed events. - */ +* @brief Will initialize threads that will decode +* and push subscribed events. +*/ void can_bus_t::start_threads() { is_decoding_ = true; @@ -224,12 +225,16 @@ void can_bus_t::stop_threads() /** * @brief Will initialize can_bus_dev_t objects after reading -* the configuration file passed in the constructor. +* the configuration file passed in the constructor. All CAN buses +* Initialized here will be added to a vector holding them for +* inventory and later access. +* +* That will initialize CAN socket reading too using a new thread. */ int can_bus_t::init_can_dev() { std::vector devices_name; - int i; + int i = 0; size_t t; devices_name = read_conf(); @@ -237,20 +242,19 @@ int can_bus_t::init_can_dev() if (! devices_name.empty()) { t = devices_name.size(); - i=0; for(const auto& device : devices_name) { - can_devices_.push_back(std::make_shared(device, i)); - if (can_devices_[i]->open() == 0) + can_bus_t::can_devices_[device] = std::make_shared(device, i); + if (can_bus_t::can_devices_[device]->open() == 0) { DEBUG(binder_interface, "Start reading thread"); NOTICE(binder_interface, "%s device opened and reading", device.c_str()); - can_devices_[i]->start_reading(*this); + can_bus_t::can_devices_[device]->start_reading(*this); + i++; } else ERROR(binder_interface, "Can't open device %s", device.c_str()); - i++; } NOTICE(binder_interface, "Initialized %d/%d can bus device(s)", i, t); @@ -396,7 +400,20 @@ void can_bus_t::push_new_vehicle_message(const openxc_VehicleMessage& v_msg) * * @return map can_bus_dev_m_ map */ -const std::vector>& can_bus_t::get_can_devices() const +const std::map>& can_bus_t::get_can_devices() const +{ + return can_bus_t::can_devices_; +} + +/** +* @brief Return the shared pointer on the can_bus_dev_t initialized +* with device_name "bus" +* +* @param[in] bus - CAN bus device name to retrieve. +* +* @return A shared pointer on an object can_bus_dev_t +*/ +std::shared_ptr can_bus_t::get_can_device(std::string bus) { - return can_devices_; + return can_bus_t::can_devices_[bus]; }