ReactESP 3.2.0
Asynchronous programming for the ESP microcontrollers
Loading...
Searching...
No Matches
event_loop.cpp
Go to the documentation of this file.
1#include "event_loop.h"
2
3#include <freertos/semphr.h>
4
5namespace reactesp {
6
8 xSemaphoreTakeRecursive(timed_queue_mutex_, portMAX_DELAY);
9 const uint64_t now = micros64();
10 TimedEvent* top = nullptr;
11
12 while (true) {
13 if (timed_queue.empty()) {
14 break;
15 }
16 top = timed_queue.top();
17 if (!top->isEnabled()) {
18 timed_queue.pop();
19 delete top;
20 continue;
21 }
22 const uint64_t trigger_t = top->getTriggerTimeMicros();
23 if (now >= trigger_t) {
24 timed_queue.pop();
25 top->tick(this);
27 } else {
28 break;
29 }
30 }
31 xSemaphoreGiveRecursive(timed_queue_mutex_);
32}
33
35 xSemaphoreTakeRecursive(untimed_list_mutex_, portMAX_DELAY);
36 for (UntimedEvent* re : this->untimed_list) {
37 re->tick(this);
39 }
40 xSemaphoreGiveRecursive(untimed_list_mutex_);
41}
42
45 tickTimed();
47}
48
49DelayEvent* EventLoop::onDelay(uint32_t delay, react_callback callback) {
50 auto* dre = new DelayEvent(delay, callback);
51 dre->add(this);
52 return dre;
53}
54
56 auto* dre = new DelayEvent(delay, callback);
57 dre->add(this);
58 return dre;
59}
60
61RepeatEvent* EventLoop::onRepeat(uint32_t interval, react_callback callback) {
62 auto* rre = new RepeatEvent(interval, callback);
63 rre->add(this);
64 return rre;
65}
66
68 react_callback callback) {
69 auto* rre = new RepeatEvent(interval, callback);
70 rre->add(this);
71 return rre;
72}
73
75 auto* sre = new StreamEvent(stream, callback);
76 sre->add(this);
77 return sre;
78}
79
80ISREvent* EventLoop::onInterrupt(uint8_t pin_number, int mode,
81 react_callback callback) {
82 auto* isrre = new ISREvent(pin_number, mode, callback);
83 isrre->add(this);
84 return isrre;
85}
86
88 auto* tre = new TickEvent(callback);
89 tre->add(this);
90 return tre;
91}
92
93void EventLoop::remove(TimedEvent* event) { event->remove(this); }
94
96 xSemaphoreTakeRecursive(this->untimed_list_mutex_, portMAX_DELAY);
97 auto it = std::find(this->untimed_list.begin(), this->untimed_list.end(), event);
98 if (it != this->untimed_list.end()) {
99 this->untimed_list.erase(it);
100 }
101 delete event;
102 xSemaphoreGiveRecursive(this->untimed_list_mutex_);
103}
105 xSemaphoreTakeRecursive(this->isr_event_list_mutex_, portMAX_DELAY);
106 auto it = std::find(this->isr_event_list.begin(), this->isr_event_list.end(), event);
107 if (it != this->isr_event_list.end()) {
108 this->isr_event_list.erase(it);
109 }
110 delete event;
111 xSemaphoreGiveRecursive(this->isr_event_list_mutex_);
112}
113
114void EventLoop::remove(Event* event) { event->remove(this); }
115
116} // namespace reactesp
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
void remove(TimedEvent *event)
DelayEvent * onDelayMicros(uint64_t delay, react_callback callback)
Create a new DelayEvent.
friend class ISREvent
Definition event_loop.h:19
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
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.
SemaphoreHandle_t isr_event_list_mutex_
Definition event_loop.h:147
uint64_t timed_event_counter
Definition event_loop.h:149
friend class RepeatEvent
Definition event_loop.h:17
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
uint64_t getTriggerTimeMicros() const
Definition events.h:117
virtual void tick(EventLoop *event_loop)=0
bool isEnabled() const
Definition events.h:120
Events that are triggered based on something else than time.
Definition events.h:178
std::function< void()> react_callback
Definition events.h:11
uint64_t ICACHE_RAM_ATTR micros64()
Return the current time since the device restart in microseconds.
Definition events.h:21