examples/agl-vcar/application-generated.cpp

   1 #include "application.hpp"
   2 #include "../can/can-decoder.hpp"
   3 #include "../can/can-encoder.hpp"
   4
   5 application_t::application_t()
   6         : can_bus_manager_{utils::config_parser_t{"/etc/dev-mapping.conf"}}
   7         , message_set_{
   8                 {std::make_shared<message_set_t>(message_set_t{0,"AGL Virtual Car",
   9                         { // beginning message_definition_ vector
  10                                 {std::make_shared<message_definition_t>(message_definition_t{"ls",0x21,"",8,2,frequency_clock_t(5.00000f),true,
  11                                         { // beginning signals vector
  12                                                 {std::make_shared<signal_t> (signal_t{
  13                                                         "steering_wheel.cruise.cancel",// generic_name
  14                                                         52,// bit_position
  15                                                         1,// 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                                                         },// states
  25                                                         false,// writable
  26                                                         decoder_t::decode_boolean,// decoder
  27                                                         nullptr,// encoder
  28                                                         false,// received
  29                                                         std::make_pair<bool, int>(false, 0),// multiplex
  30                                                         false,// is_big_endian
  31                                                         false,// is_signed
  32                                                         ""// unit
  33                                                 })},
  34                                                 {std::make_shared<signal_t> (signal_t{
  35                                                         "steering_wheel.cruise.distance",// generic_name
  36                                                         55,// bit_position
  37                                                         1,// bit_size
  38                                                         1.00000f,// factor
  39                                                         0.00000f,// offset
  40                                                         0,// min_value
  41                                                         0,// max_value
  42                                                         frequency_clock_t(0.00000f),// frequency
  43                                                         true,// send_same
  44                                                         false,// force_send_changed
  45                                                         {
  46                                                         },// states
  47                                                         false,// writable
  48                                                         decoder_t::decode_boolean,// decoder
  49                                                         nullptr,// encoder
  50                                                         false,// received
  51                                                         std::make_pair<bool, int>(false, 0),// multiplex
  52                                                         false,// is_big_endian
  53                                                         false,// is_signed
  54                                                         ""// unit
  55                                                 })},
  56                                                 {std::make_shared<signal_t> (signal_t{
  57                                                         "steering_wheel.cruise.enable",// generic_name
  58                                                         48,// bit_position
  59                                                         1,// bit_size
  60                                                         1.00000f,// factor
  61                                                         0.00000f,// offset
  62                                                         0,// min_value
  63                                                         0,// max_value
  64                                                         frequency_clock_t(0.00000f),// frequency
  65                                                         true,// send_same
  66                                                         false,// force_send_changed
  67                                                         {
  68                                                         },// states
  69                                                         false,// writable
  70                                                         decoder_t::decode_boolean,// decoder
  71                                                         nullptr,// encoder
  72                                                         false,// received
  73                                                         std::make_pair<bool, int>(false, 0),// multiplex
  74                                                         false,// is_big_endian
  75                                                         false,// is_signed
  76                                                         ""// unit
  77                                                 })},
  78                                                 {std::make_shared<signal_t> (signal_t{
  79                                                         "steering_wheel.cruise.limit",// generic_name
  80                                                         54,// bit_position
  81                                                         1,// bit_size
  82                                                         1.00000f,// factor
  83                                                         0.00000f,// offset
  84                                                         0,// min_value
  85                                                         0,// max_value
  86                                                         frequency_clock_t(0.00000f),// frequency
  87                                                         true,// send_same
  88                                                         false,// force_send_changed
  89                                                         {
  90                                                         },// states
  91                                                         false,// writable
  92                                                         decoder_t::decode_boolean,// decoder
  93                                                         nullptr,// encoder
  94                                                         false,// received
  95                                                         std::make_pair<bool, int>(false, 0),// multiplex
  96                                                         false,// is_big_endian
  97                                                         false,// is_signed
  98                                                         ""// unit
  99                                                 })},
 100                                                 {std::make_shared<signal_t> (signal_t{
 101                                                         "steering_wheel.cruise.resume",// generic_name
 102                                                         49,// bit_position
 103                                                         1,// bit_size
 104                                                         1.00000f,// factor
 105                                                         0.00000f,// offset
 106                                                         0,// min_value
 107                                                         0,// max_value
 108                                                         frequency_clock_t(0.00000f),// frequency
 109                                                         true,// send_same
 110                                                         false,// force_send_changed
 111                                                         {
 112                                                         },// states
 113                                                         false,// writable
 114                                                         decoder_t::decode_boolean,// decoder
 115                                                         nullptr,// encoder
 116                                                         false,// received
 117                                                         std::make_pair<bool, int>(false, 0),// multiplex
 118                                                         false,// is_big_endian
 119                                                         false,// is_signed
 120                                                         ""// unit
 121                                                 })},
 122                                                 {std::make_shared<signal_t> (signal_t{
 123                                                         "steering_wheel.cruise.set",// generic_name
 124                                                         51,// bit_position
 125                                                         1,// bit_size
 126                                                         1.00000f,// factor
 127                                                         0.00000f,// offset
 128                                                         0,// min_value
 129                                                         0,// max_value
 130                                                         frequency_clock_t(0.00000f),// frequency
 131                                                         true,// send_same
 132                                                         false,// force_send_changed
 133                                                         {
 134                                                         },// states
 135                                                         false,// writable
 136                                                         decoder_t::decode_boolean,// decoder
 137                                                         nullptr,// encoder
 138                                                         false,// received
 139                                                         std::make_pair<bool, int>(false, 0),// multiplex
 140                                                         false,// is_big_endian
 141                                                         false,// is_signed
 142                                                         ""// unit
 143                                                 })},
 144                                                 {std::make_shared<signal_t> (signal_t{
 145                                                         "steering_wheel.horn",// generic_name
 146                                                         56,// bit_position
 147                                                         1,// bit_size
 148                                                         1.00000f,// factor
 149                                                         0.00000f,// offset
 150                                                         0,// min_value
 151                                                         0,// max_value
 152                                                         frequency_clock_t(0.00000f),// frequency
 153                                                         true,// send_same
 154                                                         false,// force_send_changed
 155                                                         {
 156                                                         },// states
 157                                                         false,// writable
 158                                                         decoder_t::decode_boolean,// decoder
 159                                                         nullptr,// encoder
 160                                                         false,// received
 161                                                         std::make_pair<bool, int>(false, 0),// multiplex
 162                                                         false,// is_big_endian
 163                                                         false,// is_signed
 164                                                         ""// unit
 165                                                 })},
 166                                                 {std::make_shared<signal_t> (signal_t{
 167                                                         "steering_wheel.info",// generic_name
 168                                                         38,// bit_position
 169                                                         1,// bit_size
 170                                                         1.00000f,// 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                                                         false,// writable
 180                                                         decoder_t::decode_boolean,// decoder
 181                                                         nullptr,// encoder
 182                                                         false,// received
 183                                                         std::make_pair<bool, int>(false, 0),// multiplex
 184                                                         false,// is_big_endian
 185                                                         false,// is_signed
 186                                                         ""// unit
 187                                                 })},
 188                                                 {std::make_shared<signal_t> (signal_t{
 189                                                         "steering_wheel.lane_departure_warning",// generic_name
 190                                                         63,// bit_position
 191                                                         1,// bit_size
 192                                                         1.00000f,// factor
 193                                                         0.00000f,// offset
 194                                                         0,// min_value
 195                                                         0,// max_value
 196                                                         frequency_clock_t(0.00000f),// frequency
 197                                                         true,// send_same
 198                                                         false,// force_send_changed
 199                                                         {
 200                                                         },// states
 201                                                         false,// writable
 202                                                         decoder_t::decode_boolean,// decoder
 203                                                         nullptr,// encoder
 204                                                         false,// received
 205                                                         std::make_pair<bool, int>(false, 0),// multiplex
 206                                                         false,// is_big_endian
 207                                                         false,// is_signed
 208                                                         ""// unit
 209                                                 })},
 210                                                 {std::make_shared<signal_t> (signal_t{
 211                                                         "steering_wheel.mode",// generic_name
 212                                                         34,// bit_position
 213                                                         1,// bit_size
 214                                                         1.00000f,// factor
 215                                                         0.00000f,// offset
 216                                                         0,// min_value
 217                                                         0,// max_value
 218                                                         frequency_clock_t(0.00000f),// frequency
 219                                                         true,// send_same
 220                                                         false,// force_send_changed
 221                                                         {
 222                                                         },// states
 223                                                         false,// writable
 224                                                         decoder_t::decode_boolean,// decoder
 225                                                         nullptr,// encoder
 226                                                         false,// received
 227                                                         std::make_pair<bool, int>(false, 0),// multiplex
 228                                                         false,// is_big_endian
 229                                                         false,// is_signed
 230                                                         ""// unit
 231                                                 })},
 232                                                 {std::make_shared<signal_t> (signal_t{
 233                                                         "steering_wheel.next",// generic_name
 234                                                         36,// bit_position
 235                                                         1,// bit_size
 236                                                         1.00000f,// factor
 237                                                         0.00000f,// offset
 238                                                         0,// min_value
 239                                                         0,// max_value
 240                                                         frequency_clock_t(0.00000f),// frequency
 241                                                         true,// send_same
 242                                                         false,// force_send_changed
 243                                                         {
 244                                                         },// states
 245                                                         false,// writable
 246                                                         decoder_t::decode_boolean,// decoder
 247                                                         nullptr,// encoder
 248                                                         false,// received
 249                                                         std::make_pair<bool, int>(false, 0),// multiplex
 250                                                         false,// is_big_endian
 251                                                         false,// is_signed
 252                                                         ""// unit
 253                                                 })},
 254                                                 {std::make_shared<signal_t> (signal_t{
 255                                                         "steering_wheel.phone.call",// generic_name
 256                                                         47,// bit_position
 257                                                         1,// bit_size
 258                                                         1.00000f,// factor
 259                                                         0.00000f,// offset
 260                                                         0,// min_value
 261                                                         0,// max_value
 262                                                         frequency_clock_t(0.00000f),// frequency
 263                                                         true,// send_same
 264                                                         false,// force_send_changed
 265                                                         {
 266                                                         },// states
 267                                                         false,// writable
 268                                                         decoder_t::decode_boolean,// decoder
 269                                                         nullptr,// encoder
 270                                                         false,// received
 271                                                         std::make_pair<bool, int>(false, 0),// multiplex
 272                                                         false,// is_big_endian
 273                                                         false,// is_signed
 274                                                         ""// unit
 275                                                 })},
 276                                                 {std::make_shared<signal_t> (signal_t{
 277                                                         "steering_wheel.phone.hangup",// generic_name
 278                                                         46,// bit_position
 279                                                         1,// bit_size
 280                                                         1.00000f,// factor
 281                                                         0.00000f,// offset
 282                                                         0,// min_value
 283                                                         0,// max_value
 284                                                         frequency_clock_t(0.00000f),// frequency
 285                                                         true,// send_same
 286                                                         false,// force_send_changed
 287                                                         {
 288                                                         },// states
 289                                                         false,// writable
 290                                                         decoder_t::decode_boolean,// decoder
 291                                                         nullptr,// encoder
 292                                                         false,// received
 293                                                         std::make_pair<bool, int>(false, 0),// multiplex
 294                                                         false,// is_big_endian
 295                                                         false,// is_signed
 296                                                         ""// unit
 297                                                 })},
 298                                                 {std::make_shared<signal_t> (signal_t{
 299                                                         "steering_wheel.previous",// generic_name
 300                                                         32,// bit_position
 301                                                         1,// bit_size
 302                                                         1.00000f,// factor
 303                                                         0.00000f,// offset
 304                                                         0,// min_value
 305                                                         0,// max_value
 306                                                         frequency_clock_t(0.00000f),// frequency
 307                                                         true,// send_same
 308                                                         false,// force_send_changed
 309                                                         {
 310                                                         },// states
 311                                                         false,// writable
 312                                                         decoder_t::decode_boolean,// decoder
 313                                                         nullptr,// encoder
 314                                                         false,// received
 315                                                         std::make_pair<bool, int>(false, 0),// multiplex
 316                                                         false,// is_big_endian
 317                                                         false,// is_signed
 318                                                         ""// unit
 319                                                 })},
 320                                                 {std::make_shared<signal_t> (signal_t{
 321                                                         "steering_wheel.voice",// generic_name
 322                                                         45,// bit_position
 323                                                         1,// bit_size
 324                                                         1.00000f,// factor
 325                                                         0.00000f,// offset
 326                                                         0,// min_value
 327                                                         0,// max_value
 328                                                         frequency_clock_t(0.00000f),// frequency
 329                                                         true,// send_same
 330                                                         false,// force_send_changed
 331                                                         {
 332                                                         },// states
 333                                                         false,// writable
 334                                                         decoder_t::decode_boolean,// decoder
 335                                                         nullptr,// encoder
 336                                                         false,// received
 337                                                         std::make_pair<bool, int>(false, 0),// multiplex
 338                                                         false,// is_big_endian
 339                                                         false,// is_signed
 340                                                         ""// unit
 341                                                 })},
 342                                                 {std::make_shared<signal_t> (signal_t{
 343                                                         "steering_wheel.volume.down",// generic_name
 344                                                         35,// bit_position
 345                                                         1,// bit_size
 346                                                         1.00000f,// factor
 347                                                         0.00000f,// offset
 348                                                         0,// min_value
 349                                                         0,// max_value
 350                                                         frequency_clock_t(0.00000f),// frequency
 351                                                         true,// send_same
 352                                                         false,// force_send_changed
 353                                                         {
 354                                                         },// states
 355                                                         false,// writable
 356                                                         decoder_t::decode_boolean,// decoder
 357                                                         nullptr,// encoder
 358                                                         false,// received
 359                                                         std::make_pair<bool, int>(false, 0),// multiplex
 360                                                         false,// is_big_endian
 361                                                         false,// is_signed
 362                                                         ""// unit
 363                                                 })},
 364                                                 {std::make_shared<signal_t> (signal_t{
 365                                                         "steering_wheel.volume.mute",// generic_name
 366                                                         39,// bit_position
 367                                                         1,// bit_size
 368                                                         1.00000f,// factor
 369                                                         0.00000f,// offset
 370                                                         0,// min_value
 371                                                         0,// max_value
 372                                                         frequency_clock_t(0.00000f),// frequency
 373                                                         true,// send_same
 374                                                         false,// force_send_changed
 375                                                         {
 376                                                         },// states
 377                                                         false,// writable
 378                                                         decoder_t::decode_boolean,// decoder
 379                                                         nullptr,// encoder
 380                                                         false,// received
 381                                                         std::make_pair<bool, int>(false, 0),// multiplex
 382                                                         false,// is_big_endian
 383                                                         false,// is_signed
 384                                                         ""// unit
 385                                                 })},
 386                                                 {std::make_shared<signal_t> (signal_t{
 387                                                         "steering_wheel.volume.up",// generic_name
 388                                                         33,// bit_position
 389                                                         1,// bit_size
 390                                                         1.00000f,// factor
 391                                                         0.00000f,// offset
 392                                                         0,// min_value
 393                                                         0,// max_value
 394                                                         frequency_clock_t(0.00000f),// frequency
 395                                                         true,// send_same
 396                                                         false,// force_send_changed
 397                                                         {
 398                                                         },// states
 399                                                         false,// writable
 400                                                         decoder_t::decode_boolean,// decoder
 401                                                         nullptr,// encoder
 402                                                         false,// received
 403                                                         std::make_pair<bool, int>(false, 0),// multiplex
 404                                                         false,// is_big_endian
 405                                                         false,// is_signed
 406                                                         ""// unit
 407                                                 })}
 408                                         } // end signals vector
 409                                 })} // end message_definition entry
 410 ,                               {std::make_shared<message_definition_t>(message_definition_t{"ls",0x30,"",8,4,frequency_clock_t(5.00000f),true,
 411                                         { // beginning signals vector
 412                                                 {std::make_shared<signal_t> (signal_t{
 413                                                         "hvac.fan.speed",// generic_name
 414                                                         32,// bit_position
 415                                                         8,// bit_size
 416                                                         23.5294f,// factor
 417                                                         0.00000f,// offset
 418                                                         0,// min_value
 419                                                         0,// max_value
 420                                                         frequency_clock_t(0.00000f),// frequency
 421                                                         true,// send_same
 422                                                         false,// force_send_changed
 423                                                         {
 424                                                         },// states
 425                                                         true,// writable
 426                                                         nullptr,// decoder
 427                                                         nullptr,// encoder
 428                                                         false,// received
 429                                                         std::make_pair<bool, int>(false, 0),// multiplex
 430                                                         false,// is_big_endian
 431                                                         false,// is_signed
 432                                                         ""// unit
 433                                                 })},
 434                                                 {std::make_shared<signal_t> (signal_t{
 435                                                         "hvac.temperature.left",// generic_name
 436                                                         0,// bit_position
 437                                                         8,// bit_size
 438                                                         1.00000f,// factor
 439                                                         0.00000f,// offset
 440                                                         0,// min_value
 441                                                         0,// max_value
 442                                                         frequency_clock_t(0.00000f),// frequency
 443                                                         true,// send_same
 444                                                         false,// force_send_changed
 445                                                         {
 446                                                         },// states
 447                                                         true,// writable
 448                                                         nullptr,// decoder
 449                                                         nullptr,// encoder
 450                                                         false,// received
 451                                                         std::make_pair<bool, int>(false, 0),// multiplex
 452                                                         false,// is_big_endian
 453                                                         false,// is_signed
 454                                                         ""// unit
 455                                                 })},
 456                                                 {std::make_shared<signal_t> (signal_t{
 457                                                         "hvac.temperature.right",// generic_name
 458                                                         8,// bit_position
 459                                                         8,// bit_size
 460                                                         1.00000f,// factor
 461                                                         0.00000f,// offset
 462                                                         0,// min_value
 463                                                         0,// max_value
 464                                                         frequency_clock_t(0.00000f),// frequency
 465                                                         true,// send_same
 466                                                         false,// force_send_changed
 467                                                         {
 468                                                         },// states
 469                                                         true,// writable
 470                                                         nullptr,// decoder
 471                                                         nullptr,// encoder
 472                                                         false,// received
 473                                                         std::make_pair<bool, int>(false, 0),// multiplex
 474                                                         false,// is_big_endian
 475                                                         false,// is_signed
 476                                                         ""// unit
 477                                                 })},
 478                                                 {std::make_shared<signal_t> (signal_t{
 479                                                         "hvac.temperature.average",// generic_name
 480                                                         16,// bit_position
 481                                                         8,// bit_size
 482                                                         1.00000f,// factor
 483                                                         0.00000f,// offset
 484                                                         0,// min_value
 485                                                         0,// max_value
 486                                                         frequency_clock_t(0.00000f),// frequency
 487                                                         true,// send_same
 488                                                         false,// force_send_changed
 489                                                         {
 490                                                         },// states
 491                                                         true,// writable
 492                                                         nullptr,// decoder
 493                                                         nullptr,// encoder
 494                                                         false,// received
 495                                                         std::make_pair<bool, int>(false, 0),// multiplex
 496                                                         false,// is_big_endian
 497                                                         false,// is_signed
 498                                                         ""// unit
 499                                                 })}
 500                                         } // end signals vector
 501                                 })} // end message_definition entry
 502 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x3D9,"",8,2,frequency_clock_t(5.00000f),true,
 503                                         { // beginning signals vector
 504                                                 {std::make_shared<signal_t> (signal_t{
 505                                                         "engine.speed",// generic_name
 506                                                         16,// bit_position
 507                                                         16,// bit_size
 508                                                         0.250000f,// factor
 509                                                         0.00000f,// offset
 510                                                         0,// min_value
 511                                                         0,// max_value
 512                                                         frequency_clock_t(0.00000f),// frequency
 513                                                         true,// send_same
 514                                                         false,// force_send_changed
 515                                                         {
 516                                                         },// states
 517                                                         true,// writable
 518                                                         nullptr,// decoder
 519                                                         nullptr,// encoder
 520                                                         false,// received
 521                                                         std::make_pair<bool, int>(false, 0),// multiplex
 522                                                         false,// is_big_endian
 523                                                         false,// is_signed
 524                                                         ""// unit
 525                                                 })},
 526                                                 {std::make_shared<signal_t> (signal_t{
 527                                                         "fuel.level.low",// generic_name
 528                                                         55,// bit_position
 529                                                         1,// bit_size
 530                                                         1.00000f,// factor
 531                                                         0.00000f,// offset
 532                                                         0,// min_value
 533                                                         0,// max_value
 534                                                         frequency_clock_t(0.00000f),// frequency
 535                                                         true,// send_same
 536                                                         false,// force_send_changed
 537                                                         {
 538                                                         },// states
 539                                                         true,// writable
 540                                                         decoder_t::decode_boolean,// decoder
 541                                                         nullptr,// encoder
 542                                                         false,// received
 543                                                         std::make_pair<bool, int>(false, 0),// multiplex
 544                                                         false,// is_big_endian
 545                                                         false,// is_signed
 546                                                         ""// unit
 547                                                 })},
 548                                                 {std::make_shared<signal_t> (signal_t{
 549                                                         "fuel.level",// generic_name
 550                                                         8,// bit_position
 551                                                         8,// bit_size
 552                                                         0.392157f,// factor
 553                                                         0.00000f,// offset
 554                                                         0,// min_value
 555                                                         0,// max_value
 556                                                         frequency_clock_t(0.00000f),// frequency
 557                                                         true,// send_same
 558                                                         false,// force_send_changed
 559                                                         {
 560                                                         },// states
 561                                                         true,// writable
 562                                                         nullptr,// decoder
 563                                                         nullptr,// encoder
 564                                                         false,// received
 565                                                         std::make_pair<bool, int>(false, 0),// multiplex
 566                                                         false,// is_big_endian
 567                                                         false,// is_signed
 568                                                         ""// unit
 569                                                 })}
 570                                         } // end signals vector
 571                                 })} // end message_definition entry
 572 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x3E9,"",8,2,frequency_clock_t(5.00000f),true,
 573                                         { // beginning signals vector
 574                                                 {std::make_shared<signal_t> (signal_t{
 575                                                         "vehicle.average.speed",// generic_name
 576                                                         0,// bit_position
 577                                                         15,// bit_size
 578                                                         0.0156250f,// factor
 579                                                         0.00000f,// offset
 580                                                         0,// min_value
 581                                                         0,// max_value
 582                                                         frequency_clock_t(0.00000f),// frequency
 583                                                         true,// send_same
 584                                                         false,// force_send_changed
 585                                                         {
 586                                                         },// states
 587                                                         false,// writable
 588                                                         nullptr,// decoder
 589                                                         nullptr,// encoder
 590                                                         false,// received
 591                                                         std::make_pair<bool, int>(false, 0),// multiplex
 592                                                         false,// is_big_endian
 593                                                         false,// is_signed
 594                                                         ""// unit
 595                                                 })}
 596                                         } // end signals vector
 597                                 })} // end message_definition entry
 598 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x4D1,"",8,2,frequency_clock_t(5.00000f),true,
 599                                         { // beginning signals vector
 600                                                 {std::make_shared<signal_t> (signal_t{
 601                                                         "engine.oil.temp",// generic_name
 602                                                         16,// bit_position
 603                                                         8,// bit_size
 604                                                         1.00000f,// factor
 605                                                         0.00000f,// offset
 606                                                         0,// min_value
 607                                                         0,// max_value
 608                                                         frequency_clock_t(0.00000f),// frequency
 609                                                         true,// send_same
 610                                                         false,// force_send_changed
 611                                                         {
 612                                                         },// states
 613                                                         true,// writable
 614                                                         nullptr,// decoder
 615                                                         nullptr,// encoder
 616                                                         false,// received
 617                                                         std::make_pair<bool, int>(false, 0),// multiplex
 618                                                         false,// is_big_endian
 619                                                         false,// is_signed
 620                                                         ""// unit
 621                                                 })},
 622                                                 {std::make_shared<signal_t> (signal_t{
 623                                                         "engine.oil.temp.high",// generic_name
 624                                                         7,// bit_position
 625                                                         1,// bit_size
 626                                                         1.00000f,// factor
 627                                                         0.00000f,// offset
 628                                                         0,// min_value
 629                                                         0,// max_value
 630                                                         frequency_clock_t(0.00000f),// frequency
 631                                                         true,// send_same
 632                                                         false,// force_send_changed
 633                                                         {
 634                                                         },// states
 635                                                         true,// writable
 636                                                         decoder_t::decode_boolean,// decoder
 637                                                         nullptr,// encoder
 638                                                         false,// received
 639                                                         std::make_pair<bool, int>(false, 0),// multiplex
 640                                                         false,// is_big_endian
 641                                                         false,// is_signed
 642                                                         ""// unit
 643                                                 })}
 644                                         } // end signals vector
 645                                 })} // end message_definition entry
 646 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x620,"",8,2,frequency_clock_t(5.00000f),true,
 647                                         { // beginning signals vector
 648                                                 {std::make_shared<signal_t> (signal_t{
 649                                                         "doors.boot.open",// generic_name
 650                                                         47,// bit_position
 651                                                         1,// bit_size
 652                                                         1.00000f,// factor
 653                                                         0.00000f,// offset
 654                                                         0,// min_value
 655                                                         0,// max_value
 656                                                         frequency_clock_t(0.00000f),// frequency
 657                                                         true,// send_same
 658                                                         false,// force_send_changed
 659                                                         {
 660                                                         },// states
 661                                                         true,// writable
 662                                                         decoder_t::decode_boolean,// decoder
 663                                                         nullptr,// encoder
 664                                                         false,// received
 665                                                         std::make_pair<bool, int>(false, 0),// multiplex
 666                                                         false,// is_big_endian
 667                                                         false,// is_signed
 668                                                         ""// unit
 669                                                 })},
 670                                                 {std::make_shared<signal_t> (signal_t{
 671                                                         "doors.front_left.open",// generic_name
 672                                                         43,// bit_position
 673                                                         1,// bit_size
 674                                                         1.00000f,// factor
 675                                                         0.00000f,// offset
 676                                                         0,// min_value
 677                                                         0,// max_value
 678                                                         frequency_clock_t(0.00000f),// frequency
 679                                                         true,// send_same
 680                                                         false,// force_send_changed
 681                                                         {
 682                                                         },// states
 683                                                         true,// writable
 684                                                         decoder_t::decode_boolean,// decoder
 685                                                         nullptr,// encoder
 686                                                         false,// received
 687                                                         std::make_pair<bool, int>(false, 0),// multiplex
 688                                                         false,// is_big_endian
 689                                                         false,// is_signed
 690                                                         ""// unit
 691                                                 })},
 692                                                 {std::make_shared<signal_t> (signal_t{
 693                                                         "doors.front_right.open",// generic_name
 694                                                         44,// bit_position
 695                                                         1,// bit_size
 696                                                         1.00000f,// factor
 697                                                         0.00000f,// offset
 698                                                         0,// min_value
 699                                                         0,// max_value
 700                                                         frequency_clock_t(0.00000f),// frequency
 701                                                         true,// send_same
 702                                                         false,// force_send_changed
 703                                                         {
 704                                                         },// states
 705                                                         true,// writable
 706                                                         decoder_t::decode_boolean,// decoder
 707                                                         nullptr,// encoder
 708                                                         false,// received
 709                                                         std::make_pair<bool, int>(false, 0),// multiplex
 710                                                         false,// is_big_endian
 711                                                         false,// is_signed
 712                                                         ""// unit
 713                                                 })},
 714                                                 {std::make_shared<signal_t> (signal_t{
 715                                                         "doors.rear_left.open",// generic_name
 716                                                         46,// bit_position
 717                                                         1,// bit_size
 718                                                         1.00000f,// factor
 719                                                         0.00000f,// offset
 720                                                         0,// min_value
 721                                                         0,// max_value
 722                                                         frequency_clock_t(0.00000f),// frequency
 723                                                         true,// send_same
 724                                                         false,// force_send_changed
 725                                                         {
 726                                                         },// states
 727                                                         true,// writable
 728                                                         decoder_t::decode_boolean,// decoder
 729                                                         nullptr,// encoder
 730                                                         false,// received
 731                                                         std::make_pair<bool, int>(false, 0),// multiplex
 732                                                         false,// is_big_endian
 733                                                         false,// is_signed
 734                                                         ""// unit
 735                                                 })},
 736                                                 {std::make_shared<signal_t> (signal_t{
 737                                                         "doors.rear_right.open",// generic_name
 738                                                         45,// bit_position
 739                                                         4,// bit_size
 740                                                         1.00000f,// factor
 741                                                         0.00000f,// offset
 742                                                         0,// min_value
 743                                                         0,// max_value
 744                                                         frequency_clock_t(0.00000f),// frequency
 745                                                         true,// send_same
 746                                                         false,// force_send_changed
 747                                                         {
 748                                                         },// states
 749                                                         true,// writable
 750                                                         decoder_t::decode_boolean,// decoder
 751                                                         nullptr,// encoder
 752                                                         false,// received
 753                                                         std::make_pair<bool, int>(false, 0),// multiplex
 754                                                         false,// is_big_endian
 755                                                         false,// is_signed
 756                                                         ""// unit
 757                                                 })}
 758                                         } // end signals vector
 759                                 })} // end message_definition entry
 760 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x799,"",8,2,frequency_clock_t(5.00000f),true,
 761                                         { // beginning signals vector
 762                                                 {std::make_shared<signal_t> (signal_t{
 763                                                         "windows.front_left.open",// generic_name
 764                                                         43,// bit_position
 765                                                         1,// bit_size
 766                                                         1.00000f,// factor
 767                                                         0.00000f,// offset
 768                                                         0,// min_value
 769                                                         0,// max_value
 770                                                         frequency_clock_t(0.00000f),// frequency
 771                                                         true,// send_same
 772                                                         false,// force_send_changed
 773                                                         {
 774                                                         },// states
 775                                                         true,// writable
 776                                                         decoder_t::decode_boolean,// decoder
 777                                                         nullptr,// encoder
 778                                                         false,// received
 779                                                         std::make_pair<bool, int>(false, 0),// multiplex
 780                                                         false,// is_big_endian
 781                                                         false,// is_signed
 782                                                         ""// unit
 783                                                 })},
 784                                                 {std::make_shared<signal_t> (signal_t{
 785                                                         "windows.front_right.open",// generic_name
 786                                                         44,// bit_position
 787                                                         1,// bit_size
 788                                                         1.00000f,// factor
 789                                                         0.00000f,// offset
 790                                                         0,// min_value
 791                                                         0,// max_value
 792                                                         frequency_clock_t(0.00000f),// frequency
 793                                                         true,// send_same
 794                                                         false,// force_send_changed
 795                                                         {
 796                                                         },// states
 797                                                         true,// writable
 798                                                         decoder_t::decode_boolean,// decoder
 799                                                         nullptr,// encoder
 800                                                         false,// received
 801                                                         std::make_pair<bool, int>(false, 0),// multiplex
 802                                                         false,// is_big_endian
 803                                                         false,// is_signed
 804                                                         ""// unit
 805                                                 })},
 806                                                 {std::make_shared<signal_t> (signal_t{
 807                                                         "windows.rear_left.open",// generic_name
 808                                                         46,// bit_position
 809                                                         1,// bit_size
 810                                                         1.00000f,// factor
 811                                                         0.00000f,// offset
 812                                                         0,// min_value
 813                                                         0,// max_value
 814                                                         frequency_clock_t(0.00000f),// frequency
 815                                                         true,// send_same
 816                                                         false,// force_send_changed
 817                                                         {
 818                                                         },// states
 819                                                         true,// writable
 820                                                         decoder_t::decode_boolean,// decoder
 821                                                         nullptr,// encoder
 822                                                         false,// received
 823                                                         std::make_pair<bool, int>(false, 0),// multiplex
 824                                                         false,// is_big_endian
 825                                                         false,// is_signed
 826                                                         ""// unit
 827                                                 })},
 828                                                 {std::make_shared<signal_t> (signal_t{
 829                                                         "windows.rear_right.open",// generic_name
 830                                                         45,// bit_position
 831                                                         4,// bit_size
 832                                                         1.00000f,// factor
 833                                                         0.00000f,// offset
 834                                                         0,// min_value
 835                                                         0,// max_value
 836                                                         frequency_clock_t(0.00000f),// frequency
 837                                                         true,// send_same
 838                                                         false,// force_send_changed
 839                                                         {
 840                                                         },// states
 841                                                         true,// writable
 842                                                         decoder_t::decode_boolean,// decoder
 843                                                         nullptr,// encoder
 844                                                         false,// received
 845                                                         std::make_pair<bool, int>(false, 0),// multiplex
 846                                                         false,// is_big_endian
 847                                                         false,// is_signed
 848                                                         ""// unit
 849                                                 })}
 850                                         } // end signals vector
 851                                 })} // end message_definition entry
 852
 853                 }, // end message_definition vector
 854                         { // beginning diagnostic_messages_ vector
 855                                 {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 856                                         4,
 857                                         "engine.load",
 858                                         0,
 859                                         0,
 860                                         UNIT::INVALID,
 861                                         5.00000f,
 862                                         decoder_t::decode_obd2_response,
 863                                         nullptr,
 864                                         true,
 865                                         false
 866                                 })}
 867 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 868                                         5,
 869                                         "engine.coolant.temperature",
 870                                         0,
 871                                         0,
 872                                         UNIT::INVALID,
 873                                         1.00000f,
 874                                         decoder_t::decode_obd2_response,
 875                                         nullptr,
 876                                         true,
 877                                         false
 878                                 })}
 879 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 880                                         10,
 881                                         "fuel.pressure",
 882                                         0,
 883                                         0,
 884                                         UNIT::INVALID,
 885                                         1.00000f,
 886                                         decoder_t::decode_obd2_response,
 887                                         nullptr,
 888                                         true,
 889                                         false
 890                                 })}
 891 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 892                                         11,
 893                                         "intake.manifold.pressure",
 894                                         0,
 895                                         0,
 896                                         UNIT::INVALID,
 897                                         1.00000f,
 898                                         decoder_t::decode_obd2_response,
 899                                         nullptr,
 900                                         true,
 901                                         false
 902                                 })}
 903 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 904                                         12,
 905                                         "engine.speed",
 906                                         0,
 907                                         0,
 908                                         UNIT::INVALID,
 909                                         5.00000f,
 910                                         decoder_t::decode_obd2_response,
 911                                         nullptr,
 912                                         true,
 913                                         false
 914                                 })}
 915 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 916                                         13,
 917                                         "vehicle.speed",
 918                                         0,
 919                                         0,
 920                                         UNIT::INVALID,
 921                                         5.00000f,
 922                                         decoder_t::decode_obd2_response,
 923                                         nullptr,
 924                                         true,
 925                                         false
 926                                 })}
 927 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 928                                         15,
 929                                         "intake.air.temperature",
 930                                         0,
 931                                         0,
 932                                         UNIT::INVALID,
 933                                         1.00000f,
 934                                         decoder_t::decode_obd2_response,
 935                                         nullptr,
 936                                         true,
 937                                         false
 938                                 })}
 939 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 940                                         16,
 941                                         "mass.airflow",
 942                                         0,
 943                                         0,
 944                                         UNIT::INVALID,
 945                                         5.00000f,
 946                                         decoder_t::decode_obd2_response,
 947                                         nullptr,
 948                                         true,
 949                                         false
 950                                 })}
 951 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 952                                         17,
 953                                         "throttle.position",
 954                                         0,
 955                                         0,
 956                                         UNIT::INVALID,
 957                                         5.00000f,
 958                                         decoder_t::decode_obd2_response,
 959                                         nullptr,
 960                                         true,
 961                                         false
 962                                 })}
 963 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 964                                         31,
 965                                         "running.time",
 966                                         0,
 967                                         0,
 968                                         UNIT::INVALID,
 969                                         1.00000f,
 970                                         decoder_t::decode_obd2_response,
 971                                         nullptr,
 972                                         true,
 973                                         false
 974                                 })}
 975 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 976                                         45,
 977                                         "EGR.error",
 978                                         0,
 979                                         0,
 980                                         UNIT::INVALID,
 981                                         0.00000f,
 982                                         decoder_t::decode_obd2_response,
 983                                         nullptr,
 984                                         true,
 985                                         false
 986                                 })}
 987 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
 988                                         47,
 989                                         "fuel.level",
 990                                         0,
 991                                         0,
 992                                         UNIT::INVALID,
 993                                         1.00000f,
 994                                         decoder_t::decode_obd2_response,
 995                                         nullptr,
 996                                         true,
 997                                         false
 998                                 })}
 999 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1000                                         51,
1001                                         "barometric.pressure",
1002                                         0,
1003                                         0,
1004                                         UNIT::INVALID,
1005                                         1.00000f,
1006                                         decoder_t::decode_obd2_response,
1007                                         nullptr,
1008                                         true,
1009                                         false
1010                                 })}
1011 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1012                                         70,
1013                                         "ambient.air.temperature",
1014                                         0,
1015                                         0,
1016                                         UNIT::INVALID,
1017                                         1.00000f,
1018                                         decoder_t::decode_obd2_response,
1019                                         nullptr,
1020                                         true,
1021                                         false
1022                                 })}
1023 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1024                                         76,
1025                                         "commanded.throttle.position",
1026                                         0,
1027                                         0,
1028                                         UNIT::INVALID,
1029                                         1.00000f,
1030                                         decoder_t::decode_obd2_response,
1031                                         nullptr,
1032                                         true,
1033                                         false
1034                                 })}
1035 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1036                                         82,
1037                                         "ethanol.fuel.percentage",
1038                                         0,
1039                                         0,
1040                                         UNIT::INVALID,
1041                                         1.00000f,
1042                                         decoder_t::decode_obd2_response,
1043                                         nullptr,
1044                                         true,
1045                                         false
1046                                 })}
1047 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1048                                         90,
1049                                         "accelerator.pedal.position",
1050                                         0,
1051                                         0,
1052                                         UNIT::INVALID,
1053                                         5.00000f,
1054                                         decoder_t::decode_obd2_response,
1055                                         nullptr,
1056                                         true,
1057                                         false
1058                                 })}
1059 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1060                                         91,
1061                                         "hybrid.battery-pack.remaining.life",
1062                                         0,
1063                                         0,
1064                                         UNIT::INVALID,
1065                                         5.00000f,
1066                                         decoder_t::decode_obd2_response,
1067                                         nullptr,
1068                                         true,
1069                                         false
1070                                 })}
1071 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1072                                         92,
1073                                         "engine.oil.temperature",
1074                                         0,
1075                                         0,
1076                                         UNIT::INVALID,
1077                                         1.00000f,
1078                                         decoder_t::decode_obd2_response,
1079                                         nullptr,
1080                                         true,
1081                                         false
1082                                 })}
1083 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1084                                         94,
1085                                         "engine.fuel.rate",
1086                                         0,
1087                                         0,
1088                                         UNIT::INVALID,
1089                                         1.00000f,
1090                                         decoder_t::decode_obd2_response,
1091                                         nullptr,
1092                                         true,
1093                                         false
1094                                 })}
1095 ,                               {std::make_shared<diagnostic_message_t>(diagnostic_message_t{
1096                                         99,
1097                                         "engine.torque",
1098                                         0,
1099                                         0,
1100                                         UNIT::INVALID,
1101                                         1.00000f,
1102                                         decoder_t::decode_obd2_response,
1103                                         nullptr,
1104                                         true,
1105                                         false
1106                                 })}
1107
1108                         } // end diagnostic_messages_ vector
1109                 })} // end message_set entry
1110         } // end message_set vector
1111 {
1112         for(std::shared_ptr<message_set_t> cms: message_set_)
1113         {
1114                 std::vector<std::shared_ptr<message_definition_t>> messages_definition = cms->get_messages_definition();
1115                 for(std::shared_ptr<message_definition_t> cmd : messages_definition)
1116                 {
1117                         cmd->set_parent(cms);
1118                         std::vector<std::shared_ptr<signal_t>> signals = cmd->get_signals();
1119                         for(std::shared_ptr<signal_t> sig: signals)
1120                         {
1121                                 sig->set_parent(cmd);
1122                         }
1123                 }
1124
1125                 std::vector<std::shared_ptr<diagnostic_message_t>> diagnostic_messages = cms->get_diagnostic_messages();
1126                 for(std::shared_ptr<diagnostic_message_t> dm : diagnostic_messages)
1127                 {
1128                         dm->set_parent(cms);
1129                 }
1130         }
1131                 }
1132
1133 const std::string application_t::get_diagnostic_bus() const
1134 {
1135         return "hs";
1136 }
1137
1138