Add Chrono support to Ticker et al

Author: kjbracey

drivers/LowPowerTicker.h

@@ -19,7 +19,6 @@
 
 #include "platform/platform.h"
 #include "drivers/Ticker.h"
-#include "platform/NonCopyable.h"
 
 #if defined (DEVICE_LPTICKER) || defined(DOXYGEN_ONLY)
 
@@ -40,16 +39,9 @@ namespace mbed {
  *
  * @note Synchronization level: Interrupt safe
  */
-class LowPowerTicker : public Ticker, private NonCopyable<LowPowerTicker> {
-
+class LowPowerTicker : public TickerBase {
 public:
-    LowPowerTicker() : Ticker(get_lp_ticker_data())
-    {
-    }
-
-    virtual ~LowPowerTicker()
-    {
-    }
+    LowPowerTicker();
 };
 
 /** @}*/

drivers/LowPowerTimeout.h

@@ -21,9 +21,8 @@
 
 #if DEVICE_LPTICKER || defined(DOXYGEN_ONLY)
 
-#include "hal/lp_ticker_api.h"
-#include "drivers/LowPowerTicker.h"
-#include "platform/NonCopyable.h"
+#include "drivers/LowPowerClock.h"
+#include "drivers/Timeout.h"
 
 namespace mbed {
 /**
@@ -36,14 +35,37 @@ namespace mbed {
  *
  * @note Synchronization level: Interrupt safe
  */
-class LowPowerTimeout : public LowPowerTicker, private NonCopyable<LowPowerTimeout> {
-#if !defined(DOXYGEN_ONLY)
-private:
-    virtual void handler(void)
+class LowPowerTimeout : public TimeoutBase {
+public:
+    LowPowerTimeout();
+
+    /** Clock to use with attach_absolute, guaranteeing running only while attached or manually locked */
+    using clock = LowPowerClock;
+
+    /** Clock to use with attach_absolute, running always */
+    using steady_clock = LowPowerClock;
+
+    /** @copydoc TimeoutBase::scheduled_time() */
+    LowPowerClock::time_point scheduled_time() const
     {
-        _function.call();
+        /* Massage from virtual TickerDataClock::time_point used internally to true LowPowerClock::time_point */
+        return LowPowerClock::time_point{TimeoutBase::scheduled_time().time_since_epoch()};
+    }
+
+    /** Attach a function to be called by the Timeout, specifying the absolute time
+     *
+     *  @param func pointer to the function to be called
+     *  @param abs_time the absolute time for the call, referenced to LowPowerClock
+     *
+     *  @note setting @a abs_time to a time in the past means the event will be scheduled immediately
+     *  resulting in an instant call to the function.
+     */
+    template <class F>
+    void attach_absolute(F &&func, LowPowerClock::time_point abs_time)
+    {
+        /* Massage from true LowPowerClock::time_point to virtual TickerDataClock::time_point used internally */
+        TimeoutBase::attach_absolute(std::forward<F>(func), TickerDataClock::time_point{abs_time.time_since_epoch()});
     }
-#endif
 };
 
 /** @}*/

drivers/LowPowerTimer.h

@@ -36,13 +36,9 @@ namespace mbed {
  *
  * @note Synchronization level: Interrupt safe
  */
-class LowPowerTimer : public Timer, private NonCopyable<LowPowerTimer> {
-
+class LowPowerTimer : public TimerBase {
 public:
-    LowPowerTimer() : Timer(get_lp_ticker_data())
-    {
-    }
-
+    LowPowerTimer();
 };
 
 /** @}*/

drivers/Ticker.h

@@ -17,14 +17,17 @@
 #ifndef MBED_TICKER_H
 #define MBED_TICKER_H
 
+#include <chrono>
 #include <mstd_utility>
+#include "drivers/TickerDataClock.h"
 #include "drivers/TimerEvent.h"
 #include "platform/Callback.h"
 #include "platform/mbed_toolchain.h"
 #include "platform/NonCopyable.h"
 #include "hal/lp_ticker_api.h"
 
 namespace mbed {
+
 /**
  * \defgroup drivers_Ticker Ticker class
  * \ingroup drivers-public-api-ticker
@@ -42,6 +45,7 @@ namespace mbed {
  * // Toggle the blinking LED after 5 seconds
  *
  * #include "mbed.h"
+ * using namespace std::chrono;
  *
  * Ticker timer;
  * DigitalOut led1(LED1);
@@ -54,26 +58,20 @@ namespace mbed {
  * }
  *
  * int main() {
- *     timer.attach(&attime, 5);
+ *     timer.attach(&attime, 5us);
  *     while(1) {
  *         if(flip == 0) {
  *             led1 = !led1;
  *         } else {
  *             led2 = !led2;
  *         }
- *         ThisThread::sleep_for(200);
+ *         ThisThread::sleep_for(200ms);
  *     }
  * }
  * @endcode
  */
-class Ticker : public TimerEvent, private NonCopyable<Ticker> {
-
+class TickerBase : public TimerEvent, private NonCopyable<TickerBase> {
 public:
-    Ticker();
-
-    // When low power ticker is in use, then do not disable deep sleep.
-    Ticker(const ticker_data_t *data);
-
     /** Attach a function to be called by the Ticker, specifying the interval in seconds
      *
      *  The method forwards its arguments to attach_us() rather than copying them which
@@ -82,18 +80,21 @@ class Ticker : public TimerEvent, private NonCopyable<Ticker> {
      *  possible given attach_us() expects an integer value for the callback interval.
      *  @param func pointer to the function to be called
      *  @param t the time between calls in seconds
+     *  @deprecated Pass a chrono duration, not a float second count. For example use `10ms` rather than `0.01f`.
      */
 #if defined(__ICCARM__)
+    MBED_DEPRECATED_SINCE("mbed-os-6.0.0", "Pass a chrono duration, not a float second count. For example use `10ms` rather than `0.01f`.")
     MBED_FORCEINLINE template <typename F>
 #else
     template <typename F> MBED_FORCEINLINE
+    MBED_DEPRECATED_SINCE("mbed-os-6.0.0", "Pass a chrono duration, not a float second count. For example use `10ms` rather than `0.01f`.")
 #endif
     void attach(F &&func, float t)
     {
-        attach_us(std::forward<F>(func), t * 1000000.0f);
+        auto float_interval = std::chrono::duration<float>(t);
+        attach(std::forward<F>(func), std::chrono::duration_cast<std::chrono::microseconds>(float_interval));
     }
 
-
     /** Attach a function to be called by the Ticker, specifying the interval in microseconds
      *
      *  @param func pointer to the function to be called
@@ -102,32 +103,65 @@ class Ticker : public TimerEvent, private NonCopyable<Ticker> {
      *  @note setting @a t to a value shorter than it takes to process the ticker callback
      *  causes the system to hang. Ticker callback is called constantly with no time
      *  for threads scheduling.
+     *  @deprecated Pass a chrono duration, not an integer microsecond count. For example use `10ms` rather than `10000`.
      *
      */
+    MBED_DEPRECATED_SINCE("mbed-os-6.0.0", "Pass a chrono duration, not an integer microsecond count. For example use `10ms` rather than `10000`.")
     void attach_us(Callback<void()> func, us_timestamp_t t);
 
-
-    virtual ~Ticker()
-    {
-        detach();
-    }
+    /** Attach a function to be called by the Ticker, specifying the interval in microseconds
+     *
+     *  @param func pointer to the function to be called
+     *  @param t the time between calls in micro-seconds
+     *
+     *  @note setting @a t to a value shorter than it takes to process the ticker callback
+     *  causes the system to hang. Ticker callback is called constantly with no time
+     *  for threads scheduling.
+     *
+     */
+    void attach(Callback<void()> func, std::chrono::microseconds t);
 
     /** Detach the function
      */
     void detach();
 
 #if !defined(DOXYGEN_ONLY)
 protected:
-    void setup(us_timestamp_t t);
-    virtual void handler();
+    TickerBase(const ticker_data_t *data);
+    TickerBase(const ticker_data_t *data, bool lock_deepsleep);
 
-protected:
-    us_timestamp_t         _delay;  /**< Time delay (in microseconds) for resetting the multishot callback. */
+    ~TickerBase()
+    {
+        detach();
+    }
+
+    /** Attach a function to be called by the Ticker, specifying the absolute call time
+     *
+     *  If used, handler must be overridden, as TickerBase::handler would attempt
+     *  to reschedule. This is done by `TimeoutBase` (used by `Timeout` and `LowPowerTimeout`).
+     *
+     *  @param func pointer to the function to be called
+     *  @param abs_time the time for the call
+     *
+     *  @note setting @a abs_time to a time in the past means the event will be scheduled immediately
+     *  resulting in an instant call to the function.
+     */
+    void attach_absolute(Callback<void()> func, TickerDataClock::time_point abs_time);
+
+    void handler() override;
+    std::chrono::microseconds  _delay{0};  /**< Time delay (in microseconds) for resetting the multishot callback. */
     Callback<void()>    _function;  /**< Callback. */
     bool          _lock_deepsleep;  /**< Flag which indicates if deep sleep should be disabled. */
 #endif
+private:
+    void setup(std::chrono::microseconds t);
+    void setup_absolute(TickerDataClock::time_point t);
 };
 
+class Ticker : public TickerBase {
+public:
+    Ticker();
+};
 /** @}*/
 
 } // namespace mbed