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,"", 0, false, message_format_t::STANDARD, 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                                                         0,// is_big_endian
  31                                                         0,// is_signed
  32                                                         ""// unit
  33                                                 })},
  34                                                 {std::make_shared<signal_t> (signal_t{
  35                                                         "hvac.temperature.left",// generic_name
  36                                                         0,// bit_position
  37                                                         8,// bit_size
  38                                                         1.00000f,// factor
  39                                                         0.00000f,// offset
  40                                                         0,// min_value
  41                                                         0,// max_value
  42                                                         frequency_clock_t(0.00000f),// frequency
  43                                                         true,// send_same
  44                                                         false,// force_send_changed
  45                                                         {
  46                                                         },// states
  47                                                         false,// writable
  48                                                         nullptr,// decoder
  49                                                         nullptr,// encoder
  50                                                         false,// received
  51                                                         std::make_pair<bool, int>(false, 0),// multiplex
  52                                                         0,// is_big_endian
  53                                                         0,// is_signed
  54                                                         ""// unit
  55                                                 })},
  56                                                 {std::make_shared<signal_t> (signal_t{
  57                                                         "hvac.temperature.right",// generic_name
  58                                                         8,// bit_position
  59                                                         8,// bit_size
  60                                                         1.00000f,// factor
  61                                                         0.00000f,// offset
  62                                                         0,// min_value
  63                                                         0,// max_value
  64                                                         frequency_clock_t(0.00000f),// frequency
  65                                                         true,// send_same
  66                                                         false,// force_send_changed
  67                                                         {
  68                                                         },// states
  69                                                         false,// writable
  70                                                         nullptr,// decoder
  71                                                         nullptr,// encoder
  72                                                         false,// received
  73                                                         std::make_pair<bool, int>(false, 0),// multiplex
  74                                                         0,// is_big_endian
  75                                                         0,// is_signed
  76                                                         ""// unit
  77                                                 })},
  78                                                 {std::make_shared<signal_t> (signal_t{
  79                                                         "hvac.temperature.average",// generic_name
  80                                                         16,// bit_position
  81                                                         8,// bit_size
  82                                                         1.00000f,// factor
  83                                                         0.00000f,// offset
  84                                                         0,// min_value
  85                                                         0,// max_value
  86                                                         frequency_clock_t(0.00000f),// frequency
  87                                                         true,// send_same
  88                                                         false,// force_send_changed
  89                                                         {
  90                                                         },// states
  91                                                         false,// writable
  92                                                         nullptr,// decoder
  93                                                         nullptr,// encoder
  94                                                         false,// received
  95                                                         std::make_pair<bool, int>(false, 0),// multiplex
  96                                                         0,// is_big_endian
  97                                                         0,// is_signed
  98                                                         ""// unit
  99                                                 })}
 100                                         } // end signals vector
 101                                 })} // end message_definition entry
 102
 103                 }, // end message_definition vector
 104                         { // beginning diagnostic_messages_ vector
 105
 106                         } // end diagnostic_messages_ vector
 107                 })} // end message_set entry
 108         } // end message_set vector
 109 {
 110         for(std::shared_ptr<message_set_t> cms: message_set_)
 111         {
 112                 vect_ptr_msg_def_t messages_definition = cms->get_messages_definition();
 113                 for(std::shared_ptr<message_definition_t> cmd : messages_definition)
 114                 {
 115                         cmd->set_parent(cms);
 116                         std::vector<std::shared_ptr<signal_t>> signals = cmd->get_signals();
 117                         for(std::shared_ptr<signal_t> sig: signals)
 118                         {
 119                                 sig->set_parent(cmd);
 120                         }
 121                 }
 122
 123                 std::vector<std::shared_ptr<diagnostic_message_t>> diagnostic_messages = cms->get_diagnostic_messages();
 124                 for(std::shared_ptr<diagnostic_message_t> dm : diagnostic_messages)
 125                 {
 126                         dm->set_parent(cms);
 127                 }
 128         }
 129                 }
 130
 131 const std::string application_t::get_diagnostic_bus() const
 132 {
 133         return "";
 134 }
 135
 136