Symbols ![]()
loading (3/5)...
Files ![]()
loading (4/5)...
ot::Neighbor class
Represents a Thread neighbor.
Syntax
class Neighbor : public InstanceLocatorInit
#if OPENTHREAD_CONFIG_MULTI_RADIO
,
public RadioSelector::NeighborInfo
#endif
#if OPENTHREAD_CONFIG_RADIO_LINK_TREL_ENABLE
,
public Trel::NeighborInfo
#endif
{
public:
enum State : uint8_t
{
kStateInvalid,
kStateRestored,
kStateParentRequest,
kStateParentResponse,
kStateChildIdRequest,
kStateLinkRequest,
kStateChildUpdateRequest,
kStateValid,
};
enum StateFilter : uint8_t
{
kInStateValid,
kInStateValidOrRestoring,
kInStateChildIdRequest,
kInStateValidOrAttaching,
kInStateInvalid,
kInStateAnyExceptInvalid,
kInStateAnyExceptValidOrRestoring,
kInStateAny,
};
class AddressMatcher
{
public:
AddressMatcher(Mac::ShortAddress aShortAddress, StateFilter aStateFilter)
: AddressMatcher(aStateFilter, aShortAddress, nullptr)
{
}
AddressMatcher(const Mac::ExtAddress &aExtAddress, StateFilter aStateFilter)
: AddressMatcher(aStateFilter, Mac::kShortAddrInvalid, &aExtAddress)
{
}
AddressMatcher(const Mac::Address &aMacAddress, StateFilter aStateFilter)
: AddressMatcher(aStateFilter,
aMacAddress.IsShort() ? aMacAddress.GetShort() : Mac::kShortAddrInvalid,
aMacAddress.IsExtended() ? &aMacAddress.GetExtended() : nullptr)
{
}
explicit AddressMatcher(StateFilter aStateFilter)
: AddressMatcher(aStateFilter, Mac::kShortAddrInvalid, nullptr)
{
}
bool Matches(const Neighbor &aNeighbor) const;
private:
AddressMatcher(StateFilter aStateFilter, Mac::ShortAddress aShortAddress, const Mac::ExtAddress *aExtAddress)
: mStateFilter(aStateFilter)
, mShortAddress(aShortAddress)
, mExtAddress(aExtAddress)
{
}
StateFilter mStateFilter;
Mac::ShortAddress mShortAddress;
const Mac::ExtAddress *mExtAddress;
};
class Info : public otNeighborInfo, public Clearable<Info>
{
public:
void SetFrom(const Neighbor &aNeighbor);
};
State GetState(void) const { return static_cast<State>(mState); }
void SetState(State aState);
bool IsStateInvalid(void) const { return (mState == kStateInvalid); }
bool IsStateChildIdRequest(void) const { return (mState == kStateChildIdRequest); }
bool IsStateLinkRequest(void) const { return (mState == kStateLinkRequest); }
bool IsStateParentResponse(void) const { return (mState == kStateParentResponse); }
bool IsStateRestoring(void) const { return (mState == kStateRestored) || (mState == kStateChildUpdateRequest); }
bool IsStateRestored(void) const { return (mState == kStateRestored); }
bool IsStateValid(void) const { return (mState == kStateValid); }
bool IsStateValidOrRestoring(void) const { return (mState == kStateValid) || IsStateRestoring(); }
bool IsStateValidOrAttaching(void) const;
bool MatchesFilter(StateFilter aFilter) const;
bool Matches(const AddressMatcher &aMatcher) const { return aMatcher.Matches(*this); }
Mle::DeviceMode GetDeviceMode(void) const { return Mle::DeviceMode(mMode); }
void SetDeviceMode(Mle::DeviceMode aMode) { mMode = aMode.Get(); }
bool IsRxOnWhenIdle(void) const { return GetDeviceMode().IsRxOnWhenIdle(); }
bool IsFullThreadDevice(void) const { return GetDeviceMode().IsFullThreadDevice(); }
NetworkData::Type GetNetworkDataType(void) const { return GetDeviceMode().GetNetworkDataType(); }
const Mac::ExtAddress &GetExtAddress(void) const { return mMacAddr; }
Mac::ExtAddress &GetExtAddress(void) { return mMacAddr; }
void SetExtAddress(const Mac::ExtAddress &aAddress) { mMacAddr = aAddress; }
uint32_t GetKeySequence(void) const { return mKeySequence; }
void SetKeySequence(uint32_t aKeySequence) { mKeySequence = aKeySequence; }
TimeMilli GetLastHeard(void) const { return mLastHeard; }
void SetLastHeard(TimeMilli aLastHeard) { mLastHeard = aLastHeard; }
Mac::LinkFrameCounters &GetLinkFrameCounters(void) { return mValidPending.mValid.mLinkFrameCounters; }
const Mac::LinkFrameCounters &GetLinkFrameCounters(void) const { return mValidPending.mValid.mLinkFrameCounters; }
#if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
uint32_t GetLinkAckFrameCounter(void) const { return mValidPending.mValid.mLinkAckFrameCounter; }
#endif
void SetLinkAckFrameCounter(uint32_t aAckFrameCounter)
{
#if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
mValidPending.mValid.mLinkAckFrameCounter = aAckFrameCounter;
#else
OT_UNUSED_VARIABLE(aAckFrameCounter);
#endif
}
uint32_t GetMleFrameCounter(void) const { return mValidPending.mValid.mMleFrameCounter; }
void SetMleFrameCounter(uint32_t aFrameCounter) { mValidPending.mValid.mMleFrameCounter = aFrameCounter; }
uint16_t GetRloc16(void) const { return mRloc16; }
uint8_t GetRouterId(void) const { return mRloc16 >> Mle::kRouterIdOffset; }
void SetRloc16(uint16_t aRloc16) { mRloc16 = aRloc16; }
#if OPENTHREAD_CONFIG_MULTI_RADIO
void ClearLastRxFragmentTag(void) { mLastRxFragmentTag = 0; }
uint16_t GetLastRxFragmentTag(void) const { return mLastRxFragmentTag; }
void SetLastRxFragmentTag(uint16_t aTag);
bool IsLastRxFragmentTagSet(void) const;
bool IsLastRxFragmentTagAfter(uint16_t aTag) const { return SerialNumber::IsGreater(mLastRxFragmentTag, aTag); }
#endif
bool IsThreadVersion1p1(void) const { return mState != kStateInvalid && mVersion == kThreadVersion1p1; }
bool IsThreadVersion1p2OrHigher(void) const { return mState != kStateInvalid && mVersion >= kThreadVersion1p2; }
bool IsThreadVersionCslCapable(void) const { return IsThreadVersion1p2OrHigher() && !IsRxOnWhenIdle(); }
bool IsEnhancedKeepAliveSupported(void) const
{
return (mState != kStateInvalid) && (mVersion >= kThreadVersion1p2);
}
uint16_t GetVersion(void) const { return mVersion; }
void SetVersion(uint16_t aVersion) { mVersion = aVersion; }
uint8_t GetLinkFailures(void) const { return mLinkFailures; }
void IncrementLinkFailures(void) { mLinkFailures++; }
void ResetLinkFailures(void) { mLinkFailures = 0; }
LinkQualityInfo &GetLinkInfo(void) { return mLinkInfo; }
const LinkQualityInfo &GetLinkInfo(void) const { return mLinkInfo; }
LinkQuality GetLinkQualityIn(void) const { return GetLinkInfo().GetLinkQuality(); }
void GenerateChallenge(void) { mValidPending.mPending.mChallenge.GenerateRandom(); }
const Mle::TxChallenge &GetChallenge(void) const { return mValidPending.mPending.mChallenge; }
#if OPENTHREAD_CONFIG_UPTIME_ENABLE
uint32_t GetConnectionTime(void) const;
#endif
#if OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
bool IsTimeSyncEnabled(void) const { return mTimeSyncEnabled; }
void SetTimeSyncEnabled(bool aEnabled) { mTimeSyncEnabled = aEnabled; }
#endif
#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_INITIATOR_ENABLE || OPENTHREAD_CONFIG_MLE_LINK_METRICS_SUBJECT_ENABLE
void AggregateLinkMetrics(uint8_t aSeriesId, uint8_t aFrameType, uint8_t aLqi, int8_t aRss);
void AddForwardTrackingSeriesInfo(LinkMetrics::SeriesInfo &aSeriesInfo);
LinkMetrics::SeriesInfo *GetForwardTrackingSeriesInfo(const uint8_t &aSeriesId);
LinkMetrics::SeriesInfo *RemoveForwardTrackingSeriesInfo(const uint8_t &aSeriesId);
void RemoveAllForwardTrackingSeriesInfo(void);
const LinkMetrics::Metrics &GetEnhAckProbingMetrics(void) const { return mEnhAckProbingMetrics; }
void SetEnhAckProbingMetrics(const LinkMetrics::Metrics &aEnhAckProbingMetrics)
{
mEnhAckProbingMetrics = aEnhAckProbingMetrics;
}
bool IsEnhAckProbingActive(void) const
{
return (mEnhAckProbingMetrics.mLqi != 0) || (mEnhAckProbingMetrics.mLinkMargin != 0) ||
(mEnhAckProbingMetrics.mRssi != 0);
}
#endif
static const char *StateToString(State aState);
protected:
void Init(Instance &aInstance);
private:
enum : uint32_t
{
kLastRxFragmentTagTimeout = OPENTHREAD_CONFIG_MULTI_RADIO_FRAG_TAG_TIMEOUT,
};
Mac::ExtAddress mMacAddr;
TimeMilli mLastHeard;
union
{
struct
{
Mac::LinkFrameCounters mLinkFrameCounters;
uint32_t mMleFrameCounter;
#if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
uint32_t mLinkAckFrameCounter;
#endif
} mValid;
struct
{
Mle::TxChallenge mChallenge;
} mPending;
} mValidPending;
#if OPENTHREAD_CONFIG_MULTI_RADIO
uint16_t mLastRxFragmentTag;
TimeMilli mLastRxFragmentTagTime;
#endif
uint32_t mKeySequence;
uint16_t mRloc16;
uint8_t mState : 4;
uint8_t mMode : 4;
#if OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
uint8_t mLinkFailures : 7;
bool mTimeSyncEnabled : 1;
#else
uint8_t mLinkFailures;
#endif
uint16_t mVersion;
LinkQualityInfo mLinkInfo;
#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_INITIATOR_ENABLE || OPENTHREAD_CONFIG_MLE_LINK_METRICS_SUBJECT_ENABLE
LinkedList<LinkMetrics::SeriesInfo> mLinkMetricsSeriesInfoList;
LinkMetrics::Metrics mEnhAckProbingMetrics;
#endif
#if OPENTHREAD_CONFIG_UPTIME_ENABLE
uint32_t mConnectionStart;
#endif
};
Fields
Field
Declared as
union
{
struct
{
Mac::LinkFrameCounters mLinkFrameCounters;
uint32_t mMleFrameCounter;
#if OPENTHREAD_CONFIG_THREAD_VERSION >= OT_THREAD_VERSION_1_2
uint32_t mLinkAckFrameCounter;
#endif
} mValid;
struct
{
Mle::TxChallenge mChallenge;
} mPending;
}
uint32_t
uint16_t
uint8_t : 4
uint8_t : 4
uint8_t
uint16_t
uint32_t
Related Functions
Found 19 other functions taking a Neighbor
argument:
Function
Description
Removes a link to a neighbor.
Sets the `Info` instance from a given `Neighbor`.
Indicates if a given neighbor matches the address and state filter of `AddressMatcher`.
Signals a "neighbor table changed" event. Invokes the `NeighborTable::Callback` and also signals the change through a related `Notifier` event.
Fills a Route TLV. When @p aNeighbor is not `nullptr`, we limit the number of router entries to `kMaxRoutersInRouteTlvForLinkAccept` when populating `aRouteTlv`, so that the TLV can be appended in a Link Accept message. In this case, we ensure to include router entries associated with @p aNeighbor, leader, and this device itself.
Handles a deferred ack. Some radio links can use deferred ack logic, where a tx request always report `HandleSentFrame()` quickly. The link layer would wait for the ack and report it at a later time using this method. The link layer is expected to call `HandleDeferredAck()` (with success or failure status) for every tx request on the radio link.
Indicates whether the router table contains a given `Neighbor` instance.
Indicates whether the child table contains a given `Neighbor` instance.
References
Code
Location
Scope
Referrer
Class Tree
ot::Neighbor inherits 2 classess and is inherited by 2 classess:
Instances
Instance
Scope
Location
Project