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         , 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{"hs", 0x3D9,"", 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                                                         "engine.speed",// generic_name
  14                                                         16,// bit_position
  15                                                         16,// bit_size
  16                                                         0.250000f,// 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                                                         "fuel.level.low",// generic_name
  36                                                         55,// bit_position
  37                                                         1,// 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                                                         decoder_t::decode_boolean,// 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                                                         "fuel.level",// generic_name
  58                                                         8,// bit_position
  59                                                         8,// bit_size
  60                                                         0.392157f,// 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                                         } // end signals vector
  79                                 })} // end message_definition entry
  80 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs", 0x3E9,"", 0, false, message_format_t::STANDARD, frequency_clock_t(5.00000f), true,
  81                                         { // beginning signals vector
  82                                                 {std::make_shared<signal_t> (signal_t{
  83                                                         "vehicle.average.speed",// generic_name
  84                                                         0,// bit_position
  85                                                         15,// bit_size
  86                                                         0.0156250f,// factor
  87                                                         0.00000f,// offset
  88                                                         0,// min_value
  89                                                         0,// max_value
  90                                                         frequency_clock_t(0.00000f),// frequency
  91                                                         true,// send_same
  92                                                         false,// force_send_changed
  93                                                         {
  94                                                         },// states
  95                                                         false,// writable
  96                                                         nullptr,// decoder
  97                                                         nullptr,// encoder
  98                                                         false,// received
  99                                                         std::make_pair<bool, int>(false, 0),// multiplex
 100                                                         0,// is_big_endian
 101                                                         0,// is_signed
 102                                                         ""// unit
 103                                                 })}
 104                                         } // end signals vector
 105                                 })} // end message_definition entry
 106 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs", 0x4D1,"", 0, false, message_format_t::STANDARD, frequency_clock_t(5.00000f), true,
 107                                         { // beginning signals vector
 108                                                 {std::make_shared<signal_t> (signal_t{
 109                                                         "engine.oil.temp",// generic_name
 110                                                         16,// bit_position
 111                                                         8,// bit_size
 112                                                         1.00000f,// factor
 113                                                         0.00000f,// offset
 114                                                         0,// min_value
 115                                                         0,// max_value
 116                                                         frequency_clock_t(0.00000f),// frequency
 117                                                         true,// send_same
 118                                                         false,// force_send_changed
 119                                                         {
 120                                                         },// states
 121                                                         false,// writable
 122                                                         nullptr,// decoder
 123                                                         nullptr,// encoder
 124                                                         false,// received
 125                                                         std::make_pair<bool, int>(false, 0),// multiplex
 126                                                         0,// is_big_endian
 127                                                         0,// is_signed
 128                                                         ""// unit
 129                                                 })},
 130                                                 {std::make_shared<signal_t> (signal_t{
 131                                                         "engine.oil.temp.high",// generic_name
 132                                                         7,// bit_position
 133                                                         1,// bit_size
 134                                                         1.00000f,// factor
 135                                                         0.00000f,// offset
 136                                                         0,// min_value
 137                                                         0,// max_value
 138                                                         frequency_clock_t(0.00000f),// frequency
 139                                                         true,// send_same
 140                                                         false,// force_send_changed
 141                                                         {
 142                                                         },// states
 143                                                         false,// writable
 144                                                         decoder_t::decode_boolean,// decoder
 145                                                         nullptr,// encoder
 146                                                         false,// received
 147                                                         std::make_pair<bool, int>(false, 0),// multiplex
 148                                                         0,// is_big_endian
 149                                                         0,// is_signed
 150                                                         ""// unit
 151                                                 })}
 152                                         } // end signals vector
 153                                 })} // end message_definition entry
 154
 155                 }, // end message_definition vector
 156                         { // beginning diagnostic_messages_ vector
 157
 158                         } // end diagnostic_messages_ vector
 159                 })} // end message_set entry
 160         } // end message_set vector
 161 {
 162         for(std::shared_ptr<message_set_t> cms: message_set_)
 163         {
 164                 vect_ptr_msg_def_t messages_definition = cms->get_messages_definition();
 165                 for(std::shared_ptr<message_definition_t> cmd : messages_definition)
 166                 {
 167                         cmd->set_parent(cms);
 168                         std::vector<std::shared_ptr<signal_t>> signals = cmd->get_signals();
 169                         for(std::shared_ptr<signal_t> sig: signals)
 170                         {
 171                                 sig->set_parent(cmd);
 172                         }
 173                 }
 174
 175                 std::vector<std::shared_ptr<diagnostic_message_t>> diagnostic_messages = cms->get_diagnostic_messages();
 176                 for(std::shared_ptr<diagnostic_message_t> dm : diagnostic_messages)
 177                 {
 178                         dm->set_parent(cms);
 179                 }
 180         }
 181                 }
 182
 183 const std::string application_t::get_diagnostic_bus() const
 184 {
 185         return "";
 186 }
 187
 188