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