plugins/agl-signals.cpp

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