|
|
|---|
| 274 |
Time previous = (*j).GetTime (); |
274 |
Time previous = (*j).GetTime (); |
| 275 |
WifiMode payloadMode = event->GetPayloadMode (); |
275 |
WifiMode payloadMode = event->GetPayloadMode (); |
| 276 |
WifiPreamble preamble = event->GetPreambleType (); |
276 |
WifiPreamble preamble = event->GetPreambleType (); |
| 277 |
WifiMode MfHeaderMode ; |
277 |
WifiMode HtHeaderMode ; |
| 278 |
if (preamble==WIFI_PREAMBLE_HT_MF) |
278 |
if (preamble == WIFI_PREAMBLE_HT_MF) |
| 279 |
{ |
279 |
{ |
| 280 |
MfHeaderMode = WifiPhy::GetMFPlcpHeaderMode (payloadMode, preamble); //return L-SIG mode |
280 |
//mode for HT modulation |
| 281 |
|
281 |
HtHeaderMode = WifiPhy::GetHTPlcpHeaderMode (payloadMode, preamble); |
| 282 |
} |
282 |
} |
| 283 |
WifiMode headerMode = WifiPhy::GetPlcpHeaderMode (payloadMode, preamble); |
283 |
WifiMode headerMode = WifiPhy::GetPlcpHeaderMode (payloadMode, preamble); //mode for OFDM modulation |
| 284 |
Time plcpHeaderStart = (*j).GetTime () + WifiPhy::GetPlcpPreambleDuration (payloadMode, preamble); //packet start time+ preamble |
284 |
Time plcpHeaderStart = (*j).GetTime () + WifiPhy::GetPlcpPreambleDuration (payloadMode, preamble); //packet start time + preamble |
| 285 |
Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (payloadMode, preamble);//packet start time+ preamble+L SIG |
285 |
Time plcpHsigHeaderStart = plcpHeaderStart + WifiPhy::GetPlcpHeaderDuration (payloadMode, preamble); //packet start time + preamble + L-SIG |
| 286 |
Time plcpHtTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble);//packet start time+ preamble+L SIG+HT SIG |
286 |
Time plcpHtTrainingSymbolsStart = plcpHsigHeaderStart + WifiPhy::GetPlcpHtSigHeaderDuration (preamble); //packet start time + preamble + L-SIG + HT-SIG |
| 287 |
Time plcpPayloadStart =plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (preamble,event->GetTxVector()); //packet start time+ preamble+L SIG+HT SIG+Training |
287 |
Time plcpPayloadStart = plcpHtTrainingSymbolsStart + WifiPhy::GetPlcpHtTrainingSymbolDuration (preamble, event->GetTxVector()); //packet start time + preamble + L-SIG + HT-SIG + HT Training |
| 288 |
double noiseInterferenceW = (*j).GetDelta (); |
288 |
double noiseInterferenceW = (*j).GetDelta (); |
| 289 |
double powerW = event->GetRxPowerW (); |
289 |
double powerW = event->GetRxPowerW (); |
| 290 |
j++; |
290 |
j++; |
| 291 |
while (ni->end () != j) |
291 |
while (ni->end () != j) |
| 292 |
{ |
292 |
{ |
| 293 |
Time current = (*j).GetTime (); |
293 |
Time current = (*j).GetTime (); |
| 294 |
NS_ASSERT (current >= previous); |
294 |
NS_ASSERT (current >= previous); |
| 295 |
//Case 1: Both prev and curr point to the payload |
295 |
//Case 1: Both previous and current point in the payload |
| 296 |
if (previous >= plcpPayloadStart) |
296 |
if (previous >= plcpPayloadStart) |
| 297 |
{ |
297 |
{ |
| 298 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
298 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
|
|
|---|
| 301 |
current - previous, |
301 |
current - previous, |
| 302 |
payloadMode); |
302 |
payloadMode); |
| 303 |
} |
303 |
} |
| 304 |
//Case 2: previous is before payload |
304 |
//Case 2: previous is in L-SIG for non-HT and in HT training for HT |
| 305 |
else if (previous >= plcpHtTrainingSymbolsStart) |
305 |
else if (previous >= plcpHtTrainingSymbolsStart) |
| 306 |
{ |
306 |
{ |
| 307 |
//Case 2a: current is after payload |
307 |
//Case 2a: current is after payload |
| 308 |
if (current >= plcpPayloadStart) |
308 |
if (current >= plcpPayloadStart) |
| 309 |
{ |
309 |
{ |
| 310 |
//Case 2ai and 2aii: All formats |
310 |
//All formats |
| 311 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
311 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 312 |
noiseInterferenceW, |
312 |
noiseInterferenceW, |
| 313 |
payloadMode), |
313 |
payloadMode), |
| 314 |
current - plcpPayloadStart, |
314 |
current - plcpPayloadStart, |
| 315 |
payloadMode); |
315 |
payloadMode); |
| 316 |
|
316 |
//Case 2ai: non-HT format |
| 317 |
} |
317 |
if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT) |
|
|
318 |
{ |
| 319 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 320 |
noiseInterferenceW, |
| 321 |
headerMode), |
| 322 |
plcpPayloadStart - previous, |
| 323 |
headerMode); |
| 324 |
} |
| 325 |
//Case 2aii: HT format |
| 326 |
else |
| 327 |
{ |
| 328 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 329 |
noiseInterferenceW, |
| 330 |
HtHeaderMode), |
| 331 |
plcpPayloadStart - previous, |
| 332 |
HtHeaderMode); |
| 333 |
} |
| 334 |
} |
| 335 |
//Case 2b: current and previous before payload (in L-SIG for non-HT and in HT training for HT) |
| 336 |
else |
| 337 |
{ |
| 338 |
//Case 2bi: non-HT format |
| 339 |
if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT) |
| 340 |
{ |
| 341 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 342 |
noiseInterferenceW, |
| 343 |
headerMode), |
| 344 |
current - previous, |
| 345 |
headerMode); |
| 346 |
} |
| 347 |
//Case 2bii: HT format |
| 348 |
else |
| 349 |
{ |
| 350 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 351 |
noiseInterferenceW, |
| 352 |
HtHeaderMode), |
| 353 |
current - previous, |
| 354 |
HtHeaderMode); |
| 355 |
} |
| 356 |
} |
| 318 |
} |
357 |
} |
| 319 |
//Case 3: previous is in HT-SIG: Non HT will not enter here since it didn't enter in the last two and they are all the same for non HT |
358 |
//Case 3: previous is in HT-SIG: Non HT will not enter here since it didn't enter in the last two and they are all the same for non HT |
| 320 |
else if (previous >=plcpHsigHeaderStart) |
359 |
else if (previous >= plcpHsigHeaderStart) |
| 321 |
{ |
360 |
{ |
| 322 |
//Case 3a: cuurent after payload start |
361 |
//Case 3a: current after payload start |
| 323 |
if (current >=plcpPayloadStart) |
362 |
if (current >= plcpPayloadStart) |
| 324 |
{ |
363 |
{ |
| 325 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
364 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 326 |
noiseInterferenceW, |
365 |
noiseInterferenceW, |
| 327 |
payloadMode), |
366 |
payloadMode), |
| 328 |
current - plcpPayloadStart, |
367 |
current - plcpPayloadStart, |
| 329 |
payloadMode); |
368 |
payloadMode); |
| 330 |
|
369 |
|
| 331 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
370 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 332 |
noiseInterferenceW, |
371 |
noiseInterferenceW, |
| 333 |
headerMode), |
372 |
HtHeaderMode), |
| 334 |
plcpHtTrainingSymbolsStart - previous, |
373 |
plcpPayloadStart - previous, |
| 335 |
headerMode); |
374 |
HtHeaderMode); |
| 336 |
} |
375 |
} |
| 337 |
//case 3b: current after HT training symbols start |
376 |
//case 3b: current in HT-SIG or in HT training |
| 338 |
else if (current >=plcpHtTrainingSymbolsStart) |
377 |
else |
| 339 |
{ |
378 |
{ |
| 340 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
379 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 341 |
noiseInterferenceW, |
380 |
noiseInterferenceW, |
| 342 |
headerMode), |
381 |
HtHeaderMode), |
| 343 |
plcpHtTrainingSymbolsStart - previous, |
382 |
current - previous, |
| 344 |
headerMode); |
383 |
HtHeaderMode); |
| 345 |
|
384 |
|
| 346 |
} |
385 |
} |
| 347 |
//Case 3c: current is with previous in HT sig |
386 |
} |
| 348 |
else |
387 |
//Case 4: previous in L-SIG: non-HT and GF will not reach here because it will execute the previous if and exit |
| 349 |
{ |
388 |
else if (previous >= plcpHeaderStart) |
|
|
389 |
{ |
| 390 |
//Case 4a: current after payload start |
| 391 |
if (current >= plcpPayloadStart) |
| 392 |
{ |
| 393 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 394 |
noiseInterferenceW, |
| 395 |
payloadMode), |
| 396 |
current - plcpPayloadStart, |
| 397 |
payloadMode); |
| 398 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 399 |
noiseInterferenceW, |
| 400 |
HtHeaderMode), |
| 401 |
plcpPayloadStart - plcpHsigHeaderStart, |
| 402 |
HtHeaderMode); |
| 350 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
403 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 351 |
noiseInterferenceW, |
404 |
noiseInterferenceW, |
| 352 |
headerMode), |
405 |
headerMode), |
| 353 |
current- previous, |
406 |
plcpHsigHeaderStart - previous, |
| 354 |
headerMode); |
|
|
| 355 |
|
| 356 |
} |
| 357 |
} |
| 358 |
//Case 4: previous in L-SIG: GF will not reach here because it will execute the previous if and exit |
| 359 |
else if (previous >= plcpHeaderStart) |
| 360 |
{ |
| 361 |
//Case 4a: current after payload start |
| 362 |
if (current >=plcpPayloadStart) |
| 363 |
{ |
| 364 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 365 |
noiseInterferenceW, |
| 366 |
payloadMode), |
| 367 |
current - plcpPayloadStart, |
| 368 |
payloadMode); |
| 369 |
//Case 4ai: Non HT format (No HT-SIG or Training Symbols) |
| 370 |
if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT) //plcpHtTrainingSymbolsStart==plcpHeaderStart) |
| 371 |
{ |
| 372 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 373 |
noiseInterferenceW, |
| 374 |
headerMode), |
| 375 |
plcpPayloadStart - previous, |
| 376 |
headerMode); |
| 377 |
} |
| 378 |
|
| 379 |
else{ |
| 380 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 381 |
noiseInterferenceW, |
| 382 |
headerMode), |
| 383 |
plcpHtTrainingSymbolsStart - plcpHsigHeaderStart, |
| 384 |
headerMode); |
| 385 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 386 |
noiseInterferenceW, |
| 387 |
MfHeaderMode), |
| 388 |
plcpHsigHeaderStart - previous, |
| 389 |
MfHeaderMode); |
| 390 |
} |
| 391 |
} |
| 392 |
//Case 4b: current in HT training symbol. non HT will not come here since it went in previous if or if the previous ifis not true this will be not true |
| 393 |
else if (current >=plcpHtTrainingSymbolsStart) |
| 394 |
{ |
| 395 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 396 |
noiseInterferenceW, |
| 397 |
headerMode), |
| 398 |
plcpHtTrainingSymbolsStart - plcpHsigHeaderStart, |
| 399 |
headerMode); |
407 |
headerMode); |
| 400 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
408 |
} |
| 401 |
noiseInterferenceW, |
409 |
//Case 4b: current in in HT-SIG or in HT training symbol. |
| 402 |
MfHeaderMode), |
410 |
else if (current >= plcpHtTrainingSymbolsStart) |
| 403 |
plcpHsigHeaderStart - previous, |
|
|
| 404 |
MfHeaderMode); |
| 405 |
} |
| 406 |
//Case 4c: current in H sig.non HT will not come here since it went in previous if or if the previous ifis not true this will be not true |
| 407 |
else if (current >=plcpHsigHeaderStart) |
| 408 |
{ |
411 |
{ |
| 409 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
412 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 410 |
noiseInterferenceW, |
413 |
noiseInterferenceW, |
|
|
414 |
HtHeaderMode), |
| 415 |
current - plcpHsigHeaderStart, |
| 416 |
HtHeaderMode); |
| 417 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 418 |
noiseInterferenceW, |
| 411 |
headerMode), |
419 |
headerMode), |
| 412 |
current - plcpHsigHeaderStart, |
420 |
plcpHsigHeaderStart - previous, |
| 413 |
headerMode); |
421 |
headerMode); |
| 414 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
422 |
} |
| 415 |
noiseInterferenceW, |
423 |
//Case 4c: current with previous in L-SIG |
| 416 |
MfHeaderMode), |
|
|
| 417 |
plcpHsigHeaderStart - previous, |
| 418 |
MfHeaderMode); |
| 419 |
|
| 420 |
} |
| 421 |
//Case 4d: Current with prev in L SIG |
| 422 |
else |
424 |
else |
| 423 |
{ |
425 |
{ |
| 424 |
//Case 4di: Non HT format (No HT-SIG or Training Symbols) |
|
|
| 425 |
if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT) //plcpHtTrainingSymbolsStart==plcpHeaderStart) |
| 426 |
{ |
| 427 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 428 |
noiseInterferenceW, |
| 429 |
headerMode), |
| 430 |
current - previous, |
| 431 |
headerMode); |
| 432 |
} |
| 433 |
else |
| 434 |
{ |
| 435 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
426 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 436 |
noiseInterferenceW, |
427 |
noiseInterferenceW, |
| 437 |
MfHeaderMode), |
428 |
headerMode), |
| 438 |
current - previous, |
429 |
current - previous, |
| 439 |
MfHeaderMode); |
430 |
headerMode); |
| 440 |
} |
431 |
} |
| 441 |
} |
|
|
| 442 |
} |
432 |
} |
| 443 |
//Case 5: previous is in the preamble works for all cases |
433 |
//Case 5: previous is in the preamble works for all cases |
| 444 |
else |
434 |
else |
| 445 |
{ |
435 |
{ |
|
|
436 |
//Case 5a: current after payload |
| 446 |
if (current >= plcpPayloadStart) |
437 |
if (current >= plcpPayloadStart) |
| 447 |
{ |
438 |
{ |
| 448 |
//for all |
439 |
//for all |
|
|
|---|
| 452 |
current - plcpPayloadStart, |
443 |
current - plcpPayloadStart, |
| 453 |
payloadMode); |
444 |
payloadMode); |
| 454 |
|
445 |
|
| 455 |
// Non HT format (No HT-SIG or Training Symbols) |
446 |
//Case 5ai: Non HT format (No HT-SIG or Training Symbols) |
| 456 |
if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT) |
447 |
if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT) |
| 457 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
448 |
{ |
| 458 |
noiseInterferenceW, |
449 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
|
|
450 |
noiseInterferenceW, |
| 459 |
headerMode), |
451 |
headerMode), |
| 460 |
plcpPayloadStart - plcpHeaderStart, |
452 |
plcpPayloadStart - plcpHeaderStart, |
| 461 |
headerMode); |
453 |
headerMode); |
|
|
454 |
} |
| 455 |
//Case 5aii: Greenfield or Mixed format |
| 462 |
else |
456 |
else |
| 463 |
// Greenfield or Mixed format |
457 |
{ |
| 464 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
458 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 465 |
noiseInterferenceW, |
|
|
| 466 |
headerMode), |
| 467 |
plcpHtTrainingSymbolsStart - plcpHsigHeaderStart, |
| 468 |
headerMode); |
| 469 |
if (preamble == WIFI_PREAMBLE_HT_MF) |
| 470 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 471 |
noiseInterferenceW, |
459 |
noiseInterferenceW, |
| 472 |
MfHeaderMode), |
460 |
HtHeaderMode), |
| 473 |
plcpHsigHeaderStart-plcpHeaderStart, |
461 |
plcpPayloadStart - plcpHsigHeaderStart, |
| 474 |
MfHeaderMode); |
462 |
HtHeaderMode); |
|
|
463 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 464 |
noiseInterferenceW, |
| 465 |
HtHeaderMode), |
| 466 |
plcpHsigHeaderStart - plcpHeaderStart, |
| 467 |
headerMode); |
| 468 |
} |
| 475 |
} |
469 |
} |
| 476 |
else if (current >=plcpHtTrainingSymbolsStart ) |
470 |
//Case 5b: current before payload |
| 477 |
{ |
471 |
else if (current >= plcpHtTrainingSymbolsStart ) |
| 478 |
// Non HT format will not come here since it will execute prev if |
|
|
| 479 |
// Greenfield or Mixed format |
| 480 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 481 |
noiseInterferenceW, |
| 482 |
headerMode), |
| 483 |
plcpHtTrainingSymbolsStart - plcpHsigHeaderStart, |
| 484 |
headerMode); |
| 485 |
if (preamble == WIFI_PREAMBLE_HT_MF) |
| 486 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 487 |
noiseInterferenceW, |
| 488 |
MfHeaderMode), |
| 489 |
plcpHsigHeaderStart-plcpHeaderStart, |
| 490 |
MfHeaderMode); |
| 491 |
} |
| 492 |
//non HT will not come here |
| 493 |
else if (current >=plcpHsigHeaderStart) |
| 494 |
{ |
| 495 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 496 |
noiseInterferenceW, |
| 497 |
headerMode), |
| 498 |
current- plcpHsigHeaderStart, |
| 499 |
headerMode); |
| 500 |
if (preamble != WIFI_PREAMBLE_HT_GF) |
| 501 |
{ |
| 502 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 503 |
noiseInterferenceW, |
| 504 |
MfHeaderMode), |
| 505 |
plcpHsigHeaderStart-plcpHeaderStart, |
| 506 |
MfHeaderMode); |
| 507 |
} |
| 508 |
} |
| 509 |
// GF will not come here |
| 510 |
else if (current >= plcpHeaderStart) |
| 511 |
{ |
472 |
{ |
| 512 |
if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT) |
473 |
//Case 5bi: current in L-SIG (Non HT format) |
| 513 |
{ |
474 |
if (preamble == WIFI_PREAMBLE_LONG || preamble == WIFI_PREAMBLE_SHORT) |
| 514 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
475 |
{ |
| 515 |
noiseInterferenceW, |
476 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
|
|
477 |
noiseInterferenceW, |
| 516 |
headerMode), |
478 |
headerMode), |
| 517 |
current - plcpHeaderStart, |
479 |
current - plcpHeaderStart, |
| 518 |
headerMode); |
480 |
headerMode); |
| 519 |
} |
481 |
} |
|
|
482 |
//Case 5bii: current in HT training (Greenfield or Mixed format) |
| 520 |
else |
483 |
else |
| 521 |
{ |
484 |
{ |
| 522 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
485 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 523 |
noiseInterferenceW, |
486 |
noiseInterferenceW, |
| 524 |
MfHeaderMode), |
487 |
HtHeaderMode), |
| 525 |
current - plcpHeaderStart, |
488 |
current - plcpHsigHeaderStart, |
| 526 |
MfHeaderMode); |
489 |
HtHeaderMode); |
| 527 |
} |
490 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
|
|
491 |
noiseInterferenceW, |
| 492 |
HtHeaderMode), |
| 493 |
plcpHsigHeaderStart - plcpHeaderStart, |
| 494 |
headerMode); |
| 495 |
} |
| 496 |
} |
| 497 |
//Case 5c: non HT will not come here (current in HT-SIG) |
| 498 |
else if (current >= plcpHsigHeaderStart) |
| 499 |
{ |
| 500 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 501 |
noiseInterferenceW, |
| 502 |
HtHeaderMode), |
| 503 |
current - plcpHsigHeaderStart, |
| 504 |
HtHeaderMode); |
| 505 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 506 |
noiseInterferenceW, |
| 507 |
HtHeaderMode), |
| 508 |
plcpHsigHeaderStart - plcpHeaderStart, |
| 509 |
headerMode); |
| 510 |
} |
| 511 |
//Case 5d: GF will not come here (current in L-SIG) |
| 512 |
else if (current >= plcpHeaderStart) |
| 513 |
{ |
| 514 |
psr *= CalculateChunkSuccessRate (CalculateSnr (powerW, |
| 515 |
noiseInterferenceW, |
| 516 |
HtHeaderMode), |
| 517 |
current - plcpHeaderStart, |
| 518 |
headerMode); |
| 528 |
} |
519 |
} |
| 529 |
} |
520 |
} |
| 530 |
|
521 |
|
| 531 |
noiseInterferenceW += (*j).GetDelta (); |
522 |
noiseInterferenceW += (*j).GetDelta (); |
| 532 |
previous = (*j).GetTime (); |
523 |
previous = (*j).GetTime (); |
| 533 |
j++; |
524 |
j++; |