DSP Development Environment: Introductory Exercise for TI TMS320C55x
Summary: This exercise introduces the hardware and software used in the course. By the end of this module, you should be comfortable with the basics of testing a simple real-time DSP system with Code Composer Studio, the debugging environment we will be using throughout the semester. First you will connect the laboratory equipment and test a real-time DSP system with provided code to implement an eight-tap (eight coefficient) finite impulse response (FIR) filter. With a working system available, you will then begin to explore the debugging software used for downloading, modifying, and testing your code. Finally, you will create a filter in MATLAB and use test vectors to verify the DSP's output.
- Links
-
Supplemental links
- [1] Lab 1: Prelab
Introduction
This exercise introduces the hardware and software used in
testing a simple DSP system. When you complete it, you should
be comfortable with the basics of testing a simple real-time
DSP system with the debugging environment you will use
throughout the course. First, you will connect the laboratory
equipment and test a real-time DSP system with pre-written
code to implement an eight-tap (eight coefficient)
finite impulse response (FIR)
filter. With a working system available, you will then begin
to explore the debugging software used for downloading,
modifying, and testing code. Finally, exercises are included
to refresh your familiarity with MATLAB.
Lab Equipment
This exercise assumes you have access to a laboratory station
equipped with a Texas Instruments TMS320C5510A-200 digital signal
processor chip mounted on a Spectrum Digital TMS320VC5510
evaluation board. The DUAL3006, a daughtercard produced by Educational DSP, is mounted on the external peripheral interface of the board to enable four-input/four-output capability. The evaluation module should be
connected to a PC running Windows and will be controlled using
the PC application Code Composer Studio, a debugger and
development environment. We will be using a 48kHz sample rate. The DSP board can
also communicate with user code or a terminal emulator running
on the PC via a USB interface.
In addition to the DSP board and PC, each laboratory station
should also be equipped with a function generator to provide
test signals and an oscilloscope to display the processed
waveforms.
Step 1: Connect cables
Use the provided cables (stereo-to-2BNC) to connect the output of the
function generator to input channel 1 on the DSP evaluation
board. Connect output channels 1 and 2 of the board to
channels 1 and 2 of the oscilloscope. The input and output
connections for the DSP board are shown in Figure 1. The figure may not be up to date, so ask a TA if you need help.
Example Hardware Setup Figure 1 |
Note that with this configuration, you will have only one
signal going into the DSP board and two signals coming out.
The output on channel 1 is the filtered input signal, and
the output on channel 2 is the unfiltered input signal.
This allows you to view the raw input and filtered output
simultaneously on the oscilloscope. Turn on the function
generator and the oscilloscope.
Step 2: Log in
Use your network ID and password to log into the PC
at your laboratory station.
When you log in, two shared networked drives should be
mapped to the computer: the
Z: drive, which
contains your own private network work directory, and the
C: drive, where the necessary files for ECE 609
are stored. Be sure to save any files that you use for the
course to the Z: drive. On the C:
drive, the directory c:\ece609\55x\ contains the
files necessary to assemble and test code on the TI DSP
evaluation boards.
Although you may want to work exclusively in one or the
other of lab-partners' network account, you should be
sure that both partners have copies of the lab assignment
assembly code.
The Development Environment
The evaluation board is controlled by the PC through the JTAG
interface using the application Code Composer
Studio. This development environment allows the user to
download, run, and debug code assembled on the PC. Work
through the steps below to familiarize yourself with the
debugging environment and real-time system using the provided
FIR filter code (Steps 3, 4 and 5), then verify the filter's
frequency response with the subsequent MATLAB exercises (Steps
6 and 7).
Step 3: Assemble filter code
Before you can execute and test the provided FIR filter
code, you must assemble the source file. First, bring up a
DOS prompt window and create a new directory to
hold the files, and then copy them into your directory:
z:mkdir ece609cd ece609mkdir lab0cd lab0copy c:\ece609\55x\filter .
Next, open up Code Composer Studio 3.1 . A new window should pop out. From the 'Project' menu, select 'Open...' and choose the
filter.pjt file in the directory you just copied.
Assemble the code by selecting
Rebuild All under the Project menu. In a successful build, there will be 0 errors and maybe a few warnings and remarks. The output file will be placed in a Debug folder within the project's directory. In this case, the executable binary code will be in filter.out.Step 4: Verify filter execution
Before loading your code, you must connect to the DSP board.
To connect the board, select the
Connect option from the Debug menu
in Code Composer.
Select the
Registers option from the View menu,
then select CPU Register. This will open a
sub-window at the bottom of the Code Composer application
window that displays several of the DSP registers. This display will be useful when debugging your code in the later labs. Now, load your assembled filter file onto the DSP by
selecting
Load Program from the
File menu. Finally,
execute the code by selecting Run from the
Debug menu. On subsequent runs, selecting Reload Program can be used to reload the same output file without requiring user selection of the output file.
The program you are running accepts input from input channel
1 and sends output waveforms to output channels 1 and 2 (the
filtered signal and raw input, respectively). Note that the
"raw input" on output channel 2 may differ from the actual
input on input channel 1, because of distortions introduced
in converting the analog input to a digital signal and then
back to an analog signal. The A/D and D/A converters on the
six-channel surround board operate at a sample rate of 48
kHz and have an anti-aliasing filter and an
anti-imaging filter, respectively, that in the
ideal case would eliminate frequency content above 24
kHz. The converters on the board are also
AC coupled and cannot pass DC signals. On the
basis of this information, what differences do you expect to
see between the signals at input channel 1 and at output
channel 2?
Set the amplitude on the function generator to 1.0 V
peak-to-peak and the pulse shape to sinusoidal. Adjust the function generator so that it expects a high impedance load. Observe the
frequency response of the filter by sweeping the input
signal through the relevant frequency range. Make sure the oscilloscope is set to a high impedance. What is the
relevant frequency range for a DSP system with a sample rate
of 48 kHz?
Based on the frequency response you observe, characterize
the filter in terms of its type (e.g., low-pass, high-pass,
band-pass) and its -6 dB (half-amplitude) cutoff frequency
(or frequencies). It may help to set the trigger on channel
2 of the oscilloscope since the signal on channel 1 may go
to zero.
Step 5: Re-assemble and re-run with new filter
Once you have determined the type of filter the DSP is
implementing, you are ready to repeat the process with a
different filter by including different coefficients during
the assembly process.
Copy a second set of FIR coefficients over to your working
directory with the following:
copy coef.asm coef1.asmcopy c:\ece609\55x\filter\coef2.asm coef.asm
You can now repeat the assembly and testing process with the
new filter by repeating the steps required to assemble and
execute the code discussed in Step
4.
Just as you did in Step 4,
determine the type of filter you are running and the
filter's -6 dB point by testing the system at various
frequencies.
Step 6: Check filter response in MATLAB
In this step, you will use MATLAB to verify the frequency
response of your filter by copying the coefficients from the
DSP to MATLAB and displaying the magnitude of the frequency
response using the MATLAB command
freqz.
The FIR filter coefficients included in the file
coef.asm are stored in memory on the DSP.
The location in memory can be found by typing the name of the variable. In this case, the coefficients are stored at coef1. View the filtercode.asm to make sure you understand why.
To view the filter coefficients as signed integers, select
the Memory option from the
View menu to bring up a Memory Window
Options box. In the appropriate fields, set the
starting address to coef1 and the format to
16-Bit Signed Int. Click "OK" to open a memory
window displaying the contents of the specified memory
locations. The numbers along the left-hand side indicate
the memory locations.
In this example, the filter coefficients are placed in
memory in decreasing order; that is, the last coefficient,
h 7
h
7
h 0
h
0
coef1 and the first
coefficient,
coef1+7.
Now that you can find the coefficients in memory, you are
ready to use the MATLAB command
freqz to view
the filter's response. You must create a vector in MATLAB
with the filter coefficients to use the freqz
command. For example, if you want to view the response of
the three-tap filter with coefficients -10, 20, -10 you can
use the following commands in MATLAB:
h = [-10, 20, -10];plot(abs(freqz(h)))
Note that you will have to enter eight values, the contents
of memory locations
coef1 through
coef1+7, into the coefficient vector,
h.
Does the MATLAB response compare with your experimental
results? What might account for any differences?
Step 7: Create new filter in MATLAB and verify
MATLAB scripts will be made available to you to aid in code
development. For example, one of these scripts allows you
to save filter coefficients created in MATLAB in a form that
can be included as part of the assembly process without
having to type them in by hand (a very useful tool for long
filters). These scripts may already be installed on your
computer; otherwise, download the files from the links as
they are introduced.
First, have MATLAB generate a "random" eight-tap filter by
typing
h = gen_filt; at a MATLAB prompt. Then
save this vector of filter coefficients by typing
save_coef('coef.asm',flipud(h)); Make sure you
save the file in your own directory. (The scripts that
perform these functions are available as gen_filt.m and save_coef.m . They are also available at c:/ece609/55x/m_files)
The
h
h
save_coef MATLAB script will save the
coefficients of the vector h into the named
file, which in this case is coef.asm. Note
that the coefficient vector is "flipped" prior to being
saved; this is to make the coefficients in
coef1 through
coef1+7 in reverse order, as before.
You may now re-assemble and re-run your new filter code as
you did in Step 5.
Notice when you load your new filter that the contents of
memory locations
coef1 through
coef1+7 update accordingly.
Step 8: Modify filter coefficients in memory
Not only can you view the contents of memory on the DSP
using the debugger, you can change the contents at any
memory location simply by double-clicking on the location
and making the desired change in the pop-up window.
Change the contents of memory locations
h n = 8192 δ n - 4
h
n
8192
δ
n
4
1 4
1
4
coef1
through coef1+7 such that the coefficients
implement a scale and delay filter with impulse response:
note: A clear and complete understanding of how the
DSP interprets numbers is absolutely necessary to
effectively write programs for the DSP. Save yourself time
later by learning this material now!
After you have made the changes to all eight coefficients,
run your new filter and use the oscilloscope to measure the
delay between the raw (input) and filtered (delayed)
waveforms.
What happens to the output if you change either the scaling
factor or the delay value? How many seconds long is a
six-sample delay?
Step 9: Test-vector simulation
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 using sweep.m 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
h
h
n + m - 1
n
m
1
n
n
m
m
conv command to generate a
simulated response by filtering the sweep with the filter
gen_filt
above. Note that this operation will yield a vector of
length 507 (which is
>> out=conv(h,t) % Filter t with FIR filter h >> out=out(1:500) % Keep first 500 elements of out
The
main.c file needs to be told to take input from memory on the DSP. Fortunately, the changes have already been made in the files. The test vector is stored
in a block of memory on the DSP just like other variables.
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 all four channels of input
and from four channels of output.
To run your program with test vectors, you will need to
modify
main.c as well as filtercode.asm. Both are simply text files and can be edited using the editor of
your preference, including WordPad, Emacs, and VI. Within main.c, uncomment the #define FILE_INPUT line so that your program will rewrite input from the A/D with the test vector you specified and then save the output into a block of memory. In
filtercode.asm, add the following at the end of the .data section. Depending on where you saved testvect.asm, the reference may have to be a direct reference. If you saved it in the folder of the source code we are working with, then the following should work..copy "testvect.asm"
Note that, as usual, the whitespace in front of the
.copy directive is required.
These changes will copy in the test vector. 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). How many seconds do you think it should take?Next, save the test output file and load it back into
MATLAB. This can be done by first saving 2000 memory
elements (4 channels times 500 samples) starting with
location
tv_outbuf in data memory. Do this by
choosing File->Data->Save... in Code Composer
Studio, then entering the filename output.dat
and pressing Enter. Next, enter
tv_outbuf in the Address field of the dialog box
that pops up, 2000 in the Length field, and
choose Data from the drop-down menu next to
Page. Always make sure that you use the correct
length (four 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, ch3, ch4] = 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. Note: 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.
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.
More about this content: Metadata | Version History | Cite This Content
This work is licensed by Lee Potter and Thomas Shen. See the Creative Commons License about permission to reuse this material.
Last edited by Lee Potter on Apr 2, 2007 9:04 pm GMT-5.