examples/toyota/auris/auris-signals.cpp

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