## Hi Martin,

Could you tell me the reference paper that you used in

ofdm_equalizer_simpledfe?

Thanks

Tiankun

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.

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.

–

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

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

Sponsor our Newsletter | Privacy Policy | Terms of Service | Remote Ruby Jobs