Merge branch 'fix/fix-security' into 'chores/refactoring'

fix: Fix current average value computation

See merge request cdf2020/microcontrollers/motors-control-card/motors-control-card-driver!18

include/Security.hpp

@@ -52,7 +52,10 @@ private:
     mbed::AnalogIn m_adcRightMotor;
     mbed::AnalogIn m_adcReference;
 
-    volatile uint8_t m_measuresToPerform;
+    uint8_t m_adcMeasuresCounter;
+    double m_leftVoltageAverage = 0;
+    double m_rightVoltageAverage = 0;
+    double m_referenceVoltageAverage = 0;
 
     uint32_t m_motorCurrentLimit; // mA
     uint32_t m_leftMotorCurrent;

src/Security.cpp

@@ -6,7 +6,7 @@ Security::Security(MotorsController &motorsController, uint32_t motorCurrentLimi
                                                                                                              m_adcLeftMotor(A4),
                                                                                                              m_adcRightMotor(A3),
                                                                                                              m_adcReference(A2),
-                                                                                                             m_measuresToPerform(0),
+                                                                                                             m_adcMeasuresCounter(0),
                                                                                                              m_motorCurrentLimit(motorCurrentLimit),
                                                                                                              m_leftMotorCurrent(0),
                                                                                                              m_rightMotorCurrent(0),
@@ -15,58 +15,41 @@ Security::Security(MotorsController &motorsController, uint32_t motorCurrentLimi
 {
     //Useless if we use an update method
     m_adcMeasuresTimer.attach(mbed::callback(this, &Security::performADCMeasure), 0.001); // ADC measure every 1ms
+
+    m_leftVoltageAverage = 0;
+    m_rightVoltageAverage = 0;
+    m_referenceVoltageAverage = 0;
 }
 
 void Security::performADCMeasure()
 {
-    m_measuresToPerform++;
-    //TODO(cjaverliat): This should actually contain the ADC measure... For example we could store an array of fixed size
+    m_leftVoltageAverage += m_adcLeftMotor.read();
+    m_rightVoltageAverage += m_adcRightMotor.read();
+    m_referenceVoltageAverage += m_adcReference.read();
+    ++m_adcMeasuresCounter;
 }
 
 bool Security::checkCurrent()
 {
+    // Average value on 0.001*200 = 200ms
+    if (m_adcMeasuresCounter >= 200)
+    {
+        // Voltage average computation
+        double adcLeft = m_leftVoltageAverage / 200;
+        double adcRight = m_rightVoltageAverage / 200;
+        double adcRef = m_referenceVoltageAverage / 200;
 
-    // TODO(cjaverliat): rework this, it looks like the average is useless here
-    // We should probably keep track of the n ADC measure before, and compute the average here
-
-    double leftVoltageAverage = 0;
-    double rightVoltageAverage = 0;
-    double referenceVoltageAverage = 0;
-
-    const uint8_t adcSampleMax = 200;
-
-    uint8_t adcMeasuresCounter = 0;
+        m_leftMotorCurrent = 1000 * (VCC_VALUE * (adcLeft - adcRef)) / (GAIN_OP_AMP * R_SHUNT);
+        m_rightMotorCurrent = 1000 * (VCC_VALUE * (adcRight - adcRef)) / (GAIN_OP_AMP * R_SHUNT);
 
-    while (m_measuresToPerform != 0)
-    {
-        m_measuresToPerform--;
+        m_leftVoltageAverage = 0;
+        m_rightVoltageAverage = 0;
+        m_referenceVoltageAverage = 0;
+        m_adcMeasuresCounter = 0;
 
-        if (adcMeasuresCounter <= adcSampleMax)
-        {
-            adcMeasuresCounter++;
-            leftVoltageAverage += m_adcLeftMotor.read();
-            rightVoltageAverage += m_adcRightMotor.read();
-            referenceVoltageAverage += m_adcReference.read();
-        }
-        else
+        if (m_leftMotorCurrent > m_motorCurrentLimit || m_rightMotorCurrent > m_motorCurrentLimit)
         {
-            // Voltage average computation
-            double adcLeft = leftVoltageAverage / adcSampleMax;
-            double adcRight = rightVoltageAverage / adcSampleMax;
-            double adcRef = referenceVoltageAverage / adcSampleMax;
-
-            m_leftMotorCurrent = 1000 * (VCC_VALUE * (adcLeft - adcRef)) / (GAIN_OP_AMP * R_SHUNT);
-            m_rightMotorCurrent = 1000 * (VCC_VALUE * (adcRight - adcRef)) / (GAIN_OP_AMP * R_SHUNT);
-
-            leftVoltageAverage = 0;
-            rightVoltageAverage = 0;
-            referenceVoltageAverage = 0;
-            adcMeasuresCounter = 0;
-
-            if (m_leftMotorCurrent > m_motorCurrentLimit || m_rightMotorCurrent > m_motorCurrentLimit)
-            {
-                return 1;
-            }
+            return 1;
         }
     }
     return 0;