-
-
Notifications
You must be signed in to change notification settings - Fork 230
/
Copy pathscheduler.h
168 lines (144 loc) · 6.2 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
//-----------------------------------------------------------------------------
// 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;
resetTicker();
}
virtual void loop(void) {
mMillis = millis();
mDiff = mMillis - mPrevMillis;
if (mDiff < 1000)
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();
}
void once(scdCb c, uint32_t timeout, const char *name) { addTicker(c, timeout, 0, false, name); }
void onceAt(scdCb c, uint32_t timestamp, const char *name) { addTicker(c, timestamp, 0, true, name); }
uint8_t every(scdCb c, uint32_t interval, const char *name){ return addTicker(c, interval, interval, false, name); }
void everySec(scdCb c, const char *name) { every(c, SCD_SEC, name); }
void everyMin(scdCb c, const char *name) { every(c, SCD_MIN, name); }
void everyHour(scdCb c, const char *name) { every(c, SCD_HOUR, name); }
void every12h(scdCb c, const char *name) { every(c, SCD_12H, name); }
void everyDay(scdCb c, const char *name) { every(c, SCD_DAY, name); }
virtual void setTimestamp(uint32_t ts) {
mTimestamp = ts;
}
bool resetEveryById(uint8_t id) {
if (mTickerInUse[id] == false)
return false;
mTicker[id].timeout = mTicker[id].reload;
return true;
}
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;
memset(mTicker[i].name, 0, 6);
strncpy(mTicker[i].name, name, (strlen(name) < 6) ? strlen(name) : 5);
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;
};
}
#endif /*__SCHEDULER_H__*/