#define EXIT_COMMAND_LINE_ERROR 2\r
#define EXIT_PROGRAM_ERROR 3\r
\r
+template <typename T>\r
+struct generator\r
+{\r
+ T v_;\r
+ std::string line_prefix_;\r
+ generator(T v, std::string line_prefix = "") : v_{v}, line_prefix_{line_prefix} {}\r
+};\r
+\r
+template <>\r
+struct generator<openxc::signal>\r
+{\r
+ const openxc::signal& v_;\r
+ std::uint32_t index_;\r
+ std::string line_prefix_;\r
+ generator(const openxc::signal& v, std::uint32_t index, std::string line_prefix = "")\r
+ : v_{v}, index_{index}, line_prefix_{line_prefix}\r
+ {\r
+ }\r
+};\r
+\r
+template <typename T>\r
+generator<T> gen(const T& v, std::string line_prefix = "") { return generator<T>(v, line_prefix); }\r
+\r
+generator<openxc::signal> gen(const openxc::signal& v, std::uint32_t index, std::string line_prefix = "")\r
+{\r
+ return generator<openxc::signal>(v, index, line_prefix);\r
+}\r
+\r
+template <typename T>\r
+std::ostream& operator<<(std::ostream& o, const generator<T>& v)\r
+{\r
+ o << v.line_prefix_ << v.v_;\r
+ return o;\r
+}\r
+\r
+template <>\r
+std::ostream& operator<<(std::ostream& o, const generator<bool>& v)\r
+{\r
+ o << v.line_prefix_ << (v.v_ ? "true" : "false");\r
+ return o;\r
+}\r
+\r
+template <>\r
+std::ostream& operator<<(std::ostream& o, const generator<float>& v)\r
+{\r
+ o << v.line_prefix_ << std::showpoint << v.v_ << "f";\r
+ return o;\r
+}\r
+\r
+template <>\r
+std::ostream& operator<<(std::ostream& o, const generator<std::string>& v)\r
+{\r
+ o << v.line_prefix_ << '\"' << v.v_ << '\"';\r
+ return o;\r
+}\r
+\r
+template <typename T>\r
+std::ostream& operator<<(std::ostream& o, const generator<std::vector<T>>& v)\r
+{\r
+ o << v.line_prefix_ << "{\n";\r
+ auto sz = v.v_.size();\r
+ for(const T& i : v.v_)\r
+ {\r
+ o << gen(i, v.line_prefix_ + '\t');\r
+ if (sz > 1) o << ",";\r
+ --sz;\r
+ o << '\n';\r
+ }\r
+ o << v.line_prefix_ << '}';\r
+ return o;\r
+}\r
+\r
+template <>\r
+std::ostream& operator<<(std::ostream& o, const generator<openxc::message_set>& v)\r
+{\r
+ o << v.line_prefix_\r
+ << '{'\r
+ << "0, "\r
+ << gen(v.v_.name()) << ", "\r
+ << v.v_.buses().size() << ", "\r
+ << v.v_.messages().size() << ", "\r
+ << std::accumulate(\r
+ std::begin(v.v_.messages()),\r
+ std::end(v.v_.messages()),\r
+ 0,\r
+ [](int sum, const openxc::can_message& p) { return sum + p.signals().size(); }\r
+ ) << ", "\r
+ << v.v_.commands().size() << ", "\r
+ << v.v_.diagnostic_messages().size() << "}";\r
+ return o;\r
+}\r
+\r
+template <>\r
+std::ostream& operator<<(std::ostream& o, const generator<openxc::can_message>& v)\r
+{\r
+ o << v.line_prefix_\r
+ << "can_message_definition_t("\r
+ << "0, "\r
+ << gen(v.v_.bus()) << ", "\r
+ << v.v_.id() << ", "\r
+ << "can_message_format_t::STANDARD, "\r
+ << "frequency_clock_t(" << gen(v.v_.max_frequency()) << "), "\r
+ << gen(v.v_.force_send_changed())\r
+ << ')';\r
+ return o;\r
+}\r
+\r
+template <>\r
+std::ostream& operator<<(std::ostream& o, const generator<std::map<std::string, std::vector<std::uint32_t>>>& v)\r
+{\r
+ o << v.line_prefix_ << "{\n";\r
+ std::uint32_t c1 = v.v_.size();\r
+ for(const auto& state : v.v_)\r
+ {\r
+ std::uint32_t c2 = state.second.size();\r
+ for(const auto& i : state.second)\r
+ {\r
+ o << v.line_prefix_ << "\t" << "{" << i << ", " << gen(state.first) << "}";\r
+ if (c1 > 1 || c2 > 1) o << ',';\r
+ o << '\n';\r
+ --c2;\r
+ }\r
+ --c1;\r
+ }\r
+ o << v.line_prefix_ << "}";\r
+ return o;\r
+}\r
+\r
+template <>\r
+std::ostream& operator<<(std::ostream& o, const generator<openxc::signal>& v)\r
+{\r
+ o << v.line_prefix_ << "{\n"\r
+ << v.line_prefix_ << "\t0,\n"\r
+ << v.line_prefix_ << "\t" << v.index_ << ",\n"\r
+ << v.line_prefix_ << "\t" << gen(v.v_.generic_name()) << ",\n"\r
+ << v.line_prefix_ << "\t" << v.v_.bit_position() << ",\n"\r
+ << v.line_prefix_ << "\t" << v.v_.bit_size() << ",\n"\r
+ << v.line_prefix_ << "\t" << gen(v.v_.factor()) << ", \n"\r
+ << v.line_prefix_ << "\t" << v.v_.offset() << ", \n"\r
+ << v.line_prefix_ << "\t" << "0,\n"\r
+ << v.line_prefix_ << "\t" << "0,\n"\r
+ << v.line_prefix_ << "\tfrequency_clock_t(" << gen(v.v_.max_frequency()) << "),\n"\r
+ << v.line_prefix_ << "\t" << gen(v.v_.send_same()) << ",\n"\r
+ << v.line_prefix_ << "\t" << gen(v.v_.force_send_changed()) << ",\n"\r
+ << gen(v.v_.states(), v.line_prefix_ + '\t') << ",\n"\r
+ << v.line_prefix_ << '\t' << gen(v.v_.writable()) << ",\n"\r
+ << v.line_prefix_ << '\t' << (v.v_.decoder().size() ? v.v_.decoder() : "nullptr") << ",\n"\r
+ << v.line_prefix_ << '\t' << (v.v_.encoder().size() ? v.v_.encoder() : "nullptr") << ",\n"\r
+ << v.line_prefix_ << '\t' << "false\n"\r
+ << v.line_prefix_ << "}";\r
+ return o;\r
+}\r
+\r
+\r
/// @brief Generate the configuration code.\r
/// @param[in] header Content to be inserted as a header.\r
/// @param[in] footer Content to be inserted as a footer.\r
/// @param[in] out Stream to write on.\r
void generate(const std::string& header, const std::string& footer, const openxc::message_set& message_set, std::ostream& out)\r
{\r
+ out << "#include \"configuration.hpp\"\n"\r
+ << "#include \"can/can-decoder.hpp\"\n\n";\r
+\r
if (header.size()) out << header << "\n";\r
- else out << "#pragma once\n\n";\r
- \r
- out << "namespace generated {\n"\r
- << " class configuration_generated\n"\r
+\r
+ out << "configuration_t::configuration_t()\n"\r
+ << " : can_message_set_" << gen(message_set) << '\n'\r
+ << " , can_message_definition_\n"\r
<< " {\n"\r
- << " private:\n"\r
- << " can_message_set_t can_message_set_;\n"\r
- << " std::vector<std::vector<can_message_definition_t>> can_message_definition_;\n"\r
- << " std::vector<std::vector<can_signal_t>> can_signals_;\n"\r
- << " std::vector<std::vector<obd2_signal_t>> obd2_signals_;\n"\r
- << " public:\n"\r
- << " configuration_generated()\n"\r
- << " : message_set_{0, \""\r
- << message_set.name() << "\", "\r
- << message_set.buses().size() << ", "\r
- << message_set.messages().size() << ", "\r
- << std::accumulate(\r
- std::begin(message_set.messages()),\r
- std::end(message_set.messages()),\r
- 0,\r
- [](int sum, const std::map<std::string, openxc::can_message>::value_type& p) { return sum + p.second.signals().size(); }\r
- ) << ", "\r
- << message_set.commands().size() << ", "\r
- << message_set.diagnostic_messages().size() << "}\n"\r
- << " , can_message_definition_{\n";\r
-\r
- std::uint32_t count = message_set.messages().size();\r
- for(const std::map<std::string, openxc::can_message>::value_type& m : message_set.messages())\r
+ << gen(message_set.messages(), "\t\t") << '\n'\r
+ << " }\n"\r
+ << " , can_signals_\n"\r
+ << " {\n";\r
+ std::uint32_t message_count = message_set.messages().size();\r
+ std::uint32_t index = 0;\r
+ for(const openxc::can_message& m : message_set.messages())\r
{\r
- out << " {{\"" << m.second.bus() << "\", "\r
- << m.first << ", "\r
- << "can_message_format_t::STANDARD, frequency_clock_t(), false}}";\r
- if (count > 1) out << ",";\r
- out << "\n";\r
- --count;\r
+ out << " {\n";\r
+ std::uint32_t signal_count = m.signals().size();\r
+ for(const openxc::signal& s : m.signals())\r
+ {\r
+ out << gen(s, index, " ");\r
+ if (signal_count > 1) out << ',';\r
+ --signal_count;\r
+ out << '\n';\r
+ }\r
+ out << " }";\r
+ if (index + 1 < message_count) out << ',';\r
+ ++index;\r
+ out << '\n';\r
}\r
- out << " }\n";\r
-\r
- \r
- out << " , can_signals_" << "..." << "\n"\r
- << " , obd2_signals_" << "..." << "\n"\r
- << " {\n"\r
- << " }\n"\r
- << " };\n"\r
+ out << " }\n"\r
+ << " //, obd2_signals_{" << "/*...*/" << "}\n"\r
+ << "{\n"\r
<< "}\n\n";\r
- \r
out << footer << std::endl;\r
}\r
\r
/// @return Exit code, zero if success.\r
int main(int argc, char** argv)\r
{\r
- std::ios::sync_with_stdio(false);\r
+ //std::ios::sync_with_stdio(false);\r
\r
try\r
{\r
}\r
\r
bpo::notify(vm);\r
- \r
- std::string header = read_file(header_file);\r
+\r
+ std::stringstream header;\r
+ header << read_file(header_file);\r
+ \r
std::string footer = read_file(footer_file);\r
openxc::message_set message_set;\r
message_set.from_json(read_json(message_set_file));\r
+\r
+ boost::filesystem::path message_set_path(message_set_file);\r
+ message_set_path.remove_filename();\r
+ for(const auto& s : message_set.extra_sources())\r
+ {\r
+ boost::filesystem::path extra_source(s);\r
+ if (!extra_source.is_complete()) extra_source = message_set_path / extra_source;\r
+ header << "\n// >>>>> " << s << " >>>>>\n" << read_file(extra_source.string()) << "\n// <<<<< " << s << " <<<<<\n";\r
+ }\r
+\r
std::ofstream out;\r
if (output_file.size())\r
{\r
}\r
}\r
\r
- generate(header, footer, message_set, output_file.size() ? out : std::cout); \r
+ generate(header.str(), footer, message_set, output_file.size() ? out : std::cout); \r
\r
}\r
catch (bpo::required_option& e)\r
return raw_writable_;\r
}\r
\r
- std::uint32_t can_bus::max_message_frequency() const\r
+ float can_bus::max_message_frequency() const\r
{\r
return max_message_frequency_;\r
}\r
speed_ = j.count("speed") ? j["speed"].get<std::uint32_t>() : 0;\r
raw_can_mode_ = j.count("raw_can_mode") ? j["raw_can_mode"].get<can_bus_mode>() : can_bus_mode::off;\r
raw_writable_ = j.count("raw_writable") ? j["raw_writable"].get<bool>() : false;\r
- max_message_frequency_ = j.count("max_message_frequency") ? j["max_message_frequency"].get<std::uint32_t>() : 0;\r
+ max_message_frequency_ = j.count("max_message_frequency") ? j["max_message_frequency"].get<float>() : 0;\r
force_send_changed_ = j.count("force_send_changed") ? j["force_send_changed"].get<bool>() : false;\r
}\r
\r
class can_bus\r
{\r
private:\r
- std::uint32_t controller_;\r
- std::uint32_t speed_;\r
- can_bus_mode raw_can_mode_;\r
- bool raw_writable_;\r
- std::uint32_t max_message_frequency_;\r
- bool force_send_changed_;\r
+ std::uint32_t controller_;\r
+ std::uint32_t speed_;\r
+ can_bus_mode raw_can_mode_;\r
+ bool raw_writable_;\r
+ float max_message_frequency_;\r
+ bool force_send_changed_;\r
\r
public:\r
- \r
std::uint32_t controller() const;\r
std::uint32_t speed() const;\r
can_bus_mode raw_can_mode() const;\r
bool raw_writable() const;\r
- std::uint32_t max_message_frequency() const;\r
+ float max_message_frequency() const;\r
bool force_send_changed() const;\r
\r
void from_json(const nlohmann::json& j);\r
\r
namespace openxc\r
{\r
+ std::string can_message::id() const\r
+ {\r
+ return id_;\r
+ }\r
+ \r
+ void can_message::id(const std::string& id)\r
+ {\r
+ id_ = id;\r
+ }\r
+ \r
std::string can_message::bus() const\r
{\r
return bus_;\r
return bit_numbering_inverted_;\r
}\r
\r
- const std::map<std::string, signal>& can_message::signals() const\r
+ const std::vector<signal>& can_message::signals() const\r
{\r
return signals_;\r
}\r
return enabled_;\r
}\r
\r
- std::uint32_t can_message::max_frequency() const\r
+ float can_message::max_frequency() const\r
{\r
return max_frequency_;\r
}\r
\r
- std::uint32_t can_message::max_signal_frequency() const\r
+ float can_message::max_signal_frequency() const\r
{\r
return max_signal_frequency_;\r
}\r
{\r
bus_ = j.count("bus") ? j["bus"].get<std::string>() : "";\r
bit_numbering_inverted_ = j.count("bit_numbering_inverted") ? j["bit_numbering_inverted"].get<bool>() : false;\r
- signals_= j.count("signals") ? j["signals"].get<std::map<std::string, signal>>() : std::map<std::string, signal>();\r
name_ = j.count("name") ? j["name"].get<std::string>() : "";\r
handlers_ = j.count("handlers") ? j["handlers"].get<std::vector<std::string>>() : std::vector<std::string>();\r
enabled_ = j.count("enabled") ? j["enabled"].get<bool>() : true;\r
- max_frequency_ = j.count("max_frequency") ? j["max_frequency"].get<std::uint32_t>() : 0;\r
- max_signal_frequency_ = j.count("max_signal_frequency") ? j["max_signal_frequency"].get<std::uint32_t>() : 0;\r
+ max_frequency_ = j.count("max_frequency") ? j["max_frequency"].get<float>() : 0;\r
+ max_signal_frequency_ = j.count("max_signal_frequency") ? j["max_signal_frequency"].get<float>() : 0;\r
force_send_changed_ = j.count("force_send_changed") ? j["force_send_changed"].get<bool>() : true;\r
force_send_changed_signals_ = j.count("force_send_changed_signals") ? j["force_send_changed_signals"].get<bool>() : false;\r
+ \r
+ if(j.count("signals"))\r
+ {\r
+ std::map<std::string, nlohmann::json> signals = j["signals"];\r
+ for(const auto& s : signals)\r
+ {\r
+ signal sig = s.second.get<signal>();\r
+ sig.id(s.first);\r
+ signals_.push_back(sig);\r
+ }\r
+ }\r
+ \r
}\r
\r
std::uint32_t can_message::get_signals_count() const\r
{\r
j = p.to_json();\r
}\r
-\r
+ \r
void from_json(const nlohmann::json& j, can_message& p)\r
{\r
p.from_json(j);\r
}\r
+\r
+ void from_json(const nlohmann::json& j, can_message& p, const std::string& id)\r
+ {\r
+ p.from_json(j);\r
+ p.id(id);\r
+ }\r
}\r
\r
#include <string>\r
#include <vector>\r
-#include <map>\r
#include <json.hpp>\r
\r
#include "signal.hpp"\r
class can_message\r
{\r
private:\r
+ std::string id_;\r
std::string bus_;\r
bool bit_numbering_inverted_;\r
- std::map<std::string, signal> signals_;\r
+ std::vector<signal> signals_;\r
std::string name_;\r
std::vector<std::string> handlers_;\r
bool enabled_;\r
- std::uint32_t max_frequency_;\r
- std::uint32_t max_signal_frequency_;\r
+ float max_frequency_;\r
+ float max_signal_frequency_;\r
bool force_send_changed_;\r
bool force_send_changed_signals_;\r
\r
public:\r
+ std::string id() const;\r
+ void id(const std::string& id);\r
std::string bus() const;\r
bool bit_numbering_inverted() const;\r
- const std::map<std::string, signal>& signals() const;\r
+ const std::vector<signal>& signals() const;\r
std::string name() const;\r
std::vector<std::string> handlers() const;\r
bool enabled() const;\r
- std::uint32_t max_frequency() const;\r
- std::uint32_t max_signal_frequency() const;\r
+ float max_frequency() const;\r
+ float max_signal_frequency() const;\r
bool force_send_changed() const;\r
bool force_send_changed_signals() const;\r
\r
\r
void to_json(nlohmann::json& j, const can_message& p);\r
void from_json(const nlohmann::json& j, can_message& p);\r
+ void from_json(const nlohmann::json& j, can_message& p, const std::string& id);\r
}\r
return mode_;\r
}\r
\r
- std::uint32_t diagnostic_message::frequency() const\r
+ float diagnostic_message::frequency() const\r
{\r
return frequency_;\r
}\r
bus_ = j.count("bus") ? j["bus"].get<std::string>() : "";\r
id_ = j.count("id") ? j["id"].get<std::uint32_t>() : 0;\r
mode_ = j.count("mode") ? j["mode"].get<std::uint32_t>() : 1;\r
- frequency_ = j.count("frequency") ? j["frequency"].get<std::uint32_t>() : 0;\r
+ frequency_ = j.count("frequency") ? j["frequency"].get<float>() : 0;\r
pid_ = j.count("pid") ? j["pid"].get<std::uint32_t>() : 0;\r
name_ = j.count("name") ? j["name"].get<std::string>() : "";\r
decoder_ = j.count("decoder") ? j["decoder"].get<std::string>() : "";\r
std::string bus_;\r
std::uint32_t id_;\r
std::uint32_t mode_;\r
- std::uint32_t frequency_;\r
+ float frequency_;\r
std::uint32_t pid_;\r
std::string name_;\r
std::string decoder_;\r
std::string bus() const;\r
std::uint32_t id() const;\r
std::uint32_t mode() const;\r
- std::uint32_t frequency() const;\r
+ float frequency() const;\r
std::uint32_t pid() const;\r
std::string name() const;\r
std::string decoder() const;\r
return bit_numbering_inverted_;\r
}\r
\r
- std::uint32_t message_set::max_message_frequency() const\r
+ float message_set::max_message_frequency() const\r
{\r
return max_message_frequency_;\r
}\r
return buses_;\r
}\r
\r
- const std::map<std::string, can_message>& message_set::messages() const\r
+ const std::vector<can_message>& message_set::messages() const\r
{\r
return messages_;\r
}\r
{\r
return commands_;\r
}\r
- \r
- std::string message_set::to_initializer() const\r
- {\r
- std::uint32_t signal_count = 0;\r
- for(const auto& m : messages_)\r
- {\r
- signal_count += m.second.get_signals_count();\r
- }\r
- \r
- std::stringstream ss;\r
- ss << "{0, "\r
- << "\"" << name_ << "\", "\r
- << buses_.size() << ", "\r
- << messages_.size() << ", "\r
- << signal_count << ", "\r
- << commands_.size() << ", "\r
- << diagnostic_messages_.size() << "}";\r
- return ss.str();\r
- }\r
\r
void message_set::from_json(const nlohmann::json& j)\r
{\r
initializers_ = j.count("initializers") ? j["initializers"].get<std::vector<std::string>>() : std::vector<std::string>();\r
loopers_ = j.count("loopers") ? j["loopers"].get<std::vector<std::string>>() : std::vector<std::string>();\r
buses_ = j.count("buses") ? j["buses"].get<std::map<std::string, can_bus>>() : std::map<std::string, can_bus>();\r
- messages_ = j.count("messages") ? j["messages"].get<std::map<std::string, can_message>>() : std::map<std::string, can_message>();\r
+ //messages_ = j.count("messages") ? j["messages"].get<std::map<std::string, can_message>>() : std::map<std::string, can_message>();\r
diagnostic_messages_ = j.count("diagnostic_messages") ? j["diagnostic_messages"].get<std::vector<diagnostic_message>>() : std::vector<diagnostic_message>();\r
mappings_ = j.count("mappings") ? j["mappings"].get<std::vector<mapping>>() : std::vector<mapping>();\r
extra_sources_ = j.count("extra_sources") ? j["extra_sources"].get<std::vector<std::string>>() : std::vector<std::string>();\r
commands_ = j.count("commands") ? j["commands"].get<std::vector<command>>() : std::vector<command>();\r
+ \r
+ \r
+ if (j.count("messages"))\r
+ {\r
+ std::map<std::string, nlohmann::json> messages = j["messages"];\r
+ for(const std::map<std::string, nlohmann::json>::value_type& m : messages)\r
+ {\r
+ can_message cm = m.second.get<can_message>();\r
+ cm.id(m.first);\r
+ messages_.push_back(cm);\r
+ }\r
+ }\r
}\r
\r
-\r
nlohmann::json message_set::to_json() const\r
{\r
nlohmann::json j;\r
private:\r
std::string name_;\r
bool bit_numbering_inverted_;\r
- std::uint32_t max_message_frequency_;\r
+ float max_message_frequency_;\r
can_bus_mode raw_can_mode_;\r
std::vector<std::string> parents_;\r
std::vector<std::string> initializers_;\r
std::vector<std::string> loopers_;\r
std::map<std::string, can_bus> buses_;\r
- std::map<std::string, can_message> messages_;\r
+ //std::map<std::string, can_message> messages_;\r
+ std::vector<can_message> messages_;\r
std::vector<diagnostic_message> diagnostic_messages_;\r
std::vector<mapping> mappings_;\r
std::vector<std::string> extra_sources_;\r
\r
std::string name() const;\r
bool bit_numbering_inverted() const;\r
- std::uint32_t max_message_frequency() const;\r
+ float max_message_frequency() const;\r
can_bus_mode raw_can_mode() const;\r
const std::vector<std::string>& parents() const;\r
const std::vector<std::string>& initializers() const;\r
const std::vector<std::string>& loopers() const;\r
const std::map<std::string, can_bus>& buses() const;\r
- const std::map<std::string, can_message>& messages() const;\r
+ const std::vector<can_message>& messages() const;\r
const std::vector<diagnostic_message>& diagnostic_messages() const;\r
const std::vector<mapping>& mappings() const;\r
const std::vector<std::string>& extra_sources() const;\r
const std::vector<command>& commands() const;\r
\r
- std::string to_initializer() const;\r
-\r
void from_json(const nlohmann::json& j);\r
nlohmann::json to_json() const;\r
};\r
\r
namespace openxc\r
{\r
+ std::string signal::id() const\r
+ {\r
+ return id_;\r
+ }\r
+ \r
+ void signal::id(const std::string& id)\r
+ {\r
+ id_ = id;\r
+ }\r
+ \r
+ void id(const std::string& id);\r
+ \r
std::string signal::generic_name() const\r
{\r
return generic_name_;\r
return states_;\r
}\r
\r
- std::uint32_t signal::max_frequency() const\r
+ float signal::max_frequency() const\r
{\r
return max_frequency_;\r
}\r
class signal\r
{\r
private:\r
+ std::string id_;\r
std::string generic_name_;\r
std::uint32_t bit_position_;\r
std::uint32_t bit_size_;\r
bool ignore_;\r
bool enabled_;\r
std::map<std::string, std::vector<std::uint32_t>> states_;\r
- std::uint32_t max_frequency_;\r
+ float max_frequency_;\r
bool send_same_;\r
bool force_send_changed_;\r
bool writable_;\r
std::string encoder_;\r
public:\r
+ std::string id() const;\r
+ void id(const std::string& id);\r
std::string generic_name() const;\r
std::uint32_t bit_position() const;\r
std::uint32_t bit_size() const;\r
bool ignore() const;\r
bool enabled() const;\r
const std::map<std::string, std::vector<std::uint32_t>>& states() const;\r
- std::uint32_t max_frequency() const;\r
+ float max_frequency() const;\r
bool send_same() const;\r
bool force_send_changed() const;\r
bool writable() const;\r
--- /dev/null
+#include "configuration.hpp"
+#include "can/can-decoder.hpp"
+
+
+// >>>>> handlers.cpp >>>>>
+#include "can/canread.h"
+
+using openxc::can::read::publishNumericalMessage;
+
+void handleSteeringWheelMessage(CanMessage* message,
+ CanSignal* signals, int signalCount, Pipeline* pipeline) {
+ publishNumericalMessage("latitude", 42.0, pipeline);
+}
+
+openxc_DynamicField handleInverted(CanSignal* signal, CanSignal* signals,
+ int signalCount, float value, bool* send) {
+ return openxc::payload::wrapNumber(value * -1);
+}
+
+void initializeMyStuff() { }
+
+void initializeOtherStuff() { }
+
+void myLooper() {
+ // this function will be called once each time through the main loop, after
+ // all CAN message processing has been completed
+}
+
+// <<<<< handlers.cpp <<<<<
+
+configuration_t::configuration_t()
+ : can_message_set_{0, "example", 2, 2, 7, 1, 3}
+ , can_message_definition_
+ {
+ {
+ can_message_definition_t(0, "can0", 0x128, can_message_format_t::STANDARD, frequency_clock_t(0.00000f), true),
+ can_message_definition_t(0, "can0", 0x813, can_message_format_t::STANDARD, frequency_clock_t(0.00000f), true)
+ }
+ }
+ , can_signals_
+ {
+ {
+ {
+ 0,
+ 0,
+ "engine_speed",
+ 12,
+ 8,
+ 1.00000,
+ 0,
+ 0,
+ 0,
+ frequency_clock_t(15.0000f),
+ true,
+ false,
+ {
+ },
+ false,
+ nullptr,
+ nullptr,
+ false
+ },
+ {
+ 0,
+ 0,
+ "GearshiftPosition",
+ 41,
+ 3,
+ 1.00000,
+ 0,
+ 0,
+ 0,
+ frequency_clock_t(0.00000f),
+ true,
+ false,
+ {
+ {1, "FIRST"},
+ {4, "FOURTH"},
+ {6, "NEUTRAL"},
+ {5, "REVERSE"},
+ {2, "SECOND"},
+ {3, "THIRD"}
+ },
+ false,
+ nullptr,
+ nullptr,
+ false
+ },
+ {
+ 0,
+ 0,
+ "SteeringWheelAngle",
+ 52,
+ 12,
+ 0.153920,
+ 0,
+ 0,
+ 0,
+ frequency_clock_t(0.00000f),
+ true,
+ false,
+ {
+ },
+ false,
+ handleUnsignedSteeringWheelAngle,
+ nullptr,
+ false
+ },
+ {
+ 0,
+ 0,
+ "steering_wheel_angle_error",
+ 44,
+ 12,
+ 1.00000,
+ 0,
+ 0,
+ 0,
+ frequency_clock_t(0.00000f),
+ true,
+ false,
+ {
+ },
+ false,
+ ignoreDecoder,
+ nullptr,
+ false
+ },
+ {
+ 0,
+ 0,
+ "steering_angle_sign",
+ 52,
+ 12,
+ 1.00000,
+ 0,
+ 0,
+ 0,
+ frequency_clock_t(0.00000f),
+ true,
+ false,
+ {
+ },
+ false,
+ ignoreDecoder,
+ nullptr,
+ false
+ }
+ },
+ {
+ {
+ 0,
+ 1,
+ "abc",
+ 52,
+ 12,
+ 0.153920,
+ 0,
+ 0,
+ 0,
+ frequency_clock_t(0.00000f),
+ true,
+ false,
+ {
+ },
+ false,
+ handleUnsignedSteeringWheelAngle,
+ nullptr,
+ false
+ },
+ {
+ 0,
+ 1,
+ "def",
+ 52,
+ 12,
+ 1.00000,
+ 0,
+ 0,
+ 0,
+ frequency_clock_t(0.00000f),
+ true,
+ false,
+ {
+ },
+ false,
+ decoder_t::ignoreDecoder,
+ nullptr,
+ false
+ }
+ }
+ }
+ //, obd2_signals_{/*...*/}
+{
+}
+
+
--- /dev/null
+#include "can/canread.h"
+
+using openxc::can::read::publishNumericalMessage;
+
+void handleSteeringWheelMessage(CanMessage* message,
+ CanSignal* signals, int signalCount, Pipeline* pipeline) {
+ publishNumericalMessage("latitude", 42.0, pipeline);
+}
+
+openxc_DynamicField handleInverted(CanSignal* signal, CanSignal* signals,
+ int signalCount, float value, bool* send) {
+ return openxc::payload::wrapNumber(value * -1);
+}
+
+void initializeMyStuff() { }
+
+void initializeOtherStuff() { }
+
+void myLooper() {
+ // this function will be called once each time through the main loop, after
+ // all CAN message processing has been completed
+}
},
"DEF": {
"generic_name": "def",
- "decoder": "ignoreDecoder",
+ "decoder": "decoder_t::ignoreDecoder",
"bit_position": 52,
"bit_size": 12
}
Code Review / apps / agl-service-can-low-level.git / commitdiff