void stop_threads();
can_message_t next_can_message();
- void push_new_can_message(const can_message_t& can_msg);
+ void push_new_can_message(const can_message_t& can_msg);
std::mutex& get_can_message_mutex();
std::condition_variable& get_new_can_message_cv();
/**
* @brief The type signature for a function to handle a custom OpenXC command.
*
- * @param[in] char* name - the name of the received command.
- * @param[in] openxc_DynamicField* value - the value of the received command, in a DynamicField. The actual type
+ * @param[in] name - the name of the received command.
+ * @param[in] value - the value of the received command, in a DynamicField. The actual type
* may be a number, string or bool.
- * @param[in] openxc_DynamicField* event - an optional event from the received command, in a DynamicField. The
+ * @param[in] event - an optional event from the received command, in a DynamicField. The
* actual type may be a number, string or bool.
- * @param[in] CanSignal* signals - The list of all signals.
- * @param[in] int signalCount - The length of the signals array.
+ * @param[in] signals - The list of all signals.
+ * @param[in] signalCount - The length of the signals array.
*/
typedef void (*CommandHandler)(const char* name, openxc_DynamicField* value,
openxc_DynamicField* event, CanSignal* signals, int signalCount);
typedef struct {
const char* generic_name; /*!< generic_name - The name of the command.*/
CommandHandler handler; /*!< handler - An function to process the received command's data and perform some
- * action.*/
+ * action.*/
} CanCommand;
/* Public: Return an array of all OpenXC CAN commands enabled in the active
* configuration that can write back to CAN with a custom handler.
*
- * * Commands not defined here are handled using a 1-1 mapping from the signals
+ * Commands not defined here are handled using a 1-1 mapping from the signals
* list.
- * */
+ */
CanCommand* getCommands();
/* Public: Return the length of the array returned by getCommandCount(). */
/**
* @brief Retrieve id_ member value.
*
-* @return uint32_t id_ class member
+* @return id_ class member
*/
uint32_t can_message_t::get_id() const
{
/**
* @brief Retrieve RTR flag member.
*
-* @return bool rtr_flags_ class member
+* @return rtr_flags_ class member
*/
bool can_message_t::get_rtr_flag_() const
{
/**
* @brief Retrieve format_ member value.
*
-* @return CanMessageFormat format_ class member
+* @return format_ class member
*/
int can_message_t::get_format() const
{
}
/**
-* @brief Retrieve format_ member value.
+* @brief Retrieve flags_ member value.
*
-* @return CanMessageFormat format_ class member
+* @return flags_ class member
*/
uint8_t can_message_t::get_flags() const
{
/**
* @brief Retrieve data_ member value.
*
-* @return uint8_t data_ pointer to the first element
+* @return pointer to the first element
* of class member data_
*/
const uint8_t* can_message_t::get_data() const
/**
* @brief Retrieve length_ member value.
*
-* @return uint8_t length_ class member
+* @return length_ class member
*/
uint8_t can_message_t::get_length() const
{
* @brief Control whether the object is correctly initialized
* to be sent over the CAN bus
*
-* @return true if object correctly initialized and false if not...
+* @return true if object correctly initialized and false if not.
*/
bool can_message_t::is_correct_to_send()
{
* Preferred way to initialize these members by using
* convert_from_canfd_frame method.
*
-* @param uint32_t id_ class member
+* @param[in] id_ class member
*/
void can_message_t::set_id_and_format(const uint32_t new_id)
{
* Preferred way to initialize these members by using
* convert_from_canfd_frame method.
*
-* @param CanMessageFormat format_ class member
+* @param[in] new_format - class member
*/
void can_message_t::set_format(const CanMessageFormat new_format)
{
}
/**
-* @brief Set format_ member value. Deducing from the can_id
+* @brief Set format_ member value. Deduced from the can_id
* of a canfd_frame.
*
* Preferred way to initialize these members by using
* convert_from_canfd_frame method.
*
-* @param uint32_t can_id integer from a canfd_frame
+* @param[in] can_id - integer from a canfd_frame
*/
void can_message_t::set_format(const uint32_t can_id)
{
* Preferred way to initialize these members by using
* convert_from_canfd_frame method.
*
-* @param CanMessageFormat format_ class member
+* @param[in] format_ - class member
*/
void can_message_t::set_flags(const uint8_t flags)
{
* Preferred way to initialize these members by using
* convert_from_canfd_frame method.
*
-* @param uint8_t length_ array with a max size of 8 elements.
+* @param[in] new_length - array with a max size of 8 elements.
*/
void can_message_t::set_length(const uint8_t new_length)
{
* Preferred way to initialize these members by using
* convert_from_canfd_frame method.
*
-* @param uint8_t data_ array with a max size of 8 elements.
+* @param[in] new_data - array with a max size of 8 elements.
*/
void can_message_t::set_data(const __u8* new_data)
{
*
* This is the preferred way to initialize class members.
*
-* @param canfd_frame struct read from can bus device.
+* @param[in] args - struct read from can bus device.
*/
-void can_message_t::convert_from_canfd_frame(const std::pair<struct canfd_frame&, size_t>args)
+void can_message_t::convert_from_canfd_frame(const std::pair<struct canfd_frame&, size_t> args)
{
// May be it's overkill to assign member of the pair... May be it will change...
struct canfd_frame frame = args.first;
*/
class can_message_t {
private:
- uint32_t id_; /*!< uint32_t id - The ID of the message. */
- bool rtr_flag_; /*!< bool rtr_flag - Telling if the frame has RTR flag positionned. Then frame hasn't data field*/
- uint8_t length_; /*!< uint8_t length - the length of the data array (max 8). */
- uint8_t flags_; /*!< unint8_t flags of a CAN FD frame. Needed if we catch FD frames.*/
- CanMessageFormat format_; /*!< CanMessageFormat format - the format of the message's ID.*/
- std::vector<uint8_t> data_; /*!< uint8_t data - The message's data field with a size of 8 which is the standard about CAN bus messages.*/
+ uint32_t id_; /*!< id_ - The ID of the message. */
+ bool rtr_flag_; /*!< rtr_flag_ - Telling if the frame has RTR flag positionned. Then frame hasn't data field*/
+ uint8_t length_; /*!< length_ - the length of the data array (max 8). */
+ uint8_t flags_; /*!< flags_ - flags of a CAN FD frame. Needed if we catch FD frames.*/
+ CanMessageFormat format_; /*!< format_ - the format of the message's ID.*/
+ std::vector<uint8_t> data_; /*!< data_ - The message's data field with a size of 8 which is the standard about CAN bus messages.*/
- uint8_t maxdlen_;
+ uint8_t maxdlen_; /*!< maxdlen_ - Max data length deduce from number of bytes read from the socket.*/
public:
can_message_t();
class can_message_set_t
{
private:
- uint8_t index; /*!<index - A numerical ID for the message set, ideally the index in an array
+ uint8_t index_; /*!<index_ - A numerical ID for the message set, ideally the index in an array
* for fast lookup*/
- const std::string name; /*!< name - The name of the message set.*/
- uint8_t can_bus_count; /*!< busCount - The number of CAN buses defined for this message set.*/
- unsigned short can_message_count; /*!< messageCount - The number of CAN messages (across all buses) defined for
+ const std::string name_; /*!< name_ - The name of the message set.*/
+ uint8_t can_bus_count_; /*!< can_bus_count_ - The number of CAN buses defined for this message set.*/
+ unsigned short can_message_count_; /*!< can_message_count_ - The number of CAN messages (across all buses) defined for
* this message set.*/
- unsigned short can_signal_count; /*!< signalCount - The number of CAN signals (across all messages) defined for
+ unsigned short can_signal_count_; /*!< can_signal_count_ - The number of CAN signals (across all messages) defined for
* this message set.*/
- unsigned short can_command_count; /*!< commandCount - The number of CanCommmands defined for this message set.*/
- unsigned short obd2_signal_count; /*!< commandCount - The number of obd2 signals defined for this message set.*/
+ unsigned short can_command_count_; /*!< can_command_count_ - The number of CanCommmands defined for this message set.*/
+ unsigned short obd2_signal_count_; /*!< obd2_signal_count_ - The number of obd2 signals defined for this message set.*/
};
/** Public: Return the currently active CAN configuration. */
* @fn void find_can_signals(const openxc_DynamicField& key, std::vector<CanSignal*>& found_signals)
* @brief return signals name found searching through CAN_signals and OBD2 pid
*
- * @param[in] const openxc_DynamicField : can contain numeric or string value in order to search against
+ * @param[in] key - can contain numeric or string value in order to search against
* can signals or obd2 signals name.
- * @param[out] std::vector<CanSignal*>& found_signals : provided vector to fill with ponter to signals matched.
+ * @param[out] found_signals - provided vector to fill with ponter to signals matched.
*
*/
void find_can_signals(const openxc_DynamicField& key, std::vector<CanSignal*>& found_signals)
* @desc A SignalDecoder transforms a raw floating point CAN signal into a number,
* string or boolean.
*
- * @param[in] CanSignal signal - The CAN signal that we are decoding.
- * @param[in] CanSignal signals - The list of all signals.
- * @param[in] int signalCount - The length of the signals array.
- * @param[in] float value - The CAN signal parsed from the message as a raw floating point
+ * @param[in] signal - The CAN signal that we are decoding.
+ * @param[in] signals - The list of all signals.
+ * @param[in] signalCount - The length of the signals array.
+ * @param[in] value - The CAN signal parsed from the message as a raw floating point
* value.
- * @param[out] bool send - An output parameter. If the decoding failed or the CAN signal should
+ * @param[out] send - An output parameter. If the decoding failed or the CAN signal should
* not send for some other reason, this should be flipped to false.
*
* @return a decoded value in an openxc_DynamicField struct.
* @desc A SignalEncoder transforms a number, string or boolean into a raw floating
* point value that fits in the CAN signal.
*
- * @params[signal] - The CAN signal to encode.
- * @params[value] - The dynamic field to encode.
- * @params[send] - An output parameter. If the encoding failed or the CAN signal should
+ * @params[in] signal - The CAN signal to encode.
+ * @params[in] value - The dynamic field to encode.
+ * @params send - An output parameter. If the encoding failed or the CAN signal should
* not be encoded for some other reason, this will be flipped to false.
*/
typedef uint64_t (*SignalEncoder)(struct CanSignal* signal,
* OpenXC state names.
*/
struct CanSignalState {
- 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. */
+ const int value; /*!< value - The integer value of the state on the CAN bus.*/
+ const char* name; /*!< 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 {
- struct CanMessageDefinition* message; /*!< message - The message this signal is a part of. */
+ struct CanMessageDefinition* message; /*!< message - The message this signal is a part of. */
const char* generic_name; /*!< generic_name - 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
class can_signal_t
{
private:
- struct can_message_definition_t* message_; /*!< message - The message this signal is a part of. */
- const std::string generic_name_; /*!< generic_name - 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
+ struct can_message_definition_t* message_; /*!< message_ - The message this signal is a part of. */
+ const std::string generic_name_; /*!< generic_name_ - 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
+ 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
+ float offset_; /*!< offset_ - The final value will be added to this offset. Use 0 if you
* don't need an offset. */
- float min_value_; /*!< minValue - The minimum value for the processed signal.*/
- float max_value_; /*!< maxValue - The maximum value for the processed signal. */
- FrequencyClock clock_; /*!< clock_ - A FrequencyClock struct to control the maximum frequency to
+ float min_value_; /*!< min_value_ - The minimum value for the processed signal.*/
+ float max_value_; /*!< max_value_ - The maximum value for the processed signal. */
+ FrequencyClock frequency_; /*!< frequency_ - 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
+ bool send_same_; /*!< send_same_ - If true, will re-send even if the value hasn't changed.*/
+ bool force_send_changed_; /*!< force_send_changed_ - If true, regardless of the frequency, it will send the
* value if it has changed. */
const std::map<const int, const std::string> states_; /*!< states_ - A map of CAN signal state describing the mapping
* between numerical and string values for valid states. */
*/
class active_diagnostic_request_t {
private:
- can_bus_dev_t* bus_; /*!< can_bus_dev_t* bus_ - The CAN bus this request should be made on, or is currently in flight-on*/
- uint32_t id_; /*!< The arbitration ID (aka message ID) for the request.*/
- DiagnosticRequestHandle* handle_; /*!< DiagnosticRequestHandle* handle - A handle for the request to keep track of it between
+ can_bus_dev_t* bus_; /*!< bus_ - The CAN bus this request should be made on, or is currently in flight-on*/
+ uint32_t id_; /*!< id_ - The arbitration ID (aka message ID) for the request.*/
+ DiagnosticRequestHandle* handle_; /*!< handle_ - A handle for the request to keep track of it between
* sending the frames of the request and receiving all frames of the response.*/
- std::string name_; /*!< std::string name_ - An optional human readable name this response, to be used when publishing received
+ std::string name_; /*!< name_ - An optional human readable name this response, to be used when publishing received
* responses. If the name is NULL, the published output will use the raw OBD-II response format.*/
- DiagnosticResponseDecoder decoder_; /*!< decoder - An optional DiagnosticResponseDecoder to parse the payload of responses
+ DiagnosticResponseDecoder decoder_; /*!< decoder_ - An optional DiagnosticResponseDecoder to parse the payload of responses
* to this request. If the decoder is NULL, the output will include the raw payload
* instead of a parsed value.*/
- DiagnosticResponseCallback callback_; /*!< callback - An optional DiagnosticResponseCallback to be notified whenever a
+ DiagnosticResponseCallback callback_; /*!< callback_ - An optional DiagnosticResponseCallback to be notified whenever a
* response is received for this request.*/
bool recurring_; /*!< bool recurring_ - If true, this is a recurring request and it will remain as active until explicitly cancelled.
* The frequencyClock attribute controls how often a recurrin request is made.*/
- bool waitForMultipleResponses_; /*!< bool waitForMultipleResponses_ - False by default, when any response is received for a request
+ bool waitForMultipleResponses_; /*!< waitForMultipleResponses_ - False by default, when any response is received for a request
* it will be removed from the active list. If true, the request will remain active until the timeout
* clock expires, to allow it to receive multiple response (e.g. to a functional broadcast request).*/
- bool inFlight_; /*!< inFlight - True if the request has been sent and we are waiting for a response.*/
- FrequencyClock frequencyClock_; /*!< FrequencyClock frequencyClock_ - A FrequencyClock struct to control the send rate for a
+ bool inFlight_; /*!< inFlight_ - True if the request has been sent and we are waiting for a response.*/
+ FrequencyClock frequency_clock_; /*!< frequency_clock_ - A FrequencyClock object to control the send rate for a
* recurring request. If the request is not reecurring, this attribute is not used.*/
- FrequencyClock timeoutClock_; /*!< FrequencyClock timeoutClock_ - A FrequencyClock struct to monitor how long it's been since
+ FrequencyClock timeout_clock_; /*!< timeout_clock_ - A FrequencyClock object to monitor how long it's been since
* this request was sent.*/
public:
};
* @fn std::vector<std::string> find_signals(const openxc_DynamicField &key)
* @brief return signals name found searching through CAN_signals and OBD2 pid
*
- * @param[in] const openxc_DynamicField : can contain numeric or string value in order to search against
+ * @param[in] key - can contain numeric or string value in order to search against
* can signals or obd2 signals name.
*
- * @return std::vector<std::string> Vector of signals name found.
+ * @return Vector of signals name found.
*/
void obd2_signal_t::find_obd2_signals(const openxc_DynamicField &key, std::vector<obd2_signal_t*>& found_signals)
{
* value of the PID, using the standard formulas (see
* http://en.wikipedia.org/wiki/OBD-II_PIDs#Mode_01).
*
-* @param[in] DiagnosticResponse response - the received DiagnosticResponse (the data is in response.payload,
+* @param[in] response - the received DiagnosticResponse (the data is in response.payload,
* a byte array). This is most often used when the byte order is
* signiticant, i.e. with many OBD-II PID formulas.
-* @param[in] float parsed_payload - the entire payload of the response parsed as an int.
+* @param[in] parsed_payload - the entire payload of the response parsed as an int.
*/
float obd2_signal_t::decode_obd2_response(const DiagnosticResponse* response, float parsedPayload)
{
*
* @brief Build a specific VehicleMessage containing a SimpleMessage.
*
- * @param[in] openxc_DynamicField_Type type - The type of message to build
- * @param[in] openxc_SimpleMessage& message - simple message to include into openxc_VehicleMessage
+ * @param[in] type - The type of message to build
+ * @param[in] message - simple message to include into openxc_VehicleMessage
*
- * @return openxc_VehicleMessage - a vehicle message including simple message that will be convert into
+ * @return a vehicle message including simple message that will be convert into
* a JSON object before being pushed to the subscribers
*/
openxc_VehicleMessage build_VehicleMessage_with_SimpleMessage(openxc_DynamicField_Type type, const openxc_SimpleMessage& message);
*
* @brief Build an openxc_SimpleMessage associating a name to an openxc_DynamicField
*
- * @param[in] std::string name - const string reference name to assign to the created SimpleMessage
+ * @param[in] name - const string reference name to assign to the created SimpleMessage
* this will set has_name member to true and assign name to the name member. Maximum size for name is
* set to 100 char.
- * @param[in] openxc_DynamicField value - const reference with DynamicField to assign to SimpleMessage
+ * @param[in] value - const reference with DynamicField to assign to SimpleMessage
* value.
*
* @return an openxc_SimpleMessage struct initialized with name and value provided.
*
* @brief Build an openxc_DynamicField with a string value
*
- * @param std::string value - const string reference value to assign to builded
+ * @param[in] value - const string reference value to assign to builded
* openxc_DynamicField.
*
* @return openxc_DynamicField initialized with a string value.
*
* @brief Build an openxc_DynamicField with a double value
*
- * @param double value - double value to assign to builded openxc_DynamicField.
+ * @param[in] value - double value to assign to builded openxc_DynamicField.
*
* @return openxc_DynamicField initialized with a double value.
*/
*
* @brief Build an openxc_DynamicField with a boolean value
*
- * @param bool value - boolean value to assign to builded openxc_DynamicField.
+ * @param[in] value - boolean value to assign to builded openxc_DynamicField.
*
* @return openxc_DynamicField initialized with a boolean value.
*/
*
* @brief Make a JSON object from a DynamicField
*
- * @param[in] openxc_DynamicField field - openxc_DynamicField struct to convert into
+ * @param[in] field - openxc_DynamicField struct to convert into
* a json object.
- * @param[out] json_object pointer with the DynamicField converted
+ * @param[out] value - pointer to the object to set up.
*/
void jsonify_DynamicField(const openxc_DynamicField& field, json_object* value);
* returned value will be a SimpleMessage with all field set at false.
* DynamicField from SimpleMessage will be boolean DynamicField set to false too.
*
- * @param[in] openxc_VehicleMessage - const reference to openxc_VehicleMessage
+ * @param[in] v_msg - const reference to openxc_VehicleMessage
*
- * @return openxc_SimpleMessage - SimpleMessage from the provided VehicleMessage.
+ * @return A simpleMessage from the provided VehicleMessage.
*/
openxc_SimpleMessage get_simple_message(const openxc_VehicleMessage& v_msg);
*
* @brief Make a JSON object from a SimpleMessage
*
- * @param[in] openxc_SimpleMessage s_msg - const reference to an openxc_SimpleMessage
+ * @param[in] s_msg - const reference to an openxc_SimpleMessage
* struct to convert into a json object.
- * @param[out] json_object pointer with the DynamicField converted
+ * @param[out] json - pointer with the DynamicField converted into json object
*
- * @return boolean value - true if SimpleMessage has been transformed into json object
+ * @return True if SimpleMessage has been transformed into json object
* and false if not. In such case, a json object is returned { "error": "error msg"}
*/
bool jsonify_simple(const openxc_SimpleMessage& s_msg, json_object* json);
\ No newline at end of file
/**
* @brief return the subscribed_signals map.
*
- * return std::map<std::string, struct afb_event> - map of subscribed signals.
+ * return Map of subscribed signals.
*/
extern std::map<std::string, struct afb_event> subscribed_signals;
std::map<std::string, struct afb_event>& get_subscribed_signals();
Code Review / apps / agl-service-can-low-level.git / commitdiff