plugins/default-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("agl-virtual-car");
   7
   8 std::shared_ptr<message_set_t> cms = std::make_shared<message_set_t>(message_set_t{0,"AGL Virtual Car",
   9         { // beginning message_definition_ vector
  10                 {std::make_shared<message_definition_t>(message_definition_t{"ls",0x21,"",8,0,frequency_clock_t(5.00000f),true,
  11                         { // beginning signals vector
  12                                 {std::make_shared<signal_t> (signal_t{
  13                                         "steering_wheel.cruise.cancel",// generic_name
  14                                         52,// bit_position
  15                                         1,// bit_size
  16                                         1.00000f,// 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                                         decoder_t::decode_boolean,// 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                                         "steering_wheel.cruise.distance",// 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                                         "steering_wheel.cruise.enable",// generic_name
  58                                         48,// bit_position
  59                                         1,// bit_size
  60                                         1.00000f,// factor
  61                                         0.00000f,// offset
  62                                         0,// min_value
  63                                         0,// max_value
  64                                         frequency_clock_t(0.00000f),// frequency
  65                                         true,// send_same
  66                                         false,// force_send_changed
  67                                         {
  68                                         },// states
  69                                         false,// writable
  70                                         decoder_t::decode_boolean,// 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                                 {std::make_shared<signal_t> (signal_t{
  79                                         "steering_wheel.cruise.limit",// generic_name
  80                                         54,// bit_position
  81                                         1,// bit_size
  82                                         1.00000f,// factor
  83                                         0.00000f,// offset
  84                                         0,// min_value
  85                                         0,// max_value
  86                                         frequency_clock_t(0.00000f),// frequency
  87                                         true,// send_same
  88                                         false,// force_send_changed
  89                                         {
  90                                         },// states
  91                                         false,// writable
  92                                         decoder_t::decode_boolean,// decoder
  93                                         nullptr,// encoder
  94                                         false,// received
  95                                         std::make_pair<bool, int>(false, 0),// multiplex
  96                                         static_cast<sign_t>(0),// signed
  97                                         -1,// bit_sign_position
  98                                         ""// unit
  99                                 })},
 100                                 {std::make_shared<signal_t> (signal_t{
 101                                         "steering_wheel.cruise.resume",// generic_name
 102                                         49,// bit_position
 103                                         1,// bit_size
 104                                         1.00000f,// factor
 105                                         0.00000f,// offset
 106                                         0,// min_value
 107                                         0,// max_value
 108                                         frequency_clock_t(0.00000f),// frequency
 109                                         true,// send_same
 110                                         false,// force_send_changed
 111                                         {
 112                                         },// states
 113                                         false,// writable
 114                                         decoder_t::decode_boolean,// decoder
 115                                         nullptr,// encoder
 116                                         false,// received
 117                                         std::make_pair<bool, int>(false, 0),// multiplex
 118                                         static_cast<sign_t>(0),// signed
 119                                         -1,// bit_sign_position
 120                                         ""// unit
 121                                 })},
 122                                 {std::make_shared<signal_t> (signal_t{
 123                                         "steering_wheel.cruise.set",// generic_name
 124                                         51,// bit_position
 125                                         1,// bit_size
 126                                         1.00000f,// factor
 127                                         0.00000f,// offset
 128                                         0,// min_value
 129                                         0,// max_value
 130                                         frequency_clock_t(0.00000f),// frequency
 131                                         true,// send_same
 132                                         false,// force_send_changed
 133                                         {
 134                                         },// states
 135                                         false,// writable
 136                                         decoder_t::decode_boolean,// decoder
 137                                         nullptr,// encoder
 138                                         false,// received
 139                                         std::make_pair<bool, int>(false, 0),// multiplex
 140                                         static_cast<sign_t>(0),// signed
 141                                         -1,// bit_sign_position
 142                                         ""// unit
 143                                 })},
 144                                 {std::make_shared<signal_t> (signal_t{
 145                                         "steering_wheel.horn",// generic_name
 146                                         56,// bit_position
 147                                         1,// bit_size
 148                                         1.00000f,// factor
 149                                         0.00000f,// offset
 150                                         0,// min_value
 151                                         0,// max_value
 152                                         frequency_clock_t(0.00000f),// frequency
 153                                         true,// send_same
 154                                         false,// force_send_changed
 155                                         {
 156                                         },// states
 157                                         false,// writable
 158                                         decoder_t::decode_boolean,// decoder
 159                                         nullptr,// encoder
 160                                         false,// received
 161                                         std::make_pair<bool, int>(false, 0),// multiplex
 162                                         static_cast<sign_t>(0),// signed
 163                                         -1,// bit_sign_position
 164                                         ""// unit
 165                                 })},
 166                                 {std::make_shared<signal_t> (signal_t{
 167                                         "steering_wheel.info",// generic_name
 168                                         38,// bit_position
 169                                         1,// bit_size
 170                                         1.00000f,// factor
 171                                         0.00000f,// offset
 172                                         0,// min_value
 173                                         0,// max_value
 174                                         frequency_clock_t(0.00000f),// frequency
 175                                         true,// send_same
 176                                         false,// force_send_changed
 177                                         {
 178                                         },// states
 179                                         false,// writable
 180                                         decoder_t::decode_boolean,// decoder
 181                                         nullptr,// encoder
 182                                         false,// received
 183                                         std::make_pair<bool, int>(false, 0),// multiplex
 184                                         static_cast<sign_t>(0),// signed
 185                                         -1,// bit_sign_position
 186                                         ""// unit
 187                                 })},
 188                                 {std::make_shared<signal_t> (signal_t{
 189                                         "steering_wheel.lane_departure_warning",// generic_name
 190                                         63,// bit_position
 191                                         1,// bit_size
 192                                         1.00000f,// factor
 193                                         0.00000f,// offset
 194                                         0,// min_value
 195                                         0,// max_value
 196                                         frequency_clock_t(0.00000f),// frequency
 197                                         true,// send_same
 198                                         false,// force_send_changed
 199                                         {
 200                                         },// states
 201                                         false,// writable
 202                                         decoder_t::decode_boolean,// decoder
 203                                         nullptr,// encoder
 204                                         false,// received
 205                                         std::make_pair<bool, int>(false, 0),// multiplex
 206                                         static_cast<sign_t>(0),// signed
 207                                         -1,// bit_sign_position
 208                                         ""// unit
 209                                 })},
 210                                 {std::make_shared<signal_t> (signal_t{
 211                                         "steering_wheel.mode",// generic_name
 212                                         34,// bit_position
 213                                         1,// bit_size
 214                                         1.00000f,// factor
 215                                         0.00000f,// offset
 216                                         0,// min_value
 217                                         0,// max_value
 218                                         frequency_clock_t(0.00000f),// frequency
 219                                         true,// send_same
 220                                         false,// force_send_changed
 221                                         {
 222                                         },// states
 223                                         false,// writable
 224                                         decoder_t::decode_boolean,// decoder
 225                                         nullptr,// encoder
 226                                         false,// received
 227                                         std::make_pair<bool, int>(false, 0),// multiplex
 228                                         static_cast<sign_t>(0),// signed
 229                                         -1,// bit_sign_position
 230                                         ""// unit
 231                                 })},
 232                                 {std::make_shared<signal_t> (signal_t{
 233                                         "steering_wheel.next",// generic_name
 234                                         36,// bit_position
 235                                         1,// bit_size
 236                                         1.00000f,// factor
 237                                         0.00000f,// offset
 238                                         0,// min_value
 239                                         0,// max_value
 240                                         frequency_clock_t(0.00000f),// frequency
 241                                         true,// send_same
 242                                         false,// force_send_changed
 243                                         {
 244                                         },// states
 245                                         false,// writable
 246                                         decoder_t::decode_boolean,// decoder
 247                                         nullptr,// encoder
 248                                         false,// received
 249                                         std::make_pair<bool, int>(false, 0),// multiplex
 250                                         static_cast<sign_t>(0),// signed
 251                                         -1,// bit_sign_position
 252                                         ""// unit
 253                                 })},
 254                                 {std::make_shared<signal_t> (signal_t{
 255                                         "steering_wheel.phone.call",// generic_name
 256                                         47,// bit_position
 257                                         1,// 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                                         static_cast<sign_t>(0),// signed
 273                                         -1,// bit_sign_position
 274                                         ""// unit
 275                                 })},
 276                                 {std::make_shared<signal_t> (signal_t{
 277                                         "steering_wheel.phone.hangup",// generic_name
 278                                         46,// bit_position
 279                                         1,// bit_size
 280                                         1.00000f,// factor
 281                                         0.00000f,// offset
 282                                         0,// min_value
 283                                         0,// max_value
 284                                         frequency_clock_t(0.00000f),// frequency
 285                                         true,// send_same
 286                                         false,// force_send_changed
 287                                         {
 288                                         },// states
 289                                         false,// writable
 290                                         decoder_t::decode_boolean,// decoder
 291                                         nullptr,// encoder
 292                                         false,// received
 293                                         std::make_pair<bool, int>(false, 0),// multiplex
 294                                         static_cast<sign_t>(0),// signed
 295                                         -1,// bit_sign_position
 296                                         ""// unit
 297                                 })},
 298                                 {std::make_shared<signal_t> (signal_t{
 299                                         "steering_wheel.previous",// generic_name
 300                                         32,// bit_position
 301                                         1,// bit_size
 302                                         1.00000f,// factor
 303                                         0.00000f,// offset
 304                                         0,// min_value
 305                                         0,// max_value
 306                                         frequency_clock_t(0.00000f),// frequency
 307                                         true,// send_same
 308                                         false,// force_send_changed
 309                                         {
 310                                         },// states
 311                                         false,// writable
 312                                         decoder_t::decode_boolean,// decoder
 313                                         nullptr,// encoder
 314                                         false,// received
 315                                         std::make_pair<bool, int>(false, 0),// multiplex
 316                                         static_cast<sign_t>(0),// signed
 317                                         -1,// bit_sign_position
 318                                         ""// unit
 319                                 })},
 320                                 {std::make_shared<signal_t> (signal_t{
 321                                         "steering_wheel.voice",// generic_name
 322                                         45,// bit_position
 323                                         1,// bit_size
 324                                         1.00000f,// factor
 325                                         0.00000f,// offset
 326                                         0,// min_value
 327                                         0,// max_value
 328                                         frequency_clock_t(0.00000f),// frequency
 329                                         true,// send_same
 330                                         false,// force_send_changed
 331                                         {
 332                                         },// states
 333                                         false,// writable
 334                                         decoder_t::decode_boolean,// decoder
 335                                         nullptr,// encoder
 336                                         false,// received
 337                                         std::make_pair<bool, int>(false, 0),// multiplex
 338                                         static_cast<sign_t>(0),// signed
 339                                         -1,// bit_sign_position
 340                                         ""// unit
 341                                 })},
 342                                 {std::make_shared<signal_t> (signal_t{
 343                                         "steering_wheel.volume.down",// generic_name
 344                                         35,// bit_position
 345                                         1,// bit_size
 346                                         1.00000f,// factor
 347                                         0.00000f,// offset
 348                                         0,// min_value
 349                                         0,// max_value
 350                                         frequency_clock_t(0.00000f),// frequency
 351                                         true,// send_same
 352                                         false,// force_send_changed
 353                                         {
 354                                         },// states
 355                                         false,// writable
 356                                         decoder_t::decode_boolean,// decoder
 357                                         nullptr,// encoder
 358                                         false,// received
 359                                         std::make_pair<bool, int>(false, 0),// multiplex
 360                                         static_cast<sign_t>(0),// signed
 361                                         -1,// bit_sign_position
 362                                         ""// unit
 363                                 })},
 364                                 {std::make_shared<signal_t> (signal_t{
 365                                         "steering_wheel.volume.mute",// generic_name
 366                                         39,// bit_position
 367                                         1,// bit_size
 368                                         1.00000f,// factor
 369                                         0.00000f,// offset
 370                                         0,// min_value
 371                                         0,// max_value
 372                                         frequency_clock_t(0.00000f),// frequency
 373                                         true,// send_same
 374                                         false,// force_send_changed
 375                                         {
 376                                         },// states
 377                                         false,// writable
 378                                         decoder_t::decode_boolean,// decoder
 379                                         nullptr,// encoder
 380                                         false,// received
 381                                         std::make_pair<bool, int>(false, 0),// multiplex
 382                                         static_cast<sign_t>(0),// signed
 383                                         -1,// bit_sign_position
 384                                         ""// unit
 385                                 })},
 386                                 {std::make_shared<signal_t> (signal_t{
 387                                         "steering_wheel.volume.up",// generic_name
 388                                         33,// bit_position
 389                                         1,// bit_size
 390                                         1.00000f,// factor
 391                                         0.00000f,// offset
 392                                         0,// min_value
 393                                         0,// max_value
 394                                         frequency_clock_t(0.00000f),// frequency
 395                                         true,// send_same
 396                                         false,// force_send_changed
 397                                         {
 398                                         },// states
 399                                         false,// writable
 400                                         decoder_t::decode_boolean,// decoder
 401                                         nullptr,// encoder
 402                                         false,// received
 403                                         std::make_pair<bool, int>(false, 0),// multiplex
 404                                         static_cast<sign_t>(0),// signed
 405                                         -1,// bit_sign_position
 406                                         ""// unit
 407                                 })}
 408                         } // end signals vector
 409                 })} // end message_definition entry
 410 ,               {std::make_shared<message_definition_t>(message_definition_t{"ls",0x30,"",8,0,frequency_clock_t(5.00000f),true,
 411                         { // beginning signals vector
 412                                 {std::make_shared<signal_t> (signal_t{
 413                                         "hvac.fan.speed",// generic_name
 414                                         32,// bit_position
 415                                         8,// bit_size
 416                                         23.5294f,// factor
 417                                         0.00000f,// offset
 418                                         0,// min_value
 419                                         0,// max_value
 420                                         frequency_clock_t(0.00000f),// frequency
 421                                         true,// send_same
 422                                         false,// force_send_changed
 423                                         {
 424                                         },// states
 425                                         true,// writable
 426                                         nullptr,// decoder
 427                                         nullptr,// encoder
 428                                         false,// received
 429                                         std::make_pair<bool, int>(false, 0),// multiplex
 430                                         static_cast<sign_t>(0),// signed
 431                                         -1,// bit_sign_position
 432                                         ""// unit
 433                                 })},
 434                                 {std::make_shared<signal_t> (signal_t{
 435                                         "hvac.temperature.left",// generic_name
 436                                         0,// bit_position
 437                                         8,// bit_size
 438                                         1.00000f,// factor
 439                                         0.00000f,// offset
 440                                         0,// min_value
 441                                         0,// max_value
 442                                         frequency_clock_t(0.00000f),// frequency
 443                                         true,// send_same
 444                                         false,// force_send_changed
 445                                         {
 446                                         },// states
 447                                         true,// writable
 448                                         nullptr,// decoder
 449                                         nullptr,// encoder
 450                                         false,// received
 451                                         std::make_pair<bool, int>(false, 0),// multiplex
 452                                         static_cast<sign_t>(0),// signed
 453                                         -1,// bit_sign_position
 454                                         ""// unit
 455                                 })},
 456                                 {std::make_shared<signal_t> (signal_t{
 457                                         "hvac.temperature.right",// generic_name
 458                                         8,// bit_position
 459                                         8,// bit_size
 460                                         1.00000f,// factor
 461                                         0.00000f,// offset
 462                                         0,// min_value
 463                                         0,// max_value
 464                                         frequency_clock_t(0.00000f),// frequency
 465                                         true,// send_same
 466                                         false,// force_send_changed
 467                                         {
 468                                         },// states
 469                                         true,// writable
 470                                         nullptr,// decoder
 471                                         nullptr,// encoder
 472                                         false,// received
 473                                         std::make_pair<bool, int>(false, 0),// multiplex
 474                                         static_cast<sign_t>(0),// signed
 475                                         -1,// bit_sign_position
 476                                         ""// unit
 477                                 })},
 478                                 {std::make_shared<signal_t> (signal_t{
 479                                         "hvac.temperature.average",// generic_name
 480                                         16,// bit_position
 481                                         8,// bit_size
 482                                         1.00000f,// factor
 483                                         0.00000f,// offset
 484                                         0,// min_value
 485                                         0,// max_value
 486                                         frequency_clock_t(0.00000f),// frequency
 487                                         true,// send_same
 488                                         false,// force_send_changed
 489                                         {
 490                                         },// states
 491                                         true,// writable
 492                                         nullptr,// decoder
 493                                         nullptr,// encoder
 494                                         false,// received
 495                                         std::make_pair<bool, int>(false, 0),// multiplex
 496                                         static_cast<sign_t>(0),// signed
 497                                         -1,// bit_sign_position
 498                                         ""// unit
 499                                 })}
 500                         } // end signals vector
 501                 })} // end message_definition entry
 502 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x3D9,"",8,0,frequency_clock_t(5.00000f),true,
 503                         { // beginning signals vector
 504                                 {std::make_shared<signal_t> (signal_t{
 505                                         "engine.speed",// generic_name
 506                                         16,// bit_position
 507                                         16,// bit_size
 508                                         0.250000f,// factor
 509                                         0.00000f,// offset
 510                                         0,// min_value
 511                                         0,// max_value
 512                                         frequency_clock_t(0.00000f),// frequency
 513                                         true,// send_same
 514                                         false,// force_send_changed
 515                                         {
 516                                         },// states
 517                                         true,// writable
 518                                         nullptr,// decoder
 519                                         nullptr,// encoder
 520                                         false,// received
 521                                         std::make_pair<bool, int>(false, 0),// multiplex
 522                                         static_cast<sign_t>(0),// signed
 523                                         -1,// bit_sign_position
 524                                         ""// unit
 525                                 })},
 526                                 {std::make_shared<signal_t> (signal_t{
 527                                         "fuel.level.low",// generic_name
 528                                         55,// bit_position
 529                                         1,// bit_size
 530                                         1.00000f,// factor
 531                                         0.00000f,// offset
 532                                         0,// min_value
 533                                         0,// max_value
 534                                         frequency_clock_t(0.00000f),// frequency
 535                                         true,// send_same
 536                                         false,// force_send_changed
 537                                         {
 538                                         },// states
 539                                         true,// writable
 540                                         decoder_t::decode_boolean,// decoder
 541                                         nullptr,// encoder
 542                                         false,// received
 543                                         std::make_pair<bool, int>(false, 0),// multiplex
 544                                         static_cast<sign_t>(0),// signed
 545                                         -1,// bit_sign_position
 546                                         ""// unit
 547                                 })},
 548                                 {std::make_shared<signal_t> (signal_t{
 549                                         "fuel.level",// generic_name
 550                                         8,// bit_position
 551                                         8,// bit_size
 552                                         0.392157f,// factor
 553                                         0.00000f,// offset
 554                                         0,// min_value
 555                                         0,// max_value
 556                                         frequency_clock_t(0.00000f),// frequency
 557                                         true,// send_same
 558                                         false,// force_send_changed
 559                                         {
 560                                         },// states
 561                                         true,// writable
 562                                         nullptr,// decoder
 563                                         nullptr,// encoder
 564                                         false,// received
 565                                         std::make_pair<bool, int>(false, 0),// multiplex
 566                                         static_cast<sign_t>(0),// signed
 567                                         -1,// bit_sign_position
 568                                         ""// unit
 569                                 })}
 570                         } // end signals vector
 571                 })} // end message_definition entry
 572 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x3E9,"",8,0,frequency_clock_t(5.00000f),true,
 573                         { // beginning signals vector
 574                                 {std::make_shared<signal_t> (signal_t{
 575                                         "vehicle.average.speed",// generic_name
 576                                         0,// bit_position
 577                                         15,// bit_size
 578                                         0.0156250f,// factor
 579                                         0.00000f,// offset
 580                                         0,// min_value
 581                                         0,// max_value
 582                                         frequency_clock_t(0.00000f),// frequency
 583                                         true,// send_same
 584                                         false,// force_send_changed
 585                                         {
 586                                         },// states
 587                                         false,// writable
 588                                         nullptr,// decoder
 589                                         nullptr,// encoder
 590                                         false,// received
 591                                         std::make_pair<bool, int>(false, 0),// multiplex
 592                                         static_cast<sign_t>(0),// signed
 593                                         -1,// bit_sign_position
 594                                         ""// unit
 595                                 })}
 596                         } // end signals vector
 597                 })} // end message_definition entry
 598 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x4D1,"",8,0,frequency_clock_t(5.00000f),true,
 599                         { // beginning signals vector
 600                                 {std::make_shared<signal_t> (signal_t{
 601                                         "engine.oil.temp",// generic_name
 602                                         16,// bit_position
 603                                         8,// bit_size
 604                                         1.00000f,// factor
 605                                         0.00000f,// offset
 606                                         0,// min_value
 607                                         0,// max_value
 608                                         frequency_clock_t(0.00000f),// frequency
 609                                         true,// send_same
 610                                         false,// force_send_changed
 611                                         {
 612                                         },// states
 613                                         true,// writable
 614                                         nullptr,// decoder
 615                                         nullptr,// encoder
 616                                         false,// received
 617                                         std::make_pair<bool, int>(false, 0),// multiplex
 618                                         static_cast<sign_t>(0),// signed
 619                                         -1,// bit_sign_position
 620                                         ""// unit
 621                                 })},
 622                                 {std::make_shared<signal_t> (signal_t{
 623                                         "engine.oil.temp.high",// generic_name
 624                                         7,// bit_position
 625                                         1,// bit_size
 626                                         1.00000f,// factor
 627                                         0.00000f,// offset
 628                                         0,// min_value
 629                                         0,// max_value
 630                                         frequency_clock_t(0.00000f),// frequency
 631                                         true,// send_same
 632                                         false,// force_send_changed
 633                                         {
 634                                         },// states
 635                                         true,// writable
 636                                         decoder_t::decode_boolean,// decoder
 637                                         nullptr,// encoder
 638                                         false,// received
 639                                         std::make_pair<bool, int>(false, 0),// multiplex
 640                                         static_cast<sign_t>(0),// signed
 641                                         -1,// bit_sign_position
 642                                         ""// unit
 643                                 })}
 644                         } // end signals vector
 645                 })} // end message_definition entry
 646 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x620,"",8,0,frequency_clock_t(5.00000f),true,
 647                         { // beginning signals vector
 648                                 {std::make_shared<signal_t> (signal_t{
 649                                         "doors.boot.open",// generic_name
 650                                         47,// bit_position
 651                                         1,// bit_size
 652                                         1.00000f,// factor
 653                                         0.00000f,// offset
 654                                         0,// min_value
 655                                         0,// max_value
 656                                         frequency_clock_t(0.00000f),// frequency
 657                                         true,// send_same
 658                                         false,// force_send_changed
 659                                         {
 660                                         },// states
 661                                         true,// writable
 662                                         decoder_t::decode_boolean,// decoder
 663                                         nullptr,// encoder
 664                                         false,// received
 665                                         std::make_pair<bool, int>(false, 0),// multiplex
 666                                         static_cast<sign_t>(0),// signed
 667                                         -1,// bit_sign_position
 668                                         ""// unit
 669                                 })},
 670                                 {std::make_shared<signal_t> (signal_t{
 671                                         "doors.front_left.open",// generic_name
 672                                         43,// bit_position
 673                                         1,// bit_size
 674                                         1.00000f,// factor
 675                                         0.00000f,// offset
 676                                         0,// min_value
 677                                         0,// max_value
 678                                         frequency_clock_t(0.00000f),// frequency
 679                                         true,// send_same
 680                                         false,// force_send_changed
 681                                         {
 682                                         },// states
 683                                         true,// writable
 684                                         decoder_t::decode_boolean,// decoder
 685                                         nullptr,// encoder
 686                                         false,// received
 687                                         std::make_pair<bool, int>(false, 0),// multiplex
 688                                         static_cast<sign_t>(0),// signed
 689                                         -1,// bit_sign_position
 690                                         ""// unit
 691                                 })},
 692                                 {std::make_shared<signal_t> (signal_t{
 693                                         "doors.front_right.open",// generic_name
 694                                         44,// bit_position
 695                                         1,// bit_size
 696                                         1.00000f,// factor
 697                                         0.00000f,// offset
 698                                         0,// min_value
 699                                         0,// max_value
 700                                         frequency_clock_t(0.00000f),// frequency
 701                                         true,// send_same
 702                                         false,// force_send_changed
 703                                         {
 704                                         },// states
 705                                         true,// writable
 706                                         decoder_t::decode_boolean,// decoder
 707                                         nullptr,// encoder
 708                                         false,// received
 709                                         std::make_pair<bool, int>(false, 0),// multiplex
 710                                         static_cast<sign_t>(0),// signed
 711                                         -1,// bit_sign_position
 712                                         ""// unit
 713                                 })},
 714                                 {std::make_shared<signal_t> (signal_t{
 715                                         "doors.rear_left.open",// generic_name
 716                                         46,// bit_position
 717                                         1,// bit_size
 718                                         1.00000f,// factor
 719                                         0.00000f,// offset
 720                                         0,// min_value
 721                                         0,// max_value
 722                                         frequency_clock_t(0.00000f),// frequency
 723                                         true,// send_same
 724                                         false,// force_send_changed
 725                                         {
 726                                         },// states
 727                                         true,// writable
 728                                         decoder_t::decode_boolean,// decoder
 729                                         nullptr,// encoder
 730                                         false,// received
 731                                         std::make_pair<bool, int>(false, 0),// multiplex
 732                                         static_cast<sign_t>(0),// signed
 733                                         -1,// bit_sign_position
 734                                         ""// unit
 735                                 })},
 736                                 {std::make_shared<signal_t> (signal_t{
 737                                         "doors.rear_right.open",// generic_name
 738                                         45,// bit_position
 739                                         4,// bit_size
 740                                         1.00000f,// factor
 741                                         0.00000f,// offset
 742                                         0,// min_value
 743                                         0,// max_value
 744                                         frequency_clock_t(0.00000f),// frequency
 745                                         true,// send_same
 746                                         false,// force_send_changed
 747                                         {
 748                                         },// states
 749                                         true,// writable
 750                                         decoder_t::decode_boolean,// decoder
 751                                         nullptr,// encoder
 752                                         false,// received
 753                                         std::make_pair<bool, int>(false, 0),// multiplex
 754                                         static_cast<sign_t>(0),// signed
 755                                         -1,// bit_sign_position
 756                                         ""// unit
 757                                 })}
 758                         } // end signals vector
 759                 })} // end message_definition entry
 760 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x799,"",8,0,frequency_clock_t(5.00000f),true,
 761                         { // beginning signals vector
 762                                 {std::make_shared<signal_t> (signal_t{
 763                                         "windows.front_left.open",// generic_name
 764                                         43,// bit_position
 765                                         1,// bit_size
 766                                         1.00000f,// factor
 767                                         0.00000f,// offset
 768                                         0,// min_value
 769                                         0,// max_value
 770                                         frequency_clock_t(0.00000f),// frequency
 771                                         true,// send_same
 772                                         false,// force_send_changed
 773                                         {
 774                                         },// states
 775                                         true,// writable
 776                                         decoder_t::decode_boolean,// decoder
 777                                         nullptr,// encoder
 778                                         false,// received
 779                                         std::make_pair<bool, int>(false, 0),// multiplex
 780                                         static_cast<sign_t>(0),// signed
 781                                         -1,// bit_sign_position
 782                                         ""// unit
 783                                 })},
 784                                 {std::make_shared<signal_t> (signal_t{
 785                                         "windows.front_right.open",// generic_name
 786                                         44,// bit_position
 787                                         1,// bit_size
 788                                         1.00000f,// factor
 789                                         0.00000f,// offset
 790                                         0,// min_value
 791                                         0,// max_value
 792                                         frequency_clock_t(0.00000f),// frequency
 793                                         true,// send_same
 794                                         false,// force_send_changed
 795                                         {
 796                                         },// states
 797                                         true,// writable
 798                                         decoder_t::decode_boolean,// decoder
 799                                         nullptr,// encoder
 800                                         false,// received
 801                                         std::make_pair<bool, int>(false, 0),// multiplex
 802                                         static_cast<sign_t>(0),// signed
 803                                         -1,// bit_sign_position
 804                                         ""// unit
 805                                 })},
 806                                 {std::make_shared<signal_t> (signal_t{
 807                                         "windows.rear_left.open",// generic_name
 808                                         46,// bit_position
 809                                         1,// bit_size
 810                                         1.00000f,// factor
 811                                         0.00000f,// offset
 812                                         0,// min_value
 813                                         0,// max_value
 814                                         frequency_clock_t(0.00000f),// frequency
 815                                         true,// send_same
 816                                         false,// force_send_changed
 817                                         {
 818                                         },// states
 819                                         true,// writable
 820                                         decoder_t::decode_boolean,// decoder
 821                                         nullptr,// encoder
 822                                         false,// received
 823                                         std::make_pair<bool, int>(false, 0),// multiplex
 824                                         static_cast<sign_t>(0),// signed
 825                                         -1,// bit_sign_position
 826                                         ""// unit
 827                                 })},
 828                                 {std::make_shared<signal_t> (signal_t{
 829                                         "windows.rear_right.open",// generic_name
 830                                         45,// bit_position
 831                                         4,// bit_size
 832                                         1.00000f,// factor
 833                                         0.00000f,// offset
 834                                         0,// min_value
 835                                         0,// max_value
 836                                         frequency_clock_t(0.00000f),// frequency
 837                                         true,// send_same
 838                                         false,// force_send_changed
 839                                         {
 840                                         },// states
 841                                         true,// writable
 842                                         decoder_t::decode_boolean,// decoder
 843                                         nullptr,// encoder
 844                                         false,// received
 845                                         std::make_pair<bool, int>(false, 0),// multiplex
 846                                         static_cast<sign_t>(0),// signed
 847                                         -1,// bit_sign_position
 848                                         ""// unit
 849                                 })}
 850                         } // end signals vector
 851                 })} // end message_definition entry
 852         }, // end message_definition vector
 853         { // beginning diagnostic_messages_ vector
 854                 {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 855                         4,
 856                         "engine.load",
 857                         0,
 858                         0,
 859                         UNIT::INVALID,
 860                         5.00000f,
 861                         decoder_t::decode_obd2_response,
 862                         nullptr,
 863                         true,
 864                         false
 865                 })}
 866 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 867                         5,
 868                         "engine.coolant.temperature",
 869                         0,
 870                         0,
 871                         UNIT::INVALID,
 872                         1.00000f,
 873                         decoder_t::decode_obd2_response,
 874                         nullptr,
 875                         true,
 876                         false
 877                 })}
 878 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 879                         10,
 880                         "fuel.pressure",
 881                         0,
 882                         0,
 883                         UNIT::INVALID,
 884                         1.00000f,
 885                         decoder_t::decode_obd2_response,
 886                         nullptr,
 887                         true,
 888                         false
 889                 })}
 890 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 891                         11,
 892                         "intake.manifold.pressure",
 893                         0,
 894                         0,
 895                         UNIT::INVALID,
 896                         1.00000f,
 897                         decoder_t::decode_obd2_response,
 898                         nullptr,
 899                         true,
 900                         false
 901                 })}
 902 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 903                         12,
 904                         "engine.speed",
 905                         0,
 906                         0,
 907                         UNIT::INVALID,
 908                         5.00000f,
 909                         decoder_t::decode_obd2_response,
 910                         nullptr,
 911                         true,
 912                         false
 913                 })}
 914 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 915                         13,
 916                         "vehicle.speed",
 917                         0,
 918                         0,
 919                         UNIT::INVALID,
 920                         5.00000f,
 921                         decoder_t::decode_obd2_response,
 922                         nullptr,
 923                         true,
 924                         false
 925                 })}
 926 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 927                         15,
 928                         "intake.air.temperature",
 929                         0,
 930                         0,
 931                         UNIT::INVALID,
 932                         1.00000f,
 933                         decoder_t::decode_obd2_response,
 934                         nullptr,
 935                         true,
 936                         false
 937                 })}
 938 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 939                         16,
 940                         "mass.airflow",
 941                         0,
 942                         0,
 943                         UNIT::INVALID,
 944                         5.00000f,
 945                         decoder_t::decode_obd2_response,
 946                         nullptr,
 947                         true,
 948                         false
 949                 })}
 950 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 951                         17,
 952                         "throttle.position",
 953                         0,
 954                         0,
 955                         UNIT::INVALID,
 956                         5.00000f,
 957                         decoder_t::decode_obd2_response,
 958                         nullptr,
 959                         true,
 960                         false
 961                 })}
 962 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 963                         31,
 964                         "running.time",
 965                         0,
 966                         0,
 967                         UNIT::INVALID,
 968                         1.00000f,
 969                         decoder_t::decode_obd2_response,
 970                         nullptr,
 971                         true,
 972                         false
 973                 })}
 974 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 975                         45,
 976                         "EGR.error",
 977                         0,
 978                         0,
 979                         UNIT::INVALID,
 980                         0.00000f,
 981                         decoder_t::decode_obd2_response,
 982                         nullptr,
 983                         true,
 984                         false
 985                 })}
 986 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 987                         47,
 988                         "fuel.level",
 989                         0,
 990                         0,
 991                         UNIT::INVALID,
 992                         1.00000f,
 993                         decoder_t::decode_obd2_response,
 994                         nullptr,
 995                         true,
 996                         false
 997                 })}
 998 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 999                         51,
1000                         "barometric.pressure",
1001                         0,
1002                         0,
1003                         UNIT::INVALID,
1004                         1.00000f,
1005                         decoder_t::decode_obd2_response,
1006                         nullptr,
1007                         true,
1008                         false
1009                 })}
1010 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1011                         70,
1012                         "ambient.air.temperature",
1013                         0,
1014                         0,
1015                         UNIT::INVALID,
1016                         1.00000f,
1017                         decoder_t::decode_obd2_response,
1018                         nullptr,
1019                         true,
1020                         false
1021                 })}
1022 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1023                         76,
1024                         "commanded.throttle.position",
1025                         0,
1026                         0,
1027                         UNIT::INVALID,
1028                         1.00000f,
1029                         decoder_t::decode_obd2_response,
1030                         nullptr,
1031                         true,
1032                         false
1033                 })}
1034 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1035                         82,
1036                         "ethanol.fuel.percentage",
1037                         0,
1038                         0,
1039                         UNIT::INVALID,
1040                         1.00000f,
1041                         decoder_t::decode_obd2_response,
1042                         nullptr,
1043                         true,
1044                         false
1045                 })}
1046 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1047                         90,
1048                         "accelerator.pedal.position",
1049                         0,
1050                         0,
1051                         UNIT::INVALID,
1052                         5.00000f,
1053                         decoder_t::decode_obd2_response,
1054                         nullptr,
1055                         true,
1056                         false
1057                 })}
1058 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1059                         91,
1060                         "hybrid.battery-pack.remaining.life",
1061                         0,
1062                         0,
1063                         UNIT::INVALID,
1064                         5.00000f,
1065                         decoder_t::decode_obd2_response,
1066                         nullptr,
1067                         true,
1068                         false
1069                 })}
1070 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1071                         92,
1072                         "engine.oil.temperature",
1073                         0,
1074                         0,
1075                         UNIT::INVALID,
1076                         1.00000f,
1077                         decoder_t::decode_obd2_response,
1078                         nullptr,
1079                         true,
1080                         false
1081                 })}
1082 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1083                         94,
1084                         "engine.fuel.rate",
1085                         0,
1086                         0,
1087                         UNIT::INVALID,
1088                         1.00000f,
1089                         decoder_t::decode_obd2_response,
1090                         nullptr,
1091                         true,
1092                         false
1093                 })}
1094 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1095                         99,
1096                         "engine.torque",
1097                         0,
1098                         0,
1099                         UNIT::INVALID,
1100                         1.00000f,
1101                         decoder_t::decode_obd2_response,
1102                         nullptr,
1103                         true,
1104                         false
1105                 })}
1106
1107         } // end diagnostic_messages_ vector
1108 }); // end message_set entry
1109
1110 CTLP_ONLOAD(plugin, handle) {
1111         afb_api_t api = (afb_api_t) plugin->api;
1112         CtlConfigT* CtlConfig = (CtlConfigT*) afb_api_get_userdata(api);
1113         application_t* app = (application_t*) getExternalData(CtlConfig);
1114
1115         return app->add_message_set(cms);
1116 }
1117
1118
1119 }
1120