wave-net-device.h

Go to the documentation of this file.

/*
 * Copyright (c) 2005,2006 INRIA
 * 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: Mathieu Lacage <mathieu.lacage@sophia.inria.fr>
 *         Junling Bu <linlinjavaer@gmail.com>
 */
#ifndef WAVE_NET_DEVICE_H
#define WAVE_NET_DEVICE_H
 
#include "channel-coordinator.h"
#include "channel-manager.h"
#include "channel-scheduler.h"
#include "ocb-wifi-mac.h"
#include "vendor-specific-action.h"
#include "vsa-manager.h"
 
#include "ns3/mac48-address.h"
#include "ns3/packet.h"
#include "ns3/traced-callback.h"
#include "ns3/wifi-net-device.h"
 
#include <map>
#include <vector>
 
namespace ns3
{
struct SchInfo;
struct VsaInfo;
class NetDevice;
class ChannelScheduler;
class VsaManager;
class OcbWifiMac;
 
struct TxInfo
{
    uint32_t channelNumber; 
    uint32_t priority;      
    WifiMode dataRate;      
    WifiPreamble preamble;  
    uint32_t txPowerLevel;  
 
    // Time expiryTime;   // unsupported
    TxInfo()
        : channelNumber(CCH),
          priority(7),
          txPowerLevel(8)
    {
    }
 
    TxInfo(uint32_t channel,
           uint32_t prio = 7,
           WifiMode rate = WifiMode(),
           WifiPreamble preamble = WIFI_PREAMBLE_LONG,
           uint32_t powerLevel = 8)
        : channelNumber(channel),
          priority(prio),
          dataRate(rate),
          preamble(preamble),
          txPowerLevel(powerLevel)
    {
    }
};
 
struct TxProfile
{
    uint32_t channelNumber; 
    bool adaptable;         
    uint32_t txPowerLevel;  
    WifiMode dataRate;      
    WifiPreamble preamble;  
 
    TxProfile()
        : channelNumber(SCH1),
          adaptable(false),
          txPowerLevel(4),
          preamble(WIFI_PREAMBLE_LONG)
    {
        dataRate = WifiMode("OfdmRate6MbpsBW10MHz");
    }
 
    TxProfile(uint32_t channel, bool adapt = true, uint32_t powerLevel = 4)
        : channelNumber(channel),
          adaptable(adapt),
          txPowerLevel(powerLevel)
    {
        dataRate = WifiMode("OfdmRate6MbpsBW10MHz");
        preamble = WIFI_PREAMBLE_LONG;
    }
};
 
class WaveNetDevice : public WifiNetDevice
{
  public:
    static TypeId GetTypeId();
    WaveNetDevice();
    ~WaveNetDevice() override;
 
    void AddMac(uint32_t channelNumber, Ptr<OcbWifiMac> mac);
    Ptr<OcbWifiMac> GetMac(uint32_t channelNumber) const;
    std::map<uint32_t, Ptr<OcbWifiMac>> GetMacs() const;
    void AddPhy(Ptr<WifiPhy> phy);
    Ptr<WifiPhy> GetPhy(uint8_t index) const override;
    const std::vector<Ptr<WifiPhy>>& GetPhys() const override;
 
    void SetChannelScheduler(Ptr<ChannelScheduler> channelScheduler);
    Ptr<ChannelScheduler> GetChannelScheduler() const;
    void SetChannelManager(Ptr<ChannelManager> channelManager);
    Ptr<ChannelManager> GetChannelManager() const;
    void SetChannelCoordinator(Ptr<ChannelCoordinator> channelCoordinator);
    Ptr<ChannelCoordinator> GetChannelCoordinator() const;
    void SetVsaManager(Ptr<VsaManager> vsaManager);
    Ptr<VsaManager> GetVsaManager() const;
 
    bool StartSch(const SchInfo& schInfo);
    bool StopSch(uint32_t channelNumber);
 
    bool StartVsa(const VsaInfo& vsaInfo);
    bool StopVsa(uint32_t channelNumber);
    typedef Callback<bool, Ptr<const Packet>, const Address&, uint32_t, uint32_t> WaveVsaCallback;
    void SetWaveVsaCallback(WaveVsaCallback vsaCallback);
 
    bool RegisterTxProfile(const TxProfile& txprofile);
    bool DeleteTxProfile(uint32_t channelNumber);
 
    bool SendX(Ptr<Packet> packet, const Address& dest, uint32_t protocol, const TxInfo& txInfo);
    void ChangeAddress(Address newAddress);
    void CancelTx(uint32_t channelNumber, AcIndex ac);
 
    bool Send(Ptr<Packet> packet, const Address& dest, uint16_t protocolNumber) override;
 
    // inherited from NetDevice base class.
    void SetIfIndex(const uint32_t index) override;
    uint32_t GetIfIndex() const override;
    Ptr<Channel> GetChannel() const override;
    void SetAddress(Address address) override;
    Address GetAddress() const override;
    bool SetMtu(const uint16_t mtu) override;
    uint16_t GetMtu() const override;
    bool IsLinkUp() const override;
    void AddLinkChangeCallback(Callback<void> callback) override;
    bool IsBroadcast() const override;
    Address GetBroadcast() const override;
    bool IsMulticast() const override;
    Address GetMulticast(Ipv4Address multicastGroup) const override;
    bool IsPointToPoint() const override;
    bool IsBridge() const override;
    bool NeedsArp() const override;
    void SetReceiveCallback(NetDevice::ReceiveCallback cb) override;
    Address GetMulticast(Ipv6Address addr) const override;
    bool SendFrom(Ptr<Packet> packet,
                  const Address& source,
                  const Address& dest,
                  uint16_t protocolNumber) override;
    void SetPromiscReceiveCallback(PromiscReceiveCallback cb) override;
    bool SupportsSendFrom() const override;
 
  private:
    static const uint16_t MAX_MSDU_SIZE = 2304;
 
    static const uint16_t IPv4_PROT_NUMBER = 0x0800;
    static const uint16_t IPv6_PROT_NUMBER = 0x86DD;
 
    void DoDispose() override;
    void DoInitialize() override;
    bool IsAvailableChannel(uint32_t channelNumber) const;
    void ForwardUp(Ptr<const Packet> packet, Mac48Address from, Mac48Address to);
 
    typedef std::map<uint32_t, Ptr<OcbWifiMac>> MacEntities;
    typedef std::map<uint32_t, Ptr<OcbWifiMac>>::const_iterator MacEntitiesI;
    MacEntities m_macEntities; 
    typedef std::vector<Ptr<WifiPhy>> PhyEntities;
    typedef std::vector<Ptr<WifiPhy>>::const_iterator PhyEntitiesI;
    PhyEntities m_phyEntities; 
 
    Ptr<ChannelManager> m_channelManager;         
    Ptr<ChannelScheduler> m_channelScheduler;     
    Ptr<ChannelCoordinator> m_channelCoordinator; 
    Ptr<VsaManager> m_vsaManager;                 
    TxProfile* m_txProfile;                       
    TracedCallback<Address, Address> m_addressChange;
 
    // copy from WifiNetDevice
    NetDevice::ReceiveCallback m_forwardUp;        
    NetDevice::PromiscReceiveCallback m_promiscRx; 
    uint32_t m_ifIndex;                            
    mutable uint16_t m_mtu;                        
};
 
} // namespace ns3
 
#endif /* WAVE_NET_DEVICE_H */