Trong cc phng hi ngh, b phn nhn m thanh thng l nn nhn ca mi

trng tn sc truyn m. Hin tng tn sc ny to ra rt nhiu ting vang

trong tin hiu nhn. Mun nng cao cht lng tin hiu nhn, chng ta bt buc
phi xy dng cc phng php nhm loi b cc ting vang.
I.

t vn

Kh ting vang m thanh l mt vn c tm thc tin quan trng, chng hn

kh ting vang trong cc phng hi ngh hoc cho nhng ngi s dng in
thoi di ng trong cc xe hi m khng cn dung n tay.
X l thch nghi c ng dng rt ph bin trong x l ting ni, c bit l
c s dng lc nhiu m hc v kh ting vang (AEC). Trong thc tin,
vic x l thch nghi trn ton di s lm cho h thng phi chu 1 lng tnh
ton rt ln v gy kh khn khi thc thi vo cc phn cng. cng chnh l
nguyn nhn khch quan dn ti vic s dng thch nghi bng con trong bi
ton x l thch nghi.
II.

Nhiu ting vng

Thng thng, lc mt tn hiu cha ng thng tin c pht i, u nhn

ngoi phn tp m do b nhn pht sinh, ta cn nhn c rt nhiu ting vang
t tn hiu ny to ra do tnh tn sc ca mi trng truyn m.
H thng s x l m thanh thng thng phi ly mu khaongr 8000 mu mi
giy. Do , lc tr do hin tng tn sc to ra kh ln th m hnh knh
truyn ca mi trng truyn m thanh l mt t hp tuyn tnh ca rt nhiu h
s tng ng vi rt nhiu tr khc nhau, trn tn hiu c pht i.

Tn hiu ca ngi pht ngn vo micro c pht ra t loa (xem hnh 1). m
thanh pht i do mi trng ca phng hi ngh s c vang di i theo nhiu
chiu hng khc nhau. Nhng ting vang ny li p vo micro to thnh mt
tn hiu gm thnh phn chnh v rt nhiu ting vang khc nhau. Ti u nhn
ca micro, mi ting vang c c trng ha bi suy gim v tr. Ngoi
ra, bn thanh ca micro nu cht lng khng tt cng gy nn mt loi tp m
c gi l tp m trng hoc tp m nhit. Nh th, nu tn hiu pht i l x(t)
th u ra ca micro tin hiu r(t) s c dng:

Hnh 2 m t mt phn tch nhiu m hc n gin. , tn hiu gc l tn

hiu hnh sin c dng tn s 20Hz c ly mu tn s Fs= 100Hz. Sau , tn
hiu nhiu ting vng c bin bng mt na c cng vo tn hiu gc sau
0.3 giy. Hnh lin nt cho ta php phn tch ph cep (cepstrum) ca tn hiu b
vng v hnh t nt l ph cep ca tn hiu gc. Lu rng ph cep ca tn
hiu b vng xut hin mt nh ti t=0.3 giy.

R rng l vi cch phn tch ph truyn thng dng FFT khng th cho ta nhn
bit v nhiu ting vng trong v d trn (hnh 3)

loi b ting vang v nhiu, ngi ta dung mt b lc vi u vo tn hiu

r(t). B lc phi c chn th no u ra cho ta tn hiu xp x tt nht ca
tn hiu s(t) (vi mt suy gim v mt tr no ). Bi v cc c trng
ca mi trng ngu nhin kh bit trc c cho nn khng th no xy dng
c t trc b lc ny. Tuy nhin, cc h s ca b lc ny c th c iu
chnh mt cch t ng phc thuc vo cht lng v tnh hung cng nh mi

trng hot ng ca h thng. Phng php iu chnh t ng cc h s ny

c gi l phng php t thch nghi.
III.

X L T THCH NGHI THEO BNG CON.

Vai tr ca h thng kh ting vang l t r(t) phi ti to li cho c s(t). V

mt thc t, lc ti to s(t), ta chp nhn mt tr v mt suy gim no .
Ngoi ra, cng phi chp nhn mt tn hin giao thoa no do khng loi c
ton b nhiu v ting vang, min l tn hiu giao thoa ny nh hn tn hiu ta
mun ti to. Vn kh khn v mt ton hc cng nh v mt thit b l s
ting vang M kh ln (c th ln n vi nghn). Nhng thut ton c in
ngh s dng mt b lc nhiu h s v cc h s ny c iu chnh theo mt
s phng php mang tn t thch nghi. Cu trc ny thng c gi l cu
trc x l ton bng. Cc phng php ny c th s dng gii quyt vn
kh ting vang v lc nhiu m hc. Tuy nhin khi lng tnh ton tng ng
l rt ln cho nn khng th p dng vo thi gian thc c. gii quyt vn
ny, mun rt gn thi gian x l thc hin trn thi gian thc th ta phi
tm cch song song ha cu trc (xem hnh 4); c ngha l thay th phng php
x l hang nghn h s ln lt, th ta s l mt lot nhiu h s cng mt lc.
y l khi nim c bn ca phng php x l song song. V mt thc tin,
thc hin phng php ny ta phi dung n khi nim x l theo bng con, tc
l ng ra phi x l ln lt chng hn mt b lc gm 1000 h s, th ta x l
cng mt lc 20 b lc m mi b lc ch cha 50 h s.

Nh ni trn, mi trng truyn m thanh trong cc phng hi ngh hay

trong khng gian kn nh t th knh truyn thng c m hnh ha bi mt
h thng cha hng nghn h s. c th xy dng mt h thng theo thi
gian thc ta phi dng cc x l song song nh c cp trn.
Chng ta s nhn c th hn vo kha cnh ny nh sau: gi s dn lc bng con
M di vi cc b lc phc th ch cn x l trn M/2+1 di (coi M chn). Vi s
lng bng con ln th lm gn ng l cn x l trn M/2 bng con. S trng
s trn mi bng con lc ny l N/L. vi N l s trng s ca b lc thch nghi
ton di v 1/L l tc x l gim trn mi bng. Nh vy s trng s phc
cn thit l MN/2L. Nh vy ta d dng c lin h sau:

C th d dng thy phc tp ca bng con c th c gim theo mt h s

l s bng con (nu y ta chn M=L).
Tt nhin l vi x l bng con th chng ta phi tnh thm nhng tnh ton cn
thit trn cc dn lc phn tch v tng hp. Cng thc c thit lp cho dn
lc kiu DFT l:

Vi Na v Ns l trng s ca b lc trn dn lc phn tch v tng hp. Nu a

vo nhng tnh ton c th so snh v phc tp th phng php x l t
thch nghi bng con s tit kim c ti 60% m vn m bo cht lng.
C rt nhiu phng php x l t thch nghi bng con, nh mt cch lm t
nhin v rt trc quan, h thng m m t y c thc hin theo m hnh
trong hnh 5. Mt im d nhn thy khi quan st hnh 5 l nhc im ca x
l t thch nghi bng con: th nht l s gy nn tr (do dn lc) v chng ph
(do gim mu). li chng ph l kh nghim trng v thc t c rt nhiu
tc gi a ra cc cch khc phc khc nhau nh ly mu tc rt cao hay s
dng cc cch thit k dn lc tt hn.

Trong bi ny, cc kt qu thu c tng ng vi cc h thng x l t thch

nghi bng con khc nhau l M= 2,4,8. RLS (Recursive Least Square) v LMS
(Least Mean Square) l cc phng php gip ta iu chnh cc h s ca cc
bng con th no sai s ti to nh nht. Thng thng phng php tnh
LMS c a chung hn v phc tp thp hn..
Cng nhn trn hnh 5 minh ha v dn lc M knh, lu rang vi mi b lc
thch nghi th ei (I = 1,2,,M) l li c lng trn mi b lc thch nghi bng
con s c dung iu khin tng b lc thch nghi ny. Trn thc t, c
nhiu cch iu chnh vn tc hi t ca cc b lc thch nghi, trong c
cch iu khin bng tn hiu tng hp ca ei ny.
Trong chng trnh th nghim ny, dn lc phn tch v tng hp 4 bng con
c s dng (xem hnh 6). Kt qu thc thi c trnh by trn hnh 6 vi 1 tn
hiu v 2 ting vang c ghi m t micro. Tt nhin rang cu trc ny c
th m rng cho bt k cc thng s no m ngi s dng mong mun.

Kt qu trnh by trn hnh 7 tng ng vi cc tn hiu gc, tn hiu b nhiu

ting vang v tn hiu sau khi kh ting vang. Rt d nhn thy rng tn hiu b
nhiu ting vang b sai khc rt nhiu so vi tn hiu gc v c th cm nhn r
rang khi nghe trc tip. Nh s dng t thch nghi theo bng con m tn hiu
khi phc rt tt tuy rng chng ta phi chp nhn mt khong tr nht nh.

Hnh 8 m t s hi t ca h s b lc thch nghi trn bng con c di thng

thp nht. y bc nhy thch nghi c la chn l 0.002 v chiu di b
lc l 40.

Vi mc ch so snh cht lng ca tn hiu trn ton di v trn bng con,

chng ta tin hnh so snh li c tnh bng tr tuyt i ca tn hiu gia tn
hiu khi phc v tn hiu gc. Kt qu c th hin trn hnh 9. Nhn xt rng
tn hiu li do phng php bng con lc u suy gim nhanh hn nhng sau
khi n nh th phng php ton di thng li cho li nh hn. Khi c hai h
thng hi t, n nh th r rng cc hiu ng gy bi cc dn lc phn tch v
tng l khng th trnh khi.

Quay tr li vi h thng lc thch nghi 4 bng con. Chng ta cn xt ti bi

ton ti u chn L v mu nh th no li l ti thiu ( y bi ton gi s
ang nhm ti ti u thng s ny). Kt hp vi thut ton ni suy cc b s
cho php xc nh chnh xc c gi tr ti u ca L v mu ( y L=32 v
mu=0.055) (xem hnh 10). Tng t nh vy nu chng ta cn ti u mt thng
s no khc th chng ta li tin hnh xy dng thut ton ph hp v ti u
thng s mong mun.

V mt l thuyt, bi ny kt hp phng php lun ca phng php x l

t thch nghi v cu trc bng cn. Nhng kt qu thu ln c cho thy cu
trc x l t thch nghi ton bng v cu trc x l t thch nghi theo bng con

cho cc kt qu c cht lng tng ng. Tuy nhin, cu trc bng con cho
php rt ngn thi gian x l cho nn tng i thch hp vi cc tnh hung
thc t. Kt qu thu c cho thy x l t thch nghi theo bng con thch hp
hn rt nhiu cho nhng tnh hung m ting vang l ngun nhiu chnh m b
x l phi trc din.

A.1 LMS.m (LMS ALGORITHM)

function [input_signal, error_signal, desired_signal, filter_output, impulse, filter_current,
mse, db, db_avg]=LMS(filter_size, step_size, input_file, iterations)
% Function to perform the LMS algorithm on an input file.
% Inputs: Filter order, step size, input wav file, number of iterations.
% Outputs: Input signal, error estimation signal (echo cancelled), desired signal (echoed
signal), adaptive filter output, real impulse response
% Estimation of impulse response, mean sqaure error, attenuation (dB), average attenuation.
%Read in the input file
input_signal=wavread(input_file);
% Create the impulse response for the desired signal
Impulse = zeros(filter_size,1);
for (i=1:5)
impulse(((i-1)*filter_size/5)+1) = 1/i;
end
% Convolve the impulse with the input signal to generate the desired signal
desired_signal = conv(input_signal, impulse);
% initialise adaptive filter impulse and input vector to zero vector of length specified at
command line
filter_current = zeros(filter_size,1);
input_vector = zeros(filter_size, 1);
% Loop for number of iterations specified in command line.
for i=1:iterations
i
input_vector(1)=input_signal(i); % insert new sample at beginning of input vector.
filter_output(i)=dot(filter_current, input_vector); %Caluculate adaptive filter output
error= desired_signal(i)-filter_output(i) % Calculate estimation error
filter_current = filter_current + 2*step_size*error*input_vector; % Update filter taps by LMS
recursion
% Shift values in input vector along.
for j=filter_size:-1:2
input_vector(j)=input_vector(j-1);
end
error_signal(i)=error; % store estimation error
cost(i)=error*error; % calculate instantaneous cost square error
end
% Find moving average of error squared.
for i=1:iterations-100
mse(i)=mean(cost(i:i+100));
i
end

%find moving average of db attenuation (averaged to smooth output).

for i=1:iterations-2500
db(i)=20*log10(mean(abs(desired_signal(i:i+2500)))./mean(abs(error_signal(i:i+2500))));
i
end
%find total average db attenuation
db_avg=mean(db);
A.2 NLMS.m (NLMS ALGORITHM)
function [input_signal, error_signal, desired_signal, filter_output, impulse, filter_current,
mse, db, db_avg, ss]=NLMS(filter_size, input_file, iterations)
% Function to perform the NLMS algorithm on an input file.
% Inputs: Filter order, input wav file, number of iterations.
% Outputs: Input signal, error estimation signal (echo cancelled), desired signal (echoed
signal), adaptive filter output, real impulse response
% Estimation of impulse response, mean square error, attenuation (dB), average
attenuation, step size.
% Read in the input file
input_signal = wavread(input_file);
%Generate acoustic impulse response and convolve to get echoed signal
impulse=zeros(filter_size,1);
for (i=1:5)
impulse(((i-1)*filter_size/5)+1)=1/i;
end
desired_signal = conv(input_signal, impulse);
% initialise variables
filter_current = zeros(filter_size,1);
input_vector = zeros(filter_size, 1);
% perform the NLMS algorithm for set number of iterations
for i=1:iterations
i
% get input sample
input_vector(1)=input_signal(i);
filter_output(i)=dot(filter_current, input_vector);
error= desired_signal(i)-filter_output(i)
% calculate step size
step_size=1/(dot(input_vector, input_vector))
% update filter tap weight vector
filter_current = filter_current + step_size*error*input_vector;
% shift input vector
for j=filter_size:-1:2
input_vector(j)=input_vector(j-1);
end
error_signal(i)=error;
cost(i)=error*error;
ss(i)=step_size;
end
% Find moving average of error squared.

for i=1:iterations-100
mse(i)=mean(cost(i:i+100));
i
end
%find moving average of db attenuation (averaged to smooth output).
for i=1:iterations-2500
db(i)=20*log10(mean(abs(desired_signal(i:i+2500)))./mean(abs(error_signal(i:i+2500))));
i
end
%find total average db attenuation
db_avg=mean(db);
A.3 VSLMS.m (VSLMS ALGORITHM)
function [input_signal, error_signal, desired_signal, filter_output, impulse, filter_current,
mse, db, db_avg]=VSLMS(filter_size, ss_upper,ss_lower, input_file, iterations)
% Function to perform the VSLMS algorithm on an input file.
% Inputs: Filter order, step size, stepsize upper bound, stepsize lower bound, input wav
file, number of iterations.
% Outputs: Input signal, error estimation signal (echo cancelled), desired signal (echoed
signal), adaptive filter output, real impulse response
% Estimation of impulse response, mean sqaure error, attenuation (dB), average
attenuation.
% read in input wav file
input_signal = wavread(input_file);
% generate impulse response of acoustic environment and convolve with input to achieve
desired echo signal
impulse=zeros(filter_size,1);
for (i=1:5)
impulse(((i-1)*filter_size/5)+1)=1/i;
end
desired_signal = conv(input_signal, impulse);
% initialise variables
filter_current = zeros(filter_size,1);
input_vector = zeros(filter_size, 1);
stepsize_curr = zeros(filter_size, 1);
stepsize_prev = zeros(filter_size, 1);
gradient_curr = zeros(filter_size, 1);
gradient_prev = zeros(filter_size,1);
% perform VSLMS algorithm for set number of iterations
for i=1:iterations
i
% get input sample
input_vector(1)=input_signal(i);
% calculate filet output
filter_output(i)=dot(filter_current, input_vector);
% calculate error signal
error= desired_signal(i)-filter_output(i)
gradient_curr=error*input_vector;

%perform step size update

stepsize_curr = stepsize_prev + gradient_curr.*gradient_prev;
% Maintain step_size vector between upper and lower limits.
for j=1:filter_size
if stepsize_curr(j) > ss_upper;
stepsize_curr(j) = ss_upper;
end
if stepsize_curr(j) < ss_lower
stepsize_curr(j) = ss_lower;
end
end
% update filter tap weight vector
filter_current = filter_current + 2*diag(stepsize_curr)*gradient_curr;
% shift values in input vector along ready for next iteration
for j=filter_size:-1:2
input_vector(j)=input_vector(j-1);
end
%store values of error and cost function.
error_signal(i)=error;
cost(i)=error*error;
%update variable vectors for next iteration
gradient_prev=gradient_curr;
stepsize_curr=stepsize_prev;
end
% Find moving average of error squared.
for i=1:iterations-100
mse(i)=mean(cost(i:i+100));
i
end
%find moving average of db attenuation (averaged to smooth output).
for i=1:iterations-2500
db(i)=20*log10(mean(abs(desired_signal(i:i+2500)))./mean(abs(error_signal(i:i+2500))));
i
end
%find total average db attenuation
db_avg=mean(db);
A.4 VSNLMS.m (VSNLMS ALGORITHM)
function [input_signal, error_signal, desired_signal, filter_output, impulse, filter_current,
mse, db, db_avg]=VSNLMS(filter_size, ss_lower, input_file, iterations)
% Function to perform the VSNLMS algorithm on an input file.
% Inputs: Filter order, step size, stepsize upper bound, stepsize lower bound, input wav
file, number of iterations.
% Outputs: Input signal, error estimation signal (echo cancelled), desired signal (echoed
signal), adaptive filter output, real impulse response
% Estimation of impulse response, mean sqaure error, attenuation (dB), average
attenuation.
% read in input wav file.
input_signal = wavread(input_file);

% generate impulse response and convolve to get echoed signal

impulse=zeros(filter_size,1);
for (i=1:5)
impulse(((i-1)*filter_size/5)+1)=1/i;
end
desired_signal = conv(input_signal, impulse);
% initialise variables
filter_current = zeros(filter_size,1);
input_vector = zeros(filter_size, 1);
stepsize_curr = zeros(filter_size, 1);
stepsize_prev = zeros(filter_size, 1);
gradient_curr = zeros(filter_size, 1);
gradient_prev = zeros(filter_size,1);
% perform VSNLMS algorithm for set number of iterations
for i=1:iterations
i
% get input sample
input_vector(1)=input_signal(i);
filter_output(i)=dot(filter_current, input_vector);
error= desired_signal(i)-filter_output(i)
gradient_curr=error*input_vector;
% calcualte variable upper limit
ss_upper = 1/(2*(dot(input_vector,input_vector)));
% update stepsize vector
stepsize_curr = stepsize_prev + gradient_curr.*gradient_prev;
% Maintain step_size vector between upper and lower limits.
for j=1:filter_size
if stepsize_curr(j) > ss_upper;
stepsize_curr(j) = ss_upper;
end
if stepsize_curr(j) < ss_lower
stepsize_curr(j) = ss_lower;
end
end
% update filter tap weights
filter_current = filter_current + 2*diag(stepsize_curr)*gradient_curr;
% shift values in input vector along ready for next iteration
for j=filter_size:-1:2
input_vector(j)=input_vector(j-1);
end
%store values of error and cost function.
error_signal(i)=error;
cost(i)=error*error;
%update variable vectors for next iteration
gradient_prev=gradient_curr;
stepsize_curr=stepsize_prev;
end
% Find moving average of error squared.
for i=1:iterations-100
mse(i)=mean(cost(i:i+100));

i
end
%find moving average of db attenuation (averaged to smooth output).
for i=1:iterations-2500
db(i)=20*log10(mean(abs(desired_signal(i:i+2500)))./mean(abs(error_signal(i:i+2500))));
i
end
%find total average db attenuation
db_avg=mean(db);
A.5 RLS.m (RLS ALGORITHM)
function [input_signal, error_signal, desired_signal, filter_output, impulse, filter_prev,
cost, mse, db,db_avg]=RLS(filter_size, lambda, input_file, iterations)
% Function to perform the RLS algorithm on an input file.
% Inputs: Filter order, lambda (forgetting factor), input wav file, number of iterations.
% Outputs: Input signal, error estimation signal (echo cancelled), desired signal (echoed
signal), adaptive filter output, real impulse response
% Estimation of impulse response, cost, mean sqaure error, attenuation (dB),
average attenuation.
% Read in input file.
input_signal = wavread(input_file);
% Generate desired signal by creating impulse and convolving
impulse=zeros(filter_size,1);
for (i=1:5)
impulse(((i-1)*filter_size/5)+1)=1/i;
end
desired_signal = conv(input_signal, impulse);
% Initialise varaibles
filter_prev = zeros(filter_size,1);
input_vector = zeros(filter_size, 1);
psi_inv_prev = eye(filter_size);
intermediate= zeros(filter_size, 1);
gain = zeros(filter_size, 1);
% Perform RLS algorithm for set number of iterations.
for i=1:iterations
i
input_vector(1)=input_signal(i);
intermediate = psi_inv_prev*input_vector;
gain = (1/(lambda+dot(input_vector, intermediate)))*intermediate;
filter_output(i)=dot(filter_prev, input_vector);
error= desired_signal(i)-filter_output(i)
filter_prev = filter_prev + gain*error;
psi_inv_prev = (1/lambda)*(psi_inv_prev - gain*((input_vector)*psi_inv_prev));
% Shift along input vector
for j=filter_size:-1:2
input_vector(j)=input_vector(j-1);
end
error_signal(i)=error;
cost(i)=error*error;

end
% Find moving average of error squared.
for i=1:iterations-100
mse(i)=mean(cost(i:i+100));
i
end
%find moving average of db attenuation (averaged to smooth output).
for i=1:iterations-2500
db(i)=20*log10(mean(abs(desired_signal(i:i+2500)))./mean(abs(error_signal(i:i+2500))));
i
end
%find total average db attenuation
db_avg=mean(db);

B.1 nlms_adfilt.c
// nlms_adfilt.c
// Real time implementation of NLMS algorithm for echo cancellation system.
// Uses TI TMS320C6711 DSK.
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
// Defines
#define FILTER_LENGTH 2300
#define ECHO_DELAY 600
#define STEP_SIZE 5e-5
#define SCALE 5000.0
#define GAIN 15
// Declare variables
float input, echoed, af_output, error_signal;
float input_vector[FILTER_LENGTH];
float filter[FILTER_LENGTH];
float echo_buffer[ECHO_DELAY];
float step_size = STEP_SIZE; // fixed step size for standard LMS implementation
float nstep_size;
short output;
short output_type=1;
short delay_param=0;
short i, j, eb_index;
// Procedure for determining dot product of two arrays
float dotp (float a[], float b[])// based on Chassaing 2002, p. 242
{
float suml, sumh;
int j;
suml=0;
sumh=0;
for(j=0; j<FILTER_LENGTH; j+=2)
{

suml += a[j] * b[j];

sumh += a[j+1]*b[j+1];
}
return (suml+sumh);
}
// This interrupt is triggered at every sample instant
interrupt void c_int11()
{
input=(float)(input_sample())/SCALE; // newest input cast to float
input_vector[0] = input; // put sample
//Firsly calculate echoed output. Using delay-buffer method.
echoed = input+0.4*echo_buffer[eb_index];
echo_buffer[eb_index]=echoed;
eb_index++;
if (eb_index >= ECHO_DELAY-delay_param)
eb_index=0;
//calculate output of adaptive filter
af_output=dotp(filter, input_vector);
// calculate error value
error_signal = echoed-af_output;
// calculate variable step size
nstep_size=1/dotp(input_vector, input_vector);
//update tap weights
for (i=FILTER_LENGTH-1; i>0; i--)
{
filter[i] = filter[i] + 2*nstep_size*error_signal*input_vector[i]; //calculate
taps
input_vector[i]=input_vector[i-1]; //shift vector
}
// Switch for controlling the output type using lms.gel
if (output_type==1)
output=(short)(input*SCALE*GAIN);
if (output_type==2)
output=(short)(echoed*SCALE*GAIN);
if (output_type==3)
output=(short)(af_output*SCALE*GAIN);
if (output_type==4)
output=(short)(error_signal*SCALE*GAIN);
//output the sample
output_sample(output);
}
// This is main procedure executed on start up of program
main()
{
// Initialise variables
error_signal=0.0;
echoed=0.0;
af_output=0.0;
eb_index=0;
nstep_size=0;

for (i=0; i<FILTER_LENGTH-1; i++) // initialise filter, input vector

{
filter[i]=0.0;
input_vector[i]=0.0;
}
for (i=0; i<ECHO_DELAY; i++) // init echo buffer
{
echo_buffer[i]=0.0;
}
comm_intr(); //init DSK, codec, McBSP
while(1); //infinite loop
}
GEL file for nlms control
menuitem "LMS"
// create slider for output selection
slider LMS_output(1,4,1,1,lms_output_type)
{
output_type=lms_output_type;
}
// create slider to vary echo length
slider echo_length(0, 300, 50, 50, delays)
{
delay_param=delays;
}