binding/${TARGET_NAME}-subscription.cpp
binding/application.cpp
can/can-bus.cpp
- can/can-message-set.cpp
- can/can-message-definition.cpp
+ can/message-set.cpp
+ can/message-definition.cpp
can/message/message.cpp
can/message/can-message.cpp
- can/can-signals.cpp
+ can/signals.cpp
can/can-decoder.cpp
can/can-encoder.cpp
diagnostic/diagnostic-message.cpp
application_t::application_t()
: can_bus_manager_{utils::config_parser_t{"/etc/dev-mapping.conf"}}
- , can_message_set_{
- {std::make_shared<can_message_set_t>(can_message_set_t{0,"AGL Virtual Car",
+ , message_set_{
+ {std::make_shared<message_set_t>(message_set_t{0,"AGL Virtual Car",
{ // beginning can_message_definition_ vector
- {std::make_shared<can_message_definition_t>(can_message_definition_t{
+ {std::make_shared<message_definition_t>(message_definition_t{
"ls",
0x30,
false,
- can_message_format_t::EXTENDED,
+ message_format_t::EXTENDED,
frequency_clock_t(5.00000f),
true,
{ // beginning can_signals vector
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"hvac.fan.speed",
32,
8,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"hvac.temperature.left",
0,
8,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"hvac.temperature.right",
8,
8,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"hvac.temperature.average",
16,
8,
})}
} // end can_signals vector
})} // end can_message_definition entry
-, {std::make_shared<can_message_definition_t>(can_message_definition_t{
+, {std::make_shared<message_definition_t>(message_definition_t{
"hs",
0x3D9,
true,
- can_message_format_t::STANDARD,
+ message_format_t::STANDARD,
frequency_clock_t(5.00000f),
true,
{ // beginning can_signals vector
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"engine.speed",
16,
16,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"fuel.level.low",
55,
1,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"fuel.level",
8,
8,
})}
} // end can_signals vector
})} // end can_message_definition entry
-, {std::make_shared<can_message_definition_t>(can_message_definition_t{
+, {std::make_shared<message_definition_t>(message_definition_t{
"hs",
0x3E9,
false,
- can_message_format_t::EXTENDED,
+ message_format_t::EXTENDED,
frequency_clock_t(5.00000f),
true,
{ // beginning can_signals vector
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"vehicle.average.speed",
0,
15,
})}
} // end can_signals vector
})} // end can_message_definition entry
-, {std::make_shared<can_message_definition_t>(can_message_definition_t{
+, {std::make_shared<message_definition_t>(message_definition_t{
"hs",
0x4D1,
false,
- can_message_format_t::STANDARD,
+ message_format_t::STANDARD,
frequency_clock_t(5.00000f),
true,
{ // beginning can_signals vector
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"engine.oil.temp",
16,
8,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"engine.oil.temp.high",
7,
1,
})}
} // end can_signals vector
})} // end can_message_definition entry
-, {std::make_shared<can_message_definition_t>(can_message_definition_t{
+, {std::make_shared<message_definition_t>(message_definition_t{
"hs",
0x5D1,
false,
- can_message_format_t::STANDARD,
+ message_format_t::STANDARD,
frequency_clock_t(5.00000f),
true,
{ // beginning can_signals vector
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"accelerator.pedal.position",
16,
8,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"steering.wheel.angle",
4,
12,
})}
} // end can_signals vector
})} // end can_message_definition entry
-, {std::make_shared<can_message_definition_t>(can_message_definition_t{
+, {std::make_shared<message_definition_t>(message_definition_t{
"hs",
0x5D2,
false,
- can_message_format_t::STANDARD,
+ message_format_t::STANDARD,
frequency_clock_t(5.00000f),
true,
{ // beginning can_signals vector
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"transmission.gearinfo",
20,
4,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"transmission.mode",
16,
4,
})}
} // end can_signals vector
})} // end can_message_definition entry
-, {std::make_shared<can_message_definition_t>(can_message_definition_t{
+, {std::make_shared<message_definition_t>(message_definition_t{
"hs",
0x5D3,
false,
- can_message_format_t::STANDARD,
+ message_format_t::STANDARD,
frequency_clock_t(5.00000f),
true,
{ // beginning can_signals vector
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"turnsignal.status",
26,
3,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"lightstatus.brake",
7,
1,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"parking.brake.status",
8,
1,
})}
} // end can_signals vector
})} // end can_message_definition entry
-, {std::make_shared<can_message_definition_t>(can_message_definition_t{
+, {std::make_shared<message_definition_t>(message_definition_t{
"hs",
0x620,
false,
- can_message_format_t::STANDARD,
+ message_format_t::STANDARD,
frequency_clock_t(5.00000f),
true,
{ // beginning can_signals vector
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"doors.boot.open",
47,
1,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"doors.front_left.open",
43,
1,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"doors.front_right.open",
44,
1,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"doors.rear_left.open",
46,
1,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"doors.rear_right.open",
45,
4,
})}
} // end can_signals vector
})} // end can_message_definition entry
-, {std::make_shared<can_message_definition_t>(can_message_definition_t{
+, {std::make_shared<message_definition_t>(message_definition_t{
"hs",
0x799,
false,
- can_message_format_t::STANDARD,
+ message_format_t::STANDARD,
frequency_clock_t(5.00000f),
true,
{ // beginning can_signals vector
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"windows.front_left.open",
43,
1,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"windows.front_right.open",
44,
1,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"windows.rear_left.open",
46,
1,
nullptr,
false
})},
- {std::make_shared<can_signal_t> (can_signal_t{
+ {std::make_shared<signal_t> (signal_t{
"windows.rear_right.open",
45,
4,
})} // end can_message_set entry
} // end can_message_set vector
{
- for(auto& cms: can_message_set_)
+ for(auto& cms: message_set_)
{
- std::vector<std::shared_ptr<can_message_definition_t> >& can_messages_definition = cms->get_can_message_definition();
+ std::vector<std::shared_ptr<message_definition_t> >& can_messages_definition = cms->get_messages_definition();
for(auto& cmd : can_messages_definition)
{
- cmd->set_parent(cms.get());
- std::vector<std::shared_ptr<can_signal_t> >& can_signals = cmd->get_can_signals();
+ cmd->set_parent(cms);
+ std::vector<std::shared_ptr<signal_t> >& can_signals = cmd->get_signals();
for(auto& sig: can_signals)
{
- sig->set_parent(cmd.get());
+ sig->set_parent(cmd);
}
}
return active_message_set_;
}
-std::vector<std::shared_ptr<can_message_set_t> > application_t::get_can_message_set()
+std::vector<std::shared_ptr<message_set_t> > application_t::get_message_set()
{
- return can_message_set_;
+ return message_set_;
}
-std::vector<std::shared_ptr<can_signal_t> > application_t::get_all_can_signals()
+std::vector<std::shared_ptr<signal_t> > application_t::get_all_signals()
{
- return can_message_set_[active_message_set_]->get_all_can_signals();
+ return message_set_[active_message_set_]->get_all_signals();
}
-std::vector<std::shared_ptr<diagnostic_message_t> >& application_t::get_diagnostic_messages()
+std::vector<std::shared_ptr<diagnostic_message_t> > application_t::get_diagnostic_messages()
{
- return can_message_set_[active_message_set_]->get_diagnostic_messages();
+ return message_set_[active_message_set_]->get_diagnostic_messages();
}
-std::vector<std::shared_ptr<can_message_definition_t> >& application_t::get_can_message_definition()
+std::vector<std::shared_ptr<message_definition_t>> application_t::get_messages_definition()
{
- return can_message_set_[active_message_set_]->get_can_message_definition();
+ return message_set_[active_message_set_]->get_messages_definition();
}
uint32_t application_t::get_signal_id(diagnostic_message_t& sig) const
return sig.get_pid();
}
-uint32_t application_t::get_signal_id(can_signal_t& sig) const
+uint32_t application_t::get_signal_id(signal_t& sig) const
{
return sig.get_message()->get_id();
}
bool engine_on = false;
uint64_t last_timestamp_in_s;
- if(sf.can_signals.size() == 1)
+ if(sf.signals.size() == 1)
{
- last_timestamp_in_s = sf.can_signals.front()->get_last_value_with_timestamp().second
+ last_timestamp_in_s = sf.signals.front()->get_last_value_with_timestamp().second
/ MICROSECONDS_IN_SECOND;
- if(sf.can_signals.front()->get_last_value_with_timestamp().first > 0 &&
+ if(sf.signals.front()->get_last_value_with_timestamp().first > 0 &&
std::difftime(std::time(nullptr), last_timestamp_in_s) < ENGINE_VALUE_TIMEOUT)
{
engine_on = true;
#include <memory>
#include "../can/can-bus.hpp"
-#include "../can/can-message-set.hpp"
-#include "../can/can-signals.hpp"
+#include "../can/message-set.hpp"
+#include "../can/signals.hpp"
#include "../diagnostic/diagnostic-manager.hpp"
///
diagnostic_manager_t diagnostic_manager_; ///< Diagnostic manager use to manage diagnostic message communication.
uint8_t active_message_set_ = 0; ///< Which is the active message set ? Default to 0.
- std::vector<std::shared_ptr<can_message_set_t> > can_message_set_; ///< Vector holding all message set from JSON signals description file
+ std::vector<std::shared_ptr<message_set_t> > message_set_; ///< Vector holding all message set from JSON signals description file
std::map<std::string, std::shared_ptr<low_can_subscription_t> > can_devices_; ///< Map containing all independant opened CAN sockets, key is the socket int value.
uint8_t get_active_message_set() const;
- std::vector<std::shared_ptr<can_message_set_t> > get_can_message_set();
+ std::vector<std::shared_ptr<message_set_t> > get_message_set();
- std::vector<std::shared_ptr<can_signal_t> > get_all_can_signals();
+ std::vector<std::shared_ptr<signal_t> > get_all_signals();
- std::vector<std::shared_ptr<diagnostic_message_t> >& get_diagnostic_messages();
+ std::vector<std::shared_ptr<diagnostic_message_t> > get_diagnostic_messages();
const std::vector<std::string>& get_signals_prefix() const;
- std::vector<std::shared_ptr<can_message_definition_t> >& get_can_message_definition();
+ std::vector<std::shared_ptr<message_definition_t> > get_messages_definition();
uint32_t get_signal_id(diagnostic_message_t& sig) const;
- uint32_t get_signal_id(can_signal_t& sig) const;
+ uint32_t get_signal_id(signal_t& sig) const;
bool isEngineOn();
#include "application.hpp"
#include "../can/can-encoder.hpp"
#include "../can/can-bus.hpp"
-#include "../can/can-signals.hpp"
+#include "../can/signals.hpp"
#include "../can/message/message.hpp"
#include "../utils/signals.hpp"
#include "../diagnostic/diagnostic-message.hpp"
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;
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;
low_can_subscription_t::operator bool() const
{
- return ((can_signal_ != nullptr || ! diagnostic_message_.empty()) && ! socket_);
+ return ((signal_ != nullptr || ! diagnostic_message_.empty()) && ! socket_);
}
afb_event_t low_can_subscription_t::get_event()
{
return index_;
}
-const std::shared_ptr<can_signal_t> low_can_subscription_t::get_can_signal() const
+const std::shared_ptr<signal_t> low_can_subscription_t::get_signal() const
{
- return can_signal_;
+ return signal_;
}
-bool low_can_subscription_t::is_signal_subscription_corresponding(const std::shared_ptr<can_signal_t> can_signal, const struct event_filter_t& event_filter) const
+bool low_can_subscription_t::is_signal_subscription_corresponding(const std::shared_ptr<signal_t> signal, const struct event_filter_t& event_filter) const
{
- return can_signal_ == can_signal && event_filter_ == event_filter;
+ return signal_ == signal && event_filter_ == event_filter;
}
const std::vector<std::shared_ptr<diagnostic_message_t> > low_can_subscription_t::get_diagnostic_message() const
/// or no CAN signal subscribed
const std::string low_can_subscription_t::get_name() const
{
- if (can_signal_ != nullptr)
- return can_signal_->get_name();
+ if (signal_ != nullptr)
+ return signal_->get_name();
else if (!diagnostic_message_.empty())
return "diagnostic_messages";
int ret = 0;
if(! socket_)
{
- if( can_signal_ != nullptr)
- {ret = socket_->open(can_signal_->get_message()->get_bus_device_name());}
+ if( signal_ != nullptr)
+ {ret = socket_->open(signal_->get_message()->get_bus_device_name());}
else if (! diagnostic_message_ .empty())
{ret = socket_->open(application_t::instance().get_diagnostic_manager().get_bus_device_name());}
else if ( ! bus_name.empty())
}
#ifdef USE_FEATURE_J1939
-int low_can_subscription_t::create_rx_filter_j1939(low_can_subscription_t &subscription, std::shared_ptr<can_signal_t> sig)
+int low_can_subscription_t::create_rx_filter_j1939(low_can_subscription_t &subscription, std::shared_ptr<signal_t> sig)
{
- subscription.can_signal_= sig;
+ subscription.signal_= sig;
// Make sure that socket is opened.
if(subscription.open_socket() < 0)
/// subscription
///
/// @return 0 if ok else -1
-int low_can_subscription_t::create_rx_filter_can(low_can_subscription_t &subscription, std::shared_ptr<can_signal_t> sig)
+int low_can_subscription_t::create_rx_filter_can(low_can_subscription_t &subscription, std::shared_ptr<signal_t> sig)
{
uint32_t flags;
float val;
struct timeval freq, timeout = {0, 0};
struct canfd_frame cfd;
- subscription.can_signal_= sig;
+ subscription.signal_= sig;
if (sig->get_message()->is_fd())
{
flags = SETTIMER|RX_NO_AUTOTIMER;
cfd.len = CAN_MAX_DLEN;
}
- val = (float)(1 << subscription.can_signal_->get_bit_size()) - 1;
+ val = (float)(1 << subscription.signal_->get_bit_size()) - 1;
if(! bitfield_encode_float(val,
- subscription.can_signal_->get_bit_position(),
- subscription.can_signal_->get_bit_size(),
+ subscription.signal_->get_bit_position(),
+ subscription.signal_->get_bit_size(),
1,
- subscription.can_signal_->get_offset(),
+ subscription.signal_->get_offset(),
cfd.data,
cfd.len))
return -1;
- frequency_clock_t f = subscription.event_filter_.frequency == 0 ? subscription.can_signal_->get_frequency() : frequency_clock_t(subscription.event_filter_.frequency);
+ frequency_clock_t f = subscription.event_filter_.frequency == 0 ? subscription.signal_->get_frequency() : frequency_clock_t(subscription.event_filter_.frequency);
freq = f.get_timeval_from_period();
- struct bcm_msg bcm_msg = subscription.make_bcm_head(RX_SETUP, subscription.can_signal_->get_message()->get_id(), flags, timeout, freq);
+ struct bcm_msg bcm_msg = subscription.make_bcm_head(RX_SETUP, subscription.signal_->get_message()->get_id(), flags, timeout, freq);
subscription.add_one_bcm_frame(cfd, bcm_msg);
return create_rx_filter_bcm(subscription, bcm_msg);
}
-int low_can_subscription_t::create_rx_filter(std::shared_ptr<can_signal_t> sig)
+int low_can_subscription_t::create_rx_filter(std::shared_ptr<signal_t> sig)
{
#ifdef USE_FEATURE_J1939
if(sig->get_message()->is_j1939())
#include <cmath>
#include <utility>
-#include "../can/can-signals.hpp"
+#include "../can/signals.hpp"
#include "../diagnostic/diagnostic-message.hpp"
#include "../utils/socketcan-bcm.hpp"
afb_event_t event_; ///< event_ - application framework event used to push on client
/// Signal part
- std::shared_ptr<can_signal_t> can_signal_; ///< can_signal_ - the CAN signal subscribed
+ std::shared_ptr<signal_t> signal_; ///< signal_ - the CAN signal subscribed
std::vector<std::shared_ptr<diagnostic_message_t> > diagnostic_message_; ///< diagnostic_message_ - diagnostic messages meant to receive OBD2
/// responses. Normal diagnostic request and response are not tested for now.
std::shared_ptr<utils::socketcan_t> socket_; ///< socket_ - socket_ that receives CAN messages.
int unsubscribe(afb_req_t request);
int get_index() const;
- const std::shared_ptr<can_signal_t> get_can_signal() const;
- bool is_signal_subscription_corresponding(const std::shared_ptr<can_signal_t>, const struct event_filter_t& event_filter) const;
+ const std::shared_ptr<signal_t> get_signal() const;
+ bool is_signal_subscription_corresponding(const std::shared_ptr<signal_t>, const struct event_filter_t& event_filter) const;
const std::shared_ptr<diagnostic_message_t> get_diagnostic_message(uint32_t pid) const;
const std::vector<std::shared_ptr<diagnostic_message_t> > get_diagnostic_message() const;
const std::shared_ptr<diagnostic_message_t> get_diagnostic_message(const std::string& name) const;
int open_socket(const std::string& bus_name = "");
- int create_rx_filter(std::shared_ptr<can_signal_t> sig);
+ int create_rx_filter(std::shared_ptr<signal_t> sig);
int create_rx_filter(std::shared_ptr<diagnostic_message_t> sig);
- static int create_rx_filter_can(low_can_subscription_t &subscription, std::shared_ptr<can_signal_t> sig);
- static int create_rx_filter_j1939(low_can_subscription_t &subscription, std::shared_ptr<can_signal_t> sig);
+ static int create_rx_filter_can(low_can_subscription_t &subscription, std::shared_ptr<signal_t> sig);
+ static int create_rx_filter_j1939(low_can_subscription_t &subscription, std::shared_ptr<signal_t> sig);
static int create_rx_filter_bcm(low_can_subscription_t &subscription, struct bcm_msg& bcm_msg);
static int tx_send(low_can_subscription_t &subscription, struct canfd_frame& cfd, const std::string& bus_name);
#include "can-bus.hpp"
-#include "can-signals.hpp"
+#include "signals.hpp"
#include "can-decoder.hpp"
#include "../binding/application.hpp"
#include "../utils/signals.hpp"
/// @param[in] can_message - a single CAN message from the CAN socket read, to be decode.
///
/// @return How many signals has been decoded.
-void can_bus_t::process_signals(const message_t& message, std::map<int, std::shared_ptr<low_can_subscription_t> >& s)
+void can_bus_t::process_signals(std::shared_ptr<message_t> message, std::map<int, std::shared_ptr<low_can_subscription_t> >& s)
{
- int subscription_id = message.get_sub_id();
+ int subscription_id = message->get_sub_id();
openxc_DynamicField decoded_message;
openxc_VehicleMessage vehicle_message;
if( s.find(subscription_id) != s.end() && afb_event_is_valid(s[subscription_id]->get_event()))
{
bool send = true;
- // First we have to found which can_signal_t it is
+ // First we have to found which signal_t it is
std::shared_ptr<low_can_subscription_t> sig = s[subscription_id];
- decoded_message = decoder_t::translate_signal(*sig->get_can_signal(), message, &send);
+ decoded_message = decoder_t::translate_signal(*sig->get_signal(), message, &send);
openxc_SimpleMessage s_message = build_SimpleMessage(sig->get_name(), decoded_message);
- vehicle_message = build_VehicleMessage(s_message, message.get_timestamp());
+ vehicle_message = build_VehicleMessage(s_message, message->get_timestamp());
if(send && apply_filter(vehicle_message, sig))
{
process_diagnostic_signals(application_t::instance().get_diagnostic_manager(), message, s);
}
else
- {process_signals(*message, s);}
+ {process_signals(message, s);}
}
can_message_lock.lock();
}
utils::config_parser_t conf_file_; ///< configuration file handle used to initialize can_bus_dev_t objects.
bool apply_filter(const openxc_VehicleMessage& vehicle_message, std::shared_ptr<low_can_subscription_t> can_subscription);
- void process_signals(const message_t& message, std::map<int, std::shared_ptr<low_can_subscription_t> >& s);
- void process_diagnostic_signals(diagnostic_manager_t& manager, std::shared_ptr<message_t> message, std::map<int, std::shared_ptr<low_can_subscription_t> >& s);
+ void process_signals(std::shared_ptr<message_t> message, std::map<int, std::shared_ptr<low_can_subscription_t> >& s);
+ void process_diagnostic_signals(diagnostic_manager_t& manager, std::shared_ptr<message_t> can_message, std::map<int, std::shared_ptr<low_can_subscription_t> >& s);
void can_decode_message();
std::thread th_decoding_; ///< thread that will handle decoding a can frame
#pragma once
#include "openxc.pb.h"
-#include "can-signals.hpp"
+#include "signals.hpp"
///
/// @brief The type signature for a function to handle a custom OpenXC command.
/// @param[in] signalCount - The length of the signals array.
///
typedef void (*CommandHandler)(const char* name, openxc_DynamicField* value,
- openxc_DynamicField* event, can_signal_t* signals, int signalCount);
+ openxc_DynamicField* event, signal_t* signals, int signalCount);
/// @struct CanCommand
/// @brief The structure to represent a supported custom OpenXC command.
#include "canutil/read.h"
#include "../utils/openxc-utils.hpp"
-#include "can-message-definition.hpp"
+#include "message-definition.hpp"
#include "../binding/low-can-hat.hpp"
/// @brief Parses the signal's bitfield from the given data and returns the raw
/// @return Returns the raw value of the signal parsed as a bitfield from the given byte
/// array.
///
-float decoder_t::parse_signal_bitfield(can_signal_t& signal, const message_t& message)
+float decoder_t::parse_signal_bitfield(signal_t& signal, std::shared_ptr<message_t> message)
{
- return bitfield_parse_float(message.get_data(), CAN_MESSAGE_SIZE,
+ return bitfield_parse_float(message->get_data(), CAN_MESSAGE_SIZE,
signal.get_bit_position(), signal.get_bit_size(), signal.get_factor(),
signal.get_offset());
}
/// @brief Wraps a raw CAN signal value in a DynamicField without modification.
///
/// This is an implementation of the Signal type signature, and can be
-/// used directly in the can_signal_t.decoder field.
+/// used directly in the signal_t.decoder field.
///
/// @param[in] signal - The details of the signal that contains the state mapping.
/// @param[in] value - The numerical value that will be wrapped in a DynamicField.
/// its numeric value. The 'send' argument will not be modified as this decoder
/// always succeeds.
///
-openxc_DynamicField decoder_t::decode_noop(can_signal_t& signal, float value, bool* send)
+openxc_DynamicField decoder_t::decode_noop(signal_t& signal, float value, bool* send)
{
openxc_DynamicField decoded_value = build_DynamicField(value);
/// @brief Coerces a numerical value to a boolean.
///
/// This is an implementation of the Signal type signature, and can be
-/// used directly in the can_signal_t.decoder field.
+/// used directly in the signal_t.decoder field.
///
/// @param[in] signal - The details of the signal that contains the state mapping.
/// @param[in] value - The numerical value that will be converted to a boolean.
/// is 0.0, otherwise true. The 'send' argument will not be modified as this
/// decoder always succeeds.
///
-openxc_DynamicField decoder_t::decode_boolean(can_signal_t& signal, float value, bool* send)
+openxc_DynamicField decoder_t::decode_boolean(signal_t& signal, float value, bool* send)
{
openxc_DynamicField decoded_value = build_DynamicField(value == 0.0 ? false : true);
/// @brief Update the metadata for a signal and the newly received value.
///
/// This is an implementation of the Signal type signature, and can be
-/// used directly in the can_signal_t.decoder field.
+/// used directly in the signal_t.decoder field.
///
/// This function always flips 'send' to false.
///
///
/// @return Return value is undefined.
///
-openxc_DynamicField decoder_t::decode_ignore(can_signal_t& signal, float value, bool* send)
+openxc_DynamicField decoder_t::decode_ignore(signal_t& signal, float value, bool* send)
{
if(send)
*send = false;
/// raw integer value.
///
/// This is an implementation of the Signal type signature, and can be
-/// used directly in the can_signal_t.decoder field.
+/// used directly in the signal_t.decoder field.
///
/// @param[in] signal - The details of the signal that contains the state mapping.
/// @param[in] value - The numerical value that should map to a state.
/// the signal. If an equivalent isn't found, send is sent to false and the
/// return value is undefined.
///
-openxc_DynamicField decoder_t::decode_state(can_signal_t& signal, float value, bool* send)
+openxc_DynamicField decoder_t::decode_state(signal_t& signal, float value, bool* send)
{
const std::string signal_state = signal.get_states((uint8_t)value);
openxc_DynamicField decoded_value = build_DynamicField(signal_state);
/// @brief Parse a signal from a CAN message, apply any required transforations
/// to get a human readable value and public the result to the pipeline.
///
-/// If the can_signal_t has a non-NULL 'decoder' field, the raw CAN signal value
+/// If the signal_t has a non-NULL 'decoder' field, the raw CAN signal value
/// will be passed to the decoder before publishing.
///
/// @param[in] signal - The details of the signal to decode and forward.
/// The decoder returns an openxc_DynamicField, which may contain a number,
/// string or boolean.
///
-openxc_DynamicField decoder_t::translate_signal(can_signal_t& signal, const message_t& message, bool* send)
+openxc_DynamicField decoder_t::translate_signal(signal_t& signal, std::shared_ptr<message_t> message, bool* send)
{
float value = decoder_t::parse_signal_bitfield(signal, message);
AFB_DEBUG("Decoded message from parse_signal_bitfield: %f", value);
*send = false;
}
signal.set_last_value(value);
- signal.set_timestamp(message.get_timestamp());
+ signal.set_timestamp(message->get_timestamp());
signal.get_message()->set_last_value(message);
return decoded_value;
}
/// @brief Parse a signal from a CAN message and apply any required
/// transforations to get a human readable value.
///
-/// If the can_signal_t has a non-NULL 'decoder' field, the raw CAN signal value
+/// If the signal_t has a non-NULL 'decoder' field, the raw CAN signal value
/// will be passed to the decoder before returning.
///
/// @param[in] signal - The details of the signal to decode and forward.
/// @return The decoder returns an openxc_DynamicField, which may contain a number,
/// string or boolean. If 'send' is false, the return value is undefined.
///
-openxc_DynamicField decoder_t::decode_signal( can_signal_t& signal, float value, bool* send)
+openxc_DynamicField decoder_t::decode_signal( signal_t& signal, float value, bool* send)
{
signal_decoder decoder = signal.get_decoder() == nullptr ?
decode_noop : signal.get_decoder();
/// @param[out] send - An output parameter that will be flipped to false if the value could
/// not be decoded.
///
-openxc_DynamicField decoder_t::decode_signal( can_signal_t& signal, const can_message_t& message, bool* send)
+openxc_DynamicField decoder_t::decode_signal( signal_t& signal, std::shared_ptr<message_t> message, bool* send)
{
float value = parse_signal_bitfield(signal, message);
return decode_signal(signal, value, send);
#pragma once
-#include "can-signals.hpp"
+#include "signals.hpp"
#include "message/can-message.hpp"
#include "openxc.pb.h"
class decoder_t
{
public:
- static float parse_signal_bitfield(can_signal_t& signal, const message_t& message);
+ static float parse_signal_bitfield(signal_t& signal, std::shared_ptr<message_t> message);
- static openxc_DynamicField decode_state(can_signal_t& signal, float value, bool* send);
- static openxc_DynamicField decode_boolean(can_signal_t& signal, float value, bool* send);
- static openxc_DynamicField decode_ignore(can_signal_t& signal, float value, bool* send);
- static openxc_DynamicField decode_noop(can_signal_t& signal, float value, bool* send);
+ static openxc_DynamicField decode_state(signal_t& signal, float value, bool* send);
+ static openxc_DynamicField decode_boolean(signal_t& signal, float value, bool* send);
+ static openxc_DynamicField decode_ignore(signal_t& signal, float value, bool* send);
+ static openxc_DynamicField decode_noop(signal_t& signal, float value, bool* send);
- static openxc_DynamicField translate_signal(can_signal_t& signal, const message_t& messag, bool* send);
+ static openxc_DynamicField translate_signal(signal_t& signal, std::shared_ptr<message_t> message, bool* send);
- static openxc_DynamicField decode_signal(can_signal_t& signal, const can_message_t& message, bool* send);
+ static openxc_DynamicField decode_signal(signal_t& signal, std::shared_ptr<message_t> message, bool* send);
- static openxc_DynamicField decode_signal(can_signal_t& signal, float value, bool* send);
+ static openxc_DynamicField decode_signal(signal_t& signal, float value, bool* send);
static float decode_obd2_response(const DiagnosticResponse* response, float parsed_payload);
};
#include "canutil/write.h"
#include "../utils/openxc-utils.hpp"
-#include "can-message-definition.hpp"
+#include "message-definition.hpp"
/// @brief Write a value in a CAN signal in the destination buffer.
///
/// @param[in] length - The length of the destination buffer.
///
/// @return Returns a canfd_frame struct initialized and ready to be send.
-const canfd_frame encoder_t::build_frame(const std::shared_ptr<can_signal_t>& signal, uint64_t value)
+const canfd_frame encoder_t::build_frame(const std::shared_ptr<signal_t>& signal, uint64_t value)
{
struct canfd_frame cf;
::memset(&cf, 0, sizeof(cf));
signal->set_last_value((float)value);
- for(const auto& sig: signal->get_message()->get_can_signals())
+ for(const auto& sig: signal->get_message()->get_signals())
{
float last_value = sig->get_last_value();
bitfield_encode_float(last_value,
/// @return Returns the encoded integer. If 'send' is changed to false, the field could
/// not be encoded and the return value is undefined.
///
-uint64_t encoder_t::encode_boolean(const can_signal_t& signal, bool value, bool* send)
+uint64_t encoder_t::encode_boolean(const signal_t& signal, bool value, bool* send)
{
return encode_number(signal, float(value), send);
}
/// @return Returns the encoded integer. If 'send' is changed to false, the field could
/// not be encoded and the return value is undefined.
///
-uint64_t encoder_t::encode_number(const can_signal_t& signal, float value, bool* send)
+uint64_t encoder_t::encode_number(const signal_t& signal, float value, bool* send)
{
return float_to_fixed_point(value, signal.get_factor(), signal.get_offset());
}
/// @return Returns the encoded integer. If 'send' is changed to false, the field could
/// not be encoded and the return value is undefined.
///
-uint64_t encoder_t::encode_state(const can_signal_t& signal, const std::string& state, bool* send)
+uint64_t encoder_t::encode_state(const signal_t& signal, const std::string& state, bool* send)
{
uint64_t value = 0;
if(state == "")
/// @brief Parse a signal from a CAN message and apply any required
/// transforations to get a human readable value.
///
-/// If the can_signal_t has a non-NULL 'decoder' field, the raw CAN signal value
+/// If the signal_t has a non-NULL 'decoder' field, the raw CAN signal value
/// will be passed to the decoder before returning.
///
/// @param[in] signal - The details of the signal to decode and forward.
/// @return The decoder returns an openxc_DynamicField, which may contain a number,
/// string or boolean. If 'send' is false, the return value is undefined.
///
-uint64_t encoder_t::encode_DynamicField( can_signal_t& signal, const openxc_DynamicField& field, bool* send)
+uint64_t encoder_t::encode_DynamicField( signal_t& signal, const openxc_DynamicField& field, bool* send)
{
uint64_t value = 0;
switch(field.type) {
#pragma once
-#include "can-signals.hpp"
+#include "signals.hpp"
#include "message/can-message.hpp"
#include "openxc.pb.h"
class encoder_t
{
public:
- static const canfd_frame build_frame(const std::shared_ptr<can_signal_t>& signal, uint64_t value);
- static uint64_t encode_state(const can_signal_t& signal, const std::string& value, bool* send);
- static uint64_t encode_boolean(const can_signal_t& signal, bool value, bool* send);
- static uint64_t encode_number(const can_signal_t& signal, float value, bool* send);
+ static const canfd_frame build_frame(const std::shared_ptr<signal_t>& signal, uint64_t value);
+ static uint64_t encode_state(const signal_t& signal, const std::string& value, bool* send);
+ static uint64_t encode_boolean(const signal_t& signal, bool value, bool* send);
+ static uint64_t encode_number(const signal_t& signal, float value, bool* send);
- static uint64_t encode_DynamicField(can_signal_t& signal, const openxc_DynamicField& field, bool* send);
+ static uint64_t encode_DynamicField(signal_t& signal, const openxc_DynamicField& field, bool* send);
};
* limitations under the License.
*/
-#include "can-message-definition.hpp"
+#include "message-definition.hpp"
#include "../binding/application.hpp"
-can_message_definition_t::can_message_definition_t(
+message_definition_t::message_definition_t(
const std::string bus,
uint32_t id,
bool is_fd,
- can_message_format_t format,
+ message_format_t format,
frequency_clock_t frequency_clock,
bool force_send_changed,
- const std::vector<std::shared_ptr<can_signal_t> >& can_signals)
+ const std::vector<std::shared_ptr<signal_t> >& signals)
: parent_{nullptr},
bus_{bus},
id_{id},
frequency_clock_{frequency_clock},
force_send_changed_{force_send_changed},
last_value_{CAN_MESSAGE_SIZE},
- can_signals_{can_signals}
+ signals_{signals}
{}
-can_message_definition_t::can_message_definition_t(const std::string bus,
+message_definition_t::message_definition_t(const std::string bus,
uint32_t id,
const std::string name,
uint32_t length,
bool is_fd,
- can_message_format_t format,
+ message_format_t format,
frequency_clock_t frequency_clock,
bool force_send_changed,
- const std::vector<std::shared_ptr<can_signal_t> >& can_signals)
+ const std::vector<std::shared_ptr<signal_t> >& signals)
: parent_{nullptr},
bus_{bus},
id_{id},
frequency_clock_{frequency_clock},
force_send_changed_{force_send_changed},
last_value_{CAN_MESSAGE_SIZE},
- can_signals_{can_signals}
+ signals_{signals}
{}
-const std::string can_message_definition_t::get_bus_device_name() const
+const std::string message_definition_t::get_bus_device_name() const
{
return application_t::instance().get_can_bus_manager()
.get_can_device_name(bus_);
}
-uint32_t can_message_definition_t::get_id() const
+uint32_t message_definition_t::get_id() const
{
return id_;
}
-bool can_message_definition_t::is_fd() const
+bool message_definition_t::is_fd() const
{
return is_fd_;
}
-bool can_message_definition_t::is_j1939() const
+bool message_definition_t::is_j1939() const
{
- if(format_ == can_message_format_t::J1939)
+ if(format_ == message_format_t::J1939)
{
return true;
}
}
}
-std::vector<std::shared_ptr<can_signal_t> >& can_message_definition_t::get_can_signals()
+std::vector<std::shared_ptr<signal_t>>& message_definition_t::get_signals()
{
- return can_signals_;
+ return signals_;
}
-void can_message_definition_t::set_parent(can_message_set_t* parent)
+void message_definition_t::set_parent(std::shared_ptr<message_set_t> parent)
{
parent_= parent;
}
-void can_message_definition_t::set_last_value(const message_t& cm)
+void message_definition_t::set_last_value(std::shared_ptr<message_t> m)
{
- last_value_= cm.get_data_vector();
+ last_value_= m->get_data_vector();
}
*/
/**
- * @class can_message_definition_t
+ * @class message_definition_t
*
* @brief The definition of a CAN message. This includes a lot of metadata, so
* to save memory this struct should not be used for storing incoming and
#include <vector>
#include <memory>
-#include "can-signals.hpp"
-#include "message/can-message.hpp"
-#include "can-message-set.hpp"
+#include "signals.hpp"
+#include "message-set.hpp"
#include "../utils/timer.hpp"
+#include "message/message.hpp"
-class can_message_set_t;
+class message_set_t;
/// @brief The definition of a CAN message. This includes a lot of metadata, so
-/// to save memory this class gets the can_signal_t object related to a CAN message.
-class can_message_definition_t
+/// to save memory this class gets the signal_t object related to a CAN message.
+class message_definition_t
{
private:
- can_message_set_t* parent_; ///< parent_ - Pointer to the CAN message set holding this CAN message definition */
+ std::shared_ptr<message_set_t> parent_; ///< parent_ - Pointer to the CAN message set holding this CAN message definition */
std::string bus_; ///< bus_ - Address of CAN bus device. */
- uint32_t id_; ///< id_ - The ID of the message.*/
+ uint32_t id_; ///< id_ - The ID or the PGN (if j1939) of the message.*/
std::string name_; ///< name_ - J1939 PGN name
uint32_t length_; ///< length_ - Message data length in bytes. For J1939 message, this is the expected data size
bool is_fd_; /*!< uses_fd_ - Flags to enable an FD CAN message communication*/
- can_message_format_t format_; ///< format_ - the format of the message's ID.*/
+ message_format_t format_; ///< format_ - the format of the message's ID.*/
frequency_clock_t frequency_clock_; ///< clock_ - an optional frequency clock to control the output of this
/// message, if sent raw, or simply to mark the max frequency for custom
/// handlers to retrieve.*/
std::vector<uint8_t> last_value_; ///< last_value_ - The last received value of the message. Defaults to undefined.
/// This is required for the forceSendChanged functionality, as the stack
/// needs to compare an incoming CAN message with the previous frame.*/
- std::vector<std::shared_ptr<can_signal_t> > can_signals_; ///< can_signals_ - Vector holding can_signal_t object which share the same arbitration ID */
+ std::vector<std::shared_ptr<signal_t> > signals_; ///< signals_ - Vector holding signal_t object which share the same arbitration ID */
public:
- //can_message_definition_t(const can_message_definition_t& b);
- can_message_definition_t(const std::string bus);
- can_message_definition_t(const std::string bus, uint32_t id, frequency_clock_t frequency_clock, bool force_send_changed);
- can_message_definition_t(const std::string bus, uint32_t id, can_message_format_t format, frequency_clock_t frequency_clock, bool force_send_changed);
- can_message_definition_t(const std::string bus,
+ //message_definition_t(const message_definition_t& b);
+ message_definition_t(const std::string bus);
+ message_definition_t(const std::string bus, uint32_t id, frequency_clock_t frequency_clock, bool force_send_changed);
+ message_definition_t(const std::string bus, uint32_t id, message_format_t format, frequency_clock_t frequency_clock, bool force_send_changed);
+ message_definition_t(const std::string bus,
uint32_t id,
bool is_fd,
- can_message_format_t format,
+ message_format_t format,
frequency_clock_t frequency_clock,
bool force_send_changed,
- const std::vector<std::shared_ptr<can_signal_t> >& can_signals);
- can_message_definition_t(const std::string bus,
+ const std::vector<std::shared_ptr<signal_t> >& signals);
+ message_definition_t(const std::string bus,
uint32_t id,
std::string name,
uint32_t length,
bool is_fd,
- can_message_format_t format,
+ message_format_t format,
frequency_clock_t frequency_clock,
bool force_send_changed,
- const std::vector<std::shared_ptr<can_signal_t> >& can_signals);
+ const std::vector<std::shared_ptr<signal_t> >& signals);
+
const std::string get_bus_name() const;
const std::string get_bus_device_name() const;
uint32_t get_id() const;
bool is_fd() const;
bool is_j1939() const;
- std::vector<std::shared_ptr<can_signal_t> >& get_can_signals();
+ std::vector<std::shared_ptr<signal_t>>& get_signals();
- void set_parent(can_message_set_t* parent);
- void set_last_value(const message_t& cm);
+ void set_parent(std::shared_ptr<message_set_t> parent);
+ void set_last_value(std::shared_ptr<message_t> m);
};
* limitations under the License.
*/
-#include "can-message-set.hpp"
+#include "message-set.hpp"
-#include "../can/can-message-definition.hpp"
+#include "../can/message-definition.hpp"
-can_message_set_t::can_message_set_t(
+message_set_t::message_set_t(
uint8_t index,
const std::string& name,
- const std::vector<std::shared_ptr<can_message_definition_t> >& can_messages_definition,
+ const std::vector<std::shared_ptr<message_definition_t> >& messages_definition,
const std::vector<std::shared_ptr<diagnostic_message_t> >& diagnostic_messages)
: index_{index}
, name_{name}
- , can_messages_definition_{can_messages_definition}
+ , messages_definition_{messages_definition}
, diagnostic_messages_{diagnostic_messages}
{}
/// @brief Returns a vector holding all message definitions which are handled by this message set.
-std::vector<std::shared_ptr<can_message_definition_t> >& can_message_set_t::get_can_message_definition()
+std::vector<std::shared_ptr<message_definition_t>>& message_set_t::get_messages_definition()
{
- return can_messages_definition_;
+ return messages_definition_;
}
-std::vector<std::shared_ptr<can_signal_t> > can_message_set_t::get_all_can_signals() const
+std::vector<std::shared_ptr<signal_t>> message_set_t::get_all_signals() const
{
- std::vector<std::shared_ptr<can_signal_t> > can_signals;
- for(const auto& cmd: can_messages_definition_)
+ std::vector<std::shared_ptr<signal_t> > signals;
+ for(const auto& cmd: messages_definition_)
{
- std::vector<std::shared_ptr<can_signal_t> >& cmd_signals = cmd->get_can_signals();
- can_signals.insert( can_signals.end(),
+ std::vector<std::shared_ptr<signal_t>> cmd_signals = cmd->get_signals();
+ signals.insert( signals.end(),
cmd_signals.begin(),
cmd_signals.end()
);
}
- return can_signals;
+ return signals;
}
/// @brief Returns a vector holding all diagnostic message definitions which are handled by this message set.
-std::vector<std::shared_ptr<diagnostic_message_t> >& can_message_set_t::get_diagnostic_messages()
+std::vector<std::shared_ptr<diagnostic_message_t>>& message_set_t::get_diagnostic_messages()
{
return diagnostic_messages_;
-}
\ No newline at end of file
+}
#include <vector>
#include <memory>
-class can_signal_t;
-class can_message_definition_t;
+class signal_t;
+class message_definition_t;
class diagnostic_message_t;
/// @brief A parent wrapper for a particular set of CAN messages and diagnostic messages
/// (e.g. a vehicle or program).
-class can_message_set_t
+class message_set_t
{
private:
uint8_t index_; /// < A numerical ID for the message set, ideally the index is in an array for fast lookup
const std::string name_; /// < The name of the message set.
- std::vector<std::shared_ptr<can_message_definition_t> > can_messages_definition_; ///< Vector holding all message definitions handled by the message set.
+ std::vector<std::shared_ptr<message_definition_t> > messages_definition_; ///< Vector holding all message definitions handled by the message set.
std::vector<std::shared_ptr<diagnostic_message_t> > diagnostic_messages_; ///< Vector holding all diagnostics messages from JSON signals description file. First vector map to message set
public:
- can_message_set_t(
+ message_set_t(
uint8_t index,
const std::string& name,
- const std::vector<std::shared_ptr<can_message_definition_t> >& can_messages_definition,
+ const std::vector<std::shared_ptr<message_definition_t> >& messages_definition,
const std::vector<std::shared_ptr<diagnostic_message_t> >& diagnostic_messages);
- std::vector<std::shared_ptr<can_message_definition_t> >& get_can_message_definition();
- std::vector<std::shared_ptr<can_signal_t> > get_all_can_signals() const;
- std::vector<std::shared_ptr<diagnostic_message_t> >& get_diagnostic_messages();
+ std::vector<std::shared_ptr<message_definition_t>>& get_messages_definition();
+ std::vector<std::shared_ptr<signal_t>> get_all_signals() const;
+ std::vector<std::shared_ptr<diagnostic_message_t>>& get_diagnostic_messages();
};
can_message_t::can_message_t(uint8_t maxdlen,
uint32_t id,
uint8_t length,
- can_message_format_t format,
+ message_format_t format,
bool rtr_flag,
uint8_t flags,
std::vector<uint8_t>& data,
/// @return True if object correctly initialized and false if not.
bool can_message_t::is_correct_to_send()
{
- if (id_ != 0 && length_ != 0 && format_ != can_message_format_t::INVALID)
+ if (id_ != 0 && length_ != 0 && format_ != message_format_t::INVALID)
{
int i;
for(i=0;i<CAN_MESSAGE_SIZE;i++)
{
uint8_t maxdlen = 0, length = 0, flags = 0;
uint32_t id;
- can_message_format_t format;
+ message_format_t format;
bool rtr_flag;
std::vector<uint8_t> data;
if (frame.can_id & CAN_ERR_FLAG)
{
- format = can_message_format_t::INVALID;
+ format = message_format_t::INVALID;
id = frame.can_id & (CAN_ERR_MASK|CAN_ERR_FLAG);
}
else if (frame.can_id & CAN_EFF_FLAG)
{
- format = can_message_format_t::EXTENDED;
+ format = message_format_t::EXTENDED;
id = frame.can_id & CAN_EFF_MASK;
}
else
{
- format = can_message_format_t::STANDARD;
+ format = message_format_t::STANDARD;
id = frame.can_id & CAN_SFF_MASK;
}
public:
can_message_t();
- can_message_t(uint8_t maxdlen, uint32_t id, uint8_t length, can_message_format_t format, bool rtr_flag_, uint8_t flags, std::vector<uint8_t>& data, uint64_t timestamp);
+ can_message_t(uint8_t maxdlen, uint32_t id, uint8_t length, message_format_t format, bool rtr_flag_, uint8_t flags, std::vector<uint8_t>& data, uint64_t timestamp);
uint32_t get_id() const;
{}
j1939_message_t::j1939_message_t(uint8_t length,
- can_message_format_t format,
+ message_format_t format,
std::vector<uint8_t>& data,
uint64_t timestamp,
name_t name,
std::shared_ptr<j1939_message_t> j1939_message_t::convert_from_addr(struct sockaddr_can& addr, uint8_t (&data)[128],size_t nbytes, uint64_t timestamp)
{
uint8_t length = 0;
- can_message_format_t format;
+ message_format_t format;
std::vector<uint8_t> dataVector;
if(nbytes > J1939_MAX_DLEN)
{
AFB_DEBUG("Unsupported j1939 frame");
- format = can_message_format_t::INVALID;
+ format = message_format_t::INVALID;
}
else
{
AFB_DEBUG("Got a j1939 frame");
- format = can_message_format_t::J1939;
+ format = message_format_t::J1939;
}
length = (uint8_t) nbytes;
public:
j1939_message_t();
- j1939_message_t(uint8_t length, can_message_format_t format, std::vector<uint8_t>& data, uint64_t timestamp, name_t name, pgn_t pgn, uint8_t addr);
+ j1939_message_t(uint8_t length, message_format_t format, std::vector<uint8_t>& data, uint64_t timestamp, name_t name, pgn_t pgn, uint8_t addr);
uint64_t get_name() const;
uint32_t get_pgn() const;
uint8_t get_addr() const;
///
message_t::message_t()
: length_{0},
- format_{can_message_format_t::INVALID},
+ format_{message_format_t::INVALID},
timestamp_{0},
sub_id_{-1}
{}
message_t::message_t(uint8_t length,
- can_message_format_t format,
+ message_format_t format,
std::vector<uint8_t>& data,
uint64_t timestamp)
: length_{length},
return timestamp_;
}
-can_message_format_t message_t::get_msg_format()
+message_format_t message_t::get_msg_format()
{
return format_;
}
};
/**
- * @enum can_message_format_t
+ * @enum message_format_t
* @brief The ID format for a CAN message.
*/
-enum class can_message_format_t {
+enum class message_format_t {
STANDARD, ///< STANDARD - standard 11-bit CAN arbitration ID. */
EXTENDED, ///< EXTENDED - an extended frame, with a 29-bit arbitration ID. */
J1939, ///< J1939 - Format for j1939 messages
class message_t {
protected:
uint8_t length_; ///< length_ - the length of the data array (max 8). */
- can_message_format_t format_; ///< format_ - the format of the message's ID.*/
+ message_format_t format_; ///< format_ - the format of the message's ID.*/
std::vector<uint8_t> data_; ///< data_ - The message's data field with a size of 8 which is the standard about CAN bus messages.*/
uint64_t timestamp_; ///< timestamp_ - timestamp of the received message*/
int sub_id_; ///< sub_id_ - Subscription index. */
public:
message_t();
- message_t(uint8_t length, can_message_format_t format, std::vector<uint8_t>& data, uint64_t timestamp);
+ message_t(uint8_t length, message_format_t format, std::vector<uint8_t>& data, uint64_t timestamp);
int get_sub_id() const;
const uint8_t* get_data() const;
void set_sub_id(int sub_id);
void set_timestamp(uint64_t timestamp);
- can_message_format_t get_msg_format();
+ message_format_t get_msg_format();
virtual bool is_set() = 0;
virtual std::string get_debug_message() = 0;
virtual uint32_t get_id() const = 0;
#include <fnmatch.h>
-#include "can-signals.hpp"
+#include "signals.hpp"
#include "../binding/application.hpp"
#include "../utils/signals.hpp"
#include "../diagnostic/diagnostic-message.hpp"
#include "canutil/write.h"
-std::string can_signal_t::prefix_ = "messages";
+std::string signal_t::prefix_ = "messages";
-can_signal_t::can_signal_t(
+signal_t::signal_t(
std::string generic_name,
uint8_t bit_position,
uint8_t bit_size,
bool writable,
signal_decoder decoder,
signal_encoder encoder,
- bool received)
+ bool received,
+ std::pair<bool,int> multiplex,
+ bool is_big_endian,
+ bool is_signed,
+ std::string unit)
: parent_{nullptr},
generic_name_{ generic_name }
, bit_position_{ bit_position }
, encoder_{encoder}
, received_{received}
, last_value_{.0f}
+ , multiplex_{multiplex}
+ , is_big_endian_{is_big_endian}
+ , is_signed_{is_signed}
+ , unit_{unit}
{}
-can_message_definition_t* can_signal_t::get_message() const
+signal_t::signal_t(
+ std::string generic_name,
+ uint8_t bit_position,
+ uint8_t bit_size,
+ float factor,
+ float offset,
+ float min_value,
+ float max_value,
+ frequency_clock_t frequency,
+ bool send_same,
+ bool force_send_changed,
+ std::map<uint8_t, std::string> states,
+ bool writable,
+ signal_decoder decoder,
+ signal_encoder encoder,
+ bool received)
+ : generic_name_{ generic_name }
+ , bit_position_{ bit_position }
+ , bit_size_{ bit_size }
+ , factor_{ factor }
+ , offset_{ offset }
+ , min_value_{min_value}
+ , max_value_{max_value}
+ , frequency_{frequency}
+ , send_same_{send_same}
+ , force_send_changed_{force_send_changed}
+ , states_{states}
+ , writable_{writable}
+ , decoder_{decoder}
+ , encoder_{encoder}
+ , received_{received}
+{}
+
+std::shared_ptr<message_definition_t> signal_t::get_message() const
{
return parent_;
}
-const std::string can_signal_t::get_generic_name() const
+const std::string signal_t::get_generic_name() const
{
return generic_name_;
}
-const std::string can_signal_t::get_name() const
+const std::string signal_t::get_name() const
{
return prefix_ + "." + generic_name_;
}
-uint8_t can_signal_t::get_bit_position() const
+uint8_t signal_t::get_bit_position() const
{
return bit_position_;
}
-uint8_t can_signal_t::get_bit_size() const
+uint8_t signal_t::get_bit_size() const
{
return bit_size_;
}
-float can_signal_t::get_factor() const
+float signal_t::get_factor() const
{
return factor_;
}
-float can_signal_t::get_offset() const
+float signal_t::get_offset() const
{
return offset_;
}
-frequency_clock_t& can_signal_t::get_frequency()
+frequency_clock_t& signal_t::get_frequency()
{
return frequency_;
}
-bool can_signal_t::get_send_same() const
+bool signal_t::get_send_same() const
{
return send_same_;
}
-const std::string can_signal_t::get_states(uint8_t value)
+const std::string signal_t::get_states(uint8_t value)
{
if ( states_.count(value) > 0 )
return states_[value];
return std::string();
}
-uint64_t can_signal_t::get_states(const std::string& value) const
+uint64_t signal_t::get_states(const std::string& value) const
{
uint64_t ret = -1;
for( const auto& state: states_)
return ret;
}
-bool can_signal_t::get_writable() const
+bool signal_t::get_writable() const
{
return writable_;
}
-signal_decoder& can_signal_t::get_decoder()
+signal_decoder& signal_t::get_decoder()
{
return decoder_;
}
-signal_encoder& can_signal_t::get_encoder()
+signal_encoder& signal_t::get_encoder()
{
return encoder_;
}
-bool can_signal_t::get_received() const
+bool signal_t::get_received() const
{
return received_;
}
-float can_signal_t::get_last_value() const
+float signal_t::get_last_value() const
{
return last_value_;
}
-std::pair<float, uint64_t> can_signal_t::get_last_value_with_timestamp() const
+std::pair<float, uint64_t> signal_t::get_last_value_with_timestamp() const
{
return std::make_pair(last_value_, frequency_.get_last_tick());
}
-void can_signal_t::set_parent(can_message_definition_t* parent)
+void signal_t::set_parent(std::shared_ptr<message_definition_t> parent)
{
parent_ = parent;
}
-void can_signal_t::set_received(bool r)
+void signal_t::set_received(bool r)
{
received_ = r;
}
-void can_signal_t::set_last_value(float val)
+void signal_t::set_last_value(float val)
{
last_value_ = val;
}
-void can_signal_t::set_timestamp(uint64_t timestamp)
+void signal_t::set_timestamp(uint64_t timestamp)
{
frequency_.tick(timestamp);
}
+std::pair<bool,int> signal_t::get_multiplex() const
+{
+ return multiplex_;
+}
+
+bool signal_t::get_is_big_endian() const
+{
+ return is_big_endian_;
+}
+
+bool signal_t::get_is_signed() const
+{
+ return is_signed_;
+}
+
+const std::string signal_t::get_unit() const
+{
+ return unit_;
+}
#include <memory>
#include "openxc.pb.h"
-#include "can-message-definition.hpp"
+#include "message-definition.hpp"
#include "../utils/timer.hpp"
#include "../utils/socketcan-bcm.hpp"
#include "message/can-message.hpp"
#define MESSAGE_SET_ID 0
-class can_signal_t;
+class signal_t;
///
/// @brief The type signature for a CAN signal decoder.
///
///
/// @return a decoded value in an openxc_DynamicField struct.
///
-typedef openxc_DynamicField (*signal_decoder)(can_signal_t& signal, float value, bool* send);
+typedef openxc_DynamicField (*signal_decoder)(signal_t& signal, float value, bool* send);
///
/// @brief: The type signature for a CAN signal encoder.
/// @param[out] send - An output parameter. If the encoding failed or the CAN signal should
/// not be encoded for some other reason, this will be flipped to false.
///
-typedef uint64_t (*signal_encoder)(can_signal_t& signal,
+typedef uint64_t (*signal_encoder)(signal_t& signal,
const openxc_DynamicField& field, bool* send);
-class can_signal_t
+class signal_t
{
private:
- can_message_definition_t* parent_; /*!< parent_ - pointer to the parent message definition holding this signal*/
+ std::shared_ptr<message_definition_t> parent_; /*!< parent_ - pointer to the parent message definition holding this signal*/
std::string generic_name_; /*!< generic_name_ - The name of the signal to be output.*/
static std::string prefix_; /*!< prefix_ - generic_name_ will be prefixed with it. It has to reflect the used protocol.
* which make easier to sort message when the come in.*/
bool received_; /*!< received_ - True if this signal has ever been received.*/
float last_value_; /*!< lastValue_ - The last received value of the signal. If 'received' is false,
* this value is undefined. */
+ std::pair<bool,int> multiplex_; /*!< multiplex_ - If bool is false and int is 0 is not a multiplex signal
+ If bool is true, that indicate that is a multiplexor
+ If int is different of 0, that indicate the link with a multiplexor */
+ bool is_big_endian_; /*!< is_big_endian - True if the signal's data are meant to be read as a big_endian */
+ bool is_signed_; /* !< is_signed_ - True if the data is signed */
+ std::string unit_; /* !< unit_ - The unit of the data */
public:
- can_signal_t(
+
+ signal_t(
+ std::string generic_name,
+ uint8_t bit_position,
+ uint8_t bit_size,
+ float factor,
+ float offset,
+ float min_value,
+ float max_value,
+ frequency_clock_t frequency,
+ bool send_same,
+ bool force_send_changed,
+ std::map<uint8_t, std::string> states,
+ bool writable,
+ signal_decoder decoder,
+ signal_encoder encoder,
+ bool received,
+ std::pair<bool,int> multiplex,
+ bool is_big_endian,
+ bool is_signed,
+ std::string unit);
+
+
+ signal_t(
std::string generic_name,
uint8_t bit_position,
uint8_t bit_size,
signal_encoder encoder,
bool received);
- can_message_definition_t* get_message() const;
+
+ std::shared_ptr<message_definition_t> get_message() const;
const std::string get_generic_name() const;
const std::string get_name() const;
uint8_t get_bit_position() const;
bool get_received() const;
float get_last_value() const;
std::pair<float, uint64_t> get_last_value_with_timestamp() const;
+ std::pair<bool,int> get_multiplex() const;
+ bool get_is_big_endian() const;
+ bool get_is_signed() const;
+ const std::string get_unit() const;
- void set_parent(can_message_definition_t* parent);
+ void set_parent(std::shared_ptr<message_definition_t> parent);
void set_received(bool r);
void set_last_value(float val);
void set_timestamp(uint64_t timestamp);
/// @return True if the active diagnostic request match the response.
bool diagnostic_manager_t::is_diagnostic_response(std::shared_ptr<message_t> m)
{
- if(m->get_msg_format() == can_message_format_t::STANDARD || m->get_msg_format() == can_message_format_t::EXTENDED)
+ if(m->get_msg_format() == message_format_t::STANDARD || m->get_msg_format() == message_format_t::EXTENDED)
{
if (m->get_id() >= 0x7e8 && m->get_id() <= 0x7ef)
return true;
supported_ = value;
}
-void diagnostic_message_t::set_parent(std::shared_ptr<can_message_set_t> parent)
+void diagnostic_message_t::set_parent(std::shared_ptr<message_set_t> parent)
{
parent_ = parent;
}
#include <string>
#include "uds/uds.h"
-#include "../can/can-message-set.hpp"
+#include "../can/message-set.hpp"
#include "../can/message/can-message.hpp"
#include "active-diagnostic-request.hpp"
class diagnostic_message_t
{
private:
- std::shared_ptr<can_message_set_t> parent_; /*!< parent_ - Pointer to the CAN message set holding this diagnostic message */
+ std::shared_ptr<message_set_t> parent_; /*!< parent_ - Pointer to the CAN message set holding this diagnostic message */
uint8_t pid_; /*!< pid_ - The 1 byte PID.*/
std::string generic_name_; /*!< generic_name_ - A human readable name to use for this PID when published.*/
int min_; /*!< min_ - Minimum value that can take this pid */
void set_timestamp(uint64_t timestamp);
void set_supported(bool value);
- void set_parent(std::shared_ptr<can_message_set_t> parent);
+ void set_parent(std::shared_ptr<message_set_t> parent);
const DiagnosticRequest build_diagnostic_request() const;
bool is_obd2_response(const can_message_t& can_message);
///
/// @fn std::vector<std::string> find_signals(const openxc_DynamicField &key)
- /// @brief return signals name found searching through CAN_signals and OBD2 pid
+ /// @brief return signals name found searching through signals and OBD2 pid
///
/// @param[in] key : can contain numeric or string value in order to search against
/// can signals or obd2 signals name.
switch(key.type)
{
case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING:
- lookup_signals_by_name(key.string_value, application_t::instance().get_all_can_signals(), sf.can_signals);
+ lookup_signals_by_name(key.string_value, application_t::instance().get_all_signals(), sf.signals);
lookup_signals_by_name(key.string_value, application_t::instance().get_diagnostic_messages(), sf.diagnostic_messages);
break;
case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM:
- lookup_signals_by_id(key.numeric_value, application_t::instance().get_all_can_signals(), sf.can_signals);
+ lookup_signals_by_id(key.numeric_value, application_t::instance().get_all_signals(), sf.signals);
lookup_signals_by_id(key.numeric_value, application_t::instance().get_diagnostic_messages(), sf.diagnostic_messages);
break;
default:
AFB_ERROR("wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only.");
break;
}
- AFB_DEBUG("Found %d signal(s)", (int)(sf.can_signals.size() + sf.diagnostic_messages.size()));
+ AFB_DEBUG("Found %d signal(s)", (int)(sf.signals.size() + sf.diagnostic_messages.size()));
return sf;
}
}
#include "openxc.pb.h"
#include "../binding/application.hpp"
-#include "../can/can-signals.hpp"
+#include "../can/signals.hpp"
#include "../diagnostic/diagnostic-message.hpp"
#include "../binding/low-can-subscription.hpp"
{
struct signals_found
{
- std::vector<std::shared_ptr<can_signal_t> > can_signals;
+ std::vector<std::shared_ptr<signal_t> > signals;
std::vector<std::shared_ptr<diagnostic_message_t> > diagnostic_messages;
};
struct signals_found find_signals(const openxc_DynamicField &key);
void find_diagnostic_messages(const openxc_DynamicField &key, std::vector<std::shared_ptr<diagnostic_message_t> >& found_signals);
- void find_can_signals(const openxc_DynamicField &key, std::vector<std::shared_ptr<can_signal_t> >& found_signals);
+ void find_signals(const openxc_DynamicField &key, std::vector<std::shared_ptr<signal_t> >& found_signals);
template <typename T>
void lookup_signals_by_name(const std::string& key, std::vector<std::shared_ptr<T> > signals, std::vector<std::shared_ptr<T> >& found_signals)
Code Review / apps / agl-service-can-low-level.git / commitdiff