plugins/agl-vcar-signals.cpp

   1 #include <binding/application.hpp>
   2 #include <can/can-decoder.hpp>
   3 #include <can/can-encoder.hpp>
   4
   5 extern "C"
   6 {
   7
   8 CTLP_CAPI_REGISTER("agl-vcar-signals");
   9
  10 std::shared_ptr<message_set_t> cms = std::make_shared<message_set_t>(message_set_t{0,"AGL Virtual Car",
  11                         { // beginning message_definition_ vector
  12                                 {std::make_shared<message_definition_t>(message_definition_t{"ls",0x30,"",8,0,true,frequency_clock_t(5.00000f),true,
  13                                         { // beginning signals vector
  14                                                 {std::make_shared<signal_t> (signal_t{
  15                                                         "hvac.fan.speed",// generic_name
  16                                                         32,// bit_position
  17                                                         8,// bit_size
  18                                                         23.5294f,// factor
  19                                                         0.00000f,// offset
  20                                                         0,// min_value
  21                                                         0,// max_value
  22                                                         frequency_clock_t(0.00000f),// frequency
  23                                                         true,// send_same
  24                                                         false,// force_send_changed
  25                                                         {
  26                                                         },// states
  27                                                         true,// writable
  28                                                         nullptr,// decoder
  29                                                         nullptr,// encoder
  30                                                         false,// received
  31                                                         std::make_pair<bool, int>(false, 0),// multiplex
  32                                                         false,// is_big_endian
  33                                                         static_cast<sign_t>(0),// signed
  34                                                         -1,// bit_sign_position
  35                                                         ""// unit
  36                                                 })},
  37                                                 {std::make_shared<signal_t> (signal_t{
  38                                                         "hvac.temperature.left",// generic_name
  39                                                         0,// bit_position
  40                                                         8,// bit_size
  41                                                         1.00000f,// factor
  42                                                         0.00000f,// offset
  43                                                         0,// min_value
  44                                                         0,// max_value
  45                                                         frequency_clock_t(0.00000f),// frequency
  46                                                         true,// send_same
  47                                                         false,// force_send_changed
  48                                                         {
  49                                                         },// states
  50                                                         true,// writable
  51                                                         nullptr,// decoder
  52                                                         nullptr,// encoder
  53                                                         false,// received
  54                                                         std::make_pair<bool, int>(false, 0),// multiplex
  55                                                         false,// is_big_endian
  56                                                         static_cast<sign_t>(0),// signed
  57                                                         -1,// bit_sign_position
  58                                                         ""// unit
  59                                                 })},
  60                                                 {std::make_shared<signal_t> (signal_t{
  61                                                         "hvac.temperature.right",// generic_name
  62                                                         8,// bit_position
  63                                                         8,// bit_size
  64                                                         1.00000f,// factor
  65                                                         0.00000f,// offset
  66                                                         0,// min_value
  67                                                         0,// max_value
  68                                                         frequency_clock_t(0.00000f),// frequency
  69                                                         true,// send_same
  70                                                         false,// force_send_changed
  71                                                         {
  72                                                         },// states
  73                                                         true,// writable
  74                                                         nullptr,// decoder
  75                                                         nullptr,// encoder
  76                                                         false,// received
  77                                                         std::make_pair<bool, int>(false, 0),// multiplex
  78                                                         false,// is_big_endian
  79                                                         static_cast<sign_t>(0),// signed
  80                                                         -1,// bit_sign_position
  81                                                         ""// unit
  82                                                 })},
  83                                                 {std::make_shared<signal_t> (signal_t{
  84                                                         "hvac.temperature.average",// generic_name
  85                                                         16,// bit_position
  86                                                         8,// bit_size
  87                                                         1.00000f,// factor
  88                                                         0.00000f,// offset
  89                                                         0,// min_value
  90                                                         0,// max_value
  91                                                         frequency_clock_t(0.00000f),// frequency
  92                                                         true,// send_same
  93                                                         false,// force_send_changed
  94                                                         {
  95                                                         },// states
  96                                                         true,// writable
  97                                                         nullptr,// decoder
  98                                                         nullptr,// encoder
  99                                                         false,// received
 100                                                         std::make_pair<bool, int>(false, 0),// multiplex
 101                                                         false,// is_big_endian
 102                                                         static_cast<sign_t>(0),// signed
 103                                                         -1,// bit_sign_position
 104                                                         ""// unit
 105                                                 })}
 106                                         } // end signals vector
 107                                 })} // end message_definition entry
 108 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x3D9,"",8,128,true,frequency_clock_t(5.00000f),true,
 109                                         { // beginning signals vector
 110                                                 {std::make_shared<signal_t> (signal_t{
 111                                                         "engine.speed",// generic_name
 112                                                         16,// bit_position
 113                                                         16,// bit_size
 114                                                         0.250000f,// factor
 115                                                         0.00000f,// offset
 116                                                         0,// min_value
 117                                                         0,// max_value
 118                                                         frequency_clock_t(0.00000f),// frequency
 119                                                         true,// send_same
 120                                                         false,// force_send_changed
 121                                                         {
 122                                                         },// states
 123                                                         true,// writable
 124                                                         nullptr,// decoder
 125                                                         nullptr,// encoder
 126                                                         false,// received
 127                                                         std::make_pair<bool, int>(false, 0),// multiplex
 128                                                         false,// is_big_endian
 129                                                         static_cast<sign_t>(0),// signed
 130                                                         -1,// bit_sign_position
 131                                                         ""// unit
 132                                                 })},
 133                                                 {std::make_shared<signal_t> (signal_t{
 134                                                         "fuel.level.low",// generic_name
 135                                                         55,// bit_position
 136                                                         1,// bit_size
 137                                                         1.00000f,// factor
 138                                                         0.00000f,// offset
 139                                                         0,// min_value
 140                                                         0,// max_value
 141                                                         frequency_clock_t(0.00000f),// frequency
 142                                                         true,// send_same
 143                                                         false,// force_send_changed
 144                                                         {
 145                                                         },// states
 146                                                         true,// writable
 147                                                         decoder_t::decode_boolean,// decoder
 148                                                         nullptr,// encoder
 149                                                         false,// received
 150                                                         std::make_pair<bool, int>(false, 0),// multiplex
 151                                                         false,// is_big_endian
 152                                                         static_cast<sign_t>(0),// signed
 153                                                         -1,// bit_sign_position
 154                                                         ""// unit
 155                                                 })},
 156                                                 {std::make_shared<signal_t> (signal_t{
 157                                                         "fuel.level",// generic_name
 158                                                         8,// bit_position
 159                                                         8,// bit_size
 160                                                         0.392157f,// factor
 161                                                         0.00000f,// offset
 162                                                         0,// min_value
 163                                                         0,// max_value
 164                                                         frequency_clock_t(0.00000f),// frequency
 165                                                         true,// send_same
 166                                                         false,// force_send_changed
 167                                                         {
 168                                                         },// states
 169                                                         true,// writable
 170                                                         nullptr,// decoder
 171                                                         nullptr,// encoder
 172                                                         false,// received
 173                                                         std::make_pair<bool, int>(false, 0),// multiplex
 174                                                         false,// is_big_endian
 175                                                         static_cast<sign_t>(0),// signed
 176                                                         -1,// bit_sign_position
 177                                                         ""// unit
 178                                                 })}
 179                                         } // end signals vector
 180                                 })} // end message_definition entry
 181 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x3E9,"",8,0,true,frequency_clock_t(5.00000f),true,
 182                                         { // beginning signals vector
 183                                                 {std::make_shared<signal_t> (signal_t{
 184                                                         "vehicle.average.speed",// generic_name
 185                                                         0,// bit_position
 186                                                         15,// bit_size
 187                                                         0.0156250f,// factor
 188                                                         0.00000f,// offset
 189                                                         0,// min_value
 190                                                         0,// max_value
 191                                                         frequency_clock_t(0.00000f),// frequency
 192                                                         true,// send_same
 193                                                         false,// force_send_changed
 194                                                         {
 195                                                         },// states
 196                                                         false,// writable
 197                                                         nullptr,// decoder
 198                                                         nullptr,// encoder
 199                                                         false,// received
 200                                                         std::make_pair<bool, int>(false, 0),// multiplex
 201                                                         false,// is_big_endian
 202                                                         static_cast<sign_t>(0),// signed
 203                                                         -1,// bit_sign_position
 204                                                         ""// unit
 205                                                 })}
 206                                         } // end signals vector
 207                                 })} // end message_definition entry
 208 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x4D1,"",8,0,true,frequency_clock_t(5.00000f),true,
 209                                         { // beginning signals vector
 210                                                 {std::make_shared<signal_t> (signal_t{
 211                                                         "engine.oil.temp",// generic_name
 212                                                         16,// bit_position
 213                                                         8,// bit_size
 214                                                         1.00000f,// factor
 215                                                         0.00000f,// offset
 216                                                         0,// min_value
 217                                                         0,// max_value
 218                                                         frequency_clock_t(0.00000f),// frequency
 219                                                         true,// send_same
 220                                                         false,// force_send_changed
 221                                                         {
 222                                                         },// states
 223                                                         true,// writable
 224                                                         nullptr,// decoder
 225                                                         nullptr,// encoder
 226                                                         false,// received
 227                                                         std::make_pair<bool, int>(false, 0),// multiplex
 228                                                         false,// is_big_endian
 229                                                         static_cast<sign_t>(0),// signed
 230                                                         -1,// bit_sign_position
 231                                                         ""// unit
 232                                                 })},
 233                                                 {std::make_shared<signal_t> (signal_t{
 234                                                         "engine.oil.temp.high",// generic_name
 235                                                         7,// bit_position
 236                                                         1,// bit_size
 237                                                         1.00000f,// factor
 238                                                         0.00000f,// offset
 239                                                         0,// min_value
 240                                                         0,// max_value
 241                                                         frequency_clock_t(0.00000f),// frequency
 242                                                         true,// send_same
 243                                                         false,// force_send_changed
 244                                                         {
 245                                                         },// states
 246                                                         true,// writable
 247                                                         decoder_t::decode_boolean,// decoder
 248                                                         nullptr,// encoder
 249                                                         false,// received
 250                                                         std::make_pair<bool, int>(false, 0),// multiplex
 251                                                         false,// is_big_endian
 252                                                         static_cast<sign_t>(0),// signed
 253                                                         -1,// bit_sign_position
 254                                                         ""// unit
 255                                                 })}
 256                                         } // end signals vector
 257                                 })} // end message_definition entry
 258 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x620,"",8,0,true,frequency_clock_t(5.00000f),true,
 259                                         { // beginning signals vector
 260                                                 {std::make_shared<signal_t> (signal_t{
 261                                                         "doors.boot.open",// generic_name
 262                                                         47,// bit_position
 263                                                         1,// bit_size
 264                                                         1.00000f,// factor
 265                                                         0.00000f,// offset
 266                                                         0,// min_value
 267                                                         0,// max_value
 268                                                         frequency_clock_t(0.00000f),// frequency
 269                                                         true,// send_same
 270                                                         false,// force_send_changed
 271                                                         {
 272                                                         },// states
 273                                                         true,// writable
 274                                                         decoder_t::decode_boolean,// decoder
 275                                                         nullptr,// encoder
 276                                                         false,// received
 277                                                         std::make_pair<bool, int>(false, 0),// multiplex
 278                                                         false,// is_big_endian
 279                                                         static_cast<sign_t>(0),// signed
 280                                                         -1,// bit_sign_position
 281                                                         ""// unit
 282                                                 })},
 283                                                 {std::make_shared<signal_t> (signal_t{
 284                                                         "doors.front_left.open",// generic_name
 285                                                         43,// bit_position
 286                                                         1,// bit_size
 287                                                         1.00000f,// factor
 288                                                         0.00000f,// offset
 289                                                         0,// min_value
 290                                                         0,// max_value
 291                                                         frequency_clock_t(0.00000f),// frequency
 292                                                         true,// send_same
 293                                                         false,// force_send_changed
 294                                                         {
 295                                                         },// states
 296                                                         true,// writable
 297                                                         decoder_t::decode_boolean,// decoder
 298                                                         nullptr,// encoder
 299                                                         false,// received
 300                                                         std::make_pair<bool, int>(false, 0),// multiplex
 301                                                         false,// is_big_endian
 302                                                         static_cast<sign_t>(0),// signed
 303                                                         -1,// bit_sign_position
 304                                                         ""// unit
 305                                                 })},
 306                                                 {std::make_shared<signal_t> (signal_t{
 307                                                         "doors.front_right.open",// generic_name
 308                                                         44,// bit_position
 309                                                         1,// bit_size
 310                                                         1.00000f,// factor
 311                                                         0.00000f,// offset
 312                                                         0,// min_value
 313                                                         0,// max_value
 314                                                         frequency_clock_t(0.00000f),// frequency
 315                                                         true,// send_same
 316                                                         false,// force_send_changed
 317                                                         {
 318                                                         },// states
 319                                                         true,// writable
 320                                                         decoder_t::decode_boolean,// decoder
 321                                                         nullptr,// encoder
 322                                                         false,// received
 323                                                         std::make_pair<bool, int>(false, 0),// multiplex
 324                                                         false,// is_big_endian
 325                                                         static_cast<sign_t>(0),// signed
 326                                                         -1,// bit_sign_position
 327                                                         ""// unit
 328                                                 })},
 329                                                 {std::make_shared<signal_t> (signal_t{
 330                                                         "doors.rear_left.open",// generic_name
 331                                                         46,// bit_position
 332                                                         1,// bit_size
 333                                                         1.00000f,// factor
 334                                                         0.00000f,// offset
 335                                                         0,// min_value
 336                                                         0,// max_value
 337                                                         frequency_clock_t(0.00000f),// frequency
 338                                                         true,// send_same
 339                                                         false,// force_send_changed
 340                                                         {
 341                                                         },// states
 342                                                         true,// writable
 343                                                         decoder_t::decode_boolean,// decoder
 344                                                         nullptr,// encoder
 345                                                         false,// received
 346                                                         std::make_pair<bool, int>(false, 0),// multiplex
 347                                                         false,// is_big_endian
 348                                                         static_cast<sign_t>(0),// signed
 349                                                         -1,// bit_sign_position
 350                                                         ""// unit
 351                                                 })},
 352                                                 {std::make_shared<signal_t> (signal_t{
 353                                                         "doors.rear_right.open",// generic_name
 354                                                         45,// bit_position
 355                                                         4,// bit_size
 356                                                         1.00000f,// factor
 357                                                         0.00000f,// offset
 358                                                         0,// min_value
 359                                                         0,// max_value
 360                                                         frequency_clock_t(0.00000f),// frequency
 361                                                         true,// send_same
 362                                                         false,// force_send_changed
 363                                                         {
 364                                                         },// states
 365                                                         true,// writable
 366                                                         decoder_t::decode_boolean,// decoder
 367                                                         nullptr,// encoder
 368                                                         false,// received
 369                                                         std::make_pair<bool, int>(false, 0),// multiplex
 370                                                         false,// is_big_endian
 371                                                         static_cast<sign_t>(0),// signed
 372                                                         -1,// bit_sign_position
 373                                                         ""// unit
 374                                                 })}
 375                                         } // end signals vector
 376                                 })} // end message_definition entry
 377 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x799,"",8,0,true,frequency_clock_t(5.00000f),true,
 378                                         { // beginning signals vector
 379                                                 {std::make_shared<signal_t> (signal_t{
 380                                                         "windows.front_left.open",// generic_name
 381                                                         43,// bit_position
 382                                                         1,// bit_size
 383                                                         1.00000f,// factor
 384                                                         0.00000f,// offset
 385                                                         0,// min_value
 386                                                         0,// max_value
 387                                                         frequency_clock_t(0.00000f),// frequency
 388                                                         true,// send_same
 389                                                         false,// force_send_changed
 390                                                         {
 391                                                         },// states
 392                                                         true,// writable
 393                                                         decoder_t::decode_boolean,// decoder
 394                                                         nullptr,// encoder
 395                                                         false,// received
 396                                                         std::make_pair<bool, int>(false, 0),// multiplex
 397                                                         false,// is_big_endian
 398                                                         static_cast<sign_t>(0),// signed
 399                                                         -1,// bit_sign_position
 400                                                         ""// unit
 401                                                 })},
 402                                                 {std::make_shared<signal_t> (signal_t{
 403                                                         "windows.front_right.open",// generic_name
 404                                                         44,// bit_position
 405                                                         1,// bit_size
 406                                                         1.00000f,// factor
 407                                                         0.00000f,// offset
 408                                                         0,// min_value
 409                                                         0,// max_value
 410                                                         frequency_clock_t(0.00000f),// frequency
 411                                                         true,// send_same
 412                                                         false,// force_send_changed
 413                                                         {
 414                                                         },// states
 415                                                         true,// writable
 416                                                         decoder_t::decode_boolean,// decoder
 417                                                         nullptr,// encoder
 418                                                         false,// received
 419                                                         std::make_pair<bool, int>(false, 0),// multiplex
 420                                                         false,// is_big_endian
 421                                                         static_cast<sign_t>(0),// signed
 422                                                         -1,// bit_sign_position
 423                                                         ""// unit
 424                                                 })},
 425                                                 {std::make_shared<signal_t> (signal_t{
 426                                                         "windows.rear_left.open",// generic_name
 427                                                         46,// bit_position
 428                                                         1,// bit_size
 429                                                         1.00000f,// factor
 430                                                         0.00000f,// offset
 431                                                         0,// min_value
 432                                                         0,// max_value
 433                                                         frequency_clock_t(0.00000f),// frequency
 434                                                         true,// send_same
 435                                                         false,// force_send_changed
 436                                                         {
 437                                                         },// states
 438                                                         true,// writable
 439                                                         decoder_t::decode_boolean,// decoder
 440                                                         nullptr,// encoder
 441                                                         false,// received
 442                                                         std::make_pair<bool, int>(false, 0),// multiplex
 443                                                         false,// is_big_endian
 444                                                         static_cast<sign_t>(0),// signed
 445                                                         -1,// bit_sign_position
 446                                                         ""// unit
 447                                                 })},
 448                                                 {std::make_shared<signal_t> (signal_t{
 449                                                         "windows.rear_right.open",// generic_name
 450                                                         45,// bit_position
 451                                                         4,// bit_size
 452                                                         1.00000f,// factor
 453                                                         0.00000f,// offset
 454                                                         0,// min_value
 455                                                         0,// max_value
 456                                                         frequency_clock_t(0.00000f),// frequency
 457                                                         true,// send_same
 458                                                         false,// force_send_changed
 459                                                         {
 460                                                         },// states
 461                                                         true,// writable
 462                                                         decoder_t::decode_boolean,// decoder
 463                                                         nullptr,// encoder
 464                                                         false,// received
 465                                                         std::make_pair<bool, int>(false, 0),// multiplex
 466                                                         false,// is_big_endian
 467                                                         static_cast<sign_t>(0),// signed
 468                                                         -1,// bit_sign_position
 469                                                         ""// unit
 470                                                 })}
 471                                         } // end signals vector
 472                                 })} // end message_definition entry
 473
 474                 }, // end message_definition vector
 475                         { // beginning diagnostic_messages_ vector
 476                                 {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 477                                         4,
 478                                         "engine.load",
 479                                         0,
 480                                         0,
 481                                         UNIT::INVALID,
 482                                         5.00000f,
 483                                         decoder_t::decode_obd2_response,
 484                                         nullptr,
 485                                         true,
 486                                         false
 487                                 })}
 488 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 489                                         5,
 490                                         "engine.coolant.temperature",
 491                                         0,
 492                                         0,
 493                                         UNIT::INVALID,
 494                                         1.00000f,
 495                                         decoder_t::decode_obd2_response,
 496                                         nullptr,
 497                                         true,
 498                                         false
 499                                 })}
 500 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 501                                         10,
 502                                         "fuel.pressure",
 503                                         0,
 504                                         0,
 505                                         UNIT::INVALID,
 506                                         1.00000f,
 507                                         decoder_t::decode_obd2_response,
 508                                         nullptr,
 509                                         true,
 510                                         false
 511                                 })}
 512 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 513                                         11,
 514                                         "intake.manifold.pressure",
 515                                         0,
 516                                         0,
 517                                         UNIT::INVALID,
 518                                         1.00000f,
 519                                         decoder_t::decode_obd2_response,
 520                                         nullptr,
 521                                         true,
 522                                         false
 523                                 })}
 524 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 525                                         12,
 526                                         "engine.speed",
 527                                         0,
 528                                         0,
 529                                         UNIT::INVALID,
 530                                         5.00000f,
 531                                         decoder_t::decode_obd2_response,
 532                                         nullptr,
 533                                         true,
 534                                         false
 535                                 })}
 536 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 537                                         13,
 538                                         "vehicle.speed",
 539                                         0,
 540                                         0,
 541                                         UNIT::INVALID,
 542                                         5.00000f,
 543                                         decoder_t::decode_obd2_response,
 544                                         nullptr,
 545                                         true,
 546                                         false
 547                                 })}
 548 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 549                                         15,
 550                                         "intake.air.temperature",
 551                                         0,
 552                                         0,
 553                                         UNIT::INVALID,
 554                                         1.00000f,
 555                                         decoder_t::decode_obd2_response,
 556                                         nullptr,
 557                                         true,
 558                                         false
 559                                 })}
 560 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 561                                         16,
 562                                         "mass.airflow",
 563                                         0,
 564                                         0,
 565                                         UNIT::INVALID,
 566                                         5.00000f,
 567                                         decoder_t::decode_obd2_response,
 568                                         nullptr,
 569                                         true,
 570                                         false
 571                                 })}
 572 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 573                                         17,
 574                                         "throttle.position",
 575                                         0,
 576                                         0,
 577                                         UNIT::INVALID,
 578                                         5.00000f,
 579                                         decoder_t::decode_obd2_response,
 580                                         nullptr,
 581                                         true,
 582                                         false
 583                                 })}
 584 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 585                                         31,
 586                                         "running.time",
 587                                         0,
 588                                         0,
 589                                         UNIT::INVALID,
 590                                         1.00000f,
 591                                         decoder_t::decode_obd2_response,
 592                                         nullptr,
 593                                         true,
 594                                         false
 595                                 })}
 596 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 597                                         45,
 598                                         "EGR.error",
 599                                         0,
 600                                         0,
 601                                         UNIT::INVALID,
 602                                         0.00000f,
 603                                         decoder_t::decode_obd2_response,
 604                                         nullptr,
 605                                         true,
 606                                         false
 607                                 })}
 608 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 609                                         47,
 610                                         "fuel.level",
 611                                         0,
 612                                         0,
 613                                         UNIT::INVALID,
 614                                         1.00000f,
 615                                         decoder_t::decode_obd2_response,
 616                                         nullptr,
 617                                         true,
 618                                         false
 619                                 })}
 620 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 621                                         51,
 622                                         "barometric.pressure",
 623                                         0,
 624                                         0,
 625                                         UNIT::INVALID,
 626                                         1.00000f,
 627                                         decoder_t::decode_obd2_response,
 628                                         nullptr,
 629                                         true,
 630                                         false
 631                                 })}
 632 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 633                                         70,
 634                                         "ambient.air.temperature",
 635                                         0,
 636                                         0,
 637                                         UNIT::INVALID,
 638                                         1.00000f,
 639                                         decoder_t::decode_obd2_response,
 640                                         nullptr,
 641                                         true,
 642                                         false
 643                                 })}
 644 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 645                                         76,
 646                                         "commanded.throttle.position",
 647                                         0,
 648                                         0,
 649                                         UNIT::INVALID,
 650                                         1.00000f,
 651                                         decoder_t::decode_obd2_response,
 652                                         nullptr,
 653                                         true,
 654                                         false
 655                                 })}
 656 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 657                                         82,
 658                                         "ethanol.fuel.percentage",
 659                                         0,
 660                                         0,
 661                                         UNIT::INVALID,
 662                                         1.00000f,
 663                                         decoder_t::decode_obd2_response,
 664                                         nullptr,
 665                                         true,
 666                                         false
 667                                 })}
 668 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 669                                         90,
 670                                         "accelerator.pedal.position",
 671                                         0,
 672                                         0,
 673                                         UNIT::INVALID,
 674                                         5.00000f,
 675                                         decoder_t::decode_obd2_response,
 676                                         nullptr,
 677                                         true,
 678                                         false
 679                                 })}
 680 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 681                                         91,
 682                                         "hybrid.battery-pack.remaining.life",
 683                                         0,
 684                                         0,
 685                                         UNIT::INVALID,
 686                                         5.00000f,
 687                                         decoder_t::decode_obd2_response,
 688                                         nullptr,
 689                                         true,
 690                                         false
 691                                 })}
 692 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 693                                         92,
 694                                         "engine.oil.temperature",
 695                                         0,
 696                                         0,
 697                                         UNIT::INVALID,
 698                                         1.00000f,
 699                                         decoder_t::decode_obd2_response,
 700                                         nullptr,
 701                                         true,
 702                                         false
 703                                 })}
 704 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 705                                         94,
 706                                         "engine.fuel.rate",
 707                                         0,
 708                                         0,
 709                                         UNIT::INVALID,
 710                                         1.00000f,
 711                                         decoder_t::decode_obd2_response,
 712                                         nullptr,
 713                                         true,
 714                                         false
 715                                 })}
 716 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 717                                         99,
 718                                         "engine.torque",
 719                                         0,
 720                                         0,
 721                                         UNIT::INVALID,
 722                                         1.00000f,
 723                                         decoder_t::decode_obd2_response,
 724                                         nullptr,
 725                                         true,
 726                                         false
 727                                 })}
 728
 729                         } // end diagnostic_messages_ vector
 730                 }); // end message_set entry
 731
 732 CTLP_ONLOAD(plugin, handle)
 733 {
 734         afb_api_t api = (afb_api_t) plugin->api;
 735         CtlConfigT* CtlConfig = (CtlConfigT*) afb_api_get_userdata(api);
 736         application_t* app = (application_t*) getExternalData(CtlConfig);
 737
 738         return app->add_message_set(cms);
 739 }
 740
 741 }