X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=low-can-binding%2Fcan%2Fcan-bus.cpp;h=11b7770c743cc9398c550ecbaac94b4c183b1d98;hb=9e23caa4c56259044604c38f107f7c637001b846;hp=739e865cbd42f9bdaace25d238cb24cf4eae848b;hpb=d2d2620bbb8f0aad0181e67e9f6affc3d6cb4a51;p=apps%2Fagl-service-can-low-level.git diff --git a/low-can-binding/can/can-bus.cpp b/low-can-binding/can/can-bus.cpp index 739e865c..11b7770c 100644 --- a/low-can-binding/can/can-bus.cpp +++ b/low-can-binding/can/can-bus.cpp @@ -27,7 +27,7 @@ #include "can-bus.hpp" -#include "can-signals.hpp" +#include "signals.hpp" #include "can-decoder.hpp" #include "../binding/application.hpp" #include "../utils/signals.hpp" @@ -44,12 +44,39 @@ can_bus_t::~can_bus_t() } /// @brief Class constructor -/// -/// @param[in] conf_file - handle to the json configuration file. -can_bus_t::can_bus_t(utils::config_parser_t conf_file) - : conf_file_{conf_file} +can_bus_t::can_bus_t() {} +/// @brief Fills the CAN device map member with value from device +/// +/// @param[in] mapping configuration section. +void can_bus_t::set_can_devices(json_object *mapping) +{ + if (! mapping) + { + AFB_ERROR("Can't initialize CAN buses with this empty mapping."); + return; + } + + struct json_object_iterator it = json_object_iter_begin(mapping); + struct json_object_iterator end = json_object_iter_end(mapping); + while (! json_object_iter_equal(&it, &end)) { + can_devices_mapping_.push_back(std::make_pair( + json_object_iter_peek_name(&it), + json_object_get_string(json_object_iter_peek_value(&it)) + )); + json_object_iter_next(&it); + } +} + +/// @brief Fills the CAN device map member with given values +/// +/// @param[in] mapping configuration section. +void can_bus_t::set_can_devices(const std::vector >& mapping) +{ + can_devices_mapping_ = mapping; +} + /// @brief Take a decoded message to determine if its value complies with the desired /// filters. /// @@ -81,27 +108,49 @@ bool can_bus_t::apply_filter(const openxc_VehicleMessage& vehicle_message, std:: /// @param[in] can_message - a single CAN message from the CAN socket read, to be decode. /// /// @return How many signals has been decoded. -void can_bus_t::process_signals(const message_t& message, std::map >& s) +void can_bus_t::process_signals(std::shared_ptr message, map_subscription& s) { - int subscription_id = message.get_sub_id(); + int subscription_id = message->get_sub_id(); openxc_DynamicField decoded_message; openxc_VehicleMessage vehicle_message; if( s.find(subscription_id) != s.end() && afb_event_is_valid(s[subscription_id]->get_event())) { bool send = true; - // First we have to found which can_signal_t it is - std::shared_ptr sig = s[subscription_id]; + // First we have to found which signal_t it is + std::shared_ptr subscription = s[subscription_id]; + openxc_SimpleMessage s_message; + + // messages + if(subscription->get_message_definition() != nullptr) + { + openxc_DynamicField dynamicField_tmp; + json_object *signal_json_tmp; + decoded_message = build_DynamicField_json(json_object_new_array()); + for(std::shared_ptr sig : subscription->get_message_definition()->get_signals()) + { + signal_json_tmp = json_object_new_object(); + dynamicField_tmp = decoder_t::translate_signal(*sig, message, &send); + json_object_object_add(signal_json_tmp,"name", json_object_new_string(sig->get_name().c_str())); + jsonify_DynamicField(dynamicField_tmp,signal_json_tmp); + if(sig != nullptr && sig->get_unit() != "") + json_object_object_add(signal_json_tmp, "unit", json_object_new_string(sig->get_unit().c_str())); + json_object_array_add(decoded_message.json_value,signal_json_tmp); + } + } + else // signal + { + decoded_message = decoder_t::translate_signal(*subscription->get_signal(), message, &send); + } - decoded_message = decoder_t::translate_signal(*sig->get_can_signal(), message, &send); - openxc_SimpleMessage s_message = build_SimpleMessage(sig->get_name(), decoded_message); - vehicle_message = build_VehicleMessage(s_message, message.get_timestamp()); + s_message = build_SimpleMessage(subscription->get_name(), decoded_message); + vehicle_message = build_VehicleMessage(s_message, message->get_timestamp()); - if(send && apply_filter(vehicle_message, sig)) + if(send && apply_filter(vehicle_message, subscription)) { std::lock_guard decoded_can_message_lock(decoded_can_message_mutex_); push_new_vehicle_message(subscription_id, vehicle_message); - AFB_DEBUG("%s CAN signals processed.", sig->get_name().c_str()); + AFB_DEBUG("%s CAN signals processed.", subscription->get_name().c_str()); } } } @@ -114,13 +163,13 @@ void can_bus_t::process_signals(const message_t& message, std::map message, std::map >& s) +void can_bus_t::process_diagnostic_signals(diagnostic_manager_t& manager, std::shared_ptr message, map_subscription& s) { int subscription_id = message->get_sub_id(); openxc_VehicleMessage vehicle_message = manager.find_and_decode_adr(message); if (message->get_timestamp()) - {vehicle_message.timestamp = message->get_timestamp();} + vehicle_message.timestamp = message->get_timestamp(); if( (vehicle_message.has_simple_message && vehicle_message.simple_message.has_name) && s.find(subscription_id) != s.end() && afb_event_is_valid(s[subscription_id]->get_event())) { @@ -160,13 +209,11 @@ void can_bus_t::can_decode_message() { std::lock_guard subscribed_signals_lock(sm.get_subscribed_signals_mutex()); - std::map >& s = sm.get_subscribed_signals(); + map_subscription& s = sm.get_subscribed_signals(); if(application_t::instance().get_diagnostic_manager().is_diagnostic_response(message)) - { process_diagnostic_signals(application_t::instance().get_diagnostic_manager(), message, s); - } else - {process_signals(*message, s);} + process_signals(message, s); } can_message_lock.lock(); } @@ -192,17 +239,17 @@ void can_bus_t::can_event_push() decoded_can_message_lock.unlock(); { std::lock_guard subscribed_signals_lock(sm.get_subscribed_signals_mutex()); - std::map >& s = sm.get_subscribed_signals(); + map_subscription& s = sm.get_subscribed_signals(); if(s.find(v_message.first) != s.end() && afb_event_is_valid(s[v_message.first]->get_event())) { jo = json_object_new_object(); - jsonify_vehicle(v_message.second, jo); + jsonify_vehicle(v_message.second, s[v_message.first]->get_signal(), jo); if(afb_event_push(s[v_message.first]->get_event(), jo) == 0) { if(v_message.second.has_diagnostic_response) - {on_no_clients(s[v_message.first], v_message.second.diagnostic_response.pid, s);} + on_no_clients(s[v_message.first], v_message.second.diagnostic_response.pid, s); else - {on_no_clients(s[v_message.first], s);} + on_no_clients(s[v_message.first], s); } } } @@ -303,23 +350,6 @@ void can_bus_t::push_new_vehicle_message(int subscription_id, const openxc_Vehic vehicle_message_q_.push(std::make_pair(subscription_id, v_msg)); } -/// @brief Fills the CAN device map member with value from device -/// mapping configuration file read at initialization. -void can_bus_t::set_can_devices() -{ - if(conf_file_.check_conf()) - { - can_devices_mapping_ = conf_file_.get_devices_name(); - - if(can_devices_mapping_.empty()) - { - AFB_ERROR("No mapping found in config file: '%s'. Check it that it have a CANbus-mapping section.", - conf_file_.filepath().c_str()); - } - } -} - - /// @brief Return the CAN device index from the map /// map are sorted so index depend upon alphabetical sorting. int can_bus_t::get_can_device_index(const std::string& bus_name) const