Hello Abraham,

Let xin[n] be the input sample of the equalizer, you should implement something that should be like the following loop.

Sincerely,

Pascal.

LFF = 21; % number of feedforward coefficients

LBW = 5; % number of backward coefficients

% init of filter memory

MemFF = zeros(LFF,1); % memory init of the feedforward filter

MemBW = zeros(LBW,1); % memory init of the feedback filter

% init of filter coefficients

hFF = zeros(LFF,1);

hFF(LFF-1/2) = 1.;

hFB= zeros(LFB,1);

out = zeros(length(xin),1); % output of the equalizer

for n = 1: length(xin)

% filtering

MemFF=[xin(n);MemFF(1:LFF-1)]; % circular buffer for FFE

out(n) = hFF'*MemFF + hBW'*MemBW;

%a priori error computation

dec = out(n) - decision(out(n));

error = dec - out(n);

% filter update

hFF = hFF + stepsize * error * MemFF;

hBW = hBW + stepsize * error * MemBW;

MemBW = [dec;MemBW(1:LBW-1)]; % circular buffer for FBE

end

Hello Pascal,

Thank you very much for this awesome solution. If I understood this is the LMS ( stochastic gradient descent) solution to compute the two filters. 🙂

Hello Abraham,

Yes, the filter coefficients are updated with the LMS algorithm.

Note1 : After re-reading my answer, I found 1 typo in the matlab code : the init of the feddwordward filter should be :

hFF = zeros(LFF,1); hFF((LFF-1)/2) = 1.; % missed parenthesis

Note 2 : ilf the filtering operation is implemented by the following equation (transpose operator in place of conjugate-transpose) :

out(n) = transpose(hFF)*MemFF + transpose(hBW)*MemBW;

then the filter update shoud be :

hFF = hFF + stepsize * error * conj(MemFF);

hBW = hBW + stepsize * error * conj(MemBW) ;

I hope this will help you,

Pascal.

Hello Abraham,

I' found a second typo in my previous code. It should be :

dec = decision(out(n));

instead of

dec = out(n) - decision(out(n));

Below, you will find a correct version of the code.

Sincerely,

Pascal.

% ---------------------------------------------------------------------------------------

LFF = 21; % number of feedforward coefficients

LBW = 5; % number of backward coefficients

% init of filter memory

MemFF = zeros(LFF,1); % memory init of the feedforward filter

MemBW = zeros(LBW,1); % memory init of the feedback filter

% init of filter coefficients

hFF = zeros(LFF,1);

hFF((LFF-1)/2) = 1.;

hFB= zeros(LFB,1);

out = zeros(length(xin),1); % output of the equalizer

for n = 1: length(xin)

% filtering

MemFF=[xin(n);MemFF(1:LFF-1)]; % circular buffer for FFE

out(n) = hFF'*MemFF + hBW'*MemBW;

%a priori error computation

dec = decision(out(n));

error = dec - out(n);

% filter update

hFF = hFF + stepsize * error * MemFF;

hBW = hBW + stepsize * error * MemBW;

MemBW = [dec;MemBW(1:LBW-1)]; % circular buffer for FBE

end

Good morning Pascal,

I am implementing your solution, is hFB THE same as hBW?

Hello Abraham,

No the the hFB are not the same as the hBW !!!!

- hFB are the filter coefficients for the FF (FeedForward) part of the equalizer, that's why they are denoted hFB (means h for FeedForward part of the equalizer)

- hBW are the filter coefficients for the BF (BackWard) part of the equalizer, that's why they are denoted hBW (means h for Backward part of the equalizer)

Usuallly the number of feedback coefficient is very smal, let's say 3 or 5.

Actually in the code hBW is never initialized and hFB on the other hand is never used...

I use demod object in matlab for dec,

hMod = comm.BPSKDemodulator;

Dec = step(hDemod, out(n)).

Or maybe the dec is equal to the hard decision after the filtering through the feedforward filter ?

Any thoughts?

Hello Abraham

for the point on initialization : the central coefficient of the FF filter is initialized to one (the other coefficients of the FF part to 0), and for the BW filter, all coefficient are initialized with 0.

>> hFF = zeros(LFF,1);

>> hFF((LFF-1)/2) = 1.;

>> hFB= zeros(LFB,1);

For the point on ".. hFB on the other hand is never used" : The backward coefficients are used in the filtering operation :

>> out(n) = hFF'*MemFF + hBW'*MemBW;

and the BW coefficents are updated with the following instruction :

>> hBW = hBW + stepsize * error * MemBW;

I think that all was OK in the code that can be foud in my last post.

Pascal

Hi all,

I would first of all say thank you again all, and especially to Pascal Scalart for the support and the supplied piece of code.

I am still struggling to understand the filter updating process, the computation of the demodulated result and the computation of the error.

Attached you can find the simulation I've done so far, the BER ~ 0.5 for all any range of SNR. That means I am missing something ...

Anyway, Thank you for your help again.

Kind regards

Abraham

Hello Abraham,

I have done a quick look at your Matlab code.

In my opinion, you shoudl first try to test your algorithm :

• withtout AWGN noise
• the number of transmitted dat shoudl be greater that 100 because the equalizer convergence is sometimes slow. A value of N = 40000 should be better
• the step-size shoudl be selected according to the following rule : stepsize = K / L / mean(abs(x.in).^2) with K in [0,1]. A value near zero (lets's say 0.05) will introduce slow but fine convergence; and a value near one (let's say 0.9) with introduce fast / noisy convergence (and perhaps divergence of the equalizer coefficients)
• to fix the stepsize, observe the time variations of your filter coefficients in order to be sure that they are converging toward an asymptotic value
• with fewer backward coefficients : LFB = 15; is too much,... try to work with 2 or 3 backward coeeficients
• be carefull when computing the BER because your equalizer as well as the channel impulse response may introduce a delay in the transmission chain. You shoud estimate this delay by computing the cross-correlation between the imput bit stream and the estimated bit stream (with a mono-polar O/1 to bipolar +1/-1 transformation). Il should be something like

>> M = min (length(s), length(sdec));

>> % the operation 1-2*x transforms 0/1 values to -1/+1 values (i.e. bipolar)

>> Ryx = xcorr(1-2*sdec(1:M),1-2*s(1:M),'unbiased');

>> k = (1:length(Rxy)) - M;

>> figure; stem( k, Rxy) % plot the cross-correlation Ryx(k)

>> [~,Delay] = max(Rxy(M-99:M+99)) -100; % search for the maximum

>> sdec_synchronized = sdec(1+Delay:end);

>> s_synchronized = s(1:length(sdec_synchronized));

then the error computation should be :

>> error_num = sum( s_synchronized~= sdec_synchronized) + error_num;

Try all of this and tell me more....

Hello Pascal,

thank you a thousand times for your help in understanding this !

back again , slowly but surely we are going to achieve it. now I made the changes you ask:

My main concern is about those two lines of code that computes the output after the DFE, and the error with the sent sequence, i.e., I am having hard time to understand why it is computed like this :

%------------------------------------------------------------------------------------------------------------%

dec(n) = step(hDemod, out(n)); % Demodulated soft output

error = dec(n) - out(n);

%------------------------------------------------------------------------------------------------------------%

Thank you again

Hello Abraham,

Here is a gift ... with this corona virus I have some time to spend and I have changed few lines in your code (I have done the modulation/demodulation operation with qammod/qamdemod)

There is still few things to do :

• there is something wrong in the SNR svalues because it does not stop by itself,
• as you can see, it takes some time to have convergence of the filter taps, so you should compute the BER (the 'asymptotic' BER) only once the coefficients have reach their asymptotical value

Pascal.

Hello Pascal ,

I'll fine tune the other parameters.

But Your solution is working...

thanks a lot.

It was a real pleasure to help you because you were so motivated to understand DFE equalizers !!! ..... I could not do nothing :-)

Hello Pascal Scalart I hope this message find you well,

I have an other question in regard to adaptativeDFE EQ,

Let's suppose we have a fast fading channel, how can we track the delay between the received symbols and the transmitted symbols ?

Knowing that the reference tap of the channel is changing with time .

thanks in advance