examples/agl-vcar/agl-vcar-signals.cpp

   1 #include <binding/application.hpp>
   2 #include <can/can-decoder.hpp>
   3 #include <can/can-encoder.hpp>
   4
   5 extern "C" {
   6 CTLP_CAPI_REGISTER("agl-virtual-car");
   7
   8 std::shared_ptr<message_set_t> cms = std::make_shared<message_set_t>(message_set_t{0,"AGL Virtual Car",
   9         { // beginning message_definition_ vector
  10                 {std::make_shared<message_definition_t>(message_definition_t{"ls",0x21,"",8,0,frequency_clock_t(5.00000f),true,
  11                         { // beginning signals vector
  12                                 {std::make_shared<signal_t> (signal_t{
  13                                         "steering_wheel.cruise.cancel",// generic_name
  14                                         52,// bit_position
  15                                         1,// bit_size
  16                                         1.00000f,// factor
  17                                         0.00000f,// offset
  18                                         0,// min_value
  19                                         0,// max_value
  20                                         frequency_clock_t(0.00000f),// frequency
  21                                         true,// send_same
  22                                         false,// force_send_changed
  23                                         {
  24                                         },// states
  25                                         false,// writable
  26                                         decoder_t::decode_boolean,// decoder
  27                                         nullptr,// encoder
  28                                         false,// received
  29                                         std::make_pair<bool, int>(false, 0),// multiplex
  30                                         static_cast<sign_t>(0),// signed
  31                                         -1,// bit_sign_position
  32                                         ""// unit
  33                                 })},
  34                                 {std::make_shared<signal_t> (signal_t{
  35                                         "steering_wheel.cruise.distance",// generic_name
  36                                         55,// bit_position
  37                                         1,// bit_size
  38                                         1.00000f,// factor
  39                                         0.00000f,// offset
  40                                         0,// min_value
  41                                         0,// max_value
  42                                         frequency_clock_t(0.00000f),// frequency
  43                                         true,// send_same
  44                                         false,// force_send_changed
  45                                         {
  46                                         },// states
  47                                         false,// writable
  48                                         decoder_t::decode_boolean,// decoder
  49                                         nullptr,// encoder
  50                                         false,// received
  51                                         std::make_pair<bool, int>(false, 0),// multiplex
  52                                         static_cast<sign_t>(0),// signed
  53                                         -1,// bit_sign_position
  54                                         ""// unit
  55                                 })},
  56                                 {std::make_shared<signal_t> (signal_t{
  57                                         "steering_wheel.cruise.enable",// generic_name
  58                                         48,// bit_position
  59                                         1,// bit_size
  60                                         1.00000f,// factor
  61                                         0.00000f,// offset
  62                                         0,// min_value
  63                                         0,// max_value
  64                                         frequency_clock_t(0.00000f),// frequency
  65                                         true,// send_same
  66                                         false,// force_send_changed
  67                                         {
  68                                         },// states
  69                                         false,// writable
  70                                         decoder_t::decode_boolean,// decoder
  71                                         nullptr,// encoder
  72                                         false,// received
  73                                         std::make_pair<bool, int>(false, 0),// multiplex
  74                                         static_cast<sign_t>(0),// signed
  75                                         -1,// bit_sign_position
  76                                         ""// unit
  77                                 })},
  78                                 {std::make_shared<signal_t> (signal_t{
  79                                         "steering_wheel.cruise.limit",// generic_name
  80                                         54,// bit_position
  81                                         1,// bit_size
  82                                         1.00000f,// factor
  83                                         0.00000f,// offset
  84                                         0,// min_value
  85                                         0,// max_value
  86                                         frequency_clock_t(0.00000f),// frequency
  87                                         true,// send_same
  88                                         false,// force_send_changed
  89                                         {
  90                                         },// states
  91                                         false,// writable
  92                                         decoder_t::decode_boolean,// decoder
  93                                         nullptr,// encoder
  94                                         false,// received
  95                                         std::make_pair<bool, int>(false, 0),// multiplex
  96                                         static_cast<sign_t>(0),// signed
  97                                         -1,// bit_sign_position
  98                                         ""// unit
  99                                 })},
 100                                 {std::make_shared<signal_t> (signal_t{
 101                                         "steering_wheel.cruise.resume",// generic_name
 102                                         49,// bit_position
 103                                         1,// bit_size
 104                                         1.00000f,// factor
 105                                         0.00000f,// offset
 106                                         0,// min_value
 107                                         0,// max_value
 108                                         frequency_clock_t(0.00000f),// frequency
 109                                         true,// send_same
 110                                         false,// force_send_changed
 111                                         {
 112                                         },// states
 113                                         false,// writable
 114                                         decoder_t::decode_boolean,// decoder
 115                                         nullptr,// encoder
 116                                         false,// received
 117                                         std::make_pair<bool, int>(false, 0),// multiplex
 118                                         static_cast<sign_t>(0),// signed
 119                                         -1,// bit_sign_position
 120                                         ""// unit
 121                                 })},
 122                                 {std::make_shared<signal_t> (signal_t{
 123                                         "steering_wheel.cruise.set",// generic_name
 124                                         51,// bit_position
 125                                         1,// bit_size
 126                                         1.00000f,// factor
 127                                         0.00000f,// offset
 128                                         0,// min_value
 129                                         0,// max_value
 130                                         frequency_clock_t(0.00000f),// frequency
 131                                         true,// send_same
 132                                         false,// force_send_changed
 133                                         {
 134                                         },// states
 135                                         false,// writable
 136                                         decoder_t::decode_boolean,// decoder
 137                                         nullptr,// encoder
 138                                         false,// received
 139                                         std::make_pair<bool, int>(false, 0),// multiplex
 140                                         static_cast<sign_t>(0),// signed
 141                                         -1,// bit_sign_position
 142                                         ""// unit
 143                                 })},
 144                                 {std::make_shared<signal_t> (signal_t{
 145                                         "steering_wheel.horn",// generic_name
 146                                         56,// bit_position
 147                                         1,// bit_size
 148                                         1.00000f,// factor
 149                                         0.00000f,// offset
 150                                         0,// min_value
 151                                         0,// max_value
 152                                         frequency_clock_t(0.00000f),// frequency
 153                                         true,// send_same
 154                                         false,// force_send_changed
 155                                         {
 156                                         },// states
 157                                         false,// writable
 158                                         decoder_t::decode_boolean,// decoder
 159                                         nullptr,// encoder
 160                                         false,// received
 161                                         std::make_pair<bool, int>(false, 0),// multiplex
 162                                         static_cast<sign_t>(0),// signed
 163                                         -1,// bit_sign_position
 164                                         ""// unit
 165                                 })},
 166                                 {std::make_shared<signal_t> (signal_t{
 167                                         "steering_wheel.info",// generic_name
 168                                         38,// bit_position
 169                                         1,// bit_size
 170                                         1.00000f,// factor
 171                                         0.00000f,// offset
 172                                         0,// min_value
 173                                         0,// max_value
 174                                         frequency_clock_t(0.00000f),// frequency
 175                                         true,// send_same
 176                                         false,// force_send_changed
 177                                         {
 178                                         },// states
 179                                         false,// writable
 180                                         decoder_t::decode_boolean,// decoder
 181                                         nullptr,// encoder
 182                                         false,// received
 183                                         std::make_pair<bool, int>(false, 0),// multiplex
 184                                         static_cast<sign_t>(0),// signed
 185                                         -1,// bit_sign_position
 186                                         ""// unit
 187                                 })},
 188                                 {std::make_shared<signal_t> (signal_t{
 189                                         "steering_wheel.lane_departure_warning",// generic_name
 190                                         63,// bit_position
 191                                         1,// bit_size
 192                                         1.00000f,// factor
 193                                         0.00000f,// offset
 194                                         0,// min_value
 195                                         0,// max_value
 196                                         frequency_clock_t(0.00000f),// frequency
 197                                         true,// send_same
 198                                         false,// force_send_changed
 199                                         {
 200                                         },// states
 201                                         false,// writable
 202                                         decoder_t::decode_boolean,// decoder
 203                                         nullptr,// encoder
 204                                         false,// received
 205                                         std::make_pair<bool, int>(false, 0),// multiplex
 206                                         static_cast<sign_t>(0),// signed
 207                                         -1,// bit_sign_position
 208                                         ""// unit
 209                                 })},
 210                                 {std::make_shared<signal_t> (signal_t{
 211                                         "steering_wheel.mode",// generic_name
 212                                         34,// bit_position
 213                                         1,// bit_size
 214                                         1.00000f,// factor
 215                                         0.00000f,// offset
 216                                         0,// min_value
 217                                         0,// max_value
 218                                         frequency_clock_t(0.00000f),// frequency
 219                                         true,// send_same
 220                                         false,// force_send_changed
 221                                         {
 222                                         },// states
 223                                         false,// writable
 224                                         decoder_t::decode_boolean,// decoder
 225                                         nullptr,// encoder
 226                                         false,// received
 227                                         std::make_pair<bool, int>(false, 0),// multiplex
 228                                         static_cast<sign_t>(0),// signed
 229                                         -1,// bit_sign_position
 230                                         ""// unit
 231                                 })},
 232                                 {std::make_shared<signal_t> (signal_t{
 233                                         "steering_wheel.next",// generic_name
 234                                         36,// bit_position
 235                                         1,// bit_size
 236                                         1.00000f,// factor
 237                                         0.00000f,// offset
 238                                         0,// min_value
 239                                         0,// max_value
 240                                         frequency_clock_t(0.00000f),// frequency
 241                                         true,// send_same
 242                                         false,// force_send_changed
 243                                         {
 244                                         },// states
 245                                         false,// writable
 246                                         decoder_t::decode_boolean,// decoder
 247                                         nullptr,// encoder
 248                                         false,// received
 249                                         std::make_pair<bool, int>(false, 0),// multiplex
 250                                         static_cast<sign_t>(0),// signed
 251                                         -1,// bit_sign_position
 252                                         ""// unit
 253                                 })},
 254                                 {std::make_shared<signal_t> (signal_t{
 255                                         "steering_wheel.phone.call",// generic_name
 256                                         47,// bit_position
 257                                         1,// bit_size
 258                                         1.00000f,// factor
 259                                         0.00000f,// offset
 260                                         0,// min_value
 261                                         0,// max_value
 262                                         frequency_clock_t(0.00000f),// frequency
 263                                         true,// send_same
 264                                         false,// force_send_changed
 265                                         {
 266                                         },// states
 267                                         false,// writable
 268                                         decoder_t::decode_boolean,// decoder
 269                                         nullptr,// encoder
 270                                         false,// received
 271                                         std::make_pair<bool, int>(false, 0),// multiplex
 272                                         static_cast<sign_t>(0),// signed
 273                                         -1,// bit_sign_position
 274                                         ""// unit
 275                                 })},
 276                                 {std::make_shared<signal_t> (signal_t{
 277                                         "steering_wheel.phone.hangup",// generic_name
 278                                         46,// bit_position
 279                                         1,// bit_size
 280                                         1.00000f,// factor
 281                                         0.00000f,// offset
 282                                         0,// min_value
 283                                         0,// max_value
 284                                         frequency_clock_t(0.00000f),// frequency
 285                                         true,// send_same
 286                                         false,// force_send_changed
 287                                         {
 288                                         },// states
 289                                         false,// writable
 290                                         decoder_t::decode_boolean,// decoder
 291                                         nullptr,// encoder
 292                                         false,// received
 293                                         std::make_pair<bool, int>(false, 0),// multiplex
 294                                         static_cast<sign_t>(0),// signed
 295                                         -1,// bit_sign_position
 296                                         ""// unit
 297                                 })},
 298                                 {std::make_shared<signal_t> (signal_t{
 299                                         "steering_wheel.previous",// generic_name
 300                                         32,// bit_position
 301                                         1,// bit_size
 302                                         1.00000f,// factor
 303                                         0.00000f,// offset
 304                                         0,// min_value
 305                                         0,// max_value
 306                                         frequency_clock_t(0.00000f),// frequency
 307                                         true,// send_same
 308                                         false,// force_send_changed
 309                                         {
 310                                         },// states
 311                                         false,// writable
 312                                         decoder_t::decode_boolean,// decoder
 313                                         nullptr,// encoder
 314                                         false,// received
 315                                         std::make_pair<bool, int>(false, 0),// multiplex
 316                                         static_cast<sign_t>(0),// signed
 317                                         -1,// bit_sign_position
 318                                         ""// unit
 319                                 })},
 320                                 {std::make_shared<signal_t> (signal_t{
 321                                         "steering_wheel.voice",// generic_name
 322                                         45,// bit_position
 323                                         1,// bit_size
 324                                         1.00000f,// factor
 325                                         0.00000f,// offset
 326                                         0,// min_value
 327                                         0,// max_value
 328                                         frequency_clock_t(0.00000f),// frequency
 329                                         true,// send_same
 330                                         false,// force_send_changed
 331                                         {
 332                                         },// states
 333                                         false,// writable
 334                                         decoder_t::decode_boolean,// decoder
 335                                         nullptr,// encoder
 336                                         false,// received
 337                                         std::make_pair<bool, int>(false, 0),// multiplex
 338                                         static_cast<sign_t>(0),// signed
 339                                         -1,// bit_sign_position
 340                                         ""// unit
 341                                 })},
 342                                 {std::make_shared<signal_t> (signal_t{
 343                                         "steering_wheel.volume.down",// generic_name
 344                                         35,// bit_position
 345                                         1,// bit_size
 346                                         1.00000f,// factor
 347                                         0.00000f,// offset
 348                                         0,// min_value
 349                                         0,// max_value
 350                                         frequency_clock_t(0.00000f),// frequency
 351                                         true,// send_same
 352                                         false,// force_send_changed
 353                                         {
 354                                         },// states
 355                                         false,// writable
 356                                         decoder_t::decode_boolean,// decoder
 357                                         nullptr,// encoder
 358                                         false,// received
 359                                         std::make_pair<bool, int>(false, 0),// multiplex
 360                                         static_cast<sign_t>(0),// signed
 361                                         -1,// bit_sign_position
 362                                         ""// unit
 363                                 })},
 364                                 {std::make_shared<signal_t> (signal_t{
 365                                         "steering_wheel.volume.mute",// generic_name
 366                                         39,// bit_position
 367                                         1,// bit_size
 368                                         1.00000f,// factor
 369                                         0.00000f,// offset
 370                                         0,// min_value
 371                                         0,// max_value
 372                                         frequency_clock_t(0.00000f),// frequency
 373                                         true,// send_same
 374                                         false,// force_send_changed
 375                                         {
 376                                         },// states
 377                                         false,// writable
 378                                         decoder_t::decode_boolean,// decoder
 379                                         nullptr,// encoder
 380                                         false,// received
 381                                         std::make_pair<bool, int>(false, 0),// multiplex
 382                                         static_cast<sign_t>(0),// signed
 383                                         -1,// bit_sign_position
 384                                         ""// unit
 385                                 })},
 386                                 {std::make_shared<signal_t> (signal_t{
 387                                         "steering_wheel.volume.up",// generic_name
 388                                         33,// bit_position
 389                                         1,// bit_size
 390                                         1.00000f,// factor
 391                                         0.00000f,// offset
 392                                         0,// min_value
 393                                         0,// max_value
 394                                         frequency_clock_t(0.00000f),// frequency
 395                                         true,// send_same
 396                                         false,// force_send_changed
 397                                         {
 398                                         },// states
 399                                         false,// writable
 400                                         decoder_t::decode_boolean,// decoder
 401                                         nullptr,// encoder
 402                                         false,// received
 403                                         std::make_pair<bool, int>(false, 0),// multiplex
 404                                         static_cast<sign_t>(0),// signed
 405                                         -1,// bit_sign_position
 406                                         ""// unit
 407                                 })}
 408                         } // end signals vector
 409                 })} // end message_definition entry
 410 ,               {std::make_shared<message_definition_t>(message_definition_t{"ls",0x30,"",8,0,frequency_clock_t(5.00000f),true,
 411                         { // beginning signals vector
 412                                 {std::make_shared<signal_t> (signal_t{
 413                                         "hvac.fan.speed",// generic_name
 414                                         32,// bit_position
 415                                         8,// bit_size
 416                                         23.5294f,// factor
 417                                         0.00000f,// offset
 418                                         0,// min_value
 419                                         0,// max_value
 420                                         frequency_clock_t(0.00000f),// frequency
 421                                         true,// send_same
 422                                         false,// force_send_changed
 423                                         {
 424                                         },// states
 425                                         true,// writable
 426                                         nullptr,// decoder
 427                                         nullptr,// encoder
 428                                         false,// received
 429                                         std::make_pair<bool, int>(false, 0),// multiplex
 430                                         static_cast<sign_t>(0),// signed
 431                                         -1,// bit_sign_position
 432                                         ""// unit
 433                                 })},
 434                                 {std::make_shared<signal_t> (signal_t{
 435                                         "hvac.temperature.left",// generic_name
 436                                         0,// bit_position
 437                                         8,// bit_size
 438                                         1.00000f,// factor
 439                                         0.00000f,// offset
 440                                         0,// min_value
 441                                         0,// max_value
 442                                         frequency_clock_t(0.00000f),// frequency
 443                                         true,// send_same
 444                                         false,// force_send_changed
 445                                         {
 446                                         },// states
 447                                         true,// writable
 448                                         nullptr,// decoder
 449                                         nullptr,// encoder
 450                                         false,// received
 451                                         std::make_pair<bool, int>(false, 0),// multiplex
 452                                         static_cast<sign_t>(0),// signed
 453                                         -1,// bit_sign_position
 454                                         ""// unit
 455                                 })},
 456                                 {std::make_shared<signal_t> (signal_t{
 457                                         "hvac.temperature.right",// generic_name
 458                                         8,// bit_position
 459                                         8,// bit_size
 460                                         1.00000f,// factor
 461                                         0.00000f,// offset
 462                                         0,// min_value
 463                                         0,// max_value
 464                                         frequency_clock_t(0.00000f),// frequency
 465                                         true,// send_same
 466                                         false,// force_send_changed
 467                                         {
 468                                         },// states
 469                                         true,// writable
 470                                         nullptr,// decoder
 471                                         nullptr,// encoder
 472                                         false,// received
 473                                         std::make_pair<bool, int>(false, 0),// multiplex
 474                                         static_cast<sign_t>(0),// signed
 475                                         -1,// bit_sign_position
 476                                         ""// unit
 477                                 })},
 478                                 {std::make_shared<signal_t> (signal_t{
 479                                         "hvac.temperature.average",// generic_name
 480                                         16,// bit_position
 481                                         8,// bit_size
 482                                         1.00000f,// factor
 483                                         0.00000f,// offset
 484                                         0,// min_value
 485                                         0,// max_value
 486                                         frequency_clock_t(0.00000f),// frequency
 487                                         true,// send_same
 488                                         false,// force_send_changed
 489                                         {
 490                                         },// states
 491                                         true,// writable
 492                                         nullptr,// decoder
 493                                         nullptr,// encoder
 494                                         false,// received
 495                                         std::make_pair<bool, int>(false, 0),// multiplex
 496                                         static_cast<sign_t>(0),// signed
 497                                         -1,// bit_sign_position
 498                                         ""// unit
 499                                 })}
 500                         } // end signals vector
 501                 })} // end message_definition entry
 502 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x3D9,"",8,0,frequency_clock_t(5.00000f),true,
 503                         { // beginning signals vector
 504                                 {std::make_shared<signal_t> (signal_t{
 505                                         "engine.speed",// generic_name
 506                                         16,// bit_position
 507                                         16,// bit_size
 508                                         0.250000f,// factor
 509                                         0.00000f,// offset
 510                                         0,// min_value
 511                                         0,// max_value
 512                                         frequency_clock_t(0.00000f),// frequency
 513                                         true,// send_same
 514                                         false,// force_send_changed
 515                                         {
 516                                         },// states
 517                                         true,// writable
 518                                         nullptr,// decoder
 519                                         nullptr,// encoder
 520                                         false,// received
 521                                         std::make_pair<bool, int>(false, 0),// multiplex
 522                                         static_cast<sign_t>(0),// signed
 523                                         -1,// bit_sign_position
 524                                         ""// unit
 525                                 })},
 526                                 {std::make_shared<signal_t> (signal_t{
 527                                         "fuel.level.low",// generic_name
 528                                         55,// bit_position
 529                                         1,// bit_size
 530                                         1.00000f,// factor
 531                                         0.00000f,// offset
 532                                         0,// min_value
 533                                         0,// max_value
 534                                         frequency_clock_t(0.00000f),// frequency
 535                                         true,// send_same
 536                                         false,// force_send_changed
 537                                         {
 538                                         },// states
 539                                         true,// writable
 540                                         decoder_t::decode_boolean,// decoder
 541                                         nullptr,// encoder
 542                                         false,// received
 543                                         std::make_pair<bool, int>(false, 0),// multiplex
 544                                         static_cast<sign_t>(0),// signed
 545                                         -1,// bit_sign_position
 546                                         ""// unit
 547                                 })},
 548                                 {std::make_shared<signal_t> (signal_t{
 549                                         "fuel.level",// generic_name
 550                                         8,// bit_position
 551                                         8,// bit_size
 552                                         0.392157f,// factor
 553                                         0.00000f,// offset
 554                                         0,// min_value
 555                                         0,// max_value
 556                                         frequency_clock_t(0.00000f),// frequency
 557                                         true,// send_same
 558                                         false,// force_send_changed
 559                                         {
 560                                         },// states
 561                                         true,// writable
 562                                         nullptr,// decoder
 563                                         nullptr,// encoder
 564                                         false,// received
 565                                         std::make_pair<bool, int>(false, 0),// multiplex
 566                                         static_cast<sign_t>(0),// signed
 567                                         -1,// bit_sign_position
 568                                         ""// unit
 569                                 })}
 570                         } // end signals vector
 571                 })} // end message_definition entry
 572 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x3DA,"",8,2,frequency_clock_t(5.00000f),true,
 573                         { // beginning signals vector
 574                                 {std::make_shared<signal_t> (signal_t{
 575                                         "fd.engine.speed",// generic_name
 576                                         16,// bit_position
 577                                         16,// bit_size
 578                                         0.250000f,// factor
 579                                         0.00000f,// offset
 580                                         0,// min_value
 581                                         0,// max_value
 582                                         frequency_clock_t(0.00000f),// frequency
 583                                         true,// send_same
 584                                         false,// force_send_changed
 585                                         {
 586                                         },// states
 587                                         true,// writable
 588                                         nullptr,// decoder
 589                                         nullptr,// encoder
 590                                         false,// received
 591                                         std::make_pair<bool, int>(false, 0),// multiplex
 592                                         static_cast<sign_t>(0),// signed
 593                                         -1,// bit_sign_position
 594                                         ""// unit
 595                                 })},
 596                                 {std::make_shared<signal_t> (signal_t{
 597                                         "fd.fuel.level.low",// generic_name
 598                                         55,// bit_position
 599                                         1,// bit_size
 600                                         1.00000f,// factor
 601                                         0.00000f,// offset
 602                                         0,// min_value
 603                                         0,// max_value
 604                                         frequency_clock_t(0.00000f),// frequency
 605                                         true,// send_same
 606                                         false,// force_send_changed
 607                                         {
 608                                         },// states
 609                                         true,// writable
 610                                         decoder_t::decode_boolean,// decoder
 611                                         nullptr,// encoder
 612                                         false,// received
 613                                         std::make_pair<bool, int>(false, 0),// multiplex
 614                                         static_cast<sign_t>(0),// signed
 615                                         -1,// bit_sign_position
 616                                         ""// unit
 617                                 })},
 618                                 {std::make_shared<signal_t> (signal_t{
 619                                         "fd.fuel.level",// generic_name
 620                                         8,// bit_position
 621                                         8,// bit_size
 622                                         0.392157f,// factor
 623                                         0.00000f,// offset
 624                                         0,// min_value
 625                                         0,// max_value
 626                                         frequency_clock_t(0.00000f),// frequency
 627                                         true,// send_same
 628                                         false,// force_send_changed
 629                                         {
 630                                         },// states
 631                                         true,// writable
 632                                         nullptr,// decoder
 633                                         nullptr,// encoder
 634                                         false,// received
 635                                         std::make_pair<bool, int>(false, 0),// multiplex
 636                                         static_cast<sign_t>(0),// signed
 637                                         -1,// bit_sign_position
 638                                         ""// unit
 639                                 })}
 640                         } // end signals vector
 641                 })} // end message_definition entry
 642 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x3E9,"",8,0,frequency_clock_t(5.00000f),true,
 643                         { // beginning signals vector
 644                                 {std::make_shared<signal_t> (signal_t{
 645                                         "vehicle.average.speed",// generic_name
 646                                         0,// bit_position
 647                                         15,// bit_size
 648                                         0.0156250f,// factor
 649                                         0.00000f,// offset
 650                                         0,// min_value
 651                                         0,// max_value
 652                                         frequency_clock_t(0.00000f),// frequency
 653                                         true,// send_same
 654                                         false,// force_send_changed
 655                                         {
 656                                         },// states
 657                                         false,// writable
 658                                         nullptr,// decoder
 659                                         nullptr,// encoder
 660                                         false,// received
 661                                         std::make_pair<bool, int>(false, 0),// multiplex
 662                                         static_cast<sign_t>(0),// signed
 663                                         -1,// bit_sign_position
 664                                         ""// unit
 665                                 })}
 666                         } // end signals vector
 667                 })} // end message_definition entry
 668 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x4D1,"",8,0,frequency_clock_t(5.00000f),true,
 669                         { // beginning signals vector
 670                                 {std::make_shared<signal_t> (signal_t{
 671                                         "engine.oil.temp",// generic_name
 672                                         16,// bit_position
 673                                         8,// bit_size
 674                                         1.00000f,// factor
 675                                         0.00000f,// offset
 676                                         0,// min_value
 677                                         0,// max_value
 678                                         frequency_clock_t(0.00000f),// frequency
 679                                         true,// send_same
 680                                         false,// force_send_changed
 681                                         {
 682                                         },// states
 683                                         true,// writable
 684                                         nullptr,// decoder
 685                                         nullptr,// encoder
 686                                         false,// received
 687                                         std::make_pair<bool, int>(false, 0),// multiplex
 688                                         static_cast<sign_t>(0),// signed
 689                                         -1,// bit_sign_position
 690                                         ""// unit
 691                                 })},
 692                                 {std::make_shared<signal_t> (signal_t{
 693                                         "engine.oil.temp.high",// generic_name
 694                                         7,// bit_position
 695                                         1,// bit_size
 696                                         1.00000f,// factor
 697                                         0.00000f,// offset
 698                                         0,// min_value
 699                                         0,// max_value
 700                                         frequency_clock_t(0.00000f),// frequency
 701                                         true,// send_same
 702                                         false,// force_send_changed
 703                                         {
 704                                         },// states
 705                                         true,// writable
 706                                         decoder_t::decode_boolean,// decoder
 707                                         nullptr,// encoder
 708                                         false,// received
 709                                         std::make_pair<bool, int>(false, 0),// multiplex
 710                                         static_cast<sign_t>(0),// signed
 711                                         -1,// bit_sign_position
 712                                         ""// unit
 713                                 })}
 714                         } // end signals vector
 715                 })} // end message_definition entry
 716 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x620,"",8,0,frequency_clock_t(5.00000f),true,
 717                         { // beginning signals vector
 718                                 {std::make_shared<signal_t> (signal_t{
 719                                         "doors.boot.open",// generic_name
 720                                         47,// bit_position
 721                                         1,// bit_size
 722                                         1.00000f,// factor
 723                                         0.00000f,// offset
 724                                         0,// min_value
 725                                         0,// max_value
 726                                         frequency_clock_t(0.00000f),// frequency
 727                                         true,// send_same
 728                                         false,// force_send_changed
 729                                         {
 730                                         },// states
 731                                         true,// writable
 732                                         decoder_t::decode_boolean,// decoder
 733                                         nullptr,// encoder
 734                                         false,// received
 735                                         std::make_pair<bool, int>(false, 0),// multiplex
 736                                         static_cast<sign_t>(0),// signed
 737                                         -1,// bit_sign_position
 738                                         ""// unit
 739                                 })},
 740                                 {std::make_shared<signal_t> (signal_t{
 741                                         "doors.front_left.open",// generic_name
 742                                         43,// bit_position
 743                                         1,// bit_size
 744                                         1.00000f,// factor
 745                                         0.00000f,// offset
 746                                         0,// min_value
 747                                         0,// max_value
 748                                         frequency_clock_t(0.00000f),// frequency
 749                                         true,// send_same
 750                                         false,// force_send_changed
 751                                         {
 752                                         },// states
 753                                         true,// writable
 754                                         decoder_t::decode_boolean,// decoder
 755                                         nullptr,// encoder
 756                                         false,// received
 757                                         std::make_pair<bool, int>(false, 0),// multiplex
 758                                         static_cast<sign_t>(0),// signed
 759                                         -1,// bit_sign_position
 760                                         ""// unit
 761                                 })},
 762                                 {std::make_shared<signal_t> (signal_t{
 763                                         "doors.front_right.open",// generic_name
 764                                         44,// bit_position
 765                                         1,// bit_size
 766                                         1.00000f,// factor
 767                                         0.00000f,// offset
 768                                         0,// min_value
 769                                         0,// max_value
 770                                         frequency_clock_t(0.00000f),// frequency
 771                                         true,// send_same
 772                                         false,// force_send_changed
 773                                         {
 774                                         },// states
 775                                         true,// writable
 776                                         decoder_t::decode_boolean,// decoder
 777                                         nullptr,// encoder
 778                                         false,// received
 779                                         std::make_pair<bool, int>(false, 0),// multiplex
 780                                         static_cast<sign_t>(0),// signed
 781                                         -1,// bit_sign_position
 782                                         ""// unit
 783                                 })},
 784                                 {std::make_shared<signal_t> (signal_t{
 785                                         "doors.rear_left.open",// generic_name
 786                                         46,// bit_position
 787                                         1,// bit_size
 788                                         1.00000f,// factor
 789                                         0.00000f,// offset
 790                                         0,// min_value
 791                                         0,// max_value
 792                                         frequency_clock_t(0.00000f),// frequency
 793                                         true,// send_same
 794                                         false,// force_send_changed
 795                                         {
 796                                         },// states
 797                                         true,// writable
 798                                         decoder_t::decode_boolean,// decoder
 799                                         nullptr,// encoder
 800                                         false,// received
 801                                         std::make_pair<bool, int>(false, 0),// multiplex
 802                                         static_cast<sign_t>(0),// signed
 803                                         -1,// bit_sign_position
 804                                         ""// unit
 805                                 })},
 806                                 {std::make_shared<signal_t> (signal_t{
 807                                         "doors.rear_right.open",// generic_name
 808                                         45,// bit_position
 809                                         4,// bit_size
 810                                         1.00000f,// factor
 811                                         0.00000f,// offset
 812                                         0,// min_value
 813                                         0,// max_value
 814                                         frequency_clock_t(0.00000f),// frequency
 815                                         true,// send_same
 816                                         false,// force_send_changed
 817                                         {
 818                                         },// states
 819                                         true,// writable
 820                                         decoder_t::decode_boolean,// decoder
 821                                         nullptr,// encoder
 822                                         false,// received
 823                                         std::make_pair<bool, int>(false, 0),// multiplex
 824                                         static_cast<sign_t>(0),// signed
 825                                         -1,// bit_sign_position
 826                                         ""// unit
 827                                 })}
 828                         } // end signals vector
 829                 })} // end message_definition entry
 830 ,               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x799,"",8,0,frequency_clock_t(5.00000f),true,
 831                         { // beginning signals vector
 832                                 {std::make_shared<signal_t> (signal_t{
 833                                         "windows.front_left.open",// generic_name
 834                                         43,// bit_position
 835                                         1,// bit_size
 836                                         1.00000f,// factor
 837                                         0.00000f,// offset
 838                                         0,// min_value
 839                                         0,// max_value
 840                                         frequency_clock_t(0.00000f),// frequency
 841                                         true,// send_same
 842                                         false,// force_send_changed
 843                                         {
 844                                         },// states
 845                                         true,// writable
 846                                         decoder_t::decode_boolean,// decoder
 847                                         nullptr,// encoder
 848                                         false,// received
 849                                         std::make_pair<bool, int>(false, 0),// multiplex
 850                                         static_cast<sign_t>(0),// signed
 851                                         -1,// bit_sign_position
 852                                         ""// unit
 853                                 })},
 854                                 {std::make_shared<signal_t> (signal_t{
 855                                         "windows.front_right.open",// generic_name
 856                                         44,// bit_position
 857                                         1,// bit_size
 858                                         1.00000f,// factor
 859                                         0.00000f,// offset
 860                                         0,// min_value
 861                                         0,// max_value
 862                                         frequency_clock_t(0.00000f),// frequency
 863                                         true,// send_same
 864                                         false,// force_send_changed
 865                                         {
 866                                         },// states
 867                                         true,// writable
 868                                         decoder_t::decode_boolean,// decoder
 869                                         nullptr,// encoder
 870                                         false,// received
 871                                         std::make_pair<bool, int>(false, 0),// multiplex
 872                                         static_cast<sign_t>(0),// signed
 873                                         -1,// bit_sign_position
 874                                         ""// unit
 875                                 })},
 876                                 {std::make_shared<signal_t> (signal_t{
 877                                         "windows.rear_left.open",// generic_name
 878                                         46,// bit_position
 879                                         1,// bit_size
 880                                         1.00000f,// factor
 881                                         0.00000f,// offset
 882                                         0,// min_value
 883                                         0,// max_value
 884                                         frequency_clock_t(0.00000f),// frequency
 885                                         true,// send_same
 886                                         false,// force_send_changed
 887                                         {
 888                                         },// states
 889                                         true,// writable
 890                                         decoder_t::decode_boolean,// decoder
 891                                         nullptr,// encoder
 892                                         false,// received
 893                                         std::make_pair<bool, int>(false, 0),// multiplex
 894                                         static_cast<sign_t>(0),// signed
 895                                         -1,// bit_sign_position
 896                                         ""// unit
 897                                 })},
 898                                 {std::make_shared<signal_t> (signal_t{
 899                                         "windows.rear_right.open",// generic_name
 900                                         45,// bit_position
 901                                         4,// bit_size
 902                                         1.00000f,// factor
 903                                         0.00000f,// offset
 904                                         0,// min_value
 905                                         0,// max_value
 906                                         frequency_clock_t(0.00000f),// frequency
 907                                         true,// send_same
 908                                         false,// force_send_changed
 909                                         {
 910                                         },// states
 911                                         true,// writable
 912                                         decoder_t::decode_boolean,// decoder
 913                                         nullptr,// encoder
 914                                         false,// received
 915                                         std::make_pair<bool, int>(false, 0),// multiplex
 916                                         static_cast<sign_t>(0),// signed
 917                                         -1,// bit_sign_position
 918                                         ""// unit
 919                                 })}
 920                         } // end signals vector
 921                 })} // end message_definition entry
 922 ,               {std::make_shared<message_definition_t>(message_definition_t{"j1939",130306,"Wind.Data",8,8,frequency_clock_t(5.00000f),true,
 923                         { // beginning signals vector
 924                                 {std::make_shared<signal_t> (signal_t{
 925                                         "Wind.Data.Reference",// generic_name
 926                                         40,// bit_position
 927                                         3,// bit_size
 928                                         1.00000f,// factor
 929                                         0.00000f,// offset
 930                                         0,// min_value
 931                                         0,// max_value
 932                                         frequency_clock_t(0.00000f),// frequency
 933                                         true,// send_same
 934                                         false,// force_send_changed
 935                                         {
 936                                                 {2,"Apparent"},
 937                                                 {1,"Magnetic (ground referenced to Magnetic North)"},
 938                                                 {3,"True (boat referenced)"},
 939                                                 {0,"True (ground referenced to North)"},
 940                                                 {4,"True (water referenced)"}
 941                                         },// states
 942                                         false,// writable
 943                                         decoder_t::decode_state,// decoder
 944                                         nullptr,// encoder
 945                                         false,// received
 946                                         std::make_pair<bool, int>(false, 0),// multiplex
 947                                         static_cast<sign_t>(0),// signed
 948                                         -1,// bit_sign_position
 949                                         ""// unit
 950                                 })},
 951                                 {std::make_shared<signal_t> (signal_t{
 952                                         "Wind.Data.Reserved",// generic_name
 953                                         43,// bit_position
 954                                         21,// bit_size
 955                                         1.00000f,// factor
 956                                         0.00000f,// offset
 957                                         0,// min_value
 958                                         0,// max_value
 959                                         frequency_clock_t(0.00000f),// frequency
 960                                         true,// send_same
 961                                         false,// force_send_changed
 962                                         {
 963                                         },// states
 964                                         false,// writable
 965                                         decoder_t::decode_bytes,// decoder
 966                                         nullptr,// encoder
 967                                         false,// received
 968                                         std::make_pair<bool, int>(false, 0),// multiplex
 969                                         static_cast<sign_t>(0),// signed
 970                                         -1,// bit_sign_position
 971                                         ""// unit
 972                                 })},
 973                                 {std::make_shared<signal_t> (signal_t{
 974                                         "Wind.Data.Sid",// generic_name
 975                                         0,// bit_position
 976                                         8,// bit_size
 977                                         1.00000f,// factor
 978                                         0.00000f,// offset
 979                                         0,// min_value
 980                                         0,// max_value
 981                                         frequency_clock_t(0.00000f),// frequency
 982                                         true,// send_same
 983                                         false,// force_send_changed
 984                                         {
 985                                         },// states
 986                                         false,// writable
 987                                         nullptr,// decoder
 988                                         nullptr,// encoder
 989                                         false,// received
 990                                         std::make_pair<bool, int>(false, 0),// multiplex
 991                                         static_cast<sign_t>(0),// signed
 992                                         -1,// bit_sign_position
 993                                         ""// unit
 994                                 })},
 995                                 {std::make_shared<signal_t> (signal_t{
 996                                         "Wind.Data.Wind.Angle",// generic_name
 997                                         24,// bit_position
 998                                         16,// bit_size
 999                                         0.000100000f,// factor
1000                                         0.00000f,// offset
1001                                         0,// min_value
1002                                         0,// max_value
1003                                         frequency_clock_t(0.00000f),// frequency
1004                                         true,// send_same
1005                                         false,// force_send_changed
1006                                         {
1007                                         },// states
1008                                         false,// writable
1009                                         nullptr,// decoder
1010                                         nullptr,// encoder
1011                                         false,// received
1012                                         std::make_pair<bool, int>(false, 0),// multiplex
1013                                         static_cast<sign_t>(0),// signed
1014                                         -1,// bit_sign_position
1015                                         "rad"// unit
1016                                 })},
1017                                 {std::make_shared<signal_t> (signal_t{
1018                                         "Wind.Data.Wind.Speed",// generic_name
1019                                         8,// bit_position
1020                                         16,// bit_size
1021                                         0.0100000f,// factor
1022                                         0.00000f,// offset
1023                                         0,// min_value
1024                                         0,// max_value
1025                                         frequency_clock_t(0.00000f),// frequency
1026                                         true,// send_same
1027                                         false,// force_send_changed
1028                                         {
1029                                         },// states
1030                                         false,// writable
1031                                         nullptr,// decoder
1032                                         nullptr,// encoder
1033                                         false,// received
1034                                         std::make_pair<bool, int>(false, 0),// multiplex
1035                                         static_cast<sign_t>(0),// signed
1036                                         -1,// bit_sign_position
1037                                         "m/s"// unit
1038                                 })}
1039                         } // end signals vector
1040                 })} // end message_definition entry
1041 ,               {std::make_shared<message_definition_t>(message_definition_t{"j1939",61442,"ETC1",8,8,frequency_clock_t(5.00000f),true,
1042                         { // beginning signals vector
1043                                 {std::make_shared<signal_t> (signal_t{
1044                                         "Eng.Momentary.Overspeed.Enable",// generic_name
1045                                         32,// bit_position
1046                                         2,// bit_size
1047                                         1.00000f,// factor
1048                                         0.00000f,// offset
1049                                         0,// min_value
1050                                         0,// max_value
1051                                         frequency_clock_t(0.00000f),// frequency
1052                                         true,// send_same
1053                                         false,// force_send_changed
1054                                         {
1055                                                 {0,"MomentaryEngOverspeedIsDisabled"},
1056                                                 {1,"MomentaryEngOverspeedIsEnabled"},
1057                                                 {2,"Reserved"},
1058                                                 {3,"TakeNoAction"}
1059                                         },// states
1060                                         true,// writable
1061                                         decoder_t::decode_state,// decoder
1062                                         nullptr,// encoder
1063                                         false,// received
1064                                         std::make_pair<bool, int>(false, 0),// multiplex
1065                                         static_cast<sign_t>(0),// signed
1066                                         -1,// bit_sign_position
1067                                         ""// unit
1068                                 })},
1069                                 {std::make_shared<signal_t> (signal_t{
1070                                         "Momentary.Eng.Max.Power.Enable",// generic_name
1071                                         36,// bit_position
1072                                         2,// bit_size
1073                                         1.00000f,// factor
1074                                         0.00000f,// offset
1075                                         0,// min_value
1076                                         0,// max_value
1077                                         frequency_clock_t(0.00000f),// frequency
1078                                         true,// send_same
1079                                         false,// force_send_changed
1080                                         {
1081                                                 {2,"fault"},
1082                                                 {1,"mmntarilyRqingMaxPowerAvailable"},
1083                                                 {3,"notAvailable"},
1084                                                 {0,"notRqingMaxPowerAvailable"}
1085                                         },// states
1086                                         true,// writable
1087                                         decoder_t::decode_state,// decoder
1088                                         nullptr,// encoder
1089                                         false,// received
1090                                         std::make_pair<bool, int>(false, 0),// multiplex
1091                                         static_cast<sign_t>(0),// signed
1092                                         -1,// bit_sign_position
1093                                         ""// unit
1094                                 })},
1095                                 {std::make_shared<signal_t> (signal_t{
1096                                         "Percent.Clutch.Slip",// generic_name
1097                                         24,// bit_position
1098                                         8,// bit_size
1099                                         0.400000f,// factor
1100                                         0.00000f,// offset
1101                                         0,// min_value
1102                                         0,// max_value
1103                                         frequency_clock_t(0.00000f),// frequency
1104                                         true,// send_same
1105                                         false,// force_send_changed
1106                                         {
1107                                         },// states
1108                                         true,// writable
1109                                         nullptr,// decoder
1110                                         nullptr,// encoder
1111                                         false,// received
1112                                         std::make_pair<bool, int>(false, 0),// multiplex
1113                                         static_cast<sign_t>(0),// signed
1114                                         -1,// bit_sign_position
1115                                         "%"// unit
1116                                 })},
1117                                 {std::make_shared<signal_t> (signal_t{
1118                                         "Progressive.Shift.Disable",// generic_name
1119                                         34,// bit_position
1120                                         2,// bit_size
1121                                         1.00000f,// factor
1122                                         0.00000f,// offset
1123                                         0,// min_value
1124                                         0,// max_value
1125                                         frequency_clock_t(0.00000f),// frequency
1126                                         true,// send_same
1127                                         false,// force_send_changed
1128                                         {
1129                                                 {1,"ProgressiveShiftIsDisabled"},
1130                                                 {0,"ProgressiveShiftIsNotDisabled"},
1131                                                 {2,"Reserved"},
1132                                                 {3,"TakeNoAction"}
1133                                         },// states
1134                                         true,// writable
1135                                         decoder_t::decode_state,// decoder
1136                                         nullptr,// encoder
1137                                         false,// received
1138                                         std::make_pair<bool, int>(false, 0),// multiplex
1139                                         static_cast<sign_t>(0),// signed
1140                                         -1,// bit_sign_position
1141                                         ""// unit
1142                                 })},
1143                                 {std::make_shared<signal_t> (signal_t{
1144                                         "Src.Addrss.Of.Ctrllng.Dvc.Fr.Trns.Cntrl",// generic_name
1145                                         56,// bit_position
1146                                         8,// bit_size
1147                                         1.00000f,// factor
1148                                         0.00000f,// offset
1149                                         0,// min_value
1150                                         0,// max_value
1151                                         frequency_clock_t(0.00000f),// frequency
1152                                         true,// send_same
1153                                         false,// force_send_changed
1154                                         {
1155                                         },// states
1156                                         true,// writable
1157                                         nullptr,// decoder
1158                                         nullptr,// encoder
1159                                         false,// received
1160                                         std::make_pair<bool, int>(false, 0),// multiplex
1161                                         static_cast<sign_t>(0),// signed
1162                                         -1,// bit_sign_position
1163                                         ""// unit
1164                                 })},
1165                                 {std::make_shared<signal_t> (signal_t{
1166                                         "Trans.Driveline.Engaged",// generic_name
1167                                         0,// bit_position
1168                                         2,// bit_size
1169                                         1.00000f,// factor
1170                                         0.00000f,// offset
1171                                         0,// min_value
1172                                         0,// max_value
1173                                         frequency_clock_t(0.00000f),// frequency
1174                                         true,// send_same
1175                                         false,// force_send_changed
1176                                         {
1177                                                 {0,"DrivelineDisengaged"},
1178                                                 {1,"DrivelineEngaged"},
1179                                                 {2,"Error"},
1180                                                 {3,"NotAvailable"}
1181                                         },// states
1182                                         true,// writable
1183                                         decoder_t::decode_state,// decoder
1184                                         nullptr,// encoder
1185                                         false,// received
1186                                         std::make_pair<bool, int>(false, 0),// multiplex
1187                                         static_cast<sign_t>(0),// signed
1188                                         -1,// bit_sign_position
1189                                         ""// unit
1190                                 })},
1191                                 {std::make_shared<signal_t> (signal_t{
1192                                         "Trans.Input.Shaft.Speed",// generic_name
1193                                         40,// bit_position
1194                                         16,// bit_size
1195                                         0.125000f,// factor
1196                                         0.00000f,// offset
1197                                         0,// min_value
1198                                         0,// max_value
1199                                         frequency_clock_t(0.00000f),// frequency
1200                                         true,// send_same
1201                                         false,// force_send_changed
1202                                         {
1203                                         },// states
1204                                         true,// writable
1205                                         nullptr,// decoder
1206                                         nullptr,// encoder
1207                                         false,// received
1208                                         std::make_pair<bool, int>(false, 0),// multiplex
1209                                         static_cast<sign_t>(0),// signed
1210                                         -1,// bit_sign_position
1211                                         "rpm"// unit
1212                                 })},
1213                                 {std::make_shared<signal_t> (signal_t{
1214                                         "Trans.Output.Shaft.Speed",// generic_name
1215                                         8,// bit_position
1216                                         16,// bit_size
1217                                         0.125000f,// factor
1218                                         0.00000f,// offset
1219                                         0,// min_value
1220                                         0,// max_value
1221                                         frequency_clock_t(0.00000f),// frequency
1222                                         true,// send_same
1223                                         false,// force_send_changed
1224                                         {
1225                                         },// states
1226                                         true,// writable
1227                                         nullptr,// decoder
1228                                         nullptr,// encoder
1229                                         false,// received
1230                                         std::make_pair<bool, int>(false, 0),// multiplex
1231                                         static_cast<sign_t>(0),// signed
1232                                         -1,// bit_sign_position
1233                                         "rpm"// unit
1234                                 })},
1235                                 {std::make_shared<signal_t> (signal_t{
1236                                         "Trans.Shift.In.Process",// generic_name
1237                                         4,// bit_position
1238                                         2,// bit_size
1239                                         1.00000f,// factor
1240                                         0.00000f,// offset
1241                                         0,// min_value
1242                                         0,// max_value
1243                                         frequency_clock_t(0.00000f),// frequency
1244                                         true,// send_same
1245                                         false,// force_send_changed
1246                                         {
1247                                                 {2,"Error"},
1248                                                 {3,"NotAvailable"},
1249                                                 {1,"ShiftInProcess"},
1250                                                 {0,"ShiftIsNotInProcess"}
1251                                         },// states
1252                                         true,// writable
1253                                         decoder_t::decode_state,// decoder
1254                                         nullptr,// encoder
1255                                         false,// received
1256                                         std::make_pair<bool, int>(false, 0),// multiplex
1257                                         static_cast<sign_t>(0),// signed
1258                                         -1,// bit_sign_position
1259                                         ""// unit
1260                                 })},
1261                                 {std::make_shared<signal_t> (signal_t{
1262                                         "Trns.Trq.Cnvrtr.Lckp.Trnstn.In.Prcess",// generic_name
1263                                         6,// bit_position
1264                                         2,// bit_size
1265                                         1.00000f,// factor
1266                                         0.00000f,// offset
1267                                         0,// min_value
1268                                         0,// max_value
1269                                         frequency_clock_t(0.00000f),// frequency
1270                                         true,// send_same
1271                                         false,// force_send_changed
1272                                         {
1273                                                 {2,"Error"},
1274                                                 {3,"NotAvailable"},
1275                                                 {1,"TransitionIsInProcess"},
1276                                                 {0,"TransitionIsNotInProcess"}
1277                                         },// states
1278                                         true,// writable
1279                                         decoder_t::decode_state,// decoder
1280                                         nullptr,// encoder
1281                                         false,// received
1282                                         std::make_pair<bool, int>(false, 0),// multiplex
1283                                         static_cast<sign_t>(0),// signed
1284                                         -1,// bit_sign_position
1285                                         ""// unit
1286                                 })},
1287                                 {std::make_shared<signal_t> (signal_t{
1288                                         "Trns.Trque.Converter.Lockup.Engaged",// generic_name
1289                                         2,// bit_position
1290                                         2,// bit_size
1291                                         1.00000f,// factor
1292                                         0.00000f,// offset
1293                                         0,// min_value
1294                                         0,// max_value
1295                                         frequency_clock_t(0.00000f),// frequency
1296                                         true,// send_same
1297                                         false,// force_send_changed
1298                                         {
1299                                                 {2,"Error"},
1300                                                 {3,"NotAvailable"},
1301                                                 {0,"TorqueConverterLockupDisengaged"},
1302                                                 {1,"TorqueConverterLockupEngaged"}
1303                                         },// states
1304                                         true,// writable
1305                                         decoder_t::decode_state,// decoder
1306                                         nullptr,// encoder
1307                                         false,// received
1308                                         std::make_pair<bool, int>(false, 0),// multiplex
1309                                         static_cast<sign_t>(0),// signed
1310                                         -1,// bit_sign_position
1311                                         ""// unit
1312                                 })}
1313                         } // end signals vector
1314                 })} // end message_definition entry
1315 ,               {std::make_shared<message_definition_t>(message_definition_t{"j1939",61444,"EEC1",8,8,frequency_clock_t(5.00000f),true,
1316                         { // beginning signals vector
1317                                 {std::make_shared<signal_t> (signal_t{
1318                                         "Actl.Eng.Prcnt.Trque.High.Resolution",// generic_name
1319                                         4,// bit_position
1320                                         4,// bit_size
1321                                         0.125000f,// factor
1322                                         0.00000f,// offset
1323                                         0,// min_value
1324                                         0,// max_value
1325                                         frequency_clock_t(0.00000f),// frequency
1326                                         true,// send_same
1327                                         false,// force_send_changed
1328                                         {
1329                                                 {0,"0000"},
1330                                                 {1,"0125"},
1331                                                 {7,"0875"},
1332                                                 {8,"1111NotAvailable"}
1333                                         },// states
1334                                         false,// writable
1335                                         decoder_t::decode_state,// decoder
1336                                         nullptr,// encoder
1337                                         false,// received
1338                                         std::make_pair<bool, int>(false, 0),// multiplex
1339                                         static_cast<sign_t>(0),// signed
1340                                         -1,// bit_sign_position
1341                                         "%"// unit
1342                                 })},
1343                                 {std::make_shared<signal_t> (signal_t{
1344                                         "Actual.Eng.Percent.Torque",// generic_name
1345                                         16,// bit_position
1346                                         8,// bit_size
1347                                         1.00000f,// factor
1348                                         -125.000f,// offset
1349                                         0,// min_value
1350                                         0,// max_value
1351                                         frequency_clock_t(0.00000f),// frequency
1352                                         true,// send_same
1353                                         false,// force_send_changed
1354                                         {
1355                                         },// states
1356                                         false,// writable
1357                                         nullptr,// decoder
1358                                         nullptr,// encoder
1359                                         false,// received
1360                                         std::make_pair<bool, int>(false, 0),// multiplex
1361                                         static_cast<sign_t>(0),// signed
1362                                         -1,// bit_sign_position
1363                                         "%"// unit
1364                                 })},
1365                                 {std::make_shared<signal_t> (signal_t{
1366                                         "Drivers.Demand.Eng.Percent.Torque",// generic_name
1367                                         8,// bit_position
1368                                         8,// bit_size
1369                                         1.00000f,// factor
1370                                         -125.000f,// offset
1371                                         0,// min_value
1372                                         0,// max_value
1373                                         frequency_clock_t(0.00000f),// frequency
1374                                         true,// send_same
1375                                         false,// force_send_changed
1376                                         {
1377                                         },// states
1378                                         false,// writable
1379                                         nullptr,// decoder
1380                                         nullptr,// encoder
1381                                         false,// received
1382                                         std::make_pair<bool, int>(false, 0),// multiplex
1383                                         static_cast<sign_t>(0),// signed
1384                                         -1,// bit_sign_position
1385                                         "%"// unit
1386                                 })},
1387                                 {std::make_shared<signal_t> (signal_t{
1388                                         "Eng.Demand.Percent.Torque",// generic_name
1389                                         56,// bit_position
1390                                         8,// bit_size
1391                                         1.00000f,// factor
1392                                         -125.000f,// offset
1393                                         0,// min_value
1394                                         0,// max_value
1395                                         frequency_clock_t(0.00000f),// frequency
1396                                         true,// send_same
1397                                         false,// force_send_changed
1398                                         {
1399                                         },// states
1400                                         false,// writable
1401                                         nullptr,// decoder
1402                                         nullptr,// encoder
1403                                         false,// received
1404                                         std::make_pair<bool, int>(false, 0),// multiplex
1405                                         static_cast<sign_t>(0),// signed
1406                                         -1,// bit_sign_position
1407                                         "%"// unit
1408                                 })},
1409                                 {std::make_shared<signal_t> (signal_t{
1410                                         "Eng.Speed",// generic_name
1411                                         24,// bit_position
1412                                         16,// bit_size
1413                                         0.125000f,// factor
1414                                         0.00000f,// offset
1415                                         0,// min_value
1416                                         0,// max_value
1417                                         frequency_clock_t(0.00000f),// frequency
1418                                         true,// send_same
1419                                         false,// force_send_changed
1420                                         {
1421                                         },// states
1422                                         false,// writable
1423                                         nullptr,// decoder
1424                                         nullptr,// encoder
1425                                         false,// received
1426                                         std::make_pair<bool, int>(false, 0),// multiplex
1427                                         static_cast<sign_t>(0),// signed
1428                                         -1,// bit_sign_position
1429                                         "rpm"// unit
1430                                 })},
1431                                 {std::make_shared<signal_t> (signal_t{
1432                                         "Eng.Starter.Mode",// generic_name
1433                                         48,// bit_position
1434                                         4,// bit_size
1435                                         1.00000f,// factor
1436                                         0.00000f,// offset
1437                                         0,// min_value
1438                                         0,// max_value
1439                                         frequency_clock_t(0.00000f),// frequency
1440                                         true,// send_same
1441                                         false,// force_send_changed
1442                                         {
1443                                                 {9,"1011Reserved"},
1444                                                 {14,"error"},
1445                                                 {15,"notAvailable"},
1446                                                 {0,"startNotRqed"},
1447                                                 {2,"starterActiveGearEngaged"},
1448                                                 {1,"starterActiveGearNotEngaged"},
1449                                                 {12,"starterInhibitedReasonUnknown"},
1450                                                 {3,"strtFnshdStrtrNtActvAftrHvngBnA"},
1451                                                 {6,"strtrInhbtdDTDrvlnEnggdOthrTrns"},
1452                                                 {5,"strtrInhbtdDTEngNtReadyForStart"},
1453                                                 {7,"strtrInhbtdDToActiveImmobilizer"},
1454                                                 {4,"strtrInhbtdDToEngAlreadyRunning"},
1455                                                 {8,"strtrInhbtdDueToStarterOvertemp"}
1456                                         },// states
1457                                         false,// writable
1458                                         decoder_t::decode_state,// decoder
1459                                         nullptr,// encoder
1460                                         false,// received
1461                                         std::make_pair<bool, int>(false, 0),// multiplex
1462                                         static_cast<sign_t>(0),// signed
1463                                         -1,// bit_sign_position
1464                                         ""// unit
1465                                 })},
1466                                 {std::make_shared<signal_t> (signal_t{
1467                                         "Eng.Torque.Mode",// generic_name
1468                                         0,// bit_position
1469                                         4,// bit_size
1470                                         1.00000f,// factor
1471                                         0.00000f,// offset
1472                                         0,// min_value
1473                                         0,// max_value
1474                                         frequency_clock_t(0.00000f),// frequency
1475                                         true,// send_same
1476                                         false,// force_send_changed
1477                                         {
1478                                                 {7,"ABS control"},
1479                                                 {5,"ASR control"},
1480                                                 {1,"Accelerator pedal/operator selec"},
1481                                                 {10,"Braking system"},
1482                                                 {2,"Cruise control"},
1483                                                 {9,"High speed governor"},
1484                                                 {0,"Low idle governor/no request (de"},
1485                                                 {15,"Not available"},
1486                                                 {3,"PTO governor"},
1487                                                 {11,"Remote accelerator"},
1488                                                 {4,"Road speed governor"},
1489                                                 {8,"Torque limiting"},
1490                                                 {6,"Transmission control"}
1491                                         },// states
1492                                         false,// writable
1493                                         decoder_t::decode_state,// decoder
1494                                         nullptr,// encoder
1495                                         false,// received
1496                                         std::make_pair<bool, int>(false, 0),// multiplex
1497                                         static_cast<sign_t>(0),// signed
1498                                         -1,// bit_sign_position
1499                                         ""// unit
1500                                 })},
1501                                 {std::make_shared<signal_t> (signal_t{
1502                                         "Src.AddrssOf.Ctrllng.Dvc.Fr.Eng.Cntrl",// generic_name
1503                                         40,// bit_position
1504                                         8,// bit_size
1505                                         1.00000f,// factor
1506                                         0.00000f,// offset
1507                                         0,// min_value
1508                                         0,// max_value
1509                                         frequency_clock_t(0.00000f),// frequency
1510                                         true,// send_same
1511                                         false,// force_send_changed
1512                                         {
1513                                         },// states
1514                                         false,// writable
1515                                         nullptr,// decoder
1516                                         nullptr,// encoder
1517                                         false,// received
1518                                         std::make_pair<bool, int>(false, 0),// multiplex
1519                                         static_cast<sign_t>(0),// signed
1520                                         -1,// bit_sign_position
1521                                         ""// unit
1522                                 })}
1523                         } // end signals vector
1524                 })} // end message_definition entry
1525         }, // end message_definition vector
1526         { // beginning diagnostic_messages_ vector
1527                 {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1528                         4,
1529                         "engine.load",
1530                         0,
1531                         0,
1532                         UNIT::INVALID,
1533                         5.00000f,
1534                         decoder_t::decode_obd2_response,
1535                         nullptr,
1536                         true,
1537                         false
1538                 })}
1539 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1540                         5,
1541                         "engine.coolant.temperature",
1542                         0,
1543                         0,
1544                         UNIT::INVALID,
1545                         1.00000f,
1546                         decoder_t::decode_obd2_response,
1547                         nullptr,
1548                         true,
1549                         false
1550                 })}
1551 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1552                         10,
1553                         "fuel.pressure",
1554                         0,
1555                         0,
1556                         UNIT::INVALID,
1557                         1.00000f,
1558                         decoder_t::decode_obd2_response,
1559                         nullptr,
1560                         true,
1561                         false
1562                 })}
1563 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1564                         11,
1565                         "intake.manifold.pressure",
1566                         0,
1567                         0,
1568                         UNIT::INVALID,
1569                         1.00000f,
1570                         decoder_t::decode_obd2_response,
1571                         nullptr,
1572                         true,
1573                         false
1574                 })}
1575 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1576                         12,
1577                         "engine.speed",
1578                         0,
1579                         0,
1580                         UNIT::INVALID,
1581                         5.00000f,
1582                         decoder_t::decode_obd2_response,
1583                         nullptr,
1584                         true,
1585                         false
1586                 })}
1587 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1588                         13,
1589                         "vehicle.speed",
1590                         0,
1591                         0,
1592                         UNIT::INVALID,
1593                         5.00000f,
1594                         decoder_t::decode_obd2_response,
1595                         nullptr,
1596                         true,
1597                         false
1598                 })}
1599 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1600                         15,
1601                         "intake.air.temperature",
1602                         0,
1603                         0,
1604                         UNIT::INVALID,
1605                         1.00000f,
1606                         decoder_t::decode_obd2_response,
1607                         nullptr,
1608                         true,
1609                         false
1610                 })}
1611 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1612                         16,
1613                         "mass.airflow",
1614                         0,
1615                         0,
1616                         UNIT::INVALID,
1617                         5.00000f,
1618                         decoder_t::decode_obd2_response,
1619                         nullptr,
1620                         true,
1621                         false
1622                 })}
1623 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1624                         17,
1625                         "throttle.position",
1626                         0,
1627                         0,
1628                         UNIT::INVALID,
1629                         5.00000f,
1630                         decoder_t::decode_obd2_response,
1631                         nullptr,
1632                         true,
1633                         false
1634                 })}
1635 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1636                         31,
1637                         "running.time",
1638                         0,
1639                         0,
1640                         UNIT::INVALID,
1641                         1.00000f,
1642                         decoder_t::decode_obd2_response,
1643                         nullptr,
1644                         true,
1645                         false
1646                 })}
1647 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1648                         45,
1649                         "EGR.error",
1650                         0,
1651                         0,
1652                         UNIT::INVALID,
1653                         0.00000f,
1654                         decoder_t::decode_obd2_response,
1655                         nullptr,
1656                         true,
1657                         false
1658                 })}
1659 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1660                         47,
1661                         "fuel.level",
1662                         0,
1663                         0,
1664                         UNIT::INVALID,
1665                         1.00000f,
1666                         decoder_t::decode_obd2_response,
1667                         nullptr,
1668                         true,
1669                         false
1670                 })}
1671 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1672                         51,
1673                         "barometric.pressure",
1674                         0,
1675                         0,
1676                         UNIT::INVALID,
1677                         1.00000f,
1678                         decoder_t::decode_obd2_response,
1679                         nullptr,
1680                         true,
1681                         false
1682                 })}
1683 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1684                         70,
1685                         "ambient.air.temperature",
1686                         0,
1687                         0,
1688                         UNIT::INVALID,
1689                         1.00000f,
1690                         decoder_t::decode_obd2_response,
1691                         nullptr,
1692                         true,
1693                         false
1694                 })}
1695 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1696                         76,
1697                         "commanded.throttle.position",
1698                         0,
1699                         0,
1700                         UNIT::INVALID,
1701                         1.00000f,
1702                         decoder_t::decode_obd2_response,
1703                         nullptr,
1704                         true,
1705                         false
1706                 })}
1707 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1708                         82,
1709                         "ethanol.fuel.percentage",
1710                         0,
1711                         0,
1712                         UNIT::INVALID,
1713                         1.00000f,
1714                         decoder_t::decode_obd2_response,
1715                         nullptr,
1716                         true,
1717                         false
1718                 })}
1719 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1720                         90,
1721                         "accelerator.pedal.position",
1722                         0,
1723                         0,
1724                         UNIT::INVALID,
1725                         5.00000f,
1726                         decoder_t::decode_obd2_response,
1727                         nullptr,
1728                         true,
1729                         false
1730                 })}
1731 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1732                         91,
1733                         "hybrid.battery-pack.remaining.life",
1734                         0,
1735                         0,
1736                         UNIT::INVALID,
1737                         5.00000f,
1738                         decoder_t::decode_obd2_response,
1739                         nullptr,
1740                         true,
1741                         false
1742                 })}
1743 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1744                         92,
1745                         "engine.oil.temperature",
1746                         0,
1747                         0,
1748                         UNIT::INVALID,
1749                         1.00000f,
1750                         decoder_t::decode_obd2_response,
1751                         nullptr,
1752                         true,
1753                         false
1754                 })}
1755 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1756                         94,
1757                         "engine.fuel.rate",
1758                         0,
1759                         0,
1760                         UNIT::INVALID,
1761                         1.00000f,
1762                         decoder_t::decode_obd2_response,
1763                         nullptr,
1764                         true,
1765                         false
1766                 })}
1767 ,               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1768                         99,
1769                         "engine.torque",
1770                         0,
1771                         0,
1772                         UNIT::INVALID,
1773                         1.00000f,
1774                         decoder_t::decode_obd2_response,
1775                         nullptr,
1776                         true,
1777                         false
1778                 })}
1779
1780         } // end diagnostic_messages_ vector
1781 }); // end message_set entry
1782
1783 CTLP_ONLOAD(plugin, handle) {
1784         afb_api_t api = (afb_api_t) plugin->api;
1785         CtlConfigT* CtlConfig = (CtlConfigT*) afb_api_get_userdata(api);
1786         application_t* app = (application_t*) getExternalData(CtlConfig);
1787
1788         return app->add_message_set(cms);
1789 }
1790
1791
1792 }
1793