rename Resolution to Clock

use dependency injection for Clock instead of tag dispatch

Author: kpfleming

README.md

@@ -14,10 +14,10 @@ Include the library and create a *TimerSet* instance.
 auto timerset = Timers::create_default();
 ```
 
-Or using the *TimerSet* constructors for different timer limits / time resolution.
+Or using the *TimerSet* constructors for different timer limits / time clocks.
 ```cpp
-Timers::TimerSet<10> timerset; // 10 concurrent timers, using millis as resolution
-Timers::TimerSet<10, Timers::Resolution::micros> microtimerset; // 10 concurrent timers, using micros as resolution
+Timers::TimerSet<10> timerset; // 10 concurrent timers, using millisecond clock
+Timers::TimerSet<10, Timers::Clock::micros> microtimerset; // 10 concurrent timers, using microsecond clock
 ```
 
 Call *timerset*.**tick_and_delay()** in the ```loop``` function to execute handlers for any timers

examples/blink/blink.ino

@@ -11,7 +11,7 @@ auto timerset = Timers::create_default(); // create a TimerSet with default sett
 
 Timers::HandlerResult toggle_led() {
   digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); // toggle the LED
-  return  Timers::TimerStatus::repeat;
+  return Timers::TimerStatus::repeat;
 }
 
 void setup() {

examples/blink_micros/blink_micros.ino

@@ -7,7 +7,7 @@
 
 #include <arduino-timer-cpp17.h>
 
-Timers::TimerSet<1, Timers::Resolution::micros> timerset; // create a TimerSet with 1 timer and microsecond resolution
+Timers::TimerSet<1, Timers::Clock::micros> timerset; // create a TimerSet with 1 timer and microsecond clock
 
 Timers::HandlerResult toggle_led() {
   digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); // toggle the LED

examples/full/full.ino

@@ -3,7 +3,7 @@
  *
  * Full example using the arduino-timer-cpp17 library.
  * Shows:
- *  - Setting a different number of tasks with microsecond resolution
+ *  - Setting a different number of tasks with microsecond clock
  *  - disabling a repeated function
  *  - running a function after a delay
  *  - cancelling a task
@@ -15,11 +15,11 @@
 auto timerset = Timers::create_default(); // create a TimerSet with default settings
 Timers::TimerSet<> default_timerset; // same as above
 
-// create a TimerSet that can hold 1 concurrent task, with microsecond resolution
-Timers::TimerSet<1, Timers::Resolution::micros> microtimerset;
+// create a TimerSet that can hold 1 concurrent task, with microsecond clock
+Timers::TimerSet<1, Timers::Clock::micros> microtimerset;
 
-// create a TimerSet that holds 16 tasks, with millisecond resolution
-Timers::TimerSet<16, Timers::Resolution::millis> t_timerset;
+// create a TimerSet that holds 16 tasks, with millisecond clock
+Timers::TimerSet<16, Timers::Clock::millis> t_timerset;
 
 Timers::HandlerResult toggle_led() {
   digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN)); // toggle the LED
@@ -67,7 +67,7 @@ void setup() {
   auto timer = timerset.every(500, toggle_led);
   timerset.cancel(timer); // this task is now cancelled, and will not run
 
-  // call print_message in 2 seconds, but with microsecond resolution
+  // call print_message in 2 seconds, but with microsecond clock
   microtimerset.in(2000000, [](){ return print_message("delayed two seconds using microseconds"); });
 
   if (!microtimerset.in(5000, [](){ return print_message("never printed"); })) {

extras/tests/rollover-generic/rollover-generic.ino

@@ -2,15 +2,15 @@
  Test timer rollover handling
  */
 
-#include <arduino-timer.h>
+#include <arduino-timer-cpp17.h>
 
-unsigned long wrapping_millis();
+Timers::Timepoint wrapping_millis();
 
-Timer<1, wrapping_millis> timer; // this timer will wrap
-auto _timer = timer_create_default(); // to count milliseconds
+Timers::TimerSet<1, Timers::Clock::custom<wrapping_millis>> timerset; // this timer will wrap
+auto _timerset = Timers::create_default(); // to count milliseconds
 
-unsigned long _millis = 0L;
-unsigned long wrapping_millis()
+Timers::Timepoint _millis = 0L;
+Timers::Timepoint wrapping_millis()
 {
     // uses _millis controled by _timer
     // 6-second time loop starting at rollover - 3 seconds
@@ -21,19 +21,19 @@ unsigned long wrapping_millis()
 
 void setup() {
     pinMode(LED_BUILTIN, OUTPUT);
-    _timer.every(1, [](void *) -> bool {
+    _timerset.every(1, [](){
         ++_millis; // increase _millis every millisecond
-        return true;
+        return Timers::TimerStatus::repeat;
     });
 
-    // should blink the led every second, regardless of wrapping
-    timer.every(1000, [](void *) -> bool {
+    // should blink the LED every second, regardless of wrapping
+    timerset.every(1000, [](){
         digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
-        return true;
+        return Timers::TimerStatus::repeat;
     });
 }
 
 void loop() {
-    _timer.tick();
-    timer.tick();
+    _timerset.tick();
+    timerset.tick();
 }

extras/tests/rollover/rollover.ino

@@ -3,9 +3,9 @@
  */
 
 #include <util/atomic.h>
-#include <arduino-timer.h>
+#include <arduino-timer-cpp17.h>
 
-auto timer = timer_create_default();
+auto timerset = Timers::create_default();
 
 // https://arduino.stackexchange.com/questions/12587/how-can-i-handle-the-millis-rollover
 void set_millis(unsigned long ms)
@@ -18,15 +18,15 @@ void set_millis(unsigned long ms)
 
 void setup() {
     pinMode(LED_BUILTIN, OUTPUT);
-    timer.every(1000, [](void *) -> bool {
+    timerset.every(1000, [](){
         digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
-        return true;
+        return Timers::TimerStatus::repeat;
     });
 }
 
 void loop() {
     // 6-second time loop starting at rollover - 3 seconds
     if (millis() - (-3000) >= 6000)
         set_millis(-3000);
-    timer.tick();
+    timerset.tick();
 }

src/arduino-timer-cpp17.h

@@ -88,46 +88,57 @@ struct Timer {
 
 using TimerHandle = std::optional<std::reference_wrapper<Timer>>;
 
-struct Resolution {
-	struct millis {};
-	struct micros {};
+struct Clock {
+	struct millis {
+		static
+		Timepoint
+		now() {
+			return ::millis();
+		}
+
+		static
+		void
+		delay(Timepoint until) {
+			::delay(until);
+		}
+	};
+
+	struct micros {
+		static
+		Timepoint
+		now() {
+			return ::micros();
+		}
+
+		static
+		void
+		delay(Timepoint until) {
+			unsigned int micros = until % 1000;
+
+			::delayMicroseconds(micros);
+			::delay(until - micros);
+		}
+	};
+
+	template <
+		Timers::Timepoint (*clock_func)()
+		>
+	struct custom {
+		static
+		Timepoint
+		now() {
+			return clock_func();
+		}
+	};
 };
 
 template <
 	size_t max_timers = TIMERSET_DEFAULT_TIMERS, // max number of timers
-	typename resolution = Resolution::millis // resolution of timers
+	typename clock = Clock::millis // clock for timers
 	>
 class TimerSet {
 	std::array<Timer, max_timers> timers;
 
-	Timepoint
-	get_clock(Resolution::millis) {
-		return millis();
-	}
-
-	Timepoint
-	get_clock(Resolution::micros) {
-		return micros();
-	}
-
-	void
-	delay_until(Timepoint time, Resolution::millis) {
-		delay(time);
-	}
-
-	void
-	delay_until(Timepoint time, Resolution::micros) {
-		unsigned int micros = time % 1000;
-
-		time -= micros;
-
-		delayMicroseconds(micros);
-
-		if (time > 0) {
-			delay_until(time, Resolution::millis());
-		}
-	}
-
 	void
 	remove(TimerHandle handle)
 	{
@@ -170,29 +181,29 @@ class TimerSet {
 	TimerHandle
 	in(Timepoint delay, Handler h)
 	{
-		return add_timer(get_clock(resolution()), delay, h);
+		return add_timer(clock::now(), delay, h);
 	}
 
 	// Calls handler at time
 	TimerHandle
 	at(Timepoint time, Handler h)
 	{
-		const Timepoint now = get_clock(resolution());
+		const Timepoint now = clock::now();
 		return add_timer(now, time - now, h);
 	}
 
 	// Calls handler every interval units of time
 	TimerHandle
 	every(Timepoint interval, Handler h)
 	{
-		return add_timer(get_clock(resolution()), interval, h, interval);
+		return add_timer(clock::now(), interval, h, interval);
 	}
 
 	// Calls handler immediately and every interval units of time
 	TimerHandle
 	now_and_every(Timepoint interval, Handler h)
 	{
-		const Timepoint now = get_clock(resolution());
+		const Timepoint now = clock::now();
 		return add_timer(now, now, h, interval);
 	}
 
@@ -226,7 +237,7 @@ class TimerSet {
 				continue;
 			}
 
-			Timepoint now = get_clock(resolution());
+			Timepoint now = clock::now();
 			Timepoint elapsed = now - timer.start;
 
 			if (elapsed >= timer.expires) {
@@ -250,7 +261,7 @@ class TimerSet {
 
 		// compute lowest remaining time after all handlers have been executed
 		// (some timers may have expired during handler execution)
-		const Timepoint now = get_clock(resolution());
+		const Timepoint now = clock::now();
 
 		for (auto& timer: timers) {
 			if (!timer.handler) {
@@ -268,11 +279,7 @@ class TimerSet {
 	void
 	tick_and_delay()
 	{
-		Timepoint next = tick();
-
-		if (next > 0) {
-			delay_until(next, resolution());
-		}
+		clock::delay(tick());
 	}
 };