time.h

Go to the documentation of this file.

//   Copyright 2016-2023 Jean-Francois Poilpret
//
//   Licensed under the Apache License, Version 2.0 (the "License");
//   you may not use this file except in compliance with the License.
//   You may obtain a copy of the License at
//
//       http://www.apache.org/licenses/LICENSE-2.0
//
//   Unless required by applicable law or agreed to in writing, software
//   distributed under the License is distributed on an "AS IS" BASIS,
//   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//   See the License for the specific language governing permissions and
//   limitations under the License.
 
 
#ifndef TIME_HH
#define TIME_HH
 
#include <stdint.h>
#include "boards/io.h"
#include <util/delay_basic.h>
#include "utilities.h"
 
namespace time
{
    // Forward declaration to avoid compilation error
    class RTTTime;
    inline RTTTime operator-(const RTTTime& a, const RTTTime& b);
 
    class RTTTime
    {
    public:
        explicit RTTTime(uint32_t micros = 0UL) : millis_(micros / ONE_MILLI_32), micros_(micros % ONE_MILLI_32) {}
 
        RTTTime(uint32_t millis, uint16_t micros) : millis_(millis), micros_(micros) {}
 
        RTTTime(const RTTTime& that) : millis_{that.millis_}, micros_{that.micros_} {}
 
        RTTTime& operator=(const RTTTime& that)
        {
            if (this != &that)
            {
                millis_ = that.millis_;
                micros_ = that.micros_;
            }
            return *this;
        }
 
        RTTTime& operator+=(uint32_t microseconds)
        {
            uint32_t extra_millis = microseconds / ONE_MILLI_32;
            uint16_t extra_micros = microseconds % ONE_MILLI_32;
            millis_ += extra_millis;
            micros_ += extra_micros;
            if (micros_ >= ONE_MILLI_16)
            {
                ++millis_;
                micros_ -= ONE_MILLI_16;
            }
            return *this;
        }
 
        RTTTime& operator-=(uint32_t microseconds)
        {
            return *this = (*this - RTTTime{microseconds});
        }
 
        uint32_t total_micros() const
        {
            return millis_ * ONE_MILLI_32 + micros_;
        }
 
        uint32_t millis() const
        {
            return millis_;
        }
 
        uint16_t micros() const
        {
            return micros_;
        }
 
    private:
        uint32_t millis_;
        uint16_t micros_;
    };
 
    inline bool operator>(const RTTTime& a, const RTTTime& b)
    {
        if (a.millis() > b.millis()) return true;
        if (a.millis() < b.millis()) return false;
        return a.micros() > b.micros();
    }
 
    inline bool operator>=(const RTTTime& a, const RTTTime& b)
    {
        if (a.millis() > b.millis()) return true;
        if (a.millis() < b.millis()) return false;
        return a.micros() >= b.micros();
    }
 
    inline bool operator<(const RTTTime& a, const RTTTime& b)
    {
        if (a.millis() < b.millis()) return true;
        if (a.millis() > b.millis()) return false;
        return a.micros() < b.micros();
    }
 
    inline bool operator<=(const RTTTime& a, const RTTTime& b)
    {
        if (a.millis() < b.millis()) return true;
        if (a.millis() > b.millis()) return false;
        return a.micros() <= b.micros();
    }
 
    inline bool operator==(const RTTTime& a, const RTTTime& b)
    {
        return (a.millis() == b.millis()) && (a.micros() == b.micros());
    }
 
    inline bool operator!=(const RTTTime& a, const RTTTime& b)
    {
        return (a.millis() != b.millis()) || (a.micros() != b.micros());
    }
 
    inline RTTTime operator+(const RTTTime& a, const RTTTime& b)
    {
        uint32_t millis = a.millis() + b.millis();
        uint16_t micros = a.micros() + b.micros();
        if (micros >= ONE_MILLI_16)
        {
            ++millis;
            micros -= ONE_MILLI_16;
        }
        return RTTTime{millis, micros};
    }
 
    inline RTTTime operator-(const RTTTime& a, const RTTTime& b)
    {
        if (a <= b) return RTTTime{0, 0};
        uint32_t millis = a.millis() - b.millis();
        if (a.micros() >= b.micros()) return RTTTime{millis, a.micros() - b.micros()};
        return RTTTime{millis - 1, ONE_MILLI_16 + a.micros() - b.micros()};
    }
 
    void yield();
 
    RTTTime delta(const RTTTime& time1, const RTTTime& time2);
 
    uint32_t since(uint32_t start_ms);
 
    using DELAY_PTR = void (*)(uint32_t ms);
 
    extern DELAY_PTR delay;
 
    using MILLIS_PTR = uint32_t (*)();
 
    extern MILLIS_PTR millis;
 
    inline void delay_us(uint16_t us) INLINE;
    inline void delay_us(uint16_t us)
    {
        _delay_loop_2(us * INST_PER_US / 4UL);
    }
 
    inline void delay_ms(uint16_t ms) INLINE;
    inline void delay_ms(uint16_t ms)
    {
        while (ms--) delay_us(ONE_MILLI_16);
    }
 
    void default_delay(uint32_t ms);
 
    template<typename CLOCK> class ClockDelegate
    {
        using TYPE = ClockDelegate<CLOCK>;
 
    public:
        ClockDelegate() = delete;
 
        static void set_clock(const CLOCK& clock)
        {
            clock_ = &clock;
            time::delay = TYPE::delay;
            time::millis = TYPE::millis;
        }
 
        static void delay(uint32_t ms)
        {
            clock_->delay(ms);
        }
 
        static uint32_t millis()
        {
            return clock_->millis();
        }
 
    private:
        static const CLOCK* clock_;
    };
 
    template<typename CLOCK> const CLOCK* ClockDelegate<CLOCK>::clock_ = nullptr;
 
    template<typename CLOCK> void set_clock(const CLOCK& clock)
    {
        time::ClockDelegate<CLOCK>::set_clock(clock);
    }
 
    class auto_delay
    {
    public:
        auto_delay(const auto_delay&) = delete;
        auto_delay& operator=(const auto_delay&) = delete;
 
        explicit auto_delay(DELAY_PTR new_delay) INLINE
        {
            delay = new_delay;
        }
        ~auto_delay() INLINE
        {
            delay = old_delay_;
        }
    private:
        const DELAY_PTR old_delay_ = delay;
    };
 
    class auto_millis
    {
    public:
        auto_millis(const auto_millis&) = delete;
        auto_millis& operator=(const auto_millis&) = delete;
        
        explicit auto_millis(MILLIS_PTR new_millis) INLINE
        {
            millis = new_millis;
        }
        ~auto_millis() INLINE
        {
            millis = old_millis_;
        }
    private:
        const MILLIS_PTR old_millis_ = millis;
    };
};
 
#endif /* TIME_HH */