examples/j1939/j1939-simple.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,"Virtual J1939",
   9                         { // beginning message_definition_ vector
  10                                 {std::make_shared<message_definition_t>(message_definition_t{"j1939",61442,"ETC1",8,4,true,frequency_clock_t(5.00000f),true,
  11                                         { // beginning signals vector
  12                                                 {std::make_shared<signal_t> (signal_t{
  13                                                         "Eng.Momentary.Overspeed.Enable",// generic_name
  14                                                         32,// bit_position
  15                                                         2,// bit_size
  16                                                         1.00000f,// factor
  17                                                         0.00000f,// offset
  18                                                         0,// min_value
  19                                                         0,// max_value
  20                                                         frequency_clock_t(0.00000f),// frequency
  21                                                         true,// send_same
  22                                                         false,// force_send_changed
  23                                                         {
  24                                                                 {0,"MomentaryEngOverspeedIsDisabled"},
  25                                                                 {1,"MomentaryEngOverspeedIsEnabled"},
  26                                                                 {2,"Reserved"},
  27                                                                 {3,"TakeNoAction"}
  28                                                         },// states
  29                                                         true,// writable
  30                                                         decoder_t::decode_state,// decoder
  31                                                         nullptr,// encoder
  32                                                         false,// received
  33                                                         std::make_pair<bool, int>(false, 0),// multiplex
  34                                                         false,// is_big_endian
  35                                                         static_cast<sign_t>(0),// signed
  36                                                         -1,// bit_sign_position
  37                                                         ""// unit
  38                                                 })},
  39                                                 {std::make_shared<signal_t> (signal_t{
  40                                                         "Momentary.Eng.Max.Power.Enable",// generic_name
  41                                                         36,// bit_position
  42                                                         2,// bit_size
  43                                                         1.00000f,// factor
  44                                                         0.00000f,// offset
  45                                                         0,// min_value
  46                                                         0,// max_value
  47                                                         frequency_clock_t(0.00000f),// frequency
  48                                                         true,// send_same
  49                                                         false,// force_send_changed
  50                                                         {
  51                                                                 {2,"fault"},
  52                                                                 {1,"mmntarilyRqingMaxPowerAvailable"},
  53                                                                 {3,"notAvailable"},
  54                                                                 {0,"notRqingMaxPowerAvailable"}
  55                                                         },// states
  56                                                         true,// writable
  57                                                         decoder_t::decode_state,// decoder
  58                                                         nullptr,// encoder
  59                                                         false,// received
  60                                                         std::make_pair<bool, int>(false, 0),// multiplex
  61                                                         false,// is_big_endian
  62                                                         static_cast<sign_t>(0),// signed
  63                                                         -1,// bit_sign_position
  64                                                         ""// unit
  65                                                 })},
  66                                                 {std::make_shared<signal_t> (signal_t{
  67                                                         "Percent.Clutch.Slip",// generic_name
  68                                                         24,// bit_position
  69                                                         8,// bit_size
  70                                                         0.400000f,// factor
  71                                                         0.00000f,// offset
  72                                                         0,// min_value
  73                                                         0,// max_value
  74                                                         frequency_clock_t(0.00000f),// frequency
  75                                                         true,// send_same
  76                                                         false,// force_send_changed
  77                                                         {
  78                                                         },// states
  79                                                         true,// writable
  80                                                         nullptr,// decoder
  81                                                         nullptr,// encoder
  82                                                         false,// received
  83                                                         std::make_pair<bool, int>(false, 0),// multiplex
  84                                                         false,// is_big_endian
  85                                                         static_cast<sign_t>(0),// signed
  86                                                         -1,// bit_sign_position
  87                                                         "%"// unit
  88                                                 })},
  89                                                 {std::make_shared<signal_t> (signal_t{
  90                                                         "Progressive.Shift.Disable",// generic_name
  91                                                         34,// bit_position
  92                                                         2,// bit_size
  93                                                         1.00000f,// factor
  94                                                         0.00000f,// offset
  95                                                         0,// min_value
  96                                                         0,// max_value
  97                                                         frequency_clock_t(0.00000f),// frequency
  98                                                         true,// send_same
  99                                                         false,// force_send_changed
 100                                                         {
 101                                                                 {1,"ProgressiveShiftIsDisabled"},
 102                                                                 {0,"ProgressiveShiftIsNotDisabled"},
 103                                                                 {2,"Reserved"},
 104                                                                 {3,"TakeNoAction"}
 105                                                         },// states
 106                                                         true,// writable
 107                                                         decoder_t::decode_state,// decoder
 108                                                         nullptr,// encoder
 109                                                         false,// received
 110                                                         std::make_pair<bool, int>(false, 0),// multiplex
 111                                                         false,// is_big_endian
 112                                                         static_cast<sign_t>(0),// signed
 113                                                         -1,// bit_sign_position
 114                                                         ""// unit
 115                                                 })},
 116                                                 {std::make_shared<signal_t> (signal_t{
 117                                                         "Src.Addrss.Of.Ctrllng.Dvc.Fr.Trns.Cntrl",// generic_name
 118                                                         56,// bit_position
 119                                                         8,// bit_size
 120                                                         1.00000f,// factor
 121                                                         0.00000f,// offset
 122                                                         0,// min_value
 123                                                         0,// max_value
 124                                                         frequency_clock_t(0.00000f),// frequency
 125                                                         true,// send_same
 126                                                         false,// force_send_changed
 127                                                         {
 128                                                         },// states
 129                                                         true,// writable
 130                                                         nullptr,// decoder
 131                                                         nullptr,// encoder
 132                                                         false,// received
 133                                                         std::make_pair<bool, int>(false, 0),// multiplex
 134                                                         false,// is_big_endian
 135                                                         static_cast<sign_t>(0),// signed
 136                                                         -1,// bit_sign_position
 137                                                         ""// unit
 138                                                 })},
 139                                                 {std::make_shared<signal_t> (signal_t{
 140                                                         "Trans.Driveline.Engaged",// generic_name
 141                                                         0,// bit_position
 142                                                         2,// bit_size
 143                                                         1.00000f,// factor
 144                                                         0.00000f,// offset
 145                                                         0,// min_value
 146                                                         0,// max_value
 147                                                         frequency_clock_t(0.00000f),// frequency
 148                                                         true,// send_same
 149                                                         false,// force_send_changed
 150                                                         {
 151                                                                 {0,"DrivelineDisengaged"},
 152                                                                 {1,"DrivelineEngaged"},
 153                                                                 {2,"Error"},
 154                                                                 {3,"NotAvailable"}
 155                                                         },// states
 156                                                         true,// writable
 157                                                         decoder_t::decode_state,// decoder
 158                                                         nullptr,// encoder
 159                                                         false,// received
 160                                                         std::make_pair<bool, int>(false, 0),// multiplex
 161                                                         false,// is_big_endian
 162                                                         static_cast<sign_t>(0),// signed
 163                                                         -1,// bit_sign_position
 164                                                         ""// unit
 165                                                 })},
 166                                                 {std::make_shared<signal_t> (signal_t{
 167                                                         "Trans.Input.Shaft.Speed",// generic_name
 168                                                         40,// bit_position
 169                                                         16,// bit_size
 170                                                         0.125000f,// factor
 171                                                         0.00000f,// offset
 172                                                         0,// min_value
 173                                                         0,// max_value
 174                                                         frequency_clock_t(0.00000f),// frequency
 175                                                         true,// send_same
 176                                                         false,// force_send_changed
 177                                                         {
 178                                                         },// states
 179                                                         true,// writable
 180                                                         nullptr,// decoder
 181                                                         nullptr,// encoder
 182                                                         false,// received
 183                                                         std::make_pair<bool, int>(false, 0),// multiplex
 184                                                         false,// is_big_endian
 185                                                         static_cast<sign_t>(0),// signed
 186                                                         -1,// bit_sign_position
 187                                                         "rpm"// unit
 188                                                 })},
 189                                                 {std::make_shared<signal_t> (signal_t{
 190                                                         "Trans.Output.Shaft.Speed",// generic_name
 191                                                         8,// bit_position
 192                                                         16,// bit_size
 193                                                         0.125000f,// factor
 194                                                         0.00000f,// offset
 195                                                         0,// min_value
 196                                                         0,// max_value
 197                                                         frequency_clock_t(0.00000f),// frequency
 198                                                         true,// send_same
 199                                                         false,// force_send_changed
 200                                                         {
 201                                                         },// states
 202                                                         true,// writable
 203                                                         nullptr,// decoder
 204                                                         nullptr,// encoder
 205                                                         false,// received
 206                                                         std::make_pair<bool, int>(false, 0),// multiplex
 207                                                         false,// is_big_endian
 208                                                         static_cast<sign_t>(0),// signed
 209                                                         -1,// bit_sign_position
 210                                                         "rpm"// unit
 211                                                 })},
 212                                                 {std::make_shared<signal_t> (signal_t{
 213                                                         "Trans.Shift.In.Process",// generic_name
 214                                                         4,// bit_position
 215                                                         2,// bit_size
 216                                                         1.00000f,// factor
 217                                                         0.00000f,// offset
 218                                                         0,// min_value
 219                                                         0,// max_value
 220                                                         frequency_clock_t(0.00000f),// frequency
 221                                                         true,// send_same
 222                                                         false,// force_send_changed
 223                                                         {
 224                                                                 {2,"Error"},
 225                                                                 {3,"NotAvailable"},
 226                                                                 {1,"ShiftInProcess"},
 227                                                                 {0,"ShiftIsNotInProcess"}
 228                                                         },// states
 229                                                         true,// writable
 230                                                         decoder_t::decode_state,// decoder
 231                                                         nullptr,// encoder
 232                                                         false,// received
 233                                                         std::make_pair<bool, int>(false, 0),// multiplex
 234                                                         false,// is_big_endian
 235                                                         static_cast<sign_t>(0),// signed
 236                                                         -1,// bit_sign_position
 237                                                         ""// unit
 238                                                 })},
 239                                                 {std::make_shared<signal_t> (signal_t{
 240                                                         "Trns.Trq.Cnvrtr.Lckp.Trnstn.In.Prcess",// generic_name
 241                                                         6,// bit_position
 242                                                         2,// bit_size
 243                                                         1.00000f,// factor
 244                                                         0.00000f,// offset
 245                                                         0,// min_value
 246                                                         0,// max_value
 247                                                         frequency_clock_t(0.00000f),// frequency
 248                                                         true,// send_same
 249                                                         false,// force_send_changed
 250                                                         {
 251                                                                 {2,"Error"},
 252                                                                 {3,"NotAvailable"},
 253                                                                 {1,"TransitionIsInProcess"},
 254                                                                 {0,"TransitionIsNotInProcess"}
 255                                                         },// states
 256                                                         true,// writable
 257                                                         decoder_t::decode_state,// decoder
 258                                                         nullptr,// encoder
 259                                                         false,// received
 260                                                         std::make_pair<bool, int>(false, 0),// multiplex
 261                                                         false,// is_big_endian
 262                                                         static_cast<sign_t>(0),// signed
 263                                                         -1,// bit_sign_position
 264                                                         ""// unit
 265                                                 })},
 266                                                 {std::make_shared<signal_t> (signal_t{
 267                                                         "Trns.Trque.Converter.Lockup.Engaged",// generic_name
 268                                                         2,// bit_position
 269                                                         2,// bit_size
 270                                                         1.00000f,// factor
 271                                                         0.00000f,// offset
 272                                                         0,// min_value
 273                                                         0,// max_value
 274                                                         frequency_clock_t(0.00000f),// frequency
 275                                                         true,// send_same
 276                                                         false,// force_send_changed
 277                                                         {
 278                                                                 {2,"Error"},
 279                                                                 {3,"NotAvailable"},
 280                                                                 {0,"TorqueConverterLockupDisengaged"},
 281                                                                 {1,"TorqueConverterLockupEngaged"}
 282                                                         },// states
 283                                                         true,// writable
 284                                                         decoder_t::decode_state,// decoder
 285                                                         nullptr,// encoder
 286                                                         false,// received
 287                                                         std::make_pair<bool, int>(false, 0),// multiplex
 288                                                         false,// is_big_endian
 289                                                         static_cast<sign_t>(0),// signed
 290                                                         -1,// bit_sign_position
 291                                                         ""// unit
 292                                                 })}
 293                                         } // end signals vector
 294                                 })} // end message_definition entry
 295 ,                               {std::make_shared<message_definition_t>(message_definition_t{"j1939",61444,"EEC1",8,4,true,frequency_clock_t(5.00000f),true,
 296                                         { // beginning signals vector
 297                                                 {std::make_shared<signal_t> (signal_t{
 298                                                         "Actl.Eng.Prcnt.Trque.High.Resolution",// generic_name
 299                                                         4,// bit_position
 300                                                         4,// bit_size
 301                                                         0.125000f,// factor
 302                                                         0.00000f,// offset
 303                                                         0,// min_value
 304                                                         0,// max_value
 305                                                         frequency_clock_t(0.00000f),// frequency
 306                                                         true,// send_same
 307                                                         false,// force_send_changed
 308                                                         {
 309                                                                 {0,"0000"},
 310                                                                 {1,"0125"},
 311                                                                 {7,"0875"},
 312                                                                 {8,"1111NotAvailable"}
 313                                                         },// states
 314                                                         false,// writable
 315                                                         decoder_t::decode_state,// decoder
 316                                                         nullptr,// encoder
 317                                                         false,// received
 318                                                         std::make_pair<bool, int>(false, 0),// multiplex
 319                                                         false,// is_big_endian
 320                                                         static_cast<sign_t>(0),// signed
 321                                                         -1,// bit_sign_position
 322                                                         "%"// unit
 323                                                 })},
 324                                                 {std::make_shared<signal_t> (signal_t{
 325                                                         "Actual.Eng.Percent.Torque",// generic_name
 326                                                         16,// bit_position
 327                                                         8,// bit_size
 328                                                         1.00000f,// factor
 329                                                         -125.000f,// offset
 330                                                         0,// min_value
 331                                                         0,// max_value
 332                                                         frequency_clock_t(0.00000f),// frequency
 333                                                         true,// send_same
 334                                                         false,// force_send_changed
 335                                                         {
 336                                                         },// states
 337                                                         false,// writable
 338                                                         nullptr,// decoder
 339                                                         nullptr,// encoder
 340                                                         false,// received
 341                                                         std::make_pair<bool, int>(false, 0),// multiplex
 342                                                         false,// is_big_endian
 343                                                         static_cast<sign_t>(0),// signed
 344                                                         -1,// bit_sign_position
 345                                                         "%"// unit
 346                                                 })},
 347                                                 {std::make_shared<signal_t> (signal_t{
 348                                                         "Drivers.Demand.Eng.Percent.Torque",// generic_name
 349                                                         8,// bit_position
 350                                                         8,// bit_size
 351                                                         1.00000f,// factor
 352                                                         -125.000f,// offset
 353                                                         0,// min_value
 354                                                         0,// max_value
 355                                                         frequency_clock_t(0.00000f),// frequency
 356                                                         true,// send_same
 357                                                         false,// force_send_changed
 358                                                         {
 359                                                         },// states
 360                                                         false,// writable
 361                                                         nullptr,// decoder
 362                                                         nullptr,// encoder
 363                                                         false,// received
 364                                                         std::make_pair<bool, int>(false, 0),// multiplex
 365                                                         false,// is_big_endian
 366                                                         static_cast<sign_t>(0),// signed
 367                                                         -1,// bit_sign_position
 368                                                         "%"// unit
 369                                                 })},
 370                                                 {std::make_shared<signal_t> (signal_t{
 371                                                         "Eng.Demand.Percent.Torque",// generic_name
 372                                                         56,// bit_position
 373                                                         8,// bit_size
 374                                                         1.00000f,// factor
 375                                                         -125.000f,// offset
 376                                                         0,// min_value
 377                                                         0,// max_value
 378                                                         frequency_clock_t(0.00000f),// frequency
 379                                                         true,// send_same
 380                                                         false,// force_send_changed
 381                                                         {
 382                                                         },// states
 383                                                         false,// writable
 384                                                         nullptr,// decoder
 385                                                         nullptr,// encoder
 386                                                         false,// received
 387                                                         std::make_pair<bool, int>(false, 0),// multiplex
 388                                                         false,// is_big_endian
 389                                                         static_cast<sign_t>(0),// signed
 390                                                         -1,// bit_sign_position
 391                                                         "%"// unit
 392                                                 })},
 393                                                 {std::make_shared<signal_t> (signal_t{
 394                                                         "Eng.Speed",// generic_name
 395                                                         24,// bit_position
 396                                                         16,// bit_size
 397                                                         0.125000f,// factor
 398                                                         0.00000f,// offset
 399                                                         0,// min_value
 400                                                         0,// max_value
 401                                                         frequency_clock_t(0.00000f),// frequency
 402                                                         true,// send_same
 403                                                         false,// force_send_changed
 404                                                         {
 405                                                         },// states
 406                                                         false,// writable
 407                                                         nullptr,// decoder
 408                                                         nullptr,// encoder
 409                                                         false,// received
 410                                                         std::make_pair<bool, int>(false, 0),// multiplex
 411                                                         false,// is_big_endian
 412                                                         static_cast<sign_t>(0),// signed
 413                                                         -1,// bit_sign_position
 414                                                         "rpm"// unit
 415                                                 })},
 416                                                 {std::make_shared<signal_t> (signal_t{
 417                                                         "Eng.Starter.Mode",// generic_name
 418                                                         48,// bit_position
 419                                                         4,// bit_size
 420                                                         1.00000f,// factor
 421                                                         0.00000f,// offset
 422                                                         0,// min_value
 423                                                         0,// max_value
 424                                                         frequency_clock_t(0.00000f),// frequency
 425                                                         true,// send_same
 426                                                         false,// force_send_changed
 427                                                         {
 428                                                                 {9,"1011Reserved"},
 429                                                                 {14,"error"},
 430                                                                 {15,"notAvailable"},
 431                                                                 {0,"startNotRqed"},
 432                                                                 {2,"starterActiveGearEngaged"},
 433                                                                 {1,"starterActiveGearNotEngaged"},
 434                                                                 {12,"starterInhibitedReasonUnknown"},
 435                                                                 {3,"strtFnshdStrtrNtActvAftrHvngBnA"},
 436                                                                 {6,"strtrInhbtdDTDrvlnEnggdOthrTrns"},
 437                                                                 {5,"strtrInhbtdDTEngNtReadyForStart"},
 438                                                                 {7,"strtrInhbtdDToActiveImmobilizer"},
 439                                                                 {4,"strtrInhbtdDToEngAlreadyRunning"},
 440                                                                 {8,"strtrInhbtdDueToStarterOvertemp"}
 441                                                         },// states
 442                                                         false,// writable
 443                                                         decoder_t::decode_state,// decoder
 444                                                         nullptr,// encoder
 445                                                         false,// received
 446                                                         std::make_pair<bool, int>(false, 0),// multiplex
 447                                                         false,// is_big_endian
 448                                                         static_cast<sign_t>(0),// signed
 449                                                         -1,// bit_sign_position
 450                                                         ""// unit
 451                                                 })},
 452                                                 {std::make_shared<signal_t> (signal_t{
 453                                                         "Eng.Torque.Mode",// generic_name
 454                                                         0,// bit_position
 455                                                         4,// bit_size
 456                                                         1.00000f,// factor
 457                                                         0.00000f,// offset
 458                                                         0,// min_value
 459                                                         0,// max_value
 460                                                         frequency_clock_t(0.00000f),// frequency
 461                                                         true,// send_same
 462                                                         false,// force_send_changed
 463                                                         {
 464                                                                 {7,"ABS control"},
 465                                                                 {5,"ASR control"},
 466                                                                 {1,"Accelerator pedal/operator selec"},
 467                                                                 {10,"Braking system"},
 468                                                                 {2,"Cruise control"},
 469                                                                 {9,"High speed governor"},
 470                                                                 {0,"Low idle governor/no request (de"},
 471                                                                 {15,"Not available"},
 472                                                                 {3,"PTO governor"},
 473                                                                 {11,"Remote accelerator"},
 474                                                                 {4,"Road speed governor"},
 475                                                                 {8,"Torque limiting"},
 476                                                                 {6,"Transmission control"}
 477                                                         },// states
 478                                                         false,// writable
 479                                                         decoder_t::decode_state,// decoder
 480                                                         nullptr,// encoder
 481                                                         false,// received
 482                                                         std::make_pair<bool, int>(false, 0),// multiplex
 483                                                         false,// is_big_endian
 484                                                         static_cast<sign_t>(0),// signed
 485                                                         -1,// bit_sign_position
 486                                                         ""// unit
 487                                                 })},
 488                                                 {std::make_shared<signal_t> (signal_t{
 489                                                         "Src.AddrssOf.Ctrllng.Dvc.Fr.Eng.Cntrl",// generic_name
 490                                                         40,// bit_position
 491                                                         8,// bit_size
 492                                                         1.00000f,// factor
 493                                                         0.00000f,// offset
 494                                                         0,// min_value
 495                                                         0,// max_value
 496                                                         frequency_clock_t(0.00000f),// frequency
 497                                                         true,// send_same
 498                                                         false,// force_send_changed
 499                                                         {
 500                                                         },// states
 501                                                         false,// writable
 502                                                         nullptr,// decoder
 503                                                         nullptr,// encoder
 504                                                         false,// received
 505                                                         std::make_pair<bool, int>(false, 0),// multiplex
 506                                                         false,// is_big_endian
 507                                                         static_cast<sign_t>(0),// signed
 508                                                         -1,// bit_sign_position
 509                                                         ""// unit
 510                                                 })}
 511                                         } // end signals vector
 512                                 })} // end message_definition entry
 513 ,                               {std::make_shared<message_definition_t>(message_definition_t{"j1939",61449,"VDC2",8,4,true,frequency_clock_t(5.00000f),true,
 514                                         { // beginning signals vector
 515                                                 {std::make_shared<signal_t> (signal_t{
 516                                                         "Lateral.Acceleration",// generic_name
 517                                                         40,// bit_position
 518                                                         16,// bit_size
 519                                                         0.000488281f,// factor
 520                                                         -15.6870f,// offset
 521                                                         0,// min_value
 522                                                         0,// max_value
 523                                                         frequency_clock_t(0.00000f),// frequency
 524                                                         true,// send_same
 525                                                         false,// force_send_changed
 526                                                         {
 527                                                         },// states
 528                                                         false,// writable
 529                                                         nullptr,// decoder
 530                                                         nullptr,// encoder
 531                                                         false,// received
 532                                                         std::make_pair<bool, int>(false, 0),// multiplex
 533                                                         false,// is_big_endian
 534                                                         static_cast<sign_t>(0),// signed
 535                                                         -1,// bit_sign_position
 536                                                         "m/s/s"// unit
 537                                                 })},
 538                                                 {std::make_shared<signal_t> (signal_t{
 539                                                         "Longitudinal.Acceleration",// generic_name
 540                                                         56,// bit_position
 541                                                         8,// bit_size
 542                                                         0.100000f,// factor
 543                                                         -12.5000f,// offset
 544                                                         0,// min_value
 545                                                         0,// max_value
 546                                                         frequency_clock_t(0.00000f),// frequency
 547                                                         true,// send_same
 548                                                         false,// force_send_changed
 549                                                         {
 550                                                         },// states
 551                                                         false,// writable
 552                                                         nullptr,// decoder
 553                                                         nullptr,// encoder
 554                                                         false,// received
 555                                                         std::make_pair<bool, int>(false, 0),// multiplex
 556                                                         false,// is_big_endian
 557                                                         static_cast<sign_t>(0),// signed
 558                                                         -1,// bit_sign_position
 559                                                         "m/s/s"// unit
 560                                                 })},
 561                                                 {std::make_shared<signal_t> (signal_t{
 562                                                         "Steer.Wheel.Angle",// generic_name
 563                                                         0,// bit_position
 564                                                         16,// bit_size
 565                                                         0.000976562f,// factor
 566                                                         -31.3740f,// offset
 567                                                         0,// min_value
 568                                                         0,// max_value
 569                                                         frequency_clock_t(0.00000f),// frequency
 570                                                         true,// send_same
 571                                                         false,// force_send_changed
 572                                                         {
 573                                                         },// states
 574                                                         false,// writable
 575                                                         nullptr,// decoder
 576                                                         nullptr,// encoder
 577                                                         false,// received
 578                                                         std::make_pair<bool, int>(false, 0),// multiplex
 579                                                         false,// is_big_endian
 580                                                         static_cast<sign_t>(0),// signed
 581                                                         -1,// bit_sign_position
 582                                                         "rad"// unit
 583                                                 })},
 584                                                 {std::make_shared<signal_t> (signal_t{
 585                                                         "Steer.Wheel.Angle.Sensor.Type",// generic_name
 586                                                         22,// bit_position
 587                                                         2,// bit_size
 588                                                         1.00000f,// factor
 589                                                         0.00000f,// offset
 590                                                         0,// min_value
 591                                                         0,// max_value
 592                                                         frequency_clock_t(0.00000f),// frequency
 593                                                         true,// send_same
 594                                                         false,// force_send_changed
 595                                                         {
 596                                                                 {1,"AbsMeasuringPrinciple"},
 597                                                                 {3,"NotAvailable"},
 598                                                                 {0,"RelativeMeasuringPrinciple"},
 599                                                                 {2,"Reserved"}
 600                                                         },// states
 601                                                         false,// writable
 602                                                         decoder_t::decode_state,// decoder
 603                                                         nullptr,// encoder
 604                                                         false,// received
 605                                                         std::make_pair<bool, int>(false, 0),// multiplex
 606                                                         false,// is_big_endian
 607                                                         static_cast<sign_t>(0),// signed
 608                                                         -1,// bit_sign_position
 609                                                         ""// unit
 610                                                 })},
 611                                                 {std::make_shared<signal_t> (signal_t{
 612                                                         "Steer.Wheel.Turn.Counter",// generic_name
 613                                                         16,// bit_position
 614                                                         6,// bit_size
 615                                                         1.00000f,// factor
 616                                                         -32.0000f,// offset
 617                                                         0,// min_value
 618                                                         0,// max_value
 619                                                         frequency_clock_t(0.00000f),// frequency
 620                                                         true,// send_same
 621                                                         false,// force_send_changed
 622                                                         {
 623                                                         },// states
 624                                                         false,// writable
 625                                                         nullptr,// decoder
 626                                                         nullptr,// encoder
 627                                                         false,// received
 628                                                         std::make_pair<bool, int>(false, 0),// multiplex
 629                                                         false,// is_big_endian
 630                                                         static_cast<sign_t>(0),// signed
 631                                                         -1,// bit_sign_position
 632                                                         "turns"// unit
 633                                                 })},
 634                                                 {std::make_shared<signal_t> (signal_t{
 635                                                         "Yaw.Rate",// generic_name
 636                                                         24,// bit_position
 637                                                         16,// bit_size
 638                                                         0.000122070f,// factor
 639                                                         -3.92000f,// offset
 640                                                         0,// min_value
 641                                                         0,// max_value
 642                                                         frequency_clock_t(0.00000f),// frequency
 643                                                         true,// send_same
 644                                                         false,// force_send_changed
 645                                                         {
 646                                                         },// states
 647                                                         false,// writable
 648                                                         nullptr,// decoder
 649                                                         nullptr,// encoder
 650                                                         false,// received
 651                                                         std::make_pair<bool, int>(false, 0),// multiplex
 652                                                         false,// is_big_endian
 653                                                         static_cast<sign_t>(0),// signed
 654                                                         -1,// bit_sign_position
 655                                                         "rad/s"// unit
 656                                                 })}
 657                                         } // end signals vector
 658                                 })} // end message_definition entry
 659 ,                               {std::make_shared<message_definition_t>(message_definition_t{"j1939",65215,"EBC2",8,4,true,frequency_clock_t(5.00000f),true,
 660                                         { // beginning signals vector
 661                                                 {std::make_shared<signal_t> (signal_t{
 662                                                         "Front.Axle.Speed",// generic_name
 663                                                         0,// bit_position
 664                                                         16,// bit_size
 665                                                         0.00390625f,// factor
 666                                                         0.00000f,// offset
 667                                                         0,// min_value
 668                                                         0,// max_value
 669                                                         frequency_clock_t(0.00000f),// frequency
 670                                                         true,// send_same
 671                                                         false,// force_send_changed
 672                                                         {
 673                                                         },// states
 674                                                         false,// writable
 675                                                         nullptr,// decoder
 676                                                         nullptr,// encoder
 677                                                         false,// received
 678                                                         std::make_pair<bool, int>(false, 0),// multiplex
 679                                                         false,// is_big_endian
 680                                                         static_cast<sign_t>(0),// signed
 681                                                         -1,// bit_sign_position
 682                                                         "km/h"// unit
 683                                                 })},
 684                                                 {std::make_shared<signal_t> (signal_t{
 685                                                         "Relative.Speed.Front.Axle.Left.Wheel",// generic_name
 686                                                         16,// bit_position
 687                                                         8,// bit_size
 688                                                         0.0625000f,// factor
 689                                                         -7.81250f,// offset
 690                                                         0,// min_value
 691                                                         0,// max_value
 692                                                         frequency_clock_t(0.00000f),// frequency
 693                                                         true,// send_same
 694                                                         false,// force_send_changed
 695                                                         {
 696                                                         },// states
 697                                                         false,// writable
 698                                                         nullptr,// decoder
 699                                                         nullptr,// encoder
 700                                                         false,// received
 701                                                         std::make_pair<bool, int>(false, 0),// multiplex
 702                                                         false,// is_big_endian
 703                                                         static_cast<sign_t>(0),// signed
 704                                                         -1,// bit_sign_position
 705                                                         "km/h"// unit
 706                                                 })},
 707                                                 {std::make_shared<signal_t> (signal_t{
 708                                                         "Relative.Speed.Rear.Axle1.Left.Wheel",// generic_name
 709                                                         32,// bit_position
 710                                                         8,// bit_size
 711                                                         0.0625000f,// factor
 712                                                         -7.81250f,// offset
 713                                                         0,// min_value
 714                                                         0,// max_value
 715                                                         frequency_clock_t(0.00000f),// frequency
 716                                                         true,// send_same
 717                                                         false,// force_send_changed
 718                                                         {
 719                                                         },// states
 720                                                         false,// writable
 721                                                         nullptr,// decoder
 722                                                         nullptr,// encoder
 723                                                         false,// received
 724                                                         std::make_pair<bool, int>(false, 0),// multiplex
 725                                                         false,// is_big_endian
 726                                                         static_cast<sign_t>(0),// signed
 727                                                         -1,// bit_sign_position
 728                                                         "km/h"// unit
 729                                                 })},
 730                                                 {std::make_shared<signal_t> (signal_t{
 731                                                         "Relative.Speed.Rear.Axle2.Left.Wheel",// generic_name
 732                                                         48,// bit_position
 733                                                         8,// bit_size
 734                                                         0.0625000f,// factor
 735                                                         -7.81250f,// offset
 736                                                         0,// min_value
 737                                                         0,// max_value
 738                                                         frequency_clock_t(0.00000f),// frequency
 739                                                         true,// send_same
 740                                                         false,// force_send_changed
 741                                                         {
 742                                                         },// states
 743                                                         false,// writable
 744                                                         nullptr,// decoder
 745                                                         nullptr,// encoder
 746                                                         false,// received
 747                                                         std::make_pair<bool, int>(false, 0),// multiplex
 748                                                         false,// is_big_endian
 749                                                         static_cast<sign_t>(0),// signed
 750                                                         -1,// bit_sign_position
 751                                                         "km/h"// unit
 752                                                 })},
 753                                                 {std::make_shared<signal_t> (signal_t{
 754                                                         "Rlative.Speed.Front.Axle.Right.Wheel",// generic_name
 755                                                         24,// bit_position
 756                                                         8,// bit_size
 757                                                         0.0625000f,// factor
 758                                                         -7.81250f,// offset
 759                                                         0,// min_value
 760                                                         0,// max_value
 761                                                         frequency_clock_t(0.00000f),// frequency
 762                                                         true,// send_same
 763                                                         false,// force_send_changed
 764                                                         {
 765                                                         },// states
 766                                                         false,// writable
 767                                                         nullptr,// decoder
 768                                                         nullptr,// encoder
 769                                                         false,// received
 770                                                         std::make_pair<bool, int>(false, 0),// multiplex
 771                                                         false,// is_big_endian
 772                                                         static_cast<sign_t>(0),// signed
 773                                                         -1,// bit_sign_position
 774                                                         "km/h"// unit
 775                                                 })},
 776                                                 {std::make_shared<signal_t> (signal_t{
 777                                                         "Rlative.Speed.Rear.Axle1.Right.Wheel",// generic_name
 778                                                         40,// bit_position
 779                                                         8,// bit_size
 780                                                         0.0625000f,// factor
 781                                                         -7.81250f,// offset
 782                                                         0,// min_value
 783                                                         0,// max_value
 784                                                         frequency_clock_t(0.00000f),// frequency
 785                                                         true,// send_same
 786                                                         false,// force_send_changed
 787                                                         {
 788                                                         },// states
 789                                                         false,// writable
 790                                                         nullptr,// decoder
 791                                                         nullptr,// encoder
 792                                                         false,// received
 793                                                         std::make_pair<bool, int>(false, 0),// multiplex
 794                                                         false,// is_big_endian
 795                                                         static_cast<sign_t>(0),// signed
 796                                                         -1,// bit_sign_position
 797                                                         "km/h"// unit
 798                                                 })},
 799                                                 {std::make_shared<signal_t> (signal_t{
 800                                                         "Rlative.Speed.Rear.Axle2.Right.Wheel",// generic_name
 801                                                         56,// bit_position
 802                                                         8,// bit_size
 803                                                         0.0625000f,// factor
 804                                                         -7.81250f,// offset
 805                                                         0,// min_value
 806                                                         0,// max_value
 807                                                         frequency_clock_t(0.00000f),// frequency
 808                                                         true,// send_same
 809                                                         false,// force_send_changed
 810                                                         {
 811                                                         },// states
 812                                                         false,// writable
 813                                                         nullptr,// decoder
 814                                                         nullptr,// encoder
 815                                                         false,// received
 816                                                         std::make_pair<bool, int>(false, 0),// multiplex
 817                                                         false,// is_big_endian
 818                                                         static_cast<sign_t>(0),// signed
 819                                                         -1,// bit_sign_position
 820                                                         "km/h"// unit
 821                                                 })}
 822                                         } // end signals vector
 823                                 })} // end message_definition entry
 824 ,                               {std::make_shared<message_definition_t>(message_definition_t{"j1939",65253,"HOURS",8,4,true,frequency_clock_t(5.00000f),true,
 825                                         { // beginning signals vector
 826                                                 {std::make_shared<signal_t> (signal_t{
 827                                                         "Eng.Total.Hours.Of.Operation",// generic_name
 828                                                         0,// bit_position
 829                                                         32,// bit_size
 830                                                         0.0500000f,// factor
 831                                                         0.00000f,// offset
 832                                                         0,// min_value
 833                                                         0,// max_value
 834                                                         frequency_clock_t(0.00000f),// frequency
 835                                                         true,// send_same
 836                                                         false,// force_send_changed
 837                                                         {
 838                                                         },// states
 839                                                         false,// writable
 840                                                         nullptr,// decoder
 841                                                         nullptr,// encoder
 842                                                         false,// received
 843                                                         std::make_pair<bool, int>(false, 0),// multiplex
 844                                                         false,// is_big_endian
 845                                                         static_cast<sign_t>(0),// signed
 846                                                         -1,// bit_sign_position
 847                                                         "hr"// unit
 848                                                 })},
 849                                                 {std::make_shared<signal_t> (signal_t{
 850                                                         "Eng.Total.Revolutions",// generic_name
 851                                                         32,// bit_position
 852                                                         32,// bit_size
 853                                                         1000.00f,// factor
 854                                                         0.00000f,// offset
 855                                                         0,// min_value
 856                                                         0,// max_value
 857                                                         frequency_clock_t(0.00000f),// frequency
 858                                                         true,// send_same
 859                                                         false,// force_send_changed
 860                                                         {
 861                                                         },// states
 862                                                         false,// writable
 863                                                         nullptr,// decoder
 864                                                         nullptr,// encoder
 865                                                         false,// received
 866                                                         std::make_pair<bool, int>(false, 0),// multiplex
 867                                                         false,// is_big_endian
 868                                                         static_cast<sign_t>(0),// signed
 869                                                         -1,// bit_sign_position
 870                                                         "r"// unit
 871                                                 })}
 872                                         } // end signals vector
 873                                 })} // end message_definition entry
 874 ,                               {std::make_shared<message_definition_t>(message_definition_t{"j1939",65262,"ET1",8,4,true,frequency_clock_t(5.00000f),true,
 875                                         { // beginning signals vector
 876                                                 {std::make_shared<signal_t> (signal_t{
 877                                                         "Eng.Coolant.Temp",// generic_name
 878                                                         0,// bit_position
 879                                                         8,// bit_size
 880                                                         0.0312500f,// factor
 881                                                         -273.000f,// offset
 882                                                         0,// min_value
 883                                                         0,// max_value
 884                                                         frequency_clock_t(0.00000f),// frequency
 885                                                         true,// send_same
 886                                                         false,// force_send_changed
 887                                                         {
 888                                                         },// states
 889                                                         false,// writable
 890                                                         nullptr,// decoder
 891                                                         nullptr,// encoder
 892                                                         false,// received
 893                                                         std::make_pair<bool, int>(false, 0),// multiplex
 894                                                         false,// is_big_endian
 895                                                         static_cast<sign_t>(0),// signed
 896                                                         -1,// bit_sign_position
 897                                                         "deg C"// unit
 898                                                 })},
 899                                                 {std::make_shared<signal_t> (signal_t{
 900                                                         "Eng.Fuel.Temp1",// generic_name
 901                                                         8,// bit_position
 902                                                         8,// bit_size
 903                                                         1.00000f,// factor
 904                                                         -40.0000f,// offset
 905                                                         0,// min_value
 906                                                         0,// max_value
 907                                                         frequency_clock_t(0.00000f),// frequency
 908                                                         true,// send_same
 909                                                         false,// force_send_changed
 910                                                         {
 911                                                         },// states
 912                                                         false,// writable
 913                                                         nullptr,// decoder
 914                                                         nullptr,// encoder
 915                                                         false,// received
 916                                                         std::make_pair<bool, int>(false, 0),// multiplex
 917                                                         false,// is_big_endian
 918                                                         static_cast<sign_t>(0),// signed
 919                                                         -1,// bit_sign_position
 920                                                         "deg C"// unit
 921                                                 })},
 922                                                 {std::make_shared<signal_t> (signal_t{
 923                                                         "Eng.Intercooler.Temp",// generic_name
 924                                                         48,// bit_position
 925                                                         8,// bit_size
 926                                                         1.00000f,// factor
 927                                                         -40.0000f,// offset
 928                                                         0,// min_value
 929                                                         0,// max_value
 930                                                         frequency_clock_t(0.00000f),// frequency
 931                                                         true,// send_same
 932                                                         false,// force_send_changed
 933                                                         {
 934                                                         },// states
 935                                                         false,// writable
 936                                                         nullptr,// decoder
 937                                                         nullptr,// encoder
 938                                                         false,// received
 939                                                         std::make_pair<bool, int>(false, 0),// multiplex
 940                                                         false,// is_big_endian
 941                                                         static_cast<sign_t>(0),// signed
 942                                                         -1,// bit_sign_position
 943                                                         "deg C"// unit
 944                                                 })},
 945                                                 {std::make_shared<signal_t> (signal_t{
 946                                                         "Eng.Intercooler.Thermostat.Opening",// generic_name
 947                                                         56,// bit_position
 948                                                         8,// bit_size
 949                                                         0.400000f,// factor
 950                                                         0.00000f,// offset
 951                                                         0,// min_value
 952                                                         0,// max_value
 953                                                         frequency_clock_t(0.00000f),// frequency
 954                                                         true,// send_same
 955                                                         false,// force_send_changed
 956                                                         {
 957                                                         },// states
 958                                                         false,// writable
 959                                                         nullptr,// decoder
 960                                                         nullptr,// encoder
 961                                                         false,// received
 962                                                         std::make_pair<bool, int>(false, 0),// multiplex
 963                                                         false,// is_big_endian
 964                                                         static_cast<sign_t>(0),// signed
 965                                                         -1,// bit_sign_position
 966                                                         "%"// unit
 967                                                 })},
 968                                                 {std::make_shared<signal_t> (signal_t{
 969                                                         "Eng.Oil.Temp1",// generic_name
 970                                                         16,// bit_position
 971                                                         16,// bit_size
 972                                                         0.0312500f,// factor
 973                                                         -273.000f,// offset
 974                                                         0,// min_value
 975                                                         0,// max_value
 976                                                         frequency_clock_t(0.00000f),// frequency
 977                                                         true,// send_same
 978                                                         false,// force_send_changed
 979                                                         {
 980                                                         },// states
 981                                                         false,// writable
 982                                                         nullptr,// decoder
 983                                                         nullptr,// encoder
 984                                                         false,// received
 985                                                         std::make_pair<bool, int>(false, 0),// multiplex
 986                                                         false,// is_big_endian
 987                                                         static_cast<sign_t>(0),// signed
 988                                                         -1,// bit_sign_position
 989                                                         "deg C"// unit
 990                                                 })},
 991                                                 {std::make_shared<signal_t> (signal_t{
 992                                                         "Eng.Turbo.Oil.Temp",// generic_name
 993                                                         32,// bit_position
 994                                                         16,// bit_size
 995                                                         0.0312500f,// factor
 996                                                         -273.000f,// offset
 997                                                         0,// min_value
 998                                                         0,// max_value
 999                                                         frequency_clock_t(0.00000f),// frequency
1000                                                         true,// send_same
1001                                                         false,// force_send_changed
1002                                                         {
1003                                                         },// states
1004                                                         false,// writable
1005                                                         nullptr,// decoder
1006                                                         nullptr,// encoder
1007                                                         false,// received
1008                                                         std::make_pair<bool, int>(false, 0),// multiplex
1009                                                         false,// is_big_endian
1010                                                         static_cast<sign_t>(0),// signed
1011                                                         -1,// bit_sign_position
1012                                                         "deg C"// unit
1013                                                 })}
1014                                         } // end signals vector
1015                                 })} // end message_definition entry
1016
1017                 }, // end message_definition vector
1018                         { // beginning diagnostic_messages_ vector
1019
1020                         } // end diagnostic_messages_ vector
1021                 })} // end message_set entry
1022         } // end message_set vector
1023 {
1024         for(std::shared_ptr<message_set_t> cms: message_set_)
1025         {
1026                 std::vector<std::shared_ptr<message_definition_t>> messages_definition = cms->get_messages_definition();
1027                 for(std::shared_ptr<message_definition_t> cmd : messages_definition)
1028                 {
1029                         cmd->set_parent(cms);
1030                         std::vector<std::shared_ptr<signal_t>> signals = cmd->get_signals();
1031                         for(std::shared_ptr<signal_t> sig: signals)
1032                         {
1033                                 sig->set_parent(cmd);
1034                         }
1035                 }
1036
1037                 std::vector<std::shared_ptr<diagnostic_message_t>> diagnostic_messages = cms->get_diagnostic_messages();
1038                 for(std::shared_ptr<diagnostic_message_t> dm : diagnostic_messages)
1039                 {
1040                         dm->set_parent(cms);
1041                 }
1042         }
1043                 }
1044
1045 const std::string application_t::get_diagnostic_bus() const
1046 {
1047         return "";
1048 }
1049
1050