os-clocks.h

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2016-2025 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_ */