events.h

Go to the documentation of this file.

#ifndef REACTESP_SRC_EVENTS_H_
#define REACTESP_SRC_EVENTS_H_
 
#include <Arduino.h>
 
#include <functional>
#include <memory>
#include <set>
 
namespace reactesp {
 
using react_callback = std::function<void()>;
using isr_react_callback = void (*)(void*);

inline uint64_t ICACHE_RAM_ATTR micros64() { return esp_timer_get_time(); }
 
// forward declarations
 
class EventLoop;

struct EventInterface {
  virtual ~EventInterface() = default;
 
  virtual void add(EventLoop* event_loop) = 0;
  virtual void remove(EventLoop* event_loop) = 0;
  virtual void tick(EventLoop* event_loop) = 0;
 
  virtual void add(std::shared_ptr<EventLoop> event_loop) {
    add(event_loop.get());
  }
  virtual void remove(std::shared_ptr<EventLoop> event_loop) {
    remove(event_loop.get());
  }
  virtual void tick(std::shared_ptr<EventLoop> event_loop) {
    tick(event_loop.get());
  }
};

class Event : public EventInterface {
 protected:
  const react_callback callback;
 
 public:
  Event(react_callback callback) : callback(callback) {}
 
  // Disabling copy and move semantics
  Event(const Event&) = delete;
  Event(Event&&) = delete;
  Event& operator=(const Event&) = delete;
  Event& operator=(Event&&) = delete;
};

class TimedEvent : public Event {
 protected:
  const uint64_t interval;
  uint64_t last_trigger_time;
  bool enabled;
 
 public:
  TimedEvent(uint32_t interval, react_callback callback)
      : Event(callback),
        interval((uint64_t)1000 * (uint64_t)interval),
        last_trigger_time(micros64()),
        enabled(true) {}

  TimedEvent(uint64_t interval, react_callback callback)
      : Event(callback),
        interval(interval),
        last_trigger_time(micros64()),
        enabled(true) {}
 
  bool operator<(const TimedEvent& other) const;
  virtual void add(EventLoop* event_loop) override;
  virtual void remove(EventLoop* event_loop) override;
 
  using EventInterface::add;
  using EventInterface::remove;
  using EventInterface::tick;
 
  uint32_t getTriggerTime() const {
    return (last_trigger_time + interval) / 1000;
  }
  uint64_t getTriggerTimeMicros() const {
    return (last_trigger_time + interval);
  }

  bool isEnabled() const { return enabled; }
};

struct TriggerTimeCompare {
  bool operator()(const TimedEvent* a, const TimedEvent* b) const {
    const uint64_t ta = a->getTriggerTimeMicros();
    const uint64_t tb = b->getTriggerTimeMicros();
    if (ta != tb) return ta < tb;
    return std::less<const TimedEvent*>{}(a, b);
  }
};

class DelayEvent : public TimedEvent {
 public:
  DelayEvent(uint32_t delay, react_callback callback);
  DelayEvent(uint64_t delay, react_callback callback);
 
  void tick(EventLoop* event_loop) override;
};

class RepeatEvent : public TimedEvent {
 public:
  RepeatEvent(uint32_t interval, react_callback callback)
      : TimedEvent(interval, callback) {}

  RepeatEvent(uint64_t interval, react_callback callback)
      : TimedEvent(interval, callback) {}
 
  void tick(EventLoop* event_loop) override;
};

class UntimedEvent : public Event {
 public:
  UntimedEvent(react_callback callback) : Event(callback) {}
 
  void add(EventLoop* event_loop) override;
  void remove(EventLoop* event_loop) override;
 
  using EventInterface::add;
  using EventInterface::remove;
  using EventInterface::tick;
};

class StreamEvent : public UntimedEvent {
 private:
  Stream& stream;
 
 public:
  StreamEvent(Stream& stream, react_callback callback)
      : UntimedEvent(callback), stream(stream) {}
 
  void tick(EventLoop* event_loop) override;
};

class TickEvent : public UntimedEvent {
 public:
  TickEvent(react_callback callback) : UntimedEvent(callback) {}
 
  void tick(EventLoop* event_loop) override;
};

class ISREvent : public Event {
 private:
  const uint8_t pin_number;
  const int mode;
#ifdef ESP32
  // set to true once gpio_install_isr_service is called
  static bool isr_service_installed;
  static void isr(void* this_ptr);
#endif
 
 public:
  ISREvent(uint8_t pin_number, int mode, react_callback callback)
      : Event(callback), pin_number(pin_number), mode(mode) {
#ifdef ESP32
    gpio_int_type_t intr_type;
    switch (mode) {
      case RISING:
        intr_type = GPIO_INTR_POSEDGE;
        break;
      case FALLING:
        intr_type = GPIO_INTR_NEGEDGE;
        break;
      case CHANGE:
        intr_type = GPIO_INTR_ANYEDGE;
        break;
      default:
        intr_type = GPIO_INTR_DISABLE;
        break;
    }
    // configure the IO pin
    gpio_set_intr_type((gpio_num_t)pin_number, intr_type);
 
    if (!isr_service_installed) {
      isr_service_installed = true;
      gpio_install_isr_service(ESP_INTR_FLAG_LOWMED);
    }
#endif
  }
 
  void add(EventLoop* event_loop) override;
  void remove(EventLoop* event_loop) override;
  void tick(EventLoop* event_loop) override {}
};
 
}  // namespace reactesp
 
#endif  // REACTESP_SRC_EVENTS_H_