}
/// @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<std::pair<std::string, std::string> >& mapping)
+{
+ can_devices_mapping_ = mapping;
+}
+
/// @brief Take a decoded message to determine if its value complies with the desired
/// filters.
///
{
bool send = true;
// First we have to found which signal_t it is
- std::shared_ptr<low_can_subscription_t> sig = s[subscription_id];
+ std::shared_ptr<low_can_subscription_t> subscription = s[subscription_id];
+ openxc_SimpleMessage s_message;
- decoded_message = decoder_t::translate_signal(*sig->get_signal(), message, &send);
- openxc_SimpleMessage s_message = build_SimpleMessage(sig->get_name(), decoded_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<signal_t> 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);
+ }
+
+ 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<std::mutex> 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());
}
}
}
std::lock_guard<std::mutex> subscribed_signals_lock(sm.get_subscribed_signals_mutex());
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);
}
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)
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