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",0x111,"",16,16,frequency_clock_t(5.00000f),true,
  11                         { // beginning signals vector
  12                                 {std::make_shared<signal_t> (signal_t{
  13                                         "sig1.1",// generic_name
  14                                         0,// bit_position
  15                                         16,// 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                                         true,// 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                                         "sig1.2",// generic_name
  36                                         16,// bit_position
  37                                         16,// bit_size
  38                                         1.00000f,// factor
  39                                         0.00000f,// offset
  40                                         0,// min_value
  41                                         0,// max_value
  42                                         frequency_clock_t(0.00000f),// frequency
  43                                         true,// send_same
  44                                         false,// force_send_changed
  45                                         {
  46                                         },// states
  47                                         true,// writable
  48                                         nullptr,// decoder
  49                                         nullptr,// encoder
  50                                         false,// received
  51                                         std::make_pair<bool, int>(false, 0),// multiplex
  52                                         static_cast<sign_t>(0),// signed
  53                                         -1,// bit_sign_position
  54                                         ""// unit
  55                                 })},
  56                                 {std::make_shared<signal_t> (signal_t{
  57                                         "sig2.1",// generic_name
  58                                         32,// bit_position
  59                                         16,// bit_size
  60                                         1.00000f,// factor
  61                                         0.00000f,// offset
  62                                         0,// min_value
  63                                         0,// max_value
  64                                         frequency_clock_t(0.00000f),// frequency
  65                                         true,// send_same
  66                                         false,// force_send_changed
  67                                         {
  68                                         },// states
  69                                         true,// writable
  70                                         nullptr,// decoder
  71                                         nullptr,// encoder
  72                                         false,// received
  73                                         std::make_pair<bool, int>(false, 0),// multiplex
  74                                         static_cast<sign_t>(0),// signed
  75                                         -1,// bit_sign_position
  76                                         ""// unit
  77                                 })},
  78                                 {std::make_shared<signal_t> (signal_t{
  79                                         "sig2.2",// generic_name
  80                                         48,// bit_position
  81                                         16,// bit_size
  82                                         1.00000f,// factor
  83                                         0.00000f,// offset
  84                                         0,// min_value
  85                                         0,// max_value
  86                                         frequency_clock_t(0.00000f),// frequency
  87                                         true,// send_same
  88                                         false,// force_send_changed
  89                                         {
  90                                         },// states
  91                                         true,// writable
  92                                         nullptr,// decoder
  93                                         nullptr,// encoder
  94                                         false,// received
  95                                         std::make_pair<bool, int>(false, 0),// multiplex
  96                                         static_cast<sign_t>(0),// signed
  97                                         -1,// bit_sign_position
  98                                         ""// unit
  99                                 })},
 100                                 {std::make_shared<signal_t> (signal_t{
 101                                         "sig3.1",// generic_name
 102                                         64,// bit_position
 103                                         16,// 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                                         true,// writable
 114                                         nullptr,// 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                                         "sig3.2",// generic_name
 124                                         80,// bit_position
 125                                         16,// 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                                         true,// writable
 136                                         nullptr,// 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                                         "sig4.1",// generic_name
 146                                         96,// bit_position
 147                                         16,// 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                                         true,// writable
 158                                         nullptr,// 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                                         "sig4.2",// generic_name
 168                                         112,// bit_position
 169                                         16,// 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                                         true,// writable
 180                                         nullptr,// 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                         } // end signals vector
 189                 })} // end message_definition entry
 190 ,*/             {std::make_shared<message_definition_t>(message_definition_t{"ls",0x30,"",8,0,frequency_clock_t(5.00000f),true,
 191                         { // beginning signals vector
 192                                 {std::make_shared<signal_t> (signal_t{
 193                                         "hvac.fan.speed",// generic_name
 194                                         32,// bit_position
 195                                         8,// bit_size
 196                                         23.5294f,// factor
 197                                         0.00000f,// offset
 198                                         0,// min_value
 199                                         0,// max_value
 200                                         frequency_clock_t(0.00000f),// frequency
 201                                         true,// send_same
 202                                         false,// force_send_changed
 203                                         {
 204                                         },// states
 205                                         true,// writable
 206                                         nullptr,// decoder
 207                                         nullptr,// encoder
 208                                         false,// received
 209                                         std::make_pair<bool, int>(false, 0),// multiplex
 210                                         static_cast<sign_t>(0),// signed
 211                                         -1,// bit_sign_position
 212                                         ""// unit
 213                                 })},
 214                                 {std::make_shared<signal_t> (signal_t{
 215                                         "hvac.temperature.left",// generic_name
 216                                         0,// bit_position
 217                                         8,// bit_size
 218                                         1.00000f,// factor
 219                                         0.00000f,// offset
 220                                         0,// min_value
 221                                         0,// max_value
 222                                         frequency_clock_t(0.00000f),// frequency
 223                                         true,// send_same
 224                                         false,// force_send_changed
 225                                         {
 226                                         },// states
 227                                         true,// writable
 228                                         nullptr,// decoder
 229                                         nullptr,// encoder
 230                                         false,// received
 231                                         std::make_pair<bool, int>(false, 0),// multiplex
 232                                         static_cast<sign_t>(0),// signed
 233                                         -1,// bit_sign_position
 234                                         ""// unit
 235                                 })},
 236                                 {std::make_shared<signal_t> (signal_t{
 237                                         "hvac.temperature.right",// generic_name
 238                                         8,// bit_position
 239                                         8,// bit_size
 240                                         1.00000f,// factor
 241                                         0.00000f,// offset
 242                                         0,// min_value
 243                                         0,// max_value
 244                                         frequency_clock_t(0.00000f),// frequency
 245                                         true,// send_same
 246                                         false,// force_send_changed
 247                                         {
 248                                         },// states
 249                                         true,// writable
 250                                         nullptr,// decoder
 251                                         nullptr,// encoder
 252                                         false,// received
 253                                         std::make_pair<bool, int>(false, 0),// multiplex
 254                                         static_cast<sign_t>(0),// signed
 255                                         -1,// bit_sign_position
 256                                         ""// unit
 257                                 })},
 258                                 {std::make_shared<signal_t> (signal_t{
 259                                         "hvac.temperature.average",// generic_name
 260                                         16,// bit_position
 261                                         8,// bit_size
 262                                         1.00000f,// factor
 263                                         0.00000f,// offset
 264                                         0,// min_value
 265                                         0,// max_value
 266                                         frequency_clock_t(0.00000f),// frequency
 267                                         true,// send_same
 268                                         false,// force_send_changed
 269                                         {
 270                                         },// states
 271                                         true,// writable
 272                                         nullptr,// decoder
 273                                         nullptr,// encoder
 274                                         false,// received
 275                                         std::make_pair<bool, int>(false, 0),// multiplex
 276                                         static_cast<sign_t>(0),// signed
 277                                         -1,// bit_sign_position
 278                                         ""// unit
 279                                 })}
 280                         } // end signals vector
 281                 })} // end message_definition entry
 282 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x3D9,"",8,2,frequency_clock_t(5.00000f),true,
 283                         { // beginning signals vector
 284                                 {std::make_shared<signal_t> (signal_t{
 285                                         "engine.speed",// generic_name
 286                                         16,// bit_position
 287                                         16,// bit_size
 288                                         0.250000f,// factor
 289                                         0.00000f,// offset
 290                                         0,// min_value
 291                                         0,// max_value
 292                                         frequency_clock_t(0.00000f),// frequency
 293                                         true,// send_same
 294                                         false,// force_send_changed
 295                                         {
 296                                         },// states
 297                                         true,// writable
 298                                         nullptr,// decoder
 299                                         nullptr,// encoder
 300                                         false,// received
 301                                         std::make_pair<bool, int>(false, 0),// multiplex
 302                                         static_cast<sign_t>(0),// signed
 303                                         -1,// bit_sign_position
 304                                         ""// unit
 305                                 })},
 306                                 {std::make_shared<signal_t> (signal_t{
 307                                         "fuel.level.low",// generic_name
 308                                         55,// bit_position
 309                                         1,// bit_size
 310                                         1.00000f,// factor
 311                                         0.00000f,// offset
 312                                         0,// min_value
 313                                         0,// max_value
 314                                         frequency_clock_t(0.00000f),// frequency
 315                                         true,// send_same
 316                                         false,// force_send_changed
 317                                         {
 318                                         },// states
 319                                         true,// writable
 320                                         decoder_t::decode_boolean,// decoder
 321                                         nullptr,// encoder
 322                                         false,// received
 323                                         std::make_pair<bool, int>(false, 0),// multiplex
 324                                         static_cast<sign_t>(0),// signed
 325                                         -1,// bit_sign_position
 326                                         ""// unit
 327                                 })},
 328                                 {std::make_shared<signal_t> (signal_t{
 329                                         "fuel.level",// generic_name
 330                                         8,// bit_position
 331                                         8,// bit_size
 332                                         0.392157f,// factor
 333                                         0.00000f,// offset
 334                                         0,// min_value
 335                                         0,// max_value
 336                                         frequency_clock_t(0.00000f),// frequency
 337                                         true,// send_same
 338                                         false,// force_send_changed
 339                                         {
 340                                         },// states
 341                                         true,// writable
 342                                         nullptr,// decoder
 343                                         nullptr,// encoder
 344                                         false,// received
 345                                         std::make_pair<bool, int>(false, 0),// multiplex
 346                                         static_cast<sign_t>(0),// signed
 347                                         -1,// bit_sign_position
 348                                         ""// unit
 349                                 })}
 350                         } // end signals vector
 351                 })} // end message_definition entry
 352 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x3E9,"",8,0,frequency_clock_t(5.00000f),true,
 353                         { // beginning signals vector
 354                                 {std::make_shared<signal_t> (signal_t{
 355                                         "vehicle.average.speed",// generic_name
 356                                         0,// bit_position
 357                                         15,// bit_size
 358                                         0.0156250f,// factor
 359                                         0.00000f,// offset
 360                                         0,// min_value
 361                                         0,// max_value
 362                                         frequency_clock_t(0.00000f),// frequency
 363                                         true,// send_same
 364                                         false,// force_send_changed
 365                                         {
 366                                         },// states
 367                                         false,// writable
 368                                         nullptr,// decoder
 369                                         nullptr,// encoder
 370                                         false,// received
 371                                         std::make_pair<bool, int>(false, 0),// multiplex
 372                                         static_cast<sign_t>(0),// signed
 373                                         -1,// bit_sign_position
 374                                         ""// unit
 375                                 })}
 376                         } // end signals vector
 377                 })} // end message_definition entry
 378 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x4D1,"",8,0,frequency_clock_t(5.00000f),true,
 379                         { // beginning signals vector
 380                                 {std::make_shared<signal_t> (signal_t{
 381                                         "engine.oil.temp",// generic_name
 382                                         16,// bit_position
 383                                         8,// bit_size
 384                                         1.00000f,// factor
 385                                         0.00000f,// offset
 386                                         0,// min_value
 387                                         0,// max_value
 388                                         frequency_clock_t(0.00000f),// frequency
 389                                         true,// send_same
 390                                         false,// force_send_changed
 391                                         {
 392                                         },// states
 393                                         true,// writable
 394                                         nullptr,// decoder
 395                                         nullptr,// encoder
 396                                         false,// received
 397                                         std::make_pair<bool, int>(false, 0),// multiplex
 398                                         static_cast<sign_t>(0),// signed
 399                                         -1,// bit_sign_position
 400                                         ""// unit
 401                                 })},
 402                                 {std::make_shared<signal_t> (signal_t{
 403                                         "engine.oil.temp.high",// generic_name
 404                                         7,// bit_position
 405                                         1,// bit_size
 406                                         1.00000f,// factor
 407                                         0.00000f,// offset
 408                                         0,// min_value
 409                                         0,// max_value
 410                                         frequency_clock_t(0.00000f),// frequency
 411                                         true,// send_same
 412                                         false,// force_send_changed
 413                                         {
 414                                         },// states
 415                                         true,// writable
 416                                         decoder_t::decode_boolean,// decoder
 417                                         nullptr,// encoder
 418                                         false,// received
 419                                         std::make_pair<bool, int>(false, 0),// multiplex
 420                                         static_cast<sign_t>(0),// signed
 421                                         -1,// bit_sign_position
 422                                         ""// unit
 423                                 })}
 424                         } // end signals vector
 425                 })} // end message_definition entry
 426 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x620,"",8,0,frequency_clock_t(5.00000f),true,
 427                         { // beginning signals vector
 428                                 {std::make_shared<signal_t> (signal_t{
 429                                         "doors.boot.open",// generic_name
 430                                         47,// bit_position
 431                                         1,// bit_size
 432                                         1.00000f,// factor
 433                                         0.00000f,// offset
 434                                         0,// min_value
 435                                         0,// max_value
 436                                         frequency_clock_t(0.00000f),// frequency
 437                                         true,// send_same
 438                                         false,// force_send_changed
 439                                         {
 440                                         },// states
 441                                         true,// writable
 442                                         decoder_t::decode_boolean,// decoder
 443                                         nullptr,// encoder
 444                                         false,// received
 445                                         std::make_pair<bool, int>(false, 0),// multiplex
 446                                         static_cast<sign_t>(0),// signed
 447                                         -1,// bit_sign_position
 448                                         ""// unit
 449                                 })},
 450                                 {std::make_shared<signal_t> (signal_t{
 451                                         "doors.front_left.open",// generic_name
 452                                         43,// bit_position
 453                                         1,// bit_size
 454                                         1.00000f,// factor
 455                                         0.00000f,// offset
 456                                         0,// min_value
 457                                         0,// max_value
 458                                         frequency_clock_t(0.00000f),// frequency
 459                                         true,// send_same
 460                                         false,// force_send_changed
 461                                         {
 462                                         },// states
 463                                         true,// writable
 464                                         decoder_t::decode_boolean,// decoder
 465                                         nullptr,// encoder
 466                                         false,// received
 467                                         std::make_pair<bool, int>(false, 0),// multiplex
 468                                         static_cast<sign_t>(0),// signed
 469                                         -1,// bit_sign_position
 470                                         ""// unit
 471                                 })},
 472                                 {std::make_shared<signal_t> (signal_t{
 473                                         "doors.front_right.open",// generic_name
 474                                         44,// bit_position
 475                                         1,// bit_size
 476                                         1.00000f,// factor
 477                                         0.00000f,// offset
 478                                         0,// min_value
 479                                         0,// max_value
 480                                         frequency_clock_t(0.00000f),// frequency
 481                                         true,// send_same
 482                                         false,// force_send_changed
 483                                         {
 484                                         },// states
 485                                         true,// writable
 486                                         decoder_t::decode_boolean,// decoder
 487                                         nullptr,// encoder
 488                                         false,// received
 489                                         std::make_pair<bool, int>(false, 0),// multiplex
 490                                         static_cast<sign_t>(0),// signed
 491                                         -1,// bit_sign_position
 492                                         ""// unit
 493                                 })},
 494                                 {std::make_shared<signal_t> (signal_t{
 495                                         "doors.rear_left.open",// generic_name
 496                                         46,// bit_position
 497                                         1,// bit_size
 498                                         1.00000f,// factor
 499                                         0.00000f,// offset
 500                                         0,// min_value
 501                                         0,// max_value
 502                                         frequency_clock_t(0.00000f),// frequency
 503                                         true,// send_same
 504                                         false,// force_send_changed
 505                                         {
 506                                         },// states
 507                                         true,// writable
 508                                         decoder_t::decode_boolean,// decoder
 509                                         nullptr,// encoder
 510                                         false,// received
 511                                         std::make_pair<bool, int>(false, 0),// multiplex
 512                                         static_cast<sign_t>(0),// signed
 513                                         -1,// bit_sign_position
 514                                         ""// unit
 515                                 })},
 516                                 {std::make_shared<signal_t> (signal_t{
 517                                         "doors.rear_right.open",// generic_name
 518                                         45,// bit_position
 519                                         4,// bit_size
 520                                         1.00000f,// factor
 521                                         0.00000f,// offset
 522                                         0,// min_value
 523                                         0,// max_value
 524                                         frequency_clock_t(0.00000f),// frequency
 525                                         true,// send_same
 526                                         false,// force_send_changed
 527                                         {
 528                                         },// states
 529                                         true,// writable
 530                                         decoder_t::decode_boolean,// decoder
 531                                         nullptr,// encoder
 532                                         false,// received
 533                                         std::make_pair<bool, int>(false, 0),// multiplex
 534                                         static_cast<sign_t>(0),// signed
 535                                         -1,// bit_sign_position
 536                                         ""// unit
 537                                 })}
 538                         } // end signals vector
 539                 })} // end message_definition entry
 540 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x799,"",8,0,frequency_clock_t(5.00000f),true,
 541                         { // beginning signals vector
 542                                 {std::make_shared<signal_t> (signal_t{
 543                                         "windows.front_left.open",// generic_name
 544                                         43,// bit_position
 545                                         1,// bit_size
 546                                         1.00000f,// factor
 547                                         0.00000f,// offset
 548                                         0,// min_value
 549                                         0,// max_value
 550                                         frequency_clock_t(0.00000f),// frequency
 551                                         true,// send_same
 552                                         false,// force_send_changed
 553                                         {
 554                                         },// states
 555                                         true,// writable
 556                                         decoder_t::decode_boolean,// decoder
 557                                         nullptr,// encoder
 558                                         false,// received
 559                                         std::make_pair<bool, int>(false, 0),// multiplex
 560                                         static_cast<sign_t>(0),// signed
 561                                         -1,// bit_sign_position
 562                                         ""// unit
 563                                 })},
 564                                 {std::make_shared<signal_t> (signal_t{
 565                                         "windows.front_right.open",// generic_name
 566                                         44,// bit_position
 567                                         1,// bit_size
 568                                         1.00000f,// factor
 569                                         0.00000f,// offset
 570                                         0,// min_value
 571                                         0,// max_value
 572                                         frequency_clock_t(0.00000f),// frequency
 573                                         true,// send_same
 574                                         false,// force_send_changed
 575                                         {
 576                                         },// states
 577                                         true,// writable
 578                                         decoder_t::decode_boolean,// decoder
 579                                         nullptr,// encoder
 580                                         false,// received
 581                                         std::make_pair<bool, int>(false, 0),// multiplex
 582                                         static_cast<sign_t>(0),// signed
 583                                         -1,// bit_sign_position
 584                                         ""// unit
 585                                 })},
 586                                 {std::make_shared<signal_t> (signal_t{
 587                                         "windows.rear_left.open",// generic_name
 588                                         46,// bit_position
 589                                         1,// bit_size
 590                                         1.00000f,// factor
 591                                         0.00000f,// offset
 592                                         0,// min_value
 593                                         0,// max_value
 594                                         frequency_clock_t(0.00000f),// frequency
 595                                         true,// send_same
 596                                         false,// force_send_changed
 597                                         {
 598                                         },// states
 599                                         true,// writable
 600                                         decoder_t::decode_boolean,// decoder
 601                                         nullptr,// encoder
 602                                         false,// received
 603                                         std::make_pair<bool, int>(false, 0),// multiplex
 604                                         static_cast<sign_t>(0),// signed
 605                                         -1,// bit_sign_position
 606                                         ""// unit
 607                                 })},
 608                                 {std::make_shared<signal_t> (signal_t{
 609                                         "windows.rear_right.open",// generic_name
 610                                         45,// bit_position
 611                                         4,// bit_size
 612                                         1.00000f,// factor
 613                                         0.00000f,// offset
 614                                         0,// min_value
 615                                         0,// max_value
 616                                         frequency_clock_t(0.00000f),// frequency
 617                                         true,// send_same
 618                                         false,// force_send_changed
 619                                         {
 620                                         },// states
 621                                         true,// writable
 622                                         decoder_t::decode_boolean,// decoder
 623                                         nullptr,// encoder
 624                                         false,// received
 625                                         std::make_pair<bool, int>(false, 0),// multiplex
 626                                         static_cast<sign_t>(0),// signed
 627                                         -1,// bit_sign_position
 628                                         ""// unit
 629                                 })}
 630                         } // end signals vector
 631                 })} // end message_definition entry
 632 ,               {std::make_shared<message_definition_t>(message_definition_t{"j1939",130306,"Wind.Data",8,392,frequency_clock_t(5.00000f),true,
 633                         { // beginning signals vector
 634                                 {std::make_shared<signal_t> (signal_t{
 635                                         "Wind.Data.Reference",// generic_name
 636                                         40,// bit_position
 637                                         3,// bit_size
 638                                         1.00000f,// factor
 639                                         0.00000f,// offset
 640                                         0,// min_value
 641                                         0,// max_value
 642                                         frequency_clock_t(0.00000f),// frequency
 643                                         true,// send_same
 644                                         false,// force_send_changed
 645                                         {
 646                                                 {2,"Apparent"},
 647                                                 {1,"Magnetic (ground referenced to Magnetic North)"},
 648                                                 {3,"True (boat referenced)"},
 649                                                 {0,"True (ground referenced to North)"},
 650                                                 {4,"True (water referenced)"}
 651                                         },// states
 652                                         false,// writable
 653                                         decoder_t::decode_state,// decoder
 654                                         nullptr,// encoder
 655                                         false,// received
 656                                         std::make_pair<bool, int>(false, 0),// multiplex
 657                                         static_cast<sign_t>(0),// signed
 658                                         -1,// bit_sign_position
 659                                         ""// unit
 660                                 })},
 661                                 {std::make_shared<signal_t> (signal_t{
 662                                         "Wind.Data.Reserved",// generic_name
 663                                         43,// bit_position
 664                                         21,// bit_size
 665                                         1.00000f,// factor
 666                                         0.00000f,// offset
 667                                         0,// min_value
 668                                         0,// max_value
 669                                         frequency_clock_t(0.00000f),// frequency
 670                                         true,// send_same
 671                                         false,// force_send_changed
 672                                         {
 673                                         },// states
 674                                         false,// writable
 675                                         decoder_t::decode_bytes,// decoder
 676                                         nullptr,// encoder
 677                                         false,// received
 678                                         std::make_pair<bool, int>(false, 0),// multiplex
 679                                         static_cast<sign_t>(0),// signed
 680                                         -1,// bit_sign_position
 681                                         ""// unit
 682                                 })},
 683                                 {std::make_shared<signal_t> (signal_t{
 684                                         "Wind.Data.Sid",// generic_name
 685                                         0,// bit_position
 686                                         8,// bit_size
 687                                         1.00000f,// factor
 688                                         0.00000f,// offset
 689                                         0,// min_value
 690                                         0,// max_value
 691                                         frequency_clock_t(0.00000f),// frequency
 692                                         true,// send_same
 693                                         false,// force_send_changed
 694                                         {
 695                                         },// states
 696                                         false,// writable
 697                                         nullptr,// decoder
 698                                         nullptr,// encoder
 699                                         false,// received
 700                                         std::make_pair<bool, int>(false, 0),// multiplex
 701                                         static_cast<sign_t>(0),// signed
 702                                         -1,// bit_sign_position
 703                                         ""// unit
 704                                 })},
 705                                 {std::make_shared<signal_t> (signal_t{
 706                                         "Wind.Data.Wind.Angle",// generic_name
 707                                         24,// bit_position
 708                                         16,// bit_size
 709                                         0.000100000f,// factor
 710                                         0.00000f,// offset
 711                                         0,// min_value
 712                                         0,// max_value
 713                                         frequency_clock_t(0.00000f),// frequency
 714                                         true,// send_same
 715                                         false,// force_send_changed
 716                                         {
 717                                         },// states
 718                                         false,// writable
 719                                         nullptr,// decoder
 720                                         nullptr,// encoder
 721                                         false,// received
 722                                         std::make_pair<bool, int>(false, 0),// multiplex
 723                                         static_cast<sign_t>(0),// signed
 724                                         -1,// bit_sign_position
 725                                         "rad"// unit
 726                                 })},
 727                                 {std::make_shared<signal_t> (signal_t{
 728                                         "Wind.Data.Wind.Speed",// generic_name
 729                                         8,// bit_position
 730                                         16,// bit_size
 731                                         0.0100000f,// factor
 732                                         0.00000f,// offset
 733                                         0,// min_value
 734                                         0,// max_value
 735                                         frequency_clock_t(0.00000f),// frequency
 736                                         true,// send_same
 737                                         false,// force_send_changed
 738                                         {
 739                                         },// states
 740                                         false,// writable
 741                                         nullptr,// decoder
 742                                         nullptr,// encoder
 743                                         false,// received
 744                                         std::make_pair<bool, int>(false, 0),// multiplex
 745                                         static_cast<sign_t>(0),// signed
 746                                         -1,// bit_sign_position
 747                                         "m/s"// unit
 748                                 })}
 749                         } // end signals vector
 750                 })} // end message_definition entry
 751 ,               {std::make_shared<message_definition_t>(message_definition_t{"j1939",61442,"ETC1",8,8,frequency_clock_t(5.00000f),true,
 752                         { // beginning signals vector
 753                                 {std::make_shared<signal_t> (signal_t{
 754                                         "Eng.Momentary.Overspeed.Enable",// generic_name
 755                                         32,// bit_position
 756                                         2,// bit_size
 757                                         1.00000f,// factor
 758                                         0.00000f,// offset
 759                                         0,// min_value
 760                                         0,// max_value
 761                                         frequency_clock_t(0.00000f),// frequency
 762                                         true,// send_same
 763                                         false,// force_send_changed
 764                                         {
 765                                                 {0,"MomentaryEngOverspeedIsDisabled"},
 766                                                 {1,"MomentaryEngOverspeedIsEnabled"},
 767                                                 {2,"Reserved"},
 768                                                 {3,"TakeNoAction"}
 769                                         },// states
 770                                         true,// writable
 771                                         decoder_t::decode_state,// decoder
 772                                         nullptr,// encoder
 773                                         false,// received
 774                                         std::make_pair<bool, int>(false, 0),// multiplex
 775                                         static_cast<sign_t>(0),// signed
 776                                         -1,// bit_sign_position
 777                                         ""// unit
 778                                 })},
 779                                 {std::make_shared<signal_t> (signal_t{
 780                                         "Momentary.Eng.Max.Power.Enable",// generic_name
 781                                         36,// bit_position
 782                                         2,// bit_size
 783                                         1.00000f,// factor
 784                                         0.00000f,// offset
 785                                         0,// min_value
 786                                         0,// max_value
 787                                         frequency_clock_t(0.00000f),// frequency
 788                                         true,// send_same
 789                                         false,// force_send_changed
 790                                         {
 791                                                 {2,"fault"},
 792                                                 {1,"mmntarilyRqingMaxPowerAvailable"},
 793                                                 {3,"notAvailable"},
 794                                                 {0,"notRqingMaxPowerAvailable"}
 795                                         },// states
 796                                         true,// writable
 797                                         decoder_t::decode_state,// decoder
 798                                         nullptr,// encoder
 799                                         false,// received
 800                                         std::make_pair<bool, int>(false, 0),// multiplex
 801                                         static_cast<sign_t>(0),// signed
 802                                         -1,// bit_sign_position
 803                                         ""// unit
 804                                 })},
 805                                 {std::make_shared<signal_t> (signal_t{
 806                                         "Percent.Clutch.Slip",// generic_name
 807                                         24,// bit_position
 808                                         8,// bit_size
 809                                         0.400000f,// factor
 810                                         0.00000f,// offset
 811                                         0,// min_value
 812                                         0,// max_value
 813                                         frequency_clock_t(0.00000f),// frequency
 814                                         true,// send_same
 815                                         false,// force_send_changed
 816                                         {
 817                                         },// states
 818                                         true,// writable
 819                                         nullptr,// decoder
 820                                         nullptr,// encoder
 821                                         false,// received
 822                                         std::make_pair<bool, int>(false, 0),// multiplex
 823                                         static_cast<sign_t>(0),// signed
 824                                         -1,// bit_sign_position
 825                                         "%"// unit
 826                                 })},
 827                                 {std::make_shared<signal_t> (signal_t{
 828                                         "Progressive.Shift.Disable",// generic_name
 829                                         34,// bit_position
 830                                         2,// bit_size
 831                                         1.00000f,// factor
 832                                         0.00000f,// offset
 833                                         0,// min_value
 834                                         0,// max_value
 835                                         frequency_clock_t(0.00000f),// frequency
 836                                         true,// send_same
 837                                         false,// force_send_changed
 838                                         {
 839                                                 {1,"ProgressiveShiftIsDisabled"},
 840                                                 {0,"ProgressiveShiftIsNotDisabled"},
 841                                                 {2,"Reserved"},
 842                                                 {3,"TakeNoAction"}
 843                                         },// states
 844                                         true,// writable
 845                                         decoder_t::decode_state,// decoder
 846                                         nullptr,// encoder
 847                                         false,// received
 848                                         std::make_pair<bool, int>(false, 0),// multiplex
 849                                         static_cast<sign_t>(0),// signed
 850                                         -1,// bit_sign_position
 851                                         ""// unit
 852                                 })},
 853                                 {std::make_shared<signal_t> (signal_t{
 854                                         "Src.Addrss.Of.Ctrllng.Dvc.Fr.Trns.Cntrl",// generic_name
 855                                         56,// bit_position
 856                                         8,// bit_size
 857                                         1.00000f,// factor
 858                                         0.00000f,// offset
 859                                         0,// min_value
 860                                         0,// max_value
 861                                         frequency_clock_t(0.00000f),// frequency
 862                                         true,// send_same
 863                                         false,// force_send_changed
 864                                         {
 865                                         },// states
 866                                         true,// writable
 867                                         nullptr,// decoder
 868                                         nullptr,// encoder
 869                                         false,// received
 870                                         std::make_pair<bool, int>(false, 0),// multiplex
 871                                         static_cast<sign_t>(0),// signed
 872                                         -1,// bit_sign_position
 873                                         ""// unit
 874                                 })},
 875                                 {std::make_shared<signal_t> (signal_t{
 876                                         "Trans.Driveline.Engaged",// generic_name
 877                                         0,// bit_position
 878                                         2,// bit_size
 879                                         1.00000f,// factor
 880                                         0.00000f,// offset
 881                                         0,// min_value
 882                                         0,// max_value
 883                                         frequency_clock_t(0.00000f),// frequency
 884                                         true,// send_same
 885                                         false,// force_send_changed
 886                                         {
 887                                                 {0,"DrivelineDisengaged"},
 888                                                 {1,"DrivelineEngaged"},
 889                                                 {2,"Error"},
 890                                                 {3,"NotAvailable"}
 891                                         },// states
 892                                         true,// writable
 893                                         decoder_t::decode_state,// decoder
 894                                         nullptr,// encoder
 895                                         false,// received
 896                                         std::make_pair<bool, int>(false, 0),// multiplex
 897                                         static_cast<sign_t>(0),// signed
 898                                         -1,// bit_sign_position
 899                                         ""// unit
 900                                 })},
 901                                 {std::make_shared<signal_t> (signal_t{
 902                                         "Trans.Input.Shaft.Speed",// generic_name
 903                                         40,// bit_position
 904                                         16,// bit_size
 905                                         0.125000f,// factor
 906                                         0.00000f,// offset
 907                                         0,// min_value
 908                                         0,// max_value
 909                                         frequency_clock_t(0.00000f),// frequency
 910                                         true,// send_same
 911                                         false,// force_send_changed
 912                                         {
 913                                         },// states
 914                                         true,// writable
 915                                         nullptr,// decoder
 916                                         nullptr,// encoder
 917                                         false,// received
 918                                         std::make_pair<bool, int>(false, 0),// multiplex
 919                                         static_cast<sign_t>(0),// signed
 920                                         -1,// bit_sign_position
 921                                         "rpm"// unit
 922                                 })},
 923                                 {std::make_shared<signal_t> (signal_t{
 924                                         "Trans.Output.Shaft.Speed",// generic_name
 925                                         8,// bit_position
 926                                         16,// bit_size
 927                                         0.125000f,// factor
 928                                         0.00000f,// offset
 929                                         0,// min_value
 930                                         0,// max_value
 931                                         frequency_clock_t(0.00000f),// frequency
 932                                         true,// send_same
 933                                         false,// force_send_changed
 934                                         {
 935                                         },// states
 936                                         true,// writable
 937                                         nullptr,// decoder
 938                                         nullptr,// encoder
 939                                         false,// received
 940                                         std::make_pair<bool, int>(false, 0),// multiplex
 941                                         static_cast<sign_t>(0),// signed
 942                                         -1,// bit_sign_position
 943                                         "rpm"// unit
 944                                 })},
 945                                 {std::make_shared<signal_t> (signal_t{
 946                                         "Trans.Shift.In.Process",// generic_name
 947                                         4,// bit_position
 948                                         2,// bit_size
 949                                         1.00000f,// factor
 950                                         0.00000f,// offset
 951                                         0,// min_value
 952                                         0,// max_value
 953                                         frequency_clock_t(0.00000f),// frequency
 954                                         true,// send_same
 955                                         false,// force_send_changed
 956                                         {
 957                                                 {2,"Error"},
 958                                                 {3,"NotAvailable"},
 959                                                 {1,"ShiftInProcess"},
 960                                                 {0,"ShiftIsNotInProcess"}
 961                                         },// states
 962                                         true,// writable
 963                                         decoder_t::decode_state,// decoder
 964                                         nullptr,// encoder
 965                                         false,// received
 966                                         std::make_pair<bool, int>(false, 0),// multiplex
 967                                         static_cast<sign_t>(0),// signed
 968                                         -1,// bit_sign_position
 969                                         ""// unit
 970                                 })},
 971                                 {std::make_shared<signal_t> (signal_t{
 972                                         "Trns.Trq.Cnvrtr.Lckp.Trnstn.In.Prcess",// generic_name
 973                                         6,// bit_position
 974                                         2,// bit_size
 975                                         1.00000f,// factor
 976                                         0.00000f,// offset
 977                                         0,// min_value
 978                                         0,// max_value
 979                                         frequency_clock_t(0.00000f),// frequency
 980                                         true,// send_same
 981                                         false,// force_send_changed
 982                                         {
 983                                                 {2,"Error"},
 984                                                 {3,"NotAvailable"},
 985                                                 {1,"TransitionIsInProcess"},
 986                                                 {0,"TransitionIsNotInProcess"}
 987                                         },// states
 988                                         true,// writable
 989                                         decoder_t::decode_state,// decoder
 990                                         nullptr,// encoder
 991                                         false,// received
 992                                         std::make_pair<bool, int>(false, 0),// multiplex
 993                                         static_cast<sign_t>(0),// signed
 994                                         -1,// bit_sign_position
 995                                         ""// unit
 996                                 })},
 997                                 {std::make_shared<signal_t> (signal_t{
 998                                         "Trns.Trque.Converter.Lockup.Engaged",// generic_name
 999                                         2,// bit_position
1000                                         2,// bit_size
1001                                         1.00000f,// factor
1002                                         0.00000f,// offset
1003                                         0,// min_value
1004                                         0,// max_value
1005                                         frequency_clock_t(0.00000f),// frequency
1006                                         true,// send_same
1007                                         false,// force_send_changed
1008                                         {
1009                                                 {2,"Error"},
1010                                                 {3,"NotAvailable"},
1011                                                 {0,"TorqueConverterLockupDisengaged"},
1012                                                 {1,"TorqueConverterLockupEngaged"}
1013                                         },// states
1014                                         true,// writable
1015                                         decoder_t::decode_state,// decoder
1016                                         nullptr,// encoder
1017                                         false,// received
1018                                         std::make_pair<bool, int>(false, 0),// multiplex
1019                                         static_cast<sign_t>(0),// signed
1020                                         -1,// bit_sign_position
1021                                         ""// unit
1022                                 })}
1023                         } // end signals vector
1024                 })} // end message_definition entry
1025 ,               {std::make_shared<message_definition_t>(message_definition_t{"j1939",61444,"EEC1",8,8,frequency_clock_t(5.00000f),true,
1026                         { // beginning signals vector
1027                                 {std::make_shared<signal_t> (signal_t{
1028                                         "Actl.Eng.Prcnt.Trque.High.Resolution",// generic_name
1029                                         4,// bit_position
1030                                         4,// bit_size
1031                                         0.125000f,// factor
1032                                         0.00000f,// offset
1033                                         0,// min_value
1034                                         0,// max_value
1035                                         frequency_clock_t(0.00000f),// frequency
1036                                         true,// send_same
1037                                         false,// force_send_changed
1038                                         {
1039                                                 {0,"0000"},
1040                                                 {1,"0125"},
1041                                                 {7,"0875"},
1042                                                 {8,"1111NotAvailable"}
1043                                         },// states
1044                                         false,// writable
1045                                         decoder_t::decode_state,// decoder
1046                                         nullptr,// encoder
1047                                         false,// received
1048                                         std::make_pair<bool, int>(false, 0),// multiplex
1049                                         static_cast<sign_t>(0),// signed
1050                                         -1,// bit_sign_position
1051                                         "%"// unit
1052                                 })},
1053                                 {std::make_shared<signal_t> (signal_t{
1054                                         "Actual.Eng.Percent.Torque",// generic_name
1055                                         16,// bit_position
1056                                         8,// bit_size
1057                                         1.00000f,// factor
1058                                         -125.000f,// offset
1059                                         0,// min_value
1060                                         0,// max_value
1061                                         frequency_clock_t(0.00000f),// frequency
1062                                         true,// send_same
1063                                         false,// force_send_changed
1064                                         {
1065                                         },// states
1066                                         false,// writable
1067                                         nullptr,// decoder
1068                                         nullptr,// encoder
1069                                         false,// received
1070                                         std::make_pair<bool, int>(false, 0),// multiplex
1071                                         static_cast<sign_t>(0),// signed
1072                                         -1,// bit_sign_position
1073                                         "%"// unit
1074                                 })},
1075                                 {std::make_shared<signal_t> (signal_t{
1076                                         "Drivers.Demand.Eng.Percent.Torque",// generic_name
1077                                         8,// bit_position
1078                                         8,// bit_size
1079                                         1.00000f,// factor
1080                                         -125.000f,// offset
1081                                         0,// min_value
1082                                         0,// max_value
1083                                         frequency_clock_t(0.00000f),// frequency
1084                                         true,// send_same
1085                                         false,// force_send_changed
1086                                         {
1087                                         },// states
1088                                         false,// writable
1089                                         nullptr,// decoder
1090                                         nullptr,// encoder
1091                                         false,// received
1092                                         std::make_pair<bool, int>(false, 0),// multiplex
1093                                         static_cast<sign_t>(0),// signed
1094                                         -1,// bit_sign_position
1095                                         "%"// unit
1096                                 })},
1097                                 {std::make_shared<signal_t> (signal_t{
1098                                         "Eng.Demand.Percent.Torque",// generic_name
1099                                         56,// bit_position
1100                                         8,// bit_size
1101                                         1.00000f,// factor
1102                                         -125.000f,// offset
1103                                         0,// min_value
1104                                         0,// max_value
1105                                         frequency_clock_t(0.00000f),// frequency
1106                                         true,// send_same
1107                                         false,// force_send_changed
1108                                         {
1109                                         },// states
1110                                         false,// writable
1111                                         nullptr,// decoder
1112                                         nullptr,// encoder
1113                                         false,// received
1114                                         std::make_pair<bool, int>(false, 0),// multiplex
1115                                         static_cast<sign_t>(0),// signed
1116                                         -1,// bit_sign_position
1117                                         "%"// unit
1118                                 })},
1119                                 {std::make_shared<signal_t> (signal_t{
1120                                         "Eng.Speed",// generic_name
1121                                         24,// bit_position
1122                                         16,// bit_size
1123                                         0.125000f,// factor
1124                                         0.00000f,// offset
1125                                         0,// min_value
1126                                         0,// max_value
1127                                         frequency_clock_t(0.00000f),// frequency
1128                                         true,// send_same
1129                                         false,// force_send_changed
1130                                         {
1131                                         },// states
1132                                         false,// writable
1133                                         nullptr,// decoder
1134                                         nullptr,// encoder
1135                                         false,// received
1136                                         std::make_pair<bool, int>(false, 0),// multiplex
1137                                         static_cast<sign_t>(0),// signed
1138                                         -1,// bit_sign_position
1139                                         "rpm"// unit
1140                                 })},
1141                                 {std::make_shared<signal_t> (signal_t{
1142                                         "Eng.Starter.Mode",// generic_name
1143                                         48,// bit_position
1144                                         4,// bit_size
1145                                         1.00000f,// factor
1146                                         0.00000f,// offset
1147                                         0,// min_value
1148                                         0,// max_value
1149                                         frequency_clock_t(0.00000f),// frequency
1150                                         true,// send_same
1151                                         false,// force_send_changed
1152                                         {
1153                                                 {9,"1011Reserved"},
1154                                                 {14,"error"},
1155                                                 {15,"notAvailable"},
1156                                                 {0,"startNotRqed"},
1157                                                 {2,"starterActiveGearEngaged"},
1158                                                 {1,"starterActiveGearNotEngaged"},
1159                                                 {12,"starterInhibitedReasonUnknown"},
1160                                                 {3,"strtFnshdStrtrNtActvAftrHvngBnA"},
1161                                                 {6,"strtrInhbtdDTDrvlnEnggdOthrTrns"},
1162                                                 {5,"strtrInhbtdDTEngNtReadyForStart"},
1163                                                 {7,"strtrInhbtdDToActiveImmobilizer"},
1164                                                 {4,"strtrInhbtdDToEngAlreadyRunning"},
1165                                                 {8,"strtrInhbtdDueToStarterOvertemp"}
1166                                         },// states
1167                                         false,// writable
1168                                         decoder_t::decode_state,// decoder
1169                                         nullptr,// encoder
1170                                         false,// received
1171                                         std::make_pair<bool, int>(false, 0),// multiplex
1172                                         static_cast<sign_t>(0),// signed
1173                                         -1,// bit_sign_position
1174                                         ""// unit
1175                                 })},
1176                                 {std::make_shared<signal_t> (signal_t{
1177                                         "Eng.Torque.Mode",// generic_name
1178                                         0,// bit_position
1179                                         4,// bit_size
1180                                         1.00000f,// factor
1181                                         0.00000f,// offset
1182                                         0,// min_value
1183                                         0,// max_value
1184                                         frequency_clock_t(0.00000f),// frequency
1185                                         true,// send_same
1186                                         false,// force_send_changed
1187                                         {
1188                                                 {7,"ABS control"},
1189                                                 {5,"ASR control"},
1190                                                 {1,"Accelerator pedal/operator selec"},
1191                                                 {10,"Braking system"},
1192                                                 {2,"Cruise control"},
1193                                                 {9,"High speed governor"},
1194                                                 {0,"Low idle governor/no request (de"},
1195                                                 {15,"Not available"},
1196                                                 {3,"PTO governor"},
1197                                                 {11,"Remote accelerator"},
1198                                                 {4,"Road speed governor"},
1199                                                 {8,"Torque limiting"},
1200                                                 {6,"Transmission control"}
1201                                         },// states
1202                                         false,// writable
1203                                         decoder_t::decode_state,// decoder
1204                                         nullptr,// encoder
1205                                         false,// received
1206                                         std::make_pair<bool, int>(false, 0),// multiplex
1207                                         static_cast<sign_t>(0),// signed
1208                                         -1,// bit_sign_position
1209                                         ""// unit
1210                                 })},
1211                                 {std::make_shared<signal_t> (signal_t{
1212                                         "Src.AddrssOf.Ctrllng.Dvc.Fr.Eng.Cntrl",// generic_name
1213                                         40,// bit_position
1214                                         8,// bit_size
1215                                         1.00000f,// factor
1216                                         0.00000f,// offset
1217                                         0,// min_value
1218                                         0,// max_value
1219                                         frequency_clock_t(0.00000f),// frequency
1220                                         true,// send_same
1221                                         false,// force_send_changed
1222                                         {
1223                                         },// states
1224                                         false,// writable
1225                                         nullptr,// decoder
1226                                         nullptr,// encoder
1227                                         false,// received
1228                                         std::make_pair<bool, int>(false, 0),// multiplex
1229                                         static_cast<sign_t>(0),// signed
1230                                         -1,// bit_sign_position
1231                                         ""// unit
1232                                 })}
1233                         } // end signals vector
1234                 })} // end message_definition entry
1235         }, // end message_definition vector
1236         { // beginning diagnostic_messages_ vector
1237                 {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1238                         4,
1239                         "engine.load",
1240                         0,
1241                         0,
1242                         UNIT::INVALID,
1243                         5.00000f,
1244                         decoder_t::decode_obd2_response,
1245                         nullptr,
1246                         true,
1247                         false
1248                 })}
1249 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1250                         5,
1251                         "engine.coolant.temperature",
1252                         0,
1253                         0,
1254                         UNIT::INVALID,
1255                         1.00000f,
1256                         decoder_t::decode_obd2_response,
1257                         nullptr,
1258                         true,
1259                         false
1260                 })}
1261 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1262                         10,
1263                         "fuel.pressure",
1264                         0,
1265                         0,
1266                         UNIT::INVALID,
1267                         1.00000f,
1268                         decoder_t::decode_obd2_response,
1269                         nullptr,
1270                         true,
1271                         false
1272                 })}
1273 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1274                         11,
1275                         "intake.manifold.pressure",
1276                         0,
1277                         0,
1278                         UNIT::INVALID,
1279                         1.00000f,
1280                         decoder_t::decode_obd2_response,
1281                         nullptr,
1282                         true,
1283                         false
1284                 })}
1285 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1286                         12,
1287                         "engine.speed",
1288                         0,
1289                         0,
1290                         UNIT::INVALID,
1291                         5.00000f,
1292                         decoder_t::decode_obd2_response,
1293                         nullptr,
1294                         true,
1295                         false
1296                 })}
1297 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1298                         13,
1299                         "vehicle.speed",
1300                         0,
1301                         0,
1302                         UNIT::INVALID,
1303                         5.00000f,
1304                         decoder_t::decode_obd2_response,
1305                         nullptr,
1306                         true,
1307                         false
1308                 })}
1309 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1310                         15,
1311                         "intake.air.temperature",
1312                         0,
1313                         0,
1314                         UNIT::INVALID,
1315                         1.00000f,
1316                         decoder_t::decode_obd2_response,
1317                         nullptr,
1318                         true,
1319                         false
1320                 })}
1321 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1322                         16,
1323                         "mass.airflow",
1324                         0,
1325                         0,
1326                         UNIT::INVALID,
1327                         5.00000f,
1328                         decoder_t::decode_obd2_response,
1329                         nullptr,
1330                         true,
1331                         false
1332                 })}
1333 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1334                         17,
1335                         "throttle.position",
1336                         0,
1337                         0,
1338                         UNIT::INVALID,
1339                         5.00000f,
1340                         decoder_t::decode_obd2_response,
1341                         nullptr,
1342                         true,
1343                         false
1344                 })}
1345 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1346                         31,
1347                         "running.time",
1348                         0,
1349                         0,
1350                         UNIT::INVALID,
1351                         1.00000f,
1352                         decoder_t::decode_obd2_response,
1353                         nullptr,
1354                         true,
1355                         false
1356                 })}
1357 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1358                         45,
1359                         "EGR.error",
1360                         0,
1361                         0,
1362                         UNIT::INVALID,
1363                         0.00000f,
1364                         decoder_t::decode_obd2_response,
1365                         nullptr,
1366                         true,
1367                         false
1368                 })}
1369 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1370                         47,
1371                         "fuel.level",
1372                         0,
1373                         0,
1374                         UNIT::INVALID,
1375                         1.00000f,
1376                         decoder_t::decode_obd2_response,
1377                         nullptr,
1378                         true,
1379                         false
1380                 })}
1381 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1382                         51,
1383                         "barometric.pressure",
1384                         0,
1385                         0,
1386                         UNIT::INVALID,
1387                         1.00000f,
1388                         decoder_t::decode_obd2_response,
1389                         nullptr,
1390                         true,
1391                         false
1392                 })}
1393 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1394                         70,
1395                         "ambient.air.temperature",
1396                         0,
1397                         0,
1398                         UNIT::INVALID,
1399                         1.00000f,
1400                         decoder_t::decode_obd2_response,
1401                         nullptr,
1402                         true,
1403                         false
1404                 })}
1405 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1406                         76,
1407                         "commanded.throttle.position",
1408                         0,
1409                         0,
1410                         UNIT::INVALID,
1411                         1.00000f,
1412                         decoder_t::decode_obd2_response,
1413                         nullptr,
1414                         true,
1415                         false
1416                 })}
1417 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1418                         82,
1419                         "ethanol.fuel.percentage",
1420                         0,
1421                         0,
1422                         UNIT::INVALID,
1423                         1.00000f,
1424                         decoder_t::decode_obd2_response,
1425                         nullptr,
1426                         true,
1427                         false
1428                 })}
1429 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1430                         90,
1431                         "accelerator.pedal.position",
1432                         0,
1433                         0,
1434                         UNIT::INVALID,
1435                         5.00000f,
1436                         decoder_t::decode_obd2_response,
1437                         nullptr,
1438                         true,
1439                         false
1440                 })}
1441 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1442                         91,
1443                         "hybrid.battery-pack.remaining.life",
1444                         0,
1445                         0,
1446                         UNIT::INVALID,
1447                         5.00000f,
1448                         decoder_t::decode_obd2_response,
1449                         nullptr,
1450                         true,
1451                         false
1452                 })}
1453 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1454                         92,
1455                         "engine.oil.temperature",
1456                         0,
1457                         0,
1458                         UNIT::INVALID,
1459                         1.00000f,
1460                         decoder_t::decode_obd2_response,
1461                         nullptr,
1462                         true,
1463                         false
1464                 })}
1465 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1466                         94,
1467                         "engine.fuel.rate",
1468                         0,
1469                         0,
1470                         UNIT::INVALID,
1471                         1.00000f,
1472                         decoder_t::decode_obd2_response,
1473                         nullptr,
1474                         true,
1475                         false
1476                 })}
1477 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1478                         99,
1479                         "engine.torque",
1480                         0,
1481                         0,
1482                         UNIT::INVALID,
1483                         1.00000f,
1484                         decoder_t::decode_obd2_response,
1485                         nullptr,
1486                         true,
1487                         false
1488                 })}
1489
1490         } // end diagnostic_messages_ vector
1491 }); // end message_set entry
1492
1493 CTLP_ONLOAD(plugin, handle) {
1494         afb_api_t api = (afb_api_t) plugin->api;
1495         CtlConfigT* CtlConfig = (CtlConfigT*) afb_api_get_userdata(api);
1496         application_t* app = (application_t*) getExternalData(CtlConfig);
1497
1498         return app->add_message_set(cms);
1499 }
1500
1501
1502 }