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-2023 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software
 * for any purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can
 * be obtained from https://opensource.org/licenses/mit/.
 */
 
#ifndef CMSIS_PLUS_RTOS_OS_CLOCKS_H_
#define CMSIS_PLUS_RTOS_OS_CLOCKS_H_
 
// ----------------------------------------------------------------------------
 
#if defined(__cplusplus)
 
// ----------------------------------------------------------------------------
 
#if defined(OS_USE_OS_APP_CONFIG_H)
#include <cmsis-plus/os-app-config.h>
#endif
 
#include <cmsis-plus/rtos/os-decls.h>
 
// ----------------------------------------------------------------------------
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#pragma clang diagnostic ignored "-Wdocumentation-unknown-command"
#endif
 
// ----------------------------------------------------------------------------
 
namespace os
{
  namespace rtos
  {
 
    // ========================================================================
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wpadded"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wpadded"
#pragma GCC diagnostic ignored "-Wsuggest-final-methods"
#pragma GCC diagnostic ignored "-Wsuggest-final-types"
#endif
    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.
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wdeprecated-volatile"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wvolatile"
#endif
      ++steady_count_;
#pragma GCC diagnostic pop
    }
 
    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
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wsign-conversion"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wsign-conversion"
#endif
      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));
      }
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#endif
#pragma GCC diagnostic pop
 
    // ========================================================================
    inline void
    __attribute__((always_inline))
    clock_highres::internal_increment_count (void)
    {
      // Increment the highres count by SysTick divisor.
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wdeprecated-volatile"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wvolatile"
#endif
      steady_count_ += port::clock_highres::cycles_per_tick ();
#pragma GCC diagnostic pop
    }
 
    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 */
 
#pragma GCC diagnostic pop
 
// ----------------------------------------------------------------------------
 
#endif /* __cplusplus */
 
// ----------------------------------------------------------------------------
 
#endif /* CMSIS_PLUS_RTOS_OS_CLOCKS_H_ */