satellite-ut-mac.h

Go to the documentation of this file.

/* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */
/*
 * Copyright (c) 2013 Magister Solutions Ltd
 * Copyright (c) 2018 CNES
 *
 * 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: Sami Rantanen <sami.rantanen@magister.fi>
 * Author: Mathias Ettinger <mettinger@toulouse.viveris.fr>
 */
 
#ifndef SATELLITE_UT_MAC_H
#define SATELLITE_UT_MAC_H
 
#include "satellite-beam-scheduler.h"
#include "satellite-enums.h"
#include "satellite-mac.h"
#include "satellite-phy.h"
#include "satellite-queue.h"
#include "satellite-random-access-container.h"
#include "satellite-signal-parameters.h"
#include "satellite-ut-mac-state.h"
#include "satellite-ut-scheduler.h"
 
#include <ns3/callback.h>
#include <ns3/nstime.h>
#include <ns3/ptr.h>
#include <ns3/traced-callback.h>
#include <ns3/traced-value.h>
 
#include <utility>
 
namespace ns3
{
 
class Packet;
class Mac48Address;
class SatSuperframeSeq;
class SatNodeInfo;
class SatFrameConf;
class SatTbtpMessage;
class SatWaveform;
class SatTimeSlotConf;
class SatTbtpContainer;
class UniformRandomVariable;
 
class SatUtMac : public SatMac
{
  public:
    static TypeId GetTypeId(void);
    virtual TypeId GetInstanceTypeId(void) const;
 
    SatUtMac();
 
    SatUtMac(uint32_t satId,
             uint32_t beamId,
             Ptr<SatSuperframeSeq> seq,
             SatEnums::RegenerationMode_t forwardLinkRegenerationMode,
             SatEnums::RegenerationMode_t returnLinkRegenerationMode,
             bool crdsaOnlyForControl);
 
    ~SatUtMac();
 
    inline uint32_t GetSatId() const
    {
        return m_satId;
    }
 
    inline uint32_t GetBeamId() const
    {
        return m_beamId;
    }
 
    virtual void Receive(SatPhy::PacketContainer_t packets, Ptr<SatSignalParameters> /*rxParams*/);
 
    typedef Callback<Time> TimingAdvanceCallback;
 
    void SetTimingAdvanceCallback(SatUtMac::TimingAdvanceCallback cb);
 
    typedef Callback<void, uint8_t, uint32_t> AssignedDaResourcesCallback;
 
    void SetAssignedDaResourcesCallback(SatUtMac::AssignedDaResourcesCallback cb);
 
    typedef Callback<bool> TxCheckCallback;
 
    void SetTxCheckCallback(SatUtMac::TxCheckCallback cb);
 
    typedef Callback<void, uint8_t> SliceSubscriptionCallback;
 
    void SetSliceSubscriptionCallback(SatUtMac::SliceSubscriptionCallback cb);
 
    typedef Callback<void> SendLogonCallback;
 
    void SetSendLogonCallback(SatUtMac::SendLogonCallback cb);
 
    typedef Callback<void, Mac48Address> UpdateGwAddressCallback;
 
    void SetUpdateGwAddressCallback(SatUtMac::UpdateGwAddressCallback cb);
 
    typedef Callback<Ptr<SatBeamScheduler>, uint32_t, uint32_t> BeamScheculerCallback;
 
    void SetBeamScheculerCallback(SatUtMac::BeamScheculerCallback cb);
 
    Time GetNextSuperFrameTxTime(uint8_t superFrameSeqId) const;
 
    virtual void ReceiveQueueEvent(SatQueue::QueueEvent_t event, uint8_t rcIndex);
 
    virtual void ReceiveQueueEventEssa(SatQueue::QueueEvent_t event, uint8_t rcIndex);
 
    void SendLogon(Ptr<Packet> packet);
 
    virtual void SetSatelliteAddress(Address satelliteAddress);
 
    Mac48Address GetGwAddress();
 
    void SetGwAddress(Mac48Address gwAddress);
 
    virtual void SetNodeInfo(Ptr<SatNodeInfo> nodeInfo);
 
    void SetRaChannel(uint32_t raChannel);
 
    uint32_t GetRaChannel() const;
 
    void SetRandomAccess(Ptr<SatRandomAccess> randomAccess);
 
    bool ControlMsgTransmissionPossible() const;
 
    bool LogonMsgTransmissionPossible() const;
 
    typedef void (*TbtpResourcesTraceCallback)(uint32_t size);
 
    typedef Callback<void, uint32_t> HandoverCallback;
 
    void SetHandoverCallback(SatUtMac::HandoverCallback cb);
 
    typedef Callback<void, Mac48Address> GatewayUpdateCallback;
 
    void SetGatewayUpdateCallback(SatUtMac::GatewayUpdateCallback cb);
 
    typedef Callback<bool, uint32_t, uint32_t> BeamCheckerCallback;
 
    typedef Callback<uint32_t> AskedBeamCallback;
 
    void SetBeamCheckerCallback(SatUtMac::BeamCheckerCallback cb);
 
    void SetAskedBeamCallback(SatUtMac::AskedBeamCallback cb);
 
    void LogOff();
 
    void SetLogonChannel(uint32_t channelId);
 
    SatUtMacState::RcstState_t GetRcstState() const;
 
  protected:
    void DoDispose(void);
 
  private:
    Time GetCurrentSuperFrameStartTime(uint8_t superFrameSeqId) const;
 
    uint32_t GetCurrentSuperFrameId(uint8_t superFrameSeqId) const;
 
    void DoRandomAccess(SatEnums::RandomAccessTriggerType_t randomAccessTriggerType);
 
    uint32_t GetNextRandomAccessAllocationChannel();
 
    void ScheduleSlottedAlohaTransmission(uint32_t allocationChannel);
 
    void ScheduleEssaTransmission(uint32_t allocationChannel);
 
    void ScheduleCrdsaTransmission(uint32_t allocationChannel,
                                   SatRandomAccess::RandomAccessTxOpportunities_s txOpportunities);
 
    void CreateCrdsaPacketInstances(uint32_t allocationChannel, std::set<uint32_t> slots);
 
    void RemovePastRandomAccessSlots(uint32_t superFrameId);
 
    bool UpdateUsedRandomAccessSlots(uint32_t superFrameId,
                                     uint32_t allocationChannel,
                                     uint32_t slot);
 
    std::pair<bool, uint32_t> FindNextAvailableRandomAccessSlot(Time opportunityOffset,
                                                                Ptr<SatFrameConf> frameConf,
                                                                uint32_t timeSlotCount,
                                                                uint32_t superFrameId,
                                                                uint32_t allocationChannel);
 
    std::pair<bool, uint32_t> SearchFrameForAvailableSlot(Time superframeStartTime,
                                                          Ptr<SatFrameConf> frameConf,
                                                          uint32_t timeSlotCount,
                                                          uint32_t superFrameId,
                                                          uint32_t allocationChannel);
 
    bool IsRandomAccessSlotAvailable(uint32_t superFrameId,
                                     uint32_t allocationChannelId,
                                     uint32_t slotId);
 
    void PrintUsedRandomAccessSlots();
 
    void ScheduleTimeSlots(Ptr<SatTbtpMessage> tbtp);
 
    void ScheduleDaTxOpportunity(Time transmitDelay,
                                 Time duration,
                                 Ptr<SatWaveform> wf,
                                 Ptr<SatTimeSlotConf> tsConf,
                                 uint32_t carrierId);
 
    void DoTransmit(Time duration,
                    uint32_t carrierId,
                    Ptr<SatWaveform> wf,
                    Ptr<SatTimeSlotConf> tsConf,
                    SatUtScheduler::SatCompliancePolicy_t policy = SatUtScheduler::LOOSE);
 
    void DoSlottedAlohaTransmit(
        Time duration,
        Ptr<SatWaveform> waveform,
        uint32_t carrierId,
        uint8_t rcIndex,
        SatUtScheduler::SatCompliancePolicy_t policy = SatUtScheduler::LOOSE);
 
    void DoEssaTransmit(Time duration,
                        Ptr<SatWaveform> waveform,
                        uint32_t carrierId,
                        uint8_t rcIndex,
                        SatUtScheduler::SatCompliancePolicy_t policy = SatUtScheduler::LOOSE);
 
    SatPhy::PacketContainer_t FetchPackets(uint32_t payloadBytes,
                                           SatTimeSlotConf::SatTimeSlotType_t type,
                                           uint8_t rcIndex,
                                           SatUtScheduler::SatCompliancePolicy_t policy);
 
    void ExtractPacketsToSchedule(SatPhy::PacketContainer_t& packets,
                                  uint32_t payloadBytes,
                                  SatTimeSlotConf::SatTimeSlotType_t type,
                                  uint8_t rcIndex,
                                  SatUtScheduler::SatCompliancePolicy_t policy,
                                  bool randomAccessChannel);
 
    void TransmitPackets(SatPhy::PacketContainer_t packets,
                         Time duration,
                         uint32_t carrierId,
                         SatSignalParameters::txInfo_s txInfo);
 
    void ReceiveSignalingPacket(Ptr<Packet> packet);
 
    void DoFrameStart();
 
    Time GetRealSendingTime(Time t);
 
    SatUtMac& operator=(const SatUtMac&);
    SatUtMac(const SatUtMac&);
 
    uint32_t m_satId;
 
    uint32_t m_beamId;
 
    Ptr<SatSuperframeSeq> m_superframeSeq;
 
    TimingAdvanceCallback m_timingAdvanceCb;
 
    AssignedDaResourcesCallback m_assignedDaResourcesCallback;
 
    Ptr<SatRandomAccess> m_randomAccess;
 
    Time m_guardTime;
 
    Ptr<SatTbtpContainer> m_tbtpContainer;
 
    Ptr<UniformRandomVariable> m_uniformRandomVariable;
 
    std::map<std::pair<uint32_t, uint32_t>, std::set<uint32_t>> m_usedRandomAccessSlots;
 
    uint32_t m_raChannel;
 
    uint32_t m_logonChannel;
 
    bool m_loggedOn;
 
    bool m_useLogon;
 
    uint32_t m_sendLogonTries;
 
    Time m_windowInitLogon;
 
    Time m_maxWaitingTimeLogonResponse;
    Ptr<UniformRandomVariable> m_waitingTimeLogonRng;
 
    Time m_nextLogonTransmissionPossible;
 
    Ptr<SatUtScheduler> m_utScheduler;
 
    TracedCallback<uint32_t> m_tbtpResourcesTrace;
 
    uint32_t m_crdsaUniquePacketId;
 
    bool m_crdsaOnlyForControl;
 
    Time m_nextPacketTime;
 
    bool m_isRandomAccessScheduled;
 
    class SatTimuInfo : public SimpleRefCount<SatTimuInfo>
    {
      public:
        SatTimuInfo(uint32_t beamId, Address address);
 
        uint32_t GetBeamId() const;
 
        Address GetGwAddress() const;
 
      private:
        uint32_t m_beamId;
        Address m_gwAddress;
    };
 
    Ptr<SatTimuInfo> m_timuInfo;
 
    Mac48Address m_gwAddress;
 
    SatUtMacState m_rcstState;
 
    Time m_lastNcrDateReceived;
 
    uint64_t m_ncr;
 
    int64_t m_deltaNcr;
 
    int32_t m_clockDrift;
 
    std::queue<Time> m_receptionDates;
 
    typedef enum
    {
        NO_HANDOVER,
        HANDOVER_RECOMMENDATION_SENT,
        WAITING_FOR_TBTP,
    } HandoverState_t;
 
    HandoverState_t m_handoverState;
 
    uint32_t m_handoverMessagesCount;
    uint32_t m_maxHandoverMessagesSent;
 
    uint32_t m_firstTransmittableSuperframeId;
 
    SatUtMac::HandoverCallback m_handoverCallback;
 
    SatUtMac::GatewayUpdateCallback m_gatewayUpdateCallback;
 
    SatUtMac::BeamCheckerCallback m_beamCheckerCallback;
 
    SatUtMac::AskedBeamCallback m_askedBeamCallback;
 
    SatUtMac::TxCheckCallback m_txCheckCallback;
 
    SatUtMac::SliceSubscriptionCallback m_sliceSubscriptionCallback;
 
    SatUtMac::SendLogonCallback m_sendLogonCallback;
 
    SatUtMac::UpdateGwAddressCallback m_updateGwAddressCallback;
 
    SatUtMac::BeamScheculerCallback m_beamScheculerCallback;
};
 
} // namespace ns3
 
#endif /* SATELLITE_UT_MAC_H */