Experiments for Chapter 6

Download Chapter 6 experimental software programs

From C to Assembly language - IIR Filter Design Examples

There are 5 experiments in this chapter:

1. Experiment 6A - IIR Filter Implementation Using Floating-point C

2. Experiment 6B - Fixed-point C Implementation Using Intrinsics

3. Experiment 6C - Fixed-point C Programming Consideration

4. Experiment 6D - IIR Filter Assembly Language Implementation

There are many paths you can take to realize algorithms to applications. Figure E6-1 shows a commonly used software development flow. In early day s, DSP development is heavily concentrated in stage 3 while stage 1 and 2 are skipped. With the C compiler improving rapidly in recent years, C compilers have been widely used in stage 1 and 2 of the design flow. Aided by compiler optimization and special features like intrinsics, and DSP processor speed, more and more real-time DSP applications are implemented using mixed C and assembly code. In the first experiment, we will use floating-point C code to implement an IIR filter as stage 1 of Figure E6-1. Developing code in stage 1 does not require knowledge of the DSP processors. The second and third experiments are emphasis the use of C compiler optimization, data types, and intrinsics, as show in stage 2. The fourth experiment is done by the assembly c ode. The stage 3 requires most of the time because assembly programming is more difficult than C language programming. In general, assembly code is proven to be the most efficient in digital signal processing algorithms, like filters involving multiplication and accumulation operations, while C code can do well in data manipulation, like data formatting and arrangement. Finally, we show a special IIR filter application - resonator in the last experiment.

Figure E6-1 DSP software development flow chart.

Table E6-1 The software signal generator for Experiment 6A, 6B, 6C and 6D.

/* signal_gen2 - generate two sinewaves of f1 and f2 */ #include <intrindefs.h> #define DELTA 0x7fa0 /* Delat - excite signal */ #define UNIT 0x7fff #define THIRD 0x2aaa /* 1/3 */ #define PI 3.1415926 #define N 1024 /* Max number of samples per block */ /* Fs = 8000 Sampling frequency */ /* f1 = 800, f2 = 1800, f3 = 3300 */ #define A1 0x678d /* UNIT*cos(2*PI*f1/Fs) */ #define A2 0x1405 /* UNIT*cos(2*PI*f2/Fs) */ #define A3 0x92de /* UNIT*cos(2*PI*f3/Fs) */ #define D1 0x4b04 /* DELTA*sin(2*PI*f1/Fs) */ #define D2 0x7e0e /* DELTA*sin(2*PI*f2/Fs) */ #define D3 0x42af /* DELTA*sin(2*PI*f3/Fs) */ static int w1[2]={(int)D1,0}; /* Determine the excite signal 1 */ static int w2[2]={(int)D2,0}; /* Determine the excite signal 2 */ static int w3[2]={(int)D3,0}; /* Determine the excite signal 3 */ static int cos_w1=(int)A1; /* Determine the coefficient 1 */ static int cos_w2=(int)A2; /* Determine the coefficient 2 */ static int cos_w3=(int)A3; /* Determine the coefficient 3 */ int x1[N],x2[N],x3[N]; extern void sine(int *, int *, unsigned int, int); void signal_gen2(int *x, unsigned int M) { unsigned int i; sine(x1,w1,M,cos_w1); /* x1=A1*sin(2*PI*n*f1/Fs) */ sine(x2,w2,M,cos_w2); /* x2=A2*sin(2*PI*n*f2/Fs) */ sine(x3,w3,M,cos_w3); /* x3=A3*sin(2*PI*n*f3/Fs) */ for (i=0; i<M; i++) { x[i] = _smpy(x1[i],THIRD); x[i] = _sadd(x[i], _smpy(x2[i],THIRD)); x[i] = _sadd(x[i], _smpy(x3[i],THIRD)); } }

Table E6-1 shows the software signal generator signal_gen2.c for the experiments in this section. It is written using fixed-point C . The assembly routine sine.asm used by the signal_gen2() is given in Table E6-2. The command file exp6.cmd is given in Table E6-3.

Table E6-2 The IIR second-order resonator.

; ; sine.asm - 2nd-order resonator as sinewave generator ; ; It works better in the range of f/Fs=[0.125-0.975] ; Initialization condition: ; A = cos(2*PI*f/Fs) ; w[0] = sin(2*PI*f/Fs) ; w[1] = 0 ; ; prototype: void sinewave_gen(int *x, unsigned int N, int *x, int cos_w) ; ; Entry: x[i] - AR0: output sinewave sample buffer ; wd[i] - AR1: delay-line ; N - T0: number of samples ; cos_w - T1: coefficient controls sinewave frequency ; ; .def _sine .text _sine pshm ST1_55 ; Save ST1, ST2, and ST3 pshm ST2_55 pshm ST3_55 sub #1,T0 mov mmap(T0),BRC0 bset FRCT bset SATD bset SMUL mpym *AR1+,T1,AC0 ; AC0=cos(w)*w[0] || rptb sine_loop-1 ; for(i=0;i<N;i++) sub *AR1-<<#16,AC0,AC1 ; AC1=cos(w)*w[0]-w[1] add AC0,AC1 ; AC1=2*cos(w)*w[0]-w[1] || delay *AR1 ; w[1]=w[0] mov rnd(hi(AC1)),*AR1 ; w[0]=y[i] mov rnd(hi(AC1)),*AR0+ ; y[i]=2*cos(w)*w[0]-w[1] || mpym *AR1+,T1,AC0 ; AC0=cos(w)*w[0] sine_loop popm ST3_55 ; Restore ST1, ST2, and ST3 popm ST2_55 popm ST1_55 ret .end

Table E6-3 The linker command file.

/* Linker command file for Experiment 6 (C55x memory map) */ MEMORY { SPRAM : origin = 00000c0h, length = 0000040 DARAM0 : origin = 0000100h, length = 0003F00h DARAM1 : origin = 0004000h, length = 0004000h DARAM2 : origin = 0008000h, length = 0004000h DARAM3 : origin = 000c000h, length = 0004000h SARAM0 : origin = 0010000h, length = 0004000h SARAM1 : origin = 0014000h, length = 0004000h SARAM2 : origin = 0018000h, length = 0004000h SARAM3 : origin = 001c000h, length = 0004000h SARAM4 : origin = 0020000h, length = 0004000h SARAM5 : origin = 0024000h, length = 0004000h SARAM6 : origin = 0028000h, length = 0004000h SARAM7 : origin = 002c000h, length = 0004000h SARAM8 : origin = 0030000h, length = 0004000h SARAM9 : origin = 0034000h, length = 0004000h SARAM10 : origin = 0038000h, length = 0004000h SARAM11 : origin = 003c000h, length = 0004000h SARAM12 : origin = 0040000h, length = 0004000h SARAM13 : origin = 0044000h, length = 0004000h SARAM14 : origin = 0048000h, length = 0004000h SARAM15 : origin = 004c000h, length = 0004000h VECS : origin = 0ffff00h, length = 00100h /* reset vector */ } SECTIONS { vectors : {} > VECS /* interrupt vector table */ .cinit : {} > SARAM0 .text : {} > SARAM1 .stack : {} > DARAM0 .sysstack: {} > DARAM0 .sysmem : {} > DARAM1 .data : {} > DARAM1 .bss : {} > DARAM1 .const : {} > DARAM1 iir_coef : {} > SARAM0 /* user defined sections */ iir_data : {} > DARAM2 input : {} > SARAM0 output : {} > SARAM0 /* word boundary alignment */ iir_code : {} > SARAM1 isrs : {} > SARAM2 }

Experiment 6A - IIR Filter Implementation Using Floating-point C

This experiment demonstrates the first stage of the design flow of a lowpass IIR filter using TMS320C55x. The main C function exp6a.c in Table E6-4 and software signal generator listed in Table E6-1 and Table E6-2 are used to aid the experiment. Table E6-5 gives the IIR Filter iir.c.

Table E6-4 The list of C function for Experiment 6A.

/* exp6a.c - Direct form II - IIR function implementation in floating-point C and using signal generator */ #define M 128 /* Number of samples per block */ #define Ns 2 /* Number od 2nd order sections */ /* Low-pass IIR filter coefficients */ float C[Ns*5]={ /* i=section number */ /* A[i][1],A[i][2],B[i][2],B[i][0],B[i][1] */ -0.8659, 0.2139, 0.0992, 0.0992, 0.1984, -1.1249, 0.5770, 0.0992, 0.0992, 0.1984}; /* IIR filter delay line: w[]=w[i][n-1],w[i+1][n-1],...,w[i][n-2],w[i+1][n-2],... */ float w[Ns*2]; int out[M]; int in[M]; /* IIR filter function */ extern void iir(int*, int, int *, float *, int, float *); /* Software signal generator */ extern void signal_gen2(int *, unsigned int); void main(void) { int i; /* Initialize IIR filter delay line */ for (i=0; i<Ns*2;i++) w[i]=0; /* IIR filter experiment start */ for (;;) { signal_gen2(in,M); /* Generate a block of samples */ iir(in,M,out,C,Ns,w); /* Filter a block of samples */ } }

Table E6-5 The floating-point C IIR filter routine.

/* iir.c - IIR direct form II biquads implementation prototype: void iir(int *, int, int *, float *, int, float *); Entry: arg0: pointer to the input sample buffer arg1: size of the input sample buffer arg2: pointer to the output sample buffer arg3: pointer to the coefficients array arg4: number of second-order IIR sections arg5: pointer to the filter delay-line buffer Return: None */ #define CHECK_OVERFLOW 1 #if CHECK_OVERFLOW static float w_max=-1.,w_min=1.; #endif void iir(int *x, int Nx, int *y, float *coef, int Ns, float *w) { int i,j,n,m,k,l,p; float temp, w_0; m=Ns*5; /* Setup for circular buffer coef[] */ k=Ns*2; /* Setup for circular buffer d[] */ for (j=0,l=0,n=0; n<Nx; n++) /* IIR filter */ { w_0 = (float)(x[n]/32767.0); /* Q15 to float */ for (i=0; i<Ns; i++) { w_0 -= *(w+l) * *(coef+j); j++; l=(l+Ns)%k; w_0 -= *(w+l) * *(coef+j); j++; temp = *(w+l); *(w+l) = w_0; #if CHECK_OVERFLOW for (p=0;p<k;p++) { if (w_max <= w_0) w_max = w_0; if (w_min > w_0) w_min = w_0; } #endif w_0 = temp * *(coef+j); j++; w_0 += *(w+l) * *(coef+j); j++; l=(l+Ns)%k; w_0 += *(w+l) * *(coef+j); j=(j+1)%m; l=(l+1)%k; #if CHECK_OVERFLOW for (p=0;p<k;p++) { if (w_max <= w_0) w_max = w_0; if (w_min > w_0) w_min = w_0; } #endif } y[n] = (int)(w_0*32767); /* Q15 format output */ } }

To conduct Experiment 6A, following these steps:

1. Create the project, exp6a and include the linker command file exp6.cmd, the C function exp6a.c, iir.c, signal_gen2.c, and the assembly routine sine.asm. The lowpass filter iir() will remove high frequency components from the input signal generated by the signal generator signal_gen2() which uses the resonator sinewave function sine() to generate three sinewaves in 800Hz, 1.8kHz, and 3.3 kHz.

2. Use rts55.lib for the C function main()initialization and build the project exp6a.

3. Enable break point at the statement for(;;)of the main() function and use CCS graphic function to view the 16-bit integer output samples in the buffer out[], set data length to 128 for viewing one block data a time. Animate the filtering process and observe the filter output as a clean sine wave of 800 Hz.

4. Profile IIR filter iir() performance and record the memory space usage.

5. Check the IIR filter function for possible overflow. Use CCS watch window to view w_max and w_min in animation.

Figure E6-1 and Figure E6-2 show the plots of the first block of input and output samples of Experiment 6A in frequency and time domain.

Figure E6-1 Input of the filter in frequency and time domain.

Figure E6-2 Output of the filter in frequency and time domain.

Experiment 6B - Fixed-point C Implementation Using Intrinsics

Experiment 6B introduces the C intrinsics for TMS320C55x programming in C. Using C intrinsics is an efficient way to prototype the DSP applications. In some cases, it may provide the performance efficient enough for use. The programs using intrinsics can be used as a design reference for bit-exactness verification between C and assembly languages. The use of intrinsics is similar to a C function call. The specific computation is carried out as assembly instructions and inserted to the code directly. The C function exp6b.c for Experiment 6B is listed in Table E6-6 for reference. The IIR filter C function that uses intrinsics iir_i1.c, which uses intrinsics is given in Table E6-7.

Table E6-6 List of C function for Experiment 6B.

/* exp6b.c - Direct form II - IIR function implementation in Fixed-point C and using signal generator */ #define M 128 /* Number of samples per block */ #define Ns 2 /* Number od 2nd order sections */ /* Low-pass IIR filter coefficients in Q14 format */ int C[Ns*5]={ /* i=section number */ /* A[i][1],A[i][2],B[i][2],B[i][0],B[i][1] */ -14187, 3505, 1624, 1624, 3249, -18430, 9454, 1624, 1624, 3249}; /* IIR filter delay line: w[]=w[i][n-1],w[i+1][n-1],...,w[i][n-2],w[i+1][n-2],... */ int w[Ns*2]; int out[M]; int in[M]; /* IIR filter function */ extern void iir(int*, int, int *, int *, int, int *); /* Software signal generator */ extern void signal_gen2(int *, unsigned int); void main(void) { int i; /* Initialize IIR filter delay line and signal generator */ for (i=0; i<Ns*2; i++) w[i]=0; /* IIR filter experiment start */ for (;;) { signal_gen2(in,M); /* Generate a buffer of samples */ iir(in,M,out,C,Ns,w); /* Filter a buffer of samples */ } }

Table E6-7 IIR filter using C intrinsics.

/* iir_i1.c - IIR direct form II biquads filter in Fixed-point implementation */ #include <intrindefs.h> #define SCALE 1 void iir(int *x, int Nx, int *y, int *coef, int Ns, int *w) { int i,j,n,m,k,l; int temp; long w_0; m=Ns*5; /* Setup for circular buffer coef[] */ k=Ns*2; /* Setup for circular buffer d[] */ for (j=0,l=0,n=0; n<Nx; n++) /* IIR filter */ { w_0 = (long)x[n]<<(15-SCALE); /* Q14 input (scaled) */ for (i=0; i<Ns; i++) { w_0 = _smas(w_0,*(w+l),*(coef+j)); j++; l=(l+Ns)%k; w_0 = _smas(w_0,*(w+l),*(coef+j)); j++; temp = *(w+l); *(w+l) = w_0>>15; w_0 = _lsmpy( temp,*(coef+j)); j++; w_0 = _smac(w_0,*(w+l),*(coef+j)); j++; l=(l+Ns)%k; w_0 = _smac(w_0,*(w+l),*(coef+j)); j=(j+1)%m; l=(l+1)%k; } y[n] = w_0>>(15-SCALE); /* Q15 format output */ } }

To conduct Experiment 6B, following these steps:

1. Create the project, exp6b and include the linker command file exp6.cmd, the C function exp6b.c, iir_i1.c, signal_gen2.c, and the assembly routine sine.asm.

2. Use rts55.lib for the C function main()initialization and build the project exp6b.

4. Profile the IIR filter iir_i1() and compare the result with those obtained in Experiment 6A.

5. In file iir_i1() set the scale factor, SCALE, to 0 so the samples will not be scaled. Rebuild the project and run the IIR filter experiment in the ANIMATION mode. You will see the output waveform distortions caused by the intermediate overflow.

Experiment 6C - Fixed-point C Programming Implementation Consideration

Familiar with the assembly code generated by the TMS320C55x C compiler can help us to understand and write a better-structured C code for C compiler. Some basic considerations when programming in C are the use of build-in library functions, loop counters, loops and local -repeat loop, as well as compiler optimization options. Experiment 6C demonstrates how an IIR filter can be better written for the C compiler. Table E6-8 and Table E6-9 give the function exp6c.c and modified IIR function iir_i2.c, respectively.

Table E6-8 List of C function for Experiment 6C.

/* exp6c.c - Direct form II - IIR function implementation in Fixed-point C and using signal generator */ #define M 128 /* Number of samples per block */ #define Ns 2 /* Number od 2nd order sections */ #pragma DATA_SECTION(C, "iir_coef"); #pragma DATA_SECTION(w, "iir_data"); #pragma DATA_SECTION(out, "iir_out"); #pragma DATA_SECTION(in, "iir_in"); #pragma CODE_SECTION(main, "iir_code"); /* Low-pass IIR filter coefficients in Q14 format */ int C[Ns*5]={ /* i=section number */ /* A[i][1],A[i][2],B[i][2],B[i][0],B[i][1] */ -14187, 3505, 1624, 1624, 3249, -18430, 9454, 1624, 1624, 3249}; /* IIR filter delay line: w[]=w[i][n-1],w[i+1][n-1],...,w[i][n-2],w[i+1][n-2],... */ int w[Ns*2]; int out[M]; int in[M]; /* IIR filter function */ extern void iir(int*, unsigned int, int *, int *, unsigned int, int *); /* Software signal generator */ extern void signal_gen2(int *, unsigned int); void main(void) { unsigned int i; int *ptr=&w[0]; /* Initialize IIR filter delay line and signal generator */ for (i=Ns*2; i>0; i--) *ptr++ = 0; /* IIR filter */ for (;;) { signal_gen2(in,M); /* Generate a buffer of samples */ iir(in,M,out,C,Ns,w); /* Filter a buffer of samples */ } }

Table E6-9 Modified IIR filter function.

/* iir_i2.c - IIR direct form II biquads filter in Fixed-point implementation */ #include <intrindefs.h> #pragma CODE_SECTION(iir, "iir_code"); #define SCALE 1 void iir(int *x, unsigned int Nx, int *y, int *coef, unsigned int Ns, int *w) { unsigned int i,j,n,m,k,l; int temp; long w_0; m=Ns*5; /* Setup for circular buffer coef[] */ k=(Ns<<1)-1; /* Setup for circular buffer d[] */ for (j=0,l=0,n=Nx; n>0; n--) /* IIR filter */ { w_0 = (long)*x <<(15-SCALE); *x++; /* Q14 input (scaled) */ for (i=Ns; i>0; i--) { w_0 = _smas(w_0,*(w+l),*(coef+j)); j++; l=(l+Ns)&k; w_0 = _smas(w_0,*(w+l),*(coef+j)); j++; temp = *(w+l); *(w+l) = w_0>>15; w_0 = _lsmpy( temp,*(coef+j)); j++; w_0 = _smac(w_0,*(w+l),*(coef+j)); j++; l=(l+Ns)&k; w_0 = _smac(w_0,*(w+l),*(coef+j)); j=(j+1)%m; l=(l+1)&k; } *y++ = w_0>>(15-SCALE); /* Q15 format output */ } }

To conduct Experiment 6C, following these steps:

1. Create the project, exp6c and include the linker command file exp6.cmd, the C function exp6c.c, iir_i2.c, signal_gen2.c, and the assembly routine sine.asm. The C routine iir_i2.c uses unsigned integer for trip counters and replaced the MOD operation with AND operation for the delay-line buffer.

2. Use rts55.lib for the C function main()initialization and build the project exp6c.

3. Relocate the C program and data variables into different named SARAM and DARAM sections defined by the linker command files.

4. Enable –o3 and –mp options to rebuild the project.

5. Enable break point at the statement for(;;)of the main() function and use CCS graphic function to view the 16-bit integer output samples in the buffer out[], set data length to 128 for viewing one block data a time. Animate the filtering process and observe the filter output as a clean sine wave of 800 Hz.

6. Profile the IIR filter iir_i2() and compare the result with those obtained in Experiment 6B.

Experiment 6D - IIR Filter Assembly Language Implementation

The hand-coded assembly code for the TMS320C55x DSP processor will give us the best performance although it generally takes longer time to write and debug. We can write an efficient IIR filter assembly routine that uses only seven DSP cycles to compute each output. Table E6-10 and Table E6-11 give the function exp6d.c and modified IIR function iirform2.asm, respectively.

Table E6-10 List of C function for Experiment 6D.

/* exp6d.c - Direct form II - IIR function in TMS320C55x assembly */ #define M 128 /* Number of samples per block */ #define Ns 2 /* Number od 2nd order sections */ #pragma DATA_SECTION(C, "iir_coef"); #pragma DATA_SECTION(w, "iir_data"); #pragma DATA_SECTION(out, "iir_out"); #pragma DATA_SECTION(in, "iir_in"); #pragma CODE_SECTION(main, "iir_code"); /* exp6d.c - Direct form II - IIR function in TMS320C55x assembly */ #define M 128 /* Number of samples per block */ #define Ns 2 /* Number od 2nd order sections */ #pragma DATA_SECTION(C, "iir_coef"); #pragma DATA_SECTION(w, "iir_data"); #pragma DATA_SECTION(out, "iir_out"); #pragma DATA_SECTION(in, "iir_in"); #pragma CODE_SECTION(main, "iir_code"); /* Low-pass IIR filter coefficients in Q14 format */ int C[Ns*5]={ /* i=section number */ /* A[i][1],A[i][2],B[i][2],B[i][0],B[i][1] */ -14187, 3505, 1624, 1624, 3249, -18430, 9454, 1624, 1624, 3249}; /* IIR filter delay line: w[]=w[i][n-1],w[i+1][n-1],...,w[i][n-2],w[i+1][n-2],... */ int w[Ns*2]; int out[M]; int in[M]; /* IIR filter function */ extern void iirform2(int*, unsigned int, int *, int *, unsigned int , int *); /* Software signal generator */ extern void signal_gen2(int *, unsigned int, int); void main(void) { unsigned int i; int *ptr=&w[0]; /* Initialize IIR filter delay line and signal generator */ for (i=Ns*2; i>0; i--) *ptr++ = 0; signal_gen2(in,M,1); /* IIR filter experiment start */ for (;;) { signal_gen2(in,M,0); /* Generate a block of samples */ iirform2(in,M,out,C,Ns,w); /* Filter a block of samples */ } }

Table E6-11 Modified IIR filter function.

; ; iirform2.asm IIR direct form II (biquads) IIR filter ; ; Prototype: void iirform2(int *, unsigned int, int *, int *, unsigned int, int *); ; ; Entry: arg0: AR0-filter input sample buffer pointer ; arg1: T0-number of samples in input buffer ; arg2: AR2-output sample buffer pointer ; arg3: AR1-IIR coefficients array pointer ; arg4: T1-number of biquads IIR sections ; arg5: AR3-delayline pointer ; ; ; Direct form II - IIR filter (the ith sections): ; d(n) = x(n) - ai1*d(n-1)-ai2*d(n-2) ; y(n) = bi0*d(n) + bi1*d(n-1) + bi2*d(n-2) ; ; Memory arrangement and initialization: (1,2,...i,..,Ns) ; tempbuf[2*Ns] coefficient[5*Ns] ; AR3 -> w1i AR7 -> a1i ; w1j a2i ; : b2i ; w2i b0i ; w2j b1i ; : : ; ; Scale: Coefficient is in Q14 format ; The filter result is scaled up to compensate the Q14 coefficient ; .global _iirform2 .sect "iir_code" _iirform2 pshm ST1_55 ; Save ST1, ST2, and ST3 pshm ST2_55 pshm ST3_55 psh T3 ; Save T3 pshboth XAR7 ; Save AR7 or #0x340,mmap(ST1_55) ; Set FRCT,SXMD,SATD bset SMUL ; Set SMUL sub #1,T0 ; Number of samples - 1 mov T0,BRC0 ; Set up outer loop counter sub #1,T1,T0 ; Number of sections -1 mov T0,BRC1 ; Set up inner loop counter mov T1,T0 ; Set up circular buffer sizes sfts T0,#1 mov mmap(T0),BK03 ; BK03=2*number of sections sfts T0,#1 add T1,T0 mov mmap(T0),BK47 ; BK47=5*number of sections mov mmap(AR3),BSA23 ; Initial delay buffer base mov mmap(AR2),BSA67 ; Initial coefficient base amov #0,AR3 ; Initial delay buffer entry amov #0,AR7 ; Initial coefficient entry or #0x88,mmap(ST2_55) mov #1,T0 ; Used for shift left || rptblocal sample_loop-1 ; Start IIR filter loop mov *AR0+ <<#14,AC0 ; AC0 = x(n)/2 (i.e. Q14) || rptblocal filter_loop-1 ; Loop for each section masm *(AR3+T1),*AR7+,AC0 ; AC0-=ai1*di(n-1) masm T3=*AR3,*AR7+,AC0 ; AC0-=ai2*di(n-2) mov rnd(hi(AC0<<T0)),*AR3 ; di(n-2)=di(n) || mpym *AR7+,T3,AC0 ; AC0+=bi2*di(n-2) macm *(AR3+T1),*AR7+,AC0 ; AC0+=bi0*di(n-1) macm *AR3+,*AR7+,AC0 ; AC0+=bi1*di(n) filter_loop mov rnd(hi(AC0<<#2)),*AR1+ ; Store result in Q15 sample_loop popboth XAR7 ; Restore AR7 pop T3 ; Restore T3 popm ST3_55 ; Restore ST1, ST2, and ST3 popm ST2_55 popm ST1_55 ret .end

To conduct Experiment 6D, following these steps:

1. Create the project, exp6d and include the linker command file exp6.cmd, the C function exp6d.c, signal_gen2.c, the assembly routine sine.asm, and the IIR filter assembly routine iirform2.asm.

2. Use rts55.lib for the C function main()initialization and build the project exp6d.

4. Profile the IIR filter iirform2() and compare the profile result with those obtained in Experiment 6B and 6C.