Attachment #2171 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)

                {
                  mpdutype = NORMAL_MPDU;
                }
              m_phy->SendPacket (newPacket, packet->GetSize (), txVector, preamble, mpdutype);
            }
          else
            {
              Simulator::Schedule (delay, &MacLow::SendMpdu, this, newPacket, packet->GetSize (), txVector, preamble, mpdutype);
            }
          if (queueSize > 1)
            {
              delay = delay + m_phy->CalculateTxDuration (GetSize (newPacket, &newHdr), packet->GetSize (), txVector, preamble, m_phy->GetFrequency (), mpdutype, 0);
            }
          preamble = WIFI_PREAMBLE_NONE;
        }

}

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

void

      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;




  void ForwardDown (Ptr<const Packet> packet, const WifiMacHeader *hdr,
                    WifiTxVector txVector, WifiPreamble preamble);
  /**
   * Forward the MPDU down to WifiPhy for transmission. This is called for each MPDU when MPDU aggregation is used.
   *
   * \param packet
   * \param ampduSize
   * \param hdr
   * \param txVector
   * \param preamble
   * \param mpdutype
   */
  void SendMpdu (Ptr<const Packet> packet, uint32_t ampduSize, WifiTxVector txVector, WifiPreamble preamble, enum mpduType mpdutype);
  /**
   * Return a TXVECTOR for the RTS frame given the destination.
   * 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

(-)a/src/wifi/model/wifi-phy.cc (-18 / +60 lines)

Lines 395-404	Link Here

395

396

397

Time

397

Time

398

WifiPhy::GetPayloadDuration (uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency, enum mpduType mpdutype, uint8_t incFlag)

398

WifiPhy::GetPayloadDuration (uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency)

399

400

  return GetPayloadDuration (size, size, txVector, preamble, frequency, NORMAL_MPDU, 0);

401

402

403

Time

404

WifiPhy::GetPayloadDuration (uint32_t mpduSize, uint32_t ampduSize, WifiTxVector txVector, WifiPreamble preamble, double frequency, enum mpduType mpdutype, uint8_t incFlag)

399

405

400

  WifiMode payloadMode = txVector.GetMode ();

406

  WifiMode payloadMode = txVector.GetMode ();

401

  NS_LOG_FUNCTION (size << payloadMode);

407

  NS_LOG_FUNCTION (mpduSize << payloadMode);

402

408

403

  switch (payloadMode.GetModulationClass ())

409

  switch (payloadMode.GetModulationClass ())

404

410

Lines 432-458	Link Here

432

        if (mpdutype == MPDU_IN_AGGREGATE && preamble != WIFI_PREAMBLE_NONE)

438

        if (mpdutype == MPDU_IN_AGGREGATE && preamble != WIFI_PREAMBLE_NONE)

433

439

434

            //First packet in an A-MPDU

440

            //First packet in an A-MPDU

435

            numSymbols = ceil ((16 + size * 8.0 + 6) / numDataBitsPerSymbol);

441

            numSymbols = ceil ((16 + mpduSize * 8.0 + 6) / numDataBitsPerSymbol);

436

            if (incFlag == 1)

442

            if (incFlag == 1)

437

443

438

                m_totalAmpduSize += size;

444

                m_totalAmpduSize += mpduSize;

439

                m_totalAmpduNumSymbols += numSymbols;

445

                m_totalAmpduNumSymbols += numSymbols;

446

                NS_ASSERT (m_totalAmpduSize <= ampduSize);

447

                uint32_t expectedTotalSymbols = lrint (ceil ((16 + ampduSize * 8.0 + 6) / numDataBitsPerSymbol));

448

                if (m_totalAmpduNumSymbols == expectedTotalSymbols)

449

450

                    //Workaround to avoid to have null duration for the last MPDU when it is has a small size (e.g. BAR, ...).

451

                    m_totalAmpduNumSymbols--;

452

440

453

441

454

442

        else if (mpdutype == MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE)

455

        else if (mpdutype == MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE)

443

456

444

            //consecutive packets in an A-MPDU

457

            //consecutive packets in an A-MPDU

445

            numSymbols = ((size * 8.0) / numDataBitsPerSymbol);

458

            numSymbols = ((mpduSize * 8.0) / numDataBitsPerSymbol);

446

            if (incFlag == 1)

459

            if (incFlag == 1)

447

460

448

                m_totalAmpduSize += size;

461

                m_totalAmpduSize += mpduSize;

449

                m_totalAmpduNumSymbols += numSymbols;

462

                m_totalAmpduNumSymbols += numSymbols;

463

                NS_ASSERT (m_totalAmpduSize <= ampduSize);

464

                uint32_t expectedTotalSymbols = lrint (ceil ((16 + ampduSize * 8.0 + 6) / numDataBitsPerSymbol));

465

                if (m_totalAmpduNumSymbols == expectedTotalSymbols)

466

467

                    //Workaround to avoid to have null duration for the last MPDU when it is has a small size (e.g. BAR, ...).

468

                    m_totalAmpduNumSymbols--;

469

450

470

451

471

452

        else if (mpdutype == LAST_MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE)

472

        else if (mpdutype == LAST_MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE)

453

473

454

            //last packet in an A-MPDU

474

            //last packet in an A-MPDU

455

            uint32_t totalAmpduSize = m_totalAmpduSize + size;

475

            uint32_t totalAmpduSize = m_totalAmpduSize + mpduSize;

476

            NS_ASSERT (totalAmpduSize == ampduSize);

456

            numSymbols = lrint (ceil ((16 + totalAmpduSize * 8.0 + 6) / numDataBitsPerSymbol));

477

            numSymbols = lrint (ceil ((16 + totalAmpduSize * 8.0 + 6) / numDataBitsPerSymbol));

457

            numSymbols -= m_totalAmpduNumSymbols;

478

            numSymbols -= m_totalAmpduNumSymbols;

458

            if (incFlag == 1)

479

            if (incFlag == 1)

Lines 464-470	Link Here

464

        else if (mpdutype == NORMAL_MPDU && preamble != WIFI_PREAMBLE_NONE)

485

        else if (mpdutype == NORMAL_MPDU && preamble != WIFI_PREAMBLE_NONE)

465

486

466

            //Not an A-MPDU

487

            //Not an A-MPDU

467

            numSymbols = lrint (ceil ((16 + size * 8.0 + 6.0) / numDataBitsPerSymbol));

488

            numSymbols = lrint (ceil ((16 + mpduSize * 8.0 + 6.0) / numDataBitsPerSymbol));

468

489

469

        else

490

        else

470

491

Lines 526-552	Link Here

526

        if (mpdutype == MPDU_IN_AGGREGATE && preamble != WIFI_PREAMBLE_NONE)

547

        if (mpdutype == MPDU_IN_AGGREGATE && preamble != WIFI_PREAMBLE_NONE)

527

548

528

            //First packet in an A-MPDU

549

            //First packet in an A-MPDU

529

            numSymbols = ceil (m_Stbc * (16 + size * 8.0 + 6 * Nes) / (m_Stbc * numDataBitsPerSymbol));

550

            numSymbols = ceil (m_Stbc * (16 + mpduSize * 8.0 + 6 * Nes) / (m_Stbc * numDataBitsPerSymbol));

530

            if (incFlag == 1)

551

            if (incFlag == 1)

531

552

532

                m_totalAmpduSize += size;

553

                m_totalAmpduSize += mpduSize;

533

                m_totalAmpduNumSymbols += numSymbols;

554

                m_totalAmpduNumSymbols += numSymbols;

555

                NS_ASSERT (m_totalAmpduSize <= ampduSize);

556

                uint32_t expectedTotalSymbols = lrint (m_Stbc * ceil ((16 + ampduSize * 8.0 + 6 * Nes) / (m_Stbc * numDataBitsPerSymbol)));

557

                if (m_totalAmpduNumSymbols == expectedTotalSymbols)

558

559

                    //Workaround to avoid to have null duration for the last MPDU when it is has a small size (e.g. BAR, ...).

560

                    m_totalAmpduNumSymbols--;

561

534

562

535

563

536

        else if (mpdutype == MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE)

564

        else if (mpdutype == MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE)

537

565

538

            //consecutive packets in an A-MPDU

566

            //consecutive packets in an A-MPDU

539

            numSymbols = m_Stbc * ((size * 8.0 ) / (m_Stbc * numDataBitsPerSymbol));

567

            numSymbols = m_Stbc * ((mpduSize * 8.0 ) / (m_Stbc * numDataBitsPerSymbol));

540

            if (incFlag == 1)

568

            if (incFlag == 1)

541

569

542

                m_totalAmpduSize += size;

570

                m_totalAmpduSize += mpduSize;

543

                m_totalAmpduNumSymbols += numSymbols;

571

                m_totalAmpduNumSymbols += numSymbols;

572

                NS_ASSERT (m_totalAmpduSize <= ampduSize);

573

                uint32_t expectedTotalSymbols = lrint (m_Stbc * ceil ((16 + ampduSize * 8.0 + 6 * Nes) / (m_Stbc * numDataBitsPerSymbol)));

574

                if (m_totalAmpduNumSymbols == expectedTotalSymbols)

575

576

                    //Workaround to avoid to have null duration for the last MPDU when it is has a small size (e.g. BAR, ...).

577

                    m_totalAmpduNumSymbols--;

578

544

579

545

580

546

        else if (mpdutype == LAST_MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE)

581

        else if (mpdutype == LAST_MPDU_IN_AGGREGATE && preamble == WIFI_PREAMBLE_NONE)

547

582

548

            //last packet in an A-MPDU

583

            //last packet in an A-MPDU

549

            uint32_t totalAmpduSize = m_totalAmpduSize + size;

584

            uint32_t totalAmpduSize = m_totalAmpduSize + mpduSize;

585

            NS_ASSERT (totalAmpduSize == ampduSize);

550

            numSymbols = lrint (m_Stbc * ceil ((16 + totalAmpduSize * 8.0 + 6 * Nes) / (m_Stbc * numDataBitsPerSymbol)));

586

            numSymbols = lrint (m_Stbc * ceil ((16 + totalAmpduSize * 8.0 + 6 * Nes) / (m_Stbc * numDataBitsPerSymbol)));

551

            NS_ASSERT (m_totalAmpduNumSymbols <= numSymbols);

587

            NS_ASSERT (m_totalAmpduNumSymbols <= numSymbols);

552

            numSymbols -= m_totalAmpduNumSymbols;

588

            numSymbols -= m_totalAmpduNumSymbols;

Lines 559-565	Link Here

559

        else if (mpdutype == NORMAL_MPDU && preamble != WIFI_PREAMBLE_NONE)

595

        else if (mpdutype == NORMAL_MPDU && preamble != WIFI_PREAMBLE_NONE)

560

596

561

            //Not an A-MPDU

597

            //Not an A-MPDU

562

            numSymbols = lrint (m_Stbc * ceil ((16 + size * 8.0 + 6.0 * Nes) / (m_Stbc * numDataBitsPerSymbol)));

598

            numSymbols = lrint (m_Stbc * ceil ((16 + mpduSize * 8.0 + 6.0 * Nes) / (m_Stbc * numDataBitsPerSymbol)));

563

599

564

        else

600

        else

565

601

Lines 578-587	Link Here

578

    case WIFI_MOD_CLASS_DSSS:

614

    case WIFI_MOD_CLASS_DSSS:

579

    case WIFI_MOD_CLASS_HR_DSSS:

615

    case WIFI_MOD_CLASS_HR_DSSS:

580

      //(Section 17.2.3.6 "Long PLCP LENGTH field"; IEEE Std 802.11-2012)

616

      //(Section 17.2.3.6 "Long PLCP LENGTH field"; IEEE Std 802.11-2012)

581

      NS_LOG_LOGIC (" size=" << size

617

      NS_LOG_LOGIC (" size=" << mpduSize

582

                             << " mode=" << payloadMode

618

                             << " mode=" << payloadMode

583

                             << " rate=" << payloadMode.GetDataRate (22, 0, 1));

619

                             << " rate=" << payloadMode.GetDataRate (22, 0, 1));

584

      return MicroSeconds (lrint (ceil ((size * 8.0) / (payloadMode.GetDataRate (22, 0, 1) / 1.0e6))));

620

      return MicroSeconds (lrint (ceil ((mpduSize * 8.0) / (payloadMode.GetDataRate (22, 0, 1) / 1.0e6))));

585

    default:

621

    default:

586

      NS_FATAL_ERROR ("unsupported modulation class");

622

      NS_FATAL_ERROR ("unsupported modulation class");

587

      return MicroSeconds (0);

623

      return MicroSeconds (0);

Lines 602-614	Link Here

602

638

603

639

604

Time

640

Time

605

WifiPhy::CalculateTxDuration (uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency, enum mpduType mpdutype, uint8_t incFlag)

641

WifiPhy::CalculateTxDuration (uint32_t mpduSize, uint32_t ampduSize, WifiTxVector txVector, WifiPreamble preamble, double frequency, enum mpduType mpdutype, uint8_t incFlag)

606

642

607

  Time duration = CalculatePlcpPreambleAndHeaderDuration (txVector, preamble)

643

  Time duration = CalculatePlcpPreambleAndHeaderDuration (txVector, preamble)

608

    + GetPayloadDuration (size, txVector, preamble, frequency, mpdutype, incFlag);

644

    + GetPayloadDuration (mpduSize, ampduSize, txVector, preamble, frequency, mpdutype, incFlag);

609

  return duration;

645

  return duration;

610

646

611

647

648

Time

649

WifiPhy::CalculateTxDuration (uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency)

650

651

  return CalculateTxDuration (size, size, txVector, preamble, frequency, NORMAL_MPDU, 0);

652

653

612

void

654

void

613

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

655

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

614

656

(-)a/src/wifi/model/wifi-phy.h (-5 / +34 lines)

Lines 235-243	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 totalSize the total number of bytes that is going to be transmitted in the case of an A-MPDU.

243

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

244

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

245

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

246

   * \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.

247

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

239

*/

248

*/

240

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

249

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

241

250

242

/**

251

/**

243

   * \param listener the new listener

252

   * \param listener the new listener

Lines 315-326	Link Here

315

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

324

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

316

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

325

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

317

   * \param frequency the channel center frequency (MHz)

326

   * \param frequency the channel center frequency (MHz)

327

328

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

329

*/

330

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

331

/**

332

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

333

   * \param ampduSize the total number of bytes that is going to be transmitted in the case of an A-MPDU.

334

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

335

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

336

   * \param frequency the channel center frequency (MHz)

318

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

337

   * \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.

338

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

339

321

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

340

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

322

*/

341

*/

323

  Time CalculateTxDuration (uint32_t size, WifiTxVector txVector, enum WifiPreamble preamble, double frequency, enum mpduType mpdutype, uint8_t incFlag);

342

  Time CalculateTxDuration (uint32_t mpduSize, uint32_t ampduSize, WifiTxVector txVector, enum WifiPreamble preamble, double frequency, enum mpduType mpdutype, uint8_t incFlag);

324

343

325

/**

344

/**

326

   * \param txVector the transmission parameters used for this packet

345

   * \param txVector the transmission parameters used for this packet

Lines 397-412	Link Here

397

*/

416

*/

398

  static Time GetPlcpPreambleDuration (WifiTxVector txVector, WifiPreamble preamble);

417

  static Time GetPlcpPreambleDuration (WifiTxVector txVector, WifiPreamble preamble);

399

/**

418

/**

400

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

419

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

420

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

421

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

422

   * \param frequency the channel center frequency (MHz)

423

424

   * \return the duration of the payload

425

*/

426

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

427

/**

428

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

429

   * \param ampduSize the total number of bytes in the A-MPDU.

401

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

430

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

402

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

431

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

403

   * \param frequency the channel center frequency (MHz)

432

   * \param frequency the channel center frequency (MHz)

404

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

433

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

434

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

435

407

   * \return the duration of the payload

436

   * \return the duration of the MPDU in an A-MPDU

408

*/

437

*/

409

  Time GetPayloadDuration (uint32_t size, WifiTxVector txVector, WifiPreamble preamble, double frequency, enum mpduType mpdutype, uint8_t incFlag);

438

  Time GetPayloadDuration (uint32_t size, uint32_t totalSize, WifiTxVector txVector, WifiPreamble preamble, double frequency, enum mpduType mpdutype, uint8_t incFlag);

410

439

411

/**

440

/**

412

   * The WifiPhy::GetNModes() and WifiPhy::GetMode() methods are used

441

   * The WifiPhy::GetNModes() and WifiPhy::GetMode() methods are used

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

Lines 767-773	Link Here

767

768

769

void

769

void

770

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

770

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

771

772

  SendPacket (packet, packet->GetSize (), txVector, preamble, NORMAL_MPDU);

773

774

775

void

776

YansWifiPhy::SendPacket (Ptr<const Packet> packet, uint32_t ampduSize, 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);

773

  /* Transmission can happen if:

779

  /* Transmission can happen if:

Lines 785-791	Link Here

785

      return;

791

      return;

786

792

787

793

788

  Time txDuration = CalculateTxDuration (packet->GetSize (), txVector, preamble, GetFrequency (), mpdutype, 1);

794

  Time txDuration = CalculateTxDuration (packet->GetSize (), ampduSize, txVector, preamble, GetFrequency (), mpdutype, 1);

789

  NS_ASSERT (txDuration > NanoSeconds (0));

795

  NS_ASSERT (txDuration > NanoSeconds (0));

790

796

791

  if (m_state->IsStateRx ())

797

  if (m_state->IsStateRx ())

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

Lines 279-285	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, enum mpduType mpdutype);

282

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

283

  virtual void SendPacket (Ptr<const Packet> packet, uint32_t mpduSize, 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);

285

  virtual void SetSleepMode (void);

286

  virtual void SetSleepMode (void);




    {
      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