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);

    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 */