timeref.h

Go to the documentation of this file.

// Copyright 2021-2025 The Aerospace Corporation.
// This file is a part of SatCat5, licensed under CERN-OHL-W v2 or later.
 
#pragma once
 
#include <satcat5/types.h>
#include <satcat5/utils.h>
 
namespace satcat5 {
    namespace util {
        struct TimeVal {
            TimeRef* clk;   
            u32 tval;       
 
            // Explicitly declare default constructor and assignment methods.
            TimeVal() = delete;
            TimeVal(const TimeVal& t) = default;
            TimeVal& operator=(const TimeVal& t) = default;
 
            unsigned elapsed_tick() const;
            unsigned elapsed_usec() const;
            unsigned elapsed_msec() const;
 
            unsigned increment_usec();
 
            unsigned increment_msec();
 
            bool interval_tick(u32 ticks);
            bool interval_usec(unsigned usec);
            bool interval_msec(unsigned msec);
 
            bool checkpoint_elapsed();
        };
 
        class TimeRef {
        protected:
            explicit constexpr TimeRef(u64 ticks_per_sec)
                : m_msec_per_tick(div_ceil<u64>(   1000ull << 32, ticks_per_sec))
                , m_usec_per_tick(div_ceil<u64>(1000000ull << 32, ticks_per_sec))
                , m_tick_per_msec(div_round<u64>(ticks_per_sec << 32,    1000ull))
                , m_tick_per_usec(div_round<u64>(ticks_per_sec << 32, 1000000ull))
                {}  // No other initialization required.
            ~TimeRef() {}
 
        private:
            friend satcat5::util::TimeVal;
 
            // Fixed-point scaling for conversion to/from engineering units.
            // (Internal use only, format is subject to change at any time.)
            u64 const m_msec_per_tick;   // 2^32 * 1K / FT
            u64 const m_usec_per_tick;   // 2^32 * 1M / FT
            u64 const m_tick_per_msec;   // 2^32 * FT / 1K
            u64 const m_tick_per_usec;   // 2^32 * FT / 1M
 
        public:
            virtual u32 raw() = 0;
 
            TimeVal now();
 
            inline u32 ticks_per_sec() const
                { return u32((1000 * m_tick_per_msec) >> 32); }
            inline u32 ticks_per_msec() const
                { return u32(m_tick_per_msec >> 32); }
            inline u32 ticks_per_usec() const
                { return u32(m_tick_per_usec >> 32); }
 
            TimeVal checkpoint_usec(unsigned usec);
            TimeVal checkpoint_msec(unsigned msec);
 
            void busywait_usec(unsigned usec);
        };
 
        class NullTimer : public satcat5::util::TimeRef {
        public:
            constexpr NullTimer() : TimeRef(1) {}
            u32 raw() override {return 0;}
        };
 
        class TimeRegister final : public satcat5::util::TimeRef {
        public:
            constexpr TimeRegister(volatile u32* reg, u32 clkref_hz)
                : TimeRef(clkref_hz), m_reg(reg) {}
            ~TimeRegister() {}
 
            u32 raw() override;     // Return counter register value
 
        private:
            volatile u32* m_reg;    // Pointer to the counter register
        };
    }
}