application_t *application = (application_t*) ctrlConfig->external;
- if(wrap_json_unpack(json_obj, "{si, ss}",
+ if(wrap_json_unpack(json_obj, "{si, s?s}",
"active_message_set", &active_message_set,
"diagnostic_bus", &diagnotic_bus))
return -1;
/// Initialize Diagnostic manager that will handle obd2 requests.
/// We pass by default the first CAN bus device to its Initialization.
- if(! application_t::instance().get_diagnostic_manager().initialize(diagnotic_bus))
- {
- AFB_ERROR("Diagnostic Manager: error at initialization");
- return -1;
- }
+ if(! diagnotic_bus || application_t::instance().get_diagnostic_manager().initialize(diagnotic_bus))
+ AFB_WARNING("Diagnostic Manager: not initialized. No diagnostic messages will be processed.");
return 0;
}
* subsciptions.
*/
if(! request)
- {
return 0;
- }
// Event doesn't exist , so let's create it
if ((ret = can_subscription->subscribe(request)) < 0)
if (json_object_object_get_ex(filter, "max", &obj)
&& (json_object_is_type(obj, json_type_double) || json_object_is_type(obj, json_type_int)))
event_filter.max = (float)json_object_get_double(obj);
+ if (json_object_object_get_ex(filter, "promisc", &obj)
+ && (json_object_is_type(obj, json_type_boolean)))
+ event_filter.promisc = (bool)json_object_get_boolean(obj);
if (json_object_object_get_ex(filter, "rx_id", &obj)
&& (json_object_is_type(obj, json_type_int)))
event_filter.rx_id = (canid_t) json_object_get_int(obj);
static int one_subscribe_unsubscribe_id(afb_req_t request, bool subscribe, const uint32_t& id, json_object *args)
{
- int ret = 0;
std::shared_ptr<message_definition_t> message_definition = application_t::instance().get_message_definition(id);
struct utils::signals_found sf;
if(sf.signals.empty())
{
AFB_NOTICE("No signal(s) found for %d.", id);
- ret = -1;
- }
- else
- {
- event_filter_t event_filter = generate_filter(args);
- ret = subscribe_unsubscribe_signals(request, subscribe, sf, event_filter);
+ return -1;
}
- return ret;
+ event_filter_t event_filter = generate_filter(args);
+ std::shared_ptr<low_can_subscription_t> can_subscription = std::make_shared<low_can_subscription_t>(low_can_subscription_t(event_filter));
+ can_subscription->set_message_definition(message_definition);
+
+ utils::signals_manager_t& sm = utils::signals_manager_t::instance();
+ std::lock_guard<std::mutex> subscribed_signals_lock(sm.get_subscribed_signals_mutex());
+ map_subscription& s = sm.get_subscribed_signals();
+
+ if(can_subscription->create_rx_filter(message_definition) < 0)
+ return -1;
+ if(add_to_event_loop(can_subscription) < 0)
+ return -1;
+
+ if(subscribe_unsubscribe_signal(request, subscribe, can_subscription, s) < 0)
+ return -1;
+
+ return 0;
}
// 2 cases : ID(PGN) and event
json_object_object_get_ex(args,"event",&event);
- json_bool test_id = json_object_object_get_ex(args,"id",&id);
- if(!test_id)
- test_id = json_object_object_get_ex(args,"pgn",&id);
+ json_object_object_get_ex(args,"id",&id) || json_object_object_get_ex(args,"pgn",&id);
- if( args == NULL || (id && ((std::string)json_object_get_string(id)).compare("*") == 0))
+ if( args == NULL || (id && ((std::string)json_object_get_string(id)).compare("*") == 0))
{
rc = one_subscribe_unsubscribe_events(request, subscribe, "*", args);
}
do_subscribe_unsubscribe(request, false);
}
-/*
-static int send_frame(struct canfd_frame& cfd, const std::string& bus_name, socket_type type)
-{
- if(bus_name.empty())
- {
- return -1;
- }
-
- std::map<std::string, std::shared_ptr<low_can_subscription_t> >& cd = application_t::instance().get_can_devices();
-
- if( cd.count(bus_name) == 0)
- {
- cd[bus_name] = std::make_shared<low_can_subscription_t>(low_can_subscription_t());
- }
-
-
- if(type == socket_type::BCM)
- {
- return low_can_subscription_t::tx_send(*cd[bus_name], cfd, bus_name);
- }
- else if(type == socket_type::J1939)
- {
- return low_can_subscription_t::j1939_send(*cd[bus_name], cfd, bus_name);
- }
- else{
- return -1;
- }
-}
-*/
static int send_message(message_t *message, const std::string& bus_name, uint32_t flags, event_filter_t &event_filter, std::shared_ptr<signal_t> signal)
{
if(bus_name.empty())
can_bus_manager.start_threads();
utils::signals_manager_t& sm = utils::signals_manager_t::instance();
- // Add a recurring dignostic message request to get engine speed at all times.
- openxc_DynamicField search_key = build_DynamicField("diagnostic_messages.engine.speed");
- struct utils::signals_found sf = sm.find_signals(search_key);
-
- if(sf.signals.empty() && sf.diagnostic_messages.size() == 1)
+ if (application.get_diagnostic_manager().is_initialized())
{
- afb_req_t request = nullptr;
+ // Add a recurring dignostic message request to get engine speed at all times.
+ openxc_DynamicField search_key = build_DynamicField("diagnostic_messages.engine.speed");
+ struct utils::signals_found sf = sm.find_signals(search_key);
+
+ if(sf.signals.empty() && sf.diagnostic_messages.size() == 1)
+ {
+ afb_req_t request = nullptr;
- struct event_filter_t event_filter;
- event_filter.frequency = sf.diagnostic_messages.front()->get_frequency();
+ struct event_filter_t event_filter;
+ event_filter.frequency = sf.diagnostic_messages.front()->get_frequency();
- map_subscription& s = sm.get_subscribed_signals();
+ map_subscription& s = sm.get_subscribed_signals();
- subscribe_unsubscribe_diagnostic_messages(request, true, sf.diagnostic_messages, event_filter, s, true);
+ subscribe_unsubscribe_diagnostic_messages(request, true, sf.diagnostic_messages, event_filter, s, true);
+ }
}
-
#ifdef USE_FEATURE_J1939
std::string j1939_bus;
vect_ptr_msg_def_t current_messages_definition = application.get_messages_definition();