iotmanager/IoTManager
1
0
Fork 0
mirror of https://github.com/IoTManagerProject/IoTManager.git synced 2026-03-26 22:22:16 +03:00
Code Issues Packages Projects Releases Wiki Activity

delete

Browse Source
This commit is contained in:
Dmitry Borisenko
2021-10-05 19:19:14 +08:00
parent 60a292a2f5
commit 74c31e30ea
269 changed files with 0 additions and 20922 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
lib/TickerScheduler/README.md
View File

@@ -1,81 +0,0 @@
# TickerScheduler
Simple scheduler for ESP8266 Arduino based on Ticker
### Initialization
`TickerScheduler(uint size);`
| Param | Description |
| --- | --- |
| size | Amount of task Tickers to initialize |
**Example**:
`TickerScheduler ts(5)`
### Add task
`boolean add(uint i, uint32_t period, tscallback_t f, boolean shouldFireNow = false); `
| Param | Description |
| --- | --- |
| i | Task ID |
| period | Task execution period in ms |
| f | Task callback |
| shouldFireNow| `true` if you want to execute task right after first scheduler update or wait next scheduled start |
**Returns**:
`true` - task added sucessfully
`false` - task was not added
**Example**:
`ts.add(0, 3000, sendData)`
### Execute scheduler in `loop()`
`ts.update()`
### Remove task
`boolean remove(uint i)`
**Returns**:
`true` - task removed sucessfully
`false` - task was not removed
| Param | Description |
| --- | --- |
| i | Task ID |
### Enable/Disable task
`boolean enable(uint i)`
`boolean disable(uint i)`
**Returns**:
`true` - task enabled/disabled sucessfully
`false` - task was not enabled/disabled
| Param | Description |
| --- | --- |
| i | Task ID |
### Enable / disable all tasks
`void enableAll()`
`void disableAll()`
### TODO
* Task callback parameters support
* ...

116
lib/TickerScheduler/TickerScheduler.cpp
View File

@@ -1,116 +0,0 @@
#include "TickerScheduler.h"
TickerScheduler::TickerScheduler(uint8_t size)
{
this->items = new TickerSchedulerItem[size];
this->size = size;
}
TickerScheduler::~TickerScheduler()
{
for (uint8_t i = 0; i < this->size; i++)
{
this->remove(i);
yield();
}
delete[] this->items;
this->items = NULL;
this->size = 0;
}
void TickerScheduler::handleTickerFlag(bool * flag)
{
if (!*flag)
*flag = true;
}
void TickerScheduler::handleTicker(tscallback_t f, void * arg, bool * flag)
{
if (*flag)
{
yield();
*flag = false;
yield();
f(arg);
yield();
}
}
bool TickerScheduler::add(uint8_t i, uint32_t period, tscallback_t f, void* arg, boolean shouldFireNow)
{
if (i >= this->size || this->items[i].is_used)
return false;
this->items[i].cb = f;
this->items[i].cb_arg = arg;
this->items[i].flag = shouldFireNow;
this->items[i].period = period;
this->items[i].is_used = true;
enable(i);
return true;
}
bool TickerScheduler::remove(uint8_t i)
{
if (i >= this->size || !this->items[i].is_used)
return false;
this->items[i].is_used = false;
this->items[i].t.detach();
this->items[i].flag = false;
this->items[i].cb = NULL;
return true;
}
bool TickerScheduler::disable(uint8_t i)
{
if (i >= this->size || !this->items[i].is_used)
return false;
this->items[i].t.detach();
return true;
}
bool TickerScheduler::enable(uint8_t i)
{
if (i >= this->size || !this->items[i].is_used)
return false;
bool * flag = &this->items[i].flag;
this->items[i].t.attach_ms(this->items[i].period, TickerScheduler::handleTickerFlag, flag);
return true;
}
void TickerScheduler::disableAll()
{
for (uint8_t i = 0; i < this->size; i++)
disable(i);
}
void TickerScheduler::enableAll()
{
for (uint8_t i = 0; i < this->size; i++)
enable(i);
}
void TickerScheduler::update()
{
for (uint8_t i = 0; i < this->size; i++)
{
if (this->items[i].is_used)
{
#ifdef ARDUINO_ARCH_AVR
this->items[i].t.Tick();
#endif
handleTicker(this->items[i].cb, this->items[i].cb_arg, &this->items[i].flag);
}
yield();
}
}

91
lib/TickerScheduler/TickerScheduler.h
View File

@@ -1,91 +0,0 @@
#ifndef TICKERSCHEDULER_H
#define TICKERSCHEDULER_H
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#endif
#include <stdint.h>
#ifdef ARDUINO_ARCH_AVR
class Ticker
{
typedef void(*ticker_callback_t)(bool*);
private:
bool is_attached = false;
uint32_t period = 0;
uint32_t last_tick = 0;
ticker_callback_t callback;
bool *callback_argument;
public:
void Tick()
{
if (is_attached && millis() - last_tick >= period)
{
callback(callback_argument);
last_tick = millis();
}
}
void detach()
{
this->is_attached = true;
}
template<typename TArg> void attach_ms(uint32_t milliseconds, void(*callback)(TArg), TArg arg)
{
this->period = milliseconds;
this->callback = callback;
this->callback_argument = arg;
this->is_attached = true;
}
};
#endif
//#ifdef ARDUINO_ARCH_ESP8266
#include <Ticker.h>
#include <functional>
//#endif
void tickerFlagHandle(volatile bool * flag);
#ifdef _GLIBCXX_FUNCTIONAL
typedef std::function<void(void*)> tscallback_t;
#else
typedef void(*tscallback_t)(void*);
#endif
struct TickerSchedulerItem
{
Ticker t;
bool flag = false;
tscallback_t cb;
void * cb_arg;
uint32_t period;
volatile bool is_used = false;
};
class TickerScheduler
{
private:
uint8_t size;
TickerSchedulerItem *items = NULL;
void handleTicker(tscallback_t, void *, bool * flag);
static void handleTickerFlag(bool * flag);
public:
TickerScheduler(uint8_t size);
~TickerScheduler();
bool add(uint8_t i, uint32_t period, tscallback_t, void *, boolean shouldFireNow = false);
bool remove(uint8_t i);
bool enable(uint8_t i);
bool disable(uint8_t i);
void enableAll();
void disableAll();
void update();
};
#endif

29
lib/TickerScheduler/example/blink/blink/blink.ino
View File

@@ -1,29 +0,0 @@
#include <TickerScheduler.h>
#define LED1 4
#define LED2 5
TickerScheduler ts(2);
void blink1() {
digitalWrite(LED1, !digitalRead(LED1));
}
void blink2() {
digitalWrite(LED2, !digitalRead(LED2));
}
void setup() {
pinMode(LED1, OUTPUT);
digitalWrite(LED1, LOW);
pinMode(LED2, OUTPUT);
digitalWrite(LED2, LOW);
ts.add(0, 1000, [&](void *) { blink1(); }, nullptr, true);
ts.add(1, 3000, [&](void *) { blink2(); }, nullptr, true);
}
void loop() {
ts.update();
}