examples/tests/application-generated.cpp

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