Experiments for Chapter 8

Download Chapter 8 experimental software programs

Adaptive Filter Implementation

There are 2 experiments in this chapter:

1. Experiment 8A - System Identification Using Adaptive Filter

2. Experiment 8B - Self-tuned Leaky LMS Adaptive System

We will conduct two experiments for Chapter 8 applying the adaptive algorithms. The first experiment uses LMS algorithm for an application of system identification. The unknown system can be any types of plants. Here we use an FIR filter (the lowpass filter from Chapter 5) as the unknown system. We will show you how the adaptive filter adjusts its weights to match the unknown system. The second experiment is an application of adaptive linear predictor. It can be used to separate the narrow band signal from wide band signal. It can also be used to remove a narrow band signal from the wide band signal as a notch filer. The linker command file exp8.cmd for both experiments is given in Table E8-1.

Table 8-1 Linker command file for experiments in this chapter.

/* SPECIFY THE SYSTEM MEMORY MAP */ MEMORY { RAM (RWIX) : origin = 0100h, length = 01feffh /* Data Memory */ RAM2 (RWIX) : origin = 040100h, length = 040000h /* Program Memory */ ROM (RIX) : origin = 020100h, length = 020000h /* Program Memory */ VECS (RIX) : origin = 0ffff00h length = 00100h /* Reset Vector */ } /* SPECIFY THE SECTIONS ALLOCATION INTO MEMORY */ SECTIONS { vectors > VECS /* Interrupt vector table */ .text > ROM /* CODE */ lms_code > ROM /* CODE */ fir_code > ROM /* CODE */ .switch > RAM /* SWITCH TABLE INFO */ .const > RAM /* CONSTANT DATA */ .cinit > RAM2 /* INITIALIZATION TABLES */ .data > RAM /* INITIALIZED DATA */ lms_coef > RAM /* INITIALIZED DATA */ lms_data > RAM /* INITIALIZED DATA */ .bss > RAM /* GLOBAL & STATIC VARS */ lms_err > RAM aligh 4 /* GLOBAL & STATIC VARS */ lms_out > RAM align 4 /* GLOBAL & STATIC VARS */ lms_in > RAM align 4 /* GLOBAL & STATIC VARS */ .stack > RAM /* PRIMARY SYSTEM STACK */ }

Experiment 8A - System Identification Using Adaptive Filter

System identification is an application using adaptive filters. Figure E8-1 shows the block diagram of the system identification system using LMS algorithm.

Figure E8-1 Block diagram of an LMS adaptive system identification

Our experiment uses an lowpass filter as the unknown system. This lowpass filter is identical to the one used in Chapter 5. It is defined by the filter coefficients LP_coef.dat and implemented in C55x assembly language, fir_filt.asm.

The LMS adaptive filter adaptive.asm is implemented in the C55x assembly language. It consists of two blocks, a block FIR filter and the LMS adaptation algorithm, see Table E8-2.

Table E8-2 List of adaptive.asm

; ; adaptive.asm - Adaptive filter for system identification ; ; Prototype: unsigned int adaptive(int *in, int *d, int *x, int *w, ; unsigned int Ns, unsigned int N, unsigned int index) ; ; Entry: in[] - input signals ; d[] - reference signal ; x[] - adaptive filter delay-line buffer ; w[] - adaptive filter coefficient array ; Ns - number of samples per block ; N - order of the adaptive filter ; index - index to x[] ; ; Return: T0 = Adaptive filter delay-line buffer index ; TWOMU .set 0x1000 ; 2*MU .def _adaptive .sect "lms_code" _adaptive: pshm ST1_55 ; Save ST1, ST2, and ST3 pshm ST2_55 pshm ST3_55 mov mmap(AR3),BSA45 mov mmap(T1),BK47 mov mmap(AR2),BSA23 mov mmap(T1),BK03 mov AR4,AR3 ; AR3 -> x[] as circular buffer mov #0,AR4 ; AR4 -> w[] as circular buffer or #0x340,mmap(ST1_55); Set FRCT,SXMD,SATD or #0x18,mmap(ST2_55) ; Enable circular addressing mode bset SATA ; Set SATA sub #1,T0 mov mmap(T0),BRC0 ; Set Sample block loop counter sub #2,T1 mov mmap(T1),BRC1 ; Counter for LMS update loop mov mmap(T1),CSR ; Counter for FIR filter loop rptblocal loop-1 ; for (n=0; n<Ns; n++) mov *AR0+,*AR3 ; x[n]=in[n] mpym *AR3+,*AR4+,AC0 ; temp = w[0]*d[0] || rpt CSR ; for (i=0; i<N-1; i++) macm *AR3+,*AR4+,AC0 ; y += w[i]*x[i] sub *AR1+ <<#16,AC0 ; AC0=-e=y-d[n], AR1 points to d[n] mpyk #-TWOMU,AC0 mov rnd(hi(AC0)),mmap(T1); T1=2*mu*e[n] rptblocal lms_loop-1 ; for(j=0; i<N-2; i++) mpym *AR3+,T1,AC0 ; AC0=2*mu*e*x[i] add *AR4<<#16,AC0 ; w[i]+=2*mu*e*x[i] mov rnd(hi(AC0)),*AR4+ lms_loop mpym *AR3,T1,AC0 ; w[N-1]+=2*mu*e*x[N-1] add *AR4<<#16,AC0 mov rnd(hi(AC0)),*AR4+ ; Store the last w[N-1] loop popm ST3_55 ; Restore ST1, ST2, and ST2 popm ST2_55 popm ST1_55 mov AR3,T0 ; Return T0=index || ret .end

Table E8-3 sows the exciting signal source used for the experiment is a random number generator random.c. The input signal is fed into the unknown system and the adaptive filter at the same time. The output of the unknown system is used as the desired signal for the adaptive filter.

Table E8-3 Random number generator

/* random.c - Zero-mean random noise */ #define USE_DATA 0 #if USE_DATA /* Use random data file as input */ #pragma CODE_SECTION(random, "lms_code"); #pragma DATA_SECTION(randdata, "lms_data"); #pragma DATA_SECTION(i, "lms_cinit"); #include "randdata.dat" static unsigned int i=0; void random(int *x, unsigned int N) { unsigned int t; for (t=N; t>0; t--) { *x++ = randdata[i]; i++; if (i == 10000) i=0; } } #else /* Use random function for input */ #include <math.h> #pragma CODE_SECTION(random, "lms_code"); void random(int *x, unsigned int N) { unsigned int t; for (t=N; t>0; t--) *x++ = rand(0x1955)-0x4000; } #endif

After the adaptive system reaches its steady-state, the adaptive filter coefficients w[] can be used to approximate the impulse response of the unknown system. The experiment is controlled by the C function exp8a.c, listed in Table E8-4.

Table E8-4 List of exp8.c

/* exp8a.c - Experiment 8A System identification using LMS adaptive filter */ #include "LP_coef.dat" #define N0 48 /* Adaptive filter order */ #define N1 48 /* Unknown filter order */ #define Ns 128 /* Number of input signal */ #pragma CODE_SECTION(main, "lms_code"); #pragma DATA_SECTION(fir_index, "lms_data"); #pragma DATA_SECTION(sys_index, "lms_data"); #pragma DATA_SECTION(w, "lms_coef"); #pragma DATA_SECTION(d_sys, "lms_data"); #pragma DATA_SECTION(d_fir, "lms_data"); #pragma DATA_SECTION(in, "lms_in"); #pragma DATA_SECTION(d, "lms_out"); extern unsigned int fir_filt(int *, unsigned int, int *, unsigned int, int *, int *, unsigned int); extern unsigned int adaptive(int *, int *, int *, int *, unsigned int, unsigned int, unsigned int); extern void init(int *, unsigned int); extern void random(int *, unsigned int); int w[N0], /* Adaptive filter coefficients */ d_sys[N0], /* Adaptive filter delayed sample buffer */ d_fir[N1], /* Unknown system delayed sample buffer */ in[Ns], /* Input sample buffer */ d[Ns]; /* Unknown system output buffer */ unsigned int fir_index,sys_index; void main() { init(w,N0); /* Initialize adaptive filter coefficients */ init(d_sys,N0); /* Initialize adaptive filter delay-line */ init(d_fir,N1); /* Initialize unknown filter delay-line */ fir_index=0; /* Init the unknown filter delay-line index */ sys_index=0; /* Init the adaptive filter delay-line index */ for (;;) /* Generate samples to both filter and */ { /* identify unknown system */ random(in,Ns); fir_index=fir_filt(in,Ns,LP_coef,N1,d,d_fir,fir_index); sys_index=adaptive(in,d,d_sys,w,Ns,N0,sys_index); } }

The initialization of the coefficients array and filter delayline is done using the C function init.c, as shown in Figure E8-5.

Table E8-5 List of init.c

For Experiment 8A, complete these steps:

1. This experiment uses the following files: exp8.cmd, expt8a.c, init.c, random.c, adaptive.asm, fir_flt.asm, LP_coef.dat, and randdata.dat, where the assembly routine fir_flt.asm and its coefficients LP_coef.dat are identical of those used for the experiment in Chapter 5.

2. Create the project epx8a, to include exp8.cmd, expt8a.c, init.c, random.c, adaptive.asm, and fir_flt.asm. Build, debug, and run the experiment using the CCS.

3. Configure the CCS, and set animation option for viewing the coefficients of the adaptive filter w[], the unknown the system LP_coef[] in both time domain and frequency domain.

4. Verify the adaptation process by viewing how the adaptive coefficients are adjusted. Record the steady-state value of w[], and plot the frequency responses of the adaptive filter and the unknown system. Save the adaptive filter coefficients, and compare them with the unknown system coefficients given in the file LP_coef.dat.

5. Adjust adaptation step size, and repeat the system identification process. Observe how does the system performance change.

6. Increase the number of the adaptive filter coefficients to N0=64, and observe system performance.

7. Reduce the number of the adaptive filter coefficients to N0=32, and observe system performance.

The experiment result is plotted in Figure E8-2.

Figure E8-2 System identification experiment results

Experiment 8B - Self-tuned Leaky LMS Adaptive System

Figure E8-3 shows the block diagram of an adaptive linear predictor using the leaky LMS algorithm. As shown in Figure E8-3, the input to the system contains a wide band signal s(n)and a narrow band signal v(n). The system has two outputs, the wide band output e(n) and the narrow band output y(n).

Figure E8-3 Block diagram of an adaptive linear predictor

The signal source is generated by the function signal.c, listed in Table E8-6.

Table E8-6 List of function singal.c

/* signal.c - Sinewave plus additive zero-mean random noise */ #define USE_DATA 1 #if USE_DATA /* Use noise data file */ #pragma CODE_SECTION(cos_rand, "lms_code"); #pragma DATA_SECTION(noise, "lms_data"); #pragma DATA_SECTION(i, "lms_data"); #include "noise.dat" static unsigned int i=0; void cos_rand(int *x, unsigned int Ns) { unsigned int t; for (t=Ns; t>0; t--) { *x++ = noise[i]; i++; if (i == 10000) i = 0; } } #else /* Generate noise samples */ #include <math.h> #include <intrindefs.h> #pragma CODE_SECTION(cos_rand, "lms_code"); #pragma DATA_SECTION(i, "lms_data"); #define PI 3.1415962 #define K (Ns>>6) #define a1 0x4000 #define a2 0x4000 static unsigned int i=0; void cos_rand(int *x, unsigned int Ns) { unsigned int t; float two_pi_K_Ns; int temp; long ltemp; two_pi_K_Ns=2.0*PI*K/Ns; for (t=Ns; t>0; t--) { temp = (int)(0x7fff*cos(two_pi_K_Ns*i)); ltemp = _lsmpy(a1,temp); temp = rand(0x228)-0x4000; *x++ = _smac(ltemp,a2,temp)>>16; i++; i%=(Ns>>1); } } #endif

The experiment is managed by function exp8b.c, see Table E8-7. Because of using the white noise, the delay is chosen to be 1. The same initialization function init.c is used to initialize the adaptive filter.

Table E8-7 List of exp8b.c

/* exp8b.c - Experiment 8B - Adaptive noise canceller */ #define N 48 /* Adaptive FIR filter order */ #define Ns 256 /* Number of input signal per block */ #pragma DATA_SECTION(e, "lms_err"); #pragma DATA_SECTION(y, "lms_out"); #pragma DATA_SECTION(x, "lms_in"); #pragma DATA_SECTION(d, "lms_data"); #pragma DATA_SECTION(w, "lms_coef"); #pragma DATA_SECTION(index, "lms_data"); #pragma CODE_SECTION(main, "lms_code"); int e[Ns], /* Error signal buffer */ y[Ns], /* Ouptut signal buffer */ in[Ns], /* Input signal buffer */ w[N], /* Adaptive filter coefficients */ x[N], /* Filter delayline buffer */ index; extern void init(int *, unsigned int); extern unsigned int alp(int *, int *, int *, int *, int *, unsigned int, unsigned int, unsigned int); extern void cos_rand(int *, unsigned int); void main(void) { init(x,N); /* Initialize d[] to zero */ init(w,N); /* Initialize w[] to zero */ index=0; for (;;) { cos_rand(in,Ns); /* Generate samples */ index=alp(in,y,e,x,w,Ns,N,index); /* Adaptive system */ } }

The experiment result is plotted and shown in Figure E8-4. The input is a wide band (white noise) and a periodic signal (sinewave). The adaptive filter separates the narrow band signal from the wide band signal.

Figure E8-4. Adaptive linear predictor experiment result

The adaptive linear predictor alp.asm is listed in Table E8-8. We choose the leaky factor to be 0.998 and the step size 2u=96/32768.

Table E8-8 Adaptive linear predictor.

; ; alp.asm - Self-tuned Adaptive linear predictor (Leaky LMS) ; ; Prototype: unsigned int anc_lms(int *in, int *y, int *e, int *d, int *w, ; unsigned int Ns, unsigned int N, unsigned int index) ; ; Entry: in[]- input buffer contains wide & narrow band signals ; y[] - output of the filter narrow band signal ; e[] - output of the filter wide band signal ; d[] - adaptive filter delay-line buffer ; w[] - adaptive filter coefficient buffer ; Ns - number of samples per block ; N - order of the adaptive filter ; index - index to d[] ; ; Return: T0 = Adaptive filter delay-line buffer index ; TWOMU .set 0x70 ; 2*MU ALPHA .set 0x7ff0 ; Leaky factor ; ; Declare local variables in SP address mode for C-callable ; ARGS .set 1 ; Number of variables passed via stack ANC_var .struct ; Define local variable structure d_ST1 .int ; Used to save content of ST1 d_ST2 .int ; Used to save content of ST2 d_ST3 .int ; Used to save content of ST3 return_addr .int ; Return address d_index .int ; Function argument passed via stack Size .endstruct anc .set 0 anc .tag ANC_var .def _alp .sect "lms_code" _alp aadd #(ARGS-Size+1),SP ; Adjust SP for local vars mov mmap(AR4),BSA45 ; Configure for circular buffers mov mmap(T1),BK47 mov mmap(AR3),BSA23 mov mmap(T1),BK03 mov anc.d_index,AR3 ; AR3 -> x[] as circular buffer mov #0,AR4 ; AR4 -> w[] as circular buffer mov mmap(ST1_55),AC0 ; Save ST1, ST2, and ST3 mov AC0,anc.d_ST1 mov mmap(ST2_55),AC0 mov AC0,anc.d_ST2 mov mmap(ST3_55),AC0 mov AC0,anc.d_ST3 or #0x340,mmap(ST1_55); Set FRCT,SXMD,SATD or #0x18,mmap(ST2_55) ; Enable circular addressing mode bset SATA ; Set SATA sub #1,T0 mov mmap(T0),BRC0 ; Set Sample block loop counter sub #2,T1 mov mmap(T1),BRC1 ; Counter for LMS update loop mov mmap(T1),CSR ; Counter for FIR filter loop mov #ALPHA,T0 ; T0=leaky alpha || rptblocal loop-1 ; for (n=0; n<Ns; n++) mpym *AR3+,*AR4+,AC0 ; temp = w[0]*x[0] || rpt CSR ; for (i=0; i<N-1; i++) macm *AR3+,*AR4+,AC0 ; temp = w[i]*x[i] mov rnd(hi(AC0)),*AR1 ; y[t] = temp; sub *AR0,*AR1+,AC0 mov rnd(hi(AC0)),*AR2+ ; e[n]=in[n]-y[n] || mpyk #TWOMU,AC0 mov rnd(hi(AC0)),mmap(T1); T1=2*mu*e[n] mpym *AR4,T0,AC0 || rptblocal lms_loop-1 ; for(j=0; i<N-2; i++) macm *AR3+,T1,AC0 ; w[i]=alpha*w[i]+2*mu*e*x[i] mov rnd(hi(AC0)),*AR4+ mpym *AR4,T0,AC0 lms_loop macm *AR3,T1,AC0 ; w[N-1]=alpha*w[N-1]+2*mu*e[n]*x[N-1] mov rnd(hi(AC0)),*AR4+ ; Store the last w[i] mov *AR0+,*AR3 ; x[n]=in[n] loop mov anc.d_ST1,AR4 ; Restore ST1, ST2, and ST3 mov ar4,mmap(ST1_55) mov anc.d_ST2,AR4 mov ar4,mmap(ST2_55) mov anc.d_ST3,AR4 mov AR4,mmap(ST3_55) aadd #(Size-ARGS-1),SP ; Reset SP mov AR3,T0 ; Retrun T0=index || ret .end

For Experiment 8B, go through the following steps:

1. Create the project epx8b to include exp8.cmd, expt8b.c, init.c, alp.asm, and singal.c. These files can be found from the experiment software package.

2. Build, debug, and run the experiment using the CCS.

3. Configure the CCS, and set animation option for viewing the output of the adaptive filter y[], the output of the system e[], the input of the signal, in[], and the adaptive filter coefficients w[] at a block by block basis.

4. Verify the adaptive linear predictor, and compare the result with Figure E8-4.

5. Verify the adaptation process by viewing how the adaptive coefficients are adjusted. Record the steady-state value of w[], and plot the frequency response of the adaptive filter.

6. Change the order of the adaptive filter, and observe system performance.

7. Adjust adaptation step size, and observe system performance.

8. Change the leaky factor, and observe system performance.

9. Can you obtain a similar result without using leaky LMS (by setting leaky factor to 0x7fff)? Find the steady-state adaptive filter coefficients w[] by running the adaptive system for a period of time, and compare the frequency response with the one obtained in step 5.

10. Select the best step size and leaky factor that will minimize order of the adaptive filter.