Implemented Ultrasonic Sensor

lib/Fullness/MockDistance.cpp

@@ -1,7 +1,10 @@
 #include "MockDistance.hpp"
 #include <vector>
 
-MockDistance::MockDistance(std::vector<int32_t> distance) : mDistanceBuffer{distance}, mDistanceBufferIdx{0}
+using namespace Fullness;
+
+MockDistance::MockDistance(std::vector<int32_t> distance)
+    : mDistanceBuffer{distance}, mDistanceBufferIdx{0}
 {
 }
 

lib/Fullness/MockDistance.hpp

@@ -10,23 +10,26 @@
 #include <stdlib.h>
 #include <vector>
 
-class MockDistance final : public Fullness::IDistance
+namespace Fullness
 {
-public:
-    /**
-     * @brief Returns the distance from the mock sensor
-     * @param int32_t Distance in millimeters
-     *
-     */
-    MockDistance(std::vector<int32_t> distance);
+    class MockDistance final : public IDistance
+    {
+    public:
+        /**
+         * @brief Returns the distance from the mock sensor
+         * @param int32_t Distance in millimeters
+         *
+         */
+        MockDistance(std::vector<int32_t> distance);
 
-    /**
-     * @brief returns distance
-     * @return int32_t mDistanceBuffer
-     */
-    int32_t getDistance() override;
+        /**
+         * @brief returns distance
+         * @return int32_t mDistanceBuffer
+         */
+        int32_t getDistance() override;
 
-private:
-    std::vector<int32_t> mDistanceBuffer;
-    size_t mDistanceBufferIdx;
-};
+    private:
+        std::vector<int32_t> mDistanceBuffer;
+        size_t mDistanceBufferIdx;
+    };
+}

lib/Fullness/UltrasonicDistance.cpp

@@ -0,0 +1,33 @@
+#include "UltrasonicDistance.hpp"
+#include <Arduino.h>
+
+using namespace Fullness;
+
+UltrasonicDistance::UltrasonicDistance(int32_t trig, int32_t echo, size_t distanceIdx)
+    : trigPin{trig}, echoPin{echo}, mDistanceBufferIdx{distanceIdx}
+{
+}
+
+int32_t UltrasonicDistance::startDistance()
+{
+    for (int i = 0; i < 8; i++)
+    {
+        digitalWrite(trigPin, LOW);
+        vTaskDelay(1000 / portTICK_PERIOD_MS); // Delay for 1000 milliseconds
+        digitalWrite(trigPin, HIGH);
+        vTaskDelay(1000 / portTICK_PERIOD_MS); // Delay for 1000 milliseconds
+        digitalWrite(trigPin, LOW);
+
+        long duration = pulseIn(echoPin, HIGH);
+        int32_t intDuration = duration * .034 / 2;
+
+        distances[i] = intDuration;
+    }
+}
+
+int32_t UltrasonicDistance::getDistance()
+{
+    int32_t distance = distances[mDistanceBufferIdx];
+    mDistanceBufferIdx = (mDistanceBufferIdx + 1) % distances.size();
+    return distance;
+}

lib/Fullness/UltrasonicDistance.hpp

@@ -0,0 +1,44 @@
+/**
+ * @file MockDistance.hpp
+ * @brief Mock distance class that inherits from IDistance interface class. Used for unit testing.
+ * @version 0.1
+ * @date 2022-05-11
+ */
+
+#include "IDistance.hpp"
+#include <array>
+#include <cstdint>
+#include <stdlib.h>
+#include <vector>
+
+namespace Fullness
+{
+    class UltrasonicDistance final : public IDistance
+    {
+    public:
+        /**
+         * @brief Returns the distance from the mock sensor
+         * @param int32_t Distance in millimeters
+         *
+         */
+        UltrasonicDistance(int32_t trig, int32_t echo, size_t distanceIdx);
+
+        /**
+         * @brief returns distance
+         * @return int32_t mDistanceBuffer
+         */
+        int32_t getDistance() override;
+
+        /**
+         * @brief returns distance
+         * @return int32_t mDistanceBuffer
+         */
+        int32_t startDistance();
+
+    private:
+        int32_t trigPin;
+        int32_t echoPin;
+        size_t mDistanceBufferIdx;
+        std::array<int32_t, 8> distances{};
+    };
+}

src/fullnessTask.cpp

@@ -1,13 +1,19 @@
 #include "fullnessTask.hpp"
 #include "FullnessMetric.hpp"
+#include "MockDistance.hpp"
+#include "UltrasonicDistance.hpp"
 #include <Arduino.h>
+#include <vector>
 
 using namespace Zotbins;
 
 static const char *name = "fullnessTask";
 static const int priority = 1;
 static const uint32_t stackSize = 4096;
 
+const int trigPin = 5;
+const int echoPin = 18;
+
 FullnessTask::FullnessTask(QueueHandle_t &messageQueue)
     : Task(name, priority, stackSize), mMessageQueue(messageQueue)
 {
@@ -27,13 +33,22 @@ void FullnessTask::taskFunction(void *task)
 
 void FullnessTask::setup()
 {
+    Serial.begin(115200);
+    pinMode(trigPin, OUTPUT);
+    pinMode(echoPin, INPUT);
 }
 
 void FullnessTask::loop()
 {
     while (1)
     {
-        vTaskDelay(1000 / portTICK_PERIOD_MS); // Delay for 1000 milliseconds
-        log_i("Hello from Fullness Task");
+        log_i("made it 1");
+        Fullness::UltrasonicDistance ultrasonicSensor(trigPin, echoPin, 0);
+        log_i("made it 2");
+        ultrasonicSensor.startDistance();
+        log_i("made it 3");
+        Fullness::FullnessMetric fullness(1000, ultrasonicSensor);
+        log_i("made it 4");
+        log_i("Fullness: %f", fullness.getFullness());
     }
 }

test/test_desktop_fullness/testFullness.cpp

@@ -1,17 +1,61 @@
 #include "FullnessMetric.hpp"
+#include "MockDistance.hpp"
 #include <unity.h>
+#include <vector>
 
-// TODO: Add more tests
+// to-do: add more unit tests
 
-void test_always_pass()
+void test_mock_distance_sensor_returns_correct_distances()
 {
-    TEST_ASSERT_TRUE(true);
+    std::vector<int32_t> distances = {7, 8, 3, 210, 1};
+    Fullness::MockDistance mockDistanceSensor(distances);
+    for (int i = 0; i < distances.size(); i++)
+    {
+        TEST_ASSERT_EQUAL_INT(mockDistanceSensor.getDistance(), distances[i]);
+    }
+}
+
+void test_mock_distance_sensor_returns_correct_distances_and_loops()
+{
+    std::vector<int32_t> distances = {7, 8, 3, 210, 1};
+    Fullness::MockDistance mockDistanceSensor(distances);
+    int tempCounter = 0;
+    for (int i = 0; i < distances.size() * 2; i++)
+    {
+        TEST_ASSERT_EQUAL_INT(mockDistanceSensor.getDistance(), distances[i]);
+        if (i == distances.size() - 1)
+        {
+            tempCounter = 0;
+        }
+        else
+        {
+            tempCounter++;
+        }
+    }
+}
+
+void test_returns_correct_fullness()
+{
+    const uint32_t binHeight = 10;
+    const float calculatedAverageDistance = 5.5;
+    std::vector<int32_t> distances = {7, 8, 3, 2, 10, 4, 20, 0};
+    Fullness::MockDistance mockDistanceSensor(distances);
+
+    Fullness::FullnessMetric mockFullness(binHeight, mockDistanceSensor);
+    TEST_ASSERT_EQUAL_FLOAT(calculatedAverageDistance, (mockFullness.getFullness()));
+
+    for (int i = 0; i < distances.size(); i++)
+    {
+        TEST_ASSERT_TRUE(mockFullness.isValidDistance(distances[i]));
+    }
 }
 
 int main(int argc, char **argv)
 {
     UNITY_BEGIN();
-    RUN_TEST(test_always_pass);
+    RUN_TEST(test_mock_distance_sensor_returns_correct_distances);
+    RUN_TEST(test_mock_distance_sensor_returns_correct_distances_and_loops);
+    RUN_TEST(test_returns_correct_fullness);
     UNITY_END();
     return 0;
 }