add steering system tests. Fix steering failure case

lib/mock_interfaces/SteeringEncoderInterface.h

@@ -20,15 +20,18 @@ struct SteeringEncoderConversion_s
 class SteeringEncoderInterface
 {
 public:
+// Mock data
+    SteeringEncoderConversion_s mockConversion;
 // Functions
-    /// @brief Commands the underlying steering sensor to sample and hold the result
-    virtual void sample();
-    /// @brief Calculate steering angle and whether result is in sensor's defined bounds. DOES NOT SAMPLE.
-    /// @return Calculated steering angle in degrees, upperSteeringStatus_s
-    virtual SteeringEncoderConversion_s convert();
-    /// @brief Set the upper steering sensor's offset. 0 degrees should be centered.
-    /// @param newOffset 
-    virtual void setOffset(float newOffset);
+    void sample()
+    {
+        return;
+    };
+    SteeringEncoderConversion_s convert()
+    {
+        return mockConversion;
+    };
+    void setOffset(float newOffset);
 };
 
 #endif /* __UPPERSTEERINGSENSOR_H__ */

lib/systems/include/SteeringSystem.h

@@ -9,8 +9,8 @@
 
 // Definitions
 // TODO: evalaute reasonable thresholds for agreement
-#define STEERING_DIVERGENCE_ERROR_THRESHOLD (14.0) // Steering sensors can disagree by 5 degrees before output is considered erroneous
-#define STEERING_DIVERGENCE_WARN_THRESHOLD (8.0) // Warning condition will be raised when steering sensors diverge 2.5 degrees
+#define STEERING_DIVERGENCE_ERROR_THRESHOLD (14.0) // Steering sensors can disagree by x degrees before output is considered erroneous
+#define STEERING_DIVERGENCE_WARN_THRESHOLD (8.0) // Warning condition will be raised when steering sensors diverge x degrees
 
 // Enums
 enum class SteeringSystemStatus_e

lib/systems/src/SteeringSystem.cpp

@@ -28,7 +28,7 @@ void SteeringSystem::tick(const SteeringSystemTick_s &intake)
         // Sensors disagree by STEERING_DIVERGENCE_WARN_THRESHOLD degrees and less than STEERING_DIVERGENCE_ERROR_THRESHOLD degrees
         else if (
             (primaryConversion_.status == SteeringEncoderStatus_e::STEERING_ENCODER_MARGINAL)
-            || (intake.secondaryConversion.status == AnalogSensorStatus_e::ANALOG_SENSOR_CLAMPED)
+            || ((primaryConversion_.status == SteeringEncoderStatus_e::STEERING_ENCODER_NOMINAL) && (intake.secondaryConversion.status == AnalogSensorStatus_e::ANALOG_SENSOR_CLAMPED))
             || ((std::abs(primaryConversion_.angle - intake.secondaryConversion.conversion) >= STEERING_DIVERGENCE_WARN_THRESHOLD) && (std::abs(primaryConversion_.angle - intake.secondaryConversion.conversion) < STEERING_DIVERGENCE_ERROR_THRESHOLD))
         )
         {

test/test_systems/main.cpp

@@ -6,6 +6,7 @@
 #include "drivetrain_system_test.h"
 #include "safety_system_test.h"
 #include "test_CASE.h"
+#include "steering_system_test.h"
 
 int main(int argc, char **argv)
 {

test/test_systems/steering_system_test.h

@@ -0,0 +1,202 @@
+#ifndef STEERING_SYSTEM_TEST
+#define STEERING_SYSTEM_TEST
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+#include "SteeringSystem.h"
+
+TEST(SteeringSystemTesting, test_steering_nominal)
+{
+    float angles_to_test[5] = {-120.0f, -60.0f, 0.0f, 60.0f, 120.0f};
+    // Boilerplate definitions for the testing aparatus
+    SysClock sys_clock;
+    SysTick_s sys_tick = sys_clock.tick(0);
+    SteeringEncoderInterface primarySensor;
+    SteeringSystem steeringSystem(&primarySensor);
+
+    // Sweep through a few angles where the sensors agree perfectly and check the system is nominal
+    for (float angle: angles_to_test)
+    {
+        primarySensor.mockConversion.angle = angle;
+        primarySensor.mockConversion.status = SteeringEncoderStatus_e::STEERING_ENCODER_NOMINAL;
+        steeringSystem.tick(
+            (SteeringSystemTick_s)
+            {
+                .tick = sys_tick,
+                .secondaryConversion = (AnalogConversion_s)
+                {
+                    .raw = 0,
+                    .conversion = angle,
+                    .status = AnalogSensorStatus_e::ANALOG_SENSOR_GOOD
+                }
+            }
+        );
+        ASSERT_TRUE(steeringSystem.getSteeringSystemData().angle == angle);
+        ASSERT_TRUE(steeringSystem.getSteeringSystemData().status == SteeringSystemStatus_e::STEERING_SYSTEM_NOMINAL);
+    }
+}
+
+TEST(SteeringSystemTesting, test_steering_primary_is_marginal)
+{
+    // Boilerplate definitions for the testing aparatus
+    SysClock sys_clock;
+    SysTick_s sys_tick = sys_clock.tick(0);
+    SteeringEncoderInterface primarySensor;
+    SteeringSystem steeringSystem(&primarySensor);
+    float angle = 0.0f;
+
+    primarySensor.mockConversion.angle = angle;
+    primarySensor.mockConversion.status = SteeringEncoderStatus_e::STEERING_ENCODER_MARGINAL;
+    steeringSystem.tick(
+        (SteeringSystemTick_s)
+        {
+            .tick = sys_tick,
+            .secondaryConversion = (AnalogConversion_s)
+            {
+                .raw = 0,
+                .conversion = angle,
+                .status = AnalogSensorStatus_e::ANALOG_SENSOR_GOOD
+            }
+        }
+    );
+    ASSERT_TRUE(steeringSystem.getSteeringSystemData().angle == angle);
+    ASSERT_TRUE(steeringSystem.getSteeringSystemData().status == SteeringSystemStatus_e::STEERING_SYSTEM_MARGINAL);
+}
+
+TEST(SteeringSystemTesting, test_steering_secondary_is_marginal)
+{
+    // Boilerplate definitions for the testing aparatus
+    SysClock sys_clock;
+    SysTick_s sys_tick = sys_clock.tick(0);
+    SteeringEncoderInterface primarySensor;
+    SteeringSystem steeringSystem(&primarySensor);
+    float angle = 0.0f;
+
+    primarySensor.mockConversion.angle = angle;
+    primarySensor.mockConversion.status = SteeringEncoderStatus_e::STEERING_ENCODER_NOMINAL;
+    steeringSystem.tick(
+        (SteeringSystemTick_s)
+        {
+            .tick = sys_tick,
+            .secondaryConversion = (AnalogConversion_s)
+            {
+                .raw = 0,
+                .conversion = angle,
+                .status = AnalogSensorStatus_e::ANALOG_SENSOR_CLAMPED
+            }
+        }
+    );
+    ASSERT_TRUE(steeringSystem.getSteeringSystemData().angle == angle);
+    ASSERT_TRUE(steeringSystem.getSteeringSystemData().status == SteeringSystemStatus_e::STEERING_SYSTEM_MARGINAL);
+}
+
+TEST(SteeringSystemTesting, test_steering_divergence_warning)
+{
+    // Boilerplate definitions for the testing aparatus
+    SysClock sys_clock;
+    SysTick_s sys_tick = sys_clock.tick(0);
+    SteeringEncoderInterface primarySensor;
+    SteeringSystem steeringSystem(&primarySensor);
+    float primaryAngle = 0.0f;
+    float secondaryAngle = primaryAngle + STEERING_DIVERGENCE_WARN_THRESHOLD;
+
+    primarySensor.mockConversion.angle = primaryAngle;
+    primarySensor.mockConversion.status = SteeringEncoderStatus_e::STEERING_ENCODER_NOMINAL;
+    steeringSystem.tick(
+        (SteeringSystemTick_s)
+        {
+            .tick = sys_tick,
+            .secondaryConversion = (AnalogConversion_s)
+            {
+                .raw = 0,
+                .conversion = secondaryAngle,
+                .status = AnalogSensorStatus_e::ANALOG_SENSOR_GOOD
+            }
+        }
+    );
+    ASSERT_TRUE(steeringSystem.getSteeringSystemData().angle == primaryAngle);
+    ASSERT_TRUE(steeringSystem.getSteeringSystemData().status == SteeringSystemStatus_e::STEERING_SYSTEM_MARGINAL);
+}
+
+TEST(SteeringSystemTesting, test_steering_divergence_error)
+{
+    // Boilerplate definitions for the testing aparatus
+    SysClock sys_clock;
+    SysTick_s sys_tick = sys_clock.tick(0);
+    SteeringEncoderInterface primarySensor;
+    SteeringSystem steeringSystem(&primarySensor);
+    float primaryAngle = 0.0f;
+    float secondaryAngle = primaryAngle + STEERING_DIVERGENCE_ERROR_THRESHOLD;
+
+    primarySensor.mockConversion.angle = primaryAngle;
+    primarySensor.mockConversion.status = SteeringEncoderStatus_e::STEERING_ENCODER_NOMINAL;
+    steeringSystem.tick(
+        (SteeringSystemTick_s)
+        {
+            .tick = sys_tick,
+            .secondaryConversion = (AnalogConversion_s)
+            {
+                .raw = 0,
+                .conversion = secondaryAngle,
+                .status = AnalogSensorStatus_e::ANALOG_SENSOR_GOOD
+            }
+        }
+    );
+    ASSERT_TRUE(steeringSystem.getSteeringSystemData().angle == 0.0f);
+    ASSERT_TRUE(steeringSystem.getSteeringSystemData().status == SteeringSystemStatus_e::STEERING_SYSTEM_ERROR);
+}
+
+TEST(SteeringSystemTesting, test_steering_primary_is_missing)
+{
+    // Boilerplate definitions for the testing aparatus
+    SysClock sys_clock;
+    SysTick_s sys_tick = sys_clock.tick(0);
+    SteeringEncoderInterface primarySensor;
+    SteeringSystem steeringSystem(&primarySensor);
+    float angle = 100.0f;
+
+    primarySensor.mockConversion.angle = 0.0f;
+    primarySensor.mockConversion.status = SteeringEncoderStatus_e::STEERING_ENCODER_ERROR;
+    steeringSystem.tick(
+        (SteeringSystemTick_s)
+        {
+            .tick = sys_tick,
+            .secondaryConversion = (AnalogConversion_s)
+            {
+                .raw = 0,
+                .conversion = angle,
+                .status = AnalogSensorStatus_e::ANALOG_SENSOR_GOOD
+            }
+        }
+    );
+    ASSERT_TRUE(steeringSystem.getSteeringSystemData().angle == angle);
+    ASSERT_TRUE(steeringSystem.getSteeringSystemData().status == SteeringSystemStatus_e::STEERING_SYSTEM_DEGRADED);
+}
+
+TEST(SteeringSystemTesting, test_steering_primary_is_missing_and_secondary_is_marginal)
+{
+    // Boilerplate definitions for the testing aparatus
+    SysClock sys_clock;
+    SysTick_s sys_tick = sys_clock.tick(0);
+    SteeringEncoderInterface primarySensor;
+    SteeringSystem steeringSystem(&primarySensor);
+    float angle = 100.0f;
+
+    primarySensor.mockConversion.angle = 0.0f;
+    primarySensor.mockConversion.status = SteeringEncoderStatus_e::STEERING_ENCODER_ERROR;
+    steeringSystem.tick(
+        (SteeringSystemTick_s)
+        {
+            .tick = sys_tick,
+            .secondaryConversion = (AnalogConversion_s)
+            {
+                .raw = 0,
+                .conversion = angle,
+                .status = AnalogSensorStatus_e::ANALOG_SENSOR_CLAMPED
+            }
+        }
+    );
+    ASSERT_TRUE(steeringSystem.getSteeringSystemData().angle == 0.0f);
+    ASSERT_TRUE(steeringSystem.getSteeringSystemData().status == SteeringSystemStatus_e::STEERING_SYSTEM_ERROR);
+}
+
+#endif