Attachment #2173 for bug #2193

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

(-)a/examples/wireless/power-adaptation-distance.cc (-1 / +1 lines)

Lines 172-178	Link Here

172

      WifiMode mode = phy->GetMode (i);

172

      WifiMode mode = phy->GetMode (i);

173

      WifiTxVector txVector;

173

      WifiTxVector txVector;

174

      txVector.SetMode (mode);

174

      txVector.SetMode (mode);

175

      timeTable.push_back (std::make_pair (phy->CalculateTxDuration (packetSize, txVector, WIFI_PREAMBLE_LONG, phy->GetFrequency (), NORMAL_MPDU, 0), mode));

175

      timeTable.push_back (std::make_pair (phy->CalculateTxDuration (packetSize, txVector, WIFI_PREAMBLE_LONG, phy->GetFrequency ()), mode));

176

177

178

(-)a/examples/wireless/power-adaptation-interference.cc (-1 / +1 lines)

Lines 168-174	Link Here

168

      WifiMode mode = phy->GetMode (i);

168

      WifiMode mode = phy->GetMode (i);

169

      WifiTxVector txVector;

169

      WifiTxVector txVector;

170

      txVector.SetMode (mode);

170

      txVector.SetMode (mode);

171

      timeTable.push_back (std::make_pair (phy->CalculateTxDuration (packetSize, txVector, WIFI_PREAMBLE_LONG, phy->GetFrequency (), NORMAL_MPDU, 0), mode));

171

      timeTable.push_back (std::make_pair (phy->CalculateTxDuration (packetSize, txVector, WIFI_PREAMBLE_LONG, phy->GetFrequency ()), mode));

172

173

174

(-)a/src/mesh/model/dot11s/airtime-metric.cc (-1 / +1 lines)

Lines 96-102	Link Here

  //calculate metric

  //calculate metric

  uint32_t metric = (uint32_t)((double)( /*Overhead + payload*/

  uint32_t metric = (uint32_t)((double)( /*Overhead + payload*/

                                 mac->GetPifs () + mac->GetSlot () + mac->GetEifsNoDifs () + //DIFS + SIFS + AckTxTime = PIFS + SLOT + EifsNoDifs

                                 mac->GetPifs () + mac->GetSlot () + mac->GetEifsNoDifs () + //DIFS + SIFS + AckTxTime = PIFS + SLOT + EifsNoDifs

                                 mac->GetWifiPhy ()->CalculateTxDuration (m_testFrame->GetSize (), txVector, WIFI_PREAMBLE_LONG, mac->GetWifiPhy ()->GetFrequency(), NORMAL_MPDU, 0)

                                 mac->GetWifiPhy ()->CalculateTxDuration (m_testFrame->GetSize (), txVector, WIFI_PREAMBLE_LONG, mac->GetWifiPhy ()->GetFrequency())

100

                                 ).GetMicroSeconds () / (10.24 * (1.0 - failAvg)));

100

                                 ).GetMicroSeconds () / (10.24 * (1.0 - failAvg)));

101

  return metric;

101

  return metric;

102

(-)a/src/wifi/examples/test-interference-helper.cc (-2 / +2 lines)

Lines 106-112	Link Here

106

  WifiTxVector txVector;

106

  WifiTxVector txVector;

107

  txVector.SetTxPowerLevel (m_input.txPowerLevelA);

107

  txVector.SetTxPowerLevel (m_input.txPowerLevelA);

108

  txVector.SetMode (WifiMode (m_input.txModeA));

108

  txVector.SetMode (WifiMode (m_input.txModeA));

109

  m_txA->SendPacket (p, txVector, m_input.preamble, NORMAL_MPDU);

109

  m_txA->SendPacket (p, txVector, m_input.preamble);

110

111

112

void

112

void

Lines 116-122	Link Here

116

  WifiTxVector txVector;

116

  WifiTxVector txVector;

117

  txVector.SetTxPowerLevel (m_input.txPowerLevelB);

117

  txVector.SetTxPowerLevel (m_input.txPowerLevelB);

118

  txVector.SetMode (WifiMode (m_input.txModeB));

118

  txVector.SetMode (WifiMode (m_input.txModeB));

119

  m_txB->SendPacket (p, txVector, m_input.preamble, NORMAL_MPDU);

119

  m_txB->SendPacket (p, txVector, m_input.preamble);

120

121

122

InterferenceExperiment::InterferenceExperiment ()

122

InterferenceExperiment::InterferenceExperiment ()




  WifiTxVector txVector;
  txVector.SetTxPowerLevel (m_input.txPowerLevel);
  txVector.SetMode (mode);
  m_tx->SendPacket (p, txVector, WIFI_PREAMBLE_LONG);
}

void

  WifiTxVector txVector;
  txVector.SetTxPowerLevel (m_input.txPowerLevelA);
  txVector.SetMode (WifiMode (m_input.txModeA));
  m_txA->SendPacket (p, txVector, WIFI_PREAMBLE_LONG);
}

void

  WifiTxVector txVector;
  txVector.SetTxPowerLevel (m_input.txPowerLevelB);
  txVector.SetMode (WifiMode (m_input.txModeB));
  m_txB->SendPacket (p, txVector, WIFI_PREAMBLE_LONG);
}

void




MacLow::GetAckDuration (WifiTxVector ackTxVector) const
{
  NS_ASSERT (ackTxVector.GetMode ().GetModulationClass () != WIFI_MOD_CLASS_HT); //ACK should always use non-HT PPDU (HT PPDU cases not supported yet)
  return m_phy->CalculateTxDuration (GetAckSize (), ackTxVector, WIFI_PREAMBLE_LONG, m_phy->GetFrequency ());
}

Time

    {
      preamble = WIFI_PREAMBLE_LONG;
    }
  return m_phy->CalculateTxDuration (GetBlockAckSize (type), blockAckReqTxVector, preamble, m_phy->GetFrequency ());
}

Time

MacLow::GetCtsDuration (WifiTxVector ctsTxVector) const
{
  NS_ASSERT (ctsTxVector.GetMode ().GetModulationClass () != WIFI_MOD_CLASS_HT); //CTS should always use non-HT PPDU (HT PPDU cases not supported yet)
  return m_phy->CalculateTxDuration (GetCtsSize (), ctsTxVector, WIFI_PREAMBLE_LONG, m_phy->GetFrequency ());
}

uint32_t

          //Otherwise, RTS should always use non-HT PPDU (HT PPDU cases not supported yet)
          preamble = WIFI_PREAMBLE_LONG;
        }
      txTime += m_phy->CalculateTxDuration (GetRtsSize (), rtsTxVector, preamble, m_phy->GetFrequency ());
      txTime += GetCtsDuration (hdr->GetAddr1 (), rtsTxVector);
      txTime += Time (GetSifs () * 2);
    }

      preamble = WIFI_PREAMBLE_LONG;
    }
  uint32_t dataSize = GetSize (packet, hdr);
  txTime += m_phy->CalculateTxDuration (dataSize, dataTxVector, preamble, m_phy->GetFrequency ());
  if (params.MustWaitAck ())
    {
      txTime += GetSifs ();

          preamble = WIFI_PREAMBLE_LONG;
        }
      txTime += GetSifs ();
      txTime += m_phy->CalculateTxDuration (params.GetNextPacketSize (), dataTxVector, preamble, m_phy->GetFrequency ());
    }
  return txTime;
}

          cts.SetType (WIFI_MAC_CTL_CTS);
          WifiTxVector txVector = GetRtsTxVector (packet, &hdr);
          Time navCounterResetCtsMissedDelay =
            m_phy->CalculateTxDuration (cts.GetSerializedSize (), txVector, preamble, m_phy->GetFrequency ()) +
            Time (2 * GetSifs ()) + Time (2 * GetSlotTime ());
          m_navCounterResetCtsMissed = Simulator::Schedule (navCounterResetCtsMissedDelay,
                                                            &MacLow::NavCounterResetCtsMissed, this,

                ", seq=0x" << std::hex << m_currentHdr.GetSequenceControl () << std::dec);
  if (!m_ampdu || hdr->IsRts ())
    {
      m_phy->SendPacket (packet, txVector, preamble);
    }
  else
    {

              ampdutag.SetNoOfMpdus (queueSize);
            }
          newPacket->AddPacketTag (ampdutag);
          
          if (delay == Seconds (0))
            {
              if (!vhtSingleMpdu)

            }
          else
            {
              Simulator::Schedule (delay, &MacLow::SendMpdu, this, newPacket, txVector, preamble, mpdutype);
            }
          if (queueSize > 1)
            {

}

void
MacLow::SendMpdu (Ptr<const Packet> packet, WifiTxVector txVector, WifiPreamble preamble, enum mpduType mpdutype)
{
  NS_LOG_DEBUG ("Sending MPDU as part of A-MPDU");
  m_phy->SendPacket (packet, txVector, preamble, mpdutype);

      duration += GetCtsDuration (m_currentHdr.GetAddr1 (), rtsTxVector);
      duration += GetSifs ();
      duration += m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr),
                                              dataTxVector, preamble, m_phy->GetFrequency ());
      duration += GetSifs ();
      if (m_txParams.MustWaitBasicBlockAck ())
        {

      if (m_txParams.HasNextPacket ())
        {
          duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (),
                                                  dataTxVector, preamble, m_phy->GetFrequency ());
          if (m_txParams.MustWaitAck ())
            {
              duration += GetSifs ();

    }
  rts.SetDuration (duration);

  Time txDuration = m_phy->CalculateTxDuration (GetRtsSize (), rtsTxVector, preamble, m_phy->GetFrequency ());
  Time timerDelay = txDuration + GetCtsTimeout ();

  NS_ASSERT (m_ctsTimeoutEvent.IsExpired ());

      preamble = WIFI_PREAMBLE_LONG;
    }

  Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), dataTxVector, preamble, m_phy->GetFrequency ());
  if (m_txParams.MustWaitNormalAck ())
    {
      Time timerDelay = txDuration + GetAckTimeout ();

        {
          duration += GetSifs ();
          duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (),
                                                  dataTxVector, preamble, m_phy->GetFrequency ());
          if (m_txParams.MustWaitAck ())
            {
              duration += GetSifs ();

      WifiTxVector dataTxVector = GetDataTxVector (m_currentPacket, &m_currentHdr);
      duration += GetSifs ();
      duration += m_phy->CalculateTxDuration (GetSize (m_currentPacket,&m_currentHdr),
                                              dataTxVector, preamble, m_phy->GetFrequency ());
      if (m_txParams.MustWaitBasicBlockAck ())
        {


        {
          duration += GetSifs ();
          duration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (),
                                                  dataTxVector, preamble, m_phy->GetFrequency ());
          if (m_txParams.MustWaitCompressedBlockAck ())
            {
              duration += GetSifs ();


  ForwardDown (packet, &cts, ctsTxVector,preamble);

  Time txDuration = m_phy->CalculateTxDuration (GetCtsSize (), ctsTxVector, preamble, m_phy->GetFrequency ());
  txDuration += GetSifs ();
  NS_ASSERT (m_sendDataEvent.IsExpired ());


  if (m_txParams.HasNextPacket ())
    {
      newDuration += GetSifs ();
      newDuration += m_phy->CalculateTxDuration (m_txParams.GetNextPacketSize (), dataTxVector, preamble, m_phy->GetFrequency ());
      if (m_txParams.MustWaitCompressedBlockAck ())
        {
          newDuration += GetSifs ();

        }
    }

  Time txDuration = m_phy->CalculateTxDuration (GetSize (m_currentPacket, &m_currentHdr), dataTxVector, preamble, m_phy->GetFrequency ());
  duration -= txDuration;
  duration -= GetSifs ();


    }

  //An HT STA shall not transmit a PPDU that has a duration that is greater than aPPDUMaxTime (10 milliseconds)
  if (m_phy->CalculateTxDuration (aggregatedPacket->GetSize () + peekedPacket->GetSize () + peekedHdr.GetSize () + WIFI_MAC_FCS_LENGTH, dataTxVector, preamble, m_phy->GetFrequency ()) > MilliSeconds (10))
    {
      NS_LOG_DEBUG ("no more packets can be aggregated to satisfy PPDU <= aPPDUMaxTime");
      return true;

(-)a/src/wifi/model/mac-low.h (-2 / +2 lines)

Lines 887-893	Link Here

887

  void ForwardDown (Ptr<const Packet> packet, const WifiMacHeader *hdr,

887

  void ForwardDown (Ptr<const Packet> packet, const WifiMacHeader *hdr,

888

                    WifiTxVector txVector, WifiPreamble preamble);

888

                    WifiTxVector txVector, WifiPreamble preamble);

889

/**

889

/**

890

   * Forward the packet down to WifiPhy for transmission. This is called for each MPDU when MPDU aggregation is used.

890

   * Forward the MPDU down to WifiPhy for transmission. This is called for each MPDU when MPDU aggregation is used.

891

892

   * \param packet

892

   * \param packet

893

   * \param hdr

893

   * \param hdr

Lines 895-901	Link Here

895

   * \param preamble

895

   * \param preamble

896

   * \param mpdutype

896

   * \param mpdutype

897

*/

897

*/

898

  void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, WifiPreamble preamble, enum mpduType mpdutype);

898

  void SendMpdu (Ptr<const Packet> packet, WifiTxVector txVector, WifiPreamble preamble, enum mpduType mpdutype);

899

/**

899

/**

900

   * Return a TXVECTOR for the RTS frame given the destination.

900

   * Return a TXVECTOR for the RTS frame given the destination.

901

   * The function consults WifiRemoteStationManager, which controls the rate

901

   * The function consults WifiRemoteStationManager, which controls the rate

(-)a/src/wifi/model/minstrel-wifi-manager.cc (-1 / +1 lines)

Lines 138-144	Link Here

138

      WifiMode mode = phy->GetMode (i);

138

      WifiMode mode = phy->GetMode (i);

139

      WifiTxVector txVector;

139

      WifiTxVector txVector;

140

      txVector.SetMode (mode);

140

      txVector.SetMode (mode);

141

      AddCalcTxTime (mode, phy->CalculateTxDuration (m_pktLen, txVector, WIFI_PREAMBLE_LONG, phy->GetFrequency (), NORMAL_MPDU, 0));

141

      AddCalcTxTime (mode, phy->CalculateTxDuration (m_pktLen, txVector, WIFI_PREAMBLE_LONG, phy->GetFrequency ()));

142

143

  WifiRemoteStationManager::SetupPhy (phy);

143

  WifiRemoteStationManager::SetupPhy (phy);

144




}

Time
WifiPhy::GetPayloadDuration (uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency)
{
  return GetPayloadDuration (size, txVector, preamble, frequency, NORMAL_MPDU, 0);
}

Time
WifiPhy::GetPayloadDuration (uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency, enum mpduType mpdutype, uint8_t incFlag)
{
  WifiMode payloadMode = txVector.GetMode ();

        //(Section 18.3.2.3 "Modulation-dependent parameters" Table 18-4 "Modulation-dependent parameters"; IEEE Std 802.11-2012)
        //corresponds to N_{DBPS} in the table
        double numDataBitsPerSymbol = payloadMode.GetDataRate (txVector.GetChannelWidth (), 0, 1) * symbolDuration.GetNanoSeconds () / 1e9;
        double numSymbols;
        uint32_t numSymbols;

        if (mpdutype == MPDU_IN_AGGREGATE && preamble != WIFI_PREAMBLE_NONE)
          {
            //First packet in an A-MPDU
            numSymbols = ((16 + size * 8.0 + 6) / numDataBitsPerSymbol);
            if (incFlag == 1)
              {
                m_totalAmpduSize += size;

            //last packet in an A-MPDU
            uint32_t totalAmpduSize = m_totalAmpduSize + size;
            numSymbols = lrint (ceil ((16 + totalAmpduSize * 8.0 + 6) / numDataBitsPerSymbol));
            NS_ASSERT (m_totalAmpduNumSymbols <= numSymbols);
            numSymbols -= m_totalAmpduNumSymbols;
            if (incFlag == 1)
              {

        //Add signal extension for ERP PHY
        if (payloadMode.GetModulationClass () == WIFI_MOD_CLASS_ERP_OFDM)
          {
            return NanoSeconds (numSymbols * symbolDuration.GetNanoSeconds ()) + MicroSeconds (6);
          }
        else
          {
            return NanoSeconds (numSymbols * symbolDuration.GetNanoSeconds ());
          }
      }
    case WIFI_MOD_CLASS_HT:

          }

        //IEEE Std 802.11n, section 20.3.11, equation (20-32)
        uint32_t numSymbols;
        double numDataBitsPerSymbol = payloadMode.GetDataRate (txVector.GetChannelWidth (), txVector.IsShortGuardInterval (), 1) * txVector.GetNss () * symbolDuration.GetNanoSeconds () / 1e9;
        double numSymbols;

        if (mpdutype == MPDU_IN_AGGREGATE && preamble != WIFI_PREAMBLE_NONE)
          {
            //First packet in an A-MPDU
            numSymbols = (m_Stbc * (16 + size * 8.0 + 6 * Nes) / (m_Stbc * numDataBitsPerSymbol));
            if (incFlag == 1)
              {
                m_totalAmpduSize += size;

        else if (mpdutype == MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE)
          {
            //consecutive packets in an A-MPDU
            numSymbols = (m_Stbc * size * 8.0) / (m_Stbc * numDataBitsPerSymbol);
            if (incFlag == 1)
              {
                m_totalAmpduSize += size;


        if (payloadMode.GetModulationClass () == WIFI_MOD_CLASS_HT && frequency >= 2400 && frequency <= 2500 && ((mpdutype == NORMAL_MPDU && preamble != WIFI_PREAMBLE_NONE) || (mpdutype == LAST_MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE))) //at 2.4 GHz
          {
            return NanoSeconds (numSymbols * symbolDuration.GetNanoSeconds ()) + MicroSeconds (6);
          }
        else //at 5 GHz
          {
            return NanoSeconds (numSymbols * symbolDuration.GetNanoSeconds ());
          }
      }
    case WIFI_MOD_CLASS_DSSS:

  return duration;
}

Time
WifiPhy::CalculateTxDuration (uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency)
{
  return CalculateTxDuration (size, txVector, preamble, frequency, NORMAL_MPDU, 0);
}

void
WifiPhy::NotifyTxBegin (Ptr<const Packet> packet)
{

(-)a/src/wifi/model/wifi-phy.h (-1 / +27 lines)

Lines 235-240	Link Here

235

   *        this packet, and txPowerLevel, a power level to use to send this packet. The real transmission

235

   *        this packet, and txPowerLevel, a power level to use to send this packet. The real transmission

236

   *        power is calculated as txPowerMin + txPowerLevel * (txPowerMax - txPowerMin) / nTxLevels

236

   *        power is calculated as txPowerMin + txPowerLevel * (txPowerMax - txPowerMin) / nTxLevels

237

   * \param preamble the type of preamble to use to send this packet.

237

   * \param preamble the type of preamble to use to send this packet.

238

*/

239

  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, enum WifiPreamble preamble) = 0;

240

/**

241

   * \param packet the packet to send

242

   * \param txVector the TXVECTOR that has tx parameters such as mode, the transmission mode to use to send

243

   *        this packet, and txPowerLevel, a power level to use to send this packet. The real transmission

244

   *        power is calculated as txPowerMin + txPowerLevel * (txPowerMax - txPowerMin) / nTxLevels

245

   * \param preamble the type of preamble to use to send this packet.

238

   * \param mpdutype the type of the MPDU as defined in WifiPhy::mpduType.

246

   * \param mpdutype the type of the MPDU as defined in WifiPhy::mpduType.

239

*/

247

*/

240

  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, enum WifiPreamble preamble, enum mpduType mpdutype) = 0;

248

  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, enum WifiPreamble preamble, enum mpduType mpdutype) = 0;

Lines 315-320	Link Here

315

   * \param txVector the TXVECTOR used for the transmission of this packet

323

   * \param txVector the TXVECTOR used for the transmission of this packet

316

   * \param preamble the type of preamble to use for this packet.

324

   * \param preamble the type of preamble to use for this packet.

317

   * \param frequency the channel center frequency (MHz)

325

   * \param frequency the channel center frequency (MHz)

326

327

   * \return the total amount of time this PHY will stay busy for the transmission of these bytes.

328

*/

329

  Time CalculateTxDuration (uint32_t size, WifiTxVector txVector, enum WifiPreamble preamble, double frequency);

330

/**

331

   * \param size the number of bytes in the packet to send

332

   * \param txVector the TXVECTOR used for the transmission of this packet

333

   * \param preamble the type of preamble to use for this packet.

334

   * \param frequency the channel center frequency (MHz)

318

   * \param mpdutype the type of the MPDU as defined in WifiPhy::mpduType.

335

   * \param mpdutype the type of the MPDU as defined in WifiPhy::mpduType.

319

   * \param incFlag this flag is used to indicate that the static variables need to be update or not. This function is called a couple of times for the same packet so static variables should not be increased each time.

336

   * \param incFlag this flag is used to indicate that the static variables need to be update or not. This function is called a couple of times for the same packet so static variables should not be increased each time.

320

337

Lines 401-406	Link Here

401

   * \param txVector the TXVECTOR used for the transmission of this packet

418

   * \param txVector the TXVECTOR used for the transmission of this packet

402

   * \param preamble the type of preamble to use for this packet

419

   * \param preamble the type of preamble to use for this packet

403

   * \param frequency the channel center frequency (MHz)

420

   * \param frequency the channel center frequency (MHz)

421

422

   * \return the duration of the payload

423

*/

424

  Time GetPayloadDuration (uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency);

425

/**

426

   * \param size the number of bytes in the packet to send

427

   * \param txVector the TXVECTOR used for the transmission of this packet

428

   * \param preamble the type of preamble to use for this packet

429

   * \param frequency the channel center frequency (MHz)

404

   * \param mpdutype the type of the MPDU as defined in WifiPhy::mpduType.

430

   * \param mpdutype the type of the MPDU as defined in WifiPhy::mpduType.

405

   * \param incFlag this flag is used to indicate that the static variables need to be update or not. This function is called a couple of times for the same packet so static variables should not be increased each time

431

   * \param incFlag this flag is used to indicate that the static variables need to be update or not. This function is called a couple of times for the same packet so static variables should not be increased each time

406

432

Lines 1327-1333	Link Here

1327

  TracedCallback<Ptr<const Packet>, uint16_t, uint16_t, uint32_t,

1353

  TracedCallback<Ptr<const Packet>, uint16_t, uint16_t, uint32_t,

1328

                 WifiPreamble, WifiTxVector, struct mpduInfo> m_phyMonitorSniffTxTrace;

1354

                 WifiPreamble, WifiTxVector, struct mpduInfo> m_phyMonitorSniffTxTrace;

1329

1355

1330

  uint32_t m_totalAmpduNumSymbols; //!< Number of symbols previously transmitted for the MPDUs in an A-MPDU, used for the computation of the number of symbols needed for the last MPDU in the A-MPDU

1356

  double m_totalAmpduNumSymbols;   //!< Number of symbols previously transmitted for the MPDUs in an A-MPDU, used for the computation of the number of symbols needed for the last MPDU in the A-MPDU

1331

  uint32_t m_totalAmpduSize;       //!< Total size of the previously transmitted MPDUs in an A-MPDU, used for the computation of the number of symbols needed for the last MPDU in the A-MPDU

1357

  uint32_t m_totalAmpduSize;       //!< Total size of the previously transmitted MPDUs in an A-MPDU, used for the computation of the number of symbols needed for the last MPDU in the A-MPDU

1332

};

1358

};

1333

1359

(-)a/src/wifi/model/yans-wifi-phy.cc (+6 lines)

Lines 767-772	Link Here

767

768

769

void

769

void

770

YansWifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, WifiPreamble preamble)

771

772

  SendPacket (packet, txVector, preamble, NORMAL_MPDU);

773

774

775

void

770

YansWifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, WifiPreamble preamble, enum mpduType mpdutype)

776

YansWifiPhy::SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, WifiPreamble preamble, enum mpduType mpdutype)

771

777

772

  NS_LOG_FUNCTION (this << packet << txVector.GetMode () << txVector.GetMode ().GetDataRate (txVector.GetChannelWidth (), txVector.IsShortGuardInterval (), 1) << preamble << (uint32_t)txVector.GetTxPowerLevel () << (uint32_t)mpdutype);

778

  NS_LOG_FUNCTION (this << packet << txVector.GetMode () << txVector.GetMode ().GetDataRate (txVector.GetChannelWidth (), txVector.IsShortGuardInterval (), 1) << preamble << (uint32_t)txVector.GetTxPowerLevel () << (uint32_t)mpdutype);

(-)a/src/wifi/model/yans-wifi-phy.h (+1 lines)

Lines 279-284	Link Here

279

280

  virtual void SetReceiveOkCallback (WifiPhy::RxOkCallback callback);

280

  virtual void SetReceiveOkCallback (WifiPhy::RxOkCallback callback);

281

  virtual void SetReceiveErrorCallback (WifiPhy::RxErrorCallback callback);

281

  virtual void SetReceiveErrorCallback (WifiPhy::RxErrorCallback callback);

282

  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, enum WifiPreamble preamble);

282

  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, enum WifiPreamble preamble, enum mpduType mpdutype);

283

  virtual void SendPacket (Ptr<const Packet> packet, WifiTxVector txVector, enum WifiPreamble preamble, enum mpduType mpdutype);

283

  virtual void RegisterListener (WifiPhyListener *listener);

284

  virtual void RegisterListener (WifiPhyListener *listener);

284

  virtual void UnregisterListener (WifiPhyListener *listener);

285

  virtual void UnregisterListener (WifiPhyListener *listener);




    {
      testedFrequency = CHANNEL_36_MHZ;
    }
  double calculatedDurationMicroSeconds = (double)phy->GetPayloadDuration (size, txVector, preamble, testedFrequency).GetMicroSeconds  ();
  if (calculatedDurationMicroSeconds != knownDurationMicroSeconds)
    {
      std::cerr << " size=" << size

    {
      //Durations vary depending on frequency; test also 2.4 GHz (bug 1971)
      testedFrequency = CHANNEL_1_MHZ;
      calculatedDurationMicroSeconds = (double)phy->GetPayloadDuration (size, txVector, preamble, testedFrequency).GetMicroSeconds ();
      if (calculatedDurationMicroSeconds != knownDurationMicroSeconds + 6)
        {
          std::cerr << " size=" << size

    {
      testedFrequency = CHANNEL_36_MHZ;
    }
  double calculatedDurationMicroSeconds = ((double)phy->CalculateTxDuration (size, txVector, preamble, testedFrequency).GetNanoSeconds ()) / 1000;
  if (calculatedDurationMicroSeconds != knownDurationMicroSeconds)
    {
      std::cerr << " size=" << size

    {
      //Durations vary depending on frequency; test also 2.4 GHz (bug 1971)
      testedFrequency = CHANNEL_1_MHZ;
      calculatedDurationMicroSeconds = ((double)phy->CalculateTxDuration (size, txVector, preamble, testedFrequency).GetNanoSeconds ()) / 1000;
      if (calculatedDurationMicroSeconds != knownDurationMicroSeconds + 6)
        {
          std::cerr << " size=" << size

Return to bug 2193