he-frame-exchange-manager.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020 Universita' degli Studi di Napoli Federico II
 *
 * 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: Stefano Avallone <stavallo@unina.it>
 */
 
#ifndef HE_FRAME_EXCHANGE_MANAGER_H
#define HE_FRAME_EXCHANGE_MANAGER_H
 
#include "mu-snr-tag.h"
 
#include "ns3/vht-frame-exchange-manager.h"
 
#include <map>
#include <unordered_map>
 
namespace ns3
{
 
class MultiUserScheduler;
class ApWifiMac;
class StaWifiMac;
class CtrlTriggerHeader;
 
typedef std::unordered_map<uint16_t /* staId */, Ptr<WifiPsdu> /* PSDU */> WifiPsduMap;
typedef std::unordered_map<uint16_t /* staId */, Ptr<const WifiPsdu> /* PSDU */> WifiConstPsduMap;
 
bool IsTrigger(const WifiPsduMap& psduMap);
 
class HeFrameExchangeManager : public VhtFrameExchangeManager
{
  public:
    static TypeId GetTypeId();
    HeFrameExchangeManager();
    ~HeFrameExchangeManager() override;
 
    uint16_t GetSupportedBaBufferSize() const override;
    bool StartFrameExchange(Ptr<QosTxop> edca, Time availableTime, bool initialFrame) override;
    void SetWifiMac(const Ptr<WifiMac> mac) override;
    void SetWifiPhy(const Ptr<WifiPhy> phy) override;
    void CalculateAcknowledgmentTime(WifiAcknowledgment* acknowledgment) const override;
    void CalculateProtectionTime(WifiProtection* protection) const override;
    void SetTxopHolder(Ptr<const WifiPsdu> psdu, const WifiTxVector& txVector) override;
    bool VirtualCsMediumIdle() const override;
 
    void SetMultiUserScheduler(const Ptr<MultiUserScheduler> muScheduler);
 
    static Ptr<WifiPsdu> GetPsduTo(Mac48Address to, const WifiPsduMap& psduMap);
 
    virtual void SetTargetRssi(CtrlTriggerHeader& trigger) const;
 
    virtual std::optional<double> GetMostRecentRssi(const Mac48Address& address) const;
 
    bool IsIntraBssPpdu(Ptr<const WifiPsdu> psdu, const WifiTxVector& txVector) const;
 
    bool UlMuCsMediumIdle(const CtrlTriggerHeader& trigger) const;
 
  protected:
    void DoDispose() override;
    void Reset() override;
 
    void ReceiveMpdu(Ptr<const WifiMpdu> mpdu,
                     RxSignalInfo rxSignalInfo,
                     const WifiTxVector& txVector,
                     bool inAmpdu) override;
    void EndReceiveAmpdu(Ptr<const WifiPsdu> psdu,
                         const RxSignalInfo& rxSignalInfo,
                         const WifiTxVector& txVector,
                         const std::vector<bool>& perMpduStatus) override;
    void PostProcessFrame(Ptr<const WifiPsdu> psdu, const WifiTxVector& txVector) override;
    Time GetTxDuration(uint32_t ppduPayloadSize,
                       Mac48Address receiver,
                       const WifiTxParameters& txParams) const override;
    bool SendMpduFromBaManager(Ptr<WifiMpdu> mpdu, Time availableTime, bool initialFrame) override;
    void NormalAckTimeout(Ptr<WifiMpdu> mpdu, const WifiTxVector& txVector) override;
    void BlockAckTimeout(Ptr<WifiPsdu> psdu, const WifiTxVector& txVector) override;
    void CtsTimeout(Ptr<WifiMpdu> rts, const WifiTxVector& txVector) override;
    void UpdateNav(Ptr<const WifiPsdu> psdu, const WifiTxVector& txVector) override;
    void NavResetTimeout() override;
 
    void ClearTxopHolderIfNeeded() override;
 
    virtual void IntraBssNavResetTimeout();
 
    virtual Time GetMuRtsDurationId(uint32_t muRtsSize,
                                    const WifiTxVector& muRtsTxVector,
                                    Time txDuration,
                                    Time response) const;
 
    void SendMuRts(const WifiTxParameters& txParams);
 
    virtual void CtsAfterMuRtsTimeout(Ptr<WifiMpdu> muRts, const WifiTxVector& txVector);
 
    void SendCtsAfterMuRts(const WifiMacHeader& muRtsHdr,
                           const CtrlTriggerHeader& trigger,
                           double muRtsSnr);
 
    WifiMode GetCtsModeAfterMuRts() const;
 
    WifiTxVector GetCtsTxVectorAfterMuRts(const CtrlTriggerHeader& trigger, uint16_t staId) const;
 
    void SendPsduMapWithProtection(WifiPsduMap psduMap, WifiTxParameters& txParams);
 
    void ForwardPsduMapDown(WifiConstPsduMap psduMap, WifiTxVector& txVector);
 
    virtual void BlockAcksInTbPpduTimeout(WifiPsduMap* psduMap,
                                          const std::set<Mac48Address>* staMissedBlockAckFrom,
                                          std::size_t nSolicitedStations);
 
    virtual void TbPpduTimeout(WifiPsduMap* psduMap,
                               const std::set<Mac48Address>* staMissedTbPpduFrom,
                               std::size_t nSolicitedStations);
 
    virtual void BlockAckAfterTbPpduTimeout(Ptr<WifiPsdu> psdu, const WifiTxVector& txVector);
 
    WifiTxVector GetTrigVector(const CtrlTriggerHeader& trigger) const;
 
    WifiTxVector GetHeTbTxVector(CtrlTriggerHeader trigger, Mac48Address triggerSender) const;
 
    Ptr<WifiMpdu> PrepareMuBar(const WifiTxVector& responseTxVector,
                               std::map<uint16_t, CtrlBAckRequestHeader> recipients) const;
 
    void SendMultiStaBlockAck(const WifiTxParameters& txParams, Time durationId);
 
    void SendQosNullFramesInTbPpdu(const CtrlTriggerHeader& trigger, const WifiMacHeader& hdr);
 
    Ptr<ApWifiMac> m_apMac;          
    Ptr<StaWifiMac> m_staMac;        
    WifiTxVector m_trigVector;       
    Time m_intraBssNavEnd;           
    EventId m_intraBssNavResetEvent; 
 
  private:
    void SendPsduMap();
 
    void ReceiveBasicTrigger(const CtrlTriggerHeader& trigger, const WifiMacHeader& hdr);
 
    void ReceiveMuBarTrigger(const CtrlTriggerHeader& trigger,
                             uint8_t tid,
                             Time durationId,
                             double snr);
 
    WifiPsduMap m_psduMap;                        
    WifiTxParameters m_txParams;                  
    Ptr<MultiUserScheduler> m_muScheduler;        
    Ptr<WifiMpdu> m_triggerFrame;                 
    std::set<Mac48Address> m_staExpectTbPpduFrom; 
    EventId m_multiStaBaEvent;                    
    MuSnrTag m_muSnrTag;                          
    bool m_triggerFrameInAmpdu; 
};
 
} // namespace ns3
 
#endif /* HE_FRAME_EXCHANGE_MANAGER_H */