examples/j1939/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,"J1939",
   9                         { // beginning message_definition_ vector
  10
  11                                 {std::make_shared<message_definition_t>(message_definition_t{"j1939",61442,0,message_format_t::J1939,frequency_clock_t(5.00000f),true,8,
  12                                         { // beginning signals vector
  13                                                 {std::make_shared<signal_t> (signal_t{
  14                                                         "EngMomentaryOverspeedEnable",// generic_name
  15                                                         32,// bit_position
  16                                                         2,// bit_size
  17                                                         1.00000f,// factor
  18                                                         0.00000,// offset
  19                                                         0,// min_value
  20                                                         0,// max_value
  21                                                         frequency_clock_t(0.00000f),// frequency
  22                                                         true,// send_same
  23                                                         false,// force_send_changed
  24                                                         {
  25                                                                 {0,"MomentaryEngOverspeedIsDisabled"},
  26                                                                 {1,"MomentaryEngOverspeedIsEnabled"},
  27                                                                 {2,"Reserved"},
  28                                                                 {3,"TakeNoAction"}
  29                                                         },// states
  30                                                         false,// writable
  31                                                         nullptr,// decoder
  32                                                         nullptr,// encoder
  33                                                         false,// received
  34                                                         std::make_pair<bool, int>(false, 0),// multiplex
  35                                                         0,// is_big_endian
  36                                                         0,// is_signed
  37                                                         "",// unit
  38                                                         "Command signal used to indicate that the engine speed may be boosted up to the maximum engine overspeed value to"// comment
  39                                                 })},
  40                                                 {std::make_shared<signal_t> (signal_t{
  41                                                         "MomentaryEngMaxPowerEnable",// generic_name
  42                                                         36,// bit_position
  43                                                         2,// bit_size
  44                                                         1.00000f,// factor
  45                                                         0.00000,// offset
  46                                                         0,// min_value
  47                                                         0,// max_value
  48                                                         frequency_clock_t(0.00000f),// frequency
  49                                                         true,// send_same
  50                                                         false,// force_send_changed
  51                                                         {
  52                                                                 {2,"fault"},
  53                                                                 {1,"mmntarilyRqingMaxPowerAvailable"},
  54                                                                 {3,"notAvailable"},
  55                                                                 {0,"notRqingMaxPowerAvailable"}
  56                                                         },// states
  57                                                         false,// writable
  58                                                         nullptr,// decoder
  59                                                         nullptr,// encoder
  60                                                         false,// received
  61                                                         std::make_pair<bool, int>(false, 0),// multiplex
  62                                                         0,// is_big_endian
  63                                                         0,// is_signed
  64                                                         "",// unit
  65                                                         "Momentarily Requesting highest torque map from the engine control"// comment
  66                                                 })},
  67                                                 {std::make_shared<signal_t> (signal_t{
  68                                                         "PercentClutchSlip",// generic_name
  69                                                         24,// bit_position
  70                                                         8,// bit_size
  71                                                         0.400000f,// factor
  72                                                         0.00000,// offset
  73                                                         0,// min_value
  74                                                         0,// max_value
  75                                                         frequency_clock_t(0.00000f),// frequency
  76                                                         true,// send_same
  77                                                         false,// force_send_changed
  78                                                         {
  79                                                         },// states
  80                                                         false,// writable
  81                                                         nullptr,// decoder
  82                                                         nullptr,// encoder
  83                                                         false,// received
  84                                                         std::make_pair<bool, int>(false, 0),// multiplex
  85                                                         0,// is_big_endian
  86                                                         0,// is_signed
  87                                                         "%",// unit
  88                                                         "Parameter which represents the ratio of input shaft speed to current engine speed (in percent)."// comment
  89                                                 })},
  90                                                 {std::make_shared<signal_t> (signal_t{
  91                                                         "ProgressiveShiftDisable",// generic_name
  92                                                         34,// bit_position
  93                                                         2,// bit_size
  94                                                         1.00000f,// factor
  95                                                         0.00000,// offset
  96                                                         0,// min_value
  97                                                         0,// max_value
  98                                                         frequency_clock_t(0.00000f),// frequency
  99                                                         true,// send_same
 100                                                         false,// force_send_changed
 101                                                         {
 102                                                                 {1,"ProgressiveShiftIsDisabled"},
 103                                                                 {0,"ProgressiveShiftIsNotDisabled"},
 104                                                                 {2,"Reserved"},
 105                                                                 {3,"TakeNoAction"}
 106                                                         },// states
 107                                                         false,// writable
 108                                                         nullptr,// decoder
 109                                                         nullptr,// encoder
 110                                                         false,// received
 111                                                         std::make_pair<bool, int>(false, 0),// multiplex
 112                                                         0,// is_big_endian
 113                                                         0,// is_signed
 114                                                         "",// unit
 115                                                         "Command signal used to indicate that progressive shifting by the engine should be disallowed."// comment
 116                                                 })},
 117                                                 {std::make_shared<signal_t> (signal_t{
 118                                                         "SrcAddrssOfCtrllngDvcFrTrnsCntrl",// generic_name
 119                                                         56,// bit_position
 120                                                         8,// bit_size
 121                                                         1.00000f,// factor
 122                                                         0.00000,// offset
 123                                                         0,// min_value
 124                                                         0,// max_value
 125                                                         frequency_clock_t(0.00000f),// frequency
 126                                                         true,// send_same
 127                                                         false,// force_send_changed
 128                                                         {
 129                                                         },// states
 130                                                         false,// writable
 131                                                         nullptr,// decoder
 132                                                         nullptr,// encoder
 133                                                         false,// received
 134                                                         std::make_pair<bool, int>(false, 0),// multiplex
 135                                                         0,// is_big_endian
 136                                                         0,// is_signed
 137                                                         "",// unit
 138                                                         "The source address of the SAE J1939 device currently controlling the transmission."// comment
 139                                                 })},
 140                                                 {std::make_shared<signal_t> (signal_t{
 141                                                         "TransDrivelineEngaged",// generic_name
 142                                                         0,// bit_position
 143                                                         2,// bit_size
 144                                                         1.00000f,// factor
 145                                                         0.00000,// offset
 146                                                         0,// min_value
 147                                                         0,// max_value
 148                                                         frequency_clock_t(0.00000f),// frequency
 149                                                         true,// send_same
 150                                                         false,// force_send_changed
 151                                                         {
 152                                                                 {0,"DrivelineDisengaged"},
 153                                                                 {1,"DrivelineEngaged"},
 154                                                                 {2,"Error"},
 155                                                                 {3,"NotAvailable"}
 156                                                         },// states
 157                                                         false,// writable
 158                                                         nullptr,// decoder
 159                                                         nullptr,// encoder
 160                                                         false,// received
 161                                                         std::make_pair<bool, int>(false, 0),// multiplex
 162                                                         0,// is_big_endian
 163                                                         0,// is_signed
 164                                                         "",// unit
 165                                                         "Driveline engaged indicates the transmission controlled portion of the driveline is engaged sufficiently to allow a transfer"// comment
 166                                                 })},
 167                                                 {std::make_shared<signal_t> (signal_t{
 168                                                         "TransInputShaftSpeed",// generic_name
 169                                                         40,// bit_position
 170                                                         16,// bit_size
 171                                                         0.125000f,// factor
 172                                                         0.00000,// offset
 173                                                         0,// min_value
 174                                                         0,// max_value
 175                                                         frequency_clock_t(0.00000f),// frequency
 176                                                         true,// send_same
 177                                                         false,// force_send_changed
 178                                                         {
 179                                                         },// states
 180                                                         false,// writable
 181                                                         nullptr,// decoder
 182                                                         nullptr,// encoder
 183                                                         false,// received
 184                                                         std::make_pair<bool, int>(false, 0),// multiplex
 185                                                         0,// is_big_endian
 186                                                         0,// is_signed
 187                                                         "rpm",// unit
 188                                                         "Rotational velocity of the primary shaft transferring power into the transmission."// comment
 189                                                 })},
 190                                                 {std::make_shared<signal_t> (signal_t{
 191                                                         "TransOutputShaftSpeed",// generic_name
 192                                                         8,// bit_position
 193                                                         16,// bit_size
 194                                                         0.125000f,// factor
 195                                                         0.00000,// offset
 196                                                         0,// min_value
 197                                                         0,// max_value
 198                                                         frequency_clock_t(0.00000f),// frequency
 199                                                         true,// send_same
 200                                                         false,// force_send_changed
 201                                                         {
 202                                                         },// states
 203                                                         false,// writable
 204                                                         nullptr,// decoder
 205                                                         nullptr,// encoder
 206                                                         false,// received
 207                                                         std::make_pair<bool, int>(false, 0),// multiplex
 208                                                         0,// is_big_endian
 209                                                         0,// is_signed
 210                                                         "rpm",// unit
 211                                                         "Calculated speed of the transmission output shaft."// comment
 212                                                 })},
 213                                                 {std::make_shared<signal_t> (signal_t{
 214                                                         "TransShiftInProcess",// generic_name
 215                                                         4,// bit_position
 216                                                         2,// bit_size
 217                                                         1.00000f,// factor
 218                                                         0.00000,// offset
 219                                                         0,// min_value
 220                                                         0,// max_value
 221                                                         frequency_clock_t(0.00000f),// frequency
 222                                                         true,// send_same
 223                                                         false,// force_send_changed
 224                                                         {
 225                                                                 {2,"Error"},
 226                                                                 {3,"NotAvailable"},
 227                                                                 {1,"ShiftInProcess"},
 228                                                                 {0,"ShiftIsNotInProcess"}
 229                                                         },// states
 230                                                         false,// writable
 231                                                         nullptr,// decoder
 232                                                         nullptr,// encoder
 233                                                         false,// received
 234                                                         std::make_pair<bool, int>(false, 0),// multiplex
 235                                                         0,// is_big_endian
 236                                                         0,// is_signed
 237                                                         "",// unit
 238                                                         "Indicates that the transmission is in process of shifting from the current gear to the selected gear."// comment
 239                                                 })},
 240                                                 {std::make_shared<signal_t> (signal_t{
 241                                                         "TrnsTrqCnvrtrLckpTrnstnInPrcess",// generic_name
 242                                                         6,// bit_position
 243                                                         2,// bit_size
 244                                                         1.00000f,// factor
 245                                                         0.00000,// offset
 246                                                         0,// min_value
 247                                                         0,// max_value
 248                                                         frequency_clock_t(0.00000f),// frequency
 249                                                         true,// send_same
 250                                                         false,// force_send_changed
 251                                                         {
 252                                                                 {2,"Error"},
 253                                                                 {3,"NotAvailable"},
 254                                                                 {1,"TransitionIsInProcess"},
 255                                                                 {0,"TransitionIsNotInProcess"}
 256                                                         },// states
 257                                                         false,// writable
 258                                                         nullptr,// decoder
 259                                                         nullptr,// encoder
 260                                                         false,// received
 261                                                         std::make_pair<bool, int>(false, 0),// multiplex
 262                                                         0,// is_big_endian
 263                                                         0,// is_signed
 264                                                         "",// unit
 265                                                         "State signal indicating whether or not the transmission torque converter lock up clutch is transitioning between being"// comment
 266                                                 })},
 267                                                 {std::make_shared<signal_t> (signal_t{
 268                                                         "TrnsTrqueConverterLockupEngaged",// generic_name
 269                                                         2,// bit_position
 270                                                         2,// bit_size
 271                                                         1.00000f,// factor
 272                                                         0.00000,// offset
 273                                                         0,// min_value
 274                                                         0,// max_value
 275                                                         frequency_clock_t(0.00000f),// frequency
 276                                                         true,// send_same
 277                                                         false,// force_send_changed
 278                                                         {
 279                                                                 {2,"Error"},
 280                                                                 {3,"NotAvailable"},
 281                                                                 {0,"TorqueConverterLockupDisengaged"},
 282                                                                 {1,"TorqueConverterLockupEngaged"}
 283                                                         },// states
 284                                                         false,// writable
 285                                                         nullptr,// decoder
 286                                                         nullptr,// encoder
 287                                                         false,// received
 288                                                         std::make_pair<bool, int>(false, 0),// multiplex
 289                                                         0,// is_big_endian
 290                                                         0,// is_signed
 291                                                         "",// unit
 292                                                         "State signal which indicates whether the torque converter lockup is engaged."// comment
 293                                                 })}
 294                                         } // end signals vector
 295                                 })}, // end message_definition entry
 296
 297                                 {std::make_shared<message_definition_t>(message_definition_t{"j1939",61449,0,message_format_t::J1939,frequency_clock_t(5.00000f),true,8,
 298                                         { // beginning signals vector
 299                                                 {std::make_shared<signal_t> (signal_t{
 300                                                         "LateralAcceleration",// generic_name
 301                                                         40,// bit_position
 302                                                         16,// bit_size
 303                                                         0.000488281f,// factor
 304                                                         -15.6870,// offset
 305                                                         0,// min_value
 306                                                         0,// max_value
 307                                                         frequency_clock_t(0.00000f),// frequency
 308                                                         true,// send_same
 309                                                         false,// force_send_changed
 310                                                         {
 311                                                         },// states
 312                                                         false,// writable
 313                                                         nullptr,// decoder
 314                                                         nullptr,// encoder
 315                                                         false,// received
 316                                                         std::make_pair<bool, int>(false, 0),// multiplex
 317                                                         0,// is_big_endian
 318                                                         0,// is_signed
 319                                                         "m/s/s",// unit
 320                                                         "Indicates a lateral acceleration of the vehicle."// comment
 321                                                 })},
 322                                                 {std::make_shared<signal_t> (signal_t{
 323                                                         "LongitudinalAcceleration",// generic_name
 324                                                         56,// bit_position
 325                                                         8,// bit_size
 326                                                         0.100000f,// factor
 327                                                         -12.5000,// offset
 328                                                         0,// min_value
 329                                                         0,// max_value
 330                                                         frequency_clock_t(0.00000f),// frequency
 331                                                         true,// send_same
 332                                                         false,// force_send_changed
 333                                                         {
 334                                                         },// states
 335                                                         false,// writable
 336                                                         nullptr,// decoder
 337                                                         nullptr,// encoder
 338                                                         false,// received
 339                                                         std::make_pair<bool, int>(false, 0),// multiplex
 340                                                         0,// is_big_endian
 341                                                         0,// is_signed
 342                                                         "m/s/s",// unit
 343                                                         "Indicates the longitudinal acceleration of the vehicle."// comment
 344                                                 })},
 345                                                 {std::make_shared<signal_t> (signal_t{
 346                                                         "SteerWheelAngle",// generic_name
 347                                                         0,// bit_position
 348                                                         16,// bit_size
 349                                                         0.000976562f,// factor
 350                                                         -31.3740,// offset
 351                                                         0,// min_value
 352                                                         0,// max_value
 353                                                         frequency_clock_t(0.00000f),// frequency
 354                                                         true,// send_same
 355                                                         false,// force_send_changed
 356                                                         {
 357                                                         },// states
 358                                                         false,// writable
 359                                                         nullptr,// decoder
 360                                                         nullptr,// encoder
 361                                                         false,// received
 362                                                         std::make_pair<bool, int>(false, 0),// multiplex
 363                                                         0,// is_big_endian
 364                                                         0,// is_signed
 365                                                         "rad",// unit
 366                                                         "The main operator`s steering wheel angle (on the steering column, not the actual wheel angle)."// comment
 367                                                 })},
 368                                                 {std::make_shared<signal_t> (signal_t{
 369                                                         "SteerWheelAngleSensorType",// generic_name
 370                                                         22,// bit_position
 371                                                         2,// bit_size
 372                                                         1.00000f,// factor
 373                                                         0.00000,// offset
 374                                                         0,// min_value
 375                                                         0,// max_value
 376                                                         frequency_clock_t(0.00000f),// frequency
 377                                                         true,// send_same
 378                                                         false,// force_send_changed
 379                                                         {
 380                                                                 {1,"AbsMeasuringPrinciple"},
 381                                                                 {3,"NotAvailable"},
 382                                                                 {0,"RelativeMeasuringPrinciple"},
 383                                                                 {2,"Reserved"}
 384                                                         },// states
 385                                                         false,// writable
 386                                                         nullptr,// decoder
 387                                                         nullptr,// encoder
 388                                                         false,// received
 389                                                         std::make_pair<bool, int>(false, 0),// multiplex
 390                                                         0,// is_big_endian
 391                                                         0,// is_signed
 392                                                         "",// unit
 393                                                         "Indicates whether the steering wheel angle sensor is capable of absolute measuring of the number of steering wheel"// comment
 394                                                 })},
 395                                                 {std::make_shared<signal_t> (signal_t{
 396                                                         "SteerWheelTurnCounter",// generic_name
 397                                                         16,// bit_position
 398                                                         6,// bit_size
 399                                                         1.00000f,// factor
 400                                                         -32.0000,// offset
 401                                                         0,// min_value
 402                                                         0,// max_value
 403                                                         frequency_clock_t(0.00000f),// frequency
 404                                                         true,// send_same
 405                                                         false,// force_send_changed
 406                                                         {
 407                                                         },// states
 408                                                         false,// writable
 409                                                         nullptr,// decoder
 410                                                         nullptr,// encoder
 411                                                         false,// received
 412                                                         std::make_pair<bool, int>(false, 0),// multiplex
 413                                                         0,// is_big_endian
 414                                                         0,// is_signed
 415                                                         "turns",// unit
 416                                                         "Indicates number of steering wheel turns, absolute position or relative position at ignition on."// comment
 417                                                 })},
 418                                                 {std::make_shared<signal_t> (signal_t{
 419                                                         "YawRate",// generic_name
 420                                                         24,// bit_position
 421                                                         16,// bit_size
 422                                                         0.000122070f,// factor
 423                                                         -3.92000,// offset
 424                                                         0,// min_value
 425                                                         0,// max_value
 426                                                         frequency_clock_t(0.00000f),// frequency
 427                                                         true,// send_same
 428                                                         false,// force_send_changed
 429                                                         {
 430                                                         },// states
 431                                                         false,// writable
 432                                                         nullptr,// decoder
 433                                                         nullptr,// encoder
 434                                                         false,// received
 435                                                         std::make_pair<bool, int>(false, 0),// multiplex
 436                                                         0,// is_big_endian
 437                                                         0,// is_signed
 438                                                         "rad/s",// unit
 439                                                         "Indicates the rotation about the vertical axis."// comment
 440                                                 })}
 441                                         } // end signals vector
 442                                 })}, // end message_definition entry
 443
 444                                 {std::make_shared<message_definition_t>(message_definition_t{"j1939",65253,0,message_format_t::J1939,frequency_clock_t(5.00000f),true,8,
 445                                         { // beginning signals vector
 446                                                 {std::make_shared<signal_t> (signal_t{
 447                                                         "EngTotalHoursOfOperation",// generic_name
 448                                                         0,// bit_position
 449                                                         32,// bit_size
 450                                                         0.0500000f,// factor
 451                                                         0.00000,// offset
 452                                                         0,// min_value
 453                                                         0,// max_value
 454                                                         frequency_clock_t(0.00000f),// frequency
 455                                                         true,// send_same
 456                                                         false,// force_send_changed
 457                                                         {
 458                                                         },// states
 459                                                         false,// writable
 460                                                         nullptr,// decoder
 461                                                         nullptr,// encoder
 462                                                         false,// received
 463                                                         std::make_pair<bool, int>(false, 0),// multiplex
 464                                                         0,// is_big_endian
 465                                                         0,// is_signed
 466                                                         "hr",// unit
 467                                                         "Accumulated time of operation of engine."// comment
 468                                                 })},
 469                                                 {std::make_shared<signal_t> (signal_t{
 470                                                         "EngTotalRevolutions",// generic_name
 471                                                         32,// bit_position
 472                                                         32,// bit_size
 473                                                         1000.00f,// factor
 474                                                         0.00000,// offset
 475                                                         0,// min_value
 476                                                         0,// max_value
 477                                                         frequency_clock_t(0.00000f),// frequency
 478                                                         true,// send_same
 479                                                         false,// force_send_changed
 480                                                         {
 481                                                         },// states
 482                                                         false,// writable
 483                                                         nullptr,// decoder
 484                                                         nullptr,// encoder
 485                                                         false,// received
 486                                                         std::make_pair<bool, int>(false, 0),// multiplex
 487                                                         0,// is_big_endian
 488                                                         0,// is_signed
 489                                                         "r",// unit
 490                                                         "Accumulated number of revolutions of engine crankshaft during its operation."// comment
 491                                                 })}
 492                                         } // end signals vector
 493                                 })}, // end message_definition entry
 494
 495
 496                                 {std::make_shared<message_definition_t>(message_definition_t{"j1939",65262,0,message_format_t::J1939,frequency_clock_t(5.00000f),true,8,
 497                                         { // beginning signals vector
 498                                                 {std::make_shared<signal_t> (signal_t{
 499                                                         "EngCoolantTemp",// generic_name
 500                                                         0,// bit_position
 501                                                         8,// bit_size
 502                                                         0.0312500f,// factor
 503                                                         -273.000,// offset
 504                                                         0,// min_value
 505                                                         0,// max_value
 506                                                         frequency_clock_t(0.00000f),// frequency
 507                                                         true,// send_same
 508                                                         false,// force_send_changed
 509                                                         {
 510                                                         },// states
 511                                                         false,// writable
 512                                                         nullptr,// decoder
 513                                                         nullptr,// encoder
 514                                                         false,// received
 515                                                         std::make_pair<bool, int>(false, 0),// multiplex
 516                                                         0,// is_big_endian
 517                                                         0,// is_signed
 518                                                         "deg C",// unit
 519                                                         "Temperature of liquid found in engine cooling system."// comment
 520                                                 })},
 521                                                 {std::make_shared<signal_t> (signal_t{
 522                                                         "EngFuelTemp1",// generic_name
 523                                                         8,// bit_position
 524                                                         8,// bit_size
 525                                                         1.00000f,// factor
 526                                                         -40.0000,// 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                                                         false,// 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                                                         "deg C",// unit
 542                                                         "Temperature of fuel (or gas) passing through the first fuel control system."// comment
 543                                                 })},
 544                                                 {std::make_shared<signal_t> (signal_t{
 545                                                         "EngIntercoolerTemp",// generic_name
 546                                                         48,// bit_position
 547                                                         8,// bit_size
 548                                                         1.00000f,// factor
 549                                                         -40.0000,// offset
 550                                                         0,// min_value
 551                                                         0,// max_value
 552                                                         frequency_clock_t(0.00000f),// frequency
 553                                                         true,// send_same
 554                                                         false,// force_send_changed
 555                                                         {
 556                                                         },// states
 557                                                         false,// writable
 558                                                         nullptr,// decoder
 559                                                         nullptr,// encoder
 560                                                         false,// received
 561                                                         std::make_pair<bool, int>(false, 0),// multiplex
 562                                                         0,// is_big_endian
 563                                                         0,// is_signed
 564                                                         "deg C",// unit
 565                                                         "Temperature of liquid found in the intercooler located after the turbocharger."// comment
 566                                                 })},
 567                                                 {std::make_shared<signal_t> (signal_t{
 568                                                         "EngIntercoolerThermostatOpening",// generic_name
 569                                                         56,// bit_position
 570                                                         8,// bit_size
 571                                                         0.400000f,// factor
 572                                                         0.00000,// offset
 573                                                         0,// min_value
 574                                                         0,// max_value
 575                                                         frequency_clock_t(0.00000f),// frequency
 576                                                         true,// send_same
 577                                                         false,// force_send_changed
 578                                                         {
 579                                                         },// states
 580                                                         false,// writable
 581                                                         nullptr,// decoder
 582                                                         nullptr,// encoder
 583                                                         false,// received
 584                                                         std::make_pair<bool, int>(false, 0),// multiplex
 585                                                         0,// is_big_endian
 586                                                         0,// is_signed
 587                                                         "%",// unit
 588                                                         "The current position of the thermostat used to regulate the temperature of the engine intercooler."// comment
 589                                                 })},
 590                                                 {std::make_shared<signal_t> (signal_t{
 591                                                         "EngOilTemp1",// generic_name
 592                                                         16,// bit_position
 593                                                         16,// bit_size
 594                                                         0.0312500f,// factor
 595                                                         -273.000,// offset
 596                                                         0,// min_value
 597                                                         0,// max_value
 598                                                         frequency_clock_t(0.00000f),// frequency
 599                                                         true,// send_same
 600                                                         false,// force_send_changed
 601                                                         {
 602                                                         },// states
 603                                                         false,// writable
 604                                                         nullptr,// decoder
 605                                                         nullptr,// encoder
 606                                                         false,// received
 607                                                         std::make_pair<bool, int>(false, 0),// multiplex
 608                                                         0,// is_big_endian
 609                                                         0,// is_signed
 610                                                         "deg C",// unit
 611                                                         "Temperature of the engine lubricant."// comment
 612                                                 })},
 613                                                 {std::make_shared<signal_t> (signal_t{
 614                                                         "EngTurboOilTemp",// generic_name
 615                                                         32,// bit_position
 616                                                         16,// bit_size
 617                                                         0.0312500f,// factor
 618                                                         -273.000,// offset
 619                                                         0,// min_value
 620                                                         0,// max_value
 621                                                         frequency_clock_t(0.00000f),// frequency
 622                                                         true,// send_same
 623                                                         false,// force_send_changed
 624                                                         {
 625                                                         },// states
 626                                                         false,// writable
 627                                                         nullptr,// decoder
 628                                                         nullptr,// encoder
 629                                                         false,// received
 630                                                         std::make_pair<bool, int>(false, 0),// multiplex
 631                                                         0,// is_big_endian
 632                                                         0,// is_signed
 633                                                         "deg C",// unit
 634                                                         "Temperature of the turbocharger lubricant."// comment
 635                                                 })}
 636                                         } // end signals vector
 637                                 })} // end message_definition entry
 638
 639                 }, // end message_definition vector
 640                         { // beginning diagnostic_messages_ vector
 641
 642                         } // end diagnostic_messages_ vector
 643                 })} // end message_set entry
 644         } // end message_set vector
 645 {
 646         for(std::shared_ptr<message_set_t> cms: message_set_)
 647         {
 648                 std::vector<std::shared_ptr<message_definition_t>> messages_definition = cms->get_messages_definition();
 649                 for(std::shared_ptr<message_definition_t> cmd : messages_definition)
 650                 {
 651                         cmd->set_parent(cms);
 652                         std::vector<std::shared_ptr<signal_t>> signals = cmd->get_signals();
 653                         for(std::shared_ptr<signal_t> sig: signals)
 654                         {
 655                                 sig->set_parent(cmd);
 656                         }
 657                 }
 658
 659                 std::vector<std::shared_ptr<diagnostic_message_t>> diagnostic_messages = cms->get_diagnostic_messages();
 660                 for(std::shared_ptr<diagnostic_message_t> dm : diagnostic_messages)
 661                 {
 662                         dm->set_parent(cms);
 663                 }
 664         }
 665                 }
 666
 667 const std::string application_t::get_diagnostic_bus() const
 668 {
 669         return "";
 670 }
 671
 672