ReactESP 3.2.0
Asynchronous programming for the ESP microcontrollers
Loading...
Searching...
No Matches
event_loop.h
Go to the documentation of this file.
1#ifndef REACTESP_SRC_EVENT_LOOP_H_
2#define REACTESP_SRC_EVENT_LOOP_H_
3
4#include <queue>
5
6#include "events.h"
7
8namespace reactesp {
9
14class EventLoop {
15 friend class Event;
16 friend class TimedEvent;
17 friend class RepeatEvent;
18 friend class UntimedEvent;
19 friend class ISREvent;
20
21 public:
27 timed_queue_mutex_ = xSemaphoreCreateRecursiveMutex();
28 untimed_list_mutex_ = xSemaphoreCreateRecursiveMutex();
29 isr_event_list_mutex_ = xSemaphoreCreateRecursiveMutex();
30
31 // Initialize the mutexes
32
33 xSemaphoreGiveRecursive(timed_queue_mutex_);
34 xSemaphoreGiveRecursive(untimed_list_mutex_);
35 xSemaphoreGiveRecursive(isr_event_list_mutex_);
36 }
37
38 // Disabling copy constructors
39 EventLoop(const EventLoop&) = delete;
40 EventLoop(EventLoop&&) = delete;
41
42 int getTimedEventQueueSize() { return timed_queue.size(); }
43 int getUntimedEventQueueSize() { return untimed_list.size(); }
44 int getISREventQueueSize() { return isr_event_list.size(); }
49
52 uint64_t getEventCount() {
54 }
55
56 uint64_t getTickCount() { return tick_counter; }
57
58 void tick();
59
67 DelayEvent* onDelay(uint32_t delay, react_callback callback);
75 DelayEvent* onDelayMicros(uint64_t delay, react_callback callback);
83 RepeatEvent* onRepeat(uint32_t interval, react_callback callback);
91 RepeatEvent* onRepeatMicros(uint64_t interval, react_callback callback);
99 StreamEvent* onAvailable(Stream& stream, react_callback callback);
110 ISREvent* onInterrupt(uint8_t pin_number, int mode, react_callback callback);
118
119 void remove(TimedEvent* event);
120 void remove(UntimedEvent* event);
121 void remove(ISREvent* event);
122
128 void remove(Event* event);
129
130 protected:
131 // Timed events are stored in a priority queue, sorted by trigger time. It
132 // pretty much always suffices to just access the top element of the queue.
133 // Element removal is always done by invalidating the element.
134 std::priority_queue<TimedEvent*, std::vector<TimedEvent*>, TriggerTimeCompare>
136 // Untimed events are stored in a vector, which is traversed in order.
137 // Elements are rarely removed from the middle of the list, so a vector is
138 // acceptable.
139 std::vector<UntimedEvent*> untimed_list;
140 // ISR events are stored in a vector. The list is traversed or modified
141 // infrequently.
142 std::vector<ISREvent*> isr_event_list;
143
144 // Semaphores for accessing the above queues and lists
145 SemaphoreHandle_t timed_queue_mutex_;
146 SemaphoreHandle_t untimed_list_mutex_;
147 SemaphoreHandle_t isr_event_list_mutex_;
148
151 uint64_t tick_counter = 0;
152
153 void tickTimed();
154 void tickUntimed();
155};
156
157// Provide compatibility aliases for the old naming scheme
158
167
168} // namespace reactesp
169
170#endif // REACTESP_SRC_EVENT_LOOP_H_
Event that is triggered after a certain time delay.
Definition events.h:130
Events are code to be called when a given condition is fulfilled.
Definition events.h:54
Asynchronous event loop supporting timed (repeating and non-repeating), interrupt and stream events.
Definition event_loop.h:14
void remove(TimedEvent *event)
DelayEvent * onDelayMicros(uint64_t delay, react_callback callback)
Create a new DelayEvent.
EventLoop(EventLoop &&)=delete
EventLoop()
Construct a new EventLoop object.
Definition event_loop.h:25
SemaphoreHandle_t untimed_list_mutex_
Definition event_loop.h:146
StreamEvent * onAvailable(Stream &stream, react_callback callback)
Create a new StreamEvent.
TickEvent * onTick(react_callback callback)
Create a new TickEvent.
DelayEvent * onDelay(uint32_t delay, react_callback callback)
Create a new DelayEvent.
uint64_t untimed_event_counter
Definition event_loop.h:150
std::vector< UntimedEvent * > untimed_list
Definition event_loop.h:139
RepeatEvent * onRepeatMicros(uint64_t interval, react_callback callback)
Create a new RepeatEvent.
std::priority_queue< TimedEvent *, std::vector< TimedEvent * >, TriggerTimeCompare > timed_queue
Definition event_loop.h:135
int getUntimedEventQueueSize()
Definition event_loop.h:43
uint64_t getTickCount()
Definition event_loop.h:56
SemaphoreHandle_t timed_queue_mutex_
Definition event_loop.h:145
ISREvent * onInterrupt(uint8_t pin_number, int mode, react_callback callback)
Create a new ISREvent (interrupt event)
RepeatEvent * onRepeat(uint32_t interval, react_callback callback)
Create a new RepeatEvent.
uint64_t getUntimedEventCount()
Definition event_loop.h:51
SemaphoreHandle_t isr_event_list_mutex_
Definition event_loop.h:147
uint64_t getTimedEventCount()
Definition event_loop.h:50
uint64_t getEventCount()
Definition event_loop.h:52
int getTimedEventQueueSize()
Definition event_loop.h:42
uint64_t timed_event_counter
Definition event_loop.h:149
EventLoop(const EventLoop &)=delete
std::vector< ISREvent * > isr_event_list
Definition event_loop.h:142
Event that is triggered on an input pin change.
Definition events.h:229
Event that is triggered repeatedly.
Definition events.h:153
Event that is triggered when there is input available at the given Arduino Stream.
Definition events.h:194
Event that is triggered unconditionally at each execution loop.
Definition events.h:214
TimedEvents are called based on elapsing of time.
Definition events.h:76
Events that are triggered based on something else than time.
Definition events.h:178
std::function< void()> react_callback
Definition events.h:11