ot::DataPollHandler class

Implements the data poll (mac data request command) handler.

Syntax

Show:

Summary

Declaration

from data_poll_handler.hpp:65

class DataPollHandler : public InstanceLocator, private NonCopyable { friend class Mac::Mac; public: static constexpr uint8_t kMaxPollTriggeredTxAttempts = OPENTHREAD_CONFIG_MAC_MAX_TX_ATTEMPTS_INDIRECT_POLLS; enum FrameChange : uint8_t { kPurgeFrame, kReplaceFrame, }; class ChildInfo { friend class DataPollHandler; #if OPENTHREAD_FTD && OPENTHREAD_CONFIG_MAC_CSL_TRANSMITTER_ENABLE friend class CslTxScheduler; #endif private: bool IsDataPollPending(void) const { return mDataPollPending; } void SetDataPollPending(bool aPending) { mDataPollPending = aPending; } uint32_t GetIndirectFrameCounter(void) const { return mIndirectFrameCounter; } void SetIndirectFrameCounter(uint32_t aFrameCounter) { mIndirectFrameCounter = aFrameCounter; } uint8_t GetIndirectKeyId(void) const { return mIndirectKeyId; } void SetIndirectKeyId(uint8_t aKeyId) { mIndirectKeyId = aKeyId; } uint8_t GetIndirectTxAttempts(void) const { return mIndirectTxAttempts; } void ResetIndirectTxAttempts(void) { mIndirectTxAttempts = 0; } void IncrementIndirectTxAttempts(void) { mIndirectTxAttempts++; } uint8_t GetIndirectDataSequenceNumber(void) const { return mIndirectDsn; } void SetIndirectDataSequenceNumber(uint8_t aDsn) { mIndirectDsn = aDsn; } bool IsFramePurgePending(void) const { return mFramePurgePending; } void SetFramePurgePending(bool aPurgePending) { mFramePurgePending = aPurgePending; } bool IsFrameReplacePending(void) const { return mFrameReplacePending; } void SetFrameReplacePending(bool aReplacePending) { mFrameReplacePending = aReplacePending; } #if OPENTHREAD_CONFIG_MULTI_RADIO Mac::RadioType GetLastPollRadioType(void) const { return mLastPollRadioType; } void SetLastPollRadioType(Mac::RadioType aRadioType) { mLastPollRadioType = aRadioType; } #endif uint32_t mIndirectFrameCounter; uint8_t mIndirectKeyId; uint8_t mIndirectDsn; uint8_t mIndirectTxAttempts : 5; bool mDataPollPending : 1; bool mFramePurgePending : 1; bool mFrameReplacePending : 1; #if OPENTHREAD_CONFIG_MULTI_RADIO Mac::RadioType mLastPollRadioType; #endif static_assert(kMaxPollTriggeredTxAttempts < (1 << 5), "mIndirectTxAttempts cannot fit max!"); }; class Callbacks : public InstanceLocator { friend class DataPollHandler; 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); void HandleFrameChangeDone(Child &aChild); }; explicit DataPollHandler(Instance &aInstance); void Clear(void); void HandleNewFrame(Child &aChild); void RequestFrameChange(FrameChange aChange, Child &aChild); private: void HandleDataPoll(Mac::RxFrame &aFrame); Mac::TxFrame *HandleFrameRequest(Mac::TxFrames &aTxFrames); void HandleSentFrame(const Mac::TxFrame &aFrame, Error aError); void HandleSentFrame(const Mac::TxFrame &aFrame, Error aError, Child &aChild); void ProcessPendingPolls(void); void ResetTxAttempts(Child &aChild); Child *mIndirectTxChild; Callbacks::FrameContext mFrameContext; Callbacks mCallbacks; };

Fields

Field

Declared as

ot::DataPollHandler::kMaxPollTriggeredTxAttempts

ot::DataPollHandler::mIndirectTxChild

Child *

ot::DataPollHandler::mFrameContext

Callbacks::FrameContext

ot::DataPollHandler::mCallbacks

Callbacks

Methods

Clear()

Clears any state/info saved per child for indirect frame transmission.

HandleNewFrame()

Informs data poll handler that there is a new frame for a given child. After this call, the data poll handler can use the `Callbacks::PrepareFrameForChild()` method to request the frame to be prepared. A subsequent call to `Callbacks::PrepareFrameForChild()` should ensure to prepare the same frame (this is used for retransmissions of frame by data poll handler). If/When the frame transmission is finished, the data poll handler will invoke the `Callbacks::HandleSentFrameToChild()` to indicate the status of the frame transmission.

RequestFrameChange()

Requests a frame change for a given child. Two types of frame change requests are supported: 1) "Purge Frame" which indicates that the previous frame should be purged and any ongoing indirect tx aborted. 2) "Replace Frame" which indicates that the previous frame needs to be replaced with a new higher priority one. If there is no ongoing indirect frame transmission to the child, the request will be handled immediately and the callback `HandleFrameChangeDone()` is called directly from this method itself. This callback notifies the next layer that the indirect frame/message for the child can be safely updated. If there is an ongoing indirect frame transmission to this child, the request can not be handled immediately. The following options can happen based on the request type: 1) In case of "purge" request, the ongoing indirect transmission is aborted and upon completion of the abort the callback `HandleFrameChangeDone()` is invoked. 2) In case of "replace" request, the ongoing indirect transmission is allowed to finish (current tx attempt). 2.a) If the tx attempt is successful, the `Callbacks::HandleSentFrameToChild()` in invoked which indicates the "replace" could not happen (in this case the `HandleFrameChangeDone()` is no longer called). 2.b) If the ongoing tx attempt is unsuccessful, then callback `HandleFrameChangeDone()` is invoked to allow the next layer to update the frame/message for the child. If there is a pending request, a subsequent call to this method is ignored except for the case where pending request is for "replace frame" and new one is for "purge frame" where the "purge" overrides the "replace" request.