X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=src%2Fcan%2Fcan-bus.cpp;h=29e63b7eb1f1c37c21c59c2b24f122f2d20df293;hb=20336cf43a6b312cd03f76dbe68333db18122bd6;hp=69f08c5f423132479b0b79f2dc4fa992a0f3fe37;hpb=473b167761147a4cb36af86fea8e8c54bdf03d14;p=apps%2Fagl-service-can-low-level.git diff --git a/src/can/can-bus.cpp b/src/can/can-bus.cpp index 69f08c5f..29e63b7e 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,6 +51,8 @@ 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 @@ -71,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 ! */ @@ -107,47 +109,26 @@ int can_bus_t::process_can_signals(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] entry - an active_diagnostic_request_t object that made the request - * about that diagnostic CAN message. + * @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(active_diagnostic_request_t* entry, const can_message_t& can_message) +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, "process_diagnostic_signals: 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; @@ -177,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); } @@ -254,7 +234,7 @@ void can_bus_t::stop_threads() int can_bus_t::init_can_dev() { std::vector devices_name; - int i; + int i = 0; size_t t; devices_name = read_conf(); @@ -262,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); @@ -421,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]; }