#include "application.hpp"
#include "../can/can-encoder.hpp"
#include "../can/can-bus.hpp"
-#include "../can/can-signals.hpp"
-#include "../can/can-message.hpp"
+#include "../can/signals.hpp"
+#include "../can/message/message.hpp"
#include "../utils/signals.hpp"
#include "../diagnostic/diagnostic-message.hpp"
#include "../utils/openxc-utils.hpp"
s.erase(it);
}
-static void push_n_notify(const can_message_t& cm)
+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(cm);
+ cbm.push_new_can_message(m);
}
cbm.get_new_can_message_cv().notify_one();
}
int read_message(sd_event_source *event_source, int fd, uint32_t revents, void *userdata)
{
low_can_subscription_t* can_subscription = (low_can_subscription_t*)userdata;
+
+
if ((revents & EPOLLIN) != 0)
{
- can_message_t cm;
- utils::socketcan_bcm_t& s = can_subscription->get_socket();
- s >> cm;
+ std::shared_ptr<utils::socketcan_t> s = can_subscription->get_socket();
+ std::shared_ptr<message_t> message = s->read_message();
// Sure we got a valid CAN message ?
- if(! cm.get_id() == 0 && ! cm.get_length() == 0)
- {push_n_notify(cm);}
+ if (! message->get_id() == 0 && ! message->get_length() == 0)
+ {
+ push_n_notify(message);
+ }
}
// check if error or hangup
if ((revents & (EPOLLERR|EPOLLRDHUP|EPOLLHUP)) != 0)
{
sd_event_source_unref(event_source);
- can_subscription->get_socket().close();
+ can_subscription->get_socket()->close();
}
+
return 0;
}
struct sd_event_source* event_source = nullptr;
return ( sd_event_add_io(afb_daemon_get_event_loop(),
&event_source,
- can_subscription->get_socket().socket(),
+ can_subscription->get_socket()->socket(),
EPOLLIN,
read_message,
can_subscription.get()));
return rets;
}
-static int subscribe_unsubscribe_can_signals(afb_req_t request,
+static int subscribe_unsubscribe_signals(afb_req_t request,
bool subscribe,
- std::vector<std::shared_ptr<can_signal_t> > can_signals,
+ std::vector<std::shared_ptr<signal_t> > signals,
struct event_filter_t& event_filter,
std::map<int, std::shared_ptr<low_can_subscription_t> >& s)
{
int rets = 0;
- for(const auto& sig: can_signals)
+ for(const auto& sig: signals)
{
auto it = std::find_if(s.begin(), s.end(), [&sig, &event_filter](std::pair<int, std::shared_ptr<low_can_subscription_t> > sub){ return sub.second->is_signal_subscription_corresponding(sig, event_filter) ; });
std::shared_ptr<low_can_subscription_t> can_subscription;
///
/// @param[in] afb_req request : contains original request use to subscribe or unsubscribe
/// @param[in] subscribe boolean value, which chooses between a subscription operation or an unsubscription
-/// @param[in] signals - struct containing vectors with can_signal_t and diagnostic_messages to subscribe
+/// @param[in] signals - struct containing vectors with signal_t and diagnostic_messages to subscribe
///
/// @return Number of correctly subscribed signal
///
std::map<int, std::shared_ptr<low_can_subscription_t> >& s = sm.get_subscribed_signals();
rets += subscribe_unsubscribe_diagnostic_messages(request, subscribe, signals.diagnostic_messages, event_filter, s, false);
- rets += subscribe_unsubscribe_can_signals(request, subscribe, signals.can_signals, event_filter, s);
+ rets += subscribe_unsubscribe_signals(request, subscribe, signals.signals, event_filter, s);
return rets;
}
// subscribe or unsubscribe
openxc_DynamicField search_key = build_DynamicField(tag);
sf = utils::signals_manager_t::instance().find_signals(search_key);
- if (sf.can_signals.empty() && sf.diagnostic_messages.empty())
+ if (sf.signals.empty() && sf.diagnostic_messages.empty())
{
AFB_NOTICE("No signal(s) found for %s.", tag.c_str());
ret = -1;
if( cd.count(bus_name) == 0)
{cd[bus_name] = std::make_shared<low_can_subscription_t>(low_can_subscription_t());}
- return cd[bus_name]->tx_send(cfd, bus_name);
+ return cd[bus_name]->tx_send(*cd[bus_name], cfd, bus_name);
}
static void write_raw_frame(afb_req_t request, const std::string& bus_name, json_object *json_value)
sf = utils::signals_manager_t::instance().find_signals(search_key);
openxc_DynamicField dynafield_value = build_DynamicField(json_value);
- if (sf.can_signals.empty())
+ if (sf.signals.empty())
{
afb_req_fail_f(request, "No signal(s) found for %s. Message not sent.", name.c_str());
return;
}
- std::shared_ptr<can_signal_t>& sig = sf.can_signals[0];
+ std::shared_ptr<signal_t>& sig = sf.signals[0];
if(! sig->get_writable())
{
afb_req_fail_f(request, "%s isn't writable. Message not sent.", sig->get_name().c_str());
openxc_DynamicField search_key = build_DynamicField(name);
sf = utils::signals_manager_t::instance().find_signals(search_key);
- if (sf.can_signals.empty())
+ if (sf.signals.empty())
{
AFB_WARNING("No signal(s) found for %s.", name.c_str());
return NULL;
}
ans = json_object_new_array();
- for(const auto& sig: sf.can_signals)
+ for(const auto& sig: sf.signals)
{
struct json_object *jobj = json_object_new_object();
json_object_object_add(jobj, "event", json_object_new_string(sig->get_name().c_str()));
openxc_DynamicField search_key = build_DynamicField(name);
sf = utils::signals_manager_t::instance().find_signals(search_key);
- if (sf.can_signals.empty() && sf.diagnostic_messages.empty())
+ if (sf.signals.empty() && sf.diagnostic_messages.empty())
{
AFB_WARNING("No signal(s) found for %s.", name.c_str());
return NULL;
}
ans = json_object_new_array();
- for(const auto& sig: sf.can_signals)
+ for(const auto& sig: sf.signals)
{
json_object_array_add(ans,
json_object_new_string(sig->get_name().c_str()));
openxc_DynamicField search_key = build_DynamicField("diagnostic_messages.engine.speed");
struct utils::signals_found sf = utils::signals_manager_t::instance().find_signals(search_key);
- if(sf.can_signals.empty() && sf.diagnostic_messages.size() == 1)
+ if(sf.signals.empty() && sf.diagnostic_messages.size() == 1)
{
afb_req_t request = nullptr;
Code Review / apps / agl-service-can-low-level.git / blobdiff