os-clocks.cpp

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/.
 */
 
#if defined(OS_USE_OS_APP_CONFIG_H)
#include <cmsis-plus/os-app-config.h>
#endif
 
#include <cmsis-plus/rtos/os.h>
 
// ----------------------------------------------------------------------------
 
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wc++98-compat"
#endif
 
// ----------------------------------------------------------------------------
 
using namespace os;
using namespace os::rtos;
 
// ----------------------------------------------------------------------------
 
void
os_systick_handler (void)
{
  using namespace os::rtos;
 
#if defined(OS_USE_RTOS_PORT_SCHEDULER)
  // Prevent scheduler actions before starting it.
  if (scheduler::started ())
    {
      port::clock_systick::internal_interrupt_service_routine();
    }
#endif
 
#if defined(OS_TRACE_RTOS_SYSCLOCK_TICK)
  trace::putchar ('.');
#elif defined(OS_TRACE_RTOS_SYSCLOCK_TICK_BRACES)
  trace::printf ("{t ");
#endif
 
    {
      // ----- Enter critical section -----------------------------------------
      interrupts::critical_section ics;
 
      sysclock.internal_increment_count ();
      hrclock.internal_increment_count ();
      // ----- Exit critical section ------------------------------------------
    }
  sysclock.internal_check_timestamps ();
  hrclock.internal_check_timestamps ();
 
#if !defined(OS_INCLUDE_RTOS_REALTIME_CLOCK_DRIVER)
 
  // Simulate an RTC driver.
  static uint32_t ticks = clock_systick::frequency_hz;
 
  if (--ticks == 0)
    {
      ticks = clock_systick::frequency_hz;
 
      os_rtc_handler ();
    }
 
#endif /* !defined(OS_INCLUDE_RTOS_REALTIME_CLOCK_DRIVER) */
 
#if !defined(OS_USE_RTOS_PORT_SCHEDULER)
 
  port::scheduler::reschedule ();
 
#endif /* !defined(OS_USE_RTOS_PORT_SCHEDULER) */
 
#if defined(OS_TRACE_RTOS_SYSCLOCK_TICK_BRACES)
  trace::printf (" t}");
#endif
}
 
void
os_rtc_handler (void)
{
 
#if defined(OS_USE_RTOS_PORT_SCHEDULER)
  // Prevent scheduler actions before starting it.
  if (scheduler::started ())
    {
      port::clock_rtc::internal_interrupt_service_routine();
    }
#endif
 
#if defined(OS_TRACE_RTOS_RTC_TICK)
  trace_putchar ('!');
#endif
 
    {
      // ----- Enter critical section -----------------------------------------
      interrupts::critical_section ics;
 
      rtclock.internal_increment_count ();
      // ----- Exit critical section ------------------------------------------
    }
 
  rtclock.internal_check_timestamps ();
}
 
// ----------------------------------------------------------------------------
 
namespace os
{
  namespace rtos
  {
 
    // ========================================================================
 
    clock::~clock ()
    {
    }
 
    void
    clock::start (void)
    {
    }
 
    clock::timestamp_t
    clock::now (void)
    {
      // ----- Enter critical section -----------------------------------------
      interrupts::critical_section ics;
 
      // Prevent inconsistent values using the critical section.
      return steady_count_;
      // ----- Exit critical section ------------------------------------------
    }
 
    clock::timestamp_t
    clock::steady_now (void)
    {
      // ----- Enter critical section -----------------------------------------
      interrupts::critical_section ics;
 
      // Prevent inconsistent values using the critical section.
      return steady_count_;
      // ----- Exit critical section ------------------------------------------
    }
 
    result_t
    clock::sleep_for (duration_t duration)
    {
#if defined(OS_TRACE_RTOS_CLOCKS)
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wuseless-cast"
#endif
      trace::printf ("%s(%u) %p %s\n", __func__,
                     static_cast<unsigned int> (duration),
                     &this_thread::thread (), this_thread::thread ().name ());
#pragma GCC diagnostic pop
 
#endif // defined(OS_TRACE_RTOS_CLOCKS)
 
      // Don't call this from interrupt handlers.
      os_assert_err(!interrupts::in_handler_mode (), EPERM);
      // Don't call this from critical regions.
      os_assert_err(!scheduler::locked (), EPERM);
 
      clock::timestamp_t timestamp = steady_now () + duration;
      for (;;)
        {
          result_t res;
          res = internal_wait_until_ (timestamp, steady_list_);
 
          timestamp_t n = steady_now ();
          if (n >= timestamp)
            {
              return ETIMEDOUT;
            }
 
          if (this_thread::thread ().interrupted ())
            {
              return EINTR;
            }
 
          if (res != result::ok)
            {
              return res;
            }
        }
      return ENOTRECOVERABLE;
    }
 
    result_t
    clock::sleep_until (timestamp_t timestamp)
    {
#if defined(OS_TRACE_RTOS_CLOCKS)
      trace::printf ("%s()\n", __func__);
#endif
 
      // Don't call this from interrupt handlers.
      os_assert_err(!interrupts::in_handler_mode (), EPERM);
      // Don't call this from critical regions.
      os_assert_err(!scheduler::locked (), EPERM);
 
      for (;;)
        {
          result_t res;
          res = internal_wait_until_ (timestamp, steady_list_);
 
          timestamp_t nw = now ();
          if (nw >= timestamp)
            {
              return ETIMEDOUT;
            }
 
          if (this_thread::thread ().interrupted ())
            {
              return EINTR;
            }
 
          if (res != result::ok)
            {
              return res;
            }
        }
      return ENOTRECOVERABLE;
    }
 
    result_t
    clock::wait_for (duration_t timeout)
    {
#if defined(OS_TRACE_RTOS_CLOCKS)
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wuseless-cast"
#endif
      trace::printf ("%s(%u)\n", __func__, static_cast<unsigned int> (timeout));
#pragma GCC diagnostic pop
 
#endif // defined(OS_TRACE_RTOS_CLOCKS)
 
      // Don't call this from interrupt handlers.
      os_assert_err(!interrupts::in_handler_mode (), EPERM);
      // Don't call this from critical regions.
      os_assert_err(!scheduler::locked (), EPERM);
 
      clock::timestamp_t timestamp = steady_now () + timeout;
 
      result_t res;
      res = internal_wait_until_ (timestamp, steady_list_);
 
      timestamp_t nw = steady_now ();
      if (nw >= timestamp)
        {
          return ETIMEDOUT;
        }
 
      if (this_thread::thread ().interrupted ())
        {
          return EINTR;
        }
 
      return res;
    }
 
    clock::timestamp_t
    clock::update_for_slept_time (duration_t duration)
    {
      // ----- Enter critical section -----------------------------------------
      interrupts::critical_section ics;
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wdeprecated-volatile"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wvolatile"
#endif
      steady_count_ += duration;
#pragma GCC diagnostic pop
 
      internal_check_timestamps ();
      return steady_count_;
      // ----- Exit critical section ------------------------------------------
    }
 
    clock::offset_t
    clock::offset (void)
    {
      return 0;
    }
 
    clock::offset_t
    clock::offset (offset_t offset __attribute__((unused)))
    {
      return 0;
    }
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wsuggest-final-methods"
#pragma GCC diagnostic ignored "-Wsuggest-final-types"
#endif
    result_t
    clock::internal_wait_until_ (timestamp_t timestamp,
                                 internal::clock_timestamps_list& list)
    {
      thread& crt_thread = this_thread::thread ();
 
      // Prepare a list node pointing to the current thread.
      // Do not worry for being on stack, it is temporarily linked to the
      // list and guaranteed to be removed before this function returns.
      internal::timeout_thread_node node
        { timestamp, crt_thread };
 
        {
          // ----- Enter critical section -------------------------------------
          interrupts::critical_section ics;
 
          // Remove this thread from the ready list, if there.
          port::this_thread::prepare_suspend ();
 
          // Add this thread to the clock waiting list.
          list.link (node);
          crt_thread.clock_node_ = &node;
          crt_thread.state_ = thread::state::suspended;
          // ----- Exit critical section --------------------------------------
        }
 
      port::scheduler::reschedule ();
 
        {
          // ----- Enter critical section -------------------------------------
          interrupts::critical_section ics;
 
          // Remove the thread from the clock timeout list,
          // if not already removed by the timer.
          crt_thread.clock_node_ = nullptr;
          node.unlink ();
          // ----- Exit critical section --------------------------------------
        }
 
      return result::ok;
    }
#pragma GCC diagnostic pop
 
    // ========================================================================
    adjustable_clock::~adjustable_clock ()
    {
    }
 
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wsuggest-final-methods"
#endif
    clock::timestamp_t
    adjustable_clock::now (void)
    {
      // Prevent inconsistent values.
      // ----- Enter critical section -----------------------------------------
      interrupts::critical_section ics;
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wsign-conversion"
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Wsign-conversion"
#endif
      return steady_count_ + offset_;
#pragma GCC diagnostic pop
      // ----- Exit critical section ------------------------------------------
    }
#pragma GCC diagnostic pop
 
    result_t
    adjustable_clock::sleep_until (timestamp_t timestamp)
    {
#if defined(OS_TRACE_RTOS_CLOCKS)
      trace::printf ("%s()\n", __func__);
#endif
 
      // Don't call this from interrupt handlers.
      os_assert_err(!interrupts::in_handler_mode (), EPERM);
      // Don't call this from critical regions.
      os_assert_err(!scheduler::locked (), EPERM);
 
      for (;;)
        {
          result_t res;
          res = internal_wait_until_ (timestamp, adjusted_list_);
 
          timestamp_t nw = now ();
          if (nw >= timestamp)
            {
              return ETIMEDOUT;
            }
 
          if (this_thread::thread ().interrupted ())
            {
              return EINTR;
            }
 
          if (res != result::ok)
            {
              return res;
            }
        }
      return ENOTRECOVERABLE;
    }
 
    clock::offset_t
    adjustable_clock::offset (void)
    {
      return offset_;
    }
 
    clock::offset_t
    adjustable_clock::offset (offset_t value)
    {
      // ----- Enter critical section -----------------------------------------
      interrupts::critical_section ics;
 
      offset_t tmp;
      tmp = offset_;
      offset_ = value;
 
      return tmp;
      // ----- Exit critical section ------------------------------------------
    }
 
    // ========================================================================
 
    // ------------------------------------------------------------------------
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wglobal-constructors"
#pragma clang diagnostic ignored "-Wexit-time-destructors"
#endif
    clock_systick sysclock;
#pragma GCC diagnostic pop
 
    // ------------------------------------------------------------------------
 
    clock_systick::clock_systick () :
        clock
          { "sysclock" }
    {
    }
 
    clock_systick::~clock_systick ()
    {
    }
 
    void
    clock_systick::start (void)
    {
#if defined(OS_TRACE_RTOS_CLOCKS)
      trace::printf ("clock_systick::%s()\n", __func__);
#endif
      port::clock_systick::start ();
    }
 
    // ------------------------------------------------------------------------
 
#if defined(OS_USE_RTOS_PORT_CLOCK_SYSTICK_WAIT_FOR)
 
    result_t
    clock_systick::internal_wait_until_ (timestamp_t timestamp,
        internal::clock_timestamps_list& list __attribute__((unused)))
      {
        result_t res;
 
        timestamp_t nw = now ();
        if (nw >= timestamp)
          {
            return result::ok;
          }
        duration_t ticks = ((duration_t) (timestamp - nw));
        res = port::clock_systick::wait_for (ticks);
        return res;
      }
 
#endif /* defined(OS_USE_RTOS_PORT_CLOCK_SYSTICK_WAIT_FOR) */
 
    // ========================================================================
 
    // ------------------------------------------------------------------------
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wglobal-constructors"
#pragma clang diagnostic ignored "-Wexit-time-destructors"
#endif
    clock_rtc rtclock;
#pragma GCC diagnostic pop
 
    // ------------------------------------------------------------------------
 
    clock_rtc::clock_rtc () :
        adjustable_clock
          { "rtclock" }
    {
    }
 
    clock_rtc::~clock_rtc ()
    {
    }
 
    // ------------------------------------------------------------------------
 
    void
    clock_rtc::start (void)
    {
#if defined(OS_TRACE_RTOS_CLOCKS)
      trace::printf ("clock_rtc::%s()\n", __func__);
#endif
      // Don't call this from interrupt handlers.
      assert (!interrupts::in_handler_mode ());
 
      // TODO: Use the RTC driver to initialise the seconds to epoch.
    }
 
    // ========================================================================
 
#pragma GCC diagnostic push
#if defined(__clang__)
#pragma clang diagnostic ignored "-Wglobal-constructors"
#pragma clang diagnostic ignored "-Wexit-time-destructors"
#endif
    clock_highres hrclock;
#pragma GCC diagnostic pop
 
    // ------------------------------------------------------------------------
 
    clock_highres::clock_highres () :
        clock
          { "hrclock" }
    {
    }
 
    clock_highres::~clock_highres ()
    {
    }
 
    void
    clock_highres::start (void)
    {
#if defined(OS_TRACE_RTOS_CLOCKS)
      trace::printf ("clock_highres::%s()\n", __func__);
#endif
 
      port::clock_highres::start ();
    }
 
    clock::timestamp_t
    clock_highres::now (void)
    {
      // ----- Enter critical section -----------------------------------------
      interrupts::critical_section ics;
 
      return steady_count_ + port::clock_highres::cycles_since_tick ();
      // ----- Exit critical section ------------------------------------------
    }
 
  // --------------------------------------------------------------------------
 
  } /* namespace rtos */
} /* namespace os */
 
// ----------------------------------------------------------------------------