examples/j1939/j1939-signals.cpp

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