lr-wpan-mac-base.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023 Tokushima University, Japan.
 *
 * 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
 *
 *  Author: Alberto Gallegos Ramonet <alramonet@is.tokushima-u.ac.jp>
 */
 
#ifndef LR_WPAN_MAC_BASE_H
#define LR_WPAN_MAC_BASE_H
 
#include <ns3/callback.h>
#include <ns3/mac16-address.h>
#include <ns3/mac64-address.h>
#include <ns3/nstime.h>
#include <ns3/object.h>
#include <ns3/packet.h>
#include <ns3/ptr.h>
 
#include <cstdint>
 
namespace ns3
{
 
enum class LrWpanMacStatus : std::uint8_t
{
    SUCCESS = 0,              
    FULL_CAPACITY = 0x01,     
    ACCESS_DENIED = 0x02,     
    COUNTER_ERROR = 0xdb,     
    IMPROPER_KEY_TYPE = 0xdc, 
    IMPROPER_SECURITY_LEVEL = 0xdd, 
    UNSUPPORTED_LEGACY = 0xde,      
    UNSUPPORTED_SECURITY = 0xdf,    
    BEACON_LOSS = 0xe0,             
    CHANNEL_ACCESS_FAILURE = 0xe1,  
    DENIED = 0xe2,                  
    DISABLE_TRX_FAILURE = 0xe3,     
    SECURITY_ERROR = 0xe4,      // Cryptographic process of the frame failed(FAILED_SECURITY_CHECK).
    FRAME_TOO_LONG = 0xe5,      
    INVALID_GTS = 0xe6,         
    INVALID_HANDLE = 0xe7,      
    INVALID_PARAMETER = 0xe8,   
    NO_ACK = 0xe9,              
    NO_BEACON = 0xea,           
    NO_DATA = 0xeb,             
    NO_SHORT_ADDRESS = 0xec,    
    OUT_OF_CAP = 0xed,          
    PAN_ID_CONFLICT = 0xee,     
    REALIGMENT = 0xef,          
    TRANSACTION_EXPIRED = 0xf0, 
    TRANSACTION_OVERFLOW = 0xf1,  
    TX_ACTIVE = 0xf2,             
    UNAVAILABLE_KEY = 0xf3,       
    UNSUPPORTED_ATTRIBUTE = 0xf4, 
    INVALID_ADDRESS = 0xf5,       
    ON_TIME_TOO_LONG = 0xf6,      
    PAST_TIME = 0xf7,             
    TRACKING_OFF = 0xf8,          
    INVALID_INDEX = 0xf9,     
    LIMIT_REACHED = 0xfa,     
    READ_ONLY = 0xfb,         
    SCAN_IN_PROGRESS = 0xfc,  
    SUPERFRAME_OVERLAP = 0xfd 
};
 
enum LrWpanAddressMode
{
    NO_PANID_ADDR = 0,
    ADDR_MODE_RESERVED = 1,
    SHORT_ADDR = 2,
    EXT_ADDR = 3
};
 
enum LrWpanMlmeScanType
{
    MLMESCAN_ED = 0x00,
    MLMESCAN_ACTIVE = 0x01,
    MLMESCAN_PASSIVE = 0x02,
    MLMESCAN_ORPHAN = 0x03
};
 
struct McpsDataRequestParams
{
    LrWpanAddressMode m_srcAddrMode{SHORT_ADDR}; 
    LrWpanAddressMode m_dstAddrMode{SHORT_ADDR}; 
    uint16_t m_dstPanId{0};                      
    Mac16Address m_dstAddr;                      
    Mac64Address m_dstExtAddr;                   
    uint8_t m_msduHandle{0};                     
    uint8_t m_txOptions{0};                      
};
 
struct MlmeStartRequestParams
{
    uint16_t m_PanId{0};     
    uint8_t m_logCh{11};     
    uint32_t m_logChPage{0}; 
    uint32_t m_startTime{0}; 
    uint8_t m_bcnOrd{15};    
    uint8_t m_sfrmOrd{15};   
    bool m_panCoor{false};   
    bool m_battLifeExt{false}; 
    bool m_coorRealgn{false};  
};
 
struct MlmeScanRequestParams
{
    LrWpanMlmeScanType m_scanType{MLMESCAN_PASSIVE}; 
    uint32_t m_scanChannels{0x7FFF800};              
    uint8_t m_scanDuration{14}; 
    uint32_t m_chPage{0};       
};
 
struct MlmeAssociateRequestParams
{
    uint8_t m_chNum{11};                 
    uint32_t m_chPage{0};                
    uint8_t m_coordAddrMode{SHORT_ADDR}; 
    uint16_t m_coordPanId{0};            
    Mac16Address m_coordShortAddr;       
    Mac64Address m_coordExtAddr;         
    uint8_t m_capabilityInfo{0};         
};
 
struct MlmeAssociateResponseParams
{
    Mac64Address m_extDevAddr;     
    Mac16Address m_assocShortAddr; 
    LrWpanMacStatus m_status{
        LrWpanMacStatus::ACCESS_DENIED}; 
};
 
struct MlmeOrphanResponseParams
{
    Mac64Address m_orphanAddr; 
    Mac16Address m_shortAddr;  
    bool m_assocMember{false}; 
};
 
struct MlmeSyncRequestParams
{
    uint8_t m_logCh{11};    
    bool m_trackBcn{false}; 
};
 
struct MlmePollRequestParams
{
    LrWpanAddressMode m_coorAddrMode{SHORT_ADDR}; 
    uint16_t m_coorPanId{0};      
    Mac16Address m_coorShortAddr; 
    Mac64Address m_coorExtAddr;   
};
 
enum LrWpanMacPibAttributeIdentifier
{
    macBeaconPayload = 0,
    macBeaconPayloadLength = 1,
    macShortAddress = 2,
    macExtendedAddress = 3,
    macPanId = 4,
    pCurrentChannel = 100,
    pCurrentPage = 101,
    unsupported = 255
    // TODO: complete other MAC pib attributes
};
 
struct LrWpanMacPibAttributes : public SimpleRefCount<LrWpanMacPibAttributes>
{
    Ptr<Packet> macBeaconPayload;      
    uint8_t macBeaconPayloadLength{0}; 
    Mac16Address macShortAddress;      
    Mac64Address macExtendedAddress;   
    uint16_t macPanId{0xffff};         
    uint8_t pCurrentChannel{11};       
    uint8_t pCurrentPage{0};           
    // TODO: complete other MAC pib attributes
};
 
struct McpsDataConfirmParams
{
    uint8_t m_msduHandle{0};                                      
    LrWpanMacStatus m_status{LrWpanMacStatus::INVALID_PARAMETER}; 
};
 
struct McpsDataIndicationParams
{
    uint8_t m_srcAddrMode{SHORT_ADDR}; 
    uint16_t m_srcPanId{0};            
    Mac16Address m_srcAddr;            
    Mac64Address m_srcExtAddr;         
    uint8_t m_dstAddrMode{SHORT_ADDR}; 
    uint16_t m_dstPanId{0};            
    Mac16Address m_dstAddr;            
    Mac64Address m_dstExtAddr;         
    uint8_t m_mpduLinkQuality{0};      
    uint8_t m_dsn{0};                  
};
 
struct MlmeAssociateIndicationParams
{
    Mac64Address m_extDevAddr; 
    uint8_t capabilityInfo{0}; 
    uint8_t lqi{0}; 
};
 
struct MlmeCommStatusIndicationParams
{
    uint16_t m_panId{0}; 
    uint8_t m_srcAddrMode{SHORT_ADDR}; 
    Mac16Address m_srcShortAddr; 
    Mac64Address m_srcExtAddr; 
    uint8_t m_dstAddrMode{SHORT_ADDR}; 
    Mac16Address m_dstShortAddr;       
    Mac64Address m_dstExtAddr;         
    LrWpanMacStatus m_status{LrWpanMacStatus::INVALID_PARAMETER}; 
};
 
struct MlmeOrphanIndicationParams
{
    Mac64Address m_orphanAddr; 
};
 
struct MlmeStartConfirmParams
{
    LrWpanMacStatus m_status{LrWpanMacStatus::INVALID_PARAMETER}; 
};
 
struct PanDescriptor
{
    LrWpanAddressMode m_coorAddrMode{SHORT_ADDR}; 
    uint16_t m_coorPanId{0xffff};                 
    Mac16Address m_coorShortAddr; 
    Mac64Address m_coorExtAddr;   
    uint8_t m_logCh{11};          
    uint8_t m_logChPage{0};       
    uint16_t m_superframeSpec{0}; 
    bool m_gtsPermit{false};      
    uint8_t m_linkQuality{0};     
    Time m_timeStamp; 
};
 
struct MlmeScanConfirmParams
{
    LrWpanMacStatus m_status{
        LrWpanMacStatus::INVALID_PARAMETER}; 
    uint8_t m_scanType{MLMESCAN_PASSIVE};    
    uint32_t m_chPage{0};                    
    std::vector<uint8_t> m_unscannedCh;      
    uint8_t m_resultListSize{0};             
    std::vector<uint8_t> m_energyDetList;    
    std::vector<PanDescriptor> m_panDescList; 
};
 
struct MlmeAssociateConfirmParams
{
    Mac16Address m_assocShortAddr; 
    LrWpanMacStatus m_status{LrWpanMacStatus::INVALID_PARAMETER}; 
};
 
struct MlmeBeaconNotifyIndicationParams
{
    uint8_t m_bsn{0};              
    PanDescriptor m_panDescriptor; 
    uint32_t m_sduLength{0};       
    Ptr<Packet> m_sdu;             
};
 
struct MlmeSyncLossIndicationParams
{
    LrWpanMacStatus m_lossReason{LrWpanMacStatus::PAN_ID_CONFLICT}; 
    uint16_t m_panId{0}; 
    uint8_t m_logCh{11}; 
};
 
struct MlmeSetConfirmParams
{
    LrWpanMacStatus m_status{LrWpanMacStatus::UNSUPPORTED_ATTRIBUTE}; 
    LrWpanMacPibAttributeIdentifier id; 
};
 
struct MlmePollConfirmParams
{
    LrWpanMacStatus m_status{LrWpanMacStatus::INVALID_PARAMETER}; 
};
 
using McpsDataConfirmCallback = Callback<void, McpsDataConfirmParams>;
 
using McpsDataIndicationCallback = Callback<void, McpsDataIndicationParams, Ptr<Packet>>;
 
using MlmeAssociateIndicationCallback = Callback<void, MlmeAssociateIndicationParams>;
 
using MlmeCommStatusIndicationCallback = Callback<void, MlmeCommStatusIndicationParams>;
 
using MlmeOrphanIndicationCallback = Callback<void, MlmeOrphanIndicationParams>;
 
using MlmeStartConfirmCallback = Callback<void, MlmeStartConfirmParams>;
 
using MlmeScanConfirmCallback = Callback<void, MlmeScanConfirmParams>;
 
using MlmeAssociateConfirmCallback = Callback<void, MlmeAssociateConfirmParams>;
 
using MlmeBeaconNotifyIndicationCallback = Callback<void, MlmeBeaconNotifyIndicationParams>;
 
using MlmeSyncLossIndicationCallback = Callback<void, MlmeSyncLossIndicationParams>;
 
using MlmeSetConfirmCallback = Callback<void, MlmeSetConfirmParams>;
 
using MlmeGetConfirmCallback =
    Callback<void, LrWpanMacStatus, LrWpanMacPibAttributeIdentifier, Ptr<LrWpanMacPibAttributes>>;
 
using MlmePollConfirmCallback = Callback<void, MlmePollConfirmParams>;
 
class LrWpanMacBase : public Object
{
  public:
    static TypeId GetTypeId();
    ~LrWpanMacBase() override;
 
    virtual void McpsDataRequest(McpsDataRequestParams params, Ptr<Packet> p) = 0;
 
    virtual void MlmeStartRequest(MlmeStartRequestParams params) = 0;
 
    virtual void MlmeScanRequest(MlmeScanRequestParams params) = 0;
 
    virtual void MlmeAssociateRequest(MlmeAssociateRequestParams params) = 0;
 
    virtual void MlmeAssociateResponse(MlmeAssociateResponseParams params) = 0;
 
    virtual void MlmeSyncRequest(MlmeSyncRequestParams params) = 0;
 
    virtual void MlmePollRequest(MlmePollRequestParams params) = 0;
 
    virtual void MlmeOrphanResponse(MlmeOrphanResponseParams params) = 0;
 
    virtual void MlmeSetRequest(LrWpanMacPibAttributeIdentifier id,
                                Ptr<LrWpanMacPibAttributes> attribute) = 0;
 
    virtual void MlmeGetRequest(LrWpanMacPibAttributeIdentifier id) = 0;
 
    void SetMcpsDataConfirmCallback(McpsDataConfirmCallback c);
 
    void SetMcpsDataIndicationCallback(McpsDataIndicationCallback c);
 
    void SetMlmeAssociateIndicationCallback(MlmeAssociateIndicationCallback c);
 
    void SetMlmeCommStatusIndicationCallback(MlmeCommStatusIndicationCallback c);
 
    void SetMlmeOrphanIndicationCallback(MlmeOrphanIndicationCallback c);
 
    void SetMlmeStartConfirmCallback(MlmeStartConfirmCallback c);
 
    void SetMlmeScanConfirmCallback(MlmeScanConfirmCallback c);
 
    void SetMlmeAssociateConfirmCallback(MlmeAssociateConfirmCallback c);
 
    void SetMlmeBeaconNotifyIndicationCallback(MlmeBeaconNotifyIndicationCallback c);
 
    void SetMlmeSyncLossIndicationCallback(MlmeSyncLossIndicationCallback c);
 
    void SetMlmeSetConfirmCallback(MlmeSetConfirmCallback c);
 
    void SetMlmeGetConfirmCallback(MlmeGetConfirmCallback c);
 
    void SetMlmePollConfirmCallback(MlmePollConfirmCallback c);
 
  protected:
    McpsDataConfirmCallback m_mcpsDataConfirmCallback;
 
    McpsDataIndicationCallback m_mcpsDataIndicationCallback;
 
    MlmeAssociateIndicationCallback m_mlmeAssociateIndicationCallback;
 
    MlmeCommStatusIndicationCallback m_mlmeCommStatusIndicationCallback;
 
    MlmeOrphanIndicationCallback m_mlmeOrphanIndicationCallback;
 
    MlmeStartConfirmCallback m_mlmeStartConfirmCallback;
 
    MlmeScanConfirmCallback m_mlmeScanConfirmCallback;
 
    MlmeAssociateConfirmCallback m_mlmeAssociateConfirmCallback;
 
    MlmeBeaconNotifyIndicationCallback m_mlmeBeaconNotifyIndicationCallback;
 
    MlmeSyncLossIndicationCallback m_mlmeSyncLossIndicationCallback;
 
    MlmeSetConfirmCallback m_mlmeSetConfirmCallback;
 
    MlmeGetConfirmCallback m_mlmeGetConfirmCallback;
 
    MlmePollConfirmCallback m_mlmePollConfirmCallback;
};
 
} // namespace ns3
 
#endif /* LR_WPAN_MAC_BASE_H*/