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

   1 #include "application.hpp"
   2 #include "../can/can-decoder.hpp"
   3 #include "../can/can-encoder.hpp"
   4
   5 application_t::application_t()
   6         : can_bus_manager_{utils::config_parser_t{"/etc/dev-mapping.conf"}}
   7         , message_set_{
   8                 {std::make_shared<message_set_t>(message_set_t{0,"example",
   9                         { // beginning message_definition_ vector
  10                                 {std::make_shared<message_definition_t>(message_definition_t{"ls",0x21,"",0,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                                                         decoder_t::decode_boolean,// decoder
 124                                                         false,// is_big_endian
 125                                                         false,// is_signed
 126                                                         ""// unit
 127                                                 })},
 128                                                 {std::make_shared<signal_t> (signal_t{
 129                                                         "steering_wheel.horn",// generic_name
 130                                                         56,// bit_position
 131                                                         1,// bit_size
 132                                                         1.00000f,// factor
 133                                                         0.00000f,// offset
 134                                                         0,// min_value
 135                                                         0,// max_value
 136                                                         frequency_clock_t(0.00000f),// frequency
 137                                                         true,// send_same
 138                                                         false,// force_send_changed
 139                                                         {
 140                                                         },// states
 141                                                         false,// writable
 142                                                         decoder_t::decode_boolean,// decoder
 143                                                         nullptr,// encoder
 144                                                         false,// received
 145                                                         std::make_pair<bool, int>(false, 0),// multiplex
 146                                                         false,// is_big_endian
 147                                                         false,// is_signed
 148                                                         ""// unit
 149                                                 })},
 150                                                 {std::make_shared<signal_t> (signal_t{
 151                                                         "steering_wheel.info",// generic_name
 152                                                         38,// bit_position
 153                                                         1,// bit_size
 154                                                         1.00000f,// factor
 155                                                         0.00000f,// offset
 156                                                         0,// min_value
 157                                                         0,// max_value
 158                                                         frequency_clock_t(0.00000f),// frequency
 159                                                         true,// send_same
 160                                                         false,// force_send_changed
 161                                                         {
 162                                                         },// states
 163                                                         false,// writable
 164                                                         decoder_t::decode_boolean,// decoder
 165                                                         nullptr,// encoder
 166                                                         false,// received
 167                                                         std::make_pair<bool, int>(false, 0),// multiplex
 168                                                         false,// is_big_endian
 169                                                         false,// is_signed
 170                                                         ""// unit
 171                                                 })},
 172                                                 {std::make_shared<signal_t> (signal_t{
 173                                                         "steering_wheel.lane_departure_warning",// generic_name
 174                                                         63,// bit_position
 175                                                         1,// bit_size
 176                                                         1.00000f,// factor
 177                                                         0.00000f,// offset
 178                                                         0,// min_value
 179                                                         0,// max_value
 180                                                         frequency_clock_t(0.00000f),// frequency
 181                                                         true,// send_same
 182                                                         false,// force_send_changed
 183                                                         {
 184                                                         },// states
 185                                                         false,// writable
 186                                                         decoder_t::decode_boolean,// decoder
 187                                                         nullptr,// encoder
 188                                                         false,// received
 189                                                         std::make_pair<bool, int>(false, 0),// multiplex
 190                                                         false,// is_big_endian
 191                                                         false,// is_signed
 192                                                         ""// unit
 193                                                 })},
 194                                                 {std::make_shared<signal_t> (signal_t{
 195                                                         "steering_wheel.mode",// generic_name
 196                                                         34,// bit_position
 197                                                         1,// bit_size
 198                                                         1.00000f,// factor
 199                                                         0.00000f,// offset
 200                                                         0,// min_value
 201                                                         0,// max_value
 202                                                         frequency_clock_t(0.00000f),// frequency
 203                                                         true,// send_same
 204                                                         false,// force_send_changed
 205                                                         {
 206                                                         },// states
 207                                                         false,// writable
 208                                                         decoder_t::decode_boolean,// decoder
 209                                                         nullptr,// encoder
 210                                                         false,// received
 211                                                         std::make_pair<bool, int>(false, 0),// multiplex
 212                                                         false,// is_big_endian
 213                                                         false,// is_signed
 214                                                         ""// unit
 215                                                 })},
 216                                                 {std::make_shared<signal_t> (signal_t{
 217                                                         "steering_wheel.next",// generic_name
 218                                                         36,// bit_position
 219                                                         1,// bit_size
 220                                                         1.00000f,// factor
 221                                                         0.00000f,// offset
 222                                                         0,// min_value
 223                                                         0,// max_value
 224                                                         frequency_clock_t(0.00000f),// frequency
 225                                                         true,// send_same
 226                                                         false,// force_send_changed
 227                                                         {
 228                                                         },// states
 229                                                         false,// writable
 230                                                         decoder_t::decode_boolean,// decoder
 231                                                         nullptr,// encoder
 232                                                         false,// received
 233                                                         std::make_pair<bool, int>(false, 0),// multiplex
 234                                                         false,// is_big_endian
 235                                                         false,// is_signed
 236                                                         ""// unit
 237                                                 })},
 238                                                 {std::make_shared<signal_t> (signal_t{
 239                                                         "steering_wheel.phone.call",// generic_name
 240                                                         47,// bit_position
 241                                                         1,// bit_size
 242                                                         1.00000f,// factor
 243                                                         0.00000f,// offset
 244                                                         0,// min_value
 245                                                         0,// max_value
 246                                                         frequency_clock_t(0.00000f),// frequency
 247                                                         true,// send_same
 248                                                         false,// force_send_changed
 249                                                         {
 250                                                         },// states
 251                                                         false,// writable
 252                                                         decoder_t::decode_boolean,// decoder
 253                                                         nullptr,// encoder
 254                                                         false,// received
 255                                                         std::make_pair<bool, int>(false, 0),// multiplex
 256                                                         false,// is_big_endian
 257                                                         false,// is_signed
 258                                                         ""// unit
 259                                                 })},
 260                                                 {std::make_shared<signal_t> (signal_t{
 261                                                         "steering_wheel.phone.hangup",// generic_name
 262                                                         46,// bit_position
 263                                                         1,// bit_size
 264                                                         1.00000f,// factor
 265                                                         0.00000f,// offset
 266                                                         0,// min_value
 267                                                         0,// max_value
 268                                                         frequency_clock_t(0.00000f),// frequency
 269                                                         true,// send_same
 270                                                         false,// force_send_changed
 271                                                         {
 272                                                         },// states
 273                                                         false,// writable
 274                                                         decoder_t::decode_boolean,// decoder
 275                                                         nullptr,// encoder
 276                                                         false,// received
 277                                                         std::make_pair<bool, int>(false, 0),// multiplex
 278                                                         false,// is_big_endian
 279                                                         false,// is_signed
 280                                                         ""// unit
 281                                                 })},
 282                                                 {std::make_shared<signal_t> (signal_t{
 283                                                         "steering_wheel.previous",// generic_name
 284                                                         32,// bit_position
 285                                                         1,// bit_size
 286                                                         1.00000f,// factor
 287                                                         0.00000f,// offset
 288                                                         0,// min_value
 289                                                         0,// max_value
 290                                                         frequency_clock_t(0.00000f),// frequency
 291                                                         true,// send_same
 292                                                         false,// force_send_changed
 293                                                         {
 294                                                         },// states
 295                                                         false,// writable
 296                                                         decoder_t::decode_boolean,// decoder
 297                                                         nullptr,// encoder
 298                                                         false,// received
 299                                                         std::make_pair<bool, int>(false, 0),// multiplex
 300                                                         false,// is_big_endian
 301                                                         false,// is_signed
 302                                                         ""// unit
 303                                                 })},
 304                                                 {std::make_shared<signal_t> (signal_t{
 305                                                         "steering_wheel.voice",// generic_name
 306                                                         45,// bit_position
 307                                                         1,// bit_size
 308                                                         1.00000f,// factor
 309                                                         0.00000f,// offset
 310                                                         0,// min_value
 311                                                         0,// max_value
 312                                                         frequency_clock_t(0.00000f),// frequency
 313                                                         true,// send_same
 314                                                         false,// force_send_changed
 315                                                         {
 316                                                         },// states
 317                                                         false,// writable
 318                                                         decoder_t::decode_boolean,// decoder
 319                                                         nullptr,// encoder
 320                                                         false,// received
 321                                                         std::make_pair<bool, int>(false, 0),// multiplex
 322                                                         false,// is_big_endian
 323                                                         false,// is_signed
 324                                                         ""// unit
 325                                                 })},
 326                                                 {std::make_shared<signal_t> (signal_t{
 327                                                         "steering_wheel.volume.down",// generic_name
 328                                                         35,// bit_position
 329                                                         1,// bit_size
 330                                                         1.00000f,// factor
 331                                                         0.00000f,// offset
 332                                                         0,// min_value
 333                                                         0,// max_value
 334                                                         frequency_clock_t(0.00000f),// frequency
 335                                                         true,// send_same
 336                                                         false,// force_send_changed
 337                                                         {
 338                                                         },// states
 339                                                         false,// writable
 340                                                         decoder_t::decode_boolean,// decoder
 341                                                         nullptr,// encoder
 342                                                         false,// received
 343                                                         std::make_pair<bool, int>(false, 0),// multiplex
 344                                                         false,// is_big_endian
 345                                                         false,// is_signed
 346                                                         ""// unit
 347                                                 })},
 348                                                 {std::make_shared<signal_t> (signal_t{
 349                                                         "steering_wheel.volume.mute",// generic_name
 350                                                         39,// bit_position
 351                                                         1,// bit_size
 352                                                         1.00000f,// factor
 353                                                         0.00000f,// offset
 354                                                         0,// min_value
 355                                                         0,// max_value
 356                                                         frequency_clock_t(0.00000f),// frequency
 357                                                         true,// send_same
 358                                                         false,// force_send_changed
 359                                                         {
 360                                                         },// states
 361                                                         false,// writable
 362                                                         decoder_t::decode_boolean,// decoder
 363                                                         nullptr,// encoder
 364                                                         false,// received
 365                                                         std::make_pair<bool, int>(false, 0),// multiplex
 366                                                         false,// is_big_endian
 367                                                         false,// is_signed
 368                                                         ""// unit
 369                                                 })},
 370                                                 {std::make_shared<signal_t> (signal_t{
 371                                                         "steering_wheel.volume.up",// generic_name
 372                                                         33,// bit_position
 373                                                         1,// bit_size
 374                                                         1.00000f,// factor
 375                                                         0.00000f,// offset
 376                                                         0,// min_value
 377                                                         0,// max_value
 378                                                         frequency_clock_t(0.00000f),// frequency
 379                                                         true,// send_same
 380                                                         false,// force_send_changed
 381                                                         {
 382                                                         },// states
 383                                                         false,// writable
 384                                                         decoder_t::decode_boolean,// decoder
 385                                                         nullptr,// encoder
 386                                                         false,// received
 387                                                         std::make_pair<bool, int>(false, 0),// multiplex
 388                                                         false,// is_big_endian
 389                                                         false,// is_signed
 390                                                         ""// unit
 391                                                 })}
 392                                         } // end signals vector
 393                                 })} // end message_definition entry
 394 ,                               {std::make_shared<message_definition_t>(message_definition_t{"ls",0x30,"",8,4,frequency_clock_t(5.00000f),true,
 395                                         { // beginning signals vector
 396                                                 {std::make_shared<signal_t> (signal_t{
 397                                                         "hvac.fan.speed",// generic_name
 398                                                         32,// bit_position
 399                                                         8,// bit_size
 400                                                         23.5294f,// factor
 401                                                         0.00000f,// offset
 402                                                         0,// min_value
 403                                                         0,// max_value
 404                                                         frequency_clock_t(0.00000f),// frequency
 405                                                         true,// send_same
 406                                                         false,// force_send_changed
 407                                                         {
 408                                                         },// states
 409                                                         true,// writable
 410                                                         nullptr,// decoder
 411                                                         nullptr,// encoder
 412                                                         false,// received
 413                                                         std::make_pair<bool, int>(false, 0),// multiplex
 414                                                         false,// is_big_endian
 415                                                         false,// is_signed
 416                                                         ""// unit
 417                                                 })},
 418                                                 {std::make_shared<signal_t> (signal_t{
 419                                                         "hvac.temperature.left",// generic_name
 420                                                         0,// bit_position
 421                                                         8,// bit_size
 422                                                         1.00000f,// factor
 423                                                         0.00000f,// offset
 424                                                         0,// min_value
 425                                                         0,// max_value
 426                                                         frequency_clock_t(0.00000f),// frequency
 427                                                         true,// send_same
 428                                                         false,// force_send_changed
 429                                                         {
 430                                                         },// states
 431                                                         true,// writable
 432                                                         nullptr,// decoder
 433                                                         nullptr,// encoder
 434                                                         false,// received
 435                                                         std::make_pair<bool, int>(false, 0),// multiplex
 436                                                         false,// is_big_endian
 437                                                         false,// is_signed
 438                                                         ""// unit
 439                                                 })},
 440                                                 {std::make_shared<signal_t> (signal_t{
 441                                                         "hvac.temperature.right",// generic_name
 442                                                         8,// bit_position
 443                                                         8,// bit_size
 444                                                         1.00000f,// factor
 445                                                         0.00000f,// offset
 446                                                         0,// min_value
 447                                                         0,// max_value
 448                                                         frequency_clock_t(0.00000f),// frequency
 449                                                         true,// send_same
 450                                                         false,// force_send_changed
 451                                                         {
 452                                                         },// states
 453                                                         true,// writable
 454                                                         nullptr,// decoder
 455                                                         nullptr,// encoder
 456                                                         false,// received
 457                                                         std::make_pair<bool, int>(false, 0),// multiplex
 458                                                         false,// is_big_endian
 459                                                         false,// is_signed
 460                                                         ""// unit
 461                                                 })},
 462                                                 {std::make_shared<signal_t> (signal_t{
 463                                                         "hvac.temperature.average",// generic_name
 464                                                         16,// bit_position
 465                                                         8,// bit_size
 466                                                         1.00000f,// factor
 467                                                         0.00000f,// offset
 468                                                         0,// min_value
 469                                                         0,// max_value
 470                                                         frequency_clock_t(0.00000f),// frequency
 471                                                         true,// send_same
 472                                                         false,// force_send_changed
 473                                                         {
 474                                                         },// states
 475                                                         true,// writable
 476                                                         nullptr,// decoder
 477                                                         nullptr,// encoder
 478                                                         false,// received
 479                                                         std::make_pair<bool, int>(false, 0),// multiplex
 480                                                         false,// is_big_endian
 481                                                         false,// is_signed
 482                                                         ""// unit
 483                                                 })}
 484                                         } // end signals vector
 485                                 })} // end message_definition entry
 486 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x3D9,"",8,2050,frequency_clock_t(5.00000f),true,
 487                                         { // beginning signals vector
 488                                                 {std::make_shared<signal_t> (signal_t{
 489                                                         "engine.speed",// generic_name
 490                                                         16,// bit_position
 491                                                         16,// bit_size
 492                                                         0.250000f,// factor
 493                                                         0.00000f,// offset
 494                                                         0,// min_value
 495                                                         0,// max_value
 496                                                         frequency_clock_t(0.00000f),// frequency
 497                                                         true,// send_same
 498                                                         false,// force_send_changed
 499                                                         {
 500                                                         },// states
 501                                                         true,// writable
 502                                                         nullptr,// decoder
 503                                                         nullptr,// encoder
 504                                                         false,// received
 505                                                         std::make_pair<bool, int>(false, 0),// multiplex
 506                                                         false,// is_big_endian
 507                                                         false,// is_signed
 508                                                         ""// unit
 509                                                 })},
 510                                                 {std::make_shared<signal_t> (signal_t{
 511                                                         "fuel.level.low",// generic_name
 512                                                         55,// bit_position
 513                                                         1,// bit_size
 514                                                         1.00000f,// factor
 515                                                         0.00000f,// offset
 516                                                         0,// min_value
 517                                                         0,// max_value
 518                                                         frequency_clock_t(0.00000f),// frequency
 519                                                         true,// send_same
 520                                                         false,// force_send_changed
 521                                                         {
 522                                                         },// states
 523                                                         true,// writable
 524                                                         decoder_t::decode_boolean,// decoder
 525                                                         nullptr,// encoder
 526                                                         false,// received
 527                                                         std::make_pair<bool, int>(false, 0),// multiplex
 528                                                         false,// is_big_endian
 529                                                         false,// is_signed
 530                                                         ""// unit
 531                                                 })},
 532                                                 {std::make_shared<signal_t> (signal_t{
 533                                                         "fuel.level",// generic_name
 534                                                         8,// bit_position
 535                                                         8,// bit_size
 536                                                         0.392157f,// factor
 537                                                         0.00000f,// offset
 538                                                         0,// min_value
 539                                                         0,// max_value
 540                                                         frequency_clock_t(0.00000f),// frequency
 541                                                         true,// send_same
 542                                                         false,// force_send_changed
 543                                                         {
 544                                                         },// states
 545                                                         true,// writable
 546                                                         nullptr,// decoder
 547                                                         nullptr,// encoder
 548                                                         false,// received
 549                                                         std::make_pair<bool, int>(false, 0),// multiplex
 550                                                         false,// is_big_endian
 551                                                         false,// is_signed
 552                                                         ""// unit
 553                                                 })}
 554                                         } // end signals vector
 555                                 })} // end message_definition entry
 556 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x3E9,"",8,2,frequency_clock_t(5.00000f),true,
 557                                         { // beginning signals vector
 558                                                 {std::make_shared<signal_t> (signal_t{
 559                                                         "vehicle.average.speed",// generic_name
 560                                                         0,// bit_position
 561                                                         15,// bit_size
 562                                                         0.0156250f,// factor
 563                                                         0.00000f,// offset
 564                                                         0,// min_value
 565                                                         0,// max_value
 566                                                         frequency_clock_t(0.00000f),// frequency
 567                                                         true,// send_same
 568                                                         false,// force_send_changed
 569                                                         {
 570                                                         },// states
 571                                                         false,// writable
 572                                                         nullptr,// decoder
 573                                                         nullptr,// encoder
 574                                                         false,// received
 575                                                         std::make_pair<bool, int>(false, 0),// multiplex
 576                                                         false,// is_big_endian
 577                                                         false,// is_signed
 578                                                         ""// unit
 579                                                 })}
 580                                         } // end signals vector
 581                                 })} // end message_definition entry
 582 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x4D1,"",8,2,frequency_clock_t(5.00000f),true,
 583                                         { // beginning signals vector
 584                                                 {std::make_shared<signal_t> (signal_t{
 585                                                         "engine.oil.temp",// generic_name
 586                                                         16,// bit_position
 587                                                         8,// bit_size
 588                                                         1.00000f,// factor
 589                                                         0.00000f,// offset
 590                                                         0,// min_value
 591                                                         0,// max_value
 592                                                         frequency_clock_t(0.00000f),// frequency
 593                                                         true,// send_same
 594                                                         false,// force_send_changed
 595                                                         {
 596                                                         },// states
 597                                                         true,// writable
 598                                                         nullptr,// decoder
 599                                                         nullptr,// encoder
 600                                                         false,// received
 601                                                         std::make_pair<bool, int>(false, 0),// multiplex
 602                                                         false,// is_big_endian
 603                                                         false,// is_signed
 604                                                         ""// unit
 605                                                 })},
 606                                                 {std::make_shared<signal_t> (signal_t{
 607                                                         "engine.oil.temp.high",// generic_name
 608                                                         7,// bit_position
 609                                                         1,// bit_size
 610                                                         1.00000f,// factor
 611                                                         0.00000f,// offset
 612                                                         0,// min_value
 613                                                         0,// max_value
 614                                                         frequency_clock_t(0.00000f),// frequency
 615                                                         true,// send_same
 616                                                         false,// force_send_changed
 617                                                         {
 618                                                         },// states
 619                                                         true,// writable
 620                                                         decoder_t::decode_boolean,// decoder
 621                                                         nullptr,// encoder
 622                                                         false,// received
 623                                                         std::make_pair<bool, int>(false, 0),// multiplex
 624                                                         false,// is_big_endian
 625                                                         false,// is_signed
 626                                                         ""// unit
 627                                                 })}
 628                                         } // end signals vector
 629                                 })} // end message_definition entry
 630 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x620,"",8,2,frequency_clock_t(5.00000f),true,
 631                                         { // beginning signals vector
 632                                                 {std::make_shared<signal_t> (signal_t{
 633                                                         "doors.boot.open",// generic_name
 634                                                         47,// bit_position
 635                                                         1,// bit_size
 636                                                         1.00000f,// factor
 637                                                         0.00000f,// offset
 638                                                         0,// min_value
 639                                                         0,// max_value
 640                                                         frequency_clock_t(0.00000f),// frequency
 641                                                         true,// send_same
 642                                                         false,// force_send_changed
 643                                                         {
 644                                                         },// states
 645                                                         true,// writable
 646                                                         decoder_t::decode_boolean,// decoder
 647                                                         nullptr,// encoder
 648                                                         false,// received
 649                                                         std::make_pair<bool, int>(false, 0),// multiplex
 650                                                         false,// is_big_endian
 651                                                         false,// is_signed
 652                                                         ""// unit
 653                                                 })},
 654                                                 {std::make_shared<signal_t> (signal_t{
 655                                                         "doors.front_left.open",// generic_name
 656                                                         43,// bit_position
 657                                                         1,// bit_size
 658                                                         1.00000f,// factor
 659                                                         0.00000f,// offset
 660                                                         0,// min_value
 661                                                         0,// max_value
 662                                                         frequency_clock_t(0.00000f),// frequency
 663                                                         true,// send_same
 664                                                         false,// force_send_changed
 665                                                         {
 666                                                         },// states
 667                                                         true,// writable
 668                                                         decoder_t::decode_boolean,// decoder
 669                                                         nullptr,// encoder
 670                                                         false,// received
 671                                                         std::make_pair<bool, int>(false, 0),// multiplex
 672                                                         false,// is_big_endian
 673                                                         false,// is_signed
 674                                                         ""// unit
 675                                                 })},
 676                                                 {std::make_shared<signal_t> (signal_t{
 677                                                         "doors.front_right.open",// generic_name
 678                                                         44,// bit_position
 679                                                         1,// bit_size
 680                                                         1.00000f,// factor
 681                                                         0.00000f,// offset
 682                                                         0,// min_value
 683                                                         0,// max_value
 684                                                         frequency_clock_t(0.00000f),// frequency
 685                                                         true,// send_same
 686                                                         false,// force_send_changed
 687                                                         {
 688                                                         },// states
 689                                                         true,// writable
 690                                                         decoder_t::decode_boolean,// decoder
 691                                                         nullptr,// encoder
 692                                                         false,// received
 693                                                         std::make_pair<bool, int>(false, 0),// multiplex
 694                                                         false,// is_big_endian
 695                                                         false,// is_signed
 696                                                         ""// unit
 697                                                 })},
 698                                                 {std::make_shared<signal_t> (signal_t{
 699                                                         "doors.rear_left.open",// generic_name
 700                                                         46,// bit_position
 701                                                         1,// bit_size
 702                                                         1.00000f,// factor
 703                                                         0.00000f,// offset
 704                                                         0,// min_value
 705                                                         0,// max_value
 706                                                         frequency_clock_t(0.00000f),// frequency
 707                                                         true,// send_same
 708                                                         false,// force_send_changed
 709                                                         {
 710                                                         },// states
 711                                                         true,// writable
 712                                                         decoder_t::decode_boolean,// decoder
 713                                                         nullptr,// encoder
 714                                                         false,// received
 715                                                         std::make_pair<bool, int>(false, 0),// multiplex
 716                                                         false,// is_big_endian
 717                                                         false,// is_signed
 718                                                         ""// unit
 719                                                 })},
 720                                                 {std::make_shared<signal_t> (signal_t{
 721                                                         "doors.rear_right.open",// generic_name
 722                                                         45,// bit_position
 723                                                         4,// bit_size
 724                                                         1.00000f,// factor
 725                                                         0.00000f,// offset
 726                                                         0,// min_value
 727                                                         0,// max_value
 728                                                         frequency_clock_t(0.00000f),// frequency
 729                                                         true,// send_same
 730                                                         false,// force_send_changed
 731                                                         {
 732                                                         },// states
 733                                                         true,// writable
 734                                                         decoder_t::decode_boolean,// decoder
 735                                                         nullptr,// encoder
 736                                                         false,// received
 737                                                         std::make_pair<bool, int>(false, 0),// multiplex
 738                                                         false,// is_big_endian
 739                                                         false,// is_signed
 740                                                         ""// unit
 741                                                 })}
 742                                         } // end signals vector
 743                                 })} // end message_definition entry
 744 ,                               {std::make_shared<message_definition_t>(message_definition_t{"hs",0x799,"",8,2,frequency_clock_t(5.00000f),true,
 745                                         { // beginning signals vector
 746                                                 {std::make_shared<signal_t> (signal_t{
 747                                                         "windows.front_left.open",// generic_name
 748                                                         43,// bit_position
 749                                                         1,// bit_size
 750                                                         1.00000f,// factor
 751                                                         0.00000f,// 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                                                         true,// writable
 760                                                         decoder_t::decode_boolean,// decoder
 761                                                         nullptr,// encoder
 762                                                         false,// received
 763                                                         std::make_pair<bool, int>(false, 0),// multiplex
 764                                                         false,// is_big_endian
 765                                                         false,// is_signed
 766                                                         ""// unit
 767                                                 })},
 768                                                 {std::make_shared<signal_t> (signal_t{
 769                                                         "windows.front_right.open",// generic_name
 770                                                         44,// bit_position
 771                                                         1,// bit_size
 772                                                         1.00000f,// factor
 773                                                         0.00000f,// 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                                                         true,// writable
 782                                                         decoder_t::decode_boolean,// decoder
 783                                                         nullptr,// encoder
 784                                                         false,// received
 785                                                         std::make_pair<bool, int>(false, 0),// multiplex
 786                                                         false,// is_big_endian
 787                                                         false,// is_signed
 788                                                         ""// unit
 789                                                 })},
 790                                                 {std::make_shared<signal_t> (signal_t{
 791                                                         "windows.rear_left.open",// generic_name
 792                                                         46,// bit_position
 793                                                         1,// bit_size
 794                                                         1.00000f,// factor
 795                                                         0.00000f,// offset
 796                                                         0,// min_value
 797                                                         0,// max_value
 798                                                         frequency_clock_t(0.00000f),// frequency
 799                                                         true,// send_same
 800                                                         false,// force_send_changed
 801                                                         {
 802                                                         },// states
 803                                                         true,// writable
 804                                                         decoder_t::decode_boolean,// decoder
 805                                                         nullptr,// encoder
 806                                                         false,// received
 807                                                         std::make_pair<bool, int>(false, 0),// multiplex
 808                                                         false,// is_big_endian
 809                                                         false,// is_signed
 810                                                         ""// unit
 811                                                 })},
 812                                                 {std::make_shared<signal_t> (signal_t{
 813                                                         "windows.rear_right.open",// generic_name
 814                                                         45,// bit_position
 815                                                         4,// bit_size
 816                                                         1.00000f,// factor
 817                                                         0.00000f,// offset
 818                                                         0,// min_value
 819                                                         0,// max_value
 820                                                         frequency_clock_t(0.00000f),// frequency
 821                                                         true,// send_same
 822                                                         false,// force_send_changed
 823                                                         {
 824                                                         },// states
 825                                                         true,// writable
 826                                                         decoder_t::decode_boolean,// decoder
 827                                                         nullptr,// encoder
 828                                                         false,// received
 829                                                         std::make_pair<bool, int>(false, 0),// multiplex
 830                                                         false,// is_big_endian
 831                                                         false,// is_signed
 832                                                         ""// unit
 833                                                 })}
 834                                         } // end signals vector
 835                                 })} // end message_definition entry
 836                 }, // end message_definition vector
 837                         { // beginning diagnostic_messages_ vector
 838
 839                         } // end diagnostic_messages_ vector
 840                 })} // end message_set entry
 841         } // end message_set vector
 842 {
 843         for(std::shared_ptr<message_set_t> cms: message_set_)
 844         {
 845                 std::vector<std::shared_ptr<message_definition_t>> messages_definition = cms->get_messages_definition();
 846                 for(std::shared_ptr<message_definition_t> cmd : messages_definition)
 847                 {
 848                         cmd->set_parent(cms);
 849                         std::vector<std::shared_ptr<signal_t>> signals = cmd->get_signals();
 850                         for(std::shared_ptr<signal_t> sig: signals)
 851                         {
 852                                 sig->set_parent(cmd);
 853                         }
 854                 }
 855
 856                 std::vector<std::shared_ptr<diagnostic_message_t>> diagnostic_messages = cms->get_diagnostic_messages();
 857                 for(std::shared_ptr<diagnostic_message_t> dm : diagnostic_messages)
 858                 {
 859                         dm->set_parent(cms);
 860                 }
 861         }
 862                 }
 863
 864 const std::string application_t::get_diagnostic_bus() const
 865 {
 866         return diagnostic_manager_.get_bus_device_name();;
 867 }
 868
 869