low-can-binding/can/signals.cpp

   1 /*
   2  * Copyright (C) 2015, 2016 "IoT.bzh"
   3  * Author "Romain Forlot" <romain.forlot@iot.bzh>
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *       http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <fnmatch.h>
  19
  20 #include "signals.hpp"
  21
  22 #include "../binding/application.hpp"
  23 #include "../utils/signals.hpp"
  24 #include "can-decoder.hpp"
  25 #include "can-bus.hpp"
  26 #include "../diagnostic/diagnostic-message.hpp"
  27 #include "canutil/write.h"
  28
  29 std::string signal_t::prefix_ = "messages";
  30
  31 signal_t::signal_t(
  32         std::string generic_name,
  33         uint32_t bit_position,
  34         uint32_t bit_size,
  35         float factor,
  36         float offset,
  37         float min_value,
  38         float max_value,
  39         frequency_clock_t frequency,
  40         bool send_same,
  41         bool force_send_changed,
  42         std::map<uint8_t, std::string> states,
  43         bool writable,
  44         signal_decoder decoder,
  45         signal_encoder encoder,
  46         bool received,
  47         std::pair<bool, int> multiplex,
  48         bool is_big_endian,
  49         sign_t sign,
  50         int32_t bit_sign_position,
  51         std::string unit)
  52         : parent_{nullptr},
  53          generic_name_{ generic_name }
  54         , bit_position_{ bit_position }
  55         , bit_size_{ bit_size }
  56         , factor_{ factor }
  57         , offset_{ offset }
  58         , min_value_{min_value}
  59         , max_value_{max_value}
  60         , frequency_{frequency}
  61         , send_same_{send_same}
  62         , force_send_changed_{force_send_changed}
  63         , states_{states}
  64         , writable_{writable}
  65         , decoder_{decoder}
  66         , encoder_{encoder}
  67         , received_{received}
  68         , last_value_{.0f}
  69         , multiplex_{multiplex}
  70         , is_big_endian_{is_big_endian}
  71         , sign_{sign}
  72         , bit_sign_position_{bit_sign_position}
  73         , unit_{unit}
  74 {}
  75
  76 signal_t::signal_t(
  77         std::string generic_name,
  78         uint32_t bit_position,
  79         uint32_t bit_size,
  80         float factor,
  81         float offset,
  82         float min_value,
  83         float max_value,
  84         frequency_clock_t frequency,
  85         bool send_same,
  86         bool force_send_changed,
  87         std::map<uint8_t, std::string> states,
  88         bool writable,
  89         signal_decoder decoder,
  90         signal_encoder encoder,
  91         bool received)
  92         : generic_name_{ generic_name }
  93         , bit_position_{ bit_position }
  94         , bit_size_{ bit_size }
  95         , factor_{ factor }
  96         , offset_{ offset }
  97         , min_value_{min_value}
  98         , max_value_{max_value}
  99         , frequency_{frequency}
 100         , send_same_{send_same}
 101         , force_send_changed_{force_send_changed}
 102         , states_{states}
 103         , writable_{writable}
 104         , decoder_{decoder}
 105         , encoder_{encoder}
 106         , received_{received}
 107 {}
 108
 109 std::shared_ptr<message_definition_t> signal_t::get_message() const
 110 {
 111         return parent_;
 112 }
 113
 114 const std::string signal_t::get_generic_name() const
 115 {
 116         return generic_name_;
 117 }
 118
 119 const std::string signal_t::get_name() const
 120 {
 121         return prefix_ + "." + generic_name_;
 122 }
 123
 124 uint32_t signal_t::get_bit_position() const
 125 {
 126         return bit_position_;
 127 }
 128
 129 uint32_t signal_t::get_bit_size() const
 130 {
 131         return bit_size_;
 132 }
 133
 134 float signal_t::get_factor() const
 135 {
 136         return factor_;
 137 }
 138
 139 float signal_t::get_offset() const
 140 {
 141         return offset_;
 142 }
 143
 144 frequency_clock_t& signal_t::get_frequency()
 145 {
 146         return frequency_;
 147 }
 148
 149 bool signal_t::get_send_same() const
 150 {
 151         return send_same_;
 152 }
 153
 154 const std::string signal_t::get_states(uint8_t value)
 155 {
 156         if ( states_.count(value) > 0 )
 157                 return states_[value];
 158         return std::string();
 159 }
 160
 161 uint64_t signal_t::get_states(const std::string& value) const
 162 {
 163         uint64_t ret = -1;
 164         for( const auto& state: states_)
 165         {
 166                 if(caseInsCompare(state.second, value))
 167                 {
 168                         ret = (uint64_t)state.first;
 169                         break;
 170                 }
 171         }
 172         return ret;
 173 }
 174
 175 bool signal_t::get_writable() const
 176 {
 177         return writable_;
 178 }
 179
 180 signal_decoder& signal_t::get_decoder()
 181 {
 182         return decoder_;
 183 }
 184
 185 signal_encoder& signal_t::get_encoder()
 186 {
 187         return encoder_;
 188 }
 189
 190 bool signal_t::get_received() const
 191 {
 192         return received_;
 193 }
 194
 195 float signal_t::get_last_value() const
 196 {
 197         return last_value_;
 198 }
 199
 200 std::pair<float, uint64_t> signal_t::get_last_value_with_timestamp() const
 201 {
 202         return std::make_pair(last_value_, frequency_.get_last_tick());
 203 }
 204
 205 void signal_t::set_parent(std::shared_ptr<message_definition_t> parent)
 206 {
 207         parent_ = parent;
 208 }
 209
 210 void signal_t::set_received(bool r)
 211 {
 212         received_ = r;
 213 }
 214
 215 void signal_t::set_last_value(float val)
 216 {
 217         last_value_ = val;
 218 }
 219
 220 void signal_t::set_timestamp(uint64_t timestamp)
 221 {
 222         frequency_.tick(timestamp);
 223 }
 224
 225 void signal_t::set_bit_position(uint32_t bit_position)
 226 {
 227         bit_position_=bit_position;
 228 }
 229
 230 std::pair<bool,int> signal_t::get_multiplex() const
 231 {
 232         return multiplex_;
 233 }
 234
 235 bool signal_t::get_is_big_endian() const
 236 {
 237         return is_big_endian_;
 238 }
 239
 240 sign_t signal_t::get_sign() const
 241 {
 242         return sign_;
 243 }
 244
 245 int32_t signal_t::get_bit_sign_position() const
 246 {
 247         return bit_sign_position_;
 248 }
 249
 250 const std::string signal_t::get_unit() const
 251 {
 252         return unit_;
 253 }