digital_input.h

Go to the documentation of this file.

#ifndef _digital_input_H_
#define _digital_input_H_
 
#include "sensor.h"
 
#include <elapsedMillis.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 SensorT<bool> {
 public:
  DigitalInputState(uint8_t pin, int pin_mode, int read_delay = 1000,
                    String config_path = "")
      : DigitalInput{pin, pin_mode},
        SensorT<bool>(config_path),
        read_delay_{read_delay},
        triggered_{false} {
    load_configuration();
  }
 
  virtual void start() override final {
    ReactESP::app->onRepeat(read_delay_, [this]() { emit(digitalRead(pin_)); });
  }
 
 private:
  int read_delay_;
  bool triggered_;
  virtual void get_configuration(JsonObject& doc) override;
  virtual bool set_configuration(const JsonObject& config) override;
  virtual String get_config_schema() override;
};
 
class DigitalInputCounter : public DigitalInput, public SensorT<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_++; }) {}
 
  void start() override final {
    ReactESP::app->onInterrupt(pin_, interrupt_type_, interrupt_handler_);
 
    ReactESP::app->onRepeat(read_delay_, [this]() {
      noInterrupts();
      output = counter_;
      counter_ = 0;
      interrupts();
      notify();
    });
  }
 
 protected:
  DigitalInputCounter(uint8_t pin, int pin_mode, int interrupt_type,
                      unsigned int read_delay, String config_path,
                      std::function<void()> interrupt_handler)
      : DigitalInput{pin, pin_mode},
        SensorT<int>(config_path),
        interrupt_type_{interrupt_type},
        interrupt_handler_{interrupt_handler},
        read_delay_{read_delay} {
    load_configuration();
  }
 
  unsigned int read_delay_;
  volatile unsigned int counter_ = 0;
 
 private:
  int interrupt_type_;
  std::function<void()> interrupt_handler_;
  virtual void get_configuration(JsonObject& doc) override;
  virtual bool set_configuration(const JsonObject& config) override;
  virtual String get_config_schema() override;
};
 
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(); }),
        ignore_interval_ms_{ignore_interval_ms} {}
 
 private:
  void handleInterrupt();
 
  unsigned int ignore_interval_ms_;
  elapsedMillis since_last_event_;
  virtual void get_configuration(JsonObject& doc) override;
  virtual bool set_configuration(const JsonObject& config) override;
  virtual String get_config_schema() override;
};
 
class DigitalInputChange : public DigitalInput, public SensorT<bool> {
 public:
  DigitalInputChange(uint8_t pin, int pin_mode, int interrupt_type,
                     String config_path = "")
      : DigitalInput{pin, pin_mode},
        SensorT<bool>(config_path),
        interrupt_type_{interrupt_type},
        triggered_{true} {
    load_configuration();
    output = (bool)digitalRead(pin_);
    last_output_ = !output;  // ensure that we always send the first output
  }
  virtual void start() override final;
 
 private:
  int interrupt_type_;
  bool triggered_;
  bool last_output_;
  virtual void get_configuration(JsonObject& doc) override {}
  virtual bool set_configuration(const JsonObject& config) override {
    return false;
  }
};
 
}  // namespace sensesp
 
#endif