Attachment #945 for bug #917

View | Details | Raw Unified | Return to bug 917
Collapse All | Expand All

(-)a/src/devices/wifi/mac-low.cc (-1 / +1 lines)

Lines 1135-1141	Link Here

1135

            ", mode=" << txMode <<

1135

            ", mode=" << txMode <<

1136

            ", duration=" << hdr->GetDuration () <<

1136

            ", duration=" << hdr->GetDuration () <<

1137

            ", seq=0x"<< std::hex << m_currentHdr.GetSequenceControl () << std::dec);

1137

            ", seq=0x"<< std::hex << m_currentHdr.GetSequenceControl () << std::dec);

1138

  m_phy->SendPacket (packet, txMode, WIFI_PREAMBLE_LONG, 0);

1138

  m_phy->SendPacket (packet, txMode, WIFI_PREAMBLE_LONG);

1139

1140

1141

void

1141

void




    Input ();
    double distance;
    std::string txMode;
    double txPowerDbm;
    uint32_t packetSize;
    uint32_t nPackets;
  };

private:
  void Send (void);
  void Receive (Ptr<Packet> p, double snr, WifiMode mode, enum WifiPreamble preamble);
  Ptr<YansWifiPhy> m_tx;
  struct Input m_input;
  struct Output m_output;
};

{
  Ptr<Packet> p = Create<Packet> (m_input.packetSize);
  WifiMode mode = WifiMode (m_input.txMode);
  m_tx->SetTxPower (m_input.txPowerDbm);
  m_tx->SendPacket (p, mode, WIFI_PREAMBLE_SHORT);
}

void 

PsrExperiment::Input::Input ()
  : distance (5.0),
    txMode ("OfdmRate6Mbps"),
    txPowerDbm (16.0206),
    packetSize (2304),
    nPackets (400)
{}

    double xB;
    std::string txModeA;
    std::string txModeB;
    double txPowerDbmA;
    double txPowerDbmB;
    uint32_t packetSizeA;
    uint32_t packetSizeB;
    uint32_t nPackets;

  void SendA (void) const;
  void SendB (void) const;
  void Receive (Ptr<Packet> p, double snr, WifiMode mode, enum WifiPreamble preamble);
  Ptr<YansWifiPhy> m_txA;
  Ptr<YansWifiPhy> m_txB;
  uint32_t m_flowIdA;
  uint32_t m_flowIdB;
  struct Input m_input;

{
  Ptr<Packet> p = Create<Packet> (m_input.packetSizeA);
  p->AddByteTag (FlowIdTag (m_flowIdA));
  m_txA->SetTxPower (m_input.txPowerDbmA);
  m_txA->SendPacket (p, WifiMode (m_input.txModeA), 
		     WIFI_PREAMBLE_SHORT);
}

void 

{
  Ptr<Packet> p = Create<Packet> (m_input.packetSizeB);
  p->AddByteTag (FlowIdTag (m_flowIdB));
  m_txB->SetTxPower (m_input.txPowerDbmB);
  m_txB->SendPacket (p, WifiMode (m_input.txModeB), 
		     WIFI_PREAMBLE_SHORT);
}

void 

    xB (5),
    txModeA ("OfdmRate6Mbps"),
    txModeB ("OfdmRate6Mbps"),
    txPowerDbmA (16.0206),
    txPowerDbmB (16.0206),
    packetSizeA (2304),
    packetSizeB (2304),
    nPackets (400)

  cmd.AddValue ("PacketSize", "The size of each packet sent", input.packetSize);
  cmd.AddValue ("TxMode", "The mode to use to send each packet", input.txMode);
  cmd.AddValue ("NPackets", "The number of packets to send", input.nPackets);
  cmd.AddValue ("TxPowerLevel", "The power level index to use to send each packet", input.txPowerDbm);
  cmd.Parse (argc, argv);

  struct PsrExperiment::Output output;

{
  struct PsrExperiment::Input input;
  CommandLine cmd;
  cmd.AddValue ("TxPowerLevel", "The power level index to use to send each packet", input.txPowerDbm);  
  cmd.AddValue ("TxMode", "The mode to use to send each packet", input.txMode);
  cmd.AddValue ("NPackets", "The number of packets to send", input.nPackets);
  cmd.AddValue ("PacketSize", "The size of each packet sent", input.packetSize);

  double targetPsr = 0.05;
  struct PsrExperiment::Input input;
  CommandLine cmd;
  cmd.AddValue ("TxPowerLevel", "The power level index to use to send each packet", input.txPowerDbm);  
  cmd.AddValue ("TxMode", "The mode to use to send each packet", input.txMode);
  cmd.AddValue ("NPackets", "The number of packets to send", input.nPackets);
  cmd.AddValue ("TargetPsr", "The psr needed to assume that we are within range", targetPsr);




  WifiPhy ();
  virtual ~WifiPhy ();

  /** 
   * 
   * \return the TX power being used, in dBm
   * \returns the number of tx power levels available for this PHY.
   */
  virtual double GetTxPower (void) const = 0;

  /**
   * \param callback the callback to invoke

   * \param packet the packet to send
   * \param mode the transmission mode to use to send this packet
   * \param preamble the type of preamble to use to send this packet.
   * \param txPowerLevel a power level to use to send this packet. The real
   *        transmission power is calculated as txPowerMin + txPowerLevel * (txPowerMax - txPowerMin) / nTxLevels
   */
  virtual void SendPacket (Ptr<const Packet> packet, WifiMode mode, enum WifiPreamble preamble) = 0;

  /**
   * \param listener the new listener




                   MakeDoubleAccessor (&YansWifiPhy::SetRxGain,
                                       &YansWifiPhy::GetRxGain),
                   MakeDoubleChecker<double> ())
    .AddAttribute ("TxPower",
                   "TX power to be used (dBm).",
                   "TxPowerBase and TxPowerEnd included.",
                   UintegerValue (1),
                   MakeUintegerAccessor (&YansWifiPhy::m_nTxPower),
                   MakeUintegerChecker<uint32_t> ())
    .AddAttribute ("TxPowerEnd",
                   "Maximum available transmission level (dbm).",
                   DoubleValue (16.0206),
                   MakeDoubleAccessor (&YansWifiPhy::SetTxPower, 
                                       &YansWifiPhy::GetTxPower),
                   MakeDoubleChecker<double> ())
    .AddAttribute ("TxPowerStart",
                   "Minimum available transmission level (dbm).",
                   DoubleValue (16.0206),
                   MakeDoubleAccessor (&YansWifiPhy::SetTxPowerStart, 
                                       &YansWifiPhy::GetTxPowerStart),
                   MakeDoubleChecker<double> ())
    .AddAttribute ("RxNoiseFigure",
                   "Loss (dB) in the Signal-to-Noise-Ratio due to non-idealities in the receiver."

  m_interference.SetNoiseFigure (DbToRatio (noiseFigureDb));
}
void 
YansWifiPhy::SetTxPower (double txPowerDbm)
{
  NS_LOG_FUNCTION (this << txPowerDbm);
  m_txPowerDbm = txPowerDbm;
}
void 
YansWifiPhy::SetTxPowerEnd (double end)
{
  NS_LOG_FUNCTION (this << end);
  m_txPowerEndDbm = end;
}
void 
YansWifiPhy::SetNTxPower (uint32_t n)
{
  NS_LOG_FUNCTION (this << n);
  m_nTxPower = n;
}
void 
YansWifiPhy::SetTxGain (double gain)

  return RatioToDb (m_interference.GetNoiseFigure ());
}
double 
YansWifiPhy::GetTxPower (void) const
{
  return m_txPowerDbm;
}
double 
YansWifiPhy::GetTxPowerEnd (void) const
{
  return m_txPowerEndDbm;
}
double 
YansWifiPhy::GetTxGain (void) const

}

void 
YansWifiPhy::SendPacket (Ptr<const Packet> packet, WifiMode txMode, WifiPreamble preamble)
{
  NS_LOG_FUNCTION (this << packet << txMode << preamble);
  /* Transmission can happen if:
   *  - we are syncing on a packet. It is the responsability of the
   *    MAC layer to avoid doing this but the PHY does nothing to 

  uint32_t dataRate500KbpsUnits = txMode.GetDataRate () / 500000;   
  bool isShortPreamble = (WIFI_PREAMBLE_SHORT == preamble);
  NotifyPromiscSniffTx (packet, (uint16_t)GetChannelFrequencyMhz (), GetChannelNumber (), dataRate500KbpsUnits, isShortPreamble);
  m_state->SwitchToTx (txDuration, packet, txMode, preamble, m_txPowerDbm);
  m_channel->Send (this, packet, m_txPowerDbm + m_txGainDb, txMode, preamble);
}

uint32_t 

{
  return m_deviceRateSet[mode];
}
uint32_t 
YansWifiPhy::GetNTxPower (void) const
{
  return m_nTxPower;
}

void
YansWifiPhy::Configure80211a (void)

  return m_edThresholdW;
}

double 
YansWifiPhy::GetPowerDbm (uint8_t power) const
{
  NS_ASSERT (m_txPowerBaseDbm <= m_txPowerEndDbm);
  NS_ASSERT (m_nTxPower > 0);
  double dbm;
  if (m_nTxPower > 1)
    {
      dbm = m_txPowerBaseDbm + power * (m_txPowerEndDbm - m_txPowerBaseDbm) / (m_nTxPower - 1);
    }
  else 
    {
      NS_ASSERT_MSG (m_txPowerBaseDbm == m_txPowerEndDbm, "cannot have TxPowerEnd != TxPowerStart with TxPowerLevels == 1");
      dbm = m_txPowerBaseDbm;
    }
  return dbm;
}

void
YansWifiPhy::EndReceive (Ptr<Packet> packet, Ptr<InterferenceHelper::Event> event)
{




                           WifiPreamble preamble);

  void SetRxNoiseFigure (double noiseFigureDb);
  void SetTxPower (double powerDbm);
  void SetTxPowerEnd (double end);
  void SetNTxPower (uint32_t n);
  void SetTxGain (double gain);
  void SetRxGain (double gain);
  void SetEdThreshold (double threshold);

  


  virtual double GetTxPower (void) const;
  virtual double GetTxPowerEnd (void) const;
  virtual uint32_t GetNTxPower (void) const;
  virtual void SetReceiveOkCallback (WifiPhy::RxOkCallback callback);
  virtual void SetReceiveErrorCallback (WifiPhy::RxErrorCallback callback);
  virtual void SendPacket (Ptr<const Packet> packet, WifiMode mode, enum WifiPreamble preamble);
  virtual void RegisterListener (WifiPhyListener *listener);
  virtual bool IsStateCcaBusy (void);
  virtual bool IsStateIdle (void);

  double DbToRatio (double db) const;
  double WToDbm (double w) const;
  double RatioToDb (double ratio) const;
  double GetPowerDbm (uint8_t power) const;
  void EndReceive (Ptr<Packet> packet, Ptr<InterferenceHelper::Event> event);

private:

  double   m_ccaMode1ThresholdW;
  double   m_txGainDb;
  double   m_rxGainDb;
  double   m_txPowerDbm;
  double   m_txPowerEndDbm;
  uint32_t m_nTxPower;

  Ptr<YansWifiChannel> m_channel;
  uint16_t m_channelNumber;

Return to bug 917