References using in ofdm_equalizer_simpledfe

Hi Martin,
Could you tell me the reference paper that you used in
ofdm_equalizer_simpledfe?

Thanks
Tiankun

On Thu, Sep 4, 2014 at 9:04 AM, Tiankun Hu [email protected]
wrote:

Hi Martin,
Could you tell me the reference paper that you used in
ofdm_equalizer_simpledfe?

​Hello Tiankun,

A decision feedback equalizer (DFE) works like this:

The equalizer keeps track of the channel estimate on every subcarrier​
i.
Call this estimate H_i. The initial values of H_i are provided by the
Schmidl-Cox block, and these values are calculated from the SYNC symbols
present in every packet.

Now, when a symbol r_i is received on subcarrier i, it is equalized
using
the estimate H_i. The equalized symbol is matched to the nearest
constellation point. Let this symbol be R_i. Now, the new estimate of
H_i
is calculated from r_i and R_i. This new value of H_i is then used for
the
next symbol on subcarrier i.

DFE works well when the channel changes slowly across time. However, if
there is substantial residual CFO (carrier frequency offset) or Doppler,
then errors are possible. Substantial channel variations across
subcarrier
indices is irrelevant, because DFE maintains an independent channel
estimate H_i for each subcarrier i.

Good luck with GNU Radio. :slight_smile:

Best,
Aditya

Aditya, thanks your clarify !

在 2014年09月04日 21:31, Aditya D. 写道:

using the estimate H_i. The equalized symbol is matched to the nearest
Good luck with GNU Radio. :slight_smile:


Thanks
Tiankun

On Thu, Sep 4, 2014 at 11:29 AM, Tiankun Hu [email protected]
wrote:

                    if (!d_occupied_carriers[k]) {
                                / d_pilot_symbols[d_pilot_carr_
                        d_channel_state[k] = d_alpha *
            }

​Hello Tiankun,

That’s a good question. The answer depends on how you want to implement
DFE
– and there are a couple of options.

a) Ignore pilots altogether. This is what I had described in my earlier
email.

b) Since pilots are known symbols, if a pilot is encountered, the new
channel estimate will always be correct. We know the received symbol r_i
and the expected symbol E_i, so it is trivial to calculate the channel
estimate H_i. However if you ignore the pilots, then Doppler or residual
CFO can make the decoding on a non-pilot symbol incorrect, leading to an
incorrect estimate of H_i propagating to all subsequent symbol indices
on
that subcarrier ‘i’.

Hope that helps.

Best,
Aditya

Hi Aditya,
What’s use of pilot symbols in “ofdm_equalizer_simpledfe” ?
I just found pilot symbols update their carrier’s channel state, but
didn’t find what’s the use of these pilot channel state, seems them has
no relate with data symbol, data symbol also only use themselves to
update channel state.

             for (int i = 0; i < n_sym; i++) {
                 for (int k = 0; k < d_fft_len; k++) {
                     if (!d_occupied_carriers[k]) {
                         continue;
                     }
                     if (!d_pilot_carriers.empty() &&

d_pilot_carriers[d_pilot_carr_set][k]) {
======> //didn’t find any use of these channel state in pilot
carriers <=========
//seems has not relate with data symbol
d_channel_state[k] = d_alpha * d_channel_state[k]
+ (1-d_alpha) * frame[i*d_fft_len + k]
/
d_pilot_symbols[d_pilot_carr_set][k];
frame[i*d_fft_len+k] =
d_pilot_symbols[d_pilot_carr_set][k];
} else {
sym_eq = frame[i*d_fft_len+k] /
d_channel_state[k];
d_constellation->
map_to_points(d_constellation->
decision_maker(&sym_eq), &sym_est);
d_channel_state[k] = d_alpha *
d_channel_state[k]
+ (1-d_alpha) * frame[i*d_fft_len + k]
/ sym_est;
frame[i*d_fft_len+k] = sym_est;
}
}
if (!d_pilot_carriers.empty()) {
d_pilot_carr_set = (d_pilot_carr_set + 1) %
d_pilot_carriers.size();
}
}

在 2014年09月04日 22:59, Tiankun Hu 写道:

Could you tell me the reference paper that you used in

present in every packet.
subcarrier indices is irrelevant, because DFE maintains an independent
Discuss-gnuradio mailing list
[email protected]
Discuss-gnuradio Info Page


Thanks
Tiankun

Hi Aditya,
Thanks your time!
But how to use pilotes symbol’s channel state to update data symbol’s?
“ofdm_equalizer_simpledfe” is so simple, so it didn’t realize that,
right?
Is there any example or paper can be for reference?

Thanks
Tiankun

------------------ 原始邮件 ------------------
发件人: “Aditya D.”;[email protected];
发送时间: 2014年9月4日(星期四) 晚上11:45
收件人: "Tiankun Hu"[email protected];
抄送: "[email protected]"[email protected];
主题: Re: [Discuss-gnuradio] references using in ofdm_equalizer_simpledfe

On Thu, Sep 4, 2014 at 11:29 AM, Tiankun Hu [email protected]
wrote:
Hi Aditya,
What’s use of pilot symbols in “ofdm_equalizer_simpledfe” ?
I just found pilot symbols update their carrier’s channel state, but
didn’t find what’s the use of these pilot channel state, seems them has
no relate with data symbol, data symbol also only use themselves to
update channel state.

            for (int i = 0; i < n_sym; i++) {
                for (int k = 0; k < d_fft_len; k++) {
                    if (!d_occupied_carriers[k]) {
                        continue;
                    }
                    if (!d_pilot_carriers.empty() && 

d_pilot_carriers[d_pilot_carr_set][k]) {
======> //didn’t find any use of these channel state in pilot
carriers <=========
//seems has not relate with data symbol
d_channel_state[k] = d_alpha *
d_channel_state[k]
+ (1-d_alpha) * frame[i*d_fft_len + k]
/
d_pilot_symbols[d_pilot_carr_set][k];
frame[i*d_fft_len+k] =
d_pilot_symbols[d_pilot_carr_set][k];
} else {
sym_eq = frame[i*d_fft_len+k] /
d_channel_state[k];
d_constellation->
map_to_points(d_constellation->
decision_maker(&sym_eq),
&sym_est);
d_channel_state[k] = d_alpha *
d_channel_state[k]
+ (1-d_alpha) * frame[i*d_fft_len + k] /
sym_est;
frame[i*d_fft_len+k] = sym_est;
}
}
if (!d_pilot_carriers.empty()) {
d_pilot_carr_set = (d_pilot_carr_set + 1) %
d_pilot_carriers.size();
}
}

​Hello Tiankun,

That’s a good question. The answer depends on how you want to implement
DFE – and there are a couple of options.

a) Ignore pilots altogether. This is what I had described in my earlier
email.

b) Since pilots are known symbols, if a pilot is encountered, the new
channel estimate will always be correct. We know the received symbol r_i
and the expected symbol E_i, so it is trivial to calculate the channel
estimate H_i. However if you ignore the pilots, then Doppler or residual
CFO can make the decoding on a non-pilot symbol incorrect, leading to an
incorrect estimate of H_i propagating to all subsequent symbol indices
on that subcarrier ‘i’.

Hope that helps.

Best,
Aditya

It uses them. It will reset the channel state estimate every time it
encounters a pilot symbol. See eg the qa codes for examples. If you want
to
make use of them in your modem, you need to put pilots on the same
carriers
as the data.

M

Aditya/Martin, thanks your help, I will read these references that you
mentioned.

在 2014年09月06日 00:31, Aditya D. 写道:

important to note. If I remember correctly, the reference implementation

encounters a pilot symbol. See eg the qa codes for examples. If you
    But how to use pilotes symbol's channel state to update data
    *发送时间:* 2014年9月4日(星期四) 晚上11:45


        symbol
        d_channel_state[k];
                                 }

    ignore the pilots, then Doppler or residual CFO can make the

Discuss-gnuradio mailing list
[email protected]
Discuss-gnuradio Info Page


Thanks
Tiankun

Hi Tiankun,

To add on to what Martin said: In DFE, the channel state H_I on
subcarrier
i is updated everytime it receives a new symbol on that subcarrier. It
doesn’t really care of that symbol is a pilot or a data symbol. If it is
a
pilot, the channel estimate H_i is trivially calculated and updated. If
it
is a data symbol, then the nearest constellation point is found, and is
then used to update H_i.

And as Martin mentioned, the pilot placement pattern in the packet is
important to note. If I remember correctly, the reference implementation
uses the “comb” type pilot patter. Look at Figure 1(b) in the link
below.
In the “comb” pilot pattern, the pilots are useless, as the subcarriers
that contain the pilot symbols do not carry data symbols. You will need
to
use the “block” pilot pattern (look at Figure 1(a) below, and you will
immediately see how DFE is applicable in this case.

Of course, there are other types of pilot patterns, but you can ignore
them
for now. Good luck!

best,
aditya

On Fri, Sep 5, 2014 at 12:15 PM, Martin B. [email protected]

On 15 Sep 2014 17:34, “Tiankun Hu” [email protected] wrote:

Hi Aditya/Martin,
I still looked at rx/tx_ofdm.grc.
Seems there an issue in “ofdm_equalizer_simpledfe.cc line90”.
If we use “ofdm_carrier_allocator_cvc_impl.cc” to allocator data and
pilot, the d_occupied_carriers[k] and
d_pilot_carriers[d_pilot_carr_set][k]
shouldn’t equal to 1 at the same time, otherwise we will lose some data,
right? if so, when code arrive at line93 it will always false, so no
matter
we use block type or comb type pilot, the pilot will always useless.

Yep. Your configuration must be sensible.

In “qa_ofdm_frame_equalizer_vcvc.test_002_simpledfe”, since we construct
tx_data by hand, so this issue not occur, might we should remove
line90~92
or let “ofdm_carrier_allocator_cvc_impl.cc” do not allocate data to
carriers where both d_occupied_carriers[k]/d_pilot_carriers[k] equal to

And second question is why “d_occupied_carriers” degrade to 1-d arrays
when init this object?

It’s flattened for easier lookup.

M

89 for (int k = 0; k < d_fft_len; k++) {
90 if (!d_occupied_carriers[k]) {
91 continue;
92 }
93 if (!d_pilot_carriers.empty() &&
d_pilot_carriers[d_pilot_carr_set][k]) {
94 d_channel_state[k] = d_alpha * d_channel_state[k]
95 + (1-d_alpha) * frame[i*d_fft_len + k] /
d_pilot_symbols[d_pilot_carr_set][k];
96 frame[i*d_fft_len+k] = d_pilot_symbols[d_pilot_carr_set][k];
97 } else {
98 sym_eq = frame[i*d_fft_len+k] / d_channel_state[k];
99
d_constellation->map_to_points(d_constellation->decision_maker(&sym_eq),
&sym_est);
100 d_channel_state[k] = d_alpha * d_channel_state[k]
101 + (1-d_alpha) * frame[i*d_fft_len + k]
/ sym_est;

Hi Aditya/Martin,
I still looked at rx/tx_ofdm.grc.
Seems there an issue in “ofdm_equalizer_simpledfe.cc line90”.
If we use “ofdm_carrier_allocator_cvc_impl.cc” to allocator data and
pilot, the d_occupied_carriers[k] and
d_pilot_carriers[d_pilot_carr_set][k] shouldn’t equal to 1 at the same
time, otherwise we will lose some data, right? if so, when code arrive
at line93 it will always false, so no matter we use block type or comb
type pilot, the pilot will always useless.

In “qa_ofdm_frame_equalizer_vcvc.test_002_simpledfe”, since we construct
tx_data by hand, so this issue not occur, might we should remove
line90~92 or let “ofdm_carrier_allocator_cvc_impl.cc” do not allocate
data to carriers where both d_occupied_carriers[k]/d_pilot_carriers[k]
equal to 1.

And second question is why “d_occupied_carriers” degrade to 1-d arrays
when init this object?

89 for (int k = 0; k < d_fft_len; k++) {
90 if (!d_occupied_carriers[k]) {
91 continue;
92 }
93 if (!d_pilot_carriers.empty() &&
d_pilot_carriers[d_pilot_carr_set][k]) {
94 d_channel_state[k] = d_alpha * d_channel_state[k]
95 + (1-d_alpha) * frame[i*d_fft_len + k] /
d_pilot_symbols[d_pilot_carr_set][k];
96 frame[i*d_fft_len+k] =
d_pilot_symbols[d_pilot_carr_set][k];
97 } else {
98 sym_eq = frame[i*d_fft_len+k] / d_channel_state[k];
99
d_constellation->map_to_points(d_constellation->decision_maker(&sym_eq),
&sym_est);
100 d_channel_state[k] = d_alpha * d_channel_state[k]
101 + (1-d_alpha) * frame[i*d_fft_len + k] / sym_est;
102 frame[i*d_fft_len+k] = sym_est;
103 }
104 }

在 2014年09月06日 00:31, Aditya D. 写道:

important to note. If I remember correctly, the reference implementation

encounters a pilot symbol. See eg the qa codes for examples. If you
    But how to use pilotes symbol's channel state to update data
    *发送时间:* 2014年9月4日(星期四) 晚上11:45


        symbol
        d_channel_state[k];
                                 }

    ignore the pilots, then Doppler or residual CFO can make the

Discuss-gnuradio mailing list
[email protected]
Discuss-gnuradio Info Page


Thanks
Tiankun