Improve doxygen comments
authorRomain Forlot <romain.forlot@iot.bzh>
Wed, 22 Feb 2017 18:01:01 +0000 (19:01 +0100)
committerRomain Forlot <romain.forlot@iot.bzh>
Wed, 22 Feb 2017 18:01:01 +0000 (19:01 +0100)
Change-Id: I7506997865726a6caa28177a1f85713ae924336f
Signed-off-by: Romain Forlot <romain.forlot@iot.bzh>
src/can-utils.cpp
src/can-utils.hpp

index 42763b8..de9e8ce 100644 (file)
@@ -246,10 +246,6 @@ canfd_frame can_bus_dev_t::read(const struct afb_binding_interface* interface)
        return canfd_frame;
 }
 
-/**
- * @brief start reading threads and set flag is_running_
- * 
- */
 void can_bus_dev_t::start_reading(can_bus_t& can_bus)
 {
        th_reading_ = std::thread(can_reader, std::ref(*this), std::ref(can_bus));
@@ -264,12 +260,6 @@ bool can_bus_dev_t::is_running()
        return is_running_;
 }
 
-/**
- * @brief Send a can message from a can_message_t object.
- * 
- * params[const can_message_t& can_msg] the can message object to send
- * 
- */
 int can_bus_dev_t::send_can_message(can_message_t& can_msg, const struct afb_binding_interface* interface)
 {
        ssize_t nbytes;
@@ -306,22 +296,13 @@ can_bus_t::can_bus_t(const struct afb_binding_interface *interface, int& conf_fi
 {
 }
 
-/**
- * @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()
 {
        th_decoding_ = std::thread(can_decode_message, std::ref(*this));
        th_pushing_ = std::thread(can_event_push, std::ref(*this));
 }
 
-/**
- * @brief Initialize as many as can_bus_dev_t objects with their respective reading thread
- * 
- * params[std::ifstream& conf_file] conf_file ifstream to the JSON configuration 
- * file located at the rootdir of the binding
- */
+
 int can_bus_t::init_can_dev()
 {
        std::vector<std::string> devices_name;
@@ -350,11 +331,6 @@ int can_bus_t::init_can_dev()
        return 1;
 }
 
-/** 
- * @brief Read the conf file and extract device name
- * 
- * @return[std:vector<std::string>] return a vector of device name
- */
 std::vector<std::string> can_bus_t::read_conf()
 {
        std::vector<std::string> ret;
@@ -393,12 +369,6 @@ std::vector<std::string> can_bus_t::read_conf()
        return ret;
 }
 
-/**
- * @brief: Get a can_message_t from can_message_q and return it
- * then point to the next can_message_t in queue.
- * 
- * @return the next queue element or NULL if queue is empty.
- */
 can_message_t can_bus_t::next_can_message()
 {
        can_message_t can_msg(interface_);
@@ -416,34 +386,16 @@ can_message_t can_bus_t::next_can_message()
        return can_msg;
 }
 
-/**
- * @brief Append a new element to the can message queue and set
- * has_can_message_ boolean to true
- * 
- * @params[const can_message_t& can_msg] the can_message_t to append
- * 
- */
 void can_bus_t::push_new_can_message(const can_message_t& can_msg)
 {
        can_message_q_.push(can_msg);
 }
 
-/**
- * @brief Flag that let you know when can message queue is exhausted
- * 
- * @return[bool] has_can_message_ bool
- */
 bool can_bus_t::has_can_message() const
 {
        return has_can_message_;
 }
 
-/**
- * @brief: Get a VehicleMessage from vehicle_message_q and return it
- * then point to the next VehicleMessage in queue.
- * 
- * @return the next queue element or NULL if queue is empty.
- */
 openxc_VehicleMessage can_bus_t::next_vehicle_message()
 {
        openxc_VehicleMessage v_msg;
@@ -461,24 +413,12 @@ openxc_VehicleMessage can_bus_t::next_vehicle_message()
        return v_msg;
 }
 
-/**
- * @brief Append a new element to the vehicle message queue and set
- * has_vehicle_message_ boolean to true
- * 
- * @params[const openxc_VehicleMessage& v_msg] the openxc_VehicleMessage to append
- * 
- */
 void can_bus_t::push_new_vehicle_message(const openxc_VehicleMessage& v_msg)
 {
        vehicle_message_q_.push(v_msg);
        has_vehicle_message_ = true;
 }
 
-/**
- * @brief Flag that let you know when vehicle message queue is exhausted
- * 
- * @return[bool] has_vehicle_message_ bool
- */
 bool can_bus_t::has_vehicle_message() const
 {
        return has_vehicle_message_;
index 1fac69e..4252b97 100644 (file)
@@ -232,137 +232,210 @@ class can_message_t {
 };
 
 /** 
+ * @class can_bus_t
  * @brief Object used to handle decoding and manage event queue to be pushed.
  *
- * @params[in] interface_ - afb_binding_interface pointer to the binder. Used to log messages
- * @params[in] conf_file_ - configuration file handle used to initialize can_bus_dev_t objects.
+ * This object is also used to initialize can_bus_dev_t object after reading 
+ * json conf file describing the CAN devices to use. Thus, those object will read 
+ * on the device the CAN frame and push them into the can_bus_t can_message_q_ queue.
+ *
+ * That queue will be later used to be decoded and pushed to subscribers.
  */
 class can_bus_t {
        private:
-               int conf_file_;
+               int conf_file_; /*!< conf_file_ - configuration file handle used to initialize can_bus_dev_t objects.*/
                
-               std::thread th_decoding_;
-               std::thread th_pushing_;
+               std::thread th_decoding_; /*!< thread that'll handle decoding a can frame */
+               std::thread th_pushing_; /*!<  thread that'll handle pushing decoded can frame to subscribers */
 
-               bool has_can_message_;
-               std::queue <can_message_t> can_message_q_;
+               bool has_can_message_; /*!< boolean members that control whether or not there is can_message into the queue */
+               std::queue <can_message_t> can_message_q_; /*!< queue that'll store can_message_t to decoded */
 
-               bool has_vehicle_message_;
-               std::queue <openxc_VehicleMessage> vehicle_message_q_;
+               bool has_vehicle_message_; /*!< boolean members that control whether or not there is openxc_VehicleMessage into the queue */
+               std::queue <openxc_VehicleMessage> vehicle_message_q_; /*!< queue that'll store openxc_VehicleMessage to pushed */
 
        public:
-               const struct afb_binding_interface *interface_;
+               const struct afb_binding_interface *interface_; /*!< interface_ - afb_binding_interface pointer to the binder. Used to log messages */
 
-               can_bus_t(const struct afb_binding_interface *itf, int& conf_file);
+               /**
+                * @brief Class constructor
+                *
+                * @param struct afb_binding_interface *interface between daemon and binding
+                * @param int file handle to the json configuration file.
+                */
+               can_bus_t(const struct afb_binding_interface *interface, int& conf_file);
+               
+               /**
+                * @brief Will initialize can_bus_dev_t objects after reading 
+                * the configuration file passed in the constructor.
+                */
                int init_can_dev();
-               std::vector<std::string> read_conf();
                
+               /**
+                * @brief read the conf_file_ and will parse json objects
+                * in it searching for canbus objects devices name.
+                *
+                * @return Vector of can bus device name string.
+                */
+                std::vector<std::string> read_conf();
+               
+               /**
+                * @brief Will initialize threads that will decode
+                *  and push subscribed events.
+                */
                void start_threads();
 
+               /**
+                * @brief Return first can_message_t on the queue 
+                *
+                * @return a can_message_t 
+                */
                can_message_t next_can_message();
+               
+               /**
+                * @brief Push a can_message_t into the queue
+                *
+                * @param the const reference can_message_t object to push into the queue
+                */
                void push_new_can_message(const can_message_t& can_msg);                
+               
+               /**
+                * @brief Return a boolean telling if there is any can_message into the queue
+                *
+                * @return true if there is at least a can_message_t, false if not.
+                */
                bool has_can_message() const;
                
+               /**
+                * @brief Return first openxc_VehicleMessage on the queue 
+                *
+                * @return a openxc_VehicleMessage containing a decoded can message
+                */
                openxc_VehicleMessage next_vehicle_message();
+               
+               /**
+                * @brief Push a openxc_VehicleMessage into the queue
+                *
+                * @param the const reference openxc_VehicleMessage object to push into the queue
+                */
                void push_new_vehicle_message(const openxc_VehicleMessage& v_msg);
+               
+               /**
+                * @brief Return a boolean telling if there is any openxc_VehicleMessage into the queue
+                *
+                * @return true if there is at least a openxc_VehicleMessage, false if not.
+                */
                bool has_vehicle_message() const;
 };
 
-/** 
- * @brief Object representing a can device. Handle opening, closing and reading on the
- * socket. This is the low level object to be use by can_bus_t.
+/**
+ * @class can_bus_dev_t 
  *
- * @params[in] std::string device_name_ - name of the linux device handling the can bus. Generally vcan0, can0, etc.
+ * @brief Object representing a can device. Handle opening, closing and reading on the
+ *  socket. This is the low level object to be use by can_bus_t.
  */
 class can_bus_dev_t {
        private:
-               std::string device_name_;
-               int can_socket_;
-               bool is_fdmode_on_;
-               struct sockaddr_can txAddress_;
+               std::string device_name_; /*!< std::string device_name_ - name of the linux device handling the can bus. Generally vcan0, can0, etc. */
+               int can_socket_; /*!< socket handler for the can device */
+               bool is_fdmode_on_; /*!< boolean telling if whether or not the can socket use fdmode. */
+               struct sockaddr_can txAddress_; /*!< internal member using to bind to the socket */
 
-               std::thread th_reading_;
-               bool is_running_;
+               std::thread th_reading_; /*!< Thread handling read the socket can device filling can_message_q_ queue of can_bus_t */
+               bool is_running_; /*!< boolean telling whether or not reading is running or not */
 
        public:
+               /**
+                * @brief Class constructor 
+                * 
+                * @param const string representing the device name into the linux /dev tree
+                */
                can_bus_dev_t(const std::string& dev_name);
 
+               /**
+                * @brief Open the can socket and returning it 
+                *
+                * @return 
+                */
                int open(const struct afb_binding_interface* interface);
                int close();
                bool is_running();
+               
+               /**
+               * @brief start reading threads and set flag is_running_
+               *
+               * @param can_bus_t reference can_bus_t. it will be passed to the thread 
+               *  to allow using afb_binding_interface and can_bus_t queue.
+               */
                void start_reading(can_bus_t& can_bus);
+
+               /**
+               * @brief Read the can socket and retrieve canfd_frame
+               *
+               * @param const struct afb_binding_interface* interface pointer. Used to be able to log 
+               *  using application framework logger.
+               */
                canfd_frame read(const struct afb_binding_interface *interface);
                
+               /**
+               * @brief Send a can message from a can_message_t object.
+               * 
+               * @param const can_message_t& can_msg: the can message object to send 
+               * @param const struct afb_binding_interface* interface pointer. Used to be able to log 
+               *  using application framework logger.
+               */
                int send_can_message(can_message_t& can_msg, const struct afb_binding_interface* interface);
 };
 
 /**
+ * @struct CanSignalState
+ *
  * @brief A state encoded (SED) signal's mapping from numerical values to
  * OpenXC state names.
- *
- * @param[in] in value - The integer value of the state on the CAN bus.
- * @param[in] char* name  - The corresponding string name for the state in OpenXC.
  */
 struct CanSignalState {
-       const int value;
-       const char* name;
+       const int value; /*!< int value - The integer value of the state on the CAN bus.*/
+       const char* name; /*!< char* name  - The corresponding string name for the state in OpenXC. */
 };
 typedef struct CanSignalState CanSignalState;
 
 /**
- * @brief A CAN signal to decode from the bus and output over USB.
+ * @struct CanSignal
  *
- * @param[in] message     - The message this signal is a part of.
- * @param[in] genericName - The name of the signal to be output over USB.
- * @param[in] 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)
- * @param[in] bitSize     - The width of the bit field in the CAN message.
- * @param[in] factor      - The final value will be multiplied by this factor. Use 1 if you
- *                              don't need a factor.
- * @param[in] offset      - The final value will be added to this offset. Use 0 if you
- *                              don't need an offset.
- * @param[in] minValue    - The minimum value for the processed signal.
- * @param[in] maxValue    - The maximum value for the processed signal.
- * @param[in] frequencyClock - A FrequencyClock struct to control the maximum frequency to
- *                             process and send this signal. To process every value, set the
- *                             clock's frequency to 0.
- * @param[in] sendSame    - If true, will re-send even if the value hasn't changed.
- * @param[in] forceSendChanged - If true, regardless of the frequency, it will send the
- *                             value if it has changed.
- * @param[in] states      - An array of CanSignalState describing the mapping
- *                              between numerical and string values for valid states.
- * @param[in] stateCount  - The length of the states array.
- * @param[in] writable    - True if the signal is allowed to be written from the USB host
- *                              back to CAN. Defaults to false.
- * @param[in] decoder     - An optional function to decode a signal from the bus to a human
- *                             readable value. If NULL, the default numerical decoder is used.
- * @param[in] encoder     - An optional function to encode a signal value to be written to
- *                               CAN into a byte array. If NULL, the default numerical encoder
- *                               is used.
- * @param[in] received    - True if this signal has ever been received.
- * @param[in] lastValue   - The last received value of the signal. If 'received' is false,
- *             this value is undefined.
+ * @brief A CAN signal to decode from the bus and output over USB.
  */
 struct CanSignal {
-       struct CanMessageDefinition* message;
-       const char* genericName;
-       uint8_t bitPosition;
-       uint8_t bitSize;
-       float factor;
-       float offset;
-       float minValue;
-       float maxValue;
-       FrequencyClock frequencyClock;
-       bool sendSame;
-       bool forceSendChanged;
-       const CanSignalState* states;
-       uint8_t stateCount;
-       bool writable;
-       SignalDecoder decoder;
-       SignalEncoder encoder;
-       bool received;
-       float lastValue;
+       struct CanMessageDefinition* message; /*!< message         - The message this signal is a part of. */
+       const char* genericName; /*!< genericName - The name of the signal to be output over USB.*/
+       uint8_t bitPosition; /*!< 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) */
+       uint8_t bitSize; /*!< bitSize - The width of the bit field in the CAN message. */
+       float factor; /*!< factor - The final value will be multiplied by this factor. Use 1 if you
+                               *       don't need a factor. */
+       float offset; /*!< offset          - The final value will be added to this offset. Use 0 if you
+                               *       don't need an offset. */
+       float minValue; /*!< minValue    - The minimum value for the processed signal.*/
+       float maxValue; /*!< maxValue    - The maximum value for the processed signal. */
+       FrequencyClock frequencyClock; /*!< frequencyClock - A FrequencyClock struct to control the maximum frequency to
+                                                               *       process and send this signal. To process every value, set the
+                                                               *       clock's frequency to 0. */
+       bool sendSame; /*!< sendSame    - If true, will re-send even if the value hasn't changed.*/
+       bool forceSendChanged; /*!< forceSendChanged - If true, regardless of the frequency, it will send the
+                                               *       value if it has changed. */
+       const CanSignalState* states; /*!< states          - An array of CanSignalState describing the mapping
+                                                               *       between numerical and string values for valid states. */
+       uint8_t stateCount; /*!< stateCount  - The length of the states array. */
+       bool writable; /*!< writable    - True if the signal is allowed to be written from the USB host
+                               *       back to CAN. Defaults to false.*/
+       SignalDecoder decoder; /*!< decoder        - An optional function to decode a signal from the bus to a human
+                                               *       readable value. If NULL, the default numerical decoder is used. */
+       SignalEncoder encoder; /*!< encoder        - An optional function to encode a signal value to be written to
+                                               *       CAN into a byte array. If NULL, the default numerical encoder
+                                               *       is used. */
+       bool received; /*!< received    - True if this signal has ever been received.*/
+       float lastValue; /*!< lastValue   - The last received value of the signal. If 'received' is false,
+                                       *       this value is undefined. */
 };
 typedef struct CanSignal CanSignal;
 
@@ -490,8 +563,31 @@ bool isBusActive(can_bus_dev_t* bus);
 void logBusStatistics(can_bus_dev_t* buses, const int busCount);
 
 /**
- * @brief Function representing thread activated by can bus objects
+ * @fn void can_reader(can_bus_dev_t& can_bus_dev, can_bus_t& can_bus);
+ *
+ * @brief Thread function used to read the can socket.
+ *
+ * @param[in] can_bus_dev_t object to be used to read the can socket
+ * @param[in] can_bus_t object used to fill can_message_q_ queue
  */
 void can_reader(can_bus_dev_t& can_bus_dev, can_bus_t& can_bus);
+
+/**
+ * @fn void can_decode_message(can_bus_t& can_bus);
+ *
+ * @brief Thread function used to decode can messages read into the can_message_q_
+ *
+ * @param[in] can_bus_t object used to pop can_message_q_ queue and fill decoded message
+ * into vehicle_message_q_ queue.
+ */
 void can_decode_message(can_bus_t& can_bus);
+
+/**
+ * @fn void can_decode_message(can_bus_t& can_bus);
+ *
+ * @brief Thread function used to push afb_event
+ *
+ * @param[in] can_bus_t object used to pop can_message_q_ queue and fill decoded message
+ * into vehicle_message_q_ queue.
+ */
 void can_event_push(can_bus_t& can_bus);
\ No newline at end of file