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