Ticker with Delegate

libraries/Ticker/examples/TickerFunctional/TickerFunctional.ino

@@ -12,7 +12,9 @@ class ExampleClass {
   public:
     ExampleClass(int pin, int duration) : _pin(pin), _duration(duration) {
       pinMode(_pin, OUTPUT);
-      _myTicker.attach_ms(_duration, std::bind(&ExampleClass::classBlink, this));
+      _myTicker.attach_ms(_duration, [this]() {
+        classBlink();
+      });
     }
     ~ExampleClass() {};
 
@@ -52,7 +54,7 @@ void setup() {
   scheduledTicker.attach_ms_scheduled(100, scheduledBlink);
 
   pinMode(LED4, OUTPUT);
-  parameterTicker.attach_ms(100, std::bind(parameterBlink, LED4));
+  parameterTicker.attach_ms(100, parameterBlink, LED4);
 
   pinMode(LED5, OUTPUT);
   lambdaTicker.attach_ms(100, []() {

libraries/Ticker/src/Ticker.cpp

@@ -33,7 +33,7 @@ Ticker::~Ticker()
     detach();
 }
 
-void Ticker::_attach_ms(uint32_t milliseconds, bool repeat, callback_with_arg_t callback, void* arg)
+void Ticker::_attach_ms(uint32_t milliseconds, bool repeat, callback_with_arg_t* callback, void* arg)
 {
     if (_timer)
     {
@@ -43,7 +43,6 @@ void Ticker::_attach_ms(uint32_t milliseconds, bool repeat, callback_with_arg_t
     {
         _timer = &_etsTimer;
     }
-
     os_timer_setfn(_timer, callback, arg);
     os_timer_arm(_timer, milliseconds, repeat);
 }
@@ -55,17 +54,10 @@ void Ticker::detach()
 
     os_timer_disarm(_timer);
     _timer = nullptr;
-    _callback_function = nullptr;
+    _callback = nullptr;
 }
 
 bool Ticker::active() const
 {
     return _timer;
 }
-
-void Ticker::_static_callback(void* arg)
-{
-    Ticker* _this = reinterpret_cast<Ticker*>(arg);
-    if (_this && _this->_callback_function)
-        _this->_callback_function();
-}

libraries/Ticker/src/Ticker.h

@@ -22,7 +22,7 @@
 #ifndef TICKER_H
 #define TICKER_H
 
-#include <functional>
+#include <Delegate.h>
 #include <Schedule.h>
 #include <ets_sys.h>
 
@@ -32,42 +32,42 @@ class Ticker
     Ticker();
     ~Ticker();
 
-    typedef void (*callback_with_arg_t)(void*);
-    typedef std::function<void(void)> callback_function_t;
+    using callback_t = Delegate<void(), void*>;
+    using callback_with_arg_t = void(void*);
 
     // callback will be called at following loop() after ticker fires
-    void attach_scheduled(float seconds, callback_function_t callback)
+    void attach_scheduled(float seconds, callback_t callback)
     {
-        _callback_function = [callback]() { schedule_function(callback); };
-        _attach_ms(1000UL * seconds, true);
+        _callback = [callback]() { schedule_function(callback); };
+        _attach_ms(1000UL * seconds, true, _callback, _callback.arg());
     }
 
     // callback will be called in SYS ctx when ticker fires
-    void attach(float seconds, callback_function_t callback)
+    void attach(float seconds, callback_t callback)
     {
-        _callback_function = std::move(callback);
-        _attach_ms(1000UL * seconds, true);
+        _callback = std::move(callback);
+        _attach_ms(1000UL * seconds, true, _callback, _callback.arg());
     }
 
     // callback will be called at following loop() after ticker fires
-    void attach_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
+    void attach_ms_scheduled(uint32_t milliseconds, callback_t callback)
     {
-        _callback_function = [callback]() { schedule_function(callback); };
-        _attach_ms(milliseconds, true);
+        _callback = [callback]() { schedule_function(callback); };
+        _attach_ms(milliseconds, true, _callback, _callback.arg());
     }
 
     // callback will be called at following yield() after ticker fires
-    void attach_ms_scheduled_accurate(uint32_t milliseconds, callback_function_t callback)
+    void attach_ms_scheduled_accurate(uint32_t milliseconds, callback_t callback)
     {
-        _callback_function = [callback]() { schedule_recurrent_function_us([callback]() { callback(); return false; }, 0); };
-        _attach_ms(milliseconds, true);
+        _callback = [callback]() { schedule_recurrent_function_us([callback]() { callback(); return false; }, 0); };
+        _attach_ms(milliseconds, true, _callback, _callback.arg());
     }
 
     // callback will be called in SYS ctx when ticker fires
-    void attach_ms(uint32_t milliseconds, callback_function_t callback)
+    void attach_ms(uint32_t milliseconds, callback_t callback)
     {
-        _callback_function = std::move(callback);
-        _attach_ms(milliseconds, true);
+        _callback = std::move(callback);
+        _attach_ms(milliseconds, true, _callback, _callback.arg());
     }
 
     // callback will be called in SYS ctx when ticker fires
@@ -77,7 +77,7 @@ class Ticker
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-function-type"
         static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
-        _attach_ms(1000UL * seconds, true, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));
+        _attach_ms(1000UL * seconds, true, reinterpret_cast<callback_with_arg_t*>(callback), reinterpret_cast<void*>(arg));
 #pragma GCC diagnostic pop
     }
 
@@ -88,67 +88,62 @@ class Ticker
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Wcast-function-type"
         static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
-        _attach_ms(milliseconds, true, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));
+        _attach_ms(milliseconds, true, reinterpret_cast<callback_with_arg_t*>(callback), reinterpret_cast<void*>(arg));
 #pragma GCC diagnostic pop
     }
 
     // callback will be called at following loop() after ticker fires
-    void once_scheduled(float seconds, callback_function_t callback)
+    void once_scheduled(float seconds, callback_t callback)
     {
-        _callback_function = [callback]() { schedule_function(callback); };
-        _attach_ms(1000UL * seconds, false);
+        _callback = [callback]() { schedule_function(callback); };
+        _attach_ms(1000UL * seconds, false, _callback, _callback.arg());
     }
 
     // callback will be called in SYS ctx when ticker fires
-    void once(float seconds, callback_function_t callback)
+    void once(float seconds, callback_t callback)
     {
-        _callback_function = std::move(callback);
-        _attach_ms(1000UL * seconds, false);
+        _callback = std::move(callback);
+        _attach_ms(1000UL * seconds, false, _callback, _callback.arg());
     }
 
     // callback will be called at following loop() after ticker fires
-    void once_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
+    void once_ms_scheduled(uint32_t milliseconds, callback_t callback)
     {
-        _callback_function = [callback]() { schedule_function(callback); };
-        _attach_ms(milliseconds, false);
+        _callback = [callback]() { schedule_function(callback); };
+        _attach_ms(milliseconds, false, _callback, _callback.arg());
     }
 
     // callback will be called in SYS ctx when ticker fires
-    void once_ms(uint32_t milliseconds, callback_function_t callback)
+    void once_ms(uint32_t milliseconds, callback_t callback)
     {
-        _callback_function = std::move(callback);
-        _attach_ms(milliseconds, false);
+        _callback = std::move(callback);
+        _attach_ms(milliseconds, false, _callback, _callback.arg());
     }
 
     // callback will be called in SYS ctx when ticker fires
     template<typename TArg>
     void once(float seconds, void (*callback)(TArg), TArg arg)
     {
         static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
-        _attach_ms(1000UL * seconds, false, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));
+        _attach_ms(1000UL * seconds, false, reinterpret_cast<callback_with_arg_t*>(callback), reinterpret_cast<void*>(arg));
     }
 
     // callback will be called in SYS ctx when ticker fires
     template<typename TArg>
     void once_ms(uint32_t milliseconds, void (*callback)(TArg), TArg arg)
     {
         static_assert(sizeof(TArg) <= sizeof(void*), "attach() callback argument size must be <= sizeof(void*)");
-        _attach_ms(milliseconds, false, reinterpret_cast<callback_with_arg_t>(callback), reinterpret_cast<void*>(arg));
+        _attach_ms(milliseconds, false, reinterpret_cast<callback_with_arg_t*>(callback), reinterpret_cast<void*>(arg));
     }
 
     void detach();
     bool active() const;
 
 protected:
-    static void _static_callback(void* arg);
-    void _attach_ms(uint32_t milliseconds, bool repeat, callback_with_arg_t callback, void* arg);
-    void _attach_ms(uint32_t milliseconds, bool repeat)
-    {
-        _attach_ms(milliseconds, repeat, _static_callback, this);
-    }
+    void _attach_ms(uint32_t milliseconds, bool repeat, callback_with_arg_t* callback, void* arg);
 
     ETSTimer* _timer;
-    callback_function_t _callback_function = nullptr;
+    callback_t _callback = nullptr;
 
 private:
     ETSTimer _etsTimer;