low-can-binding/binding/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         , can_message_set_{
   8                 {std::make_shared<can_message_set_t>(can_message_set_t{0,"AGL Virtual Car",
   9                         { // beginning can_message_definition_ vector
  10                                 {std::make_shared<can_message_definition_t>(can_message_definition_t{
  11                                  "ls",
  12                                  0x30,
  13                                  false,
  14                                  can_message_format_t::EXTENDED,
  15                                  frequency_clock_t(5.00000f),
  16                                  true,
  17                                         { // beginning can_signals vector
  18                                                 {std::make_shared<can_signal_t> (can_signal_t{
  19                                                         "hvac.fan.speed",
  20                                                         32,
  21                                                         8,
  22                                                         23.5294f,
  23                                                         0.00000,
  24                                                         0,
  25                                                         0,
  26                                                         frequency_clock_t(0.00000f),
  27                                                         true,
  28                                                         false,
  29                                                         {
  30                                                         },
  31                                                         false,
  32                                                         nullptr,
  33                                                         nullptr,
  34                                                         false
  35                                                 })},
  36                                                 {std::make_shared<can_signal_t> (can_signal_t{
  37                                                         "hvac.temperature.left",
  38                                                         0,
  39                                                         8,
  40                                                         1.00000f,
  41                                                         0.00000,
  42                                                         0,
  43                                                         0,
  44                                                         frequency_clock_t(0.00000f),
  45                                                         true,
  46                                                         false,
  47                                                         {
  48                                                         },
  49                                                         true,
  50                                                         nullptr,
  51                                                         nullptr,
  52                                                         false
  53                                                 })},
  54                                                 {std::make_shared<can_signal_t> (can_signal_t{
  55                                                         "hvac.temperature.right",
  56                                                         8,
  57                                                         8,
  58                                                         1.00000f,
  59                                                         0.00000,
  60                                                         0,
  61                                                         0,
  62                                                         frequency_clock_t(0.00000f),
  63                                                         true,
  64                                                         false,
  65                                                         {
  66                                                         },
  67                                                         true,
  68                                                         nullptr,
  69                                                         nullptr,
  70                                                         false
  71                                                 })},
  72                                                 {std::make_shared<can_signal_t> (can_signal_t{
  73                                                         "hvac.temperature.average",
  74                                                         16,
  75                                                         8,
  76                                                         1.00000f,
  77                                                         0.00000,
  78                                                         0,
  79                                                         0,
  80                                                         frequency_clock_t(0.00000f),
  81                                                         true,
  82                                                         false,
  83                                                         {
  84                                                         },
  85                                                         true,
  86                                                         nullptr,
  87                                                         nullptr,
  88                                                         false
  89                                                 })}
  90                                         } // end can_signals vector
  91                                 })} // end can_message_definition entry
  92 ,                               {std::make_shared<can_message_definition_t>(can_message_definition_t{
  93                                  "hs",
  94                                  0x3D9,
  95                                  true,
  96                                  can_message_format_t::STANDARD,
  97                                  frequency_clock_t(5.00000f),
  98                                  true,
  99                                         { // beginning can_signals vector
 100                                                 {std::make_shared<can_signal_t> (can_signal_t{
 101                                                         "engine.speed",
 102                                                         16,
 103                                                         16,
 104                                                         0.250000f,
 105                                                         0.00000,
 106                                                         0,
 107                                                         0,
 108                                                         frequency_clock_t(0.00000f),
 109                                                         true,
 110                                                         false,
 111                                                         {
 112                                                         },
 113                                                         false,
 114                                                         nullptr,
 115                                                         nullptr,
 116                                                         false
 117                                                 })},
 118                                                 {std::make_shared<can_signal_t> (can_signal_t{
 119                                                         "fuel.level.low",
 120                                                         55,
 121                                                         1,
 122                                                         1.00000f,
 123                                                         0.00000,
 124                                                         0,
 125                                                         0,
 126                                                         frequency_clock_t(0.00000f),
 127                                                         true,
 128                                                         false,
 129                                                         {
 130                                                         },
 131                                                         false,
 132                                                         decoder_t::decode_boolean,
 133                                                         nullptr,
 134                                                         false
 135                                                 })},
 136                                                 {std::make_shared<can_signal_t> (can_signal_t{
 137                                                         "fuel.level",
 138                                                         8,
 139                                                         8,
 140                                                         0.392157f,
 141                                                         0.00000,
 142                                                         0,
 143                                                         0,
 144                                                         frequency_clock_t(0.00000f),
 145                                                         true,
 146                                                         false,
 147                                                         {
 148                                                         },
 149                                                         false,
 150                                                         nullptr,
 151                                                         nullptr,
 152                                                         false
 153                                                 })}
 154                                         } // end can_signals vector
 155                                 })} // end can_message_definition entry
 156 ,                               {std::make_shared<can_message_definition_t>(can_message_definition_t{
 157                                  "hs",
 158                                  0x3E9,
 159                                  false,
 160                                  can_message_format_t::EXTENDED,
 161                                  frequency_clock_t(5.00000f),
 162                                  true,
 163                                         { // beginning can_signals vector
 164                                                 {std::make_shared<can_signal_t> (can_signal_t{
 165                                                         "vehicle.average.speed",
 166                                                         0,
 167                                                         15,
 168                                                         0.0156250f,
 169                                                         0.00000,
 170                                                         0,
 171                                                         0,
 172                                                         frequency_clock_t(0.00000f),
 173                                                         true,
 174                                                         false,
 175                                                         {
 176                                                         },
 177                                                         false,
 178                                                         nullptr,
 179                                                         nullptr,
 180                                                         false
 181                                                 })}
 182                                         } // end can_signals vector
 183                                 })} // end can_message_definition entry
 184 ,                               {std::make_shared<can_message_definition_t>(can_message_definition_t{
 185                                  "hs",
 186                                  0x4D1,
 187                                  false,
 188                                  can_message_format_t::STANDARD,
 189                                  frequency_clock_t(5.00000f),
 190                                  true,
 191                                         { // beginning can_signals vector
 192                                                 {std::make_shared<can_signal_t> (can_signal_t{
 193                                                         "engine.oil.temp",
 194                                                         16,
 195                                                         8,
 196                                                         1.00000f,
 197                                                         0.00000,
 198                                                         0,
 199                                                         0,
 200                                                         frequency_clock_t(0.00000f),
 201                                                         true,
 202                                                         false,
 203                                                         {
 204                                                         },
 205                                                         false,
 206                                                         nullptr,
 207                                                         nullptr,
 208                                                         false
 209                                                 })},
 210                                                 {std::make_shared<can_signal_t> (can_signal_t{
 211                                                         "engine.oil.temp.high",
 212                                                         7,
 213                                                         1,
 214                                                         1.00000f,
 215                                                         0.00000,
 216                                                         0,
 217                                                         0,
 218                                                         frequency_clock_t(0.00000f),
 219                                                         true,
 220                                                         false,
 221                                                         {
 222                                                         },
 223                                                         false,
 224                                                         decoder_t::decode_boolean,
 225                                                         nullptr,
 226                                                         false
 227                                                 })}
 228                                         } // end can_signals vector
 229                                 })} // end can_message_definition entry
 230 ,                               {std::make_shared<can_message_definition_t>(can_message_definition_t{
 231                                  "hs",
 232                                  0x5D1,
 233                                  false,
 234                                  can_message_format_t::STANDARD,
 235                                  frequency_clock_t(5.00000f),
 236                                  true,
 237                                         { // beginning can_signals vector
 238                                                 {std::make_shared<can_signal_t> (can_signal_t{
 239                                                         "accelerator.pedal.position",
 240                                                         16,
 241                                                         8,
 242                                                         0.500000f,
 243                                                         0.00000,
 244                                                         0,
 245                                                         0,
 246                                                         frequency_clock_t(0.00000f),
 247                                                         true,
 248                                                         false,
 249                                                         {
 250                                                         },
 251                                                         false,
 252                                                         nullptr,
 253                                                         nullptr,
 254                                                         false
 255                                                 })},
 256                                                 {std::make_shared<can_signal_t> (can_signal_t{
 257                                                         "steering.wheel.angle",
 258                                                         4,
 259                                                         12,
 260                                                         1.00000f,
 261                                                         0.00000,
 262                                                         0,
 263                                                         0,
 264                                                         frequency_clock_t(0.00000f),
 265                                                         true,
 266                                                         false,
 267                                                         {
 268                                                         },
 269                                                         false,
 270                                                         nullptr,
 271                                                         nullptr,
 272                                                         false
 273                                                 })}
 274                                         } // end can_signals vector
 275                                 })} // end can_message_definition entry
 276 ,                               {std::make_shared<can_message_definition_t>(can_message_definition_t{
 277                                  "hs",
 278                                  0x5D2,
 279                                  false,
 280                                  can_message_format_t::STANDARD,
 281                                  frequency_clock_t(5.00000f),
 282                                  true,
 283                                         { // beginning can_signals vector
 284                                                 {std::make_shared<can_signal_t> (can_signal_t{
 285                                                         "transmission.gearinfo",
 286                                                         20,
 287                                                         4,
 288                                                         1.00000f,
 289                                                         0.00000,
 290                                                         0,
 291                                                         0,
 292                                                         frequency_clock_t(0.00000f),
 293                                                         true,
 294                                                         false,
 295                                                         {
 296                                                         },
 297                                                         false,
 298                                                         nullptr,
 299                                                         nullptr,
 300                                                         false
 301                                                 })},
 302                                                 {std::make_shared<can_signal_t> (can_signal_t{
 303                                                         "transmission.mode",
 304                                                         16,
 305                                                         4,
 306                                                         1.00000f,
 307                                                         0.00000,
 308                                                         0,
 309                                                         0,
 310                                                         frequency_clock_t(0.00000f),
 311                                                         true,
 312                                                         false,
 313                                                         {
 314                                                         },
 315                                                         false,
 316                                                         nullptr,
 317                                                         nullptr,
 318                                                         false
 319                                                 })}
 320                                         } // end can_signals vector
 321                                 })} // end can_message_definition entry
 322 ,                               {std::make_shared<can_message_definition_t>(can_message_definition_t{
 323                                  "hs",
 324                                  0x5D3,
 325                                  false,
 326                                  can_message_format_t::STANDARD,
 327                                  frequency_clock_t(5.00000f),
 328                                  true,
 329                                         { // beginning can_signals vector
 330                                                 {std::make_shared<can_signal_t> (can_signal_t{
 331                                                         "turnsignal.status",
 332                                                         26,
 333                                                         3,
 334                                                         1.00000f,
 335                                                         0.00000,
 336                                                         0,
 337                                                         0,
 338                                                         frequency_clock_t(0.00000f),
 339                                                         true,
 340                                                         false,
 341                                                         {
 342                                                         },
 343                                                         false,
 344                                                         nullptr,
 345                                                         nullptr,
 346                                                         false
 347                                                 })},
 348                                                 {std::make_shared<can_signal_t> (can_signal_t{
 349                                                         "lightstatus.brake",
 350                                                         7,
 351                                                         1,
 352                                                         1.00000f,
 353                                                         0.00000,
 354                                                         0,
 355                                                         0,
 356                                                         frequency_clock_t(0.00000f),
 357                                                         true,
 358                                                         false,
 359                                                         {
 360                                                         },
 361                                                         false,
 362                                                         decoder_t::decode_boolean,
 363                                                         nullptr,
 364                                                         false
 365                                                 })},
 366                                                 {std::make_shared<can_signal_t> (can_signal_t{
 367                                                         "parking.brake.status",
 368                                                         8,
 369                                                         1,
 370                                                         1.00000f,
 371                                                         0.00000,
 372                                                         0,
 373                                                         0,
 374                                                         frequency_clock_t(0.00000f),
 375                                                         true,
 376                                                         false,
 377                                                         {
 378                                                         },
 379                                                         false,
 380                                                         decoder_t::decode_boolean,
 381                                                         nullptr,
 382                                                         false
 383                                                 })}
 384                                         } // end can_signals vector
 385                                 })} // end can_message_definition entry
 386 ,                               {std::make_shared<can_message_definition_t>(can_message_definition_t{
 387                                  "hs",
 388                                  0x620,
 389                                  false,
 390                                  can_message_format_t::STANDARD,
 391                                  frequency_clock_t(5.00000f),
 392                                  true,
 393                                         { // beginning can_signals vector
 394                                                 {std::make_shared<can_signal_t> (can_signal_t{
 395                                                         "doors.boot.open",
 396                                                         47,
 397                                                         1,
 398                                                         1.00000f,
 399                                                         0.00000,
 400                                                         0,
 401                                                         0,
 402                                                         frequency_clock_t(0.00000f),
 403                                                         true,
 404                                                         false,
 405                                                         {
 406                                                         },
 407                                                         false,
 408                                                         decoder_t::decode_boolean,
 409                                                         nullptr,
 410                                                         false
 411                                                 })},
 412                                                 {std::make_shared<can_signal_t> (can_signal_t{
 413                                                         "doors.front_left.open",
 414                                                         43,
 415                                                         1,
 416                                                         1.00000f,
 417                                                         0.00000,
 418                                                         0,
 419                                                         0,
 420                                                         frequency_clock_t(0.00000f),
 421                                                         true,
 422                                                         false,
 423                                                         {
 424                                                         },
 425                                                         false,
 426                                                         decoder_t::decode_boolean,
 427                                                         nullptr,
 428                                                         false
 429                                                 })},
 430                                                 {std::make_shared<can_signal_t> (can_signal_t{
 431                                                         "doors.front_right.open",
 432                                                         44,
 433                                                         1,
 434                                                         1.00000f,
 435                                                         0.00000,
 436                                                         0,
 437                                                         0,
 438                                                         frequency_clock_t(0.00000f),
 439                                                         true,
 440                                                         false,
 441                                                         {
 442                                                         },
 443                                                         false,
 444                                                         decoder_t::decode_boolean,
 445                                                         nullptr,
 446                                                         false
 447                                                 })},
 448                                                 {std::make_shared<can_signal_t> (can_signal_t{
 449                                                         "doors.rear_left.open",
 450                                                         46,
 451                                                         1,
 452                                                         1.00000f,
 453                                                         0.00000,
 454                                                         0,
 455                                                         0,
 456                                                         frequency_clock_t(0.00000f),
 457                                                         true,
 458                                                         false,
 459                                                         {
 460                                                         },
 461                                                         false,
 462                                                         decoder_t::decode_boolean,
 463                                                         nullptr,
 464                                                         false
 465                                                 })},
 466                                                 {std::make_shared<can_signal_t> (can_signal_t{
 467                                                         "doors.rear_right.open",
 468                                                         45,
 469                                                         4,
 470                                                         1.00000f,
 471                                                         0.00000,
 472                                                         0,
 473                                                         0,
 474                                                         frequency_clock_t(0.00000f),
 475                                                         true,
 476                                                         false,
 477                                                         {
 478                                                         },
 479                                                         false,
 480                                                         decoder_t::decode_boolean,
 481                                                         nullptr,
 482                                                         false
 483                                                 })}
 484                                         } // end can_signals vector
 485                                 })} // end can_message_definition entry
 486 ,                               {std::make_shared<can_message_definition_t>(can_message_definition_t{
 487                                  "hs",
 488                                  0x799,
 489                                  false,
 490                                  can_message_format_t::STANDARD,
 491                                  frequency_clock_t(5.00000f),
 492                                  true,
 493                                         { // beginning can_signals vector
 494                                                 {std::make_shared<can_signal_t> (can_signal_t{
 495                                                         "windows.front_left.open",
 496                                                         43,
 497                                                         1,
 498                                                         1.00000f,
 499                                                         0.00000,
 500                                                         0,
 501                                                         0,
 502                                                         frequency_clock_t(0.00000f),
 503                                                         true,
 504                                                         false,
 505                                                         {
 506                                                         },
 507                                                         false,
 508                                                         decoder_t::decode_boolean,
 509                                                         nullptr,
 510                                                         false
 511                                                 })},
 512                                                 {std::make_shared<can_signal_t> (can_signal_t{
 513                                                         "windows.front_right.open",
 514                                                         44,
 515                                                         1,
 516                                                         1.00000f,
 517                                                         0.00000,
 518                                                         0,
 519                                                         0,
 520                                                         frequency_clock_t(0.00000f),
 521                                                         true,
 522                                                         false,
 523                                                         {
 524                                                         },
 525                                                         false,
 526                                                         decoder_t::decode_boolean,
 527                                                         nullptr,
 528                                                         false
 529                                                 })},
 530                                                 {std::make_shared<can_signal_t> (can_signal_t{
 531                                                         "windows.rear_left.open",
 532                                                         46,
 533                                                         1,
 534                                                         1.00000f,
 535                                                         0.00000,
 536                                                         0,
 537                                                         0,
 538                                                         frequency_clock_t(0.00000f),
 539                                                         true,
 540                                                         false,
 541                                                         {
 542                                                         },
 543                                                         false,
 544                                                         decoder_t::decode_boolean,
 545                                                         nullptr,
 546                                                         false
 547                                                 })},
 548                                                 {std::make_shared<can_signal_t> (can_signal_t{
 549                                                         "windows.rear_right.open",
 550                                                         45,
 551                                                         4,
 552                                                         1.00000f,
 553                                                         0.00000,
 554                                                         0,
 555                                                         0,
 556                                                         frequency_clock_t(0.00000f),
 557                                                         true,
 558                                                         false,
 559                                                         {
 560                                                         },
 561                                                         false,
 562                                                         decoder_t::decode_boolean,
 563                                                         nullptr,
 564                                                         false
 565                                                 })}
 566                                         } // end can_signals vector
 567                                 })} // end can_message_definition entry
 568
 569                 }, // end can_message_definition vector
 570                         { // beginning diagnostic_messages_ vector
 571                                 {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 572                                         4,
 573                                         "engine.load",
 574                                         0,
 575                                         0,
 576                                         UNIT::INVALID,
 577                                         5.00000f,
 578                                         decoder_t::decode_obd2_response,
 579                                         nullptr,
 580                                         true,
 581                                         false
 582                                 })}
 583 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 584                                         5,
 585                                         "engine.coolant.temperature",
 586                                         0,
 587                                         0,
 588                                         UNIT::INVALID,
 589                                         1.00000f,
 590                                         decoder_t::decode_obd2_response,
 591                                         nullptr,
 592                                         true,
 593                                         false
 594                                 })}
 595 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 596                                         10,
 597                                         "fuel.pressure",
 598                                         0,
 599                                         0,
 600                                         UNIT::INVALID,
 601                                         1.00000f,
 602                                         decoder_t::decode_obd2_response,
 603                                         nullptr,
 604                                         true,
 605                                         false
 606                                 })}
 607 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 608                                         11,
 609                                         "intake.manifold.pressure",
 610                                         0,
 611                                         0,
 612                                         UNIT::INVALID,
 613                                         1.00000f,
 614                                         decoder_t::decode_obd2_response,
 615                                         nullptr,
 616                                         true,
 617                                         false
 618                                 })}
 619 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 620                                         12,
 621                                         "engine.speed",
 622                                         0,
 623                                         0,
 624                                         UNIT::INVALID,
 625                                         5.00000f,
 626                                         decoder_t::decode_obd2_response,
 627                                         nullptr,
 628                                         true,
 629                                         false
 630                                 })}
 631 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 632                                         13,
 633                                         "vehicle.speed",
 634                                         0,
 635                                         0,
 636                                         UNIT::INVALID,
 637                                         5.00000f,
 638                                         decoder_t::decode_obd2_response,
 639                                         nullptr,
 640                                         true,
 641                                         false
 642                                 })}
 643 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 644                                         15,
 645                                         "intake.air.temperature",
 646                                         0,
 647                                         0,
 648                                         UNIT::INVALID,
 649                                         1.00000f,
 650                                         decoder_t::decode_obd2_response,
 651                                         nullptr,
 652                                         true,
 653                                         false
 654                                 })}
 655 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 656                                         16,
 657                                         "mass.airflow",
 658                                         0,
 659                                         0,
 660                                         UNIT::INVALID,
 661                                         5.00000f,
 662                                         decoder_t::decode_obd2_response,
 663                                         nullptr,
 664                                         true,
 665                                         false
 666                                 })}
 667 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 668                                         17,
 669                                         "throttle.position",
 670                                         0,
 671                                         0,
 672                                         UNIT::INVALID,
 673                                         5.00000f,
 674                                         decoder_t::decode_obd2_response,
 675                                         nullptr,
 676                                         true,
 677                                         false
 678                                 })}
 679 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 680                                         31,
 681                                         "running.time",
 682                                         0,
 683                                         0,
 684                                         UNIT::INVALID,
 685                                         1.00000f,
 686                                         decoder_t::decode_obd2_response,
 687                                         nullptr,
 688                                         true,
 689                                         false
 690                                 })}
 691 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 692                                         45,
 693                                         "EGR.error",
 694                                         0,
 695                                         0,
 696                                         UNIT::INVALID,
 697                                         0.00000f,
 698                                         decoder_t::decode_obd2_response,
 699                                         nullptr,
 700                                         true,
 701                                         false
 702                                 })}
 703 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 704                                         47,
 705                                         "fuel.level",
 706                                         0,
 707                                         0,
 708                                         UNIT::INVALID,
 709                                         1.00000f,
 710                                         decoder_t::decode_obd2_response,
 711                                         nullptr,
 712                                         true,
 713                                         false
 714                                 })}
 715 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 716                                         51,
 717                                         "barometric.pressure",
 718                                         0,
 719                                         0,
 720                                         UNIT::INVALID,
 721                                         1.00000f,
 722                                         decoder_t::decode_obd2_response,
 723                                         nullptr,
 724                                         true,
 725                                         false
 726                                 })}
 727 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 728                                         70,
 729                                         "ambient.air.temperature",
 730                                         0,
 731                                         0,
 732                                         UNIT::INVALID,
 733                                         1.00000f,
 734                                         decoder_t::decode_obd2_response,
 735                                         nullptr,
 736                                         true,
 737                                         false
 738                                 })}
 739 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 740                                         76,
 741                                         "commanded.throttle.position",
 742                                         0,
 743                                         0,
 744                                         UNIT::INVALID,
 745                                         1.00000f,
 746                                         decoder_t::decode_obd2_response,
 747                                         nullptr,
 748                                         true,
 749                                         false
 750                                 })}
 751 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 752                                         82,
 753                                         "ethanol.fuel.percentage",
 754                                         0,
 755                                         0,
 756                                         UNIT::INVALID,
 757                                         1.00000f,
 758                                         decoder_t::decode_obd2_response,
 759                                         nullptr,
 760                                         true,
 761                                         false
 762                                 })}
 763 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 764                                         90,
 765                                         "accelerator.pedal.position",
 766                                         0,
 767                                         0,
 768                                         UNIT::INVALID,
 769                                         5.00000f,
 770                                         decoder_t::decode_obd2_response,
 771                                         nullptr,
 772                                         true,
 773                                         false
 774                                 })}
 775 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 776                                         91,
 777                                         "hybrid.battery-pack.remaining.life",
 778                                         0,
 779                                         0,
 780                                         UNIT::INVALID,
 781                                         5.00000f,
 782                                         decoder_t::decode_obd2_response,
 783                                         nullptr,
 784                                         true,
 785                                         false
 786                                 })}
 787 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 788                                         92,
 789                                         "engine.oil.temperature",
 790                                         0,
 791                                         0,
 792                                         UNIT::INVALID,
 793                                         1.00000f,
 794                                         decoder_t::decode_obd2_response,
 795                                         nullptr,
 796                                         true,
 797                                         false
 798                                 })}
 799 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 800                                         94,
 801                                         "engine.fuel.rate",
 802                                         0,
 803                                         0,
 804                                         UNIT::INVALID,
 805                                         1.00000f,
 806                                         decoder_t::decode_obd2_response,
 807                                         nullptr,
 808                                         true,
 809                                         false
 810                                 })}
 811 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 812                                         99,
 813                                         "engine.torque",
 814                                         0,
 815                                         0,
 816                                         UNIT::INVALID,
 817                                         1.00000f,
 818                                         decoder_t::decode_obd2_response,
 819                                         nullptr,
 820                                         true,
 821                                         false
 822                                 })}
 823
 824                         } // end diagnostic_messages_ vector
 825                 })} // end can_message_set entry
 826         } // end can_message_set vector
 827 {
 828         for(auto& cms: can_message_set_)
 829         {
 830                 std::vector<std::shared_ptr<can_message_definition_t> >& can_messages_definition = cms->get_can_message_definition();
 831                 for(auto& cmd : can_messages_definition)
 832                 {
 833                         cmd->set_parent(cms.get());
 834                         std::vector<std::shared_ptr<can_signal_t> >& can_signals = cmd->get_can_signals();
 835                         for(auto& sig: can_signals)
 836                         {
 837                                 sig->set_parent(cmd.get());
 838                         }
 839                 }
 840
 841                 std::vector<std::shared_ptr<diagnostic_message_t> >& diagnostic_messages = cms->get_diagnostic_messages();
 842                 for(auto& dm : diagnostic_messages)
 843                 {
 844                         dm->set_parent(cms);
 845                 }
 846         }
 847                 }
 848
 849 const std::string application_t::get_diagnostic_bus() const
 850 {
 851         return "hs";
 852 }
 853
 854