satellite-ncc.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 SAT_NCC_H
#define SAT_NCC_H
 
#include "satellite-beam-scheduler.h"
#include "satellite-gw-mac.h"
#include "satellite-orbiter-net-device.h"
 
#include <ns3/object.h>
#include <ns3/ptr.h>
#include <ns3/traced-callback.h>
 
#include <map>
#include <stdint.h>
#include <tuple>
#include <utility>
 
namespace ns3
{
 
class Packet;
class Address;
class SatCrMessage;
class SatSuperframeSeq;
class SatLowerLayerServiceConf;
 
class SatNcc : public Object
{
  public:
    static TypeId GetTypeId(void);
 
    virtual TypeId GetInstanceTypeId(void) const;
 
    SatNcc();
 
    ~SatNcc();
 
    void UtCnoUpdated(uint32_t satId,
                      uint32_t beamId,
                      Address sourceMac,
                      Address gwId,
                      double cno,
                      bool isSatelliteMac);
 
    void DoRandomAccessDynamicLoadControl(uint32_t satId,
                                          uint32_t beamId,
                                          uint32_t carrierId,
                                          uint8_t allocationChannelId,
                                          double averageNormalizedOfferedLoad);
 
    void UtCrReceived(uint32_t satId, uint32_t beamId, Address utId, Ptr<SatCrMessage> crMsg);
 
    typedef SatBeamScheduler::SendCtrlMsgCallback SendCallback;
 
    typedef Callback<void, Ptr<SatTbtpMessage>> SendTbtpCallback;
 
    void AddBeam(uint32_t satId,
                 uint32_t beamId,
                 Ptr<SatNetDevice> gwNetDevice,
                 Ptr<SatOrbiterNetDevice> orbiterNetDevice,
                 SatNcc::SendCallback cb,
                 SatNcc::SendTbtpCallback tbtpCb,
                 Ptr<SatSuperframeSeq> seq,
                 uint32_t maxFrameSizeInBytes,
                 Address satAddress,
                 Address gwAddress);
 
    void AddUt(Ptr<SatLowerLayerServiceConf> llsConf,
               Address utId,
               uint32_t satId,
               uint32_t beamId,
               Callback<void, uint32_t> setRaChannelCallback,
               bool verifyExisting = false);
 
    void RemoveUt(Address utId, uint32_t satId, uint32_t beamId);
 
    void SetRandomAccessAverageNormalizedOfferedLoadThreshold(uint8_t allocationChannelId,
                                                              double threshold);
 
    void SetRandomAccessLowLoadBackoffProbability(uint8_t allocationChannelId,
                                                  uint16_t lowLoadBackOffProbability);
 
    void SetRandomAccessHighLoadBackoffProbability(uint8_t allocationChannelId,
                                                   uint16_t highLoadBackOffProbability);
 
    void SetRandomAccessLowLoadBackoffTime(uint8_t allocationChannelId,
                                           uint16_t lowLoadBackOffTime);
 
    void SetRandomAccessHighLoadBackoffTime(uint8_t allocationChannelId,
                                            uint16_t highLoadBackOffTime);
 
    Ptr<SatBeamScheduler> GetBeamScheduler(uint32_t satId, uint32_t beamId) const;
 
    void MoveUtBetweenBeams(Address utId,
                            uint32_t srcSatId,
                            uint32_t srcBeamId,
                            uint32_t destSatId,
                            uint32_t destBeamId);
 
    typedef Callback<void, Address, Address, Address> UpdateRoutingCallback;
 
    void SetUpdateRoutingCallback(SatNcc::UpdateRoutingCallback cb);
 
    void ReserveLogonChannel(uint32_t logonChannelId);
 
    void ReceiveControlBurst(Address utId, uint32_t satId, uint32_t beamId);
 
    void SetUseLogon(bool useLogon);
 
    void SetUseLora(bool useLora);
 
  private:
    SatNcc& operator=(const SatNcc&);
    SatNcc(const SatNcc&);
 
    void DoDispose(void);
 
    void CreateRandomAccessLoadControlMessage(uint16_t backoffProbability,
                                              uint16_t backoffTime,
                                              uint32_t satId,
                                              uint32_t beamId,
                                              uint8_t allocationChannelId);
 
    void DoMoveUtBetweenBeams(Address utId,
                              uint32_t srcSatId,
                              uint32_t srcBeamId,
                              uint32_t destSatId,
                              uint32_t destBeamId);
 
    void CheckTimeout(Address utId, uint32_t satId, uint32_t beamId);
 
    std::map<std::pair<uint32_t, uint32_t>, Ptr<SatBeamScheduler>> m_beamSchedulers;
 
    TracedCallback<Ptr<const Packet>> m_nccRxTrace;
 
    TracedCallback<Ptr<const Packet>> m_nccTxTrace;
 
    std::map<std::tuple<uint32_t, uint32_t, uint8_t>, bool> m_isLowRandomAccessLoad;
 
    std::map<uint8_t, double> m_randomAccessAverageNormalizedOfferedLoadThreshold;
 
    std::map<uint8_t, uint16_t> m_lowLoadBackOffProbability;
 
    std::map<uint8_t, uint16_t> m_highLoadBackOffProbability;
 
    std::map<uint8_t, uint16_t> m_lowLoadBackOffTime;
 
    std::map<uint8_t, uint16_t> m_highLoadBackOffTime;
 
    Time m_utHandoverDelay;
 
    Time m_utTimeout;
 
    bool m_useLogon;
 
    bool m_useLora;
 
    std::map<std::tuple<Address, uint32_t, uint32_t>, Time> m_lastControlBurstReception;
 
    UpdateRoutingCallback m_updateRoutingCallback;
};
 
} // namespace ns3
 
#endif /* SAT_NCC_H */