Add Functional and Scheduled callback option to Ticker

libraries/Ticker/Ticker.cpp

@@ -21,6 +21,7 @@
 
 #include <stddef.h>
 #include <stdint.h>
+#include "Arduino.h"
 
 extern "C" {
 #include "c_types.h"
@@ -67,4 +68,18 @@ void Ticker::detach()
 	os_timer_disarm(_timer);
 	delete _timer;
 	_timer = 0;
+	_callback_function = nullptr;
+}
+
+void Ticker::_static_callback(void* arg)
+{
+	Ticker* _this = (Ticker*)arg;
+	if (_this == nullptr)
+	{
+		return;
+	}
+	if (_this->_callback_function)
+	{
+		_this->_callback_function();
+	}
 }

libraries/Ticker/Ticker.h

@@ -24,6 +24,8 @@
 
 #include <stdint.h>
 #include <stddef.h>
+#include <functional>
+#include <Schedule.h>
 
 extern "C" {
 	typedef struct _ETSTIMER_ ETSTimer;
@@ -34,17 +36,31 @@ class Ticker
 public:
 	Ticker();
 	~Ticker();
+
 	typedef void (*callback_t)(void);
 	typedef void (*callback_with_arg_t)(void*);
+	typedef std::function<void(void)> callback_function_t;
+
+	void attach_scheduled(float seconds, callback_function_t callback)
+	{
+		attach(seconds,std::bind(schedule_function, callback));
+	}
 
-	void attach(float seconds, callback_t callback)
+	void attach(float seconds, callback_function_t callback)
 	{
-		_attach_ms(seconds * 1000, true, reinterpret_cast<callback_with_arg_t>(callback), 0);
+		_callback_function = callback;
+		attach(seconds, _static_callback, (void*)this);
 	}
 
-	void attach_ms(uint32_t milliseconds, callback_t callback)
+	void attach_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
 	{
-		_attach_ms(milliseconds, true, reinterpret_cast<callback_with_arg_t>(callback), 0);
+		attach_ms(milliseconds, std::bind(schedule_function, callback));
+	}
+
+	void attach_ms(uint32_t milliseconds, callback_function_t callback)
+	{
+		_callback_function = callback;
+		attach_ms(milliseconds, _static_callback, (void*)this);
 	}
 
 	template<typename TArg>
@@ -66,14 +82,26 @@ class Ticker
 		_attach_ms(milliseconds, true, reinterpret_cast<callback_with_arg_t>(callback), arg32);
 	}
 
-	void once(float seconds, callback_t callback)
+	void once_scheduled(float seconds, callback_function_t callback)
+	{
+		once(seconds, std::bind(schedule_function, callback));
+	}
+
+	void once(float seconds, callback_function_t callback)
+	{
+		_callback_function = callback;
+		once(seconds, _static_callback, (void*)this);
+	}
+
+	void once_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
 	{
-		_attach_ms(seconds * 1000, false, reinterpret_cast<callback_with_arg_t>(callback), 0);
+		once_ms(milliseconds, std::bind(schedule_function, callback));
 	}
 
-	void once_ms(uint32_t milliseconds, callback_t callback)
+	void once_ms(uint32_t milliseconds, callback_function_t callback)
 	{
-		_attach_ms(milliseconds, false, reinterpret_cast<callback_with_arg_t>(callback), 0);	
+		_callback_function = callback;
+		once_ms(milliseconds, _static_callback, (void*)this);
 	}
 
 	template<typename TArg>
@@ -96,11 +124,12 @@ class Ticker
 
 protected:	
 	void _attach_ms(uint32_t milliseconds, bool repeat, callback_with_arg_t callback, uint32_t arg);
-
+	static void _static_callback (void* arg);
 
 protected:
 	ETSTimer* _timer;
-};
+	callback_function_t _callback_function = nullptr;
 
+};
 
 #endif//TICKER_H

libraries/Ticker/examples/TickerFunctional/TickerFunctional.ino

@@ -0,0 +1,70 @@
+#include "Arduino.h"
+#include "Ticker.h"
+
+#define LED1  2
+#define LED2  4
+#define LED3  12
+#define LED4  14
+#define LED5  15
+
+
+class ExampleClass
+{
+public:
+	ExampleClass(int pin, int duration) : _pin(pin), _duration(duration)
+	{
+		pinMode(_pin, OUTPUT);
+		_myTicker.attach_ms(_duration, std::bind(&ExampleClass::classBlink,this));
+	}
+	~ExampleClass(){};
+
+	int _pin, _duration;
+	Ticker _myTicker;
+
+	void classBlink()
+	{
+		digitalWrite(_pin, !digitalRead(_pin));
+	}
+};
+
+void staticBlink()
+{
+	digitalWrite(LED2, !digitalRead(LED2));
+}
+
+void scheduledBlink()
+{
+	digitalWrite(LED3, !digitalRead(LED2));
+}
+
+void parameterBlink(int p)
+{
+	digitalWrite(p, !digitalRead(p));
+}
+
+Ticker staticTicker;
+Ticker scheduledTicker;
+Ticker parameterTicker;
+Ticker lambdaTicker;
+
+ExampleClass example(LED1, 100);
+
+
+void setup()
+{
+	pinMode(LED2, OUTPUT);
+	staticTicker.attach_ms(100, staticBlink);
+
+	pinMode(LED3, OUTPUT);
+	scheduledTicker.attach_ms_scheduled(100, scheduledBlink);
+
+	pinMode(LED4, OUTPUT);
+	parameterTicker.attach_ms(100, std::bind(parameterBlink,LED4));
+
+	pinMode(LED5, OUTPUT);
+	lambdaTicker.attach_ms(100, [](){digitalWrite(LED5, !digitalRead(LED5));}  );
+}
+
+void loop()
+{
+}