Multifixes: class and methods, typo, comments

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

diff --git a/src/can-utils.cpp b/src/can-utils.cpp
index a50bfd4..7144c02 100644 (file)
--- a/src/can-utils.cpp
+++ b/src/can-utils.cpp
@@ -30,77 +30,84 @@ can_message_t::can_message_t(const struct afb_binding_interface* interface)
 
 uint32_t can_message_t::get_id() const
 {
-       (id_ != 0) ? return id_ : return 0;
+       if (id_ != 0)
+               return id_;
+       return 0;
 }
 
 int can_message_t::get_format() const
 {
-       (format_ != CanMessageFormat::SIMPLE || format_ != CanMessageFormat::EXTENDED) return -1 : return format_;
+       if (format_ != CanMessageFormat::STANDARD || format_ != CanMessageFormat::EXTENDED)
+               return -1;
+       return format_;
 }
 
-uint8_t can_message_t::get_data() const
+const uint8_t* can_message_t::get_data() const
 {
-       return data_;
+       return &data_;
 }
-uint8_t can_message_t::get_lenght() const
+uint8_t can_message_t::get_length() const
 {
-       return lenght_;
+       return length_;
 }
 
-void can_message_t::set_id(uint32_t &new_id)
+void can_message_t::set_id(const uint32_t new_id)
 {
-       switch(format):
-               case CanMessageFormat::SIMPLE:
-                       id = new_id & CAN_SFF_MASK;
+       switch(format_)
+       {
+               case CanMessageFormat::STANDARD:
+                       id_ = new_id & CAN_SFF_MASK;
+                       break;
                case CanMessageFormat::EXTENDED:
-                       id = new_id & CAN_EFF_MASK;
+                       id_ = new_id & CAN_EFF_MASK;
+                       break;
                default:
                        ERROR(interface_, "ERROR: Can set id, not a compatible format or format not set prior to set id.");
+                       break;
+       }
 }
 
-void can_message_t::set_format(CanMessageFormat &new_format)
+void can_message_t::set_format(const CanMessageFormat new_format)
 {
-       if(new_format == CanMessageFormat::SIMPLE || new_format == CanMessageFormat::EXTENDED)
-               format = new_format;
+       if(new_format == CanMessageFormat::STANDARD || new_format == CanMessageFormat::EXTENDED)
+               format_ = new_format;
        else
                ERROR(interface_, "ERROR: Can set format, wrong format chosen");
 }
 
-void can_message_t::set_data(uint8_t &new_data)
+void can_message_t::set_data(const uint8_t new_data)
 {
-       ::memcpy(data_, new_data, new_data.size());
-       lenght_ = new_data(size);
+       ::memcpy(&data_, &new_data, sizeof(new_data));
+       length_ = sizeof(new_data);
 }
 
 /*
- * This is the preferred way to initialize a CanMessage object 
+ * @brief This is the preferred way to initialize a CanMessage object 
  * from a read canfd_frame message.
  * 
- * params: canfd_frame pointer
+ * @param: canfd_frame pointer
  */
-void can_message_t::convert_from_canfd_frame(canfd_frame &frame)
+void can_message_t::convert_from_canfd_frame(const canfd_frame& frame)
 {
-       lenght_ = (frame.len > CAN_MAX_DLEN) ? CAN_MAX_DLEN : frame.len;
-       lenght_ = (frame.len > CANFD_MAX_DLEN) ? CANFD_MAX_DLEN : frame.len;
-
-       switch (frame.can_id): 
-               case (frame.can_id & CAN_ERR_FLAG):
-                       id_ = frame.can_id & (CAN_ERR_MASK|CAN_ERR_FLAG);
-                       break;
-               case (frame.can_id & CAN_EFF_FLAG):
-                       id_ = frame.can_id & CAN_EFF_MASK;
-                       format_ = CanMessageFormat::EXTENDED;
-                       break;
-               default:
-                       format_ = CanMessageFormat::STANDARD;
-                       id_ = frame.can_id & CAN_SFF_MASK;
-                       break;
+       length_ = (frame.len > CAN_MAX_DLEN) ? (uint8_t)CAN_MAX_DLEN : frame.len;
+       length_ = (frame.len > CANFD_MAX_DLEN) ? (uint8_t)CANFD_MAX_DLEN : frame.len;
 
-       if (sizeof(frame.data) <= data_.size())
+       if (frame.can_id & CAN_ERR_FLAG)
+               id_ = frame.can_id & (CAN_ERR_MASK|CAN_ERR_FLAG);
+       else if (frame.can_id & CAN_EFF_FLAG)
        {
-               ::memcpy(data_, canfd_frame.data, lenght_);
-               return 0;
-       } else if (sizeof(frame.data) >= CAN_MAX_DLEN)
+               id_ = frame.can_id & CAN_EFF_MASK;
+               format_ = CanMessageFormat::EXTENDED;
+       }
+       else
+       {
+               id_ = frame.can_id & CAN_SFF_MASK;
+               format_ = CanMessageFormat::STANDARD;
+       }
+
+       if (sizeof(frame.data) <= sizeof(data_))
+               ::memcpy(&data_, frame.data, length_);
+       else if (sizeof(frame.data) >= CAN_MAX_DLEN)
                ERROR(interface_, "can_message_t: canfd_frame data too long to be stored into CanMessage object");
 }
 
@@ -109,8 +116,8 @@ canfd_frame can_message_t::convert_to_canfd_frame()
        canfd_frame frame;
 
        frame.can_id = get_id();
-       frame.len = get_lenght();
-       ::memcpy(frame.data, get_data(), lenght_);
+       frame.len = get_length();
+       ::memcpy(frame.data, get_data(), length_);
 
        return frame;
 }
@@ -182,6 +189,7 @@ int can_bus_dev_t::close()
 {
        ::close(can_socket_);
        can_socket_ = -1;
+       return can_socket_;
 }
 
 canfd_frame can_bus_dev_t::read(const struct afb_binding_interface* interface)
@@ -245,16 +253,21 @@ bool can_bus_dev_t::is_running()
  * 
  * @return the next queue element or NULL if queue is empty.
  */
-can_message_t can_bus_dev_t::next_can_message()
+can_message_t can_bus_dev_t::next_can_message(const struct afb_binding_interface* interface)
 {
-       if(! can_message_q_.empty())
+       can_message_t can_msg(interface);
+
+       if(!can_message_q_.empty())
        {
-               can_message_t can_msg = can_message_q_.front();
+               can_msg = can_message_q_.front();
                can_message_q_.pop();
+               DEBUG(interface, "next_can_message: Here is the next can message : id %d, length %d", can_msg.get_id(), can_msg.get_length());
                return can_msg;
        }
        
+       NOTICE(interface, "next_can_message: End of can message queue");
        has_can_message_ = false;
+       return can_msg;
 }
 
 /**
@@ -296,7 +309,6 @@ int can_bus_dev_t::send_can_message(can_message_t& can_msg, const struct afb_bin
        {
                nbytes = ::sendto(can_socket_, &f, sizeof(struct canfd_frame), 0,
                                (struct sockaddr*)&txAddress_, sizeof(txAddress_));
-                               
                if (nbytes == -1)
                {
                        ERROR(interface, "send_can_message: Sending CAN frame failed.");
@@ -325,7 +337,6 @@ can_bus_t::can_bus_t(const afb_binding_interface *itf, int& conf_file)
 /**
  * @brief start threads relative to the can bus: decoding and pushing
  * as the reading is handled by can_bus_dev_t object
- * 
  */
 void can_bus_t::start_threads()
 {
@@ -419,14 +430,19 @@ std::vector<std::string> can_bus_t::read_conf()
  */
 openxc_VehicleMessage can_bus_t::next_vehicle_message()
 {
+       openxc_VehicleMessage v_msg;
+
        if(! vehicle_message_q_.empty())
        {
-               openxc_VehicleMessage v_msg = vehicle_message_q_.front();
+               v_msg = vehicle_message_q_.front();
                vehicle_message_q_.pop();
+               DEBUG(interface_, "next_vehicle_message: next vehicle message poped");
                return v_msg;
        }
-
+       
+       NOTICE(interface_, "next_vehicle_message: End of vehicle message queue");
        has_vehicle_message_ = false;
+       return v_msg;
 }
 
 /**

diff --git a/src/can-utils.hpp b/src/can-utils.hpp
index ea116b7..c6b23a2 100644 (file)
--- a/src/can-utils.hpp
+++ b/src/can-utils.hpp
@@ -119,7 +119,7 @@ class can_message_t {
                const struct afb_binding_interface* interface_;
                uint32_t id_;
                CanMessageFormat format_;
-               uint8_t data_[CAN_MESSAGE_SIZE];
+               uint8_t data_;
                uint8_t length_;
 
        public:
@@ -127,15 +127,15 @@ class can_message_t {
 
                uint32_t get_id() const;
                int get_format() const;
-               uint8_t get_data() const;
-               uint8_t get_lenght() const;
+               const uint8_t* get_data() const;
+               uint8_t get_length() const;
 
-               void set_id(uint32_t id);
-               void set_format(CanMessageFormat format);
-               void set_data(uint8_t data);
-               void set_lenght(uint8_t length);
+               void set_id(const uint32_t new_id);
+               void set_format(const CanMessageFormat format);
+               void set_data(const uint8_t new_data);
+               void set_length(const uint8_t new_length);
 
-               void convert_from_canfd_frame(canfd_frame frame);
+               void convert_from_canfd_frame(const canfd_frame& frame);
                canfd_frame convert_to_canfd_frame();
 };
 
@@ -167,7 +167,7 @@ class can_bus_dev_t {
                void start_reading();
                canfd_frame read(const struct afb_binding_interface *interface);
                
-               can_message_t next_can_message();
+               can_message_t next_can_message(const struct afb_binding_interface* interface);
                void push_new_can_message(const can_message_t& can_msg);                
                bool has_can_message() const;
 
@@ -283,7 +283,7 @@ typedef struct CanSignal CanSignal;
  * @param[in] format - the format of the message's ID.
  * @param[in] 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.
+ *             handlers to retriec++ if ? syntaxve.
  * @param[in] forceSendChanged - If true, regardless of the frequency, it will send CAN
  *             message if it has changed when using raw passthrough.
  * @param[in] lastValue - The last received value of the message. Defaults to undefined.

diff --git a/src/can_decode_message.cpp b/src/can_decode_message.cpp
index 0f26290..f5f530e 100644 (file)
--- a/src/can_decode_message.cpp
+++ b/src/can_decode_message.cpp
@@ -26,16 +26,15 @@ void can_decode_message(can_bus_t &can_bus)
        openxc_VehicleMessage vehicle_message;
        openxc_DynamicField search_key, ret;
        bool send = true;
-       
+
        decoder_t decoder();
 
        while(true)
        {
-               if(can_message = can_bus.next_can_message())
+               if(can_message = can_bus.next_can_message(interface))
                {
                        /* First we have to found which CanSignal is */
                        search_key = build_DynamicField(openxc_DynamicField_Type::openxc_DynamicField_Type_NUM, (double)can_message.get_id())
-
                        signals = find_can_signals(search_key);
                        
                        /* Decoding the message ! Don't kill the messenger ! */

diff --git a/src/can_reader.cpp b/src/can_reader.cpp
index b8ada8d..418e292 100644 (file)
--- a/src/can_reader.cpp
+++ b/src/can_reader.cpp
@@ -18,9 +18,9 @@
 
 #include "low-can-binding.hpp"
 
-void can_reader(can_bus__dev_t &can_bus)
+void can_reader(can_bus_dev_t &can_bus)
 {
-       can_message_t can_message;
+       can_message_t can_message(interface);
 
        while(can_bus.is_running())
        {