LEFT | RIGHT |
(no file at all) | |
1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ | 1 /* -*- Mode: C++; c-file-style: "gnu"; indent-tabs-mode:nil; -*- */ |
2 /* | 2 /* |
3 * Copyright (c) 2005,2006 INRIA | 3 * Copyright (c) 2005,2006 INRIA |
4 * | 4 * |
5 * This program is free software; you can redistribute it and/or modify | 5 * This program is free software; you can redistribute it and/or modify |
6 * it under the terms of the GNU General Public License version 2 as | 6 * it under the terms of the GNU General Public License version 2 as |
7 * published by the Free Software Foundation; | 7 * published by the Free Software Foundation; |
8 * | 8 * |
9 * This program is distributed in the hope that it will be useful, | 9 * This program is distributed in the hope that it will be useful, |
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of | 10 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
(...skipping 197 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
208 AddNiChangeEvent (NiChange (event->GetStartTime (), event->GetRxPowerW ())
); | 208 AddNiChangeEvent (NiChange (event->GetStartTime (), event->GetRxPowerW ())
); |
209 } | 209 } |
210 AddNiChangeEvent (NiChange (event->GetEndTime (), -event->GetRxPowerW ())); | 210 AddNiChangeEvent (NiChange (event->GetEndTime (), -event->GetRxPowerW ())); |
211 | 211 |
212 } | 212 } |
213 | 213 |
214 | 214 |
215 double | 215 double |
216 InterferenceHelper::CalculateSnr (double signal, double noiseInterference, WifiM
ode mode) const | 216 InterferenceHelper::CalculateSnr (double signal, double noiseInterference, WifiM
ode mode) const |
217 { | 217 { |
218 // thermal noise at 290K in J/s = W | 218 double noiseFloor = CalculateNoiseFloor (mode); |
219 static const double BOLTZMANN = 1.3803e-23; | |
220 // Nt is the power of thermal noise in W | |
221 double Nt = BOLTZMANN * 290.0 * mode.GetBandwidth (); | |
222 // receiver noise Floor (W) which accounts for thermal noise and non-idealitie
s of the receiver | |
223 double noiseFloor = m_noiseFigure * Nt; | |
224 double noise = noiseFloor + noiseInterference; | 219 double noise = noiseFloor + noiseInterference; |
225 double snr = signal / noise; | 220 double snr = signal / noise; |
226 return snr; | 221 return snr; |
227 } | 222 } |
228 | 223 |
229 double | 224 double |
230 InterferenceHelper::CalculateNoiseInterferenceW (Ptr<InterferenceHelper::Event>
event, NiChanges *ni) const | 225 InterferenceHelper::CalculateNoiseInterferenceW (Ptr<InterferenceHelper::Event>
event, NiChanges *ni) const |
231 { | 226 { |
232 double noiseInterference = m_firstPower; | 227 double noiseInterference = m_firstPower; |
233 NS_ASSERT (m_rxing); | 228 NS_ASSERT (m_rxing); |
(...skipping 103 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
337 | 332 |
338 noiseInterferenceW += (*j).GetDelta (); | 333 noiseInterferenceW += (*j).GetDelta (); |
339 previous = (*j).GetTime (); | 334 previous = (*j).GetTime (); |
340 j++; | 335 j++; |
341 } | 336 } |
342 | 337 |
343 double per = 1 - psr; | 338 double per = 1 - psr; |
344 return per; | 339 return per; |
345 } | 340 } |
346 | 341 |
| 342 double |
| 343 InterferenceHelper::CalculateNoiseFloor (WifiMode mode) const |
| 344 { |
| 345 // thermal noise at 290K in J/s = W |
| 346 static const double BOLTZMANN = 1.3803e-23; |
| 347 // Nt is the power of thermal noise in W |
| 348 double Nt = BOLTZMANN * 290.0 * mode.GetBandwidth (); |
| 349 /* |
| 350 * Receiver noise Floor (W) which accounts for thermal noise and non- |
| 351 * idealities of the receiver. |
| 352 */ |
| 353 return m_noiseFigure * Nt; |
| 354 } |
| 355 |
| 356 double |
| 357 InterferenceHelper::CalculatePacketRss (Ptr<const InterferenceHelper::Event> eve
nt, |
| 358 NiChanges *ni) const |
| 359 { |
| 360 double rss = 0; |
| 361 double packetRss = 0; |
| 362 |
| 363 NiChanges::iterator j = ni->begin (); |
| 364 Time previous = (*j).GetTime (); |
| 365 WifiMode payloadMode = event->GetPayloadMode (); |
| 366 WifiPreamble preamble = event->GetPreambleType (); |
| 367 WifiMode headerMode = WifiPhy::GetPlcpHeaderMode (payloadMode, preamble); |
| 368 Time plcpHeaderStart = (*j).GetTime () + MicroSeconds (WifiPhy::GetPlcpPreambl
eDurationMicroSeconds (payloadMode, preamble)); |
| 369 Time plcpPayloadStart = plcpHeaderStart + MicroSeconds (WifiPhy::GetPlcpHeader
DurationMicroSeconds (payloadMode, preamble)); |
| 370 double powerW = event->GetRxPowerW (); // power of packet at receiver |
| 371 double noiseInterferenceW = (*j).GetDelta (); |
| 372 |
| 373 j++; |
| 374 while (ni->end () != j) |
| 375 { |
| 376 Time current = (*j).GetTime (); |
| 377 NS_ASSERT (current >= previous); |
| 378 |
| 379 // payload only |
| 380 if (previous >= plcpPayloadStart) |
| 381 { |
| 382 rss = powerW + noiseInterferenceW + CalculateNoiseFloor (payloadMode); |
| 383 packetRss += rss * (current - previous).GetSeconds (); |
| 384 } |
| 385 else if (previous >= plcpHeaderStart) |
| 386 { |
| 387 // half header half payload |
| 388 if (current >= plcpPayloadStart) |
| 389 { |
| 390 // header chunk |
| 391 rss = powerW + noiseInterferenceW + CalculateNoiseFloor (headerMod
e); |
| 392 packetRss += rss * (plcpPayloadStart - previous).GetSeconds (); |
| 393 // payload chunk |
| 394 rss = powerW + noiseInterferenceW + CalculateNoiseFloor (payloadMo
de); |
| 395 packetRss += rss * (current - plcpPayloadStart).GetSeconds (); |
| 396 } |
| 397 // header only |
| 398 else |
| 399 { |
| 400 NS_ASSERT (current >= plcpHeaderStart); |
| 401 rss = powerW + noiseInterferenceW + CalculateNoiseFloor (headerMod
e); |
| 402 packetRss += rss * (current - previous).GetSeconds (); |
| 403 } |
| 404 } |
| 405 else |
| 406 { |
| 407 // half header half payload |
| 408 if (current >= plcpPayloadStart) |
| 409 { |
| 410 // header chunk |
| 411 rss = powerW + noiseInterferenceW + CalculateNoiseFloor (headerMod
e); |
| 412 packetRss += rss * (plcpPayloadStart - plcpHeaderStart).GetSeconds
(); |
| 413 // payload chunk |
| 414 rss = powerW + noiseInterferenceW + CalculateNoiseFloor (payloadMo
de); |
| 415 packetRss += rss * (current - plcpPayloadStart).GetSeconds (); |
| 416 } |
| 417 // header only |
| 418 else if (current >= plcpHeaderStart) |
| 419 { |
| 420 rss = powerW + noiseInterferenceW + CalculateNoiseFloor (headerMod
e); |
| 421 packetRss += rss * (current - plcpHeaderStart).GetSeconds (); |
| 422 } |
| 423 } |
| 424 |
| 425 noiseInterferenceW += (*j).GetDelta (); |
| 426 previous = current; |
| 427 j++; |
| 428 } |
| 429 |
| 430 NS_ASSERT (event->GetDuration ().GetSeconds () != 0); |
| 431 // real duration = time stamp of (last ni change - start of header) |
| 432 Time duration = (ni->back()).GetTime () - plcpHeaderStart; |
| 433 packetRss /= duration.GetSeconds (); |
| 434 return packetRss; |
| 435 } |
| 436 |
| 437 double |
| 438 InterferenceHelper::CurrentNodeRss (WifiMode mode) |
| 439 { |
| 440 double rss = CalculateNoiseFloor (mode); |
| 441 Time now = Simulator::Now (); |
| 442 NiChanges::iterator nowIterator = GetPosition (now); |
| 443 for (NiChanges::iterator i = m_niChanges.begin (); i != nowIterator; i++) |
| 444 { |
| 445 rss += i->GetDelta (); |
| 446 } |
| 447 return rss; |
| 448 } |
347 | 449 |
348 struct InterferenceHelper::SnrPer | 450 struct InterferenceHelper::SnrPer |
349 InterferenceHelper::CalculateSnrPer (Ptr<InterferenceHelper::Event> event) | 451 InterferenceHelper::CalculateSnrPer (Ptr<InterferenceHelper::Event> event) |
350 { | 452 { |
351 NiChanges ni; | 453 NiChanges ni; |
352 double noiseInterferenceW = CalculateNoiseInterferenceW (event, &ni); | 454 double noiseInterferenceW = CalculateNoiseInterferenceW (event, &ni); |
353 double snr = CalculateSnr (event->GetRxPowerW (), | 455 double snr = CalculateSnr (event->GetRxPowerW (), |
354 noiseInterferenceW, | 456 noiseInterferenceW, |
355 event->GetPayloadMode ()); | 457 event->GetPayloadMode ()); |
356 | 458 |
357 /* calculate the SNIR at the start of the packet and accumulate | 459 /* |
| 460 * calculate the SNIR at the start of the packet and accumulate |
358 * all SNIR changes in the snir vector. | 461 * all SNIR changes in the snir vector. |
359 */ | 462 */ |
360 double per = CalculatePer (event, &ni); | 463 double per = CalculatePer (event, &ni); |
361 | 464 |
362 struct SnrPer snrPer; | 465 struct SnrPer snrPer; |
363 snrPer.snr = snr; | 466 snrPer.snr = snr; |
364 snrPer.per = per; | 467 snrPer.per = per; |
| 468 snrPer.packetRss = CalculatePacketRss (event, &ni); |
| 469 |
365 return snrPer; | 470 return snrPer; |
366 } | 471 } |
367 | 472 |
368 void | 473 void |
369 InterferenceHelper::EraseEvents (void) | 474 InterferenceHelper::EraseEvents (void) |
370 { | 475 { |
371 m_niChanges.clear (); | 476 m_niChanges.clear (); |
372 m_rxing = false; | 477 m_rxing = false; |
373 m_firstPower = 0.0; | 478 m_firstPower = 0.0; |
374 } | 479 } |
(...skipping 12 matching lines...) Expand all Loading... |
387 InterferenceHelper::NotifyRxStart () | 492 InterferenceHelper::NotifyRxStart () |
388 { | 493 { |
389 m_rxing = true; | 494 m_rxing = true; |
390 } | 495 } |
391 void | 496 void |
392 InterferenceHelper::NotifyRxEnd () | 497 InterferenceHelper::NotifyRxEnd () |
393 { | 498 { |
394 m_rxing = false; | 499 m_rxing = false; |
395 } | 500 } |
396 } // namespace ns3 | 501 } // namespace ns3 |
LEFT | RIGHT |