# 802.11a SNR simulation question?

Started by April 9, 2006
```I have a question that:
When we simulate the 802.11a OFDM PHY, which uses 48 subcarriers to
transmit data, 4 subcarriers for pilot, other 12 subcarriers not transmit.

How to simulate the AWGN channel with given SNR such as Es/N0 or Eb/N0, I
think, the most important one is to understand where and what's the
variance value of the Gaussian white noise should be added??

I think in general simulation, first Gaussian random variable is generated
and added before the decision module, such as simulate baseband digital
system, like PAM, where noise variance = Es*N0/2, in which Es is the
symbol energy, and N0 is noise spectral density.

In some papers of 802.11a OFDM PHY, people use the similar way to simulate
the AWGN channel as above PAM, using: 1). assume Es = 1; 2). add noise
variance = 10^(-snr/10), here snr = Es/N0, i.e., snr per (OFDM) symbol.

My question is:

1). Is it correct that: snr(per ofdm symbol) = Es/N0 = (Es*B)/(N0*B)=
(signal power)/(noise variance), so noise variance = signal power/ snr(per
ofdm symbol), but if we want get the above method, it will need signal
power to be 1 not Es = 1 assumed, so how to explain?? and also using
Parseval's theorem, how to explain the power equation:
sum(|X(k)|^2)/N = sum(|x(n)^2|), in which N = 64, however, we just use 48
subcarriers for data transmission? so how to understand the physical
meaning of that??

2). If we are given snr per bit, i.e., snr = Eb/N0, so is it correct that:
Es = Eb*Ncbps, in which Ncbps is number of coded bits per ofdm symbol?

```
```This is always a tricky issue and you must be
very clear with your definitions. I would suggest
that you begin with using all 64 subchannels as
data carriers. This way the system must give
identical performance to a single-carrier system
with AWGN, when you plot the BER/SNR or
BER/EbNo curve. If this is your reference system,
it should be easy to migrate to 48 data subcarriers
with 4 pilots.

In any case, the way I would inject noise is by
defining SNR = cov(x[n])/cov(u[n]) where x [n]
is the OFDM signal and u[n] is the noise. You
can measure cov(x[n]) easily enough in simulation
and generate noise at appropriate level for given
SNR.

To convert this to Eb/N0, it is simply a case of
converting SNR to SNR per information bit, since
the noise is white across the band. eg. if there
are 48 data carriers each with BPSK, then there
are 48 bits per every 64 samples (in fact 64 +
length of cyclic prefix). Say CP is 16 samples, then
Eb/N0 = SNR*(48/80). This is reduced even further
if you have coding, in which case Eb/N0 is reduced
by the code rate eg. with a rate 1/2 convolutional
code applied to the above example...

Eb/N0 = SNR * (48/80) * (1/2).

eg. 64 QAM  (unencoded or BICM/TCM/TTCM)
then this also needs to be accounted for...

total number of bits increases for same energy
=> energy per bit decreases.

```
```>This is always a tricky issue and you must be
>very clear with your definitions. I would suggest
>that you begin with using all 64 subchannels as
>data carriers. This way the system must give
>identical performance to a single-carrier system
>with AWGN, when you plot the BER/SNR or
>BER/EbNo curve. If this is your reference system,
>it should be easy to migrate to 48 data subcarriers
>with 4 pilots.
>
>In any case, the way I would inject noise is by
>defining SNR = cov(x[n])/cov(u[n]) where x [n]
>is the OFDM signal and u[n] is the noise. You
>can measure cov(x[n]) easily enough in simulation
>and generate noise at appropriate level for given
>SNR.
>
>To convert this to Eb/N0, it is simply a case of
>converting SNR to SNR per information bit, since
>the noise is white across the band. eg. if there
>are 48 data carriers each with BPSK, then there
>are 48 bits per every 64 samples (in fact 64 +
>length of cyclic prefix). Say CP is 16 samples, then
>Eb/N0 = SNR*(48/80). This is reduced even further
>if you have coding, in which case Eb/N0 is reduced
>by the code rate eg. with a rate 1/2 convolutional
>code applied to the above example...
>
>Eb/N0 = SNR * (48/80) * (1/2).
>