1 #include "signal.hpp"
\r
5 std::string signal::id() const
\r
10 void signal::id(const std::string& id)
\r
15 void id(const std::string& id);
\r
17 std::string signal::generic_name() const
\r
19 return generic_name_;
\r
22 std::uint32_t signal::bit_position() const
\r
24 return bit_position_;
\r
27 std::uint32_t signal::bit_size() const
\r
32 float signal::factor() const
\r
37 float signal::offset() const
\r
42 std::string signal::decoder() const
\r
47 bool signal::ignore() const
\r
52 bool signal::enabled() const
\r
57 const std::map<std::string, std::vector<std::uint32_t>>& signal::states() const
\r
62 float signal::max_frequency() const
\r
64 return max_frequency_;
\r
67 bool signal::send_same() const
\r
72 bool signal::force_send_changed() const
\r
74 return force_send_changed_;
\r
77 bool signal::writable() const
\r
82 std::string signal::encoder() const
\r
87 std::pair<bool,int> signal::multiplex() const{
\r
91 sign_t signal::sign() const
\r
96 std::int32_t signal::bit_sign_position() const
\r
98 return bit_sign_position_;
\r
101 std::string signal::unit() const{
\r
106 void signal::from_json(const nlohmann::json& j)
\r
108 generic_name_ = j.count("generic_name") ? j["generic_name"].get<std::string>() : "";
\r
109 bit_position_ = j.count("bit_position") ? j["bit_position"].get<std::uint32_t>() : 0;
\r
110 bit_size_ = j.count("bit_size") ? j["bit_size"].get<std::uint32_t>() : 0;
\r
111 factor_ = j.count("factor") ? j["factor"].get<float>() : 1.0f;
\r
112 offset_ = j.count("offset") ? j["offset"].get<float>() : 0.0f;
\r
113 decoder_ = j.count("decoder") ? j["decoder"].get<std::string>() : "";
\r
114 ignore_ = j.count("ignore") ? j["ignore"].get<bool>() : false;
\r
115 enabled_ = j.count("enabled") ? j["enabled"].get<bool>() : true;
\r
116 max_frequency_ = j.count("max_frequency") ? j["max_frequency"].get<float>() : 0.0f;
\r
117 send_same_ = j.count("send_same") ? j["send_same"].get<bool>() : true;
\r
118 force_send_changed_ = j.count("force_send_changed") ? j["force_send_changed"].get<bool>() : false;
\r
119 writable_ = j.count("writable") ? j["writable"].get<bool>() : false;
\r
120 encoder_ = j.count("encoder") ? j["encoder"].get<std::string>() : "";
\r
121 if(j.count("multiplex"))
\r
123 std::string mult = j["multiplex"].get<std::string>();
\r
124 bool first = false;
\r
126 if(mult.compare("Multiplexor") == 0){
\r
129 else if (mult.compare("") != 0)
\r
131 second = std::stoi(mult);
\r
133 multiplex_ = std::make_pair(first,second);
\r
137 multiplex_ = std::make_pair(false,0);
\r
140 bit_sign_position_ = j.count("bit_sign_position") ? j["bit_sign_position"].get<std::int32_t>() : -1;
\r
141 sign_ = j.count("signed") ? (sign_t) j["signed"].get<std::uint32_t>() : sign_t::UNSIGNED;
\r
142 unit_ = j.count("unit") ? j["unit"].get<std::string>() : "";
\r
144 if (j.count("states"))
\r
146 std::map<std::string, nlohmann::json> items = j["states"];
\r
147 for(const auto& i : items)
\r
149 states_[i.first] = i.second.get<std::vector<std::uint32_t>>();
\r
154 nlohmann::json signal::to_json() const
\r
157 j["generic_name"] = generic_name_;
\r
158 j["bit_position"] = bit_position_;
\r
159 j["bit_size"] = bit_size_;
\r
160 j["factor"] = factor_;
\r
161 j["offset"] = offset_;
\r
162 j["decoder"] = decoder_;
\r
163 j["ignore"] = ignore_;
\r
164 j["enabled"] = enabled_;
\r
165 j["states"] = states_;
\r
166 j["max_frequency"] = max_frequency_;
\r
167 j["send_same"] = send_same_;
\r
168 j["force_send_changed"] = force_send_changed_;
\r
169 j["writable"] = writable_;
\r
170 j["encoder"] = encoder_;
\r
172 std::string multi = "";
\r
174 if(multiplex_.first)
\r
176 multi = "Multiplexor";
\r
178 else if(multiplex_.second != 0)
\r
180 multi = std::to_string(multiplex_.second);
\r
187 j["multiplex"] = multi;
\r
189 j["bit_sign_position"] = bit_sign_position_;
\r
190 j["signed"] = static_cast<std::uint32_t>(sign_);
\r
195 void to_json(nlohmann::json& j, const signal& p)
\r
200 void from_json(const nlohmann::json& j, signal& p)
\r