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 "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},
        triggered_{false} {
    load();
 
    event_loop()->onRepeat(read_delay_,
                           [this]() { this->emit(digitalRead(pin_)); });
  }
 
 private:
  int read_delay_;
  bool triggered_;
  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_++; }) {
    event_loop()->onInterrupt(pin_, interrupt_type_, interrupt_handler_);
 
    event_loop()->onRepeat(read_delay_, [this]() {
      noInterrupts();
      output_ = counter_;
      counter_ = 0;
      interrupts();
      notify();
    });
  }
 
  virtual bool to_json(JsonObject& root) override;
  virtual bool from_json(const JsonObject& config) override;
 
 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},
        Sensor<int>(config_path),
        read_delay_{read_delay},
        interrupt_type_{interrupt_type},
        interrupt_handler_{interrupt_handler} {
    load();
  }
 
  unsigned int read_delay_;
  volatile unsigned int counter_ = 0;
 
 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(); }),
        ignore_interval_ms_{ignore_interval_ms} {}
 
 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_
 
    event_loop()->onInterrupt(pin_, interrupt_type_, [this]() {
      output_ = (bool)digitalRead(pin_);
      triggered_ = true;
    });
 
    event_loop()->onTick([this]() {
      if (triggered_ && (output_ != last_output_)) {
        noInterrupts();
        triggered_ = false;
        last_output_ = output_;
        interrupts();
        notify();
      }
    });
  }
 
 private:
  int interrupt_type_;
  bool triggered_;
  bool last_output_;
  virtual bool to_json(JsonObject& doc) override { return true; }
  virtual bool from_json(const JsonObject& config) override { return true; }
};
 
}  // namespace sensesp
 
#endif