/*
* Copyright (C) 2015, 2018 "IoT.bzh"
+ * Copyright (C) 2021 Konsulko Group
* Author "Romain Forlot" <romain.forlot@iot.bzh>
* Author "Loic Collignon" <loic.collignon@iot.bzh>
*
#include <queue>
#include <mutex>
#include <vector>
+#include <set>
#include <thread>
#include <algorithm>
#include <wrap-json.h>
#include "../utils/signals.hpp"
#include "../diagnostic/diagnostic-message.hpp"
#include "../utils/openxc-utils.hpp"
-#include "../utils/signals.hpp"
+#include "../utils/config-parser.hpp"
#ifdef USE_FEATURE_J1939
#include "../can/message/j1939-message.hpp"
int config_low_can(afb_api_t apiHandle, CtlSectionT *section, json_object *json_obj)
{
AFB_DEBUG("Config %s", json_object_to_json_string(json_obj));
- CtlConfigT *ctrlConfig;
-
- ctrlConfig = (CtlConfigT *) afb_api_get_userdata(apiHandle);
- if(! ctrlConfig)
- return -1;
+ CtlConfigT *ctrlConfig = (CtlConfigT *) afb_api_get_userdata(apiHandle);
+ int active_message_set = 0;
+ json_object *dev_mapping = nullptr;
+ const char *diagnostic_bus = nullptr;
- if(! ctrlConfig->external)
+ if(! ctrlConfig || ! ctrlConfig->external)
return -1;
application_t *application = (application_t*) ctrlConfig->external;
- int active_message_set;
- json_object *dev_mapping = nullptr;
- const char *diagnotic_bus = nullptr;
+ if(wrap_json_unpack(json_obj, "{si, s?s}",
+ "active_message_set", &active_message_set,
+ "diagnostic_bus", &diagnostic_bus)) {
+ AFB_ERROR("active_message_set and/or diagnostic_bus missing in controller JSON");
+ return -1;
+ }
- if(wrap_json_unpack(json_obj, "{si, ss}",
- "active_message_set", &active_message_set,
- "diagnostic_bus", &diagnotic_bus))
+ if(active_message_set < 0 ||
+ active_message_set > (application->get_messages_definition().size() - 1)) {
+ AFB_ERROR("Invalid active message set %d", active_message_set);
return -1;
+ }
+ application->set_active_message_set((uint8_t) active_message_set);
+
+ utils::config_parser_t conf_file("/etc/dev-mapping.conf");
+ if(conf_file.check_conf())
+ {
+ // If a mapping file in /etc exists, use it
+ AFB_INFO("Using /etc/dev-mapping.conf");
+ application->get_can_bus_manager().set_can_devices(conf_file.get_devices_name());
+ } else {
+ // Use whatever configuration is in the controller JSON
+ if(wrap_json_unpack(json_obj, "{so}",
+ "dev-mapping", &dev_mapping)) {
+ AFB_ERROR("No device mapping in controller JSON");
+ return -1;
+ }
+
+ application->get_can_bus_manager().set_can_devices(dev_mapping);
+ }
+
+ // Find all required buses
+ std::set<std::string> buses;
+ std::set<std::string> j1939_buses;
+ vect_ptr_msg_def_t msg_defs = application->get_messages_definition();
+ for(std::shared_ptr<message_definition_t> &msg_def : msg_defs) {
+ if(!msg_def->is_j1939())
+ buses.insert(msg_def->get_bus_name());
+ else
+ j1939_buses.insert(msg_def->get_bus_name());
+ }
+#ifdef USE_FEATURE_J1939
+ // NOTE: With C++17 just: buses.merge(j1939_buses)
+ for(auto it = begin(j1939_buses); it != end(j1939_buses); ++it)
+ buses.insert(*it);
+#endif
- application->set_active_message_set((uint8_t)active_message_set);
+ // Check that required buses have device mappings
+ for(auto it = begin(buses); it != end(buses); ++it) {
+ std::string dev = application->get_can_bus_manager().get_can_device_name(*it);
+ if(dev == "") {
+ AFB_ERROR("No CAN device defined for bus \"%s\"", it->c_str());
+ return -1;
+ }
+ AFB_INFO("Using CAN device %s for bus \"%s\"", dev.c_str(), it->c_str());
+ }
- if(wrap_json_unpack(json_obj, "{so}",
- "dev-mapping", &dev_mapping))
+ // Check that diagnostic bus is one of the configured buses
+ if(diagnostic_bus && buses.count(diagnostic_bus) == 0) {
+ AFB_ERROR("No CAN device mapping defined for diagnostic bus \"%s\"", diagnostic_bus);
return -1;
- application->get_can_bus_manager().set_can_devices(dev_mapping);
+ }
/// 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(! diagnostic_bus || application_t::instance().get_diagnostic_manager().initialize(diagnostic_bus))
+ AFB_WARNING("Diagnostic Manager: not initialized. No diagnostic messages will be processed.");
return 0;
}
CtlSectionT ctlSections_[] = {
- [0]={.key="config" , .uid="config", .info=nullptr,
- .loadCB=config_low_can,
- .handle=nullptr,
- .actions=nullptr},
- [1]={.key="plugins" , .uid="plugins", .info=nullptr,
+ [0]={.key="plugins" , .uid="plugins", .info=nullptr,
.loadCB=PluginConfig,
.handle=nullptr,
.actions=nullptr},
+ [1]={.key="config" , .uid="config", .info=nullptr,
+ .loadCB=config_low_can,
+ .handle=nullptr,
+ .actions=nullptr},
[2]={.key=nullptr , .uid=nullptr, .info=nullptr,
.loadCB=nullptr,
.handle=nullptr,
* subsciptions.
*/
if(! request)
- {
return 0;
- }
// Event doesn't exist , so let's create it
if ((ret = can_subscription->subscribe(request)) < 0)
event_filter.frequency = event_filter.frequency == 0 ? sig->get_frequency() : event_filter.frequency;
std::shared_ptr<low_can_subscription_t> can_subscription;
- auto it = std::find_if(s.begin(), s.end(), [&sig](std::pair<int, std::shared_ptr<low_can_subscription_t> > sub)
+ auto it = std::find_if(s.begin(), s.end(), [&sig](std::pair<int, std::shared_ptr<low_can_subscription_t> > sub)
{
return (! sub.second->get_diagnostic_message().empty());
});
static event_filter_t generate_filter(json_object* args)
{
- event_filter_t event_filter;
+ event_filter_t event_filter = {};
struct json_object *filter, *obj;
// computes the filter
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())
message->set_maxdlen(J1939_MAX_DLEN);
#endif
- if(message->get_length() > 0 && message->get_length() <= message->get_maxdlen())
+ if(message->get_length() > 0 &&
+ message->get_length() <= message->get_maxdlen() &&
+ json_object_get_type(can_data) == json_type_array)
{
std::vector<uint8_t> data;
for (int i = 0 ; i < message->get_length() ; i++)
return ans;
}
+
+static struct json_object *get_id_value(const uint32_t& id)
+{
+ std::shared_ptr<message_definition_t> message_definition = application_t::instance().get_message_definition(id);
+ struct utils::signals_found sf;
+ struct json_object *ans = nullptr;
+
+ if(message_definition)
+ sf.signals = list_ptr_signal_t(message_definition->get_signals().begin(), message_definition->get_signals().end());
+
+ if(sf.signals.empty())
+ {
+ AFB_WARNING("no signal(s) found for %d.", id);
+ return NULL;
+ }
+
+ ans = json_object_new_object();
+ struct json_object *jsignals = json_object_new_array();
+ json_object_object_add(ans, "signals", jsignals);
+ for(const auto& sig: sf.signals)
+ {
+ struct json_object *jobj = json_object_new_object();
+ json_object_object_add(jobj, "name", json_object_new_string(sig->get_name().c_str()));
+ json_object_object_add(jobj, "value", json_object_new_double(sig->get_last_value()));
+ json_object_array_add(jsignals, jobj);
+ }
+
+ return ans;
+}
+
void get(afb_req_t request)
{
int rc = 0;
if (!ans)
rc = -1;
}
+ else if (args != nullptr &&
+ (json_object_object_get_ex(args, "id", &json_name)))
+ {
+ if (json_object_get_type(json_name) == json_type_string) // id is set before and check if it's an array
+ {
+ ans = get_id_value(json_object_get_int(json_name));
+ }
+ else if(json_object_get_type(json_name) == json_type_array)
+ {
+ ans = json_object_new_array();
+ for (int i = 0 ; i < json_object_array_length(json_name); i++)
+ {
+ json_object *sub_ans = nullptr;
+ json_object *x = json_object_array_get_idx(json_name, i);
+ sub_ans = get_id_value(json_object_get_int(x));
+ if(!sub_ans)
+ rc = -1;
+ else {
+ struct json_object *jobj = json_object_new_object();
+ struct json_object *jid = json_object_new_string(json_object_get_string(x));
+ json_object_object_add(jobj, "id", jid);
+ json_object_object_add(jobj, "data", sub_ans);
+ json_object_array_add(ans, jobj);
+ }
+ }
+ }
+ else
+ rc = -1;
+ if (!ans)
+ rc = -1;
+ }
else
{
AFB_ERROR("Request argument malformed. Please use the following syntax:");
/// @return Exit code, zero if success.
int init_binding(afb_api_t api)
{
- int ret = 1;
+ int ret = 0;
application_t& application = application_t::instance();
can_bus_t& can_bus_manager = application.get_can_bus_manager();
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);
- struct event_filter_t event_filter;
- event_filter.frequency = sf.diagnostic_messages.front()->get_frequency();
+ if(sf.signals.empty() && sf.diagnostic_messages.size() == 1)
+ {
+ afb_req_t request = nullptr;
- map_subscription& s = sm.get_subscribed_signals();
+ struct event_filter_t event_filter;
+ event_filter.frequency = sf.diagnostic_messages.front()->get_frequency();
- subscribe_unsubscribe_diagnostic_messages(request, true, sf.diagnostic_messages, event_filter, s, true);
- }
+ map_subscription& s = sm.get_subscribed_signals();
+ subscribe_unsubscribe_diagnostic_messages(request, true, sf.diagnostic_messages, event_filter, s, true);
+ }
+ }
#ifdef USE_FEATURE_J1939
std::string j1939_bus;
if (!configPath)
{
- AFB_ERROR_V3("CtlPreInit: No control-* config found invalid JSON %s ", filepath.c_str());
+ AFB_ERROR_V3("CtlPreInit: No control-%s* config found invalid JSON %s ", GetBinderName(), filepath.c_str());
return -1;
}
Code Review / apps / agl-service-can-low-level.git / blobdiff