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 <stdint.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 void NotifyConstructionCompleted() override;

    virtual ~SatPhy();

    static TypeId GetTypeId(void);

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

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

    CreateParam_t m_params;

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