examples/hvac/application-generated.cpp

   1 #include "application.hpp"
   2 #include "../can/can-decoder.hpp"
   3 #include "../can/can-encoder.hpp"
   4
   5 application_t::application_t()
   6         : can_bus_manager_{utils::config_parser_t{"/etc/dev-mapping.conf"}}
   7         , message_set_{
   8                 {std::make_shared<message_set_t>(message_set_t{0,"example",
   9                         { // beginning message_definition_ vector
  10                                 {std::make_shared<message_definition_t>(message_definition_t{"ls",0x30,"",8,0,true,frequency_clock_t(5.00000f),true,
  11                                         { // beginning signals vector
  12                                                 {std::make_shared<signal_t> (signal_t{
  13                                                         "hvac.fan.speed",// generic_name
  14                                                         32,// bit_position
  15                                                         8,// bit_size
  16                                                         23.5294f,// factor
  17                                                         0.00000f,// offset
  18                                                         0,// min_value
  19                                                         0,// max_value
  20                                                         frequency_clock_t(0.00000f),// frequency
  21                                                         true,// send_same
  22                                                         false,// force_send_changed
  23                                                         {
  24                                                         },// states
  25                                                         false,// writable
  26                                                         nullptr,// decoder
  27                                                         nullptr,// encoder
  28                                                         false,// received
  29                                                         std::make_pair<bool, int>(false, 0),// multiplex
  30                                                         false,// is_big_endian
  31                                                         static_cast<sign_t>(0),// signed
  32                                                         -1,// bit_sign_position
  33                                                         ""// unit
  34                                                 })},
  35                                                 {std::make_shared<signal_t> (signal_t{
  36                                                         "hvac.temperature.left",// generic_name
  37                                                         0,// bit_position
  38                                                         8,// bit_size
  39                                                         1.00000f,// factor
  40                                                         0.00000f,// offset
  41                                                         0,// min_value
  42                                                         0,// max_value
  43                                                         frequency_clock_t(0.00000f),// frequency
  44                                                         true,// send_same
  45                                                         false,// force_send_changed
  46                                                         {
  47                                                         },// states
  48                                                         false,// writable
  49                                                         nullptr,// decoder
  50                                                         nullptr,// encoder
  51                                                         false,// received
  52                                                         std::make_pair<bool, int>(false, 0),// multiplex
  53                                                         false,// is_big_endian
  54                                                         static_cast<sign_t>(0),// signed
  55                                                         -1,// bit_sign_position
  56                                                         ""// unit
  57                                                 })},
  58                                                 {std::make_shared<signal_t> (signal_t{
  59                                                         "hvac.temperature.right",// generic_name
  60                                                         8,// bit_position
  61                                                         8,// bit_size
  62                                                         1.00000f,// factor
  63                                                         0.00000f,// offset
  64                                                         0,// min_value
  65                                                         0,// max_value
  66                                                         frequency_clock_t(0.00000f),// frequency
  67                                                         true,// send_same
  68                                                         false,// force_send_changed
  69                                                         {
  70                                                         },// states
  71                                                         false,// writable
  72                                                         nullptr,// decoder
  73                                                         nullptr,// encoder
  74                                                         false,// received
  75                                                         std::make_pair<bool, int>(false, 0),// multiplex
  76                                                         false,// is_big_endian
  77                                                         static_cast<sign_t>(0),// signed
  78                                                         -1,// bit_sign_position
  79                                                         ""// unit
  80                                                 })},
  81                                                 {std::make_shared<signal_t> (signal_t{
  82                                                         "hvac.temperature.average",// generic_name
  83                                                         16,// bit_position
  84                                                         8,// bit_size
  85                                                         1.00000f,// factor
  86                                                         0.00000f,// offset
  87                                                         0,// min_value
  88                                                         0,// max_value
  89                                                         frequency_clock_t(0.00000f),// frequency
  90                                                         true,// send_same
  91                                                         false,// force_send_changed
  92                                                         {
  93                                                         },// states
  94                                                         false,// writable
  95                                                         nullptr,// decoder
  96                                                         nullptr,// encoder
  97                                                         false,// received
  98                                                         std::make_pair<bool, int>(false, 0),// multiplex
  99                                                         false,// is_big_endian
 100                                                         static_cast<sign_t>(0),// signed
 101                                                         -1,// bit_sign_position
 102                                                         ""// unit
 103                                                 })}
 104                                         } // end signals vector
 105                                 })} // end message_definition entry
 106
 107                 }, // end message_definition vector
 108                         { // beginning diagnostic_messages_ vector
 109
 110                         } // end diagnostic_messages_ vector
 111                 })} // end message_set entry
 112         } // end message_set vector
 113 {
 114         for(std::shared_ptr<message_set_t> cms: message_set_)
 115         {
 116                 std::vector<std::shared_ptr<message_definition_t>> messages_definition = cms->get_messages_definition();
 117                 for(std::shared_ptr<message_definition_t> cmd : messages_definition)
 118                 {
 119                         cmd->set_parent(cms);
 120                         std::vector<std::shared_ptr<signal_t>> signals = cmd->get_signals();
 121                         for(std::shared_ptr<signal_t> sig: signals)
 122                         {
 123                                 sig->set_parent(cmd);
 124                         }
 125                 }
 126
 127                 std::vector<std::shared_ptr<diagnostic_message_t>> diagnostic_messages = cms->get_diagnostic_messages();
 128                 for(std::shared_ptr<diagnostic_message_t> dm : diagnostic_messages)
 129                 {
 130                         dm->set_parent(cms);
 131                 }
 132         }
 133                 }
 134
 135 const std::string application_t::get_diagnostic_bus() const
 136 {
 137         return "";
 138 }
 139
 140