Improved

Author: sajith

plant-care/main/main.cpp

@@ -1,13 +1,38 @@
 //
 // Created by sajith on 3/25/21.
 //
-#include <iostream>
+#include <thread>
+#include <mutex>
 
-using namespace std;
+#include "caretaker/PlantCaretaker.h"
+#include "sensors/MoistureSensor.h"
+#include "sensors/SunlightSensor.h"
+
+void run()
+{
+    std::mutex sensorMutex;
+    auto sunlightSensor = sensors::SunlightSensor(std::chrono::seconds(2), sensorMutex);
+    auto moistureSensor = sensors::MoistureSensor(std::chrono::seconds(3), sensorMutex);
+
+    caretaker::PlantCareTaker plantCareTaker1;
+    moistureSensor.subscribe(plantCareTaker1);
+    sunlightSensor.subcribe(plantCareTaker1);
+
+    caretaker::PlantCareTaker plantCareTaker2;
+    moistureSensor.subscribe(plantCareTaker2);
+    sunlightSensor.subcribe(plantCareTaker2);
+
+    std::thread sunlightSensorThread(sunlightSensor);
+    std::thread moistureSensorThread(moistureSensor);
+
+    sunlightSensorThread.join();
+    moistureSensorThread.join();
+}
 
 int main()
 {
-    cout << "Hello Plant care\n";
+
+    run();
     return 0;
 
 }

plant-care/sensors/CMakeLists.txt

@@ -1,10 +1,15 @@
 project(sensors)
 
+include_directories(${PROJECT_SOURCE_DIR}/include)
+
 set(SOURCE
         ${PROJECT_SOURCE_DIR}/include/sensors/SunlightSensor.h
         ${PROJECT_SOURCE_DIR}/include/sensors/MoistureSensor.h
         ${PROJECT_SOURCE_DIR}/src/SunlightSensor.cpp
         ${PROJECT_SOURCE_DIR}/src/MoistureSensor.cpp)
 
 
-add_library(${PROJECT_NAME} STATIC ${SOURCE})
+add_library(${PROJECT_NAME} STATIC ${SOURCE})
+
+target_link_libraries(${PROJECT_NAME} caretaker)
+target_include_directories(${PROJECT_NAME} PUBLIC ${PROJECT_SOURCE_DIR}/include)

plant-care/sensors/include/sensors/MoistureSensor.h

@@ -11,7 +11,7 @@
 
 #include "caretaker/PlantCaretaker.h"
 
-namespace sensor
+namespace sensors
 {
     class MoistureSensor
     {
@@ -26,13 +26,13 @@ namespace sensor
     public:
         MoistureSensor(const std::chrono::seconds, std::mutex &mtx);
         void subscribe(caretaker::PlantCareTaker &);
-        operator()();
+        void operator()();
 
     private:
         bool isAirTooDry();
         bool isSoilTooDry();
         int getAirMoisture();
-        int getAirSoilMoisture();
+        int getSoilMoisture();
     };
 }
 

plant-care/sensors/include/sensors/SunlightSensor.h

@@ -5,4 +5,42 @@
 #ifndef SOLID_SUNLIGHTSENSOR_H
 #define SOLID_SUNLIGHTSENSOR_H
 
+#include <chrono>
+#include <mutex>
+#include <optional>
+#include <set>
+
+#include "caretaker/PlantCaretaker.h"
+
+namespace sensors
+{
+    class SunlightSensor
+    {
+        using TimePoint = decltype(std::chrono::system_clock::now());
+
+        const std::chrono::seconds sleepTime;
+        std::mutex &mtx;
+        std::set<caretaker::PlantCareTaker *> caretakers;
+
+        std::optional<TimePoint> sunlightOnFrom;
+        std::optional<TimePoint> sunlightOffFrom;
+
+        const int threshold = 2;
+        bool sensorOn = true;
+
+    public:
+        SunlightSensor(const std::chrono::seconds, std::mutex &);
+        void subcribe(caretaker::PlantCareTaker &);
+        void operator()();
+
+    private:
+
+        void updateState(const bool);
+        bool isTooMuchSunlight(const bool);
+        bool isTooLittleSunlight(const bool);
+        bool isSunlight() const;
+
+    };
+}// namespace sensors
+
 #endif //SOLID_SUNLIGHTSENSOR_H

plant-care/sensors/src/MoistureSensor.cpp

@@ -2,3 +2,69 @@
 // Created by sajith on 3/25/21.
 //
 
+#include <iostream>
+#include <random>
+#include <thread>
+
+
+#include "sensors/MoistureSensor.h"
+
+namespace sensors
+{
+    MoistureSensor::MoistureSensor(const std::chrono::seconds sleeptime, std::mutex &mtx) : sleepTime{sleeptime},
+                                                                                            mtx{mtx} {}
+
+    void MoistureSensor::subscribe(caretaker::PlantCareTaker &c)
+    {
+        careTakers.insert(&c);
+    }
+
+    void MoistureSensor::operator()()
+    {
+        for (;;)
+        {
+            std::unique_lock<std::mutex> lock(mtx);
+            if (isAirTooDry())
+            {
+                for (auto p: careTakers)
+                {
+                    p->sprinkleWater();
+                }
+            }
+
+            if (isSoilTooDry())
+            {
+                for (auto p: careTakers)
+                {
+                    p->pourWater();
+                }
+            }
+
+            lock.unlock();
+            std::this_thread::sleep_for(sleepTime);
+        }
+    }
+
+
+    bool MoistureSensor::isAirTooDry()
+    {
+        return getAirMoisture() < threshold;
+    }
+
+    bool MoistureSensor::isSoilTooDry()
+    {
+        return getSoilMoisture() < threshold;
+    }
+
+    int MoistureSensor::getAirMoisture()
+    {
+        static std::mt19937 generator;
+        return std::uniform_int_distribution<int>(min, max)(generator);
+    }
+
+    int MoistureSensor::getSoilMoisture()
+    {
+        static std::mt19937 generator;
+        return std::uniform_int_distribution<int>(min, max)(generator);
+    }
+}

plant-care/sensors/src/SunlightSensor.cpp

@@ -2,3 +2,97 @@
 // Created by sajith on 3/25/21.
 //
 
+#include <iostream>
+#include <random>
+#include <thread>
+
+#include "sensors/SunlightSensor.h"
+
+namespace sensors
+{
+    SunlightSensor::SunlightSensor(const std::chrono::seconds sleepTime, std::mutex &mtx) : sleepTime{sleepTime},
+                                                                                            mtx{mtx} {}
+
+    void SunlightSensor::subcribe(caretaker::PlantCareTaker &c)
+    {
+        caretakers.insert(&c);
+    }
+
+    void SunlightSensor::operator()()
+    {
+        for (;;)
+        {
+            std::unique_lock<std::mutex> lock(mtx);
+            const auto sunlight = isSunlight();
+            updateState(sunlight);
+
+            std::cout << "Sun shines: " << std::boolalpha << sunlight << "\n";
+
+            if (isTooMuchSunlight(sunlight))
+            {
+                for (auto p : caretakers)
+                    p->closeWindowBlinds();
+                sensorOn = false;
+            }
+            else if (isTooLittleSunlight(sunlight))
+            {
+                for (auto p : caretakers)
+                    p->openWindowBlinds();
+                sensorOn = true;
+            }
+
+            lock.unlock();
+            std::this_thread::sleep_for(sleepTime);
+        }
+    }
+
+    void SunlightSensor::updateState(const bool sunlight)
+    {
+        const auto currentTime = std::chrono::system_clock::now();
+        if (sunlight and sensorOn)
+        {
+            sunlightOnFrom = sunlightOnFrom ? *sunlightOnFrom : currentTime;
+            sunlightOffFrom = std::nullopt;
+        }
+        else if (not sunlight)
+        {
+            sunlightOffFrom = sunlightOffFrom ? *sunlightOffFrom : currentTime;
+            sunlightOnFrom = std::nullopt;
+        }
+    }
+
+    bool SunlightSensor::isTooMuchSunlight(const bool sunlight)
+    {
+        if (sunlight)
+        {
+            const auto timeNow = std::chrono::system_clock::now();
+            std::chrono::duration<double> elapsedSeconds = timeNow - (*sunlightOnFrom);
+            return elapsedSeconds.count() > threshold;
+        }
+        return false;
+    }
+
+    bool SunlightSensor::isTooLittleSunlight(const bool sunlight)
+    {
+        if (not sunlight)
+        {
+            const auto timeNow = std::chrono::system_clock::now();
+            std::chrono::duration<double> elapsedSeconds = timeNow - (*sunlightOffFrom);
+            return elapsedSeconds.count() > threshold;
+        }
+        return false;
+    }
+
+    bool SunlightSensor::isSunlight() const
+    {
+        /* We simulate changes of sunlight by generating random numbers that represent
+         * a probability of change in sunlight: if the sun shines or not.
+         */
+        static bool sunShines = false;
+        static std::mt19937 generator;
+        auto prob = std::uniform_int_distribution<int>(1, 100)(generator);
+        if (prob >= 80)
+            sunShines = !sunShines;
+        return sunShines;
+    }
+}