ot::TrickleTimer class

Implements a trickle timer.

Syntax

Show:

Summary

Declaration

from trickle_timer.hpp:56

class TrickleTimer : public TimerMilli { friend class TrickleTimerTester; public: enum Mode : uint8_t { kModeTrickle, kModePlainTimer, }; static constexpr uint16_t kInfiniteRedundancyConstant = NumericLimits<uint16_t>::kMax; typedef void (&Handler)(TrickleTimer &aTimer); TrickleTimer(Instance &aInstance, Handler aHandler); bool IsRunning(void) const { return TimerMilli::IsRunning(); } Mode GetMode(void) const { return mMode; } uint32_t GetIntervalMin(void) const { return mIntervalMin; } void SetIntervalMin(uint32_t aIntervalMin); uint32_t GetIntervalMax(void) const { return mIntervalMax; } void SetIntervalMax(uint32_t aIntervalMax); void Start(Mode aMode, uint32_t aIntervalMin, uint32_t aIntervalMax, uint16_t aRedundancyConstant = kInfiniteRedundancyConstant); void Stop(void) { TimerMilli::Stop(); } void IndicateConsistent(void); void IndicateInconsistent(void); private: enum Phase : uint8_t { kBeforeRandomTime, kAfterRandomTime, }; void StartNewInterval(void); static void HandleTimer(Timer &aTimer); void HandleTimer(void); void HandleEndOfTimeInInterval(void); void HandleEndOfInterval(void); TimeMilli GetStartTimeOfCurrentInterval(void) const; void StartAt(void) {} void FireAt(void) {} void FireAtIfEarlier(void) {} void GetFireTime(void) {} uint32_t mIntervalMin; uint32_t mIntervalMax; uint32_t mInterval; uint32_t mTimeInInterval; uint16_t mRedundancyConstant; uint16_t mCounter; Handler mHandler; Mode mMode; Phase mPhase; };

Fields

Field

Description

Declared as

ot::TrickleTimer::kInfiniteRedundancyConstant

Special value for redundancy constant (aka `k`) to indicate infinity (when used, it disables trickle timer's suppression behavior, invoking the handler callback independent of number of "consistent" events).

ot::TrickleTimer::mIntervalMin

uint32_t

ot::TrickleTimer::mIntervalMax

uint32_t

ot::TrickleTimer::mInterval

uint32_t

ot::TrickleTimer::mTimeInInterval

uint32_t

ot::TrickleTimer::mRedundancyConstant

uint16_t

ot::TrickleTimer::mCounter

uint16_t

ot::TrickleTimer::mHandler

Handler

ot::TrickleTimer::mMode

Mode

ot::TrickleTimer::mPhase

Phase

Methods

IsRunning() const

Indicates whether or not the trickle timer instance is running.

GetMode() const

Gets the current operation mode of the trickle timer.

GetIntervalMin() const

Gets the interval min value of the trickle timer.

SetIntervalMin()

Sets the interval min value of the trickle timer while timer is running. If @p aIntervalMin is smaller than the current `GetIntervalMax()` the interval max value is also updated to the new @p aIntervalMin (as if `SetIntervalMax(aIntervalMin)` was called).

GetIntervalMax() const

Gets the interval max value of the trickle timer.

SetIntervalMax()

Sets the interval max value of the trickle timer while timer is running. If the given @p aIntervalMax is smaller than the current `GetIntervalMin()`, the interval min value will be used instead.

Start()

This method starts the trickle timer.

Stop()

Stops the trickle timer.

IndicateConsistent()

Indicates to the trickle timer a 'consistent' event. The 'consistent' events are used to control suppression behavior. The trickle timer keeps track of the number of 'consistent' events in each interval. The timer handler is invoked only if the number of `consistent` events received in the interval is less than the redundancy constant.

IndicateInconsistent()

Indicates to the trickle timer an 'inconsistent' event. Receiving an 'inconsistent' event causes the trickle timer to reset (i.e., start with interval set to the min value) unless the current interval being used is already equal to the min interval.