timer.h

Go to the documentation of this file.

/*===========================================================================
     _____        _____        _____        _____
 ___|    _|__  __|_    |__  __|__   |__  __| __  |__  ______
|    \  /  | ||    \      ||     |     ||  |/ /     ||___   |
|     \/   | ||     \     ||     \     ||     \     ||___   |
|__/\__/|__|_||__|\__\  __||__|\__\  __||__|\__\  __||______|
    |_____|      |_____|      |_____|      |_____|

--[Mark3 Realtime Platform]--------------------------------------------------

Copyright (c) 2012 - 2019 m0slevin, all rights reserved.
See license.txt for more information
=========================================================================== */
#pragma once
#include "kerneltypes.h"
#include "mark3cfg.h"

#include "ll.h"

namespace Mark3
{
class Thread;

//---------------------------------------------------------------------------
static constexpr auto uMaxTimerTicks     = uint32_t { 0x7FFFFFFF }; 
static constexpr auto uTimerTicksInvalid = uint32_t { 0 };
static constexpr auto uTimerFlagOneShot  = uint8_t { 0x01 }; 
static constexpr auto uTimerFlagActive   = uint8_t { 0x02 }; 
static constexpr auto uTimerFlagCallback = uint8_t { 0x04 }; 
static constexpr auto uTimerFlagExpired  = uint8_t { 0x08 }; 

//---------------------------------------------------------------------------
using TimerCallback = void (*)(Thread* pclOwner_, void* pvData_);

//---------------------------------------------------------------------------
class TimerList;
class TimerScheduler;
class Quantum;

//---------------------------------------------------------------------------
class Timer : public TypedLinkListNode<Timer>
{
public:
    void* operator new(size_t sz, void* pv) { return reinterpret_cast<Timer*>(pv); }
    ~Timer() {}

    Timer();

    void Init();

    void Start(bool bRepeat_, uint32_t u32IntervalMs_, TimerCallback pfCallback_, void* pvData_);

    void Start();

    void Stop();

private:
    friend class TimerList;

    void SetInitialized() { m_u8Initialized = m_uTimerInitCookie; }

    bool IsInitialized(void) { return (m_u8Initialized == m_uTimerInitCookie); }

    static inline uint32_t SecondsToTicks(uint32_t x) { return (x) * 1000; }
    static inline uint32_t MSecondsToTicks(uint32_t x) { return (x); }
    static inline uint32_t USecondsToTicks(uint32_t x) { return ((x + 999) / 1000); }

    static constexpr auto m_uTimerInvalidCookie = uint8_t { 0x3C };
    static constexpr auto m_uTimerInitCookie    = uint8_t { 0xC3 };

    uint8_t m_u8Initialized;

    uint8_t m_u8Flags;

    TimerCallback m_pfCallback;

    uint32_t m_u32Interval;

    uint32_t m_u32TimeLeft;

    Thread* m_pclOwner;

    void* m_pvData;
};
} // namespace Mark3