Add some options for J1939 support

This commit add some options for the support of the J1939.

Signed-off-by: Arthur Guyader <arthur.guyader@iot.bzh>
Change-Id: I9baee6a7319c8e8effa988d940a67e45ab64496d

diff --git a/src/main.cpp b/src/main.cpp
index 7880da2..ac7ce4b 100644 (file)
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -109,16 +109,16 @@ template <>
 std::ostream& operator<<(std::ostream& o, const generator<openxc::message_set>& v)\r
 {\r
        o       << v.line_prefix_\r
-               << "{std::make_shared<can_message_set_t>(can_message_set_t{"\r
+               << "{std::make_shared<message_set_t>(message_set_t{"\r
                << "0,"\r
                << gen(v.v_.name()) << ",\n"\r
-               << "\t\t\t{ // beginning can_message_definition_ vector\n"\r
+               << "\t\t\t{ // beginning message_definition_ vector\n"\r
                << gen(v.v_.messages(), "\t\t\t")\r
-               << "\n\t\t}, // end can_message_definition vector\n"\r
+               << "\n\t\t}, // end message_definition vector\n"\r
                << "\t\t\t{ // beginning diagnostic_messages_ vector\n"\r
                << gen(v.v_.diagnostic_messages(),"\t\t\t") << "\n"\r
                << "\t\t\t} // end diagnostic_messages_ vector\n"\r
-               << "\t\t})} // end can_message_set entry\n";\r
+               << "\t\t})} // end message_set entry\n";\r
        return o;\r
 }\r
 \r
@@ -146,22 +146,33 @@ std::ostream& operator<<(std::ostream& o, const generator<std::map<std::string,
 template <>\r
 std::ostream& operator<<(std::ostream& o, const generator<openxc::signal>& v)\r
 {\r
-       o       << v.line_prefix_ << "{std::make_shared<can_signal_t> (can_signal_t{\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() : v.v_.states().size() ? "decoder_t::decode_state" : "nullptr") << ",\n"\r
-               << v.line_prefix_ << '\t' << (v.v_.encoder().size() ? v.v_.encoder() : "nullptr") << ",\n"\r
-               << v.line_prefix_ << '\t' << "false\n"\r
+       o       << v.line_prefix_ << "{std::make_shared<signal_t> (signal_t{\n"\r
+               << v.line_prefix_ << "\t" << gen(v.v_.generic_name()) << ",// generic_name\n"\r
+               << v.line_prefix_ << "\t" << v.v_.bit_position() << ",// bit_position\n"\r
+               << v.line_prefix_ << "\t" << v.v_.bit_size() << ",// bit_size\n"\r
+               << v.line_prefix_ << "\t" << gen(v.v_.factor()) << ",// factor\n"\r
+               << v.line_prefix_ << "\t" << v.v_.offset() << ",// offset\n"\r
+               << v.line_prefix_ << "\t" << "0,// min_value\n"\r
+               << v.line_prefix_ << "\t" << "0,// max_value\n"\r
+               << v.line_prefix_ << "\tfrequency_clock_t(" << gen(v.v_.max_frequency()) << "),// frequency\n"\r
+               << v.line_prefix_ << "\t" << gen(v.v_.send_same()) << ",// send_same\n"\r
+               << v.line_prefix_ << "\t" << gen(v.v_.force_send_changed()) << ",// force_send_changed\n"\r
+               << gen(v.v_.states(), v.line_prefix_ + '\t') << ",// states\n"\r
+               << v.line_prefix_ << '\t' << gen(v.v_.writable()) << ",// writable\n"\r
+               << v.line_prefix_ << '\t' << (v.v_.decoder().size() ? v.v_.decoder() : v.v_.states().size() ? "decoder_t::decode_state" : "nullptr") << ",// decoder\n"\r
+               << v.line_prefix_ << '\t' << (v.v_.encoder().size() ? v.v_.encoder() : "nullptr") << ",// encoder\n"\r
+               << v.line_prefix_ << '\t' << "false,// received\n";\r
+               std::string multi_first = "";\r
+               if(v.v_.multiplex().first){\r
+                       multi_first = "true";\r
+               }else{\r
+                       multi_first = "false";\r
+               }\r
+               std::string multi = "std::make_pair<bool, int>(" + multi_first + "," + std::to_string(v.v_.multiplex().second) + ")";\r
+       o       << v.line_prefix_ << '\t' << multi << ",// multiplex\n"\r
+               << v.line_prefix_ << '\t' << v.v_.is_big_endian() << ",// is_big_endian\n"\r
+               << v.line_prefix_ << '\t' << v.v_.is_signed() << ",// is_signed\n"\r
+               << v.line_prefix_ << "\t" << gen(v.v_.unit()) << ",// unit\n"\r
                << v.line_prefix_ << "})}";\r
        return o;\r
 }\r
@@ -170,15 +181,26 @@ template <>
 std::ostream& operator<<(std::ostream& o, const generator<openxc::can_message>& v)\r
 {\r
        o       << v.line_prefix_\r
-               << "{std::make_shared<can_message_definition_t>(can_message_definition_t{"\r
+               << "{std::make_shared<message_definition_t>(message_definition_t{"\r
                << gen(v.v_.bus()) << ","\r
                << v.v_.id() << ","\r
-               << v.v_.is_fd() << ","\r
-               << "can_message_format_t::STANDARD,"\r
-               << "frequency_clock_t(" << gen(v.v_.max_frequency()) << "),"\r
-               << gen(v.v_.force_send_changed()) << ",\n";\r
+               << "\"" << v.v_.name() << "\","\r
+               << v.v_.length() << ","\r
+               << gen(v.v_.is_fd()) << ",";\r
+               if(v.v_.is_j1939()){\r
+                       o << "message_format_t::J1939,";\r
+               }\r
+               else if(v.v_.is_extended())\r
+               {\r
+                       o << "message_format_t::EXTENDED,";\r
+               }\r
+               else{\r
+                       o << "message_format_t::STANDARD,";\r
+               }\r
+       o       << "frequency_clock_t(" << gen(v.v_.max_frequency()) << "),"\r
+               << gen(v.v_.force_send_changed()) << ",";\r
                std::uint32_t index = 0;\r
-       o       << "\t\t\t\t\t{ // beginning can_signals vector\n";\r
+       o       << "\t\t\t\t\t{ // beginning signals vector\n";\r
                        std::uint32_t signal_count = (uint32_t)v.v_.signals().size();\r
                        for(const openxc::signal& s : v.v_.signals())\r
                        {\r
@@ -187,8 +209,8 @@ std::ostream& operator<<(std::ostream& o, const generator<openxc::can_message>&
                                --signal_count;\r
        o                       << '\n';\r
                        }\r
-       o       << "\t\t\t\t\t} // end can_signals vector\n"\r
-               << "\t\t\t\t})} // end can_message_definition entry\n";\r
+       o       << "\t\t\t\t\t} // end signals vector\n"\r
+               << "\t\t\t\t})} // end message_definition entry\n";\r
        return o;\r
 }\r
 \r
@@ -225,26 +247,26 @@ void generate(const std::string& header, const std::string& footer, const openxc
 \r
        out     << "application_t::application_t()\n"\r
                << "    : can_bus_manager_{utils::config_parser_t{\"/etc/dev-mapping.conf\"}}\n"\r
-               << "    , can_message_set_{\n"\r
+               << "    , message_set_{\n"\r
                << gen(message_set, "\t\t")\r
-               << "\t} // end can_message_set vector\n"\r
+               << "\t} // end message_set vector\n"\r
                << "{\n"\r
-               << "    for(auto& cms: can_message_set_)\n"\r
+               << "    for(std::shared_ptr<message_set_t> cms: message_set_)\n"\r
                << "    {\n"\r
-               << "            std::vector<std::shared_ptr<can_message_definition_t> >& can_messages_definition = cms->get_can_message_definition();\n"\r
-               << "            for(auto& cmd : can_messages_definition)\n"\r
+               << "            std::vector<std::shared_ptr<message_definition_t>> messages_definition = cms->get_messages_definition();\n"\r
+               << "            for(std::shared_ptr<message_definition_t> cmd : messages_definition)\n"\r
                << "            {\n"\r
-               << "                    cmd->set_parent(cms.get());\n"\r
-               << "                    std::vector<std::shared_ptr<can_signal_t> >& can_signals = cmd->get_can_signals();\n"\r
-               << "                    for(auto& sig: can_signals)\n"\r
+               << "                    cmd->set_parent(cms);\n"\r
+               << "                    std::vector<std::shared_ptr<signal_t>> signals = cmd->get_signals();\n"\r
+               << "                    for(std::shared_ptr<signal_t> sig: signals)\n"\r
                << "                    {\n"\r
-               << "                            sig->set_parent(cmd.get());\n"\r
+               << "                            sig->set_parent(cmd);\n"\r
                << "                    }\n"\r
                << "            }\n\n"\r
-               << "            std::vector<std::shared_ptr<diagnostic_message_t> >& diagnostic_messages = cms->get_diagnostic_messages();\n"\r
-               << "            for(auto& dm : diagnostic_messages)\n"\r
+               << "            std::vector<std::shared_ptr<diagnostic_message_t>> diagnostic_messages = cms->get_diagnostic_messages();\n"\r
+               << "            for(std::shared_ptr<diagnostic_message_t> dm : diagnostic_messages)\n"\r
                << "            {\n"\r
-               << "                    dm->set_parent(cms.get());\n"\r
+               << "                    dm->set_parent(cms);\n"\r
                << "            }\n"\r
                << "    }\n"\r
                << "            }\n\n"\r

diff --git a/src/openxc/can_message.cpp b/src/openxc/can_message.cpp
index 77418d8..70b98a7 100755 (executable)
--- a/src/openxc/can_message.cpp
+++ b/src/openxc/can_message.cpp
@@ -6,17 +6,17 @@ namespace openxc
        {\r
                return id_;\r
        }\r
-       \r
+\r
        void can_message::id(const std::string& id)\r
        {\r
                id_ = id;\r
        }\r
-       \r
+\r
        std::string can_message::bus() const\r
        {\r
                return bus_;\r
        }\r
-       \r
+\r
        void can_message::is_fd(const bool is_fd)\r
        {\r
                is_fd_ = is_fd;\r
@@ -26,56 +26,82 @@ namespace openxc
        {\r
                return is_fd_;\r
        }\r
+       void can_message::is_extended(const bool is_extended)\r
+       {\r
+               is_extended_ = is_extended;\r
+       }\r
+\r
+       bool can_message::is_extended() const\r
+       {\r
+               return is_extended_;\r
+       }\r
+\r
+       void can_message::is_j1939(const bool is_j1939)\r
+       {\r
+               is_j1939_ = is_j1939;\r
+       }\r
+\r
+       bool can_message::is_j1939() const\r
+       {\r
+               return is_j1939_;\r
+       }\r
 \r
        bool can_message::bit_numbering_inverted() const\r
        {\r
                return bit_numbering_inverted_;\r
        }\r
-       \r
+\r
        const std::vector<signal>& can_message::signals() const\r
        {\r
                return signals_;\r
        }\r
-       \r
+\r
        std::string can_message::name() const\r
        {\r
                return name_;\r
        }\r
-       \r
+\r
        std::vector<std::string> can_message::handlers() const\r
        {\r
                return handlers_;\r
        }\r
-       \r
+\r
        bool can_message::enabled() const\r
        {\r
                return enabled_;\r
        }\r
-       \r
+\r
        float can_message::max_frequency() const\r
        {\r
                return max_frequency_;\r
        }\r
-       \r
+\r
        float can_message::max_signal_frequency() const\r
        {\r
                return max_signal_frequency_;\r
        }\r
-       \r
+\r
        bool can_message::force_send_changed() const\r
        {\r
                return force_send_changed_;\r
        }\r
-       \r
+\r
        bool can_message::force_send_changed_signals() const\r
        {\r
                return force_send_changed_;\r
        }\r
-       \r
+\r
+       uint32_t can_message::length() const\r
+       {\r
+               return length_;\r
+       }\r
+\r
        void can_message::from_json(const nlohmann::json& j)\r
        {\r
                bus_ = j.count("bus") ? j["bus"].get<std::string>() : "";\r
                is_fd_ = j.count("is_fd") ? j["is_fd"].get<bool>() : false;\r
+               is_extended_ = j.count("is_extended") ? j["is_extended"].get<bool>() : false;\r
+               is_j1939_ = j.count("is_j1939") ? j["is_j1939"].get<bool>() : false;\r
                bit_numbering_inverted_ = j.count("bit_numbering_inverted") ? j["bit_numbering_inverted"].get<bool>() : false;\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
@@ -84,7 +110,8 @@ namespace openxc
                max_signal_frequency_ = j.count("max_signal_frequency") ? j["max_signal_frequency"].get<float>() : 5;\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
+               length_ = j.count("length") ? j["length"].get<uint32_t>() : 0;\r
+\r
                if(j.count("signals"))\r
                {\r
                        std::map<std::string, nlohmann::json> signals = j["signals"];\r
@@ -95,9 +122,9 @@ namespace openxc
                                signals_.push_back(sig);\r
                        }\r
                }\r
-               \r
+\r
        }\r
-       \r
+\r
        std::uint32_t can_message::get_signals_count() const\r
        {\r
                return (uint32_t)signals_.size();\r
@@ -108,6 +135,10 @@ namespace openxc
                nlohmann::json j;\r
                j["bus"] = bus_;\r
                j["is_fd"] = is_fd_;\r
+\r
+               j["is_extended"] = is_extended_;\r
+\r
+               j["is_j1939"] = is_j1939_;\r
                j["bit_numbering_inverted"] = bit_numbering_inverted_;\r
                j["signals"] = signals_;\r
                j["name"] = name_;\r
@@ -117,6 +148,7 @@ namespace openxc
                j["max_signal_frequency"] = max_signal_frequency_;\r
                j["force_send_changed"] = force_send_changed_;\r
                j["force_send_changed_signals"] = force_send_changed_signals_;\r
+               j["length"] = length_;\r
                return j;\r
        }\r
 \r
@@ -124,7 +156,7 @@ namespace openxc
        {\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

diff --git a/src/openxc/can_message.hpp b/src/openxc/can_message.hpp
index f2d1b6e..98b38a5 100755 (executable)
--- a/src/openxc/can_message.hpp
+++ b/src/openxc/can_message.hpp
@@ -22,13 +22,22 @@ namespace openxc
                float                                                   max_signal_frequency_;\r
                bool                                                    force_send_changed_;\r
                bool                                                    force_send_changed_signals_;\r
-               bool                            is_fd_;\r
+               bool                                                    is_fd_;\r
+               bool                                                    is_extended_;\r
+               bool                                                    is_j1939_;\r
+               uint32_t                                                length_;\r
+               float                                                   min_value;\r
+               float                                                   max_value;\r
 \r
        public:\r
                std::string id() const;\r
                void id(const std::string& id);\r
                void is_fd(const bool is_fd);\r
                bool is_fd() const;\r
+               void is_extended(const bool is_extended);\r
+               bool is_extended() const;\r
+               void is_j1939(const bool is_j1939);\r
+               bool is_j1939() const;\r
                std::string     bus() const;\r
                bool bit_numbering_inverted() const;\r
                const std::vector<signal>& signals() const;\r
@@ -39,10 +48,11 @@ namespace openxc
                float max_signal_frequency() const;\r
                bool force_send_changed() const;\r
                bool force_send_changed_signals() const;\r
-               \r
+               uint32_t length() const;\r
+\r
                void from_json(const nlohmann::json& j);\r
                nlohmann::json to_json() const;\r
-               \r
+\r
                std::uint32_t get_signals_count() const;\r
        };\r
 \r

diff --git a/src/openxc/signal.cpp b/src/openxc/signal.cpp
index e9c1088..e60c3ee 100755 (executable)
--- a/src/openxc/signal.cpp
+++ b/src/openxc/signal.cpp
@@ -83,6 +83,23 @@ namespace openxc
        {\r
                return encoder_;\r
        }\r
+\r
+       std::pair<bool,int> signal::multiplex() const{\r
+               return multiplex_;\r
+       }\r
+\r
+       bool signal::is_big_endian() const{\r
+               return is_big_endian_;\r
+       }\r
+\r
+       bool signal::is_signed() const{\r
+               return is_signed_;\r
+       }\r
+\r
+       std::string signal::unit() const{\r
+               return unit_;\r
+       }\r
+\r
        \r
        void signal::from_json(const nlohmann::json& j)\r
        {\r
@@ -99,6 +116,29 @@ namespace openxc
                force_send_changed_ = j.count("force_send_changed") ? j["force_send_changed"].get<bool>() : false;\r
                writable_ = j.count("writable") ? j["writable"].get<bool>() : false;\r
                encoder_ = j.count("encoder") ? j["encoder"].get<std::string>() : "";\r
+               if(j.count("multiplex"))\r
+               {\r
+                       std::string mult = j["multiplex"].get<std::string>();\r
+                       bool first = false;\r
+                       int second = 0 ;\r
+                       if(mult.compare("Multiplexor") == 0){\r
+                               first = true;\r
+                       }\r
+                       else if (mult.compare("") != 0)\r
+                       {\r
+                               second = std::stoi(mult);\r
+                       }\r
+                       multiplex_ = std::make_pair(first,second);\r
+               }\r
+               else\r
+               {\r
+                       multiplex_ =  std::make_pair(false,0);\r
+               }\r
+               is_big_endian_ = j.count("is_big_endian") ? j["is_big_endian"].get<bool>() : false;\r
+               is_signed_ = j.count("is_signed") ? j["is_signed"].get<bool>() : false;\r
+               unit_ = j.count("unit") ? j["unit"].get<std::string>() : "";\r
+\r
+\r
 \r
                if (j.count("states"))\r
                {\r
@@ -127,6 +167,29 @@ namespace openxc
                j["force_send_changed"] = force_send_changed_;\r
                j["writable"] = writable_;\r
                j["encoder"] = encoder_;\r
+\r
+               std::string multi = "";\r
+\r
+               if(multiplex_.first)\r
+               {\r
+                       multi = "Multiplexor";\r
+               }\r
+               else if(multiplex_.second != 0)\r
+               {\r
+                       multi = std::to_string(multiplex_.second);\r
+               }\r
+               else\r
+               {\r
+                       multi = "";\r
+               }\r
+\r
+               j["multiplex"] = multi;\r
+\r
+\r
+\r
+               j["is_big_endian"] = is_big_endian_;\r
+               j["is_signed"] = is_signed_;\r
+               j["unit"] = unit_;\r
                return j;\r
        }\r
 \r

diff --git a/src/openxc/signal.hpp b/src/openxc/signal.hpp
index e0124c3..750926b 100755 (executable)
--- a/src/openxc/signal.hpp
+++ b/src/openxc/signal.hpp
@@ -21,11 +21,16 @@ namespace openxc
                bool                                                                                            ignore_;\r
                bool                                                                                            enabled_;\r
                std::map<std::string, std::vector<std::uint32_t>>       states_;\r
-               float                                                                           max_frequency_;\r
+               float                                                                                           max_frequency_;\r
                bool                                                                                            send_same_;\r
                bool                                                                                            force_send_changed_;\r
                bool                                                                                            writable_;\r
                std::string                                                                                     encoder_;\r
+               std::pair<bool,int>                                                                     multiplex_;\r
+               bool                                                                                            is_big_endian_;\r
+               bool                                                                                            is_signed_;\r
+               std::string                                                                                     unit_;\r
+\r
        public:\r
                std::string id() const;\r
                void id(const std::string& id);\r
@@ -43,7 +48,11 @@ namespace openxc
                bool force_send_changed() const;\r
                bool writable() const;\r
                std::string encoder() const;\r
-               \r
+               std::pair<bool,int> multiplex() const;\r
+               bool is_big_endian() const;\r
+               bool is_signed() const;\r
+               std::string unit() const;\r
+\r
                void from_json(const nlohmann::json& j);\r
                nlohmann::json to_json() const;\r
        };\r