timer.hpp

Go to the documentation of this file.

/*
 *  Copyright (c) 2016, The OpenThread Authors.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the copyright holder nor the
 *     names of its contributors may be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef TIMER_HPP_
#define TIMER_HPP_

#include "openthread-core-config.h"

#include <stddef.h>
#include "utils/wrap_stdint.h"

#include <openthread/types.h>
#include <openthread/platform/alarm-micro.h>
#include <openthread/platform/alarm-milli.h>

#include "common/context.hpp"
#include "common/debug.hpp"
#include "common/locator.hpp"
#include "common/tasklet.hpp"

namespace ot {

class TimerMilliScheduler;

class Timer: public InstanceLocator, public Context
{
    friend class TimerScheduler;

public:

    enum
    {
        kMaxDt = (1UL << 31) - 1,  //< Maximum permitted value for parameter `aDt` in `Start` and `StartAt` method.
    };

    typedef void (*Handler)(Timer &aTimer);

    Timer(otInstance &aInstance, Handler aHandler, void *aContext):
        InstanceLocator(aInstance),
        Context(aContext),
        mHandler(aHandler),
        mFireTime(0),
        mNext(this) {
    }

    uint32_t GetFireTime(void) const { return mFireTime; }

    bool IsRunning(void) const { return (mNext != this); }

protected:
    bool DoesFireBefore(const Timer &aTimer, uint32_t aNow);

    void Fired(void) { mHandler(*this); }

    Handler   mHandler;
    uint32_t  mFireTime;
    Timer     *mNext;
};

class TimerMilli: public Timer
{
public:
    TimerMilli(otInstance &aInstance, Handler aHandler, void *aContext):
        Timer(aInstance, aHandler, aContext) {
    }

    void Start(uint32_t aDt) { StartAt(GetNow(), aDt); }

    void StartAt(uint32_t aT0, uint32_t aDt);

    void Stop(void);

    static uint32_t GetNow(void) { return otPlatAlarmMilliGetNow(); }

    static uint32_t SecToMsec(uint32_t aSeconds) { return aSeconds * 1000u; }

    static uint32_t MsecToSec(uint32_t aMilliseconds) { return aMilliseconds / 1000u; }

private:
    TimerMilliScheduler &GetTimerMilliScheduler(void) const;
};


class TimerScheduler: public InstanceLocator
{
    friend class Timer;

protected:
    struct AlarmApi
    {
        void (*AlarmStartAt)(otInstance *aInstance, uint32_t aT0, uint32_t aDt);
        void (*AlarmStop)(otInstance *aInstance);
        uint32_t (*AlarmGetNow)(void);
    };

    TimerScheduler(otInstance &aInstance):
        InstanceLocator(aInstance),
        mHead(NULL) {
    }

    void Add(Timer &aTimer, const AlarmApi &aAlarmApi);

    void Remove(Timer &aTimer, const AlarmApi &aAlarmApi);

    void ProcessTimers(const AlarmApi &aAlarmApi);

    void SetAlarm(const AlarmApi &aAlarmApi);

    static bool IsStrictlyBefore(uint32_t aTimeA, uint32_t aTimeB);

    Timer *mHead;
};

class TimerMilliScheduler: public TimerScheduler
{
public:
    TimerMilliScheduler(otInstance &aInstance):
        TimerScheduler(aInstance) {
    }

    void Add(TimerMilli &aTimer) { TimerScheduler::Add(aTimer, sAlarmMilliApi); }

    void Remove(TimerMilli &aTimer) { TimerScheduler::Remove(aTimer, sAlarmMilliApi); };

    void ProcessTimers(void) { TimerScheduler::ProcessTimers(sAlarmMilliApi); }

private:
    static const AlarmApi sAlarmMilliApi;
};

#if OPENTHREAD_CONFIG_ENABLE_PLATFORM_USEC_TIMER
class TimerMicroScheduler;

class TimerMicro: public Timer
{
public:
    TimerMicro(otInstance &aInstance, Handler aHandler, void *aContext):
        Timer(aInstance, aHandler, aContext) {
    }

    void Start(uint32_t aDt) { StartAt(GetNow(), aDt); }

    void StartAt(uint32_t aT0, uint32_t aDt);

    void Stop(void);

    static uint32_t GetNow(void) { return otPlatAlarmMicroGetNow(); }

private:
    TimerMicroScheduler &GetTimerMicroScheduler(void) const;
};

class TimerMicroScheduler: public TimerScheduler
{
public:
    TimerMicroScheduler(otInstance &aInstance):
        TimerScheduler(aInstance) {
    }

    void Add(TimerMicro &aTimer) { TimerScheduler::Add(aTimer, sAlarmMicroApi); }

    void Remove(TimerMicro &aTimer) { TimerScheduler::Remove(aTimer, sAlarmMicroApi); };

    void ProcessTimers(void) { TimerScheduler::ProcessTimers(sAlarmMicroApi); }

private:
    static const AlarmApi sAlarmMicroApi;
};
#endif // OPENTHREAD_CONFIG_ENABLE_PLATFORM_USEC_TIMER

}  // namespace ot

#endif  // TIMER_HPP_