git.maemo.org Git - speedfreak/blob - Client/calculate.cpp

   1 /*
   2  * Calculate class to process accelerometer data
   3  *
   4  * @author      Kai Rasilainen <kai.rasilainen@fudeco.com>
   5  * @author      Jukka Kurttila <jukka.kurttila@fudeco.com>
   6  * @author      Toni Jussila   <toni.jussila@fudeco.com>
   7  * @copyright   (c) 2010 Speed Freak team
   8  * @license     http://opensource.org/licenses/gpl-license.php GNU Public License
   9  */
  10
  11 #include "calculate.h"
  12 #include <math.h>
  13 #include <QFile>
  14 #include <QString>
  15 #include <QTimer>
  16 #include <QRegExp>
  17
  18 const double G_ACCELERATION = 9.80665;
  19 const double SECONDS_IN_HOUR = 3600;
  20 const double AIR_DENSITY = 1.225;
  21 const double WATTS_PER_HORSEPOWER = 745.69987158227025;
  22 const double carFrontalArea = 1.5;
  23 const double dragCoefficient = 0.31;
  24 const int carWeight = 850;
  25
  26 /**
  27   * Default constructor for Calculate class.
  28   */
  29 Calculate::Calculate()
  30 {
  31     this->reset();
  32 }
  33
  34 /**
  35   * Default destructor for Calculate class.
  36   * Deletes all dynamic objects and sets them to NULL.
  37   */
  38 Calculate::~Calculate()
  39 {
  40
  41 }
  42
  43 /**
  44   * This function reset all variables.
  45   */
  46 void Calculate::reset()
  47 {
  48     averageSpeed = 0;
  49     averagePower = 0;
  50     peakPower = 0;
  51     currentPower = 0;
  52     currentSpeed = 0;
  53     maxSpeed = 0;
  54     distanceTraveled = 0;
  55     lastAcceleration = 0;
  56     lastDistance = 0;
  57     lastSpeed = 0;
  58     numOfIterations = 0;
  59     totalTime = 0;
  60     count = 0;
  61
  62     if(speedCheckPoints.count() == 0)
  63     {
  64         speedCheckPoints.append(10);
  65         speedCheckPoints.append(20);
  66         speedCheckPoints.append(30);
  67         speedCheckPoints.append(40);
  68         speedCheckPoints.append(50);
  69         speedCheckPoints.append(60);
  70         speedCheckPoints.append(70);
  71         speedCheckPoints.append(80);
  72         speedCheckPoints.append(90);
  73         speedCheckPoints.append(100);
  74     }
  75     checkPointCounter = 0;
  76     checkPoint = speedCheckPoints[checkPointCounter];
  77     valuesMap.clear();
  78 }
  79
  80 /**
  81   * This is a main function for calculating various parameters. Accelerometer
  82   * provides currentAcceleration and calling function measures time (seconds).
  83   * This function should be called 20-30 times/second to minimize
  84   * calculation error.
  85   *
  86   * @param double current acceleration
  87   * @param double seconds
  88   */
  89 void Calculate::calculateParameters(double currentAcceleration, double seconds)
  90 {
  91     double force, power1, power2;
  92
  93     currentAcceleration *= G_ACCELERATION;
  94     numOfIterations++;
  95     totalTime = (totalTime + seconds);
  96
  97     // v=v0 + a*t
  98     // v(n) = v(n-1)+(a(n) + a(n-1))*(seconds)/2
  99
 100     // First integration of acceleration provides speed
 101     currentSpeed = (lastSpeed + (((currentAcceleration + lastAcceleration) * seconds) / 2));
 102
 103     // Update maximum speed
 104     if (currentSpeed > maxSpeed)
 105         maxSpeed = currentSpeed;
 106
 107     // Second integration: distance.
 108     distanceTraveled = (lastDistance + (((currentSpeed + lastSpeed) * seconds) / 2));
 109
 110     // Average speed
 111     averageSpeed = (distanceTraveled / totalTime);
 112
 113     // F=ma
 114     force = (carWeight * currentAcceleration);
 115
 116     power1 = (force * currentSpeed);
 117
 118     power2 = ((AIR_DENSITY * (pow(currentSpeed, 3)
 119              * (carFrontalArea * dragCoefficient))) / 2);
 120
 121     currentPower = ((power1 + power2) / WATTS_PER_HORSEPOWER);
 122
 123     // Save peak power
 124     if ((currentPower > peakPower))
 125     {
 126         peakPower = currentPower;
 127     }
 128
 129     if ((currentPower > 0))
 130     {
 131         averagePower = (averagePower + currentPower);
 132     }
 133     else
 134     {
 135         numOfIterations--;
 136     }
 137
 138     if( (checkPoint > 0) && (currentSpeed*3.6 > checkPoint) )
 139     {
 140         //Update checkPoint
 141         if( checkPointCounter <= speedCheckPoints.count() )
 142         {
 143             //Save time
 144             valuesMap.insert( checkPoint, totalTime );
 145             if( checkPointCounter < speedCheckPoints.count() )
 146             {
 147                 checkPoint = speedCheckPoints[checkPointCounter];
 148             }
 149             else
 150             {
 151                 checkPoint = 0;
 152             }
 153             checkPointCounter++;
 154         }
 155     }
 156
 157     // Check for movement
 158     //accelStoppedCheck(currentAcceleration);
 159
 160     lastSpeed = currentSpeed;
 161     lastAcceleration = currentAcceleration;
 162     lastDistance = distanceTraveled;
 163 }
 164
 165 /**
 166   * This function checks if acceleration has stopped for
 167   * a short period of time. Velocity is set to zero to avoid
 168   * distance errors.
 169   *
 170   * @param double current acceleration
 171   */
 172 void Calculate::accelStoppedCheck(double currentAcceleration)
 173 {
 174     // counting number of acceleration samples that equals zero
 175     if (currentAcceleration==0) {
 176         count++;
 177     } else {
 178         count = 0;
 179     }
 180
 181     // if count exceeds 25, we assume that velocity is zero
 182     if (count >= 25)
 183     {
 184         currentSpeed=0;
 185     }
 186 }
 187
 188 /**
 189   * Get average speed.
 190   *
 191   * @return double average speed
 192   */
 193 double Calculate::getAverageSpeed()
 194 {
 195     return averageSpeed;
 196 }
 197
 198 /**
 199   * Set average speed.
 200   *
 201   * @param double average speed
 202   */
 203 void Calculate::setAverageSpeed(double value)
 204 {
 205     averageSpeed = value;
 206 }
 207
 208 /**
 209   * Get current speed.
 210   *
 211   * @return double current speed
 212   */
 213 double Calculate::getCurrentSpeed()
 214 {
 215     return currentSpeed;
 216 }
 217
 218 /**
 219   * Set current speed.
 220   *
 221   * @param double current speed
 222   */
 223 void Calculate::setCurrentSpeed(double value)
 224 {
 225     currentSpeed = value;
 226 }
 227
 228 /**
 229   * Get travelled distance.
 230   *
 231   * @return double travelled distance
 232   */
 233 double Calculate::getDistanceTraveled()
 234 {
 235     return distanceTraveled;
 236 }
 237
 238 /**
 239   * Set travelled distance.
 240   *
 241   * @param double travelled distance
 242   */
 243 void Calculate::setDistanceTraveled(double value)
 244 {
 245     distanceTraveled = value;
 246 }
 247
 248 /**
 249   * Get last acceleration.
 250   *
 251   * @return double last acceleration
 252   */
 253 double Calculate::getLastAcceleration()
 254 {
 255     return lastAcceleration;
 256 }
 257
 258 /**
 259   * Set last acceleration.
 260   *
 261   * @param double last acceleration
 262   */
 263 void Calculate::setLastAcceleration(double value)
 264 {
 265     lastAcceleration = value;
 266 }
 267
 268 /**
 269   * Get last distance.
 270   *
 271   * @return double last distance
 272   */
 273 double Calculate::getLastDistance()
 274 {
 275     return lastDistance;
 276 }
 277
 278 /**
 279   * Set last distance.
 280   *
 281   * @param double last distance
 282   */
 283 void Calculate::setLastDistance(double value)
 284 {
 285     lastDistance = value;
 286 }
 287
 288 /**
 289   * Get last speed.
 290   *
 291   * @return double last speed
 292   */
 293 double Calculate::getLastSpeed()
 294 {
 295     return lastSpeed;
 296 }
 297
 298 /**
 299   * Set last speed.
 300   *
 301   * @param double last speed
 302   */
 303 void Calculate::setLastSpeed(double value)
 304 {
 305     lastSpeed = value;
 306 }
 307
 308 /**
 309   * Get number of iterations.
 310   *
 311   * @return long number of iterations
 312   */
 313 long Calculate::getNumOfIterations()
 314 {
 315     return numOfIterations;
 316 }
 317
 318 /**
 319   * Set number of iterations.
 320   *
 321   * @param long number of iterations
 322   */
 323 void Calculate::setNumOfIterations(long value)
 324 {
 325     numOfIterations = value;
 326 }
 327
 328 /**
 329   * Get total time.
 330   *
 331   * @return double total time
 332   */
 333 double Calculate::getTotalTime()
 334 {
 335     return totalTime;
 336 }
 337
 338 /**
 339   * Set total time.
 340   *
 341   * @param double total time
 342   */
 343 void Calculate::setTotalTime(double value)
 344 {
 345     totalTime = value;
 346 }
 347
 348 /**
 349   * Get current power.
 350   *
 351   * @return double current power
 352   */
 353 double Calculate::getCurrentPower()
 354 {
 355     return currentPower;
 356 }
 357
 358 /**
 359   * Set current power.
 360   *
 361   * @param double current power
 362   */
 363 void Calculate::setCurrentPower(double value)
 364 {
 365     currentPower = value;
 366 }
 367
 368 /**
 369   * Get peek power.
 370   *
 371   * @return double peek power
 372   */
 373 double Calculate::getPeakPower()
 374 {
 375     return peakPower;
 376 }
 377
 378 /**
 379   * Set peek power.
 380   *
 381   * @param double peek power
 382   */
 383 void Calculate::setPeakPower(double value)
 384 {
 385     peakPower = value;
 386 }
 387
 388 /**
 389   * Get average power.
 390   *
 391   * @return double average power
 392   */
 393 double Calculate::getAveragePower()
 394 {
 395     if (numOfIterations > 0)
 396     {
 397         return (averagePower/numOfIterations);
 398     }
 399     else
 400     {
 401         return 0;
 402     }
 403 }
 404
 405 /**
 406   * Set average power.
 407   *
 408   * @param double average power
 409   */
 410 void Calculate::setAveragePower(double value)
 411 {
 412     averagePower = value;
 413 }
 414
 415 /**
 416   * Get max speed.
 417   *
 418   * @return double max speed
 419   */
 420 double Calculate::getMaxSpeed()
 421 {
 422     return maxSpeed;
 423 }
 424
 425 /**
 426   * Set max speed.
 427   *
 428   * @param double max speed
 429   */
 430 void Calculate::setMaxSpeed(double value)
 431 {
 432     maxSpeed = value;
 433 }
 434
 435 /**
 436   * Get values map.
 437   *
 438   * @return QMap<int,double> values map.
 439   */
 440 QMap<int,double> Calculate::getValuesMap()
 441 {
 442     return valuesMap;
 443 }