-
-
Notifications
You must be signed in to change notification settings - Fork 230
/
Copy pathscheduler.h
185 lines (160 loc) · 6.88 KB
/
scheduler.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
//-----------------------------------------------------------------------------
// 2024 Ahoy, https://ahoydtu.de
// Creative Commons - http://creativecommons.org/licenses/by-nc-sa/4.0/deed
//-----------------------------------------------------------------------------
#ifndef __SCHEDULER_H__
#define __SCHEDULER_H__
#include <functional>
#include <array>
#include "dbg.h"
namespace ah {
typedef std::function<void()> scdCb;
enum {SCD_SEC = 1, SCD_MIN = 60, SCD_HOUR = 3600, SCD_12H = 43200, SCD_DAY = 86400};
struct sP {
scdCb c;
uint32_t timeout;
uint32_t reload;
bool isTimestamp;
char name[6];
sP() : c(NULL), timeout(0), reload(0), isTimestamp(false), name("\n") {}
sP(scdCb a, uint32_t tmt, uint32_t rl, bool its) : c(a), timeout(tmt), reload(rl), isTimestamp(its), name("\n") {}
};
#define MAX_NUM_TICKER 30
class Scheduler {
public:
void setup(bool directStart) {
mUptime = 0;
mTimestamp = (directStart) ? 1 : 0;
mMax = 0;
mPrevMillis = millis();
mTsMillis = mPrevMillis % 1000;
mFastTicker = false;
resetTicker();
}
virtual void loop(void) {
mMillis = millis();
mDiff = mMillis - mPrevMillis;
if (mDiff < 1000) {
if (mFastTicker) {
mDiffSeconds = 0;
checkTicker();
mFastTicker = false;
}
return;
}
mDiffSeconds = 1;
if (mDiff < 2000)
mPrevMillis += 1000;
else {
if (mMillis < mPrevMillis) { // overflow
mDiff = mMillis;
if (mDiff < 1000)
return;
}
mDiffSeconds = mDiff / 1000;
mPrevMillis += (mDiffSeconds * 1000);
}
mUptime += mDiffSeconds;
if(0 != mTimestamp) {
mTimestamp += mDiffSeconds;
mTsMillis = mPrevMillis % 1000;
}
checkTicker();
}
uint8_t once(scdCb c, uint32_t timeout, const char *name) { return addTicker(c, timeout, 0, false, name); }
uint8_t onceAt(scdCb c, uint32_t timestamp, const char *name) { return addTicker(c, timestamp, 0, true, name); }
uint8_t every(scdCb c, uint32_t interval, const char *name) { return addTicker(c, interval, interval, false, name); }
uint8_t everySec(scdCb c, const char *name) { return every(c, SCD_SEC, name); }
uint8_t everyMin(scdCb c, const char *name) { return every(c, SCD_MIN, name); }
uint8_t everyHour(scdCb c, const char *name) { return every(c, SCD_HOUR, name); }
uint8_t every12h(scdCb c, const char *name) { return every(c, SCD_12H, name); }
uint8_t everyDay(scdCb c, const char *name) { return every(c, SCD_DAY, name); }
virtual void setTimestamp(uint32_t ts) {
mTimestamp = ts;
}
bool resetTickerByName(const char* name) {
for (uint8_t id = 0; id < MAX_NUM_TICKER; id++) {
if (mTickerInUse[id]) {
if(strncmp(name, mTicker[id].name, strlen(name)) == 0) {
mTicker[id].timeout = mTicker[id].reload;
mTickerInUse[id] = false;
return true;
}
}
}
return false;
}
uint32_t getUptime(void) {
return mUptime;
}
inline void resetTicker(void) {
mTickerInUse.fill(false);
}
void getStat(uint8_t *max) {
*max = mMax;
}
void printSchedulers() {
for (uint8_t i = 0; i < MAX_NUM_TICKER; i++) {
if (mTickerInUse[i]) {
DPRINT(DBG_INFO, String(mTicker[i].name));
DBGPRINT(", tmt: ");
DBGPRINT(String(mTicker[i].timeout));
DBGPRINT(", rel: ");
DBGPRINTLN(String(mTicker[i].reload));
}
}
}
protected:
uint32_t mTimestamp;
uint32_t mUptime;
uint16_t mTsMillis;
private:
uint8_t addTicker(scdCb c, uint32_t timeout, uint32_t reload, bool isTimestamp, const char *name) {
for (uint8_t i = 0; i < MAX_NUM_TICKER; i++) {
if (!mTickerInUse[i]) {
mTickerInUse[i] = true;
mTicker[i].c = c;
mTicker[i].timeout = timeout;
mTicker[i].reload = reload;
mTicker[i].isTimestamp = isTimestamp;
strncpy(mTicker[i].name, name, 5);
mTicker[i].name[5]=0;
if (timeout == 0 && reload == false)
mFastTicker = true;
if(mMax == i)
mMax = i + 1;
return i;
}
}
return 0xff;
}
inline void checkTicker(void) {
bool inUse[MAX_NUM_TICKER];
for (uint8_t i = 0; i < MAX_NUM_TICKER; i++)
inUse[i] = mTickerInUse[i];
for (uint8_t i = 0; i < MAX_NUM_TICKER; i++) {
if (inUse[i]) {
if (mTicker[i].timeout <= ((mTicker[i].isTimestamp) ? mTimestamp : mDiffSeconds)) { // expired
if(0 == mTicker[i].reload)
mTickerInUse[i] = false;
else
mTicker[i].timeout = mTicker[i].reload;
//DPRINTLN(DBG_INFO, "checkTick " + String(i) + " reload: " + String(mTicker[i].reload) + ", timeout: " + String(mTicker[i].timeout));
(mTicker[i].c)();
yield();
}
else // not expired
if (!mTicker[i].isTimestamp)
mTicker[i].timeout -= mDiffSeconds;
}
}
}
std::array<sP, MAX_NUM_TICKER> mTicker;
std::array<bool, MAX_NUM_TICKER> mTickerInUse;
uint32_t mMillis = 0, mPrevMillis = 0, mDiff = 0;
uint8_t mDiffSeconds = 0;
uint8_t mMax = 0;
bool mFastTicker;
};
}
#endif /*__SCHEDULER_H__*/