Manage prefix on CAN and OBD2 prefix. Searching signals

is made on generic_name (without prefix) and returned
vector of string is filled with name with prefix. Then
you can process on them based upon their name differently.

OBD2 signals will generated recurring request on diagnostic
manager and decoding will not be handled the same way too.

Change-Id: I2c5239ef49661941a0a748debe0bd536b2954b3a
Signed-off-by: Romain Forlot <romain.forlot@iot.bzh>

diff --git a/src/can/can-bus.cpp b/src/can/can-bus.cpp
index a8a474c..7a18ce8 100644 (file)
--- a/src/can/can-bus.cpp
+++ b/src/can/can-bus.cpp
@@ -94,7 +94,7 @@ void can_bus_t::can_decode_message()
                        DEBUG(binder_interface, "Operator[] key string: %s, event valid? %d", sig.generic_name, afb_event_is_valid(s[std::string(sig.generic_name)]));
                        DEBUG(binder_interface, "Nb elt matched char: %d", (int)s.count(sig.generic_name));
                        DEBUG(binder_interface, "Nb elt matched string: %d", (int)s.count(std::string(sig.generic_name)));*/
-                       if( s.find(sig->get_generic_name()) != s.end() && afb_event_is_valid(s[sig->get_generic_name()]))
+                       if( s.find(sig->get_name()) != s.end() && afb_event_is_valid(s[sig->get_name()]))
                        {
                                decoded_message = decoder_t::translateSignal(*sig, can_message, configuration_t::instance().get_can_signals());
 

diff --git a/src/can/can-signals.cpp b/src/can/can-signals.cpp
index 0f774a1..2d2e7ea 100644 (file)
--- a/src/can/can-signals.cpp
+++ b/src/can/can-signals.cpp
@@ -35,6 +35,11 @@ std::string& can_signal_t::get_generic_name()
        return generic_name_;
 }
 
+std::string can_signal_t::get_name()
+{
+       return prefix_ + "." + generic_name_;
+}
+
 uint8_t can_signal_t::get_bit_position() const
 {
        return bit_position_;
@@ -114,6 +119,11 @@ float can_signal_t::get_last_value() const
        return last_value_;
 }
 
+void can_signal_t::set_prefix(std::string val)
+{
+       prefix_ = val;
+}
+
 void can_signal_t::set_received(bool r)
 {
        received_ = r;

diff --git a/src/can/can-signals.hpp b/src/can/can-signals.hpp
index e906d26..10403da 100644 (file)
--- a/src/can/can-signals.hpp
+++ b/src/can/can-signals.hpp
@@ -76,7 +76,9 @@ class can_signal_t
 {
 private:
        can_message_definition_t message_; /*!< message_ - The message this signal is a part of. */
-       std::string generic_name_; /*!< generic_name_ - The name of the signal to be output over USB.*/
+       std::string generic_name_; /*!< generic_name_ - The name of the signal to be output.*/
+       std::string prefix_ = "messages."; /*!< 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.*/
        uint8_t bit_position_; /*!< bitPosition_ - The starting bit of the signal in its CAN message (assuming
                                                                                *       non-inverted bit numbering, i.e. the most significant bit of
                                                                                *       each byte is 0) */
@@ -109,6 +111,7 @@ private:
 public:
        can_message_definition_t& get_message();
        std::string& get_generic_name();
+       std::string get_name();
        uint8_t get_bit_position() const;
        uint8_t get_bit_size() const;
        float get_factor() const;
@@ -126,6 +129,7 @@ public:
        bool get_received() const;
        float get_last_value() const;
 
+       void set_prefix(std::string val);
        void set_received(bool r);
        void set_last_value(float val);
 };
\ No newline at end of file

diff --git a/src/configuration.cpp b/src/configuration.cpp
index ff6adda..e56dc1c 100644 (file)
--- a/src/configuration.cpp
+++ b/src/configuration.cpp
@@ -21,25 +21,25 @@
 
 // Pre-defined OBD-II PIDs to query for if supported by the vehicle.
  std::vector<obd2_signal_t> OBD2_PIDS = {
-       { 0x04, "obd2.engine.load", 0, 100, POURCENT, 5, false},
-       { 0x05, "obd2.engine.coolant.temperature", -40, 215, DEGREES_CELSIUS, 1, false},
-       { 0x0a, "obd2.fuel.pressure", 0, 765, KPA, 1, false},
-       { 0x0b, "obd2.intake.manifold.pressure", 0, 255, KPA, 1, false},
-       { 0x0c, "obd2.engine.speed", 0, 16383, RPM, 5, false},
-       { 0x0d, "obd2.vehicle.speed", 0, 255, KM_H, 5, false},
-       { 0x0f, "obd2.intake.air.temperature", -40, 215, DEGREES_CELSIUS, 1, false},
-       { 0x10, "obd2.mass.airflow", 0, 655, GRAMS_SEC, 5, false},
-       { 0x11, "obd2.throttle.position", 0, 100, POURCENT, 5, false},
-       { 0x1f, "obd2.running.time", 0, 65535, SECONDS, 1, false},
-       { 0x2d, "obd2.EGR.error", -100, 99, POURCENT, 0, false},
-       { 0x2f, "obd2.fuel.level", 0, 100, POURCENT, 1, false},
-       { 0x33, "obd2.barometric.pressure", 0, 255, KPA, 1, false},
-       { 0x4c, "obd2.commanded.throttle.position", 0, 100, POURCENT, 1, false},
-       { 0x52, "obd2.ethanol.fuel.percentage", 0, 100, POURCENT, 1, false},
-       { 0x5a, "obd2.accelerator.pedal.position", 0, 100, POURCENT, 5, false},
-       { 0x5b, "obd2.hybrid.battery-pack.remaining.life", 0, 100, POURCENT, 5, false},
-       { 0x5c, "obd2.engine.oil.temperature",-40, 210, DEGREES_CELSIUS, 1, false},
-       { 0x63, "obd2.engine.torque", 0, 65535, NM, 1, false}
+       obd2_signal_t(0x04, "engine.load", 0, 100, POURCENT, 5, false),
+       obd2_signal_t(0x05, "engine.coolant.temperature", -40, 215, DEGREES_CELSIUS, 1, false),
+       obd2_signal_t(0x0a, "fuel.pressure", 0, 765, KPA, 1, false),
+       obd2_signal_t(0x0b, "intake.manifold.pressure", 0, 255, KPA, 1, false),
+       obd2_signal_t(0x0c, "engine.speed", 0, 16383, RPM, 5, false),
+       obd2_signal_t(0x0d, "vehicle.speed", 0, 255, KM_H, 5, false),
+       obd2_signal_t(0x0f, "intake.air.temperature", -40, 215, DEGREES_CELSIUS, 1, false),
+       obd2_signal_t(0x10, "mass.airflow", 0, 655, GRAMS_SEC, 5, false),
+       obd2_signal_t(0x11, "throttle.position", 0, 100, POURCENT, 5, false),
+       obd2_signal_t(0x1f, "running.time", 0, 65535, SECONDS, 1, false),
+       obd2_signal_t(0x2d, "EGR.error", -100, 99, POURCENT, 0, false),
+       obd2_signal_t(0x2f, "fuel.level", 0, 100, POURCENT, 1, false),
+       obd2_signal_t(0x33, "barometric.pressure", 0, 255, KPA, 1, false),
+       obd2_signal_t(0x4c, "commanded.throttle.position", 0, 100, POURCENT, 1, false),
+       obd2_signal_t(0x52, "ethanol.fuel.percentage", 0, 100, POURCENT, 1, false),
+       obd2_signal_t(0x5a, "accelerator.pedal.position", 0, 100, POURCENT, 5, false),
+       obd2_signal_t(0x5b, "hybrid.battery-pack.remaining.life", 0, 100, POURCENT, 5, false),
+       obd2_signal_t(0x5c, "engine.oil.temperature",-40, 210, DEGREES_CELSIUS, 1, false),
+       obd2_signal_t(0x63, "engine.torque", 0, 65535, NM, 1, false)
 };
 
 // Dumb signals and message implementation. To get compile.
@@ -115,7 +115,7 @@ void configuration_t::set_active_message_set(uint8_t id)
 }
 
 /**
- * @fn std::vector<std::string> find_signals(const openxc_DynamicField &key)
+ * @fn std::vector<std::string> find_can_signals(const openxc_DynamicField &key)
  * @brief return signals name found searching through CAN_signals and OBD2 pid
  * 
  * @param[in] key - can contain numeric or string value in order to search against 
@@ -134,7 +134,7 @@ void configuration_t::find_obd2_signals(const openxc_DynamicField &key, std::vec
                                lookup_signals_by_id(key.numeric_value, obd2_signals_[active_message_set_], found_signals);
                        break;
                default:
-                       ERROR(binder_interface, "find_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only.");
+                       ERROR(binder_interface, "find_obd2_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only.");
                        break;
        }
        DEBUG(binder_interface, "Found %d signal(s)", (int)found_signals.size());
@@ -160,7 +160,7 @@ void configuration_t::find_can_signals(const openxc_DynamicField& key, std::vect
                        lookup_signals_by_id(key.numeric_value, can_signals_[active_message_set_], found_signals);
                        break;
                default:
-                       ERROR(binder_interface, "find_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only.");
+                       ERROR(binder_interface, "find_can_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only.");
                        break;
        }
        DEBUG(binder_interface, "Found %d signal(s)", (int)found_signals.size());

diff --git a/src/diagnostic/diagnostic-message.cpp b/src/diagnostic/diagnostic-message.cpp
index 8f42653..bd76de0 100644 (file)
--- a/src/diagnostic/diagnostic-message.cpp
+++ b/src/diagnostic/diagnostic-message.cpp
@@ -48,6 +48,16 @@ std::string& obd2_signal_t::get_generic_name()
        return generic_name_;
 }
 
+std::string obd2_signal_t::get_name()
+{
+       return prefix_ + "." + generic_name_;
+}
+
+void obd2_signal_t::set_prefix(std::string val)
+{
+       prefix_ = val;
+}
+
 bool obd2_signal_t::is_obd2_response(can_message_t can_message)
 {
        /*

diff --git a/src/diagnostic/diagnostic-message.hpp b/src/diagnostic/diagnostic-message.hpp
index 5ca651c..534b9a5 100644 (file)
--- a/src/diagnostic/diagnostic-message.hpp
+++ b/src/diagnostic/diagnostic-message.hpp
@@ -40,35 +40,14 @@ enum UNIT {
 };
 
 /**
- *     @brief A representation of an OBD-II PID.
- *
- * pid - The 1 byte PID.
- * name - A human readable name to use for this PID when published.
- * min - minimum value for this pid
- * max - maximum value for this pid
- * unit - unit used
- * frequency - The frequency to request this PID if supported by the vehicle
- *             when automatic, recurring OBD-II requests are enabled.
- *     supported - is it supported by the vehicle. Initialized after scan
- */
-typedef struct _Obd2Pid {
-       uint8_t pid;
-       const char* generic_name;
-       const int min;
-       const int max;
-       enum UNIT unit;
-       int frequency;
-       bool supported;
-} Obd2Pid;
-
-/**
- * @brief - Object to handle obd2 session with pre-scan of supported pid
- * then request them regularly
+ * @brief - A representation of an OBD-II PID.
  */
 class obd2_signal_t {
        private:
                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.*/
+               std::string prefix_ = "diagnostic_messages."; /*!< 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.*/
                int min_; /*!< min_ - Minimum value that can take this pid */
                int max_; /*!< max_ - Maximum value that can take this pid */
                enum UNIT unit_; /*!< unit_ : Which unit system is used by that pid. See enum UNIT above.*/
@@ -81,7 +60,9 @@ class obd2_signal_t {
 
                uint32_t get_pid();
                std::string& get_generic_name();
+               std::string get_name();
 
+               void set_prefix(std::string val);
                void add_request(int pid);
 
                bool is_obd2_response(can_message_t can_message);

diff --git a/src/utils/signals.hpp b/src/utils/signals.hpp
index 4380045..4675b1f 100644 (file)
--- a/src/utils/signals.hpp
+++ b/src/utils/signals.hpp
@@ -55,7 +55,7 @@ void lookup_signals_by_name(const std::string& key, std::vector<T>& signals, std
        for(T& s : signals)
        {
                if(::fnmatch(key.c_str(), s.get_generic_name().c_str(), FNM_CASEFOLD) == 0)
-                       found_signals_name.push_back(s.get_generic_name());
+                       found_signals_name.push_back(s.get_name());
        }
 }
 
@@ -78,7 +78,7 @@ void lookup_signals_by_id(const double key, std::vector<T>& signals, std::vector
        {
                if(configuration_t::instance().get_signal_id(s) == key)
                {
-                       found_signals_name.push_back(s.get_generic_name());
+                       found_signals_name.push_back(s.get_name());
                }
        }
 }