examples/tests/application-generated.cpp

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