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