low-can-binding/binding/application-generated.cpp

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