tests/basic-generated.cpp

   1 #include <binding/application.hpp>
   2 #include <can/can-decoder.hpp>
   3 #include <can/can-encoder.hpp>
   4
   5 extern "C" {
   6 CTLP_CAPI_REGISTER("example");
   7
   8 std::shared_ptr<message_set_t> cms = 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{"can0",0x128,"ECM_z_5D2",8,0,frequency_clock_t(5.00000f),true,
  11                         { // beginning signals vector
  12                                 {std::make_shared<signal_t> (signal_t{
  13                                         "engine_speed",// generic_name
  14                                         12,// bit_position
  15                                         8,// bit_size
  16                                         1.00000f,// factor
  17                                         0.00000f,// offset
  18                                         0,// min_value
  19                                         0,// max_value
  20                                         frequency_clock_t(15.0000f),// 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                                         static_cast<sign_t>(0),// signed
  31                                         -1,// bit_sign_position
  32                                         ""// unit
  33                                 })},
  34                                 {std::make_shared<signal_t> (signal_t{
  35                                         "GearshiftPosition",// generic_name
  36                                         41,// bit_position
  37                                         3,// 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                                                 {1,"FIRST"},
  47                                                 {4,"FOURTH"},
  48                                                 {6,"NEUTRAL"},
  49                                                 {5,"REVERSE"},
  50                                                 {2,"SECOND"},
  51                                                 {3,"THIRD"}
  52                                         },// states
  53                                         false,// writable
  54                                         decoder_t::decode_state,// decoder
  55                                         nullptr,// encoder
  56                                         false,// received
  57                                         std::make_pair<bool, int>(false, 0),// multiplex
  58                                         static_cast<sign_t>(0),// signed
  59                                         -1,// bit_sign_position
  60                                         ""// unit
  61                                 })},
  62                                 {std::make_shared<signal_t> (signal_t{
  63                                         "SteeringWheelAngle",// generic_name
  64                                         52,// bit_position
  65                                         12,// bit_size
  66                                         0.153920f,// factor
  67                                         0.00000f,// offset
  68                                         0,// min_value
  69                                         0,// max_value
  70                                         frequency_clock_t(0.00000f),// frequency
  71                                         true,// send_same
  72                                         false,// force_send_changed
  73                                         {
  74                                         },// states
  75                                         false,// writable
  76                                         nullptr,// decoder
  77                                         nullptr,// encoder
  78                                         false,// received
  79                                         std::make_pair<bool, int>(false, 0),// multiplex
  80                                         static_cast<sign_t>(0),// signed
  81                                         -1,// bit_sign_position
  82                                         ""// unit
  83                                 })},
  84                                 {std::make_shared<signal_t> (signal_t{
  85                                         "steering_wheel_angle_error",// generic_name
  86                                         44,// bit_position
  87                                         12,// bit_size
  88                                         1.00000f,// factor
  89                                         0.00000f,// offset
  90                                         0,// min_value
  91                                         0,// max_value
  92                                         frequency_clock_t(0.00000f),// frequency
  93                                         true,// send_same
  94                                         false,// force_send_changed
  95                                         {
  96                                         },// states
  97                                         false,// writable
  98                                         nullptr,// decoder
  99                                         nullptr,// encoder
 100                                         false,// received
 101                                         std::make_pair<bool, int>(false, 0),// multiplex
 102                                         static_cast<sign_t>(0),// signed
 103                                         -1,// bit_sign_position
 104                                         ""// unit
 105                                 })},
 106                                 {std::make_shared<signal_t> (signal_t{
 107                                         "steering_angle_sign",// generic_name
 108                                         52,// bit_position
 109                                         12,// bit_size
 110                                         1.00000f,// factor
 111                                         0.00000f,// offset
 112                                         0,// min_value
 113                                         0,// max_value
 114                                         frequency_clock_t(0.00000f),// frequency
 115                                         true,// send_same
 116                                         false,// force_send_changed
 117                                         {
 118                                         },// states
 119                                         false,// writable
 120                                         nullptr,// decoder
 121                                         nullptr,// encoder
 122                                         false,// received
 123                                         std::make_pair<bool, int>(false, 0),// multiplex
 124                                         static_cast<sign_t>(0),// signed
 125                                         -1,// bit_sign_position
 126                                         ""// unit
 127                                 })}
 128                         } // end signals vector
 129                 })} // end message_definition entry
 130 ,               {std::make_shared<message_definition_t>(message_definition_t{"can0",0x813,"ECM_z_5D2",8,0,frequency_clock_t(5.00000f),true,
 131                         { // beginning signals vector
 132                                 {std::make_shared<signal_t> (signal_t{
 133                                         "abc",// generic_name
 134                                         52,// bit_position
 135                                         12,// bit_size
 136                                         0.153920f,// factor
 137                                         0.00000f,// offset
 138                                         0,// min_value
 139                                         0,// max_value
 140                                         frequency_clock_t(0.00000f),// frequency
 141                                         true,// send_same
 142                                         false,// force_send_changed
 143                                         {
 144                                         },// states
 145                                         false,// writable
 146                                         nullptr,// decoder
 147                                         nullptr,// encoder
 148                                         false,// received
 149                                         std::make_pair<bool, int>(false, 0),// multiplex
 150                                         static_cast<sign_t>(0),// signed
 151                                         -1,// bit_sign_position
 152                                         ""// unit
 153                                 })},
 154                                 {std::make_shared<signal_t> (signal_t{
 155                                         "def",// generic_name
 156                                         52,// bit_position
 157                                         12,// bit_size
 158                                         1.00000f,// factor
 159                                         0.00000f,// offset
 160                                         0,// min_value
 161                                         0,// max_value
 162                                         frequency_clock_t(0.00000f),// frequency
 163                                         true,// send_same
 164                                         false,// force_send_changed
 165                                         {
 166                                         },// states
 167                                         false,// writable
 168                                         decoder_t::ignoreDecoder,// decoder
 169                                         nullptr,// encoder
 170                                         false,// received
 171                                         std::make_pair<bool, int>(false, 0),// multiplex
 172                                         static_cast<sign_t>(0),// signed
 173                                         -1,// bit_sign_position
 174                                         ""// unit
 175                                 })}
 176                         } // end signals vector
 177                 })} // end message_definition entry
 178         }, // end message_definition vector
 179         { // beginning diagnostic_messages_ vector
 180                 {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 181                         12,
 182                         "",
 183                         0,
 184                         0,
 185                         UNIT::INVALID,
 186                         1.00000f,
 187                         decoder_t::decode_obd2_response,
 188                         nullptr,
 189                         true,
 190                         false
 191                 })}
 192 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 193                         12,
 194                         "",
 195                         0,
 196                         0,
 197                         UNIT::INVALID,
 198                         1.00000f,
 199                         nullptr,
 200                         nullptr,
 201                         true,
 202                         false
 203                 })}
 204 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 205                         6,
 206                         "",
 207                         0,
 208                         0,
 209                         UNIT::INVALID,
 210                         1.00000f,
 211                         decoder_t::decode_obd2_response,
 212                         nullptr,
 213                         true,
 214                         false
 215                 })}
 216
 217         } // end diagnostic_messages_ vector
 218 }); // end message_set entry
 219
 220 CTLP_ONLOAD(plugin, handle) {
 221         afb_api_t api = (afb_api_t) plugin->api;
 222         CtlConfigT* CtlConfig = (CtlConfigT*) afb_api_get_userdata(api);
 223         application_t* app = (application_t*) getExternalData(CtlConfig);
 224
 225         return app->add_message_set(cms);
 226 }
 227
 228
 229 }
 230