12 beambb_ lclms

Purpose

Simulation of a beam former application using an adaptive array with the adaptive coefficients adjusted using the LCLMS algorithms. Signals are assumed to be complex and at the baseband frequency (modulated carrier gone through a phase quadrature demodulator for instance).

Syntax

beambb_lclms

Description

The block diagram of the adaptive array simulated in this application is shown in Fig. 10.23. The array is composed of M omnidirectional (equally sensitive in all directions) sensors. All array elements receive narrow-band incident signals that include one or more jammer at the same center frequency $\omega_c$. Assuming that the received signals has been demodulated to baseband frequencies, complex signal processing can be used at this baseband frequency, which allows using much lower sampling frequency and therefore reduces the computation complexity, compared to processing at the RF or IF frequency. At baseband frequency, complete control can be achieved using only one complex coefficient in each branch to control the amplitude and the phase. Since no desired signal is used in the array shown in Fig. 10.23, the filter will converge to the trivial solution $\vw = \vnul$, unless another constraint is imposed on the adaptation process. The Linearly Constrained LMS is used in such applications to adapt the filter coefficients under the constraint $\vc ^H \vw = a$. The vector $\vc$ is used to define the look direction of the array; the direction at which the main lobe is obtained which should coincide with the incident direction of the useful signal. beambb_lclms first sets the array parameters, and then creates and initializes an adaptive filter of length $M$, where $M$ is the number of array elements, by calling init_lclms(). The adaptive filter here is an adaptive linear combiner with complex input signals equal to those received by the array sensors after demodulation to the base band frequency. A processing loop is then started, in each iteration in this loop, asptlclms() is called with a new set of sensor samples to calculate the filter output, error signal, and update the constrained filter coefficients. No desired signal is used here, and the desired is always set to zero. This simulation script uses the standard ASPT iteration progress window (IPWIN). The IPWIN has four buttons which allow you to stop and continue the simulation, show or hide the simulation graph window, break out of the processing loop, and quit the simulation. After processing all the samples, or on pressing the break or stop buttons, the sensor signal $e(n)$ is written to a wave audio file and a graph presenting the controller performance is generated.

Code

iter   = 5000;                    % samples to process
c      = 3450;                    % propagation speed
fc     = 40000;                   % Carrier frequency
Wc     = 2*pi*fc;                 % Carrier radian freq
lambda = 2*pi*c/Wc;               % Carrier wave length
Fs     = 100000;                  % sampling frequency
T      = 1/Fs;                    % sampling period
Wo     = Wc * T;                  % sampled carrier freq

Figure 10.23: Block diagram of an adaptive array using the Linearly Constrained LMS algorithm.

Po     = [80 0 -45];              % arrival angles [deg]
Avar   = [1 1 1];                 % variance of signals
M      = length(Po);              % # array elements
L      = lambda/2 * (1:M-1);      % distances bet. sensors
Po     = pi*Po/180;               % arrival angles [rad]
Do     = (Wc/c)*(L' * sin(Po));   % phase shifts [rad]

ph     = 2*pi*rand(iter,M);       %random phase
A      = repmat(sqrt(Avar),[iter 1]).*randn(iter,M);          
mu     = 0.01;                    % step size
E      = init_ipwin(iter,1);      % Initialize IPWIN

% need M filters each has 1 complex coefficient. Desired 
% signal here is always d(n) = 0 and the filter is updated
% so that sum(w) = 1 exp(j*0) and will produce a main lobe 
% at zero degree, the incident direction of the useful signal.  

[w,x,d,y,e] = init_lclms(M);
d = 0;
v = ones(M,1);		% constraint vector. 
a = 1;				% constraint scalar.

for n=1:iter
   % signal at the primary branch + receiver noise
   x(1) = sum(A(n,:) .* exp(j*ph(n,:) ),2) + 1e-3*rand;

   % signals at the reference branches
   for i=2:M
      r    = 1e-3*rand;     % receiver noise
      x(i) = sum(A(n,:).*exp(j*ph(n,:)-j*Do(i-1,:)),2)+r;
   end
 
   % calculate output, error, and update coefficients
   [w,y,e]	 = asptlclms(x,w,d,mu,v, a);

   % update the Iteration Progress Window  
   [E, stop,brk] = update_ipwin(E,e,d, 'b', w, L, Wo, c*T, 1);
	% handle the Stop button
	while (stop ~= 0), stop 	= getStop; end;
	% handle the Break button
	if (brk), plot_beam(E, w, L, Wo, c*T,1); break; end;
end
plot_beam(E, w, L, Wo, c*T,1);

Results

Running the above script will produce the sensitivity pattern shown in Fig. 10.24. The sensitivity pattern shows that the array main lobe is indeed at ($0^{\circ}$), where the array gain is almost unity. The array, therefore, passes signals received from this direction through while attenuates interferences incident with other angles.

Figure 10.24: Sensitivity pattern of an adaptive array adapted at the base-band frequency using the Linearly Constrained LMS algorithms.

See Also

INIT_ LCLMS, ASPTLCLMS, BEAMRF_ LMS.

Reference

[11] for an introduction to adaptive array signal processing.