Implementation of Functional and Scheduled option in Ticker lib (#5030)

* Implementation of Functional and Scheduled option in Ticker lib

* Update example formatting

* More example updates

* More updates to example

* More updates to example

Author: hreintke

libraries/Ticker/Ticker.cpp

@@ -65,9 +65,23 @@ void Ticker::detach()
 	os_timer_disarm(_timer);
 	delete _timer;
 	_timer = nullptr;
+	_callback_function = nullptr;
 }
 
 bool Ticker::active()
 {
 	return (bool)_timer;
 }
+
+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

@@ -25,6 +25,8 @@
 #include <stdint.h>
 #include <stdbool.h>
 #include <stddef.h>
+#include <functional>
+#include <Schedule.h>
 
 extern "C" {
 	typedef struct _ETSTIMER_ ETSTimer;
@@ -37,15 +39,28 @@ class Ticker
 	~Ticker();
 	typedef void (*callback_t)(void);
 	typedef void (*callback_with_arg_t)(void*);
+	typedef std::function<void(void)> callback_function_t;
 
-	void attach(float seconds, callback_t callback)
+	void attach_scheduled(float seconds, callback_function_t callback)
 	{
-		_attach_ms(seconds * 1000, true, reinterpret_cast<callback_with_arg_t>(callback), 0);
+		attach(seconds,std::bind(schedule_function, callback));
 	}
 
-	void attach_ms(uint32_t milliseconds, callback_t callback)
+	void attach(float seconds, callback_function_t callback)
 	{
-		_attach_ms(milliseconds, true, reinterpret_cast<callback_with_arg_t>(callback), 0);
+		_callback_function = callback;
+		attach(seconds, _static_callback, (void*)this);
+	}
+
+	void attach_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
+	{
+		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>
@@ -67,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)
 	{
-		_attach_ms(seconds * 1000, false, reinterpret_cast<callback_with_arg_t>(callback), 0);
+		once(seconds, std::bind(schedule_function, callback));
 	}
 
-	void once_ms(uint32_t milliseconds, callback_t callback)
+	void once(float seconds, callback_function_t callback)
 	{
-		_attach_ms(milliseconds, false, reinterpret_cast<callback_with_arg_t>(callback), 0);	
+		_callback_function = callback;
+		once(seconds, _static_callback, (void*)this);
+	}
+
+	void once_ms_scheduled(uint32_t milliseconds, callback_function_t callback)
+	{
+		once_ms(milliseconds, std::bind(schedule_function, callback));
+	}
+
+	void once_ms(uint32_t milliseconds, callback_function_t callback)
+	{
+		_callback_function = callback;
+		once_ms(milliseconds, _static_callback, (void*)this);
 	}
 
 	template<typename TArg>
@@ -98,10 +125,11 @@ 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;
 };
 
 

libraries/Ticker/examples/TickerFunctional/TickerFunctional.ino

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