- A stationary signal
*x*[*n*], that is of zero mean, unity power and temporally uncorrelated,

E[* ,*

is passed through a channel with time-discrete impulse response *h*[*k*], such that the noiseless received signal *u*[*n*] reads as

*L _{h}*1

*u*[*n*] = X *h*[*k*] *x*[*n * *k*] *,*

*k*=0

where *L _{h }*is the length of the channels impulse response. For

*L*1 the channel will introduce intersymbol interference (ISI), that the receiver wishes to remove by means of a linear minimum mean square error (LMMSE) adaptive equalizer that produces the output

_{h }>*y*[

*n*]

* ,*

where *M *is the filter length and *w*[0]*,w*[1]*,,w*[*M * 1] are the filter coefficients.

- Express the filter output
*y*[*n*] in terms of the two vectors**w**= [*w*[0]*w*[1]*w*[*M*1]]^{T }and**u**[*n*] = [*u*[*n*]*u*[*n*1]*u*[*n**M*+ 1]]^{T}. - The desired output
*d*[*n*] of the adaptive filter is chosen to be

*d*[*n*] = *x*[*n * *M *+ 1] *,*

in order to make maximum use of the filter memory. Compute the Wiener solution in terms of a correlation matrix **R **and a correlation vector **p**.

- Now compute the correlation coefficients
*r*[*m*] = E[*u*[*n*]*u*^{}[*n**m*]] and express the correlation matrix**R**and correlation vector**p**from subtask 1b as a function of the channel impulse response*h*[*k*]. - For the case
*M*=*L*= 2, with_{h }*h*[0] =*a*C,*h*[1] =*b*C and zero elsewhere, compute the Wiener solution for**w**explicitly in terms of*a*and*b*. Now set*b*= 0 and compute the current error*e*[*n*] =*d*[*n*]*y*[*n*]. - Now set the filter length to
*M*= 6, and use the channel from subtask 1d to compute the Wiener solution for*a*= 4 and*b*= 5 by using matlab. How large is the residual mean square error (MSE)? - Write a matlab program that will plot the square root of the residual mean squared error as a function of the filter length
*M*in the range 2*M*50 in steps of one. Note: Use the semilogy function for the plotting.

2

Figure 1: Frame structure of the transmitted data stream

- The adaptive equalizer from task 1 shall now be implemented using the LMS algorithm. To this end assume the transmitted data stream is structured in frames as depicted in Figure 1. Each frame starts with a training sequence (pilot) of length
*L*symbols, which is followed by_{P }*L*symbols of actual data. At the end of each frame there is a so called guard interval where the transmitter is quiet (transmitting zeros) for_{D }*L*symbols. In the following assume_{G }*L*=_{G }*L*+_{h }*M*. This will let the programmable receiver FIR-filter start in the zero state for each frame, i.e. the simulation can be carried out on a frame by frame basis. The symbols are chosen out of the set {1*,*+1}, i.e. BPSK modulated. The pilot sequence used has length*L*= 18, and is defined as:_{P }

1 1 1 +1 +1 1 1 1 +1 +1 +1 +1 1 +1 +1 1 +1 1

where the sequence is transmitted going from left to right. In the following assume *L _{D }*= 150,

*M*= 6,

*L*= 2,

_{h }*L*= 8 and the channel coefficients

_{G }*h*[0] = 4 and

*h*[1] = 5 as in subtask 1e.

- Write a matlab program that will simulate the advances of LMS adaptive equalization by evaluating thenumber of bit-errors in 30 successive frames. Note, that the weight update by LMS is only performed during the pilot phases. In each frame initialize the LMS with the weight vector obtained from the previous frame. For the very first frame use the all zero vector as the initial weight vector. Set the step size to 0
*.*0015 for the LMS. When computing bit errors, make sure you look at the data portion of the frame only. - Compare the final weight vector found by the LMS with the theoretical one derived in subtask 1e.

Hints:

- A frame can be generated e.g. like this:

data = sign(randn(Ld,1)); frame = [pilot;data;zeros(Lg,1)];

- The received signal and filter output can be computed e.g. like: u = conv(h,frame); y = conv(conj(w),u);
- Bit detection may be done like this: bits = sign(real(y))
- The desired signal is: d = [zeros(M-1,1);pilot(1:Lp-M+1)];
- Use the stem function for plotting the bit errors
- You can use the LMS program below if you like.

function w = LMS(w0,u,d,s)

%w = LMS(w0,u,d,s)

%LMS alorithm

%INPUT

% w0: [M,1] : Init weight vector, M = Number of taps

% u : [N,1] : Input data vector

% d : [N,1] : Desired output data vector

% s : [1,1] : step-size parameter

%OUTPUT

% w : [M,1] : final tap weight vector

if (nargin<4) error(Too few parameters); end;

N = length(u); M = length(w0); w = w0;

x = zeros(M,1); for k=1:N x = [u[k];x(1:M-1)]; e[k] = d[k] w*x; dw = s * conj(e[k]) * x; w = w + dw;

end;

## Reviews

There are no reviews yet.