#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 into 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 into 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<can_signal_t>& 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 encode
+ * @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<signal_t> sig, std::vector<uint8_t> &data, bool filter, bool factor, bool offset)
+{
+ uint32_t bit_size = sig->get_bit_size();
+ uint32_t bit_position = sig->get_bit_position();
+ float factor_v = factor ? sig->get_factor() : 1;
+ float offset_v = offset ? sig->get_offset() : 0;
+
+ 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);
+ std::vector<uint8_t> data_signal(new_end_byte - new_start_byte + 1, 0xFF);
+
+ if(filter)
+ {
+ uint8_t mask_first_v = static_cast<uint8_t>(0xFF >> new_start_bit);
+ uint8_t mask_last_v = static_cast<uint8_t>(0xFF << (7 - new_end_bit));
+
+ if(new_start_byte == new_end_byte)
+ {
+ data_signal[0] = mask_first_v & mask_last_v;
+ }
+ else
+ {
+ data_signal[0] = mask_first_v;
+ data_signal[new_end_byte - new_start_byte] = mask_last_v;
+ }
+ }
+ else
+ {
+ bitfield_encode_float(sig->get_last_value(),
+ new_start_bit,
+ bit_size,
+ factor_v,
+ offset_v,
+ data_signal.data(),
+ bit_size);
+ }
+
+ 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_t>& signal, uint64_t value, message_t *message, bool factor, bool offset)
{
- struct can_frame cf;
- ::memset(&cf, 0, sizeof(cf));
+ signal->set_last_value(static_cast<float>(value));
+ std::vector<uint8_t> data(message->get_length(), 0);
- cf.can_id = signal->get_message()->get_id();
- cf.can_dlc = CAN_MAX_DLEN;
+ for(const auto& sig: signal->get_message()->get_signals())
+ encode_data(sig, data, false, factor, offset);
- signal->set_last_value((float)value);
+ message->set_data(data);
+ return message;
+}
- for(const auto& sig: signal->get_message()->get_can_signals())
+/**
+ * @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_t>& signal, uint64_t value, bool factor, bool offset)
+{
+ message_t *message;
+ std::vector<uint8_t> data;
+ switch(signal->get_message()->get_flags())
{
- 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(),
- cf.data,
- CAN_MAX_DLEN);
+ 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);
}
- return cf;
}
/// @brief Encode a boolean into an integer, fit for a CAN signal bitfield.
/// @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);
}
/// @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());
}
/// @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 == "")
/// @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.
/// @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) {