polledTimeout: add option to use CPU count instead of millis()

cores/esp8266/PolledTimeout.h

@@ -24,6 +24,7 @@
  */
 
 #include <Arduino.h>
+#include <assert.h>
 
 namespace esp8266
 {
@@ -47,16 +48,57 @@ struct YieldOrSkip
 
 } //YieldPolicy
 
+namespace TimePolicy
+{
+
+struct TimeMillis
+{
+  // time policy in milli-seconds based on millis()
+
+  using timeType = decltype(millis());
+  static timeType time() {return millis();}
+  static constexpr timeType toMillis = 1;
 
-template <bool PeriodicT, typename YieldPolicyT = YieldPolicy::DoNothing>  
+  // rollover: 48 days, setting max to 24 days to fit in signed scalar (below is = 2^31 - 1)
+  static constexpr timeType timeMax() { return (((((timeType)1) << ((sizeof(timeType) * 8) - 2)) - 1) << 1) + 1; }
+};
+
+#ifdef CORE_MOCK
+struct TimeCycleMs: public TimeMillis {};
+#else
+
+struct TimeCycleMs
+{
+  // time policy in milli-seconds based on ESP.getCycleCount()
+
+  using timeType = decltype(ESP.getCycleCount());
+  static timeType time() {return ESP.getCycleCount();}
+  static constexpr timeType toMillis = F_CPU / 1000;
+
+  // rollover: @80Mhz:53.6s @160Mhz:26.8s
+  // setting max to half of it to ensure full range is never reached
+  // - this particular time measurement is intended to be called very often
+  //   (every loop, every yield)
+  // - this max is larger than internal watchdogs
+  static constexpr timeType timeMax() { return ((((uint64_t)1000) << (sizeof(timeType) * 8)) / F_CPU) / 2; }
+};
+
+#endif // cpu cycles
+
+
+} //TimePolicy
+
+template <bool PeriodicT, typename YieldPolicyT = YieldPolicy::DoNothing, typename TimePolicyT = TimePolicy::TimeMillis>
 class timeoutTemplate
 {
 public:
-  using timeType = decltype(millis());
+  using timeType = typename TimePolicyT::timeType;
 
   timeoutTemplate(timeType timeout) 
-    : _timeout(timeout), _start(millis())  
-  {} 
+    : _timeout(timeout * TimePolicyT::toMillis), _start(TimePolicyT::time())
+  {
+    assert(timeout < TimePolicyT::timeMax());
+  }
 
   bool expired()
   {
@@ -79,7 +121,7 @@ class timeoutTemplate
 
   void reset()
   {
-    _start = millis(); 
+    _start = TimePolicyT::time();
   }
 
   timeType getTimeout() const
@@ -96,7 +138,7 @@ class timeoutTemplate
 
   bool expiredRetrigger()
   {
-    timeType current = millis();
+    timeType current = TimePolicyT::time();
     if(checkExpired(current))
     {
       unsigned long n = (current - _start) / _timeout; //how many _timeouts periods have elapsed, will usually be 1 (current - _start >= _timeout)
@@ -108,7 +150,7 @@ class timeoutTemplate
 
   bool expiredOneShot() const
   {
-    return checkExpired(millis());
+    return checkExpired(TimePolicyT::time());
   }
 
   timeType _timeout;
@@ -117,6 +159,8 @@ class timeoutTemplate
 
 using oneShot = polledTimeout::timeoutTemplate<false>;
 using periodic = polledTimeout::timeoutTemplate<true>;
+using oneShotCycleMs = polledTimeout::timeoutTemplate<false, YieldPolicy::DoNothing, TimePolicy::TimeCycleMs>;
+using periodicCycleMs = polledTimeout::timeoutTemplate<true, YieldPolicy::DoNothing, TimePolicy::TimeCycleMs>;
 
 } //polledTimeout
 

libraries/esp8266/examples/BlinkPolledTimeout/BlinkPolledTimeout.ino

@@ -38,9 +38,10 @@ void ledToggle() {
 }
 
 
-
 esp8266::polledTimeout::periodic halfPeriod(500); //use fully qualified type and avoid importing all ::esp8266 namespace to the global namespace
 
+// also available: lighter esp8266::polledTimeout::periodicCycleMs for durations shorter than 13000 ms
+
 // the setup function runs only once at start
 void setup() {
   pinMode(LED_BUILTIN, OUTPUT);     // Initialize the LED_BUILTIN pin as an output