examples/engine/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{"hs",0x3D9,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                                                         "engine.speed",
  14                                                         16,
  15                                                         16,
  16                                                         0.250000f,
  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                                                         "fuel.level.low",
  32                                                         55,
  33                                                         1,
  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                                                         decoder_t::decode_boolean,
  45                                                         nullptr,
  46                                                         false
  47                                                 })},
  48                                                 {std::make_shared<can_signal_t> (can_signal_t{
  49                                                         "fuel.level",
  50                                                         8,
  51                                                         8,
  52                                                         0.392157f,
  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                                         } // end can_signals vector
  67                                 })} // end can_message_definition entry
  68 ,                               {std::make_shared<can_message_definition_t>(can_message_definition_t{"hs",0x3E9,can_message_format_t::STANDARD,frequency_clock_t(5.00000f),true,
  69                                         { // beginning can_signals vector
  70                                                 {std::make_shared<can_signal_t> (can_signal_t{
  71                                                         "vehicle.average.speed",
  72                                                         0,
  73                                                         15,
  74                                                         0.0156250f,
  75                                                         0.00000,
  76                                                         0,
  77                                                         0,
  78                                                         frequency_clock_t(0.00000f),
  79                                                         true,
  80                                                         false,
  81                                                         {
  82                                                         },
  83                                                         false,
  84                                                         nullptr,
  85                                                         nullptr,
  86                                                         false
  87                                                 })}
  88                                         } // end can_signals vector
  89                                 })} // end can_message_definition entry
  90 ,                               {std::make_shared<can_message_definition_t>(can_message_definition_t{"hs",0x4D1,can_message_format_t::STANDARD,frequency_clock_t(5.00000f),true,
  91                                         { // beginning can_signals vector
  92                                                 {std::make_shared<can_signal_t> (can_signal_t{
  93                                                         "engine.oil.temp",
  94                                                         16,
  95                                                         8,
  96                                                         1.00000f,
  97                                                         0.00000,
  98                                                         0,
  99                                                         0,
 100                                                         frequency_clock_t(0.00000f),
 101                                                         true,
 102                                                         false,
 103                                                         {
 104                                                         },
 105                                                         false,
 106                                                         nullptr,
 107                                                         nullptr,
 108                                                         false
 109                                                 })},
 110                                                 {std::make_shared<can_signal_t> (can_signal_t{
 111                                                         "engine.oil.temp.high",
 112                                                         7,
 113                                                         1,
 114                                                         1.00000f,
 115                                                         0.00000,
 116                                                         0,
 117                                                         0,
 118                                                         frequency_clock_t(0.00000f),
 119                                                         true,
 120                                                         false,
 121                                                         {
 122                                                         },
 123                                                         false,
 124                                                         decoder_t::decode_boolean,
 125                                                         nullptr,
 126                                                         false
 127                                                 })}
 128                                         } // end can_signals vector
 129                                 })} // end can_message_definition entry
 130
 131                 }, // end can_message_definition vector
 132                         { // beginning diagnostic_messages_ vector
 133
 134                         } // end diagnostic_messages_ vector
 135                 })} // end can_message_set entry
 136         } // end can_message_set vector
 137 {
 138         for(auto& cms: can_message_set_)
 139         {
 140                 std::vector<std::shared_ptr<can_message_definition_t> >& can_messages_definition = cms->get_can_message_definition();
 141                 for(auto& cmd : can_messages_definition)
 142                 {
 143                         cmd->set_parent(cms.get());
 144                         std::vector<std::shared_ptr<can_signal_t> >& can_signals = cmd->get_can_signals();
 145                         for(auto& sig: can_signals)
 146                         {
 147                                 sig->set_parent(cmd.get());
 148                         }
 149                 }
 150
 151                 std::vector<std::shared_ptr<diagnostic_message_t> >& diagnostic_messages = cms->get_diagnostic_messages();
 152                 for(auto& dm : diagnostic_messages)
 153                 {
 154                         dm->set_parent(cms.get());
 155                 }
 156         }
 157                 }
 158
 159 const std::string application_t::get_diagnostic_bus() const
 160 {
 161         return "";
 162 }
 163
 164