examples/agl-vcar/application-generated.cpp

   1 #include "application.hpp"
   2 #include "../can/can-decoder.hpp"
   3 #include "../can/can-encoder.hpp"
   4
   5 application_t::application_t()
   6         : can_bus_manager_{utils::config_parser_t{"/etc/dev-mapping.conf"}}
   7         , message_set_{
   8                 {std::make_shared<message_set_t>(message_set_t{0,"AGL Virtual Car",
   9                         { // beginning message_definition_ vector
  10                                 {std::make_shared<message_definition_t>(message_definition_t{"ls",0x30,"",8,4,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                                                         0,// is_big_endian
  31                                                         0,// is_signed
  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                                                         0,// is_big_endian
  53                                                         0,// is_signed
  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                                                         0,// is_big_endian
  75                                                         0,// is_signed
  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                                                         0,// is_big_endian
  97                                                         0,// is_signed
  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,2050,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                                                         0,// is_big_endian
 123                                                         0,// is_signed
 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                                                         0,// is_big_endian
 145                                                         0,// is_signed
 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                                                         0,// is_big_endian
 167                                                         0,// is_signed
 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,2,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                                                         0,// is_big_endian
 193                                                         0,// is_signed
 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,2,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                                                         0,// is_big_endian
 219                                                         0,// is_signed
 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                                                         0,// is_big_endian
 241                                                         0,// is_signed
 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,2,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                                                         0,// is_big_endian
 267                                                         0,// is_signed
 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                                                         0,// is_big_endian
 289                                                         0,// is_signed
 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                                                         0,// is_big_endian
 311                                                         0,// is_signed
 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                                                         0,// is_big_endian
 333                                                         0,// is_signed
 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                                                         0,// is_big_endian
 355                                                         0,// is_signed
 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,2,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                                                         0,// is_big_endian
 381                                                         0,// is_signed
 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                                                         0,// is_big_endian
 403                                                         0,// is_signed
 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                                                         0,// is_big_endian
 425                                                         0,// is_signed
 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                                                         0,// is_big_endian
 447                                                         0,// is_signed
 448                                                         ""// unit
 449                                                 })}
 450                                         } // end signals vector
 451                                 })} // end message_definition entry
 452
 453                 }, // end message_definition vector
 454                         { // beginning diagnostic_messages_ vector
 455                                 {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 456                                         4,
 457                                         "engine.load",
 458                                         0,
 459                                         0,
 460                                         UNIT::INVALID,
 461                                         5.00000f,
 462                                         decoder_t::decode_obd2_response,
 463                                         nullptr,
 464                                         true,
 465                                         false
 466                                 })}
 467 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 468                                         5,
 469                                         "engine.coolant.temperature",
 470                                         0,
 471                                         0,
 472                                         UNIT::INVALID,
 473                                         1.00000f,
 474                                         decoder_t::decode_obd2_response,
 475                                         nullptr,
 476                                         true,
 477                                         false
 478                                 })}
 479 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 480                                         10,
 481                                         "fuel.pressure",
 482                                         0,
 483                                         0,
 484                                         UNIT::INVALID,
 485                                         1.00000f,
 486                                         decoder_t::decode_obd2_response,
 487                                         nullptr,
 488                                         true,
 489                                         false
 490                                 })}
 491 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 492                                         11,
 493                                         "intake.manifold.pressure",
 494                                         0,
 495                                         0,
 496                                         UNIT::INVALID,
 497                                         1.00000f,
 498                                         decoder_t::decode_obd2_response,
 499                                         nullptr,
 500                                         true,
 501                                         false
 502                                 })}
 503 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 504                                         12,
 505                                         "engine.speed",
 506                                         0,
 507                                         0,
 508                                         UNIT::INVALID,
 509                                         5.00000f,
 510                                         decoder_t::decode_obd2_response,
 511                                         nullptr,
 512                                         true,
 513                                         false
 514                                 })}
 515 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 516                                         13,
 517                                         "vehicle.speed",
 518                                         0,
 519                                         0,
 520                                         UNIT::INVALID,
 521                                         5.00000f,
 522                                         decoder_t::decode_obd2_response,
 523                                         nullptr,
 524                                         true,
 525                                         false
 526                                 })}
 527 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 528                                         15,
 529                                         "intake.air.temperature",
 530                                         0,
 531                                         0,
 532                                         UNIT::INVALID,
 533                                         1.00000f,
 534                                         decoder_t::decode_obd2_response,
 535                                         nullptr,
 536                                         true,
 537                                         false
 538                                 })}
 539 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 540                                         16,
 541                                         "mass.airflow",
 542                                         0,
 543                                         0,
 544                                         UNIT::INVALID,
 545                                         5.00000f,
 546                                         decoder_t::decode_obd2_response,
 547                                         nullptr,
 548                                         true,
 549                                         false
 550                                 })}
 551 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 552                                         17,
 553                                         "throttle.position",
 554                                         0,
 555                                         0,
 556                                         UNIT::INVALID,
 557                                         5.00000f,
 558                                         decoder_t::decode_obd2_response,
 559                                         nullptr,
 560                                         true,
 561                                         false
 562                                 })}
 563 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 564                                         31,
 565                                         "running.time",
 566                                         0,
 567                                         0,
 568                                         UNIT::INVALID,
 569                                         1.00000f,
 570                                         decoder_t::decode_obd2_response,
 571                                         nullptr,
 572                                         true,
 573                                         false
 574                                 })}
 575 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 576                                         45,
 577                                         "EGR.error",
 578                                         0,
 579                                         0,
 580                                         UNIT::INVALID,
 581                                         0.00000f,
 582                                         decoder_t::decode_obd2_response,
 583                                         nullptr,
 584                                         true,
 585                                         false
 586                                 })}
 587 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 588                                         47,
 589                                         "fuel.level",
 590                                         0,
 591                                         0,
 592                                         UNIT::INVALID,
 593                                         1.00000f,
 594                                         decoder_t::decode_obd2_response,
 595                                         nullptr,
 596                                         true,
 597                                         false
 598                                 })}
 599 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 600                                         51,
 601                                         "barometric.pressure",
 602                                         0,
 603                                         0,
 604                                         UNIT::INVALID,
 605                                         1.00000f,
 606                                         decoder_t::decode_obd2_response,
 607                                         nullptr,
 608                                         true,
 609                                         false
 610                                 })}
 611 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 612                                         70,
 613                                         "ambient.air.temperature",
 614                                         0,
 615                                         0,
 616                                         UNIT::INVALID,
 617                                         1.00000f,
 618                                         decoder_t::decode_obd2_response,
 619                                         nullptr,
 620                                         true,
 621                                         false
 622                                 })}
 623 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 624                                         76,
 625                                         "commanded.throttle.position",
 626                                         0,
 627                                         0,
 628                                         UNIT::INVALID,
 629                                         1.00000f,
 630                                         decoder_t::decode_obd2_response,
 631                                         nullptr,
 632                                         true,
 633                                         false
 634                                 })}
 635 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 636                                         82,
 637                                         "ethanol.fuel.percentage",
 638                                         0,
 639                                         0,
 640                                         UNIT::INVALID,
 641                                         1.00000f,
 642                                         decoder_t::decode_obd2_response,
 643                                         nullptr,
 644                                         true,
 645                                         false
 646                                 })}
 647 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 648                                         90,
 649                                         "accelerator.pedal.position",
 650                                         0,
 651                                         0,
 652                                         UNIT::INVALID,
 653                                         5.00000f,
 654                                         decoder_t::decode_obd2_response,
 655                                         nullptr,
 656                                         true,
 657                                         false
 658                                 })}
 659 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 660                                         91,
 661                                         "hybrid.battery-pack.remaining.life",
 662                                         0,
 663                                         0,
 664                                         UNIT::INVALID,
 665                                         5.00000f,
 666                                         decoder_t::decode_obd2_response,
 667                                         nullptr,
 668                                         true,
 669                                         false
 670                                 })}
 671 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 672                                         92,
 673                                         "engine.oil.temperature",
 674                                         0,
 675                                         0,
 676                                         UNIT::INVALID,
 677                                         1.00000f,
 678                                         decoder_t::decode_obd2_response,
 679                                         nullptr,
 680                                         true,
 681                                         false
 682                                 })}
 683 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 684                                         94,
 685                                         "engine.fuel.rate",
 686                                         0,
 687                                         0,
 688                                         UNIT::INVALID,
 689                                         1.00000f,
 690                                         decoder_t::decode_obd2_response,
 691                                         nullptr,
 692                                         true,
 693                                         false
 694                                 })}
 695 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 696                                         99,
 697                                         "engine.torque",
 698                                         0,
 699                                         0,
 700                                         UNIT::INVALID,
 701                                         1.00000f,
 702                                         decoder_t::decode_obd2_response,
 703                                         nullptr,
 704                                         true,
 705                                         false
 706                                 })}
 707
 708                         } // end diagnostic_messages_ vector
 709                 })} // end message_set entry
 710         } // end message_set vector
 711 {
 712         for(std::shared_ptr<message_set_t> cms: message_set_)
 713         {
 714                 std::vector<std::shared_ptr<message_definition_t>> messages_definition = cms->get_messages_definition();
 715                 for(std::shared_ptr<message_definition_t> cmd : messages_definition)
 716                 {
 717                         cmd->set_parent(cms);
 718                         std::vector<std::shared_ptr<signal_t>> signals = cmd->get_signals();
 719                         for(std::shared_ptr<signal_t> sig: signals)
 720                         {
 721                                 sig->set_parent(cmd);
 722                         }
 723                 }
 724
 725                 std::vector<std::shared_ptr<diagnostic_message_t>> diagnostic_messages = cms->get_diagnostic_messages();
 726                 for(std::shared_ptr<diagnostic_message_t> dm : diagnostic_messages)
 727                 {
 728                         dm->set_parent(cms);
 729                 }
 730         }
 731                 }
 732
 733 const std::string application_t::get_diagnostic_bus() const
 734 {
 735         return "hs";
 736 }
 737
 738