digital_input.h

Go to the documentation of this file.

#ifndef SENSESP_SENSORS_DIGITAL_INPUT_H_
#define SENSESP_SENSORS_DIGITAL_INPUT_H_
 
#include <elapsedMillis.h>
 
#include "ReactESP.h"
#include "sensesp/ui/config_item.h"
#include "sensesp_base_app.h"
#include "sensor.h"
 
namespace sensesp {
 
class DigitalInput {
 public:
  DigitalInput(uint8_t pin, int pin_mode) : pin_{pin} {
    pinMode(pin_, pin_mode);
  };
 
 protected:
  uint8_t pin_;
};
 
class DigitalInputState : public DigitalInput, public Sensor<bool> {
 public:
  DigitalInputState(uint8_t pin, int pin_mode, int read_delay = 1000,
                    String config_path = "")
      : DigitalInput{pin, pin_mode},
        Sensor<bool>(config_path),
        read_delay_{read_delay} {
    load();
 
    repeat_event_ = event_loop()->onRepeat(read_delay_,
                           [this]() { this->emit(digitalRead(pin_)); });
  }
 
  virtual ~DigitalInputState() {
    if (repeat_event_ != nullptr) {
      repeat_event_->remove(event_loop());
    }
  }
 
 private:
  int read_delay_;
  reactesp::RepeatEvent* repeat_event_ = nullptr;
  virtual bool to_json(JsonObject& root) override;
  virtual bool from_json(const JsonObject& config) override;
};
 
const String ConfigSchema(const DigitalInputState& obj);
 
bool ConfigRequiresRestart(const DigitalInputState& obj);
 
class DigitalInputCounter : public DigitalInput, public Sensor<int> {
 public:
  DigitalInputCounter(uint8_t pin, int pin_mode, int interrupt_type,
                      unsigned int read_delay, String config_path = "")
      : DigitalInputCounter(pin, pin_mode, interrupt_type, read_delay,
                            config_path, [this]() { this->counter_ = this->counter_ + 1; }) {
    register_events();
  }
 
  virtual ~DigitalInputCounter() {
    if (repeat_event_ != nullptr) {
      repeat_event_->remove(event_loop());
    }
    if (isr_event_ != nullptr) {
      isr_event_->remove(event_loop().get());
    }
  }
 
  virtual bool to_json(JsonObject& root) override;
  virtual bool from_json(const JsonObject& config) override;
 
 protected:
  // load() calls the virtual from_json(). Inside a base-class constructor the
  // dynamic type is still the base, so loading there dispatches to the base
  // from_json() and silently drops fields a derived class adds. A derived class
  // with extra config therefore constructs with kNo and calls load() from its
  // own constructor body, where the full dynamic type is established.
  enum class LoadConfig { kNo, kYes };
 
  DigitalInputCounter(uint8_t pin, int pin_mode, int interrupt_type,
                      unsigned int read_delay, String config_path,
                      std::function<void()> interrupt_handler)
      : DigitalInputCounter(pin, pin_mode, interrupt_type, read_delay,
                            config_path, interrupt_handler, LoadConfig::kYes) {}
 
  DigitalInputCounter(uint8_t pin, int pin_mode, int interrupt_type,
                      unsigned int read_delay, String config_path,
                      std::function<void()> interrupt_handler,
                      LoadConfig load_config)
      : DigitalInput{pin, pin_mode},
        Sensor<int>(config_path),
        read_delay_{read_delay},
        interrupt_type_{interrupt_type},
        interrupt_handler_{interrupt_handler} {
    if (load_config == LoadConfig::kYes) {
      load();
    }
  }
 
  // Call after member init and after load(): registration captures read_delay_,
  // which load() may overwrite from persisted config.
  void register_events() {
    isr_event_ = event_loop()->onInterrupt(pin_, interrupt_type_, interrupt_handler_);
    repeat_event_ = event_loop()->onRepeat(read_delay_, [this]() {
      noInterrupts();
      output_ = counter_;
      counter_ = 0;
      interrupts();
      notify();
    });
  }
 
  unsigned int read_delay_;
  volatile unsigned int counter_ = 0;
  reactesp::RepeatEvent* repeat_event_ = nullptr;
  reactesp::ISREvent* isr_event_ = nullptr;
 
 private:
  int interrupt_type_;
  std::function<void()> interrupt_handler_;
};
 
const String ConfigSchema(const DigitalInputCounter& obj);
 
bool ConfigRequiresRestart(const DigitalInputCounter& obj);
 
class DigitalInputDebounceCounter : public DigitalInputCounter {
 public:
  DigitalInputDebounceCounter(uint8_t pin, int pin_mode, int interrupt_type,
                              unsigned int read_delay,
                              unsigned int ignore_interval_ms,
                              String config_path = "")
      : DigitalInputCounter(pin, pin_mode, interrupt_type, read_delay,
                            config_path, [this]() { this->handleInterrupt(); },
                            LoadConfig::kNo),
        ignore_interval_ms_{ignore_interval_ms} {
    // Load here, not in the base ctor (LoadConfig::kNo above): only now is the
    // dynamic type complete, so from_json() dispatches to this class's override
    // and ignore_interval is restored. ignore_interval_ms_ is already set, so a
    // persisted value overrides the constructor default.
    load();
    register_events();
  }
 
 private:
  void handleInterrupt();
 
  unsigned int ignore_interval_ms_;
  elapsedMillis since_last_event_;
  virtual bool to_json(JsonObject& root) override;
  virtual bool from_json(const JsonObject& config) override;
};
 
const String ConfigSchema(const DigitalInputDebounceCounter& obj);
 
bool ConfigRequiresRestart(const DigitalInputDebounceCounter& obj);
 
class DigitalInputChange : public DigitalInput, public Sensor<bool> {
 public:
  DigitalInputChange(uint8_t pin, int pin_mode, int interrupt_type,
                     String config_path = "")
      : DigitalInput{pin, pin_mode},
        Sensor<bool>(config_path),
        interrupt_type_{interrupt_type},
        triggered_{true} {
    load();
    output_ = (bool)digitalRead(pin_);
    last_output_ = !output_;  // ensure that we always send the first output_
 
    isr_event_ = event_loop()->onInterrupt(pin_, interrupt_type_, [this]() {
      output_ = (bool)digitalRead(pin_);
      triggered_ = true;
    });
 
    tick_event_ = event_loop()->onTick([this]() {
      noInterrupts();
      bool t = triggered_;
      bool val = output_;
      if (t && (val != last_output_)) {
        triggered_ = false;
        last_output_ = val;
        interrupts();
        notify();
      } else {
        interrupts();
      }
    });
  }
 
  virtual ~DigitalInputChange() {
    if (tick_event_ != nullptr) {
      tick_event_->remove(event_loop());
    }
    if (isr_event_ != nullptr) {
      isr_event_->remove(event_loop().get());
    }
  }
 
 private:
  int interrupt_type_;
  bool triggered_;
  bool last_output_;
  reactesp::TickEvent* tick_event_ = nullptr;
  reactesp::ISREvent* isr_event_ = nullptr;
  virtual bool to_json(JsonObject& doc) override { return true; }
  virtual bool from_json(const JsonObject& config) override { return true; }
};
 
}  // namespace sensesp
 
#endif