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_DRIVE    4
 240 #define D_SHIFT_VALUE_THIRD    3
 241 #define D_SHIFT_VALUE_SECOND   2
 242 #define D_SHIFT_VALUE_FIRST    1
 243 /**
 244  * TRANSMISSION SHIFT MODE
 245  * 0=normal, 1=sports, 2=eco, 3=oem custom,
 246  * 4=oem custom2
 247  */
 248 #define D_SHIFT_MODE_NORMAL     0
 249 #define D_SHIFT_MODE_SPOETS     1
 250 #define D_SHIFT_MODE_ECO        2
 251 #define D_SHIFT_MODE_OEMCUSTOM  3
 252 #define D_SHIFT_MODE_OEMCUSTOM2 3
 253
 254 class CAvgGear
 255 {
 256   public:
 257     /**
 258      * TRANSMISSION SHIFT POSITION
 259      * 0=P, 1=R, 2=N, 4=D, 5=L, 6=2, 7=oem
 260      */
 261     enum E_AT_GEAR
 262     {
 263         E_SHIFT_PARKING = 0, // 0=P
 264         E_SHIFT_REVERSE,     // 1=R
 265         E_SHIFT_NEUTRAL,     // 2=N
 266         E_SHIFT_DRIVE = 4,   // 4=N
 267         E_SHIFT_FIRST,       // 5=L
 268         E_SHIFT_SECOND,      // 6=2
 269         E_SHIFT_THIRD        // 7=oem
 270     };
 271
 272             CAvgGear();
 273             ~CAvgGear();
 274
 275     void    setShiftDown();
 276     void    setShiftUp();
 277     E_AT_GEAR getSelectGear() const;
 278     int     getValue() const;
 279     int     getMode() const;
 280     double  getGearRatio(double speed, bool down = false) const;
 281     void    chgGear(E_AT_GEAR tm);
 282     bool    isReverse() const;
 283     bool    isNeutral() const;
 284     bool    isParking() const;
 285   private:
 286     E_AT_GEAR m_transmission;
 287     int       m_transmissionValue;
 288 };
 289
 290 /**
 291  * @brief chgGear
 292  * @param tm
 293  */
 294 inline void CAvgGear::chgGear(E_AT_GEAR tm)
 295 {
 296     m_transmission = tm;
 297 }
 298
 299 /**
 300  * @brief isReverse
 301  * @return true / false
 302  */
 303 inline bool CAvgGear::isReverse() const
 304 {
 305     if (E_SHIFT_REVERSE == m_transmission) {
 306         return true;
 307     }
 308     return false;
 309 }
 310
 311 /**
 312  * @brief isNeutral
 313  * @return true / false
 314  */
 315 inline bool CAvgGear::isNeutral() const
 316 {
 317     if (E_SHIFT_NEUTRAL == m_transmission) {
 318         return true;
 319     }
 320     return false;
 321 }
 322
 323 /**
 324  * @brief isParking
 325  * @return true / false
 326  */
 327 inline bool CAvgGear::isParking() const
 328 {
 329     if (E_SHIFT_PARKING == m_transmission) {
 330         return true;
 331     }
 332     return false;
 333 }
 334
 335 /**
 336  * @vrief getSelectGear
 337  * @return transmission position is amb transmission position
 338  */
 339 inline CAvgGear::E_AT_GEAR CAvgGear::getSelectGear() const
 340 {
 341     return m_transmission;
 342 }
 343
 344 /**
 345  * @brief getValue
 346  * @return transmission value is amd transmission value
 347  */
 348 inline int CAvgGear::getValue() const
 349 {
 350     return m_transmissionValue;
 351 }
 352
 353 /**
 354  * @brief getMode
 355  * @return transmission Mode is amd transmission Mode
 356  */
 357 inline int CAvgGear::getMode() const
 358 {
 359     return D_SHIFT_MODE_NORMAL;
 360 }
 361
 362 /******************************************
 363  * Average Car
 364 ******************************************/
 365 #define D_ACCPEDAL_OPEN 65534
 366
 367 class CAvgCar:public CAvgGear
 368 {
 369 public:
 370             CAvgCar(const short RPMsz = 0,
 371                     const short SPDsz = 0,
 372                     const short BRKsz = 0);
 373             ~CAvgCar();
 374
 375     void    chgThrottle(int throttle);
 376     double  getRPM() const;
 377     bool    isEngineActive() const;
 378
 379     void    chgBrake(int brakeVal);
 380     bool    isOnBrake() const;
 381     int     getBrakeAvg() const;
 382     int     calcPressure(int brakeVal) const;
 383
 384     void    calc();
 385     double  getSpeed() const;
 386     double  getCurrentRun() const;
 387     double  getTotalRun() const;
 388     int     calcAccPedalOpen() const;
 389     double  getTripmeter() const;
 390     void    tripmeterReset();
 391
 392     void    updateAvg();
 393 private:
 394
 395     CAvgBrake m_brake;
 396     CAvgEngine m_engine;
 397
 398     double  m_odometer;
 399     double  m_currentRunMeter;
 400     double  m_tripmeter;
 401
 402     struct timespec m_tp;
 403     averageMachine  m_speed;
 404
 405     iAverageMachine m_accPedalOpen;
 406     bool    m_bChgThrottle;
 407     int     m_valThrottle;
 408     bool    m_bChgBrake;
 409     int     m_valBrake;
 410 };
 411
 412 /**
 413  * @brief getRPM
 414  * @return RPM
 415  */
 416 inline double CAvgCar::getRPM() const
 417 {
 418     return m_engine.getRPM();
 419 }
 420
 421 /**
 422  * @brief isEngineActive
 423  * @return true / false
 424  */
 425 inline bool CAvgCar::isEngineActive() const
 426 {
 427     return m_engine.isActive();
 428 }
 429
 430 /**
 431  * @brief isOnBrake
 432  * @return true / false
 433  */
 434 inline bool CAvgCar::isOnBrake() const
 435 {
 436     return m_brake.isOnBrake();
 437 }
 438
 439 /**
 440  * @brief getSpeed()
 441  * @return speed
 442  */
 443 inline double CAvgCar::getSpeed() const
 444 {
 445     return m_speed.getAvg();
 446 }
 447
 448 /**
 449  * @brief getCurrntRun
 450  * @return meter run range
 451  */
 452 inline double CAvgCar::getCurrentRun() const
 453 {
 454     return m_currentRunMeter;
 455 }
 456
 457 /**
 458  * @brief getTotalRun
 459  * @return odo meter value
 460  */
 461 inline double CAvgCar::getTotalRun() const
 462 {
 463     return m_odometer;
 464 }
 465
 466 /**
 467  * @brief getBrakeAvg
 468  * @return brake avveage valeu
 469  */
 470 inline int CAvgCar::getBrakeAvg() const
 471 {
 472     return m_brake.getBrakeAvg();
 473 }
 474
 475 /**
 476  * @brief calcPressure
 477  * @return
 478  */
 479 inline int CAvgCar::calcPressure(int brakeVal) const
 480 {
 481     return m_brake.calcPressure(brakeVal);
 482 }
 483
 484 /**
 485  * @brief calcAccPedalOpen
 486  * @return
 487  */
 488 inline int CAvgCar::calcAccPedalOpen() const
 489 {
 490     double x = (double)m_accPedalOpen.getIAvg() / (double)D_ACCPEDAL_OPEN;
 491     return  (int)(x*100.0);
 492 }
 493 /**
 494  * @brief get Tripmeter
 495  * @return trip meter value
 496  */
 497 inline double CAvgCar::getTripmeter() const
 498 {
 499     return m_tripmeter;
 500 }
 501 /**
 502  * @brief tripmeterReset
 503  *        tripmeter reset
 504  */
 505 inline void CAvgCar::tripmeterReset()
 506 {
 507     m_tripmeter = 0;
 508 }
 509
 510 #endif // CAVGCAR_H