clock.hpp

Go to the documentation of this file.

/* SPDX-License-Identifier: Apache-2.0 */
/* Copyright 2015-2019 Peter A. Bigot */
 
#ifndef NRFCXX_CLOCK_HPP
#define NRFCXX_CLOCK_HPP
#pragma once
 
#include <chrono>
#include <functional>
 
#include <nrfcxx/impl.hpp>
#include <nrfcxx/periph.hpp>
 
namespace nrfcxx {
 
namespace clock {
 
class hfclk
{
  hfclk () = delete;
  ~hfclk () = delete;
  hfclk (const hfclk&) = delete;
  hfclk& operator= (const hfclk&) = delete;
  hfclk (hfclk&& ) = delete;
  hfclk& operator= (hfclk&) = delete;
 
protected:
 
  friend class periph::TIMER;
 
  static void constlat_request (const periph::TIMER& timer,
                                bool enable);
 
public:
 
  constexpr static unsigned int Frequency_Hz = 16'000'000;
 
  static bool hfxt_active ()
  {
    return ((CLOCK_HFCLKSTAT_SRC_Xtal << CLOCK_HFCLKSTAT_SRC_Pos)
            == (nrf5::CLOCK->HFCLKSTAT & CLOCK_HFCLKSTAT_SRC_Msk));
  }
 
  static bool hfxt_configure (int on);
};
 
class lfclk
{
  lfclk () = delete;
  ~lfclk () = delete;
  lfclk (const lfclk&) = delete;
  lfclk& operator= (const lfclk&) = delete;
  lfclk (lfclk&& ) = delete;
  lfclk& operator= (lfclk&) = delete;
 
public:
 
  constexpr static unsigned int Frequency_Hz = 32768U;
 
  constexpr static unsigned int DefaultRCOCalInterval_qs = 4 * 4;
 
  static bool active ()
  {
    return ((CLOCK_LFCLKSTAT_STATE_Running << CLOCK_LFCLKSTAT_STATE_Pos)
            == (nrf5::CLOCK->LFCLKSTAT & CLOCK_LFCLKSTAT_STATE_Msk));
  }
 
  static int configure (int on);
 
  static uint32_t source ()
  {
    return (nrf5::CLOCK->LFCLKSTAT & CLOCK_LFCLKSTAT_SRC_Msk) >> CLOCK_LFCLKSTAT_SRC_Pos;
  }
 
  static int source_configure (int src,
                               unsigned cal_interval_qs = DefaultRCOCalInterval_qs);
};
 
int initialize (bool enable_hfxt = false,
                int lfclk_src = board::default_lfclk_src(),
                unsigned int lfrc_cal_interval_qs = lfclk::DefaultRCOCalInterval_qs);
 
bool configure_pcirq (int on);
 
class uptime
{
public:
  constexpr static unsigned int Frequency_Hz = 32768;
 
  using mutex_type = mutex_irq<static_cast<IRQn_Type>(nrf5::UPTIME_RTC.IRQn)>;
 
  using duration_type = std::chrono::duration<int64_t, std::ratio<1, Frequency_Hz>>;
 
  using text_type = char[13];
 
  using day_text_type = char[18];
 
  static const char* as_text (text_type buf,
                              uint64_t dur_utt);
 
  static const char* as_day_text (day_text_type buf,
                                  uint64_t dur_utt,
                                  bool with_msec = false);
 
  static unsigned int now24 ()
  {
    return nrf5::UPTIME_RTC->COUNTER;
  }
 
  constexpr static unsigned int delta24 (unsigned int a,
                                         unsigned int b)
  {
    /* This relies on standard semantics for unsigned subtraction to
     * handle the case where b < a. */
    return periph::RTC::counter_mask & (b - a);
  }
 
  class timestamp24
  {
  protected:
    unsigned int capture_utt24;
 
  public:
    timestamp24 () :
      capture_utt24{now24()}
    { }
 
    unsigned int captured () const
    {
      return capture_utt24;
    }
 
    void reset ()
    {
      capture_utt24 = now24();
    }
 
    unsigned int delta () const
    {
      auto now_utt24 = now24();
      return delta24(capture_utt24, now_utt24);
    }
 
    unsigned int delta (unsigned int tick) const
    {
      return delta24(capture_utt24, tick);
    }
 
    unsigned int delta_reset ()
    {
      auto now_utt24 = now24();
      auto rv = delta24(capture_utt24, now_utt24);
      capture_utt24 = now_utt24;
      return rv;
    }
  };
 
  static uint64_t now ();
 
  template <typename DurT>
  constexpr static DurT to_duration (int64_t utt)
  {
    return std::chrono::duration_cast<DurT>(duration_type(utt));
  }
 
  template <typename DurT>
  constexpr static typename duration_type::rep from_duration (DurT dur)
  {
    return std::chrono::duration_cast<duration_type>(dur).count();
  }
 
  constexpr static int64_t to_us (int64_t utt)
  {
    return to_duration<std::chrono::microseconds>(utt).count();
  }
 
  constexpr static int64_t from_us (int64_t us)
  {
    return from_duration(std::chrono::microseconds(us));
  }
 
  constexpr static int64_t to_ms (int64_t utt)
  {
    return to_duration<std::chrono::milliseconds>(utt).count();
  }
 
  constexpr static int64_t from_ms (int64_t ms)
  {
    return from_duration(std::chrono::milliseconds(ms));
  }
 
  static int sleep (int dur);
 
  template <typename DurT,
            typename DurT::rep = 0>
  static DurT sleep (DurT dur)
  {
    return to_duration<DurT>(sleep(from_duration(dur)));
  }
 
  static void wakeup ();
};
 
constexpr uptime::duration_type
operator"" _utt (unsigned long long n)
{
  return uptime::duration_type(n);
}
 
class alarm
{
public:
  using mutex_type = uptime::mutex_type;
 
  enum state_type
  {
    ST_unscheduled,
 
    ST_scheduled,
 
    ST_ready,
 
    ST_in_callback,
 
    ST_cancelled,
  };
 
  state_type state () const
  {
    return state_;
  }
 
  bool active () const
  {
    auto const s = state();
    return (ST_scheduled <= s) && (s <= ST_in_callback);
  }
 
  using callback_type = std::function<bool(alarm& alarm)>;
 
  /* You can't move or copy these. */
  alarm (const alarm&) = delete;
  alarm& operator= (const alarm&) = delete;
  alarm (alarm&&) = delete;
  alarm& operator= (alarm&&) = delete;
 
  alarm (callback_type callback,
         unsigned int interval = 0,
         void* md = 0) :
    callback_{callback},
    interval_{interval},
    metadata{md}
  { }
 
  alarm (callback_type callback,
         void* md) :
    alarm{callback, 0, md}
  { }
 
  template <event_set::event_type EVT,
            bool reschedule = false>
  static alarm for_event (event_set& events)
  {
    return {[&events](auto&){
        events.set(EVT);
        return reschedule;
      }};
  }
 
  template <typename DurT,
            typename DurT::rep = 0>
  constexpr alarm (callback_type callback,
                   DurT interval,
                   void* md = 0) :
  alarm(callback, uptime::from_duration(interval), md)
  { }
 
  ~alarm ()
  {
    cancel();
  }
 
  void schedule ();
 
  void schedule_offset (int offset);
 
  template <typename DurT>
  void schedule_offset (DurT offset)
  {
    return schedule_offset(uptime::from_duration(offset));
  }
 
  state_type cancel ();
 
  unsigned int
  interval () const
  {
    return interval_;
  }
 
  alarm& set_interval (unsigned int interval)
  {
    interval_ = interval;
    return *this;
  }
 
  template <typename DurT,
            typename DurT::rep = 0>
  alarm& set_interval (DurT interval)
  {
    return set_interval(uptime::from_duration(interval));
  }
 
  unsigned int
  deadline () const
  {
    return deadline_;
  }
 
  alarm& set_deadline (unsigned int deadline)
  {
    deadline_ = deadline;
    return *this;
  }
 
protected:
  struct alarm_queue;
  friend alarm_queue;
  friend void ::RTC1_IRQHandler();
  int ordinal_ (unsigned int now) const noexcept
  {
    return deadline_ - now;
  }
 
  callback_type const callback_;
  unsigned int deadline_ = 0;
  unsigned int interval_;
  state_type volatile state_ = ST_unscheduled;
  alarm* next_ = nullptr;
  static alarm_queue queue_;
 
public:
  void* const metadata;
};
 
class clock_shift
{
public:
  using time_type = uint64_t;
 
  using diff_type = std::make_signed<time_type>::type;
 
  static constexpr unsigned int RATE_DENOM = (1U << 16);
 
  void update_sync (time_type now_ctt,
                    time_type now_utt) noexcept;
 
  bool synchronized () const noexcept
  {
    return (0 != sync_ctt_);
  }
 
  time_type convert_ctt (time_type now_utt) noexcept;
 
  unsigned int rate () const noexcept
  {
    return rate_;
  }
 
  time_type offset () const noexcept
  {
    return sync_ctt_ - sync_utt_;
  }
 
private:
  time_type sync_ctt_{};
  time_type sync_utt_{};
  unsigned int rate_ = RATE_DENOM;
};
 
} // namespace clock
} // namespace nrfcxx
 
#endif /* NRFCXX_CLOCK_HPP */