lr-wpan-mac.h

Go to the documentation of this file.

/*
 * Copyright (c) 2011 The Boeing Company
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation;
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * Authors:
 *  Gary Pei <guangyu.pei@boeing.com>
 *  kwong yin <kwong-sang.yin@boeing.com>
 *  Tom Henderson <thomas.r.henderson@boeing.com>
 *  Sascha Alexander Jopen <jopen@cs.uni-bonn.de>
 *  Alberto Gallegos Ramonet <ramonet@fc.ritsumei.ac.jp>
 */
 
#ifndef LR_WPAN_MAC_H
#define LR_WPAN_MAC_H
 
#include "lr-wpan-fields.h"
#include "lr-wpan-mac-base.h"
#include "lr-wpan-phy.h"
 
#include <ns3/event-id.h>
#include <ns3/sequence-number.h>
#include <ns3/traced-callback.h>
#include <ns3/traced-value.h>
 
#include <deque>
#include <memory>
 
namespace ns3
{
 
class Packet;
class LrWpanCsmaCa;
 
enum LrWpanTxOption
{
    TX_OPTION_NONE = 0,    
    TX_OPTION_ACK = 1,     
    TX_OPTION_GTS = 2,     
    TX_OPTION_INDIRECT = 4 
};
 
enum LrWpanMacState
{
    MAC_IDLE,               
    MAC_CSMA,               
    MAC_SENDING,            
    MAC_ACK_PENDING,        
    CHANNEL_ACCESS_FAILURE, 
    CHANNEL_IDLE,           
    SET_PHY_TX_ON,          
    MAC_GTS,                
    MAC_INACTIVE,           
    MAC_CSMA_DEFERRED       
};
 
std::ostream& operator<<(std::ostream& os, const LrWpanMacState& state);
 
enum SuperframeStatus
{
    BEACON,  
    CAP,     
    CFP,     
    INACTIVE 
};
 
enum SuperframeType
{
    OUTGOING = 0, 
    INCOMING = 1  
};
 
enum PendingPrimitiveStatus
{
    MLME_NONE = 0,      
    MLME_START_REQ = 1, 
    MLME_SCAN_REQ = 2,  
    MLME_ASSOC_REQ = 3, 
    MLME_SYNC_REQ = 4   
};
 
namespace TracedValueCallback
{
 
typedef void (*LrWpanMacState)(LrWpanMacState oldValue, LrWpanMacState newValue);
 
typedef void (*SuperframeStatus)(SuperframeStatus oldValue, SuperframeStatus newValue);
 
} // namespace TracedValueCallback
 
class LrWpanMac : public LrWpanMacBase
{
  public:
    static TypeId GetTypeId();
 
    LrWpanMac();
    ~LrWpanMac() override;
 
    bool GetRxOnWhenIdle() const;
 
    void SetRxOnWhenIdle(bool rxOnWhenIdle);
 
    // XXX these setters will become obsolete if we use the attribute system
    void SetShortAddress(Mac16Address address);
 
    Mac16Address GetShortAddress() const;
 
    void SetExtendedAddress(Mac64Address address);
 
    Mac64Address GetExtendedAddress() const;
 
    void SetPanId(uint16_t panId);
 
    uint16_t GetPanId() const;
 
    Mac16Address GetCoordShortAddress() const;
 
    Mac64Address GetCoordExtAddress() const;
 
    void McpsDataRequest(McpsDataRequestParams params, Ptr<Packet> p) override;
 
    void MlmeStartRequest(MlmeStartRequestParams params) override;
 
    void MlmeScanRequest(MlmeScanRequestParams params) override;
 
    void MlmeAssociateRequest(MlmeAssociateRequestParams params) override;
 
    void MlmeAssociateResponse(MlmeAssociateResponseParams params) override;
 
    void MlmeOrphanResponse(MlmeOrphanResponseParams params) override;
 
    void MlmeSyncRequest(MlmeSyncRequestParams params) override;
 
    void MlmePollRequest(MlmePollRequestParams params) override;
 
    void MlmeSetRequest(LrWpanMacPibAttributeIdentifier id,
                        Ptr<LrWpanMacPibAttributes> attribute) override;
 
    void MlmeGetRequest(LrWpanMacPibAttributeIdentifier id) override;
 
    void SetCsmaCa(Ptr<LrWpanCsmaCa> csmaCa);
 
    void SetPhy(Ptr<LrWpanPhy> phy);
 
    Ptr<LrWpanPhy> GetPhy();
 
    // Interfaces between MAC and PHY //
 
    void PdDataIndication(uint32_t psduLength, Ptr<Packet> p, uint8_t lqi);
 
    void PdDataConfirm(LrWpanPhyEnumeration status);
 
    void PlmeCcaConfirm(LrWpanPhyEnumeration status);
 
    void PlmeEdConfirm(LrWpanPhyEnumeration status, uint8_t energyLevel);
 
    void PlmeGetAttributeConfirm(LrWpanPhyEnumeration status,
                                 LrWpanPibAttributeIdentifier id,
                                 Ptr<LrWpanPhyPibAttributes> attribute);
 
    void PlmeSetTRXStateConfirm(LrWpanPhyEnumeration status);
 
    void PlmeSetAttributeConfirm(LrWpanPhyEnumeration status, LrWpanPibAttributeIdentifier id);
 
    void SetLrWpanMacState(LrWpanMacState macState);
 
    void SetTxQMaxSize(uint32_t queueSize);
 
    void SetIndTxQMaxSize(uint32_t queueSize);
 
    // MAC PIB attributes
 
    Time m_macBeaconTxTime;
 
    Time m_macBeaconRxTime;
 
    uint64_t m_macResponseWaitTime;
 
    uint64_t m_assocRespCmdWaitTime;
 
    Mac16Address m_macCoordShortAddress;
 
    Mac64Address m_macCoordExtendedAddress;
 
    uint64_t m_macSyncSymbolOffset;
 
    uint8_t m_macBeaconOrder;
 
    uint8_t m_macSuperframeOrder;
 
    uint16_t m_macTransactionPersistenceTime;
 
    uint64_t m_rxBeaconSymbols;
 
    uint8_t m_fnlCapSlot;
 
    uint8_t m_incomingBeaconOrder;
 
    uint8_t m_incomingSuperframeOrder;
 
    uint8_t m_incomingFnlCapSlot;
 
    bool m_macPromiscuousMode;
 
    uint16_t m_macPanId;
 
    uint16_t m_macPanIdScan;
 
    SequenceNumber8 m_macDsn;
 
    SequenceNumber8 m_macBsn;
 
    Ptr<Packet> m_macBeaconPayload;
 
    uint32_t m_macBeaconPayloadLength;
 
    uint8_t m_macMaxFrameRetries;
 
    bool m_macRxOnWhenIdle;
 
    uint32_t m_macLIFSPeriod;
 
    uint32_t m_macSIFSPeriod;
 
    bool m_macAssociationPermit;
 
    bool m_macAutoRequest;
 
    uint8_t m_maxEnergyLevel;
 
    uint32_t m_ifs;
 
    bool m_panCoor;
 
    bool m_coor;
 
    uint32_t m_beaconInterval;
 
    uint32_t m_superframeDuration;
 
    uint32_t m_incomingBeaconInterval;
 
    uint32_t m_incomingSuperframeDuration;
 
    uint8_t m_deviceCapability;
 
    bool m_beaconTrackingOn;
 
    uint8_t m_numLostBeacons;
 
    uint64_t GetMacAckWaitDuration() const;
 
    uint8_t GetMacMaxFrameRetries() const;
 
    void PrintTransmitQueueSize();
 
    void SetMacMaxFrameRetries(uint8_t retries);
 
    bool isCoordDest();
 
    void SetAssociatedCoor(Mac16Address mac);
 
    void SetAssociatedCoor(Mac64Address mac);
 
    uint32_t GetIfsSize();
 
    uint64_t GetTxPacketSymbols();
 
    bool isTxAckReq();
 
    void PrintPendingTxQueue(std::ostream& os) const;
 
    void PrintTxQueue(std::ostream& os) const;
 
    typedef void (*SentTracedCallback)(Ptr<const Packet> packet, uint8_t retries, uint8_t backoffs);
 
    typedef void (*StateTracedCallback)(LrWpanMacState oldState, LrWpanMacState newState);
 
  protected:
    // Inherited from Object.
    void DoInitialize() override;
    void DoDispose() override;
 
  private:
    struct TxQueueElement : public SimpleRefCount<TxQueueElement>
    {
        uint8_t txQMsduHandle; 
        Ptr<Packet> txQPkt;    
    };
 
    struct IndTxQueueElement : public SimpleRefCount<IndTxQueueElement>
    {
        uint8_t seqNum;               
        Mac16Address dstShortAddress; 
        Mac64Address dstExtAddress;   
        Ptr<Packet> txQPkt;           
        Time expireTime; 
    };
 
    void SendOneBeacon();
 
    void SendAssocRequestCommand();
 
    void SendDataRequestCommand();
 
    void SendAssocResponseCommand(Ptr<Packet> rxDataReqPkt);
 
    void LostAssocRespCommand();
 
    void SendBeaconRequestCommand();
 
    void SendOrphanNotificationCommand();
 
    void EndStartRequest();
 
    void EndChannelScan();
 
    void EndChannelEnergyScan();
 
    void EndAssociateRequest();
 
    void StartCFP(SuperframeType superframeType);
 
    void StartCAP(SuperframeType superframeType);
 
    void StartInactivePeriod(SuperframeType superframeType);
 
    void AwaitBeacon();
 
    void BeaconSearchTimeout();
 
    void SendAck(uint8_t seqno);
 
    void EnqueueTxQElement(Ptr<TxQueueElement> txQElement);
 
    void RemoveFirstTxQElement();
 
    void ChangeMacState(LrWpanMacState newState);
 
    void AckWaitTimeout();
 
    void IfsWaitTimeout(Time ifsTime);
 
    bool PrepareRetransmission();
 
    void EnqueueInd(Ptr<Packet> p);
 
    bool DequeueInd(Mac64Address dst, Ptr<IndTxQueueElement> entry);
 
    void PurgeInd();
 
    void RemovePendTxQElement(Ptr<Packet> p);
 
    void CheckQueue();
 
    uint16_t GetSuperframeField();
 
    GtsFields GetGtsFields();
 
    PendingAddrFields GetPendingAddrFields();
 
    TracedCallback<Time> m_macIfsEndTrace;
 
    TracedCallback<Ptr<const Packet>, uint8_t, uint8_t> m_sentPktTrace;
 
    TracedCallback<Ptr<const Packet>> m_macTxEnqueueTrace;
 
    TracedCallback<Ptr<const Packet>> m_macTxDequeueTrace;
 
    TracedCallback<Ptr<const Packet>> m_macIndTxEnqueueTrace;
 
    TracedCallback<Ptr<const Packet>> m_macIndTxDequeueTrace;
 
    TracedCallback<Ptr<const Packet>> m_macTxTrace;
 
    TracedCallback<Ptr<const Packet>> m_macTxOkTrace;
 
    TracedCallback<Ptr<const Packet>> m_macTxDropTrace;
 
    TracedCallback<Ptr<const Packet>> m_macIndTxDropTrace;
 
    TracedCallback<Ptr<const Packet>> m_macPromiscRxTrace;
 
    TracedCallback<Ptr<const Packet>> m_macRxTrace;
 
    TracedCallback<Ptr<const Packet>> m_macRxDropTrace;
 
    TracedCallback<Ptr<const Packet>> m_snifferTrace;
 
    TracedCallback<Ptr<const Packet>> m_promiscSnifferTrace;
 
    TracedCallback<LrWpanMacState, LrWpanMacState> m_macStateLogger;
 
    Ptr<LrWpanPhy> m_phy;
 
    Ptr<LrWpanCsmaCa> m_csmaCa;
 
    TracedValue<LrWpanMacState> m_lrWpanMacState;
 
    TracedValue<SuperframeStatus> m_incSuperframeStatus;
 
    TracedValue<SuperframeStatus> m_outSuperframeStatus;
 
    Ptr<Packet> m_txPkt;
 
    Ptr<Packet> m_rxPkt;
 
    Mac16Address m_shortAddress;
 
    Mac64Address m_selfExt;
 
    std::deque<Ptr<TxQueueElement>> m_txQueue;
 
    std::deque<Ptr<IndTxQueueElement>> m_indTxQueue;
 
    uint32_t m_maxTxQueueSize;
 
    uint32_t m_maxIndTxQueueSize;
 
    std::vector<PanDescriptor> m_panDescriptorList;
 
    std::vector<uint8_t> m_energyDetectList;
 
    std::vector<uint8_t> m_unscannedChannels;
 
    MlmeScanRequestParams m_scanParams;
 
    MlmeStartRequestParams m_startParams;
 
    MlmeAssociateRequestParams m_associateParams;
 
    uint16_t m_channelScanIndex;
 
    PendingPrimitiveStatus m_pendPrimitive;
 
    uint8_t m_retransmission;
 
    uint8_t m_numCsmacaRetry;
 
    uint8_t m_lastRxFrameLqi;
 
    EventId m_ackWaitTimeout;
 
    EventId m_respWaitTimeout;
 
    EventId m_assocResCmdWaitTimeout;
 
    EventId m_setMacState;
 
    EventId m_ifsEvent;
 
    EventId m_beaconEvent;
 
    EventId m_capEvent;
 
    EventId m_cfpEvent;
 
    EventId m_incCapEvent;
 
    EventId m_incCfpEvent;
 
    EventId m_trackingEvent;
 
    EventId m_scanEvent;
 
    EventId m_scanOrphanEvent;
 
    EventId m_scanEnergyEvent;
};
} // namespace ns3
 
#endif /* LR_WPAN_MAC_H */