Sensor.h

Go to the documentation of this file.

/*******************************************************************************
 * @file Sensor.h
 * @brief Defines a class for managing Sensor data
 ******************************************************************************/
 
#ifndef SENSOR_INCLUDED
#define SENSOR_INCLUDED
 
#include <Arduino.h>
 
/******************************************************************************/
/***                                                                        ***/
/***                 Class Definition: Sensor                               ***/
/***                                                                        ***/
/******************************************************************************/
class Sensor
{
public:
    using sensorVal_t = float; 
 
private:
    // Simulation parameters
    const sensorVal_t MAXVAL;    
    const sensorVal_t MINVAL;    
    const sensorVal_t SIM_DELTA; 
    sensorVal_t _currentDelta;   
 
protected:
    sensorVal_t _value; 

    Sensor(sensorVal_t initialValue, sensorVal_t maxVal, sensorVal_t minVal, sensorVal_t simDelta)
        : MAXVAL{maxVal}, MINVAL{minVal}, SIM_DELTA{abs(simDelta)},
          _currentDelta{SIM_DELTA}, _value{initialValue} {};

    ~Sensor(void) = default;
 
public:
    virtual void begin(void) = 0;

    virtual void read(void) = 0;

    void simulate(void);

    const sensorVal_t value(void) const { return _value; };
};
 
/******************************************************************************/
/***                                                                        ***/
/***               Class Definition: KettleTempSensor                       ***/
/***                                                                        ***/
/******************************************************************************/
class KettleTempSensor : public Sensor
{
    // Instance of the singleton
    static KettleTempSensor *_instance;
 
    // Private Constructor
    KettleTempSensor(void)
        : Sensor{150.0, 160.0, 145.0, 0.9} {};
 
    // Private Destructor
    ~KettleTempSensor(void) = default;
 
public:
    static KettleTempSensor &getInstance(void)
    {
        if (!_instance)
            _instance = new KettleTempSensor();
        return *_instance;
    };

    KettleTempSensor(const KettleTempSensor &) = delete;

    KettleTempSensor &operator=(const KettleTempSensor &) = delete;

    void begin(void) override;

    void read(void) override;
};
 
extern KettleTempSensor *kettleTemp; 
 
/******************************************************************************/
/***                                                                        ***/
/***               Class Definition: ChillerTempSensor                      ***/
/***                                                                        ***/
/******************************************************************************/
class ChillerTempSensor : public Sensor
{
    // Instance of the singleton
    static ChillerTempSensor *_instance;
 
    // Private Constructor
    ChillerTempSensor(void)
        : Sensor{40.0, 45.0, 35.0, 0.5} {};
 
    // Private Destructor
    ~ChillerTempSensor(void) = default;
 
public:
    static ChillerTempSensor &getInstance(void)
    {
        if (!_instance)
            _instance = new ChillerTempSensor();
        return *_instance;
    };

    ChillerTempSensor(const ChillerTempSensor &) = delete;

    ChillerTempSensor &operator=(const ChillerTempSensor &) = delete;

    void begin(void) override;

    void read(void) override;
};
 
extern ChillerTempSensor *chillerTemp; 
 
/******************************************************************************/
/***                                                                        ***/
/***                 Class Definition: KettleVolSensor                      ***/
/***                                                                        ***/
/******************************************************************************/
class KettleVolSensor : public Sensor
{
    // Instance of the singleton
    static KettleVolSensor *_instance;
 
    // Private Constructor
    KettleVolSensor(void)
        : Sensor{8.0, 9.0, 7.0, 0.2} {};
 
    // Private Destructor
    ~KettleVolSensor(void) = default;
 
public:
    static KettleVolSensor &getInstance(void)
    {
        if (!_instance)
            _instance = new KettleVolSensor();
        return *_instance;
    };

    KettleVolSensor(const KettleVolSensor &) = delete;

    KettleVolSensor &operator=(const KettleVolSensor &) = delete;

    void begin(void) override;

    void read(void) override;
};
 
extern KettleVolSensor *kettleVolume; 
 
#endif