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