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