diff options
Diffstat (limited to 'low-can-binding/can')
| -rw-r--r-- | low-can-binding/can/can-encoder.cpp | 159 | ||||
| -rw-r--r-- | low-can-binding/can/can-encoder.hpp | 33 | ||||
| -rw-r--r-- | low-can-binding/can/can-signals.cpp | 14 | ||||
| -rw-r--r-- | low-can-binding/can/can-signals.hpp | 1 |
4 files changed, 207 insertions, 0 deletions
diff --git a/low-can-binding/can/can-encoder.cpp b/low-can-binding/can/can-encoder.cpp new file mode 100644 index 00000000..b87407f1 --- /dev/null +++ b/low-can-binding/can/can-encoder.cpp @@ -0,0 +1,159 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" <romain.forlot@iot.bzh> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "can-encoder.hpp" + +#include "canutil/write.h" +#include "../utils/openxc-utils.hpp" +#include "can-message-definition.hpp" +#include "../binding/low-can-hat.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 build_frame(const can_signal_t& signal, uint64_t value) +{ + struct can_frame cf; + ::memset(&cf, 0, sizeof(cf)); + + cf.can_id = signal.get_message()->get_id(); + cf.can_dlc = CAN_MAX_DLEN; + bitfield_encode_float((float)value, + signal.get_bit_position(), + signal.get_bit_size(), + signal.get_factor(), + signal.get_offset(), + cf.data, + CAN_MAX_DLEN); + + return cf; +} + +/// @brief Encode a boolean into an integer, fit for a CAN signal bitfield. +/// +/// This is a shortcut for encodeDynamicField(CanSignal*, openxc_DynamicField*, +/// bool*) that takes care of creating the DynamicField object for you with the +/// boolean value. +/// +/// @param[in] signal - The CAN signal to encode this value for.. +/// @param[in] value - The boolean value to encode +/// @param[out] send - An output argument that will be set to false if the value should +/// not be sent for any reason. +/// +/// @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) +{ + return encode_number(signal, float(value), send); +} +/// @brief Encode a float into an integer, fit for a CAN signal's bitfield. +/// +/// This is a shortcut for encodeDynamicField(CanSignal*, openxc_DynamicField*, +/// bool*) that takes care of creating the DynamicField object for you with the +/// float value. +/// +/// @param[in] signal - The CAN signal to encode this value for. +/// @param[in] value - The float value to encode. +/// @param[out] send - This output argument will always be set to false, so the caller will +/// know not to publish this value to the pipeline. +/// +/// @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) +{ + return float_to_fixed_point(value, signal.get_factor(), signal.get_offset()); +} + +/// @brief Encode a string into an integer, fit for a CAN signal's bitfield. +/// +/// Be aware that the behavior is undefined if there are multiple values assigned +/// to a single state. See https://github.com/openxc/vi-firmware/issues/185. +/// +/// This is a shortcut for encodeDynamicField(CanSignal*, openxc_DynamicField*, +/// bool*) that takes care of creating the DynamicField object for you with the +/// string state value. +/// +/// @param[in] signal - The details of the signal that contains the state mapping. +/// @param[in] value - The string state value to encode. +/// @param[out] send - An output argument that will be set to false if the value should +/// not be sent for any reason. +/// +/// @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 value = 0; + if(state == "") + { + AFB_DEBUG("Can't write state of "" -- not sending"); + *send = false; + } + else + { + uint64_t signal_state = signal.get_states(state); + if(signal_state != -1) { + value = signal_state; + } else { + AFB_DEBUG("Couldn't find a valid signal state for %s", state.c_str()); + *send = false; + } + } + return value; +} + +/// @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 +/// will be passed to the decoder before returning. +/// +/// @param[in] signal - The details of the signal to decode and forward. +/// @param[in] value - The numerical value that will be converted to a boolean. +/// @param[out] send - An output parameter that will be flipped to false if the value could +/// not be decoded. +/// +/// @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 value = 0; + switch(field.type) { + case openxc_DynamicField_Type_STRING: + value = encode_state(signal, field.string_value, send); + break; + case openxc_DynamicField_Type_NUM: + value = encode_number(signal, (float)field.numeric_value, send); + break; + case openxc_DynamicField_Type_BOOL: + value = encode_boolean(signal, field.boolean_value, send); + break; + default: + AFB_DEBUG("Dynamic field didn't have a value, can't encode"); + *send = false; + break; + } + return value; +} diff --git a/low-can-binding/can/can-encoder.hpp b/low-can-binding/can/can-encoder.hpp new file mode 100644 index 00000000..f7e8394f --- /dev/null +++ b/low-can-binding/can/can-encoder.hpp @@ -0,0 +1,33 @@ +/* + * Copyright (C) 2015, 2016 "IoT.bzh" + * Author "Romain Forlot" <romain.forlot@iot.bzh> + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#pragma once + +#include "can-signals.hpp" +#include "can-message.hpp" +#include "openxc.pb.h" + +class encoder_t +{ +public: + static const can_frame build_frame(const can_signal_t& signal, uint64_t value); + static uint64_t encode_state(const can_signal_t& signal, const std::string& value, bool* send); + static uint64_t encode_boolean(const can_signal_t& signal, bool value, bool* send); + static uint64_t encode_number(const can_signal_t& signal, float value, bool* send); + + static uint64_t encode_DynamicField(can_signal_t& signal, const openxc_DynamicField& field, bool* send); +}; diff --git a/low-can-binding/can/can-signals.cpp b/low-can-binding/can/can-signals.cpp index 573808aa..45c54cb4 100644 --- a/low-can-binding/can/can-signals.cpp +++ b/low-can-binding/can/can-signals.cpp @@ -141,6 +141,20 @@ const std::string can_signal_t::get_states(uint8_t value) return std::string(); } +uint64_t can_signal_t::get_states(const std::string& value) const +{ + uint64_t ret = -1; + for( const auto& state: states_) + { + if(state.second == value) + { + ret = (uint64_t)state.first; + break; + } + } + return ret; +} + size_t can_signal_t::get_state_count() const { return states_.size(); diff --git a/low-can-binding/can/can-signals.hpp b/low-can-binding/can/can-signals.hpp index f7ff0372..1b27622e 100644 --- a/low-can-binding/can/can-signals.hpp +++ b/low-can-binding/can/can-signals.hpp @@ -133,6 +133,7 @@ public: bool get_force_send_changed() const; const std::map<uint8_t, std::string>& get_states() const; const std::string get_states(uint8_t value); + uint64_t get_states(const std::string& value) const; size_t get_state_count() const; bool get_writable() const; signal_decoder& get_decoder(); |