Coding conventions added.

diff --git a/Client/calculate.cpp b/Client/calculate.cpp
index 781f7f9..ad535b1 100644 (file)
--- a/Client/calculate.cpp
+++ b/Client/calculate.cpp
@@ -9,17 +9,18 @@
 const double G_ACCELERATION = 9.80665;
 const double SECONDS_IN_HOUR = 3600;
 
 const double G_ACCELERATION = 9.80665;
 const double SECONDS_IN_HOUR = 3600;
 

-Calculate::Calculate() {
-
+Calculate::Calculate()
+{

     this->reset();
     this->reset();

-

 }
 
 }
 

-Calculate::~Calculate() {
-}
+Calculate::~Calculate()
+{

 
 

-void Calculate::reset() {
+}

 
 

+void Calculate::reset()
+{

     averageSpeed = 0;
     currentSpeed = 0;
     distanceTraveled = 0;
     averageSpeed = 0;
     currentSpeed = 0;
     distanceTraveled = 0;

@@ -28,85 +29,100 @@ void Calculate::reset() {
     lastSpeed = 0;
     numOfIterations = 0;
     totalTime = 0;
     lastSpeed = 0;
     numOfIterations = 0;
     totalTime = 0;

+    count = 0;

 }
 
 }
 

-/* Getters and setters
-   */
+// Getters and setters

 
 

-double Calculate::AverageSpeed()
+double Calculate::getAverageSpeed()

 {
     return averageSpeed;
 }
 {
     return averageSpeed;
 }

-void Calculate::AverageSpeed(double value)
+
+void Calculate::setAverageSpeed(double value)

 {
     averageSpeed = value;
 }
 {
     averageSpeed = value;
 }

-double Calculate::CurrentSpeed()
+
+double Calculate::getCurrentSpeed()

 {
     return currentSpeed;
 }
 {
     return currentSpeed;
 }

-void Calculate::CurrentSpeed(double value)
+
+void Calculate::setCurrentSpeed(double value)

 {
     currentSpeed = value;
 }
 {
     currentSpeed = value;
 }

-double Calculate::DistanceTraveled()
+
+double Calculate::getDistanceTraveled()

 {
     return distanceTraveled;
 }
 {
     return distanceTraveled;
 }

-void Calculate::DistanceTraveled(double value)
+
+void Calculate::setDistanceTraveled(double value)

 {
     distanceTraveled = value;
 }
 {
     distanceTraveled = value;
 }

-double Calculate::LastAcceleration()
+
+double Calculate::getLastAcceleration()

 {
     return lastAcceleration;
 }
 {
     return lastAcceleration;
 }

-void Calculate::LastAcceleration(double value)
+
+void Calculate::setLastAcceleration(double value)

 {
     lastAcceleration = value;
 }
 {
     lastAcceleration = value;
 }

-double Calculate::LastDistance()
+
+double Calculate::getLastDistance()

 {
     return lastDistance;
 }
 {
     return lastDistance;
 }

-void Calculate::LastDistance(double value)
+
+void Calculate::setLastDistance(double value)

 {
     lastDistance = value;
 }
 {
     lastDistance = value;
 }

-double Calculate::LastSpeed()
+
+double Calculate::getLastSpeed()

 {
     return lastSpeed;
 }
 {
     return lastSpeed;
 }

-void Calculate::LastSpeed(double value)
+
+void Calculate::setLastSpeed(double value)

 {
     lastSpeed = value;
 }
 {
     lastSpeed = value;
 }

-long Calculate::NumOfIterations()
+
+long Calculate::getNumOfIterations()

 {
     return numOfIterations;
 }
 {
     return numOfIterations;
 }

-void Calculate::NumOfIterations(long value)
+
+void Calculate::setNumOfIterations(long value)

 {
     numOfIterations = value;
 }
 {
     numOfIterations = value;
 }

-double Calculate::TotalTime()
+
+double Calculate::getTotalTime()

 {
     return totalTime;
 }
 {
     return totalTime;
 }

-void Calculate::TotalTime(double value)
+
+void Calculate::setTotalTime(double value)

 {
     totalTime = value;
 }
 
 {
     totalTime = value;
 }
 

-/*
-  This is a main function for calculating various parameters. Accelerometer
-  provides currentAcceleration and calling function measures time (seconds).
-  This function should be called 20-30 times/second to minimize
-  calculation error.
+/**
+  * This is a main function for calculating various parameters. Accelerometer
+  * provides currentAcceleration and calling function measures time (seconds).
+  * This function should be called 20-30 times/second to minimize
+  * calculation error.

 
 

-  To be added: params like horsepower.
+  * To be added: params like horsepower.

   */
   */

-void Calculate::CalculateParameters(double currentAcceleration, double seconds)
+void Calculate::calculateParameters(double currentAcceleration, double seconds)

 {
     numOfIterations++;
     totalTime = (totalTime + seconds);
 {
     numOfIterations++;
     totalTime = (totalTime + seconds);

@@ -114,20 +130,16 @@ void Calculate::CalculateParameters(double currentAcceleration, double seconds)
     // v=v0 + a*t
     // v(n) = v(n-1)+(a(n) + a(n-1))*(seconds)/2
 
     // v=v0 + a*t
     // v(n) = v(n-1)+(a(n) + a(n-1))*(seconds)/2
 

-    /* First integration of acceleration provides speed
-       */
+    // First integration of acceleration provides speed

     currentSpeed = (lastSpeed + (((currentAcceleration + lastAcceleration) * seconds) / 2));
 
     currentSpeed = (lastSpeed + (((currentAcceleration + lastAcceleration) * seconds) / 2));
 

-    /* Second integration: distance.
-       */
+    // Second integration: distance.

     distanceTraveled = (lastDistance + (((currentSpeed + lastSpeed) * seconds) / 2));
 
     distanceTraveled = (lastDistance + (((currentSpeed + lastSpeed) * seconds) / 2));
 

-    /* Average speed
-       */
+    // Average speed

     averageSpeed = (distanceTraveled / totalTime);
 
     averageSpeed = (distanceTraveled / totalTime);
 

-    /* Check for movement
-           */
+    // Check for movement

     accelStoppedCheck(currentAcceleration);
 
     lastSpeed = currentSpeed;
     accelStoppedCheck(currentAcceleration);
 
     lastSpeed = currentSpeed;

@@ -140,15 +152,13 @@ void Calculate::CalculateParameters(double currentAcceleration, double seconds)
   * a short period of time. Velocity is set to zero to avoid
   * distance errors.
   */
   * a short period of time. Velocity is set to zero to avoid
   * distance errors.
   */

-void Calculate::accelStoppedCheck(double currentAcceleration) {
+void Calculate::accelStoppedCheck(double currentAcceleration)
+{

 
     // counting number of acceleration samples that equals zero
 
     // counting number of acceleration samples that equals zero

-    if (currentAcceleration==0)
-    {
+    if (currentAcceleration==0) {

         count++;
         count++;

-    }
-    else
-    {
+    } else {

         count = 0;
     }
 
         count = 0;
     }
 

diff --git a/Client/calculate.h b/Client/calculate.h
index db86aed..421990f 100644 (file)
--- a/Client/calculate.h
+++ b/Client/calculate.h
@@ -13,35 +13,35 @@ public:
     ~Calculate();
 
     void reset();
     ~Calculate();
 
     void reset();

-    void CalculateParameters(double currentAcceleration, double seconds);
+    void calculateParameters(double currentAcceleration, double seconds);

     void accelStoppedCheck(double currentAcceleration);
 
     void accelStoppedCheck(double currentAcceleration);
 

-    double AverageSpeed();
-    void AverageSpeed(double value);
+    double getAverageSpeed();
+    void setAverageSpeed(double value);

 
 

-    double CurrentSpeed();
-    void CurrentSpeed(double value);
+    double getCurrentSpeed();
+    void setCurrentSpeed(double value);

 
 

-    double DistanceTraveled();
-    void DistanceTraveled(double value);
+    double getDistanceTraveled();
+    void setDistanceTraveled(double value);

 
 

-    double LastAcceleration();
-    void LastAcceleration(double value);
+    double getLastAcceleration();
+    void setLastAcceleration(double value);

 
 

-    double LastCheckpoint();
-    void LastCheckpoint(double value);
+    double getLastCheckpoint();
+    void setLastCheckpoint(double value);

 
 

-    double LastDistance();
-    void LastDistance(double value);
+    double getLastDistance();
+    void setLastDistance(double value);

 
 

-    double LastSpeed();
-    void LastSpeed(double value);
+    double getLastSpeed();
+    void setLastSpeed(double value);

 
 

-    long NumOfIterations();
-    void NumOfIterations(long value);
+    long getNumOfIterations();
+    void setNumOfIterations(long value);

 
 

-    double TotalTime();
-    void TotalTime(double value);
+    double getTotalTime();
+    void setTotalTime(double value);

 
 private:
     double averageSpeed;
 
 private:
     double averageSpeed;