As a final exercise, you will find the output of the DSP for
an input specified by a test vector. Then you will compare
that output with the output of a MATLAB simulation of the
same filter processing the same input; if the DSP
implementation is correct, the two outputs should be almost
identical. To do this, you will generate a waveform in
MATLAB and save it as a test vector. You will then run your
DSP filter using the test vector as input and import the
results back into MATLAB for comparison with a MATLAB
simulation of the filter.

The first step in using test vectors is to generate an
appropriate input signal. One way to do this is to use the
MATLAB function to generate a sinusoid that sweeps across a
range of frequencies. The MATLAB function
`save_test_vector`

(available as save_test_vector.m can then
save the sinusoidal sweep to a file you will later include
in the DSP code.

Generate a sinusoidal sweep and save it to a DSP test-vector
file using the following MATLAB commands:

```
>> t=sweep(0.1*pi,0.9*pi,0.25,500); % Generate a frequency sweep
>> save_test_vector('testvect.asm',t); % Save the test vector
```

Next, use the MATLAB `conv`

command to generate a
simulated response by filtering the sweep with the filter
h
h you generated using `gen_filt`

above. Note that this operation will yield a vector of
length 507 (which is
n+m−1
n
m
1
, where
n
n is the length of the filter and
m
m is the length of the input). You should keep only
the first 500 elements of the resulting vector.

```
>> out=conv(h,t) % Filter t with FIR filter h
>> out=out(1:500) % Keep first 500 elements of out
```

Now, modify the file `filter.asm`

to use the
alternative "test vector" core file, vectcore.asm. Rather than
accepting input from the A/D converters and sending output
to the D/A, this core file takes its input from, and saves
its output to, memory on the DSP. The test vector is stored
in a block of memory on the DSP evaluation board that will
not interfere with your program code or data.

The memory block that holds the test
vector is large enough to hold a vector up to 4,000 elements
long. The test vector stores data for both channels of input
and from all six channels of output.

To run your program with test vectors, you will need to
modify `filter.asm`

. The assembly source is
simply a text file and can be edited using the editor of
your preference, including WordPad, Emacs, and VI. Replace
the first line of the file with two lines. Instead of:

```
.copy "v:\ece420\54x\dsplib\core.asm"
```

use:

```
.copy "testvect.asm"
.copy "v:\ece420\54x\dsplib\vectcore.asm"
```

Note that, as usual, the whitespace in front of the
`.copy`

directive is required.

These changes will copy in the test vector you created and
use the alternative core file. After modifying your code,
assemble it, then load and run the file using Code Composer
as before. After a few seconds, halt the DSP (using the
`Halt`

command under the `Debug`

menu)
and verify that the DSP has halted at a branch statement
that branches to itself. In the disassembly window, the
following line should be highlighted: ```
0000:611F F073 B
611fh
```

.

Next, save the test output file and load it back into
MATLAB. This can be done by first saving 3,000 memory
elements (six channels times 500 samples) starting with
location `0x8000`

in program memory. Do this by
choosing `File->Data->Save...`

in Code Composer
Studio, then entering the filename `output.dat`

and pressing `Enter`

. Next, enter
`0x8000`

in the Address field of the dialog box
that pops up, `3000`

in the Length field, and
choose `Program`

from the drop-down menu next to
`Page`

. Always make sure that you use the correct
length (six times the length of the test vector) when you
save your results.

Last, use the `read_vector`

(available as read_vector.m) function to read
the saved result into MATLAB. Do this using the following
MATLAB command:

```
>> [ch1, ch2] = read_vector('output.dat');
```

Now, the MATLAB vector `ch1`

corresponds to the
filtered version of the test signal you generated. The
MATLAB vector `ch2`

should be nearly identical to
the test vector you generated, as it was passed from the DSP
system's input to its output unchanged.

Because of quantization error introduced in
saving the test vector for the 16-bit memory of the DSP, the
vector `ch2`

will not be identical to the MATLAB
generated test vector. Furthermore, a bug in our test vector environment sometimes causes blocks of samples to be dropped, so the test vector output signal may have gaps.

After loading the output of the filter into MATLAB, compare
the expected output (calculated as `out`

above)
and the output of the filter (in `ch1`

from
above). This can be done graphically by simply plotting the
two curves on the same axes; for example:

```
>> plot(out,'r'); % Plot the expected curve in red
>> hold on % Plot the next plot on top of this one
>> plot(ch1,'g'); % Plot the expected curve in green
>> hold off
```

You should also ensure that the difference between the two
outputs is near zero. This can be done by plotting the
difference between the two vectors:

```
>> plot(out(1:length(ch1))-ch1); % Plot error signal
```

You will observe that the two sequences are not exactly the
same; this is due to the fact that the DSP computes its
response to 16 bits precision, while MATLAB uses 64-bit
floating point numbers for its arithmetic. Blocks of output samples may also be missing from the test vector output due to a bug in the test vector core. Nonetheless, the test vector environment allows one to run repeatable experiments using the same known test input for debugging.

Comments:"Doug course at UIUC using the TI C54x DSP has been adopted by many EE, CE and CS depts Worldwide "