examples/hvac/application-generated.cpp

   1 #include "application.hpp"
   2 #include "../can/can-decoder.hpp"
   3
   4 application_t::application_t()
   5         : can_bus_manager_{utils::config_parser_t{"/etc/dev-mapping.conf"}}
   6         , can_message_set_{
   7                 {std::make_shared<can_message_set_t>(can_message_set_t{0,"example",
   8                         { // beginning can_message_definition_ vector
   9                                 {std::make_shared<can_message_definition_t>(can_message_definition_t{"ls",0x30,can_message_format_t::STANDARD,frequency_clock_t(5.00000f),true,
  10                                         { // beginning can_signals vector
  11                                                 {std::make_shared<can_signal_t> (can_signal_t{
  12                                                         "hvac.fan.speed",
  13                                                         32,
  14                                                         8,
  15                                                         23.5294f,
  16                                                         0.00000,
  17                                                         0,
  18                                                         0,
  19                                                         frequency_clock_t(0.00000f),
  20                                                         true,
  21                                                         false,
  22                                                         {
  23                                                         },
  24                                                         false,
  25                                                         nullptr,
  26                                                         nullptr,
  27                                                         false
  28                                                 })},
  29                                                 {std::make_shared<can_signal_t> (can_signal_t{
  30                                                         "hvac.temperature.left",
  31                                                         0,
  32                                                         8,
  33                                                         1.00000f,
  34                                                         0.00000,
  35                                                         0,
  36                                                         0,
  37                                                         frequency_clock_t(0.00000f),
  38                                                         true,
  39                                                         false,
  40                                                         {
  41                                                         },
  42                                                         false,
  43                                                         nullptr,
  44                                                         nullptr,
  45                                                         false
  46                                                 })},
  47                                                 {std::make_shared<can_signal_t> (can_signal_t{
  48                                                         "hvac.temperature.right",
  49                                                         8,
  50                                                         8,
  51                                                         1.00000f,
  52                                                         0.00000,
  53                                                         0,
  54                                                         0,
  55                                                         frequency_clock_t(0.00000f),
  56                                                         true,
  57                                                         false,
  58                                                         {
  59                                                         },
  60                                                         false,
  61                                                         nullptr,
  62                                                         nullptr,
  63                                                         false
  64                                                 })},
  65                                                 {std::make_shared<can_signal_t> (can_signal_t{
  66                                                         "hvac.temperature.average",
  67                                                         16,
  68                                                         8,
  69                                                         1.00000f,
  70                                                         0.00000,
  71                                                         0,
  72                                                         0,
  73                                                         frequency_clock_t(0.00000f),
  74                                                         true,
  75                                                         false,
  76                                                         {
  77                                                         },
  78                                                         false,
  79                                                         nullptr,
  80                                                         nullptr,
  81                                                         false
  82                                                 })}
  83                                         } // end can_signals vector
  84                                 })} // end can_message_definition entry
  85
  86                 }, // end can_message_definition vector
  87                         { // beginning diagnostic_messages_ vector
  88
  89                         } // end diagnostic_messages_ vector
  90                 })} // end can_message_set entry
  91         } // end can_message_set vector
  92 {
  93         for(auto& cms: can_message_set_)
  94         {
  95                 std::vector<std::shared_ptr<can_message_definition_t> >& can_messages_definition = cms->get_can_message_definition();
  96                 for(auto& cmd : can_messages_definition)
  97                 {
  98                         cmd->set_parent(cms.get());
  99                         std::vector<std::shared_ptr<can_signal_t> >& can_signals = cmd->get_can_signals();
 100                         for(auto& sig: can_signals)
 101                         {
 102                                 sig->set_parent(cmd.get());
 103                         }
 104                 }
 105
 106                 std::vector<std::shared_ptr<diagnostic_message_t> >& diagnostic_messages = cms->get_diagnostic_messages();
 107                 for(auto& dm : diagnostic_messages)
 108                 {
 109                         dm->set_parent(cms.get());
 110                 }
 111         }
 112                 }
 113
 114 const std::string application_t::get_diagnostic_bus() const
 115 {
 116         return "";
 117 }
 118
 119