Attachment #2640 for bug #2533

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





InterferenceHelper::Event::Event (uint32_t size, WifiTxVector txVector,
                                  enum WifiPreamble preamble,
                                  Time duration, double rxPower,
                                  uint8_t nbOfTxAntennas)
  : m_size (size),
    m_txVector (txVector),
    m_preamble (preamble),
    m_startTime (Simulator::Now ()),
    m_endTime (m_startTime + duration),
    m_rxPowerW (rxPower),
    m_nbOfTxAntennas (nbOfTxAntennas)
{
}


  return m_preamble;
}

uint8_t
InterferenceHelper::Event::GetNbOfTxAntennas (void) const
{
  return m_nbOfTxAntennas;
}


/****************************************************************
 *       Class which records SNIR change events for a

Ptr<InterferenceHelper::Event>
InterferenceHelper::Add (uint32_t size, WifiTxVector txVector,
                         enum WifiPreamble preamble,
                         Time duration, double rxPowerW,
                         uint8_t nbOfTxAntennas)
{
  Ptr<InterferenceHelper::Event> event;


                                             txVector,
                                             preamble,
                                             duration,
                                             rxPowerW,
                                             nbOfTxAntennas);
  AppendEvent (event);
  return event;
}

  // Parameters other than duration and rxPowerW are unused for this type
  // of signal, so we provide dummy versions
  WifiTxVector fakeTxVector;
  Add (0, fakeTxVector, WIFI_PREAMBLE_NONE, duration, rxPowerW, 1);
}

void

  return m_errorRateModel;
}

void
InterferenceHelper::SetNumberOfReceiveAntennas (uint32_t rx)
{
  m_numRxAntennas = rx;
}

Time
InterferenceHelper::GetEnergyDuration (double energyW)
{

}

double
InterferenceHelper::CalculateChunkSuccessRate (double snir, Time duration, WifiMode mode, WifiTxVector txVector, uint8_t nbOfTxAntennas) const
{
  if (duration == NanoSeconds (0))
    {

    }
  uint32_t rate = mode.GetPhyRate (txVector);
  uint64_t nbits = (uint64_t)(rate * duration.GetSeconds ());
  if (txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_HT || txVector.GetMode ().GetModulationClass () == WIFI_MOD_CLASS_VHT)
    {
      nbits /= txVector.GetNss (); // divide effective number of bits by NSS to achieve same chunk error rate as SISO for AWGN
      snir *= (nbOfTxAntennas * m_numRxAntennas); // compute gain offered by MIMO, SIMO or MISO compared to SISO for AWGN
    }
  double csr = m_errorRateModel->GetChunkSuccessRate (mode, txVector, snir, (uint32_t)nbits);
  return csr;
}

  Time plcpPayloadStart = plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (preamble, event->GetTxVector ()) + WifiPhy::GetPlcpVhtSigBDuration (preamble); //packet start time + preamble + L-SIG + HT-SIG or VHT-SIG-A (A1 + A2) + (V)HT Training + VHT-SIG-B
  double noiseInterferenceW = (*j).GetDelta ();
  double powerW = event->GetRxPowerW ();
  uint8_t nbOfTxAntennas = event->GetNbOfTxAntennas ();
  j++;
  while (ni->end () != j)
    {

                                                          noiseInterferenceW,
                                                          event->GetTxVector ().GetChannelWidth ()),
                                            current - previous,
                                            payloadMode, event->GetTxVector (), nbOfTxAntennas);

          NS_LOG_DEBUG ("Both previous and current point to the payload: mode=" << payloadMode << ", psr=" << psr);
        }

                                                          noiseInterferenceW,
                                                          event->GetTxVector ().GetChannelWidth ()),
                                            current - plcpPayloadStart,
                                            payloadMode, event->GetTxVector (), nbOfTxAntennas);
          NS_LOG_DEBUG ("previous is before payload and current is in the payload: mode=" << payloadMode << ", psr=" << psr);
        }


  Time plcpPayloadStart = plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (preamble, event->GetTxVector ()) + WifiPhy::GetPlcpVhtSigBDuration (preamble); //packet start time + preamble + L-SIG + HT-SIG or VHT-SIG-A (A1 + A2) + (V)HT Training + VHT-SIG-B
  double noiseInterferenceW = (*j).GetDelta ();
  double powerW = event->GetRxPowerW ();
  uint8_t nbOfTxAntennas = event->GetNbOfTxAntennas ();
  j++;
  while (ni->end () != j)
    {

                                                              noiseInterferenceW,
                                                              event->GetTxVector ().GetChannelWidth ()),
                                                plcpPayloadStart - previous,
                                                htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

              NS_LOG_DEBUG ("Case 2a - previous is in (V)HT training or in VHT-SIG-B and current after payload start: mode=" << htHeaderMode << ", psr=" << psr);
            }

                                                              noiseInterferenceW,
                                                              event->GetTxVector ().GetChannelWidth ()),
                                                current - previous,
                                                htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

              NS_LOG_DEBUG ("Case 2b - previous is in (V)HT training or in VHT-SIG-B and current is in (V)HT training or in VHT-SIG-B: mode=" << htHeaderMode << ", psr=" << psr);
            }

                                                              noiseInterferenceW,
                                                              event->GetTxVector ().GetChannelWidth ()),
                                                plcpPayloadStart - plcpHtTrainingSymbolsStart,
                                                htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

              //Case 3ai: VHT format
              if (preamble == WIFI_PREAMBLE_VHT)

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHtTrainingSymbolsStart - previous,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 3ai - previous is in VHT-SIG-A and current after payload start: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHtTrainingSymbolsStart - previous,
                                                    htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 3aii - previous is in HT-SIG and current after payload start: mode=" << htHeaderMode << ", psr=" << psr);
                }

                                                              noiseInterferenceW,
                                                              event->GetTxVector ().GetChannelWidth ()),
                                                current - plcpHtTrainingSymbolsStart,
                                                htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

              //Case 3bi: VHT format
              if (preamble == WIFI_PREAMBLE_VHT)

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHtTrainingSymbolsStart - previous,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 3bi - previous is in VHT-SIG-A and current is in VHT training or in VHT-SIG-B: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHtTrainingSymbolsStart - previous,
                                                    htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 3bii - previous is in HT-SIG and current is in HT training: mode=" << htHeaderMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    current - previous,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 3ci - previous with current in VHT-SIG-A: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    current - previous,
                                                    htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 3cii - previous with current in HT-SIG: mode=" << htHeaderMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpPayloadStart - previous,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 4ai - previous in L-SIG and current after payload start: mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpPayloadStart - plcpHtTrainingSymbolsStart,
                                                    htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

                  psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHtTrainingSymbolsStart - previous,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 4aii - previous is in L-SIG and current after payload start: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpPayloadStart - plcpHsigHeaderStart,
                                                    htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

                  psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHsigHeaderStart - previous,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 4aiii - previous in L-SIG and current after payload start: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    current - plcpHtTrainingSymbolsStart,
                                                    htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

                  psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHtTrainingSymbolsStart - previous,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 4bi - previous is in L-SIG and current in VHT training or in VHT-SIG-B: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    current - plcpHsigHeaderStart,
                                                    htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

                  psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHsigHeaderStart - previous,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 4bii - previous in L-SIG and current in HT training: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    current - previous,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 4ci - previous is in L-SIG and current in VHT-SIG-A: mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    current - plcpHsigHeaderStart,
                                                    htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

                  psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHsigHeaderStart - previous,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 4cii - previous in L-SIG and current in HT-SIG: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
                }

                                                              noiseInterferenceW,
                                                              event->GetTxVector ().GetChannelWidth ()),
                                                current - previous,
                                                headerMode, event->GetTxVector (), nbOfTxAntennas);

              NS_LOG_DEBUG ("Case 3c - current with previous in L-SIG: mode=" << headerMode << ", psr=" << psr);
            }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpPayloadStart - plcpHeaderStart,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 5a - previous is in the preamble and current is after payload start: mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpPayloadStart - plcpHtTrainingSymbolsStart,
                                                    htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

                  psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHtTrainingSymbolsStart - plcpHeaderStart,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 5aii - previous is in the preamble and current is after payload start: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpPayloadStart - plcpHsigHeaderStart,
                                                    htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

                  psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHsigHeaderStart - plcpHeaderStart, //HT GF: plcpHsigHeaderStart - plcpHeaderStart = 0
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 5aiii - previous is in the preamble and current is after payload start: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    current - plcpHtTrainingSymbolsStart,
                                                    htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

                  psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHtTrainingSymbolsStart - plcpHeaderStart,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 5bi - previous is in the preamble and current in VHT training or in VHT-SIG-B: VHT mode=" << htHeaderMode << ", non-VHT mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    current - plcpHsigHeaderStart,
                                                    htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

                  psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHsigHeaderStart - plcpHeaderStart,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 5bii - previous is in the preamble and current in HT training: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    current - plcpHeaderStart,
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 5ci - previous is in preamble and current in VHT-SIG-A: mode=" << headerMode << ", psr=" << psr);
                }

                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    current - plcpHsigHeaderStart,
                                                    htHeaderMode, event->GetTxVector (), nbOfTxAntennas);

                  psr *= CalculateChunkSuccessRate (CalculateSnr (powerW,
                                                                  noiseInterferenceW,
                                                                  event->GetTxVector ().GetChannelWidth ()),
                                                    plcpHsigHeaderStart - plcpHeaderStart, //HT GF: plcpHsigHeaderStart - plcpHeaderStart = 0
                                                    headerMode, event->GetTxVector (), nbOfTxAntennas);

                  NS_LOG_DEBUG ("Case 5cii - previous in preamble and current in HT-SIG: HT mode=" << htHeaderMode << ", non-HT mode=" << headerMode << ", psr=" << psr);
                }

                                                              noiseInterferenceW,
                                                              event->GetTxVector ().GetChannelWidth ()),
                                                current - plcpHeaderStart,
                                                headerMode, event->GetTxVector (), nbOfTxAntennas);

              NS_LOG_DEBUG ("Case 5d - previous is in the preamble and current is in L-SIG: mode=" << headerMode << ", psr=" << psr);
            }

(-)a/src/wifi/model/interference-helper.h (-3 / +23 lines)

Lines 58-64	Link Here

*/

*/

    Event (uint32_t size, WifiTxVector txVector,

    Event (uint32_t size, WifiTxVector txVector,

           enum WifiPreamble preamble,

           enum WifiPreamble preamble,

           Time duration, double rxPower);

           Time duration, double rxPower,

           uint8_t nbOfTxAntennas);

    ~Event ();

    ~Event ();

/**

/**

Lines 109-114	Link Here

109

     * \return the preamble type of the packet

110

     * \return the preamble type of the packet

110

*/

111

*/

111

    enum WifiPreamble GetPreambleType (void) const;

112

    enum WifiPreamble GetPreambleType (void) const;

113

/**

114

     * Return the number of TX antennas of the device used to transmit the packet.

115

116

     * \return the number of TX antennas of the device used to transmit the packet

117

*/

118

    uint8_t GetNbOfTxAntennas (void) const;

112

119

113

120

114

private:

121

private:

Lines 118-123	Link Here

118

    Time m_startTime;

125

    Time m_startTime;

119

    Time m_endTime;

126

    Time m_endTime;

120

    double m_rxPowerW;

127

    double m_rxPowerW;

128

    uint8_t m_nbOfTxAntennas;

121

};

129

};

122

130

123

/**

131

/**

Lines 157-162	Link Here

157

   * \return Error rate model

165

   * \return Error rate model

158

*/

166

*/

159

  Ptr<ErrorRateModel> GetErrorRateModel (void) const;

167

  Ptr<ErrorRateModel> GetErrorRateModel (void) const;

168

169

/**

170

   * Set the number of RX antennas in the receiver corresponding to this

171

   * interference helper.

172

173

   * \param the number of RX antennas

174

*/

175

  void SetNumberOfReceiveAntennas (uint32_t rx);

160

176

161

/**

177

/**

162

   * \param energyW the minimum energy (W) requested

178

   * \param energyW the minimum energy (W) requested

Lines 175-186	Link Here

175

   * \param preamble Wi-Fi preamble for the packet

191

   * \param preamble Wi-Fi preamble for the packet

176

   * \param duration the duration of the signal

192

   * \param duration the duration of the signal

177

   * \param rxPower receive power (W)

193

   * \param rxPower receive power (W)

194

   * \param nbOfTxAntennas number of TX antennas of the device used to transmit the packet

178

195

179

   * \return InterferenceHelper::Event

196

   * \return InterferenceHelper::Event

180

*/

197

*/

181

  Ptr<InterferenceHelper::Event> Add (uint32_t size, WifiTxVector txVector,

198

  Ptr<InterferenceHelper::Event> Add (uint32_t size, WifiTxVector txVector,

182

                                      enum WifiPreamble preamble,

199

                                      enum WifiPreamble preamble,

183

                                      Time duration, double rxPower);

200

                                      Time duration, double rxPower,

201

                                      uint8_t nbOfTxAntennas);

184

202

185

/**

203

/**

186

   * Add a non-Wifi signal to interference helper.

204

   * Add a non-Wifi signal to interference helper.

Lines 303-312	Link Here

303

   * \param duration

321

   * \param duration

304

   * \param mode

322

   * \param mode

305

   * \param txVector

323

   * \param txVector

324

   * \param nbOfTxAntennas

306

325

307

   * \return the success rate

326

   * \return the success rate

308

*/

327

*/

309

  double CalculateChunkSuccessRate (double snir, Time duration, WifiMode mode, WifiTxVector txVector) const;

328

  double CalculateChunkSuccessRate (double snir, Time duration, WifiMode mode, WifiTxVector txVector, uint8_t nbOfTxAntennas) const;

310

/**

329

/**

311

   * Calculate the error rate of the given plcp payload. The plcp payload can be divided into

330

   * Calculate the error rate of the given plcp payload. The plcp payload can be divided into

312

   * multiple chunks (e.g. due to interference from other transmissions).

331

   * multiple chunks (e.g. due to interference from other transmissions).

Lines 330-335	Link Here

330

349

331

  double m_noiseFigure; /**< noise figure (linear) */

350

  double m_noiseFigure; /**< noise figure (linear) */

332

  Ptr<ErrorRateModel> m_errorRateModel;

351

  Ptr<ErrorRateModel> m_errorRateModel;

352

  uint32_t m_numRxAntennas; /**< the number of RX antennas in the corresponding receiver */

333

  /// Experimental: needed for energy duration calculation

353

  /// Experimental: needed for energy duration calculation

334

  NiChanges m_niChanges;

354

  NiChanges m_niChanges;

335

  double m_firstPower;

355

  double m_firstPower;

(-)a/src/wifi/model/spectrum-wifi-phy.cc (-2 / +3 lines)

Lines 424-430	Link Here

424

                              txVector,

424

                              txVector,

425

                              preamble,

425

                              preamble,

426

                              rxDuration,

426

                              rxDuration,

427

                              rxPowerW);

427

                              rxPowerW,

428

                              tag.GetNbOfTxAntennas ());

428

429

  switch (m_state->GetState ())

430

  switch (m_state->GetState ())

430

431

Lines 712-718	Link Here

712

  Ptr<Packet> newPacket = packet->Copy (); // obtain non-const Packet

713

  Ptr<Packet> newPacket = packet->Copy (); // obtain non-const Packet

713

  WifiPhyTag oldtag;

714

  WifiPhyTag oldtag;

714

  newPacket->RemovePacketTag (oldtag);

715

  newPacket->RemovePacketTag (oldtag);

715

  WifiPhyTag tag (txVector, preamble, mpdutype);

716

  WifiPhyTag tag (txVector, preamble, mpdutype, GetSupportedTxSpatialStreams ());

716

  newPacket->AddPacketTag (tag);

717

  newPacket->AddPacketTag (tag);

717

718

  NS_LOG_DEBUG ("Transmission signal power before antenna gain: " << GetPowerDbm (txVector.GetTxPowerLevel ()) << " dBm");

719

  NS_LOG_DEBUG ("Transmission signal power before antenna gain: " << GetPowerDbm (txVector.GetTxPowerLevel ()) << " dBm");




uint32_t
WifiPhyTag::GetSerializedSize (void) const
{
  return (4 + (6 * 1) + 4 + 2 + 1);
}

void

  i.WriteU8 (m_wifiTxVector.IsStbc ());
  i.WriteU32 (m_wifiPreamble);
  i.WriteU16 (m_mpduType);
  i.WriteU8 (m_nbOfTxAntennas);
}

void

  m_wifiTxVector.SetStbc (i.ReadU8 ());
  m_wifiPreamble = i.ReadU32 ();
  m_mpduType = static_cast<enum mpduType> (i.ReadU16 ());
  m_nbOfTxAntennas = i.ReadU8 ();
}
void
WifiPhyTag::Print (std::ostream &os) const

{
}

WifiPhyTag::WifiPhyTag (WifiTxVector txVector, WifiPreamble preamble, enum mpduType mpdutype, uint8_t nbOfTxAntennas)
  : m_wifiTxVector (txVector),
    m_wifiPreamble (preamble),
    m_mpduType (mpdutype),
    m_nbOfTxAntennas (nbOfTxAntennas)
{
}


  return m_mpduType;
}

uint8_t
WifiPhyTag::GetNbOfTxAntennas (void) const
{
  return m_nbOfTxAntennas;
}

} // namespace ns3

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

Lines 49-55	Link Here

   * \param preamble the WifiPreamble

   * \param preamble the WifiPreamble

   * \param mpduType the mpduType

   * \param mpduType the mpduType

*/

*/

  WifiPhyTag (WifiTxVector txVector, WifiPreamble preamble, enum mpduType mpdutype);

  WifiPhyTag (WifiTxVector txVector, WifiPreamble preamble, enum mpduType mpdutype, uint8_t nbOfTxAntennas);

/**

/**

   * Getter for WifiTxVector parameter

   * Getter for WifiTxVector parameter

   * \return the WifiTxVector

   * \return the WifiTxVector

Lines 65-70	Link Here

   * \return mpduType the mpduType

   * \return mpduType the mpduType

*/

*/

  enum mpduType GetMpduType (void) const;

  enum mpduType GetMpduType (void) const;

/**

   * Getter for nbOfTxAntennas parameter

   * \return nbOfTxAntennas the number of TX antennas

*/

  uint8_t GetNbOfTxAntennas (void) const;

  // From class Tag

  // From class Tag

  virtual uint32_t GetSerializedSize (void) const;

  virtual uint32_t GetSerializedSize (void) const;

Lines 76-81	Link Here

  WifiTxVector m_wifiTxVector;

  WifiTxVector m_wifiTxVector;

  int32_t m_wifiPreamble;

  int32_t m_wifiPreamble;

  enum mpduType m_mpduType;

  enum mpduType m_mpduType;

  uint8_t m_nbOfTxAntennas;

};

};

} // namespace ns3

} // namespace ns3




{
  NS_LOG_FUNCTION (this << noiseFigureDb);
  m_interference.SetNoiseFigure (DbToRatio (noiseFigureDb));
  m_interference.SetNumberOfReceiveAntennas (GetNumberOfReceiveAntennas ());
}

double

WifiPhy::SetErrorRateModel (Ptr<ErrorRateModel> rate)
{
  m_interference.SetErrorRateModel (rate);
  m_interference.SetNumberOfReceiveAntennas (GetNumberOfReceiveAntennas ());
}

Ptr<ErrorRateModel>

WifiPhy::SetNumberOfReceiveAntennas (uint32_t rx)
{
  m_numberOfReceivers = rx;
  m_interference.SetNumberOfReceiveAntennas (rx);
}

uint32_t

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

Lines 289-295	Link Here

289

                              txVector,

289

                              txVector,

290

                              preamble,

290

                              preamble,

291

                              rxDuration,

291

                              rxDuration,

292

                              rxPowerW);

292

                              rxPowerW,

293

                              tag.GetNbOfTxAntennas ());

293

294

  switch (m_state->GetState ())

295

  switch (m_state->GetState ())

295

296

Lines 524-530	Link Here

524

  Ptr<Packet> newPacket = packet->Copy (); // obtain non-const Packet

525

  Ptr<Packet> newPacket = packet->Copy (); // obtain non-const Packet

525

  WifiPhyTag oldtag;

526

  WifiPhyTag oldtag;

526

  newPacket->RemovePacketTag (oldtag);

527

  newPacket->RemovePacketTag (oldtag);

527

  WifiPhyTag tag (txVector, preamble, mpdutype);

528

  WifiPhyTag tag (txVector, preamble, mpdutype, GetSupportedTxSpatialStreams ());

528

  newPacket->AddPacketTag (tag);

529

  newPacket->AddPacketTag (tag);

529

  m_channel->Send (this, newPacket, GetPowerDbm (txVector.GetTxPowerLevel ()) + GetTxGain (), txDuration);

530

  m_channel->Send (this, newPacket, GetPowerDbm (txVector.GetTxPowerLevel ()) + GetTxGain (), txDuration);

530

531

(-)a/src/wifi/test/spectrum-wifi-phy-test.cc (-1 / +1 lines)

Lines 88-94	Link Here

  pkt->AddHeader (hdr);

  pkt->AddHeader (hdr);

  pkt->AddTrailer (trailer);

  pkt->AddTrailer (trailer);

  WifiPhyTag tag (txVector, preamble, mpdutype);

  WifiPhyTag tag (txVector, preamble, mpdutype, 1);

  pkt->AddPacketTag (tag);

  pkt->AddPacketTag (tag);

  Ptr<SpectrumValue> txPowerSpectrum = WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (FREQUENCY, CHANNEL_WIDTH, txPowerWatts);

  Ptr<SpectrumValue> txPowerSpectrum = WifiSpectrumValueHelper::CreateOfdmTxPowerSpectralDensity (FREQUENCY, CHANNEL_WIDTH, txPowerWatts);

  Ptr<WifiSpectrumSignalParameters> txParams = Create<WifiSpectrumSignalParameters> ();

  Ptr<WifiSpectrumSignalParameters> txParams = Create<WifiSpectrumSignalParameters> ();

Return to bug 2533