src/openxc/signal.cpp

   1 #include "signal.hpp"\r
   2 \r
   3 namespace openxc\r
   4 {\r
   5         std::string signal::id() const\r
   6         {\r
   7                 return id_;\r
   8         }\r
   9         \r
  10         void signal::id(const std::string& id)\r
  11         {\r
  12                 id_ = id;\r
  13         }\r
  14         \r
  15         void id(const std::string& id);\r
  16         \r
  17         std::string signal::generic_name() const\r
  18         {\r
  19                 return generic_name_;\r
  20         }\r
  21         \r
  22         std::uint32_t signal::bit_position() const\r
  23         {\r
  24                 return bit_position_;\r
  25         }\r
  26         \r
  27         std::uint32_t signal::bit_size() const\r
  28         {\r
  29                 return bit_size_;\r
  30         }\r
  31         \r
  32         float signal::factor() const\r
  33         {\r
  34                 return factor_;\r
  35         }\r
  36         \r
  37         float signal::offset() const\r
  38         {\r
  39                 return offset_;\r
  40         }\r
  41         \r
  42         std::string signal::decoder() const\r
  43         {\r
  44                 return decoder_;\r
  45         }\r
  46         \r
  47         bool signal::ignore() const\r
  48         {\r
  49                 return ignore_;\r
  50         }\r
  51         \r
  52         bool signal::enabled() const\r
  53         {\r
  54                 return enabled_;\r
  55         }\r
  56         \r
  57         const std::map<std::string, std::vector<std::uint32_t>>& signal::states() const\r
  58         {\r
  59                 return states_;\r
  60         }\r
  61         \r
  62         float signal::max_frequency() const\r
  63         {\r
  64                 return max_frequency_;\r
  65         }\r
  66         \r
  67         bool signal::send_same() const\r
  68         {\r
  69                 return send_same_;\r
  70         }\r
  71         \r
  72         bool signal::force_send_changed() const\r
  73         {\r
  74                 return force_send_changed_;\r
  75         }\r
  76         \r
  77         bool signal::writable() const\r
  78         {\r
  79                 return writable_;\r
  80         }\r
  81         \r
  82         std::string signal::encoder() const\r
  83         {\r
  84                 return encoder_;\r
  85         }\r
  86 \r
  87         std::pair<bool,int> signal::multiplex() const{\r
  88                 return multiplex_;\r
  89         }\r
  90 \r
  91         sign_t signal::sign() const\r
  92         {\r
  93                 return sign_;\r
  94         }\r
  95 \r
  96         std::int32_t signal::bit_sign_position() const\r
  97         {\r
  98                 return bit_sign_position_;\r
  99         }\r
 100 \r
 101         std::string signal::unit() const{\r
 102                 return unit_;\r
 103         }\r
 104 \r
 105         \r
 106         void signal::from_json(const nlohmann::json& j)\r
 107         {\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
 122                 {\r
 123                         std::string mult = j["multiplex"].get<std::string>();\r
 124                         bool first = false;\r
 125                         int second = 0 ;\r
 126                         if(mult.compare("Multiplexor") == 0){\r
 127                                 first = true;\r
 128                         }\r
 129                         else if (mult.compare("") != 0)\r
 130                         {\r
 131                                 second = std::stoi(mult);\r
 132                         }\r
 133                         multiplex_ = std::make_pair(first,second);\r
 134                 }\r
 135                 else\r
 136                 {\r
 137                         multiplex_ =  std::make_pair(false,0);\r
 138                 }\r
 139 \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
 143 \r
 144                 if (j.count("states"))\r
 145                 {\r
 146                         std::map<std::string, nlohmann::json> items = j["states"];\r
 147                         for(const auto& i : items)\r
 148                         {\r
 149                                 states_[i.first] = i.second.get<std::vector<std::uint32_t>>();\r
 150                         }\r
 151                 }\r
 152         }\r
 153 \r
 154         nlohmann::json signal::to_json() const\r
 155         {\r
 156                 nlohmann::json j;\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
 171 \r
 172                 std::string multi = "";\r
 173 \r
 174                 if(multiplex_.first)\r
 175                 {\r
 176                         multi = "Multiplexor";\r
 177                 }\r
 178                 else if(multiplex_.second != 0)\r
 179                 {\r
 180                         multi = std::to_string(multiplex_.second);\r
 181                 }\r
 182                 else\r
 183                 {\r
 184                         multi = "";\r
 185                 }\r
 186 \r
 187                 j["multiplex"] = multi;\r
 188 \r
 189                 j["bit_sign_position"] = bit_sign_position_;\r
 190                 j["signed"] = static_cast<std::uint32_t>(sign_);\r
 191                 j["unit"] = unit_;\r
 192                 return j;\r
 193         }\r
 194 \r
 195         void to_json(nlohmann::json& j, const signal& p)\r
 196         {\r
 197                 j = p.to_json();\r
 198         }\r
 199 \r
 200         void from_json(const nlohmann::json& j, signal& p)\r
 201         {\r
 202                 p.from_json(j);\r
 203         }\r
 204 }\r