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

cores/esp8266/Esp.h

@@ -200,15 +200,20 @@ class EspClass {
 
         bool eraseConfig();
 
-        inline uint32_t getCycleCount();
+#ifndef CORE_MOCK
+        inline
+#endif
+        uint32_t getCycleCount();
 };
 
+#ifndef CORE_MOCK
 uint32_t EspClass::getCycleCount()
 {
     uint32_t ccount;
     __asm__ __volatile__("esync; rsr %0,ccount":"=a" (ccount));
     return ccount;
 }
+#endif
 
 extern EspClass ESP;
 

cores/esp8266/HardwareSerial.cpp

@@ -139,7 +139,7 @@ size_t HardwareSerial::readBytes(char* buffer, size_t size)
 
     while (got < size)
     {
-        esp8266::polledTimeout::oneShot timeOut(_timeout);
+        esp8266::polledTimeout::oneShotFastMs timeOut(_timeout);
         size_t avail;
         while ((avail = available()) == 0 && !timeOut);
         if (avail == 0)

cores/esp8266/PolledTimeout.h

@@ -23,6 +23,8 @@
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
+#include <limits>
+
 #include <Arduino.h>
 
 namespace esp8266
@@ -45,18 +47,100 @@ struct YieldOrSkip
   static void execute() {delay(0);}
 };
 
+template <unsigned long delayMs>
+struct YieldAndDelayMs
+{
+  static void execute() {delay(delayMs);}
+};
+
 } //YieldPolicy
 
+namespace TimePolicy
+{
+
+struct TimeMillis
+{
+  // time policy in milli-seconds based on millis()
+
+  using timeType = decltype(millis());
+  static timeType time() {return millis();}
+
+  // millis to millis
+  static timeType toTimeTypeUnit (const timeType t) { return t; }
+
+  // rollover on 32 bits: 49.7 days (::max() is a "never expires"-reserved value)
+  static constexpr timeType timeMax() { return std::numeric_limits<timeType>::max() - 1; }
+};
+
+struct TimeFastMillis
+{
+  // time policy in milli-seconds based on ESP.getCycleCount()
+
+  using timeType = decltype(ESP.getCycleCount());
+  static timeType time() {return ESP.getCycleCount();}
+  static constexpr timeType toTimeTypeUnitMul = F_CPU / 1000;
+
+  // millis to CPU cycles:
+  static timeType toTimeTypeUnit (const timeType t) { return t * toTimeTypeUnitMul; }
+
+  // rollover: @80Mhz:53.6s @160Mhz:26.8s
+  // setting max to half of min 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 (((timeType)1) << ((sizeof(timeType) * 8) - 2)) / (toTimeTypeUnitMul / 2); }
+};
+
+struct TimeFastMicros
+{
+  // time policy in micro-seconds based on ESP.getCycleCount()
+
+  using timeType = decltype(ESP.getCycleCount());
+  static timeType time() {return ESP.getCycleCount();}
+  static constexpr timeType toTimeTypeUnitMul = F_CPU / 1000000;
+
+  // micros to CPU cycles:
+  static timeType toTimeTypeUnit (const timeType t) { return t * toTimeTypeUnitMul; }
+
+  // rollover: @80Mhz:53.6s @160Mhz:26.8s
+  // setting max to half of min 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 (((timeType)1) << ((sizeof(timeType) * 8) - 2)) / (toTimeTypeUnitMul / 2); }
+};
+
+struct TimeFastNanos
+{
+  // time policy in nano-seconds based on ESP.getCycleCount()
+
+  using timeType = decltype(ESP.getCycleCount());
+  static timeType time() {return ESP.getCycleCount();}
+
+  // nanos to CPU cycles (best, within 32bits range)
+  static timeType toTimeTypeUnit (const timeType t) { return (t * (F_CPU / 40000000)) / 25; }
+
+  // given toTimeTypeUnit(), timeMax is (2^31 / 4(@160MHz)) = 0.536 seconds
+  static constexpr timeType timeMax() { return (((((timeType)1) << ((sizeof(timeType) * 8) - 2 - 2)) - 1) << 1) + 1; }
+};
+
+} //TimePolicy
 
-template <bool PeriodicT, typename YieldPolicyT = YieldPolicy::DoNothing>  
+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())  
-  {} 
+  timeoutTemplate(const timeType timeout)
+    : _timeout(TimePolicyT::toTimeTypeUnit(timeout)), _start(TimePolicyT::time())
+  {
+    if (timeout > timeMax())
+    {
+      // "never expires"  (checkExpired() condition "(t - _start) > _timeout;" is never reached)
+      _timeout = std::numeric_limits<timeType>::max();
+    }
+  }
 
   bool expired()
   {
@@ -79,7 +163,7 @@ class timeoutTemplate
 
   void reset()
   {
-    _start = millis(); 
+    _start = TimePolicyT::time();
   }
 
   timeType getTimeout() const
@@ -89,14 +173,24 @@ class timeoutTemplate
 
   bool checkExpired(const timeType t) const
   {
-    return (t - _start) >=  _timeout;
+    // always returns false when _timeout is ::max()
+    return (t - _start) > _timeout;
   }
-
+
+  static constexpr timeType timeMax()
+  {
+    return TimePolicyT::timeMax();
+  }
+
 protected:
 
   bool expiredRetrigger()
   {
-    timeType current = millis();
+    if (_timeout == 0)
+      // "always expired"
+      return true;
+
+    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,15 +202,36 @@ class timeoutTemplate
 
   bool expiredOneShot() const
   {
-    return checkExpired(millis());
+    return checkExpired(TimePolicyT::time());
   }
 
   timeType _timeout;
   timeType _start;
 };
 
-using oneShot = polledTimeout::timeoutTemplate<false>;
-using periodic = polledTimeout::timeoutTemplate<true>;
+// legacy type names, deprecated (unit is milliseconds)
+
+using oneShot = polledTimeout::timeoutTemplate<false> /*__attribute__((deprecated("use oneShotMs")))*/;
+using periodic = polledTimeout::timeoutTemplate<true> /*__attribute__((deprecated("use periodicMs")))*/;
+
+// standard versions (based on millis())
+// timeMax() is 49.7 days (2^32 ms)
+
+using oneShotMs = polledTimeout::timeoutTemplate<false>;
+using periodicMs = polledTimeout::timeoutTemplate<true>;
+
+// "Fast" versions sacrifices time range for improved precision and reduced code size (factor ~100)
+// timeMax() values:
+// Ms: max is 13421       ms (13.4   s)
+// Us: max is 13421772    us (13.4   s)
+// Ns: max is   536870911 ns ( 0.536 s)
+
+using oneShotFastMs = polledTimeout::timeoutTemplate<false, YieldPolicy::DoNothing, TimePolicy::TimeFastMillis>;
+using periodicFastMs = polledTimeout::timeoutTemplate<true, YieldPolicy::DoNothing, TimePolicy::TimeFastMillis>;
+using oneShotFastUs = polledTimeout::timeoutTemplate<false, YieldPolicy::DoNothing, TimePolicy::TimeFastMicros>;
+using periodicFastUs = polledTimeout::timeoutTemplate<true, YieldPolicy::DoNothing, TimePolicy::TimeFastMicros>;
+using oneShotFastNs = polledTimeout::timeoutTemplate<false, YieldPolicy::DoNothing, TimePolicy::TimeFastNanos>;
+using periodicFastNs = polledTimeout::timeoutTemplate<true, YieldPolicy::DoNothing, TimePolicy::TimeFastNanos>;
 
 } //polledTimeout
 

libraries/ESP8266mDNS/src/LEAmDNS.h

@@ -905,12 +905,12 @@ class MDNSResponder {
      * stcProbeInformation
      */
     struct stcProbeInformation {
-        enuProbingStatus                m_ProbingStatus;
-        uint8_t                         m_u8SentCount;  // Used for probes and announcements
-        esp8266::polledTimeout::oneShot m_Timeout;      // Used for probes and announcements
-        //clsMDNSTimeFlag                 m_TimeFlag;     // Used for probes and announcements
-        bool                            m_bConflict;
-        bool                            m_bTiebreakNeeded;
+        enuProbingStatus                  m_ProbingStatus;
+        uint8_t                           m_u8SentCount;  // Used for probes and announcements
+        esp8266::polledTimeout::oneShotMs m_Timeout;      // Used for probes and announcements
+        //clsMDNSTimeFlag                   m_TimeFlag;     // Used for probes and announcements
+        bool                              m_bConflict;
+        bool                              m_bTiebreakNeeded;
         MDNSHostProbeFn   				m_fnHostProbeResultCallback;
         MDNSServiceProbeFn 				m_fnServiceProbeResultCallback;
 
@@ -974,9 +974,9 @@ class MDNSResponder {
                 const timeoutLevel_t    TIMEOUTLEVEL_INTERVAL   = 5;
                 const timeoutLevel_t    TIMEOUTLEVEL_FINAL      = 100;
 
-                uint32_t                        m_u32TTL;
-                esp8266::polledTimeout::oneShot m_TTLTimeout;
-                timeoutLevel_t                  m_timeoutLevel;
+                uint32_t                          m_u32TTL;
+                esp8266::polledTimeout::oneShotMs m_TTLTimeout;
+                timeoutLevel_t                    m_timeoutLevel;
 
                 stcTTL(void);
                 bool set(uint32_t p_u32TTL);
@@ -1073,14 +1073,14 @@ class MDNSResponder {
 #endif
         };
 
-        stcMDNSServiceQuery*            m_pNext;
-        stcMDNS_RRDomain                m_ServiceTypeDomain;    // eg. _http._tcp.local
-        MDNSServiceQueryCallbackFunc    m_fnCallback;
-        bool                            m_bLegacyQuery;
-        uint8_t                         m_u8SentCount;
-        esp8266::polledTimeout::oneShot m_ResendTimeout;
-        bool                            m_bAwaitingAnswers;
-        stcAnswer*                      m_pAnswers;
+        stcMDNSServiceQuery*              m_pNext;
+        stcMDNS_RRDomain                  m_ServiceTypeDomain;    // eg. _http._tcp.local
+        MDNSServiceQueryCallbackFunc      m_fnCallback;
+        bool                              m_bLegacyQuery;
+        uint8_t                           m_u8SentCount;
+        esp8266::polledTimeout::oneShotMs m_ResendTimeout;
+        bool                              m_bAwaitingAnswers;
+        stcAnswer*                        m_pAnswers;
 
         stcMDNSServiceQuery(void);
         ~stcMDNSServiceQuery(void);

libraries/ESP8266mDNS/src/LEAmDNS_Control.cpp

@@ -1061,7 +1061,7 @@ bool MDNSResponder::_updateProbeStatus(void) {
         else {                                                                                      // Probing finished
             DEBUG_EX_INFO(DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _updateProbeStatus: Done host probing.\n")););
             m_HostProbeInformation.m_ProbingStatus = ProbingStatus_Done;
-            m_HostProbeInformation.m_Timeout.reset(std::numeric_limits<esp8266::polledTimeout::oneShot::timeType>::max());
+            m_HostProbeInformation.m_Timeout.reset(std::numeric_limits<esp8266::polledTimeout::oneShotMs::timeType>::max());
             if (m_HostProbeInformation.m_fnHostProbeResultCallback) {
                 m_HostProbeInformation.m_fnHostProbeResultCallback(m_pcHostname, true);
             }
@@ -1073,7 +1073,7 @@ bool MDNSResponder::_updateProbeStatus(void) {
         }
     }   // else: Probing already finished OR waiting for next time slot
     else if ((ProbingStatus_Done == m_HostProbeInformation.m_ProbingStatus) &&
-             (m_HostProbeInformation.m_Timeout.checkExpired(std::numeric_limits<esp8266::polledTimeout::oneShot::timeType>::max()))) {
+             (m_HostProbeInformation.m_Timeout.checkExpired(std::numeric_limits<esp8266::polledTimeout::oneShotMs::timeType>::max()))) {
 
         if ((bResult = _announce(true, false))) {   // Don't announce services here
             ++m_HostProbeInformation.m_u8SentCount;
@@ -1083,7 +1083,7 @@ bool MDNSResponder::_updateProbeStatus(void) {
                 DEBUG_EX_INFO(DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _updateProbeStatus: Announcing host (%lu).\n\n"), m_HostProbeInformation.m_u8SentCount););
             }
             else {
-                m_HostProbeInformation.m_Timeout.reset(std::numeric_limits<esp8266::polledTimeout::oneShot::timeType>::max());
+                m_HostProbeInformation.m_Timeout.reset(std::numeric_limits<esp8266::polledTimeout::oneShotMs::timeType>::max());
                 DEBUG_EX_INFO(DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _updateProbeStatus: Done host announcing.\n\n")););
             }
         }
@@ -1110,7 +1110,7 @@ bool MDNSResponder::_updateProbeStatus(void) {
             else {                                                                                      // Probing finished
                 DEBUG_EX_INFO(DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _updateProbeStatus: Done service probing %s.%s.%s\n\n"), (pService->m_pcName ?: m_pcHostname), pService->m_pcService, pService->m_pcProtocol););
                 pService->m_ProbeInformation.m_ProbingStatus = ProbingStatus_Done;
-                pService->m_ProbeInformation.m_Timeout.reset(std::numeric_limits<esp8266::polledTimeout::oneShot::timeType>::max());
+                pService->m_ProbeInformation.m_Timeout.reset(std::numeric_limits<esp8266::polledTimeout::oneShotMs::timeType>::max());
                 if (pService->m_ProbeInformation.m_fnServiceProbeResultCallback) {
                 	pService->m_ProbeInformation.m_fnServiceProbeResultCallback(pService->m_pcName, pService, true);
                 }
@@ -1131,7 +1131,7 @@ bool MDNSResponder::_updateProbeStatus(void) {
                     DEBUG_EX_INFO(DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _updateProbeStatus: Announcing service %s.%s.%s (%lu)\n\n"), (pService->m_pcName ?: m_pcHostname), pService->m_pcService, pService->m_pcProtocol, pService->m_ProbeInformation.m_u8SentCount););
                 }
                 else {
-                    pService->m_ProbeInformation.m_Timeout.reset(std::numeric_limits<esp8266::polledTimeout::oneShot::timeType>::max());
+                    pService->m_ProbeInformation.m_Timeout.reset(std::numeric_limits<esp8266::polledTimeout::oneShotMs::timeType>::max());
                     DEBUG_EX_INFO(DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _updateProbeStatus: Done service announcing for %s.%s.%s\n\n"), (pService->m_pcName ?: m_pcHostname), pService->m_pcService, pService->m_pcProtocol););
                 }
             }
@@ -1449,7 +1449,7 @@ bool MDNSResponder::_checkServiceQueryCache(void) {
                 ++pServiceQuery->m_u8SentCount;
                 pServiceQuery->m_ResendTimeout.reset((MDNS_DYNAMIC_QUERY_RESEND_COUNT > pServiceQuery->m_u8SentCount)
                                                         ? (MDNS_DYNAMIC_QUERY_RESEND_DELAY * (pServiceQuery->m_u8SentCount - 1))
-                                                        : std::numeric_limits<esp8266::polledTimeout::oneShot::timeType>::max());
+                                                        : std::numeric_limits<esp8266::polledTimeout::oneShotMs::timeType>::max());
             }
             DEBUG_EX_INFO(
                     DEBUG_OUTPUT.printf_P(PSTR("[MDNSResponder] _checkServiceQueryCache: %s to resend service query!"), (bResult ? "Succeeded" : "FAILED"));