os-clocks.h

Go to the documentation of this file.

/*
 * This file is part of the µOS++ distribution.
 *   (https://github.com/micro-os-plus)
 * Copyright (c) 2016 Liviu Ionescu.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom
 * the Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 * OTHER DEALINGS IN THE SOFTWARE.
 */

#ifndef CMSIS_PLUS_RTOS_OS_CLOCKS_H_
#define CMSIS_PLUS_RTOS_OS_CLOCKS_H_

// ----------------------------------------------------------------------------

#if defined(__cplusplus)

#include <cmsis-plus/rtos/os-decls.h>

// ----------------------------------------------------------------------------

namespace os
{
  namespace rtos
  {

    // ========================================================================

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wpadded"

    class clock : public internal::object_named
    {
    public:

      // ----------------------------------------------------------------------

      using duration_t = port::clock::duration_t;

      using timestamp_t = port::clock::timestamp_t;

      using offset_t = port::clock::offset_t;

      // ----------------------------------------------------------------------
    protected:

      clock (const char* name);

    public:

      // The rule of five.
      clock (const clock&) = delete;
      clock (clock&&) = delete;
      clock&
      operator= (const clock&) = delete;
      clock&
      operator= (clock&&) = delete;

      virtual
      ~clock ();

      // ----------------------------------------------------------------------
    public:

      virtual void
      start (void) = 0;

      virtual timestamp_t
      now (void);

      timestamp_t
      steady_now (void);

      result_t
      sleep_for (duration_t duration);

      virtual result_t
      sleep_until (timestamp_t timestamp);

      result_t
      wait_for (duration_t timeout);

      timestamp_t
      update_for_slept_time (duration_t duration);

      virtual offset_t
      offset (void);

      virtual offset_t
      offset (offset_t value);

      internal::clock_timestamps_list&
      steady_list (void);

      void
      internal_increment_count (void);

      void
      internal_check_timestamps (void);

    protected:

      virtual result_t
      internal_wait_until_ (timestamp_t timestamp,
                            internal::clock_timestamps_list& list);

      // ----------------------------------------------------------------------
      internal::clock_timestamps_list steady_list_;
      duration_t volatile sleep_count_ = 0;

      timestamp_t volatile steady_count_ = 0;

    };

#pragma GCC diagnostic pop

    // ========================================================================

    class adjustable_clock : public clock
    {
      // ----------------------------------------------------------------------
    protected:

      adjustable_clock (const char* name);

    public:

      // The rule of five.
      adjustable_clock (const adjustable_clock&) = delete;
      adjustable_clock (adjustable_clock&&) = delete;
      adjustable_clock&
      operator= (const adjustable_clock&) = delete;
      adjustable_clock&
      operator= (adjustable_clock&&) = delete;

      virtual
      ~adjustable_clock () override;

    public:

      virtual timestamp_t
      now (void) override;

      virtual result_t
      sleep_until (timestamp_t timestamp) override;

      virtual offset_t
      offset (void) override;

      virtual offset_t
      offset (offset_t value) override;

      void
      internal_check_timestamps (void);

    protected:

      offset_t volatile offset_ = 0;

      internal::clock_timestamps_list adjusted_list_;

    };

    // ========================================================================

    class clock_systick : public clock
    {
    public:

      static constexpr uint32_t frequency_hz = OS_INTEGER_SYSTICK_FREQUENCY_HZ;

      // ----------------------------------------------------------------------
      clock_systick ();

      // The rule of five.
      clock_systick (const clock_systick&) = delete;
      clock_systick (clock_systick&&) = delete;
      clock_systick&
      operator= (const clock_systick&) = delete;
      clock_systick&
      operator= (clock_systick&&) = delete;

      virtual
      ~clock_systick () override;

      // ----------------------------------------------------------------------
      virtual void
      start (void) override;

      template<typename Rep_T>
        static constexpr clock::duration_t
        ticks_cast (Rep_T microsec);

      // ----------------------------------------------------------------------
    protected:

#if defined(OS_USE_RTOS_PORT_CLOCK_SYSTICK_WAIT_FOR)

      virtual result_t
      internal_wait_until_ (timestamp_t timestamp, internal::clock_timestamps_list& list);

#endif /* defined(OS_USE_RTOS_PORT_CLOCK_SYSTICK_WAIT_FOR) */

    };

    extern clock_systick sysclock;

    // ========================================================================

    class clock_rtc : public adjustable_clock
    {
    public:

      static constexpr uint32_t frequency_hz = 1;

      // ----------------------------------------------------------------------
      clock_rtc ();

      // The rule of five.
      clock_rtc (const clock_rtc&) = delete;
      clock_rtc (clock_rtc&&) = delete;
      clock_rtc&
      operator= (const clock_rtc&) = delete;
      clock_rtc&
      operator= (clock_rtc&&) = delete;

      virtual
      ~clock_rtc () override;

      // ----------------------------------------------------------------------
      virtual void
      start (void) override;

#if defined(OS_USE_RTOS_PORT_CLOCK_REALTIME_WAIT_FOR)

      virtual result_t
      internal_wait_until_ (timestamp_t timestamp, clock_timestamps_list& list);

#endif

    };

    extern clock_rtc rtclock;

    // ========================================================================

    class clock_highres : public clock
    {
    public:

      clock_highres ();

      // The rule of five.
      clock_highres (const clock_highres&) = delete;
      clock_highres (clock_highres&&) = delete;
      clock_highres&
      operator= (const clock_highres&) = delete;
      clock_highres&
      operator= (clock_highres&&) = delete;

      virtual
      ~clock_highres () override;

      // ----------------------------------------------------------------------
      virtual void
      start (void) override;

      virtual timestamp_t
      now (void) override;

      uint32_t
      input_clock_frequency_hz (void);

      void
      internal_increment_count (void);

      // ----------------------------------------------------------------------
    protected:

    };

    extern clock_highres hrclock;

  } /* namespace rtos */
} /* namespace os */

// ===== Inline & template implementations ====================================

namespace os
{
  namespace rtos
  {

    // ========================================================================

    inline
    clock::clock (const char* name) :
        internal::object_named
          { name }
    {
      ;
    }

    inline internal::clock_timestamps_list&
    __attribute__((always_inline))
    clock::steady_list (void)
    {
      return steady_list_;
    }

    inline void
    __attribute__((always_inline))
    clock::internal_increment_count (void)
    {
      // One more tick count passed.
      ++steady_count_;
    }

    inline void
    __attribute__((always_inline))
    clock::internal_check_timestamps (void)
    {
      steady_list_.check_timestamp (steady_count_);
    }

    // ========================================================================
    inline
    adjustable_clock::adjustable_clock (const char* name) :
        clock
          { name }
    {
      ;
    }

    inline void
    __attribute__((always_inline))
    adjustable_clock::internal_check_timestamps (void)
    {
      clock::internal_check_timestamps ();

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wsign-conversion"
      adjusted_list_.check_timestamp (steady_count_ + offset_);
#pragma GCC diagnostic pop
    }

    // ========================================================================
    template<typename Rep_T>
      constexpr clock::duration_t
      clock_systick::ticks_cast (Rep_T microsec)
      {
        // TODO: add some restrictions to match only numeric types
        return static_cast<clock::duration_t> ((((microsec)
            * (static_cast<Rep_T> (frequency_hz)))
            + static_cast<Rep_T> (1000000ul) - 1)
            / static_cast<Rep_T> (1000000ul));
      }

    // ========================================================================
    inline void
    __attribute__((always_inline))
    clock_highres::internal_increment_count (void)
    {
      // Increment the highres count by SysTick divisor.
      steady_count_ += port::clock_highres::cycles_per_tick ();
    }

    inline uint32_t
    __attribute__((always_inline))
    clock_highres::input_clock_frequency_hz (void)
    {
      return port::clock_highres::input_clock_frequency_hz ();
    }

  // ========================================================================

  } /* namespace rtos */
} /* namespace os */

// ----------------------------------------------------------------------------

#endif /* __cplusplus */

#endif /* CMSIS_PLUS_RTOS_OS_CLOCKS_H_ */