class CslTxScheduler : public InstanceLocator, private NonCopyable { friend class Mac::Mac; friend class IndirectSender; public: static constexpr uint8_t kMaxCslTriggeredTxAttempts = OPENTHREAD_CONFIG_MAC_MAX_TX_ATTEMPTS_INDIRECT_POLLS; class ChildInfo { public: uint8_t GetCslTxAttempts(void) const { return mCslTxAttempts; } void IncrementCslTxAttempts(void) { mCslTxAttempts++; } void ResetCslTxAttempts(void) { mCslTxAttempts = 0; } bool IsCslSynchronized(void) const { return mCslSynchronized && mCslPeriod > 0; } void SetCslSynchronized(bool aCslSynchronized) { mCslSynchronized = aCslSynchronized; } uint8_t GetCslChannel(void) const { return mCslChannel; } void SetCslChannel(uint8_t aChannel) { mCslChannel = aChannel; } uint32_t GetCslTimeout(void) const { return mCslTimeout; } void SetCslTimeout(uint32_t aTimeout) { mCslTimeout = aTimeout; } uint16_t GetCslPeriod(void) const { return mCslPeriod; } void SetCslPeriod(uint16_t aPeriod) { mCslPeriod = aPeriod; } uint16_t GetCslPhase(void) const { return mCslPhase; } void SetCslPhase(uint16_t aPhase) { mCslPhase = aPhase; } TimeMilli GetCslLastHeard(void) const { return mCslLastHeard; } void SetCslLastHeard(TimeMilli aCslLastHeard) { mCslLastHeard = aCslLastHeard; } uint64_t GetLastRxTimestamp(void) const { return mLastRxTimestamp; } void SetLastRxTimestamp(uint64_t aLastRxTimestamp) { mLastRxTimestamp = aLastRxTimestamp; } private: uint8_t mCslTxAttempts : 7; bool mCslSynchronized : 1; uint8_t mCslChannel; uint32_t mCslTimeout; uint16_t mCslPeriod; uint16_t mCslPhase; TimeMilli mCslLastHeard; uint64_t mLastRxTimestamp; static_assert(kMaxCslTriggeredTxAttempts < (1 << 7), "mCslTxAttempts cannot fit max!"); }; class Callbacks : public InstanceLocator { friend class CslTxScheduler; private: typedef IndirectSenderBase::FrameContext FrameContext; explicit Callbacks(Instance &aInstance); Error PrepareFrameForChild(Mac::TxFrame &aFrame, FrameContext &aContext, Child &aChild); void HandleSentFrameToChild(const Mac::TxFrame &aFrame, const FrameContext &aContext, Error aError, Child &aChild); }; explicit CslTxScheduler(Instance &aInstance); void Update(void); void Clear(void); void UpdateFrameRequestAhead(void); private: static constexpr uint32_t kFramePreparationGuardInterval = 1500; void RescheduleCslTx(void); uint32_t GetNextCslTransmissionDelay(const Child &aChild, uint32_t &aDelayFromLastRx, uint32_t aAheadUs) const; Mac::TxFrame *HandleFrameRequest(Mac::TxFrames &aTxFrames); void HandleSentFrame(const Mac::TxFrame &aFrame, Error aError); void HandleSentFrame(const Mac::TxFrame &aFrame, Error aError, Child &aChild); uint32_t mCslFrameRequestAheadUs; Child *mCslTxChild; Message *mCslTxMessage; Callbacks::FrameContext mFrameContext; Callbacks mCallbacks; };

Fields

Field

Declared as

ot::CslTxScheduler::kMaxCslTriggeredTxAttempts

ot::CslTxScheduler::kFramePreparationGuardInterval

ot::CslTxScheduler::mCslFrameRequestAheadUs

uint32_t

ot::CslTxScheduler::mCslTxChild

Child *

ot::CslTxScheduler::mCslTxMessage

Message *

ot::CslTxScheduler::mFrameContext

Callbacks::FrameContext

ot::CslTxScheduler::mCallbacks

Callbacks

Methods

Update()

Updates the next CSL transmission (finds the nearest child). It would then request the `Mac` to do the CSL tx. If the last CSL tx has been fired at `Mac` but hasn't been done yet, and it's aborted, this method would set `mCslTxChild` to `nullptr` to notify the `HandleTransmitDone` that the operation has been aborted.

Clear()

Clears all the states inside `CslTxScheduler` and the related states in each child.

UpdateFrameRequestAhead()

Updates the value of `mCslFrameRequestAheadUs`, based on bus speed, bus latency and `OPENTHREAD_CONFIG_MAC_CSL_REQUEST_AHEAD_US`.

RescheduleCslTx()

Always finds the most recent CSL tx among all children, and requests `Mac` to do CSL tx at specific time. It shouldn't be called when `Mac` is already starting to do the CSL tx (indicated by `mCslTxMessage`).