first

lib/TickerScheduler/README.md

@@ -0,0 +1,81 @@
+# 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
+* ...

lib/TickerScheduler/TickerScheduler.cpp

@@ -0,0 +1,116 @@
+#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();
+    }
+}

lib/TickerScheduler/TickerScheduler.h

@@ -0,0 +1,91 @@
+#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

lib/TickerScheduler/example/blink/blink/blink.ino

@@ -0,0 +1,29 @@
+#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();
+}