src/can/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 "can/can-signals.hpp"
  19
  20 #include <fnmatch.h>
  21
  22 #include "utils/signals.hpp"
  23 #include "can/can-decoder.hpp"
  24 #include "obd2/obd2-signals.hpp"
  25 #include "low-can-binding.hpp"
  26
  27 can_message_definition_t& can_signal_t::get_message()
  28 {
  29         return message_;
  30 }
  31
  32 std::string& can_signal_t::get_generic_name()
  33 {
  34         return generic_name_;
  35 }
  36
  37 uint8_t can_signal_t::get_bit_position() const
  38 {
  39         return bit_position_;
  40 }
  41
  42 uint8_t can_signal_t::get_bit_size() const
  43 {
  44         return bit_size_;
  45 }
  46
  47 /**
  48  * @fn void find_can_signals(const openxc_DynamicField& key, std::vector<can_signal_t*>& found_signals)
  49  * @brief return signals name found searching through CAN_signals and OBD2 pid
  50  *
  51  * @param[in] key - can contain numeric or string value in order to search against
  52  *   can signals or obd2 signals name.
  53  * @param[out] found_signals - provided vector to fill with ponter to signals matched.
  54  *
  55  */
  56 void find_can_signals(const openxc_DynamicField& key, std::vector<can_signal_t*>& found_signals)
  57 {
  58         switch(key.type)
  59         {
  60                 case openxc_DynamicField_Type::openxc_DynamicField_Type_STRING:
  61                         lookup_signals_by_name(key.string_value, get_can_signals(), found_signals);
  62                         break;
  63                 case openxc_DynamicField_Type::openxc_DynamicField_Type_NUM:
  64                         lookup_signals_by_id(key.numeric_value, get_can_signals(), found_signals);
  65                         break;
  66                 default:
  67                         ERROR(binder_interface, "find_signals: wrong openxc_DynamicField specified. Use openxc_DynamicField_Type_NUM or openxc_DynamicField_Type_STRING type only.");
  68                         break;
  69         }
  70         DEBUG(binder_interface, "Found %d signal(s)", (int)found_signals.size());
  71 float can_signal_t::get_factor() const
  72 {
  73         return factor_;
  74 }
  75
  76 float can_signal_t::get_offset() const
  77 {
  78         return offset_;
  79 }
  80
  81 float can_signal_t::get_min_value() const
  82 {
  83         return min_value_;
  84 }
  85
  86 float can_signal_t::get_max_value() const
  87 {
  88         return max_value_;
  89 }
  90
  91 FrequencyClock& can_signal_t::get_frequency()
  92 {
  93         return frequency_;
  94 }
  95
  96 bool can_signal_t::get_send_same() const
  97 {
  98         return send_same_;
  99 }
 100
 101 bool can_signal_t::get_force_send_changed() const
 102 {
 103         return force_send_changed_;
 104 }
 105
 106 std::map<int, std::string> can_signal_t::get_state() const
 107 {
 108         return states_;
 109 }
 110
 111 size_t can_signal_t::get_state_count() const
 112 {
 113         return states_.size();
 114 }
 115
 116 bool can_signal_t::get_writable() const
 117 {
 118         return writable_;
 119 }
 120
 121 SignalDecoder& can_signal_t::get_decoder()
 122 {
 123         return decoder_;
 124 }
 125
 126 SignalEncoder& can_signal_t::get_encoder()
 127 {
 128         return encoder_;
 129 }
 130
 131 bool can_signal_t::get_received() const
 132 {
 133         return received_;
 134 }
 135 float can_signal_t::get_last_value() const
 136 {
 137         return last_value_;
 138 }
 139
 140 void can_signal_t::set_received(bool r)
 141 {
 142         received_ = r;
 143 }
 144
 145 void can_signal_t::set_last_value(float val)
 146 {
 147         last_value_ = val;
 148 }