X-Git-Url: https://gerrit.automotivelinux.org/gerrit/gitweb?a=blobdiff_plain;f=low-can-binding%2Fcan%2Fcan-encoder.cpp;h=36be668cfcbac0a1423aeb2369dafd1eb0f0961e;hb=453a68145bc28a8464efedc055dd43359dd8a8a7;hp=d90e08da8db3cb81b46b5a18837ac7fef4abcadd;hpb=88befdfd812a58fb7a36e090278ad1e70003e925;p=apps%2Fagl-service-can-low-level.git diff --git a/low-can-binding/can/can-encoder.cpp b/low-can-binding/can/can-encoder.cpp index d90e08da..36be668c 100644 --- a/low-can-binding/can/can-encoder.cpp +++ b/low-can-binding/can/can-encoder.cpp @@ -19,39 +19,331 @@ #include "canutil/write.h" #include "../utils/openxc-utils.hpp" -#include "can-message-definition.hpp" +#include "message-definition.hpp" +#include "../utils/converter.hpp" -/// @brief Write a value in a CAN signal in the destination buffer. -/// -/// @param[in] signal - The CAN signal to write, including the bit position and bit size. -/// @param[in] value - The encoded integer value to write in the CAN signal. -/// @param[out] data - The destination buffer. -/// @param[in] length - The length of the destination buffer. -/// -/// @return Returns a can_frame struct initialized and ready to be send. -const can_frame encoder_t::build_frame(const std::shared_ptr& signal, uint64_t value) +/** + * @brief Allows to encode data for a signal + * + * @param sig The signal to know its location + * @param data The data to encod + * @param filter If true that will generate the filter BCM for the signal + * @param factor If true that will use the factor of the signal else 1 + * @param offset If true that will use the offset of the signal else 0 + */ +void encoder_t::encode_data(std::shared_ptr sig, std::vector &data, bool filter, bool factor, bool offset) { - struct can_frame cf; - ::memset(&cf, 0, sizeof(cf)); + uint32_t bit_size = sig->get_bit_size(); + uint32_t bit_position = sig->get_bit_position(); + int new_start_byte = 0; + int new_end_byte = 0; + uint8_t new_start_bit = 0; + uint8_t new_end_bit = 0; + + converter_t::signal_to_bits_bytes(bit_position, bit_size, new_start_byte, new_end_byte, new_start_bit, new_end_bit); + + int len_signal_bytes_tmp = new_end_byte - new_start_byte + 1; + + uint8_t len_signal_bytes = 0; + if(len_signal_bytes_tmp > 255) + { + AFB_ERROR("Error signal %s too long", sig->get_name().c_str()); + } + else + { + len_signal_bytes = (uint8_t) len_signal_bytes_tmp; + } +/* + if(new_start_bit > 255) + { + AFB_ERROR("Error signal %s too long", sig->get_name().c_str()); + } +*/ + uint8_t new_bit_size = 0; + if(bit_size > 255) + { + AFB_ERROR("Error signal %s to long bit size", sig->get_name().c_str()); + } + else + { + new_bit_size = (uint8_t) bit_size; + } - cf.can_id = signal->get_message()->get_id(); - cf.can_dlc = CAN_MAX_DLEN; + uint8_t data_signal[len_signal_bytes] = {0}; + float factor_v = 1; + if(factor) + { + factor_v = sig->get_factor(); + } + float offset_v = 0; + if(factor) + { + offset_v = sig->get_offset(); + } + + if(filter) + { + uint8_t tmp = 0; + int j=0; + for(int i=0;i 255) + { + AFB_ERROR("Error mask too large"); + } + else + { + mask_v = (uint8_t) mask; + } + tmp = tmp|mask_v; + + if(i%8 == 7) + { + data_signal[j] = tmp; + tmp = 0; + j++; + } + } + data_signal[j]=tmp; + } + else + { + bitfield_encode_float( sig->get_last_value(), + new_start_bit, + new_bit_size, + factor_v, + offset_v, + data_signal, + len_signal_bytes); + } + + for(size_t i = new_start_byte; i <= new_end_byte ; i++) + { + data[i] = data[i] | data_signal[i-new_start_byte]; + } +} + +/** + * @brief Allows to build a multi frame message with correct data to be send + * + * @param signal The CAN signal to write, including the bit position and bit size. + * @param value The encoded integer value to write in the CAN signal. + * @param message A multi frame message to complete + * @param factor If true that will use the factor of the signal else 1 + * @param offset If true that will use the offset of the signal else 0 + * @return message_t* The message that is generated + */ +message_t* encoder_t::build_frame(const std::shared_ptr& signal, uint64_t value, message_t *message, bool factor, bool offset) +{ signal->set_last_value((float)value); + std::vector data; + for(int i = 0; iget_length();i++) + { + data.push_back(0); + } - for(const auto& sig: signal->get_message()->get_can_signals()) + for(const auto& sig: signal->get_message()->get_signals()) { + encode_data(sig, data, false, factor, offset); + } + message->set_data(data); + return message; +} + +/** + * @brief Allows to build a message_t with correct data to be send + * + * @param signal The CAN signal to write, including the bit position and bit size. + * @param value The encoded integer value to write in the CAN signal. + * @param factor If true that will use the factor of the signal else 1 + * @param offset If true that will use the offset of the signal else 0 + * @return message_t* The message that is generated + */ +message_t* encoder_t::build_message(const std::shared_ptr& signal, uint64_t value, bool factor, bool offset) +{ + message_t *message; + std::vector data; + switch(signal->get_message()->get_flags()) + { + case CAN_PROTOCOL_WITH_FD_FRAME: + message = new can_message_t(CANFD_MAX_DLEN, + signal->get_message()->get_id(), + CANFD_MAX_DLEN, + false, + signal->get_message()->get_flags(), + data, + 0); + return build_frame(signal, value, message, factor, offset); +#ifdef USE_FEATURE_J1939 + case J1939_PROTOCOL: + message = new j1939_message_t(signal->get_message()->get_length(), + data, + 0, + J1939_NO_NAME, + signal->get_message()->get_id(), + J1939_NO_ADDR); + return build_frame(signal, value, message, factor, offset); +#endif + case CAN_PROTOCOL: + message = new can_message_t(CAN_MAX_DLEN, + signal->get_message()->get_id(), + CAN_MAX_DLEN, + false, + signal->get_message()->get_flags(), + data, + 0); + return build_frame(signal, value, message, factor, offset); + default: + message = new can_message_t(CAN_MAX_DLEN, + signal->get_message()->get_id(), + CAN_MAX_DLEN, + false, + signal->get_message()->get_flags(), + data, + 0); + return build_frame(signal, value, message, factor, offset); + } + +} + + +/** + * @brief Allows to build a single frame message with correct data to be send + * + * @param signal The CAN signal to write, including the bit position and bit size. + * @param value The encoded integer value to write in the CAN signal. + * @param message A single frame message to complete + * @return message_t* The message that is generated + */ +message_t* encoder_t::build_one_frame_message(const std::shared_ptr& signal, uint64_t value, message_t *message) +{ + signal->set_last_value((float)value); + uint8_t data_tab[message->get_length()]; + std::vector data; + + for(const auto& sig: signal->get_message()->get_signals()) + { + float last_value = sig->get_last_value(); + bitfield_encode_float(last_value, + sig->get_bit_position(), + sig->get_bit_size(), + sig->get_factor(), + sig->get_offset(), + data_tab, + (uint8_t)message->get_length()); + } + + for (size_t i = 0; i < (uint8_t) message->get_length(); i++) + { + data.push_back(data_tab[i]); + } + + message->set_data(data); + return message; +} + +/** + * @brief Allows to build a multi frame message with correct data to be send + * + * @param signal The CAN signal to write, including the bit position and bit size. + * @param value The encoded integer value to write in the CAN signal. + * @param message A multi frame message to complete + * @return message_t* The message that is generated + */ +message_t* encoder_t::build_multi_frame_message(const std::shared_ptr& signal, uint64_t value, message_t *message) +{ + signal->set_last_value((float)value); + std::vector data; + + uint32_t msgs_len = signal->get_message()->get_length(); // multi frame - number of bytes + int number_of_frame = (int) msgs_len / 8; + + uint8_t data_tab[number_of_frame][8] = {0}; + + for(const auto& sig: signal->get_message()->get_signals()) + { + + int frame_position = (int) sig->get_bit_position() / 64; float last_value = sig->get_last_value(); + uint8_t bit_position = sig->get_bit_position() - ((uint8_t)(64 * frame_position)); + bitfield_encode_float(last_value, - sig->get_bit_position(), - sig->get_bit_size(), - sig->get_factor(), - sig->get_offset(), - cf.data, - CAN_MAX_DLEN); + bit_position, + sig->get_bit_size(), + sig->get_factor(), + sig->get_offset(), + data_tab[frame_position], + 8); } - return cf; + for (size_t i = 0; i < number_of_frame; i++) + { + for(size_t j = 0; j < 8 ; j++) + { + data.push_back(data_tab[i][j]); + } + } + + message->set_data(data); + return message; +} + +/** + * @brief Allows to build a message_t with correct data to be send + * + * @param signal The CAN signal to write, including the bit position and bit size. + * @param value The encoded integer value to write in the CAN signal. + * @return message_t* The message that is generated + */ +message_t* encoder_t::build_message(const std::shared_ptr& signal, uint64_t value) +{ + message_t *message; + std::vector data; + + switch(signal->get_message()->get_flags()) + { + case CAN_PROTOCOL_WITH_FD_FRAME: + message = new can_message_t(CANFD_MAX_DLEN, + signal->get_message()->get_id(), + CANFD_MAX_DLEN, + false, + signal->get_message()->get_flags(), + data, + 0); + return build_one_frame_message(signal, value, message); +#ifdef USE_FEATURE_J1939 + case J1939_PROTOCOL: + message = new j1939_message_t(signal->get_message()->get_length(), + data, + 0, + J1939_NO_NAME, + signal->get_message()->get_id(), + J1939_NO_ADDR); + return build_multi_frame_message(signal, value, message); +#endif + case CAN_PROTOCOL: + message = new can_message_t(CAN_MAX_DLEN, + signal->get_message()->get_id(), + CAN_MAX_DLEN, + false, + signal->get_message()->get_flags(), + data, + 0); + return build_one_frame_message(signal, value, message); + default: + message = new can_message_t(CAN_MAX_DLEN, + signal->get_message()->get_id(), + CAN_MAX_DLEN, + false, + signal->get_message()->get_flags(), + data, + 0); + return build_one_frame_message(signal, value, message); + } } /// @brief Encode a boolean into an integer, fit for a CAN signal bitfield. @@ -68,7 +360,7 @@ const can_frame encoder_t::build_frame(const std::shared_ptr& sign /// @return Returns the encoded integer. If 'send' is changed to false, the field could /// not be encoded and the return value is undefined. /// -uint64_t encoder_t::encode_boolean(const can_signal_t& signal, bool value, bool* send) +uint64_t encoder_t::encode_boolean(const signal_t& signal, bool value, bool* send) { return encode_number(signal, float(value), send); } @@ -86,7 +378,7 @@ uint64_t encoder_t::encode_boolean(const can_signal_t& signal, bool value, bool* /// @return Returns the encoded integer. If 'send' is changed to false, the field could /// not be encoded and the return value is undefined. /// -uint64_t encoder_t::encode_number(const can_signal_t& signal, float value, bool* send) +uint64_t encoder_t::encode_number(const signal_t& signal, float value, bool* send) { return float_to_fixed_point(value, signal.get_factor(), signal.get_offset()); } @@ -108,7 +400,7 @@ uint64_t encoder_t::encode_number(const can_signal_t& signal, float value, bool* /// @return Returns the encoded integer. If 'send' is changed to false, the field could /// not be encoded and the return value is undefined. /// -uint64_t encoder_t::encode_state(const can_signal_t& signal, const std::string& state, bool* send) +uint64_t encoder_t::encode_state(const signal_t& signal, const std::string& state, bool* send) { uint64_t value = 0; if(state == "") @@ -132,7 +424,7 @@ uint64_t encoder_t::encode_state(const can_signal_t& signal, const std::string& /// @brief Parse a signal from a CAN message and apply any required /// transforations to get a human readable value. /// -/// If the can_signal_t has a non-NULL 'decoder' field, the raw CAN signal value +/// If the signal_t has a non-NULL 'decoder' field, the raw CAN signal value /// will be passed to the decoder before returning. /// /// @param[in] signal - The details of the signal to decode and forward. @@ -143,7 +435,7 @@ uint64_t encoder_t::encode_state(const can_signal_t& signal, const std::string& /// @return The decoder returns an openxc_DynamicField, which may contain a number, /// string or boolean. If 'send' is false, the return value is undefined. /// -uint64_t encoder_t::encode_DynamicField( can_signal_t& signal, const openxc_DynamicField& field, bool* send) +uint64_t encoder_t::encode_DynamicField( signal_t& signal, const openxc_DynamicField& field, bool* send) { uint64_t value = 0; switch(field.type) {