src/CAvgCar.h

   1 /*
   2  * Copyright (c) 2013, TOYOTA MOTOR CORPORATION.
   3  *
   4  * This program is licensed under the terms and conditions of the
   5  * Apache License, version 2.0.  The full text of the Apache License is at
   6  * http://www.apache.org/licenses/LICENSE-2.0
   7  *
   8  */
   9 /**
  10  * @brief   virtual car
  11  *          RPM / Speed / Brake Value is determined by the average
  12  *
  13  * @date    Apr-08-2013 create
  14  */
  15
  16
  17 #ifndef CAVGCAR_H
  18 #define CAVGCAR_H
  19
  20 /*******************************
  21  * AVERAGE SAMPLE SPACE SIZE
  22 *******************************/
  23 #define D_SAMPLE_SPACE_SPEED    40
  24 #define D_SAMPLE_SPACE_RPM      40
  25 #define D_SAMPLE_SPACE_BRAKE    20
  26 #define D_SAMPLE_SPACE_ACCPEDAL 40
  27
  28 /******************************************
  29  * average Machine
  30 ******************************************/
  31 class averageMachine
  32 {
  33   public:
  34             averageMachine(const short sz);
  35             ~averageMachine();
  36     void    setSample(double x);
  37     double  getAvg() const;
  38     double  getPrevValue() const;
  39     void    reCalc();
  40   private:
  41     short   m_posi;             // Sample store position
  42     short   m_prev;
  43     short   m_sz;               // Sample space size
  44     double  m_n;                // Sample space size(double)
  45     double* m_x;                // Sample store Aarea
  46     double  m_t;                // Sample sum
  47     double  m_avg;              // average
  48 };
  49
  50 /**
  51  * @brief getAvg
  52  * @return average
  53  */
  54 inline double averageMachine::getAvg() const
  55 {
  56     return m_avg;
  57 }
  58
  59 /**
  60  * @brief getPrevValue
  61  * @return previous RPM value
  62  */
  63 inline double averageMachine::getPrevValue() const
  64 {
  65     return m_x[m_prev];
  66 }
  67
  68 /******************************************
  69  * average Machine Integer
  70 ******************************************/
  71 class iAverageMachine
  72 {
  73   public:
  74             iAverageMachine(const short sz);
  75             ~iAverageMachine();
  76     void    setSample(int x);
  77     double  getAvg() const;
  78     int     getIAvg() const;
  79     int     getPrevValue() const;
  80     void    reCalc();
  81   private:
  82     short   m_posi;             // Sample store position
  83     short   m_prev;
  84     short   m_sz;               // Sample space size
  85     int     m_n;                // Sample space size(double)
  86     int*    m_x;                // Sample store Aarea
  87     int     m_t;                // Sample sum
  88     double  m_avg;              // average
  89     int     m_iAvg;             // average
  90 };
  91
  92 /**
  93  * @brief getAvg
  94  *        get average
  95  * @return avarege value
  96  */
  97 inline double iAverageMachine::getAvg() const
  98 {
  99     return m_avg;
 100 }
 101
 102 /**
 103  * @brief getIAvg
 104  *        get average interger
 105  * @return avarege value
 106  */
 107 inline int iAverageMachine::getIAvg() const
 108 {
 109     return m_iAvg;
 110 }
 111
 112 /**
 113  * @brief getPrevValue
 114  * @return prev sample value
 115  */
 116 inline int iAverageMachine::getPrevValue() const
 117 {
 118     return m_x[m_prev];
 119 }
 120
 121 /******************************************
 122  * Average Engne
 123 ******************************************/
 124 #define D_IDLING_RPM            6.3L
 125 #define D_RPM_BOTTOM_BORDER     2.7L
 126 #define D_RPM_IGNITION_VALUE    4.1
 127
 128 class CAvgEngine
 129 {
 130   public:
 131             CAvgEngine(const short sz = 0);
 132             ~CAvgEngine();
 133     void    ignitionStart(int rpm = -1);
 134     void    chgThrottle(int throttle);
 135     double  getRPM() const;
 136     double  getAvgRPM() const;
 137     bool    isActive() const;
 138
 139   protected:
 140     bool    m_active;
 141     double  m_rpm;
 142     averageMachine  m_avgRPM;
 143 };
 144
 145 /**
 146  * @brief getRPM
 147  * @return RPM value
 148  */
 149 inline double CAvgEngine::getRPM() const
 150 {
 151     return m_rpm * 100.0l;
 152 }
 153 /**
 154  * @brief getAvgRPM
 155  * @return RPM value
 156  */
 157 inline double CAvgEngine::getAvgRPM() const
 158 {
 159     return m_avgRPM.getAvg();
 160 }
 161
 162 /**
 163  * @brief isActive
 164  * @return true:active / false stop
 165  */
 166 inline bool CAvgEngine::isActive() const
 167 {
 168     return m_active;
 169 }
 170
 171 /******************************************
 172  * Average Brake
 173 ******************************************/
 174 #define D_LAG_BRAKE            10240
 175 #define D_MAX_BRAKE            65534
 176 #define D_SOFT_BRAKE_MAX       21000
 177 #define D_MIDDLE_BRAKE_MAX     42000
 178 class CAvgBrake
 179 {
 180   public:
 181             CAvgBrake(const short sz = 0);
 182             ~CAvgBrake();
 183     void    chgBrake(int brake);
 184     bool    isOnBrake() const;
 185     int     getBrakeAvg() const;
 186     double  getSpeed(double sourceSpeed);
 187     int     calcPressure(int brakeVal) const;
 188 protected:
 189     void    judgeBrake();
 190   private:
 191     iAverageMachine m_brk;
 192     int     m_brakeVal;
 193     bool    m_brake;
 194 };
 195
 196 /**
 197  * @brief isOnBrake
 198  * @return true:on brake false:no brake
 199  */
 200 inline bool CAvgBrake::isOnBrake() const
 201 {
 202     return m_brake;
 203 }
 204
 205 /**
 206  * @brief
 207  * @return
 208  */
 209 inline int CAvgBrake::getBrakeAvg() const
 210 {
 211     return m_brakeVal;
 212 }
 213
 214
 215 inline int CAvgBrake::calcPressure(int brakeVal) const
 216 {
 217     if (D_LAG_BRAKE >= brakeVal) {
 218         return 0;
 219     }
 220     int a = brakeVal - D_LAG_BRAKE;
 221     int b = D_MAX_BRAKE - D_LAG_BRAKE;
 222     double x = ((double)a / (double)b) * 100.0l;
 223     int r = (int)x;
 224     return r;
 225 }
 226
 227 /******************************************
 228  * Somewhat Gear
 229 ******************************************/
 230 /**
 231  * TRANSMISSION SHIFT VALUE
 232  * 1=1st, 2=2nd, 3=3rd, ..., 64=neutral,
 233  * 128=back, 256=cvt
 234  */
 235 #define D_SHIFT_VALUE_CVT      256
 236 #define D_SHIFT_VALUE_PARKING  0
 237 #define D_SHIFT_VALUE_REVERSE  128
 238 #define D_SHIFT_VALUE_NEUTRAL  64
 239 #define D_SHIFT_VALUE_SIXTH    6
 240 #define D_SHIFT_VALUE_FIFTH    5
 241 #define D_SHIFT_VALUE_DRIVE    4
 242 #define D_SHIFT_VALUE_THIRD    3
 243 #define D_SHIFT_VALUE_SECOND   2
 244 #define D_SHIFT_VALUE_FIRST    1
 245 /**
 246  * TRANSMISSION SHIFT MODE
 247  * 0=normal, 1=sports, 2=eco, 3=oem custom,
 248  * 4=oem custom2
 249  */
 250 #define D_SHIFT_MODE_NORMAL     0
 251 #define D_SHIFT_MODE_SPOETS     1
 252 #define D_SHIFT_MODE_ECO        2
 253 #define D_SHIFT_MODE_OEMCUSTOM  3
 254 #define D_SHIFT_MODE_OEMCUSTOM2 3
 255
 256 class CAvgGear
 257 {
 258   public:
 259     /**
 260      * TRANSMISSION SHIFT POSITION
 261      * 0=P, 1=R, 2=N, 4=D, 5=L, 6=2, 7=oem
 262      */
 263     enum E_AT_GEAR
 264     {
 265         E_SHIFT_PARKING = 0, // 0=P
 266         E_SHIFT_REVERSE,     // 1=R
 267         E_SHIFT_NEUTRAL,     // 2=N
 268         E_SHIFT_DRIVE = 4,   // 4=N
 269         E_SHIFT_FIRST,       // 5=L
 270         E_SHIFT_SECOND,      // 6=2
 271         E_SHIFT_THIRD,        // 7=oem
 272         E_SHIFT_MT_FIRST = 11,
 273         E_SHIFT_MT_SECOND,
 274         E_SHIFT_MT_THIRD,
 275         E_SHIFT_MT_FOURTH,
 276         E_SHIFT_MT_FIFTH,
 277         E_SHIFT_MT_SIXTH,
 278     };
 279
 280             CAvgGear();
 281             ~CAvgGear();
 282
 283     void    setShiftDown();
 284     void    setShiftUp();
 285     E_AT_GEAR getSelectGear() const;
 286     int     getValue() const;
 287     int     getMode() const;
 288     double  getGearRatio(double speed, bool down = false) const;
 289     void    chgGear(E_AT_GEAR tm);
 290     bool    isReverse() const;
 291     bool    isNeutral() const;
 292     bool    isParking() const;
 293
 294     void    setShiftMT(E_AT_GEAR tm);
 295
 296     bool    isReverseLastTime() const;
 297     void    reset_old();
 298
 299   private:
 300     E_AT_GEAR m_transmission;
 301     E_AT_GEAR m_transmissionOLD;
 302     int       m_transmissionValue;
 303 };
 304
 305 /**
 306  * @brief chgGear
 307  * @param tm
 308  */
 309 inline void CAvgGear::chgGear(E_AT_GEAR tm)
 310 {
 311     m_transmissionOLD = m_transmission;
 312     m_transmission = tm;
 313 }
 314
 315 /**
 316  * @brief isReverse
 317  * @return true / false
 318  */
 319 inline bool CAvgGear::isReverse() const
 320 {
 321     if (E_SHIFT_REVERSE == m_transmission) {
 322         return true;
 323     }
 324     return false;
 325 }
 326
 327 /**
 328  * @brief isNeutral
 329  * @return true / false
 330  */
 331 inline bool CAvgGear::isNeutral() const
 332 {
 333     if (E_SHIFT_NEUTRAL == m_transmission) {
 334         return true;
 335     }
 336     return false;
 337 }
 338
 339 /**
 340  * @brief isParking
 341  * @return true / false
 342  */
 343 inline bool CAvgGear::isParking() const
 344 {
 345     if (E_SHIFT_PARKING == m_transmission) {
 346         return true;
 347     }
 348     return false;
 349 }
 350
 351 /**
 352  * @vrief getSelectGear
 353  * @return transmission position is amb transmission position
 354  */
 355 inline CAvgGear::E_AT_GEAR CAvgGear::getSelectGear() const
 356 {
 357     return m_transmission;
 358 }
 359
 360 /**
 361  * @brief getValue
 362  * @return transmission value is amd transmission value
 363  */
 364 inline int CAvgGear::getValue() const
 365 {
 366     return m_transmissionValue;
 367 }
 368
 369 /**
 370  * @brief getMode
 371  * @return transmission Mode is amd transmission Mode
 372  */
 373 inline int CAvgGear::getMode() const
 374 {
 375     return D_SHIFT_MODE_NORMAL;
 376 }
 377
 378 /**
 379  * @brief Reverse gear last time check
 380  * @return true / false
 381  */
 382 inline bool CAvgGear::isReverseLastTime() const
 383 {
 384     if (E_SHIFT_REVERSE == m_transmissionOLD) {
 385         return true;
 386     }
 387     return false;
 388 }
 389
 390 /**
 391  * @brief reset_old
 392  * @return transmission old value clear
 393  */
 394 inline void CAvgGear::reset_old()
 395 {
 396     m_transmissionOLD = m_transmission;
 397 }
 398
 399 /******************************************
 400  * Average Car
 401 ******************************************/
 402 #define D_ACCPEDAL_OPEN 65534
 403
 404 class CAvgCar:public CAvgGear
 405 {
 406 public:
 407             CAvgCar(const short RPMsz = 0,
 408                     const short SPDsz = 0,
 409                     const short BRKsz = 0);
 410             ~CAvgCar();
 411
 412     void    chgThrottle(int throttle);
 413     double  getRPM() const;
 414     bool    isEngineActive() const;
 415
 416     void    chgBrake(int brakeVal);
 417     bool    isOnBrake() const;
 418     int     getBrakeAvg() const;
 419     int     calcPressure(int brakeVal) const;
 420
 421     void    calc();
 422     double  getSpeed() const;
 423     double  getCurrentRun() const;
 424     double  getTotalRun() const;
 425     int     calcAccPedalOpen() const;
 426     double  getTripmeter() const;
 427     void    tripmeterReset();
 428
 429     void    updateAvg();
 430 private:
 431
 432     CAvgBrake m_brake;
 433     CAvgEngine m_engine;
 434
 435     double  m_odometer;
 436     double  m_currentRunMeter;
 437     double  m_tripmeter;
 438
 439     struct timespec m_tp;
 440     averageMachine  m_speed;
 441
 442     iAverageMachine m_accPedalOpen;
 443     bool    m_bChgThrottle;
 444     int     m_valThrottle;
 445     bool    m_bChgBrake;
 446     int     m_valBrake;
 447 };
 448
 449 /**
 450  * @brief getRPM
 451  * @return RPM
 452  */
 453 inline double CAvgCar::getRPM() const
 454 {
 455     return m_engine.getRPM();
 456 }
 457
 458 /**
 459  * @brief isEngineActive
 460  * @return true / false
 461  */
 462 inline bool CAvgCar::isEngineActive() const
 463 {
 464     return m_engine.isActive();
 465 }
 466
 467 /**
 468  * @brief isOnBrake
 469  * @return true / false
 470  */
 471 inline bool CAvgCar::isOnBrake() const
 472 {
 473     return m_brake.isOnBrake();
 474 }
 475
 476 /**
 477  * @brief getSpeed()
 478  * @return speed
 479  */
 480 inline double CAvgCar::getSpeed() const
 481 {
 482     return m_speed.getAvg();
 483 }
 484
 485 /**
 486  * @brief getCurrntRun
 487  * @return meter run range
 488  */
 489 inline double CAvgCar::getCurrentRun() const
 490 {
 491     return m_currentRunMeter;
 492 }
 493
 494 /**
 495  * @brief getTotalRun
 496  * @return odo meter value
 497  */
 498 inline double CAvgCar::getTotalRun() const
 499 {
 500     return m_odometer;
 501 }
 502
 503 /**
 504  * @brief getBrakeAvg
 505  * @return brake avveage valeu
 506  */
 507 inline int CAvgCar::getBrakeAvg() const
 508 {
 509     return m_brake.getBrakeAvg();
 510 }
 511
 512 /**
 513  * @brief calcPressure
 514  * @return
 515  */
 516 inline int CAvgCar::calcPressure(int brakeVal) const
 517 {
 518     return m_brake.calcPressure(brakeVal);
 519 }
 520
 521 /**
 522  * @brief calcAccPedalOpen
 523  * @return
 524  */
 525 inline int CAvgCar::calcAccPedalOpen() const
 526 {
 527     double x = (double)m_accPedalOpen.getIAvg() / (double)D_ACCPEDAL_OPEN;
 528     return  (int)(x*100.0);
 529 }
 530 /**
 531  * @brief get Tripmeter
 532  * @return trip meter value
 533  */
 534 inline double CAvgCar::getTripmeter() const
 535 {
 536     return m_tripmeter;
 537 }
 538 /**
 539  * @brief tripmeterReset
 540  *        tripmeter reset
 541  */
 542 inline void CAvgCar::tripmeterReset()
 543 {
 544     m_tripmeter = 0;
 545 }
 546
 547 #endif // CAVGCAR_H