configuration_t::configuration_t()
:can_bus_manager_{utils::config_parser_t{"/etc/dev-mapping.conf"}}
- , can_message_set_{{0, "example", 0, 1, 5, 0, 20}}
- , can_message_definition_
- {
- {
- can_message_definition_t{0, "can0", 0x620, can_message_format_t::STANDARD, frequency_clock_t(0.00000f), true}
- }
- }
- , can_signals_
- {
- {
- {
- 0,
- 0,
- "doors.coffer.open",
- 56,
- 1,
- 1.00000f,
- 0,
- 0,
- 0,
- frequency_clock_t(0.00000f),
- false,
- false,
- {
- },
- false,
- decoder_t::booleanDecoder,
- nullptr,
- false
- },
- {
- 0,
- 0,
- "doors.driver.open",
- 46,
- 1,
- 1.00000f,
- 0,
- 0,
- 0,
- frequency_clock_t(0.00000f),
- false,
- false,
+ , can_message_set_{
+ can_message_set_t{0, "example", 0, 1, 5, 0, 20, {
+ {std::make_shared<can_message_definition_t>(can_message_definition_t{"can0", 0x620, can_message_format_t::STANDARD, frequency_clock_t(0.00000f), true,
{
- },
- false,
- decoder_t::booleanDecoder,
- nullptr,
- false
- },
- {
- 0,
- 0,
- "doors.passenger.open",
- 47,
- 1,
- 1.00000f,
- 0,
- 0,
- 0,
- frequency_clock_t(0.00000f),
- false,
- false,
- {
- },
- false,
- decoder_t::booleanDecoder,
- nullptr,
- false
- },
- {
- 0,
- 0,
- "doors.rearleft.open",
- 54,
- 1,
- 1.00000f,
- 0,
- 0,
- 0,
- frequency_clock_t(0.00000f),
- false,
- false,
- {
- },
- false,
- decoder_t::booleanDecoder,
- nullptr,
- false
- },
- {
- 0,
- 0,
- "doors.rearright.open",
- 55,
- 4,
- 1.00000f,
- 0,
- 0,
- 0,
- frequency_clock_t(0.00000f),
- false,
- false,
- {
- },
- false,
- decoder_t::booleanDecoder,
- nullptr,
- false
- }
- }
+ {std::make_shared<can_signal_t>(
+ can_signal_t{
+ "doors.coffer.open",
+ 56,
+ 1,
+ 1.00000f,
+ 0,
+ 0,
+ 0,
+ frequency_clock_t(0.00000f),
+ false,
+ false,
+ {},
+ false,
+ decoder_t::booleanDecoder,
+ nullptr,
+ false
+ })},
+ {std::make_shared<can_signal_t> (
+ can_signal_t{
+ "doors.driver.open",
+ 46,
+ 1,
+ 1.00000f,
+ 0,
+ 0,
+ 0,
+ frequency_clock_t(0.00000f),
+ false,
+ false,
+ {},
+ false,
+ decoder_t::booleanDecoder,
+ nullptr,
+ false
+ })},
+ {std::make_shared<can_signal_t> (
+ can_signal_t{
+ "doors.passenger.open",
+ 47,
+ 1,
+ 1.00000f,
+ 0,
+ 0,
+ 0,
+ frequency_clock_t(0.00000f),
+ false,
+ false,
+ {},
+ false,
+ decoder_t::booleanDecoder,
+ nullptr,
+ false
+ })},
+ {std::make_shared<can_signal_t> (
+ can_signal_t{
+ "doors.rearleft.open",
+ 54,
+ 1,
+ 1.00000f,
+ 0,
+ 0,
+ 0,
+ frequency_clock_t(0.00000f),
+ false,
+ false,
+ {},
+ false,
+ decoder_t::booleanDecoder,
+ nullptr,
+ false
+ })},
+ {std::make_shared<can_signal_t> (
+ can_signal_t{
+ "doors.rearright.open",
+ 55,
+ 4,
+ 1.00000f,
+ 0,
+ 0,
+ 0,
+ frequency_clock_t(0.00000f),
+ false,
+ false,
+ {},
+ false,
+ decoder_t::booleanDecoder,
+ nullptr,
+ false
+ })}
+ }
+ })}
+ }}
}
, diagnostic_messages_
{
return can_message_set_;
}
-std::vector<can_signal_t>& configuration_t::get_can_signals()
+std::vector<std::shared_ptr<can_signal_t> > configuration_t::get_can_signals()
{
- return can_signals_[active_message_set_];
+ return can_message_set_[active_message_set_].get_can_signals();
}
std::vector<diagnostic_message_t>& configuration_t::get_diagnostic_messages()
return diagnostic_messages_[active_message_set_];
}
-const std::vector<can_message_definition_t>& configuration_t::get_can_message_definition()
+std::vector<std::shared_ptr<can_message_definition_t> > configuration_t::get_can_message_definition()
{
- return can_message_definition_[active_message_set_];
-}
-
-can_message_definition_t& configuration_t::get_can_message_definition(std::uint8_t message_set_id, std::uint8_t message_id)
-{
- return can_message_definition_[message_set_id][message_id];
+ return can_message_set_[active_message_set_].get_can_message_definition();
}
uint32_t configuration_t::get_signal_id(diagnostic_message_t& sig) const
uint32_t configuration_t::get_signal_id(can_signal_t& sig) const
{
- return sig.get_message().get_id();
+ return sig.get_message()->get_id();
}
void configuration_t::set_active_message_set(uint8_t id)
#include <map>
#include <vector>
#include <string>
-#include <fcntl.h>
+#include <memory>
#include "../can/can-bus.hpp"
+#include "../can/can-message-set.hpp"
#include "../can/can-signals.hpp"
-#include "../can/can-message.hpp"
#include "../diagnostic/diagnostic-manager.hpp"
#include "low-can-hat.hpp"
uint8_t active_message_set_ = 0; ///< Which is the active message set ? Default to 0.
std::vector<can_message_set_t> can_message_set_; ///< Vector holding all message set from JSON signals description file
- std::vector<std::vector<can_message_definition_t>> can_message_definition_; ///< Vector of vector holding all can message definition from JSON signals description file. This describe a CAN message. First vector map to message set
- std::vector<std::vector<can_signal_t>> can_signals_; ///< Vector of vector holding all can signasl from JSON signals description file. A CAN signal is a part of a CAN message. First vector map to message set
+ //std::vector<std::vector<can_message_definition_t>> can_message_definition_; ///< Vector of vector holding all can message definition from JSON signals description file. This describe a CAN message. First vector map to message set
+ //std::vector<std::vector<can_signal_t>> can_signals_; ///< Vector of vector holding all can signasl from JSON signals description file. A CAN signal is a part of a CAN message. First vector map to message set
std::vector<std::vector<diagnostic_message_t>> diagnostic_messages_; ///< Vector of vector holding all diagnostics messages from JSON signals description file. First vector map to message set
configuration_t(); ///< Private constructor with implementation generated by the AGL generator.
const std::vector<can_message_set_t>& get_can_message_set();
- std::vector<can_signal_t>& get_can_signals();
+ std::vector<std::shared_ptr<can_signal_t> > get_can_signals();
std::vector<diagnostic_message_t>& get_diagnostic_messages();
const std::vector<std::string>& get_signals_prefix() const;
- const std::vector<can_message_definition_t>& get_can_message_definition();
- can_message_definition_t& get_can_message_definition(std::uint8_t message_set_id, std::uint8_t message_id);
+ std::vector<std::shared_ptr<can_message_definition_t> > get_can_message_definition();
uint32_t get_signal_id(diagnostic_message_t& sig) const;
/// string or boolean.
///
openxc_DynamicField decoder_t::translateSignal(can_signal_t& signal, const can_message_t& message,
- const std::vector<can_signal_t>& signals, bool* send)
+ const std::vector<std::shared_ptr<can_signal_t> >& signals, bool* send)
{
float value = decoder_t::parseSignalBitfield(signal, message);
DEBUG(binder_interface, "%s: Decoded message from parseSignalBitfield: %f", __FUNCTION__, value);
float value, bool* send);
static openxc_DynamicField translateSignal(can_signal_t& signal, const can_message_t& message,
- const std::vector<can_signal_t>& signals, bool* send);
+ const std::vector<std::shared_ptr<can_signal_t> >& signals, bool* send);
static openxc_DynamicField decodeSignal(can_signal_t& signal, const can_message_t& message,
const std::vector<can_signal_t>& signals, bool* send);
#include "can-message-definition.hpp"
-can_message_definition_t::can_message_definition_t(std::uint8_t message_set_id, const std::string bus)
- : message_set_id_{message_set_id}, bus_{bus}, last_value_{CAN_MESSAGE_SIZE}
+can_message_definition_t::can_message_definition_t(const std::string bus)
+ : parent_{nullptr}, bus_{bus}, last_value_{CAN_MESSAGE_SIZE}
{}
-can_message_definition_t::can_message_definition_t(std::uint8_t message_set_id,
+can_message_definition_t::can_message_definition_t(
const std::string bus,
uint32_t id,
frequency_clock_t frequency_clock,
bool force_send_changed)
- : message_set_id_{message_set_id},
+ : parent_{nullptr},
bus_{bus},
id_{id},
frequency_clock_{frequency_clock},
last_value_{CAN_MESSAGE_SIZE}
{}
-can_message_definition_t::can_message_definition_t(std::uint8_t message_set_id,
+can_message_definition_t::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)
- : message_set_id_{message_set_id},
+ : parent_{nullptr},
bus_{bus},
id_{id},
format_{format},
last_value_{CAN_MESSAGE_SIZE}
{}
+can_message_definition_t::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,
+ std::vector<std::shared_ptr<can_signal_t> > can_signals)
+ : parent_{nullptr},
+ bus_{bus},
+ id_{id},
+ format_{format},
+ frequency_clock_{frequency_clock},
+ force_send_changed_{force_send_changed},
+ last_value_{CAN_MESSAGE_SIZE},
+ can_signals_{std::move(can_signals)}
+{
+ for(auto& sig: can_signals_)
+ {
+ sig->set_parent(std::make_shared<can_signal_t>(this));
+ }
+}
+
+/*can_message_definition_t(const can_message_definition_t& b)
+ : parent_{b.parent_},
+ bus_{b.bus_},
+ id_{b.id_},
+ format_{b.format_},
+ frequency_clock_{b.frequency_clock_},
+ force_send_changed_{b.force_send_changed_},
+ last_value_{b.last_value_},
+ can_signals_{b.can_signals_}
+ {}*/
+
const std::string& can_message_definition_t::get_bus_name() const
{
return bus_;
uint32_t can_message_definition_t::get_id() const
{
return id_;
+}
+
+std::vector<std::shared_ptr<can_signal_t> > can_message_definition_t::get_can_signals()
+{
+ return can_signals_;
+}
+
+void can_message_definition_t::set_parent(std::shared_ptr<can_message_set_t> parent)
+{
+ parent_= parent;
+}
void can_message_definition_t::set_last_value(const can_message_t& cm)
{
#include <memory>
#include "can-message.hpp"
+#include "can-signals.hpp"
#include "../utils/timer.hpp"
+class can_message_set_t;
+
class can_message_definition_t
{
private:
- std::uint8_t message_set_id_;
+ std::shared_ptr<can_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.*/
can_message_format_t format_; /*!< format_ - the format of the message's ID.*/
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 */
public:
- can_message_definition_t(std::uint8_t message_set_id, const std::string bus);
- can_message_definition_t(std::uint8_t message_set_id, const std::string bus, uint32_t id, frequency_clock_t frequency_clock, bool force_send_changed);
- can_message_definition_t(std::uint8_t message_set_id, 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 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, uint32_t id, can_message_format_t format, frequency_clock_t frequency_clock, bool force_send_changed, std::vector<std::shared_ptr<can_signal_t> > can_signals);
const std::string& get_bus_name() const;
uint32_t get_id() const;
+ std::vector<std::shared_ptr<can_signal_t> > get_can_signals();
+ void set_parent(std::shared_ptr<can_message_set_t> parent);
void set_last_value(const can_message_t& cm);
};
unsigned short can_message_count,
unsigned short can_signal_count,
unsigned short can_command_count,
- unsigned short obd2_signal_count)
+ unsigned short obd2_signal_count,
+ std::vector<std::shared_ptr<can_message_definition_t> > can_messages_definition)
: index_{index}
, name_{name}
, can_bus_count_{can_bus_count}
, can_signal_count_{can_signal_count}
, can_command_count_{can_command_count}
, obd2_signal_count_{obd2_signal_count}
+ , can_messages_definition_{can_messages_definition}
{
+ for(auto& cmd : can_messages_definition_)
+ {
+ cmd->set_parent(std::make_shared<can_message_set_t>(this));
+ }
}
+
+/// @brief Return vector holding all message definition handled by this message set.
+std::vector<std::shared_ptr<can_message_definition_t> > can_message_set_t::get_can_message_definition()
+{
+ return can_messages_definition_;
+}
+
+std::vector<std::shared_ptr<can_signal_t> > can_message_set_t::get_can_signals() const
+{
+ std::vector<std::shared_ptr<can_signal_t> > can_signals(can_signal_count_);
+ for(const auto& cmd: can_messages_definition_)
+ {
+ can_signals.insert( can_signals.end(),
+ cmd->get_can_signals().begin(),
+ cmd->get_can_signals().end()
+ );
+ }
+
+ return can_signals;
+}
\ No newline at end of file
#include <cstdint>
#include <string>
+#include <vector>
+#include <memory>
+
+#include "can-message-definition.hpp"
+
+class can_signal_t;
/// @brief A parent wrapper for a particular set of CAN messages and associated
/// CAN buses(e.g. a vehicle or program).
uint16_t can_signal_count_; /// < The number of CAN signals (across all messages) defined for this message set.
uint16_t can_command_count_; /// < The number of CanCommmands defined for this message set.
uint16_t obd2_signal_count_; /// < The number of obd2 signals defined for this message set.
+ std::vector<std::shared_ptr<can_message_definition_t> > can_messages_definition_; ///< Vector holding all message definition handled by this message set.
public:
can_message_set_t(
short unsigned int can_message_count,
short unsigned int can_signal_count,
short unsigned int can_command_count,
- short unsigned int obd2_signal_count);
+ short unsigned int obd2_signal_count,
+ std::vector<std::shared_ptr<can_message_definition_t> > can_messages_definition);
+ std::vector<std::shared_ptr<can_message_definition_t> > get_can_message_definition();
+ std::vector<std::shared_ptr<can_signal_t> > get_can_signals() const;
};
std::string can_signal_t::prefix_ = "messages";
-can_signal_t::can_signal_t(std::uint8_t message_set_id,
- std::uint8_t message_id,
+can_signal_t::can_signal_t(
std::string generic_name,
uint8_t bit_position,
uint8_t bit_size,
SignalDecoder decoder,
SignalEncoder encoder,
bool received)
- : message_set_id_{ message_set_id }
- , message_id_{ message_id }
- , generic_name_{ generic_name }
+ : parent_{nullptr},
+ generic_name_{ generic_name }
, bit_position_{ bit_position }
, bit_size_{ bit_size }
, factor_{ factor }
, last_value_{.0f}
{}
+/*can_signal_t::can_signal_t(const can_signal_t& b)
+ : parent_{b.parent_},
+ generic_name_{ b.generic_name_}
+ , bit_position_{ b.bit_position_}
+ , bit_size_{ b.bit_size_}
+ , factor_{ b.factor_ }
+ , offset_{ b.offset_}
+ , min_value_{b.min_value_}
+ , max_value_{b.max_value_}
+ , frequency_{b.frequency_}
+ , send_same_{b.send_same_}
+ , force_send_changed_{b.force_send_changed_}
+ , states_{b.states_}
+ , writable_{b.writable_}
+ , decoder_{b.decoder_}
+ , encoder_{b.encoder_}
+ , received_{b.received_}
+ , last_value_{b.last_value_}
+{}*/
+
utils::socketcan_bcm_t can_signal_t::get_socket() const
{
return socket_;
}
-can_message_definition_t& can_signal_t::get_message() const
+std::shared_ptr<can_message_definition_t> can_signal_t::get_message() const
{
- return configuration_t::instance().get_can_message_definition(message_set_id_, message_id_);
+ return parent_;
}
const std::string& can_signal_t::get_generic_name() const
return last_value_;
}
+void can_signal_t::set_parent(std::shared_ptr<can_message_definition_t> parent)
+{
+ parent_(parent);
+}
+
void can_signal_t::set_prefix(std::string val)
{
prefix_ = val;
#include <map>
#include <mutex>
-#include <queue>
#include <vector>
#include <string>
+#include <memory>
#include "openxc.pb.h"
#include "../utils/timer.hpp"
#include "../utils/socketcan-bcm.hpp"
#include "can-message.hpp"
-#include "can-message-definition.hpp"
#include "../diagnostic/diagnostic-message.hpp"
extern "C"
#define MESSAGE_SET_ID 0
class can_signal_t;
+class can_message_definition_t;
///
/// @brief The type signature for a CAN signal decoder.
class can_signal_t
{
private:
+ std::shared_ptr<can_message_definition_t> parent_; /*!< parent_ - pointer to the parent message definition holding this signal*/
utils::socketcan_bcm_t socket_; /*!< socket_ - Specific BCM socket that filter the signal read from CAN device */
- std::uint8_t message_set_id_; ///< message_set_id_ - Index number to the message_set_id container object
- std::uint8_t message_id_; ///< message_id_ - Index number to the message_definition_t container object
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.*/
* this value is undefined. */
public:
+ //can_signal_t(const can_signal_t& b);
can_signal_t(
- std::uint8_t message_set_id,
- std::uint8_t message_id,
std::string generic_name,
uint8_t bit_position,
uint8_t bit_size,
bool received);
utils::socketcan_bcm_t get_socket() const;
- can_message_definition_t& get_message() const;
+ std::shared_ptr<can_message_definition_t> get_message() const;
const std::string& get_generic_name() const;
const std::string get_name() const;
const std::string& get_prefix() const;
bool get_received() const;
float get_last_value() const;
+ void set_parent(std::shared_ptr<can_message_definition_t> parent);
void set_prefix(std::string val);
void set_received(bool r);
void set_last_value(float val);
Code Review / apps / low-level-can-service.git / commitdiff