satellite-phy.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: Jani Puttonen <jani.puttonen@magister.fi>
 * Author: Mathias Ettinger <mettinger@toulouse.viveris.fr>
 */
 
#ifndef SATELLITE_PHY_H
#define SATELLITE_PHY_H
 
#include "satellite-antenna-gain-pattern.h"
#include "satellite-beam-channel-pair.h"
#include "satellite-frame-conf.h"
#include "satellite-node-info.h"
#include "satellite-phy-rx-carrier-conf.h"
#include "satellite-signal-parameters.h"
 
#include <ns3/address.h>
#include <ns3/nstime.h>
#include <ns3/object.h>
#include <ns3/packet.h>
#include <ns3/ptr.h>
 
#include <string>
 
namespace ns3
{
 
class SatPhyTx;
class SatPhyRx;
class SatChannel;
class SatMac;
 
class SatPhy : public Object
{
  public:
    typedef SatPhyRxCarrierConf::InterferenceModel InterferenceModel;
    typedef SatPhyRxCarrierConf::InterferenceEliminationModel InterferenceEliminationModel;
    typedef SatPhyRxCarrierConf::ErrorModel ErrorModel;
    typedef SatSignalParameters::PacketsInBurst_t PacketContainer_t;
 
    typedef Callback<void, PacketContainer_t, Ptr<SatSignalParameters>> ReceiveCallback;
 
    typedef Callback<void, uint32_t, uint32_t, Address, Address, double, bool> CnoCallback;
 
    typedef Callback<void, uint32_t, uint32_t, uint32_t, uint8_t, double>
        AverageNormalizedOfferedLoadCallback;
 
    typedef struct
    {
        Ptr<NetDevice> m_device;
        Ptr<SatChannel> m_txCh;
        Ptr<SatChannel> m_rxCh;
        uint32_t m_satId;
        uint32_t m_beamId;
        SatEnums::SatLoraNodeType_t m_standard;
    } CreateParam_t;
 
    SatPhy(void);
 
    SatPhy(CreateParam_t& params);
 
    virtual ~SatPhy();
 
    static TypeId GetTypeId(void);
    TypeId GetInstanceTypeId(void) const;
    virtual void DoInitialize(void);
 
    virtual void DoDispose(void);
 
    virtual double GetAdditionalInterference() = 0;
 
    double CalculateSinr(double sinr, double otherInterference);
 
    void Initialize();
 
    inline double GetRxNoiseTemperatureDbk() const
    {
        return m_rxNoiseTemperatureDbk;
    }
 
    inline void SetRxNoiseTemperatureDbk(double temperatureDbk)
    {
        m_rxNoiseTemperatureDbk = temperatureDbk;
    }
 
    inline double GetRxAntennaGainDb() const
    {
        return m_rxMaxAntennaGainDb;
    }
 
    inline void SetRxAntennaGainDb(double gainDb)
    {
        m_rxMaxAntennaGainDb = gainDb;
    }
 
    inline double GetRxAntennaLossDb() const
    {
        return m_rxAntennaLossDb;
    }
 
    inline void SetRxAntennaLossDb(double lossDb)
    {
        m_rxAntennaLossDb = lossDb;
    }
 
    inline double GetTxAntennaGainDb() const
    {
        return m_txMaxAntennaGainDb;
    }
 
    inline void SetTxAntennaGainDb(double gainDb)
    {
        m_txMaxAntennaGainDb = gainDb;
    }
 
    inline double GetTxMaxPowerDbw() const
    {
        return m_txMaxPowerDbw;
    }
 
    inline void SetTxMaxPowerDbw(double powerDb)
    {
        m_txMaxPowerDbw = powerDb;
    }
 
    inline double GetTxOutputLossDb() const
    {
        return m_txOutputLossDb;
    }
 
    inline void SetTxOutputLossDb(double lossDb)
    {
        m_txOutputLossDb = lossDb;
    }
 
    inline double GetTxPointingLossDb() const
    {
        return m_txPointingLossDb;
    }
 
    inline void SetTxPointingLossDb(double lossDb)
    {
        m_txPointingLossDb = lossDb;
    }
 
    inline double GetTxOboLossDb() const
    {
        return m_txOboLossDb;
    }
 
    inline void SetTxOboLossDb(double lossDb)
    {
        m_txOboLossDb = lossDb;
    }
 
    inline double GetTxAntennaLossDb() const
    {
        return m_txAntennaLossDb;
    }
 
    inline void SetTxAntennaLossDb(double lossDb)
    {
        m_txAntennaLossDb = lossDb;
    }
 
    inline double GetDefaultFading() const
    {
        return m_defaultFadingValue;
    }
 
    inline void SetDefaultFading(double fading)
    {
        m_defaultFadingValue = fading;
    }
 
    virtual void SetTxAntennaGainPattern(Ptr<SatAntennaGainPattern> agp,
                                         Ptr<SatMobilityModel> satelliteMobility);
 
    virtual void SetRxAntennaGainPattern(Ptr<SatAntennaGainPattern> agp,
                                         Ptr<SatMobilityModel> satelliteMobility);
 
    void ConfigureRxCarriers(Ptr<SatPhyRxCarrierConf> carrierConf,
                             Ptr<SatSuperframeConf> superFrameConf);
 
    void SetRxFadingContainer(Ptr<SatBaseFading> fadingContainer);
 
    void SetTxFadingContainer(Ptr<SatBaseFading> fadingContainer);
 
    virtual Ptr<SatPhyTx> GetPhyTx() const;
 
    virtual Ptr<SatPhyRx> GetPhyRx() const;
 
    virtual void SetPhyTx(Ptr<SatPhyTx> phyTx);
 
    virtual void SetPhyRx(Ptr<SatPhyRx> phyRx);
 
    Ptr<SatChannel> GetTxChannel();
 
    virtual void SendPdu(PacketContainer_t,
                         uint32_t carrierId,
                         Time duration,
                         SatSignalParameters::txInfo_s txInfo);
 
    virtual void SendPduWithParams(Ptr<SatSignalParameters> rxParams);
 
    void SetSatId(uint32_t satId);
 
    void SetBeamId(uint32_t beamId);
 
    virtual void Receive(Ptr<SatSignalParameters> rxParams, bool phyError);
 
    void CnoInfo(uint32_t satId,
                 uint32_t beamId,
                 Address source,
                 Address destination,
                 double cno,
                 bool isSatelliteMac);
 
    void AverageNormalizedOfferedRandomAccessLoadInfo(uint32_t satId,
                                                      uint32_t beamId,
                                                      uint32_t carrierId,
                                                      uint8_t allocationChannelId,
                                                      double averageNormalizedOfferedLoad);
 
    void SetNodeInfo(const Ptr<SatNodeInfo> nodeInfo);
 
    void BeginEndScheduling();
 
    typedef Callback<SatChannelPair::ChannelPair_t, uint32_t, uint32_t> ChannelPairGetterCallback;
 
    void SetChannelPairGetterCallback(SatPhy::ChannelPairGetterCallback cb);
 
  protected:
    virtual void RxTraces(SatPhy::PacketContainer_t packets);
 
    void ModcodTrace(Ptr<SatSignalParameters> rxParams);
 
    void SetTimeTag(SatPhy::PacketContainer_t packets);
 
    virtual SatEnums::SatLinkDir_t GetSatLinkTxDir();
 
    virtual SatEnums::SatLinkDir_t GetSatLinkRxDir();
 
    SatPhy::ReceiveCallback m_rxCallback;
 
    SatPhy::ChannelPairGetterCallback m_retrieveChannelPair;
 
    TracedCallback<Time,
                   SatEnums::SatPacketEvent_t,
                   SatEnums::SatNodeType_t,
                   uint32_t,
                   Mac48Address,
                   SatEnums::SatLogLevel_t,
                   SatEnums::SatLinkDir_t,
                   std::string>
        m_packetTrace;
 
    TracedCallback<Ptr<const Packet>, const Address&> m_rxTrace;
 
    TracedCallback<const Time&, const Address&> m_rxDelayTrace;
 
    TracedCallback<const Time&, const Address&> m_rxLinkDelayTrace;
 
    TracedCallback<const Time&, const Address&> m_rxJitterTrace;
 
    TracedCallback<const Time&, const Address&> m_rxLinkJitterTrace;
 
    TracedCallback<uint32_t, const Address&> m_rxLinkModcodTrace;
 
    Ptr<SatNodeInfo> m_nodeInfo;
 
    Ptr<SatPhyTx> m_phyTx;
 
    Ptr<SatPhyRx> m_phyRx;
 
    uint32_t m_satId;
 
    uint32_t m_beamId;
 
    double m_eirpWoGainW;
 
    bool m_isStatisticsTagsEnabled;
 
    Time m_lastDelay;
 
    Time m_lastLinkDelay;
 
  private:
    SatPhy::CnoCallback m_cnoCallback;
 
    SatPhy::AverageNormalizedOfferedLoadCallback m_avgNormalizedOfferedLoadCallback;
 
    double m_rxNoiseTemperatureDbk;
 
    double m_rxMaxAntennaGainDb;
 
    double m_rxAntennaLossDb;
 
    double m_txMaxAntennaGainDb;
 
    double m_txMaxPowerDbw;
 
    double m_txOutputLossDb;
 
    double m_txPointingLossDb;
 
    double m_txOboLossDb;
 
    double m_txAntennaLossDb;
 
    double m_defaultFadingValue;
};
 
} // namespace ns3
 
#endif /* SATELLITE_PHY_H */