#include <mutex>
#include <vector>
#include <thread>
+#include <algorithm>
#include <wrap-json.h>
#include <systemd/sd-event.h>
+#include <ctl-config.h>
#include "openxc.pb.h"
#include "application.hpp"
#include "../can/can-encoder.hpp"
#include "../can/message/j1939-message.hpp"
#include <linux/can/j1939.h>
#endif
-///******************************************************************************
+
+///*****************************************************************************
///
-/// SystemD event loop Callbacks
+/// Controller Definitions and Callbacks
///
-///*******************************************************************************/
-
-void on_no_clients(std::shared_ptr<low_can_subscription_t> can_subscription, uint32_t pid, map_subscription& s)
-{
- bool is_permanent_recurring_request = false;
-
- if( ! can_subscription->get_diagnostic_message().empty() && can_subscription->get_diagnostic_message(pid) != nullptr)
- {
- DiagnosticRequest diag_req = can_subscription->get_diagnostic_message(pid)->build_diagnostic_request();
- active_diagnostic_request_t* adr = application_t::instance().get_diagnostic_manager().find_recurring_request(diag_req);
- if( adr != nullptr)
- {
- is_permanent_recurring_request = adr->get_permanent();
-
- if(! is_permanent_recurring_request)
- application_t::instance().get_diagnostic_manager().cleanup_request(adr, true);
- }
- }
-
- if(! is_permanent_recurring_request)
- on_no_clients(can_subscription, s);
-}
+///****************************************************************************/
-void on_no_clients(std::shared_ptr<low_can_subscription_t> can_subscription, map_subscription& s)
+int config_low_can(afb_api_t apiHandle, CtlSectionT *section, json_object *json_obj)
{
- auto it = s.find(can_subscription->get_index());
- s.erase(it);
-}
+ AFB_DEBUG("Config %s", json_object_to_json_string(json_obj));
+ CtlConfigT *ctrlConfig = (CtlConfigT *) afb_api_get_userdata(apiHandle);
+ int active_message_set = 0;
+ json_object *dev_mapping = nullptr;
+ const char *diagnotic_bus = nullptr;
-static void push_n_notify(std::shared_ptr<message_t> m)
-{
- can_bus_t& cbm = application_t::instance().get_can_bus_manager();
- {
- std::lock_guard<std::mutex> can_message_lock(cbm.get_can_message_mutex());
- cbm.push_new_can_message(m);
- }
- cbm.get_new_can_message_cv().notify_one();
-}
+ if(! ctrlConfig || ! ctrlConfig->external)
+ return -1;
-int read_message(sd_event_source *event_source, int fd, uint32_t revents, void *userdata)
-{
+ application_t *application = (application_t*) ctrlConfig->external;
- low_can_subscription_t* can_subscription = (low_can_subscription_t*)userdata;
+ if(wrap_json_unpack(json_obj, "{si, s?s}",
+ "active_message_set", &active_message_set,
+ "diagnostic_bus", &diagnotic_bus))
+ return -1;
+ application->set_active_message_set((uint8_t)active_message_set);
- if ((revents & EPOLLIN) != 0)
- {
- utils::signals_manager_t& sm = utils::signals_manager_t::instance();
- std::lock_guard<std::mutex> subscribed_signals_lock(sm.get_subscribed_signals_mutex());
- if(can_subscription->get_index() != -1)
- {
- std::shared_ptr<utils::socketcan_t> s = can_subscription->get_socket();
- if(s->socket() && s->socket() != -1)
- {
- std::shared_ptr<message_t> message = s->read_message();
+ if(wrap_json_unpack(json_obj, "{so}",
+ "dev-mapping", &dev_mapping))
+ return -1;
- // Sure we got a valid CAN message ?
- if (! message->get_id() == 0 && ! message->get_length() == 0 && !(message->get_flags()&INVALID_FLAG))
- {
- push_n_notify(message);
- }
- }
- }
- }
+ application->get_can_bus_manager().set_can_devices(dev_mapping);
- // check if error or hangup
- if ((revents & (EPOLLERR | EPOLLRDHUP | EPOLLHUP)) != 0)
- {
- sd_event_source_unref(event_source);
- can_subscription->get_socket()->close();
- }
+ /// Initialize Diagnostic manager that will handle obd2 requests.
+ /// We pass by default the first CAN bus device to its Initialization.
+ if(! diagnotic_bus || application_t::instance().get_diagnostic_manager().initialize(diagnotic_bus))
+ AFB_WARNING("Diagnostic Manager: not initialized");
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,
+ .loadCB=PluginConfig,
+ .handle=nullptr,
+ .actions=nullptr},
+ [2]={.key=nullptr , .uid=nullptr, .info=nullptr,
+ .loadCB=nullptr,
+ .handle=nullptr,
+ .actions=nullptr},
+};
+
+///*****************************************************************************
///
/// Subscription and unsubscription
///
-///*******************************************************************************/
+///****************************************************************************/
/// @brief This will determine if an event handle needs to be created and checks if
/// we got a valid afb_event to get subscribe or unsubscribe. After that launch the subscription or unsubscription
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());
});
// 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);
}
cd[bus_name]->set_signal(signal);
- if(flags&BCM_PROTOCOL)
+ if(flags&CAN_PROTOCOL)
return low_can_subscription_t::tx_send(*cd[bus_name], message, bus_name);
#ifdef USE_FEATURE_ISOTP
else if(flags&ISOTP_PROTOCOL)
if( !sf.signals.empty() )
{
AFB_DEBUG("ID WRITE RAW : %d", sf.signals.front()->get_message()->get_id());
- if(flags & BCM_PROTOCOL)
+ if(flags & CAN_PROTOCOL)
{
if(sf.signals.front()->get_message()->is_fd())
{
AFB_DEBUG("CANFD_MAX_DLEN");
- message->set_flags(CAN_FD_FRAME);
+ message->set_flags(CAN_PROTOCOL_WITH_FD_FRAME);
message->set_maxdlen(CANFD_MAX_DLEN);
}
else
}
else
{
- if(flags&BCM_PROTOCOL)
+ if(flags&CAN_PROTOCOL)
afb_req_fail(request, "Invalid", "Frame BCM");
else if(flags&J1939_PROTOCOL)
afb_req_fail(request, "Invalid", "Frame J1939");
"can_data", &can_data))
{
message = new can_message_t(0, id, length, false, 0, data, 0);
- write_raw_frame(request, bus_name, message, can_data, BCM_PROTOCOL, event_filter);
+ write_raw_frame(request, bus_name, message, can_data, CAN_PROTOCOL, event_filter);
}
#ifdef USE_FEATURE_J1939
else if(!wrap_json_unpack(json_value, "{si, si, so !}",
else if(sig->get_message()->is_isotp())
flags = ISOTP_PROTOCOL;
else
- flags = BCM_PROTOCOL;
+ flags = CAN_PROTOCOL;
// cfd = encoder_t::build_frame(sig, value);
message_t *message = encoder_t::build_message(sig, value, false, false);
/// @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.set_can_devices();
+ if(application.get_message_set().empty())
+ {
+ AFB_ERROR("No message_set defined");
+ return -1;
+ }
+
can_bus_manager.start_threads();
utils::signals_manager_t& sm = utils::signals_manager_t::instance();
- /// Initialize Diagnostic manager that will handle obd2 requests.
- /// We pass by default the first CAN bus device to its Initialization.
- /// TODO: be able to choose the CAN bus device that will be use as Diagnostic bus.
- if(application_t::instance().get_diagnostic_manager().initialize())
- ret = 0;
-
- // 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;
return ret;
}
+
+int load_config(afb_api_t api)
+{
+ int ret = 0;
+ CtlConfigT *ctlConfig;
+ const char *dirList = getenv("CONTROL_CONFIG_PATH");
+ std::string bindingDirPath = GetBindingDirPath(api);
+ std::string filepath = bindingDirPath + "/etc";
+
+ if (!dirList)
+ dirList=CONTROL_CONFIG_PATH;
+
+ filepath.append(":");
+ filepath.append(dirList);
+ const char *configPath = CtlConfigSearch(api, filepath.c_str(), "control");
+
+ if (!configPath)
+ {
+ AFB_ERROR_V3("CtlPreInit: No control-%s* config found invalid JSON %s ", GetBinderName(), filepath.c_str());
+ return -1;
+ }
+
+ // create one API per file
+ ctlConfig = CtlLoadMetaData(api, configPath);
+ if (!ctlConfig)
+ {
+ AFB_ERROR_V3("CtrlPreInit No valid control config file in:\n-- %s", configPath);
+ return -1;
+ }
+
+ // Save the config in the api userdata field
+ afb_api_set_userdata(api, ctlConfig);
+
+ setExternalData(ctlConfig, (void*) &application_t::instance());
+ ret= CtlLoadSections(api, ctlConfig, ctlSections_);
+
+ return ret;
+}
Code Review / apps / agl-service-can-low-level.git / blobdiff