sensor.h

Go to the documentation of this file.

#ifndef _sensor_H_
#define _sensor_H_
 
#include <set>
 
#include "sensesp/system/configurable.h"
#include "sensesp/system/observable.h"
#include "sensesp/system/startable.h"
#include "sensesp/system/valueproducer.h"
 
namespace sensesp {
 
class Sensor : virtual public Observable,
               public Configurable,
               public Startable {
 public:
  Sensor(String config_path = "");
 
  static const std::set<Sensor*>& get_sensors() { return sensors_; }
 
 private:
  static std::set<Sensor*> sensors_;
};
 
template <typename T>
class SensorT : public Sensor, public ValueProducer<T> {
 public:
  SensorT<T>(String config_path = "")
      : Sensor(config_path), ValueProducer<T>() {}
};
 
typedef SensorT<float> FloatSensor;
typedef SensorT<int> IntSensor;
typedef SensorT<bool> BoolSensor;
typedef SensorT<String> StringSensor;
 
template <class T>
class RepeatSensor : public SensorT<T> {
 public:
  RepeatSensor<T>(unsigned int repeat_interval_ms, std::function<T()> callback)
      : SensorT<T>(""),
        repeat_interval_ms_(repeat_interval_ms),
        returning_callback_(callback) {}
 
  RepeatSensor<T>(unsigned int repeat_interval_ms,
                  std::function<void(RepeatSensor<T>*)> callback)
      : SensorT<T>(""),
        repeat_interval_ms_(repeat_interval_ms),
        emitting_callback_(callback) {}
 
  void start() override final {
    if (emitting_callback_ != nullptr) {
      ReactESP::app->onRepeat(repeat_interval_ms_,
                              [this]() { emitting_callback_(this); });
    } else {
      ReactESP::app->onRepeat(repeat_interval_ms_,
                              [this]() { this->emit(this->returning_callback_()); });
    }
  }
 
 protected:
  unsigned int repeat_interval_ms_;
  std::function<T()> returning_callback_ = nullptr;
  std::function<void(RepeatSensor<T>*)> emitting_callback_ = nullptr;
};
 
}  // namespace sensesp
 
#endif