Tms320c54x DSP Ccs Tutorial
Tms320c54x DSP Ccs Tutorial
Tms320c54x DSP Ccs Tutorial
IMPORTANT NOTICE
Texas Instruments and its subsidiaries (TI) reserves the right to make changes to their products or to
discontinue any product or service without notice, and advises customers to obtain the latest version of
relevant information to verify, before placing orders, that the information being relied on is current and
complete. All products are sold subject to the terms and conditions of sale at the time of order
acknowledgment, including those pertaining to warranty, patent infringement, and limitation of liability.
TI warrants performance of its semiconductor products to the specifications applicable at the time of sale
in accordance with TIs standard warranty. Testing and other quality control techniques are utilized to the
extent TI deems necessary to support this warranty. Specific testing of all parameters of each device is
not necessarily performed, except those mandated by government requirements.
CERTAIN APPLICATIONS USING SEMICONDUCTOR PRODUCTS MAY INVOLVE POTENTIAL
RISKS OF DEATH, PERSONAL INJURY, OR SEVERE PROPERTY OR ENVIRONMENTAL DAMAGE
(CRITICAL APPLICATIONS). TI SEMICONDUCTOR PRODUCTS ARE NOT DESIGNED,
AUTHORIZED, OR WARRANTED TO BE SUITABLE FOR USE IN LIFE-SUPPORT DEVICES OR
SYSTEMS OR OTHER CRITICAL APPLICATIONS. INCLUSION OF TI PRODUCTS IN SUCH
APPLICATIONS IS UNDERSTOOD TO BE FULLY AT THE CUSTOMERS RISK.
In order to minimize risks associated with the customers applications, adequate design and operating
safeguards must be provided by the customer to minimize inherent or procedural hazards.
TI assumes no liability for applications assistance or customer product design. TI does not warrant or
represent that any license, either express or implied, is granted under any patent right, copyright, mask
work right, or other intellectual property right of TI covering or relating to any combination, machine, or
process in which such semiconductor products or services might be or are used. TIs publication of
information regarding any third partys products or services does not constitute TIs approval, warranty
or endorsement thereof.
Preface
iii
Notational Conventions
Notational Conventions
This document uses the following conventions:
iv
Related Documentation
Related Documentation
You can use the following books to supplement this user's guide:
Trademarks
MS-DOS, Windows, and Windows NT are trademarks of Microsoft
Corporation. Other Microsoft products referenced herein are either
trademarks or registered trademarks of Microsoft.
The Texas Instruments logo and Texas Instruments are registered
trademarks of Texas Instruments. Trademarks of Texas Instruments include:
TI, XDS, Code Composer Studio, Probe Point, Code Explorer, DSP/BIOS,
RTDX, Online DSP Lab, BIOSuite, and SPOX.
All other brand or product names are trademarks or registered trademarks of
their respective companies or organizations.
vi
Contents
vii
Contents
viii
Contents
6.6
6.7
7
Contents
ix
Chapter 1
Page
1.3
1.4
DSP/BIOS Plug-ins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.5
1.6
1.7
1-1
1.1
Debug
Analyze
conceptual
planning
create project,
write source code,
configuration file
syntax checking,
probe points,
logging, etc.
real-time
debugging,
statistics, tracing
In order to use this tutorial, you should have already done the following:
1-2
Run Code Composer Studio Setup. The setup program allows Code
Composer Studio to use the drivers installed for the target board.
Host
Target
source file s
.c db
(C o n fig
d a tab a s e )
c fg.c m d
c fg.s 5 4
c fg.h 5 4
O LE
app lication
using R T D X
DS P
C onfiguration
To ol
.c
.h
.asm
D S P /B IO S A P I
C o de C o m p oser proje ct
C ode
gen eration
tools
C om piler,
assem b le r,
lnker...
R TD X
plug-in
D S P /B IO S
plug-ins
3rd party
plug-ins
C o de C o m p oser de bu gg er
H o st e m ula tion su pp ort
execu ta ble
JT A G
RTDX
D S P /B IO S
T arge t h ardw a re
1-3
1.2
C compiler
Archiver
Assembler
source
Assembly
translation
assistant
Assembler
Assembler
source
Macro
library
COFF
object
files
Archiver
Run-timesupport
library
Library of
object
files
Linker
Executable
COFF
file
Hex conversion
utility
EPROM
programmer
1-4
Library-build
utility
Absolute
lister
Cross-reference
lister
Debugging
tools
TMS320C54x
The linker combines object files into a single executable object module.
As it creates the executable module, it performs relocation and resolves
external references. The linker accepts relocatable COFF object files and
object libraries as input. See the TMS320C54x Optimizing C Compiler
Users Guide and the TMS320C54x Assembly Language Tools Users
Guide for details.
The archiver allows you to collect a group of files into a single archive
file, called a library. The archiver also allows you to modify a library by
deleting, replacing, extracting, or adding members. See the
TMS320C54x Assembly Language Tools Users Guide for details.
You can use the library-build utility to build your own customized
run-time-support library. See the TMS320C54x Optimizing C Compiler
Users Guide for details.
The hex conversion utility converts a COFF object file into TI-Tagged,
ASCII-hex, Intel, Motorola-S, or Tektronix object format. You can
download the converted file to an EPROM programmer. See the
TMS320C54x Assembly Language Tools Users Guide for details.
The absolute lister accepts linked object files as input and creates .abs
files as output. You assemble the .abs files to produce a listing that
contains absolute addresses rather than relative addresses. Without the
absolute lister, producing such a listing would be tedious and require
many manual operations.
1-5
1.3
1.3.1
1-6
Finding and replacing in one or more files, find next and previous, quick
search
1.3.2
1.3.3
Watching variables
Using Probe Point tools to stream data to and from the target and to
gather memory snapshots
Code Composer Studio also provides the GEL language, which allows
developers to add functions to the Code Composer Studio menus for
commonly performed tasks.
1-7
DSP/BIOS Plug-ins
1.4
DSP/BIOS Plug-ins
During the analysis phase of the software development cycle, traditional
debugging features are ineffective for diagnosing subtle problems that arise
from time-dependent interactions.
The Code Composer Studio plug-ins provided with DSP/BIOS support such
real-time analysis. You can use them to visually probe, trace, and monitor a
DSP application with minimal impact on real-time performance. For example,
the Execution Graph shown below displays the sequence in which various
program threads execute. (Threads is a general term used to refer to any
thread of execution. For example, hardware ISRs, software interrupts, tasks,
idle functions, and periodic functions are all threads.)
1.4.1
DSP/BIOS Configuration
You can create configuration files in the Code Composer Studio environment
that define objects used by the DSP/BIOS API. This file also simplifies
memory mapping and hardware ISR vector mapping, so you may want to use
it even if you are not using the DSP/BIOS API.
A configuration file has two roles:
1-8
DSP/BIOS Plug-ins
It serves as a visual editor for creating and setting properties for run-time
objects that are used by the target applications DSP/BIOS API calls.
These objects include software interrupts, I/O pipes, and event logs.
When you open a configuration file in Code Composer Studio, a window like
the following one appears.
Unlike systems that create objects at run time with API calls that require extra
target overhead (especially code space), all DSP/BIOS objects are statically
configured and bound into an executable program image. In addition to
minimizing the target memory footprint by eliminating run-time code and
optimizing internal data structures, this static configuration strategy detects
errors earlier by validating object properties before program execution.
You can use a configuration file in both programs that use the DSP/BIOS API
and in programs that do not. A configuration file simplifies ISR vector and
memory section addressing for all programs.
Saving a configuration file generates several files that you must link with your
application. See section 1.7.2, page 116 for details about these files.
1-9
DSP/BIOS Plug-ins
1.4.2
1-10
CLK. The on-chip timer module controls the on-chip timer and provides
a logical 32-bit real-time clock with a high-resolution interrupt rate as fine
as the resolution of the on-chip timer register (1 instruction cycle) and a
low-resolution interrupt rate as long as several milliseconds or longer.
DEV. This module allows you to create and use your own device drivers.
HST. The host input/output module manages host channel objects, which
allow an application to stream data between the target and the host. Host
channels are statically configured for input or output.
IDL. The idle function module manages idle functions, which are run in a
loop when the target program has no higher priority functions to perform.
LCK. The lock module manages shared global resources, and is used to
arbitrate access to this resource among several competing tasks.
LOG. The log module manages LOG objects, which capture events in
real time while the target program executes. You can use system logs or
define your own logs. You can view messages in these logs in real time
with Code Composer Studio.
MBX. The mailbox module manages objects that pass messages from
one task to another. Tasks block when waiting for a mailbox message.
DSP/BIOS Plug-ins
MEM. The memory module allows you to specify the memory segments
required to locate the various code and data sections of a target program.
PIP. The data pipe module manages data pipes, which are used to buffer
streams of input and output data. These data pipes provide a consistent
software data structure you can use to drive I/O between the DSP device
and other real-time peripheral devices.
SIO. The stream module manages objects that provide efficient real-time
device-independent I/O.
TRC. The trace module manages a set of trace control bits which control
the real-time capture of program information through event logs and
statistics accumulators. There are no TRC objects, so the trace module
is not listed in configuration files.
TSK. The task module manages task threads, which are blocking threads
with lower priority than software interrupts.
For details, see the online help or the TMS320C54x DSP/BIOS Users Guide
and TMS320C54x DSP/BIOS API Reference Guide.
1-11
1.5
Real-time data exchange (RTDX) between the host and the DSP
1-12
RTDX consists of both target and host components. A small RTDX software
library runs on the target DSP. The designer's DSP application makes
function calls to this librarys API in order to pass data to or from it. This library
uses the on-chip emulation hardware to move data to or from the host
platform via an enhanced JTAG interface. Data transfer to the host occurs in
real time while the DSP application is running.
C ode C om poser
JTAG
T I d is p la y
R TD X host
lib ra ry
T h ird p a rty
d is p la y
R TD X C O M A P I
L iv e o r re c o rd e d
d a ta
Emulation
U s e r d is p la y
Application
TM S320 D SP
PC
R TD X target A PI
1-13
Third-Party Plug-ins
RTDX is well-suited for a variety of control, servo, and audio applications. For
example, wireless telecommunications manufacturers can capture the
outputs of their vocoder algorithms to check the implementations of speech
applications. Embedded control systems also benefit. Hard disk drive
designers can test their applications without crashing the drive with improper
signals to the servo motor, and engine control designers can analyze
changing factors like heat and environmental conditions while the control
application is running. For all of these applications, users can select
visualization tools that display information in a way that is most meaningful to
them. Future TI DSPs will enable RTDX bandwidth increases, providing
greater system visibility to an even larger number of applications. For more
information on RTDX, see the RTDX online help available within Code
Composer Studio.
1.6
Third-Party Plug-ins
Third-party software providers can create ActiveX plug-ins that complement
the functionality of Code Composer Studio. A number of third-party plug-ins
are available for a variety of purposes.
1-14
1.7
1.7.1
Installation Folders
The installation process creates the subfolders shown here in the folder
where you install Code Composer Studio (typically c:\ti). Additionally,
subfolders are created in the Windows directory (c:\windows or c:\winnt).
The c:\ti structure contains the following directories:
docs. Documentation and manuals in PDF format. If you did not choose
to install the complete documentation, see the CD-ROM for manuals in
PDF format.
1-15
1.7.2
File Extensions
While using Code Composer Studio, you work with files that have the following
file-naming conventions:
1-16
1.7.3
Environment Variables
The installation procedure defines the following variables in your
autoexec.bat file (for Windows 95 and 98) or as environment variables (for
Windows NT):
1.7.4
Variable
Description
C54X_A_DIR
C54X_C_DIR
A search list used by the compiler and linker to find library and
include files for DSP/BIOS, RTDX, and the code generation
tools. See the TMS320C54x Optimizing C Compiler Users
Guide for details.
PATH
1-17
1-18
Chapter 2
This chapter introduces Code Composer Studio and shows the basic process
used to create, build, debug, and test programs.
In this chapter, you create and test a simple program that displays a hello
world message.
This tutorial introduces you to some of the key features of Code Composer
Studio. The intention is not to provide an exhaustive description of every
feature. Instead, the objective is to prepare you to begin DSP software
development with Code Composer Studio.
In order to use this tutorial, you should have already installed Code Composer
Studio according to the installation instructions. It is recommended that you
use Code Composer Studio with a target board rather than with the simulator.
If you have Code Composer and the Code Generation Tools, but not Code
Composer Studio, or if you are using the simulator, you can perform the steps
in Chapter 2 and Chapter 4 only.
Topic
Page
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
2-1
2.1
2-2
2.2
2-3
When building the program, Code Composer Studio finds files by searching
for project files in the following path order:
2.3
The folders listed in the Include Search Path for the compiler or
assembler options (from left to right).
2-4
When FILEIO is undefined, this is a simple program that uses the standard
puts() function to display a hello world message. When you define FILEIO (as
you do in section 2.5, page 2-7), this program prompts for a string and prints
it to a file. It then reads the string from the file and prints it and a message
about its length to standard output.
2.4
2-5
2-6
2.5
2-7
6) Double-click on the red text that describes the location of the syntax error.
Notice that the hello.c source file opens, and your cursor is on the
following line:
fileStr[i] = 0;
7) Fix the syntax error in the line above the cursor location. (The semicolon
is missing.) Notice that an asterisk (*) appears next to the filename in the
Edit window's title bar, indicating that the source file has been modified.
The asterisk disappears when the file is saved.
8) Choose FileSave or press Ctrl+S to save your changes to hello.c.
(Incremental Build) toolbar button.
9) Choose ProjectBuild or click the
Code Composer Studio rebuilds files that have been updated.
2-8
2.6
4) Click the
(Toggle Breakpoint) toolbar button or press F9. The line is
highlighted in magenta. (If you like, you can change this color using
OptionColor.)
5) Choose ViewWatch Window. A separate area in the lower-right corner
of the Code Composer Studio window appears. At run time, this area
shows the values of watched variables.
6) Right-click on the Watch Window area and choose Insert New
Expression from the pop-up list.
7) Type *scanStr as the Expression and click OK.
8) Notice that *scanStr is listed in the Watch Window but is undefined. This
is because the program is currently not running in the main() function
where this variable is declared locally.
2-9
10) At the prompt, type goodbye and click OK. Notice that the Stdout tab
shows the input text in blue.
Also notice that the Watch Window now shows the value of *scanStr.
After you type an input string, the program runs and stops at the
breakpoint. The next line to be executed is highlighted in yellow.
11) Click the
to fprintf().
(Step Over) toolbar button or press F10 to step over the call
12) Experiment with the step commands Code Composer Studio provides:
13) Click
(Run) or press F5 to finish running the program when you have
finished experimenting.
2-10
2.7
2-11
2.8
6) Click the
(Toggle Profile-point) toolbar button. The C source code line
and the first assembly instruction are highlighted in green.
7) Scroll down and put your cursor in the line that says:
for (i = 0; i < BUFSIZE; i++) {
8) Click the
(Toggle Profile-point) toolbar button. (Or, right-click on the
code line and choose Toggle Profile Pt from the pop-up menu.)
2-12
The average, total, maximum, and minimum are the same for these
profile-points because these instructions are executed only one time.
Note: Target Halts at Profile-Points
Code Composer Studio temporarily halts the target whenever it reaches a
profile-point. Therefore, the target application may not be able to meet
real-time deadlines when you are using profile-points. (Real-time
monitoring can be performed using RTDX. See section 1.5, page 1-12.)
2-13
Things to Try
14) Before continuing to the next chapter (after completing section 2.9, page
2-14), perform the following steps to free the resources used in your
profiling session:
2.9
Things to Try
To further explore Code Composer Studio, try the following:
2.10
Learning More
To learn more about using Code Composer Studio, see the online help for
Code Composer Studio or the Code Composer Studio Users Guide (which is
provided as an Adobe Acrobat file).
2-14
Chapter 3
This chapter introduces DSP/BIOS and shows how to create, build, debug,
and test programs that use DSP/BIOS.
In this chapter, you optimize the hello world program you created in Chapter
2 by using DSP/BIOS.
This chapter requires a physical board and cannot be carried out using a
software simulator. Also, this chapter requires the DSP/BIOS components of
Code Composer Studio.
Topic
Page
3.1
3.2
3.3
3.4
3.5
3.6
3-1
3.1
3-2
You see a window like the following. You can expand and contract the list
by clicking the + and - symbols on the left. The right side of the window
shows properties of the object you select in the left side of the window.
4) Right-click on the LOG - Event Log Manager and choose Insert LOG from
the pop-up menu. This creates a LOG object called LOG0.
5) Right-click on the name of the LOG0 object and choose Rename from the
pop-up menu. Change the objects name to trace.
3-3
3.2
4) Click Yes. This replaces the previous command file (HELLO.CMD) with
the new one that was generated when you saved the configuration.
5) In the Project View area, right-click on the vectors.asm source file and
choose Remove from project in the pop-up menu. The hardware interrupt
vectors are automatically defined by the DSP/BIOS configuration file.
6) Right-click on the RTS.lib library file and remove it from the project. This
library is automatically included by the myhellocfg.cmd file.
7) Double-click on the hello.c program to open it for editing. If the assembly
instructions are shown, choose ViewMixed Source/ASM to hide the
assembly code.
3-4
8) Change the source files contents to the following. (You can copy and
paste this code from c:\ti\c5400\tutorial\hello2\hello.c if you like.) Make
sure you replace the existing main function (which has the puts() function)
with the main shown below, because puts() and LOG_printf use the same
resources.
/* ======== hello.c ======== */
/* DSP/BIOS header files*/
#include <std.h>
#include <log.h>
/* Objects created by the Configuration Tool */
extern far LOG_Obj trace;
/* ======== main ======== */
Void main()
{
LOG_printf(&trace, "hello world!");
/* fall into DSP/BIOS idle loop */
return;
}
3-5
3.3
7) Choose DebugHalt or press Shift F5 to stop the program. After the main
function returns, your program is in the DSP/BIOS idle loop, waiting for
an event to occur. See section 3.5, page 3-10 to learn more about the idle
loop.
8) Close the Message Log by right-clicking and selecting Close. This is
necessary because you will use the Profiler in the next section.
9) Choose ToolsRTDX to open the RTDX control window. Select RTDX
Disable from the pull-down list, then right-click on the RTDX area and
select Hide.
Note: Profiling and RTDX Cannot Be Used Together on Some Targets
The DSP/BIOS plug-ins use RTDX for host/target communication. On
some DSP targets you cannot use both profiling and RTDX at the same
time. Close all tools that uses RTDX, such as the Message Log and other
3-6
3-7
3.4
6) Click the
(Toggle Profile-point) toolbar button. This line and the
assembly language instruction that follows it are highlighted in green.
7) Scroll down and put your cursor in the line for the final curly brace of the
program, and click the
(Toggle Profile-point) toolbar button.
You might think that you should set the second profile-point on the line
that says return; since that is the last statement in the program.
However, notice that there are no assembly language equivalents shown
until after the curly brace. If you set the profile-point at the line that says
return;, Code Composer Studio automatically corrects the problem at
run time.
8) Choose ProfilerView Statistics.
9) Make sure the line numbers are in ascending order. If they are in the
reverse order, click the Location column heading once.
10) Click the
11) Notice the number of instruction cycles shown for the second
profile-point. It should be about 58. (The actual numbers shown may
vary.) This is the number of cycles required to execute the call to
LOG_printf.
3-8
13) Before proceeding to the next chapter (after completing section 3.5, page
3-10), perform the following steps to free the resources used in your
profiling session:
3-9
Things to Try
3.5
Things to Try
To explore Code Composer Studio, try the following:
Load myhello.out and put a breakpoint on the line that calls LOG_printf.
Use DebugBreakpoints to add a breakpoint at IDL_F_loop. (Type
IDL_F_loop in the Location box and click Add.)
Run the program. At the first breakpoint, use ViewCPU
RegistersCPU Register to see a list of register values. Notice that INTM
is 1, indicating that interrupts are disabled while the main function is
executing.
Run to the next breakpoint. Notice that INTM is now 0, indicating that
interrupts are now enabled. Notice that if you run the program, you hit this
breakpoint over and over.
After the startup process and main are completed, a DSP/BIOS
application drops into a background thread called the idle loop. This loop
is managed by the IDL module and continues until you halt the program.
The idle loop runs with interrupts enabled and can be preempted at any
point by any ISR, software interrupt, or task triggered to handle the
applications real-time processing. Chapter 5 through Chapter 7 explain
more about using ISRs and software interrupts with DSP/BIOS
3.6
Learning More
To learn more about Code Composer Studio and DSP/BIOS, see the online
help for Code Composer Studio. In addition, see the Code Composer Studio
Users Guide, the TMS320C54x DSP/BIOS Users Guide, and the
TMS320C54x DSP/BIOS API Reference Guide (which are provided as
Adobe Acrobat files).
3-10
Chapter 4
This chapter shows the process for creating and testing a simple algorithm
and introduces additional Code Composer Studio features.
In this chapter, you create a program that performs basic signal processing.
You expand on this example in the following two chapters.
You create and test a simple algorithm using data stored in a file on your PC.
You also use Probe Points, graphs, animation, and GEL files with Code
Composer Studio.
Topic
Page
4.1
4.2
4.3
4.4
Displaying Graphs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.5
4.6
4.7
4.8
4.9
4-1
4.1
4-2
rts.lib. This library provides run-time support for the target DSP.
4-3
4.2
After the main function prints a message, it enters an infinite loop. Within
this loop, it calls the dataIO and processing functions.
The processing function multiplies each value in the input buffer by the
gain and puts the resulting values into the output buffer. It also calls the
assembly load routine, which consumes instruction cycles based on the
processingLoad value passed to the routine.
The dataIO function in this example does not perform any actions other
than to return. Rather than using C code to perform I/O, you can use a
Probe Point within Code Composer Studio to read data from a file on the
host into the inp_buffer location.
#include <stdio.h>
#include "volume.h"
/* Global declarations */
int inp_buffer[BUFSIZE];
int out_buffer[BUFSIZE];
4-4
4-5
4.3
To transfer input data from a file on the host PC to a buffer on the target
for use by the algorithm
To transfer output data from a buffer on the target to a file on the host PC
for analysis
Probe Points are similar to breakpoints in that they both halt the target to
perform their action. However, Probe Points differ from breakpoints in the
following ways:
Probe Points halt the target momentarily, perform a single action, and
resume target execution.
Breakpoints halt the CPU until execution is manually resumed and cause
all open windows to be updated.
This chapter shows how to use a Probe Point to transfer the contents of a PC
file to the target for use as test data. It also uses a breakpoint to update all the
open windows when the Probe Point is reached. These windows include
graphs of the input and output data. Chapter 7 shows two other ways to
manage input and output streams.
1) Choose ProjectRebuild All or click the
The dataIO function acts as a placeholder. You add to it later. For now, it
is a convenient place to connect a Probe Point that injects data from a PC
file.
5) Click the
in blue.
4-6
6) Choose FileFile I/O. The File I/O dialog appears so that you can select
input and output files.
7) In the File Input tab, click Add File.
8) Choose the sine.dat file.
Notice that you can select the format of the data in the Files of Type box.
The sine.dat file contains hex values for a sine waveform.
9) Click Open to add this file to the list in the File I/O dialog.
A control window for the sine.dat file appears. (It may be covered by the
Code Composer Studio window.) Later, when you run the program, you
can use this window to start, stop, rewind, or fast forward within the data
file.
10) In the File I/O dialog, change the Address to inp_buffer and the Length to
100. Also, put a check mark in the Wrap Around box.
The Address field specifies where the data from the file is to be
placed. The inp_buffer is declared in volume.c as an integer array of
BUFSIZE.
4-7
The Length field specifies how many samples from the data file are
read each time the Probe Point is reached. You use 100 because that
is the value set for the BUFSIZE constant in volume.h (0x64).
11) Click Add Probepoint. The Probe Points tab of the Break/Probe/Profile
Points dialog appears.
12) In the Probe Point list, highlight the line that says VOLUME.C line 53 -->
No Connection.
13) In the Connect To field, click the down arrow and select the sine.dat file
from the list.
14) Click Replace. The Probe Point list changes to show that this Probe Point
is connected to the sine.dat file.
15) Click OK. The File I/O dialog shows that the file is now connected to a
Probe Point.
16) Click OK in the File I/O dialog.
4-8
Displaying Graphs
4.4
Displaying Graphs
If you ran the program now, you would not see much information about what
the program was doing. You could set watch variables on addresses within
the inp_buffer and out_buffer arrays, but you would need to watch a lot of
variables and the display would be numeric rather than visual.
Code Composer Studio provides a variety of ways to graph data processed
by your program. In this example, you view a signal plotted against time. You
open the graphs in this section and run the program in the next section.
1) Choose ViewGraphTime/Frequency.
2) In the Graph Property Dialog, change the Graph Title, Start Address,
Acquisition Buffer Size, Display Data Size, DSP Data Type, Autoscale,
and Maximum Y-value properties to the values shown here. Scroll down
or resize the dialog box to see all the properties.
4-9
4.5
4-10
buffer contains the values just read from sine.dat, while the output buffer
contains the last set of values processed by the processing function.
The graphs can also be updated using only Probe Points and the Run
command. See section 4.10, page 4-18 at the end of this chapter to try
animating the graphs using Probe Points only.
4-11
4.6
This statement multiplies a value in inp_buffer by the gain and places it in the
corresponding location in the out_buffer. The gain is initially set to MINGAIN,
which is defined as 1 in volume.h. To modify the output, you need to change
gain. One way to do this is to use a watch variable.
1) Choose ViewWatch Window.
2) Right-click on the Watch window area and choose Insert New Expression
from the pop-up list.
3) Type gain as the Expression and click OK.
4-12
4.7
6) Click OK.
7) Press F5 until the program stops at the breakpoint at the end of the
dataIO function (instead of at the breakpoint on the call to the dataIO
function).
8) Right-click on the Watch window area and choose Insert New Expression
from the pop-up list.
9) Type *input as the Expression and click OK.
4-13
10) Notice that the Watch window area says this variable is an unknown
identifier. This shows that *input is not defined within the scope of the
dataIO function.
11) Choose ViewCall Stack. You see the call stack area next to the Watch
window area.
12) Click on main() in the call stack area to see the value of *input within the
scope of the main function. (The value should be 0, but may differ if you
have modified the sine.dat file.)
13) You can also click on the address at the bottom of the call stack to see
that gain is defined globally, but *input is not. (The address varies
depending on the DSP you are using.)
14) Right-click on the call stack area and choose Hide from the pop-up menu.
15) Remove the breakpoint that you added in step 4 by putting he cursor on
(Toggle Breakpoint)
the line after return; in dataIO() and clicking the
toolbar button or pressing F9.
4-14
4.8
6) To see how the Gain GEL function works, click the + sign next to GEL
Files in the Project View. Then, double-click on the VOLUME.GEL file to
see its contents:
menuitem "Application Control"
dialog Load(loadParm "Load")
{
processingLoad = loadParm;
}
slider Gain(0, 10 ,1, 1, gainParm)
{
gain = gainParm;
}
4-15
4.9
4) Click the
(Toggle Profile-point) toolbar button or right-click and select
Toggle Profile Pt.
5) Put your cursor in the line that says:
return(TRUE);
6) Click the
10) Notice the maximum number of cycles shown for the second profile-point.
It should be about 1032 cycles. (The actual numbers shown may vary,
especially if you are using a non-generic development board.) This is the
number of cycles required to execute the load routine when the
processingLoad is 1.
4-16
12) Type 2 as the new load and click Execute. The maximum number of
cycles for the second profile-point changes to 2029. The number of
cycles increases by about 1007 when you increment the processingLoad
by 1. These instruction cycles are performed within the load function,
which is stored in load.asm.
13) Right-click on the Profile Statistics area and choose Clear All from the
pop-up menu. This resets the statistics to 0. The average, maximum, and
minimum are equal to the number of instruction cycles for the current
processingLoad.
14) Click
Close the Load and Gain controls, the sine.dat control window, and
the Time/Frequency graphs.
Choose FileFile I/O and click Remove File to delete the sine.dat
file.
Delete all expressions from the Watch Window and hide the Watch
Window.
4-17
Things to Try
4.10
Things to Try
To explore using Code Composer Studio, try the following:
Add processingLoad to the Watch window. When you use the Load GEL
control, the processingLoad value is updated in the Watch window.
Change BUFSIZE in volume.h to 0x78 (or 120) and rebuild, then reload
the program. Change the Length in the File I/O dialog to 0x78. For both
graphs, change the Acquisition Buffer Size and the Display Data Size to
0x78. This causes a buffer to contain 3 full sine waves rather than 2.5
waves. Animate the program and notice that the input and output buffer
graphs are now in phase. (You may need to halt the program to see
whether the graphs are in phase.)
Experiment with Probe Points by repeating section 4.3, page 4-6 through
section 4.5, page 4-10. This time, use only Probe Points and the Run
command. Note that you need to create three Probe Points. This is
because a Probe Point can be associated with only one action. There are
two graphs to be updated and one file to use as input. Each of these
actions requires its own Probe Point.
Also notice that each Probe Point must go on a different line of code. As
a result, the target is halted three times as often and actions are not
performed at the same point in target execution. For these reasons, the
combination of a Probe Point and a breakpoint used in this lesson is more
efficient than using Probe Points only.
4.11
To practice building projects with Code Composer Studio, copy all the
files in the c:\ti\c5400\tutorial\volume1 folder to a new folder. Delete the
volume.mak file. Then, use Code Composer Studio to recreate the
project using the ProjectNew and ProjectAdd Files to Project menu
items. See section 4.1, page 4-2 for a list of the files to add to the project.
Learning More
To learn more about Probe Points, graphs, animation, and GEL files, see the
online help for Code Composer Studio or the Code Composer Studio Users
Guide (which is provided as an Adobe Acrobat file).
4-18
Chapter 5
Page
5.1
5.2
5.3
5.4
5.5
5.6
5.7
5.8
5.9
5-1
5.1
5-2
volume.c. This is the source code for the main program. It has been
revised from the version you used in the previous chapter to support
using DSP/BIOS in this program. You examine the source code in the
next section.
load.asm. This file contains the load routine, a simple assembly loop
routine that is callable from C with one argument. It is identical to the
load.asm file used in the previous chapter.
5.2
5-3
#include <std.h>
#include <log.h>
#include <swi.h>
#include "volume.h"
/* Global declarations */
Int inp_buffer[BUFSIZE];
Int out_buffer[BUFSIZE];
5-4
5-5
5.3
5-6
You see the properties dialog for this object. At run time, this log stores
events traced by the system for various DSP/BIOS modules.
5) Change the buflen property to 512 words and click OK.
6) Highlight the CLK object called dataIO_CLK. Notice that the function
called when this CLK object is activated is _dataIO. This is the dataIO
function in volume.c.
Note: Underscores and C Function Names
This C function name is prefixed by an underscore because saving the
configuration generates assembly language files. The underscore prefix is
the convention for accessing C functions from assembly. (See the section
on interfacing C with assembly language in the TMS320C54x Optimizing C
Compiler Users Guide for more information.)
This rule applies only to C functions you write. You do not need to use the
underscore prefix with configuration-generated objects or DSP/BIOS API
calls because two names are automatically created for each object: one
prefixed with an underscore and one without.
5-7
7) Since the dataIO function is no longer run within main, what causes this
CLK object to run its function? To find out, right-click on the CLK - Clock
Manager object. From the pop-up menu, select Properties. You see the
Clock Manager Properties dialog.
Notice that there is a check mark in the Enable CLK Manager box. When
this box is checked, the timer interrupt drives the CLK manager. This box
is gray and cannot be changed because there are CLK objects that need
to use the CLK manager. If you wanted to disable the CLK manager, you
would first need to delete all the CLK objects.
8) Click Cancel to close the Clock Manager Properties dialog without
making any changes.
9) Expand the list of HWI objects and examine the properties of the
HWI_TINT object. Its interrupt source is the DSP timer and it runs a
function called CLK_F_isr when the on-chip timer causes an interrupt.
The CLK object functions run from the context of the CLK_F_isr hardware
interrupt function. Therefore, they run to completion without yielding and
have higher priority than any software interrupts. (The CLK_F_isr saves
the register context, so the CLK functions do not need to save and restore
context as would be required normally within a hardware ISR function.)
5-8
11) Click Cancel to close this properties dialog without making any changes.
12) Since the processing function is no longer run within main, what causes
this SWI object to run its function? In volume.c, the dataIO function calls
SWI_dec, which decrements the mailbox value and posts the software
interrupt if the new mailbox value is 0. So, this SWI object runs its function
every tenth time the dataIO_CLK object runs the dataIO function.
13) Choose FileClose. You are asked whether you want to save your
changes to volume.cdb. Click Yes. Saving this file also generates
volumecfg.cmd, volumecfg.s54, and volumecfg.h54.
14) Choose ProjectBuild or click the
5-9
5.4
5-10
10) The marks in the Time row show each time the Clock Manager ran the
CLK functions. Count the marks between times the processing_SWI
object was running. There should be 10 marks. This indicates that the
processing_SWI object ran its function every tenth time the dataIO_CLK
object ran its function. This is as expected because the mailbox value that
is decremented by the dataIO function starts at 10.
5-11
5.5
5-12
7) Right-click on the Execution Graph and choose Clear from the pop-up
menu. Notice that the program still meets its real-time deadline. There are
10 time marks between each execution of the processing_SWI function.
8) Using the GEL control, change the load to 200 and click Execute.
9) Right-click on the Execution Graph and choose Clear from the pop-up
menu. One or two of the time marks occur while the processing_SWI
function is executing. Does this mean the program is missing its real-time
deadline? No, it shows that the program is functioning correctly. The
hardware interrupt that runs the CLK object functions can interrupt the
software interrupt processing, and the software interrupt still completes
its work before it needs to run again.
5-13
12) Using the GEL control, change the load to 1200 and click Execute. The
CPU Load Graph and the Execution Graph stop updating as frequently
and may not update at all. This is because Execution Graph data is sent
to the host within an idle thread, which has the lowest execution priority
within the program. Because the higher-priority threads are using all the
processing time, there is not enough time for the host control updates to
be performed. The program is now missing its real-time deadline.
13) Choose DebugHalt. This stops the program and updates the Execution
Graph. You may see squares in the Assertions row. These squares
indicate that the Code Composer Studio detected that the application
missed a real-time deadline.
14) Using the GEL control, change
the load to 10 and click Execute.
The CPU load and Execution
Graph begin updating again.
5-14
5.6
3) You see the statistics fields for the processing_SWI objects. You may
want to make this area a separate window (by right-clicking on it and
deselecting Allow Docking in the pop-up menu) and resize the window so
that you can see all four fields.
4) In the RTA Control Panel, put a check mark in the enable SWI
accumulators box.
5-15
6) Notice the Max value in the Statistics View. SWI statistics are measured
in instruction cycles.
7) Using the GEL control, increase the load and click Execute. Notice the
change in the Max value for the number of instructions performed from
the beginning to the end of processing_SWI increases.
8) Experiment with different load values. If you decrease the load, right-click
on the Statistics View and select Clear from the pop-up menu.
This resets the fields to their lowest possible values, allowing you to see
the current number of instruction cycles in the Max field.
9) Click the
(Halt) toolbar button and close all the DSP/BIOS and GEL
controls you have opened.
5-16
5.7
Add the following lines below the line that includes the swi.h file:
#include <clk.h>
#include <sts.h>
#include <trc.h>
Add the following to the declarations in the section labeled with the
comment Objects created by the Configuration Tool:
extern far STS_Obj processingLoad_STS;
Add the following lines within the processing function before the call
to the load function:
/* enable instrumentation only if TRC_USER0 is set */
if (TRC_query(TRC_USER0) == 0) {
STS_set(&processingLoad_STS, CLK_gethtime());
}
Add the following lines within the processing function after the call to
the load function:
if (TRC_query(TRC_USER0) == 0) {
STS_delta(&processingLoad_STS, CLK_gethtime());
}
5-17
5.8
5-18
processingLoad_STS
processing_SWI
5-19
Things to Try
5.9
Click
Things to Try
To further explore DSP/BIOS, try the following:
5.10
Learning More
To learn more about the CLK, SWI, STS, and TRC modules, see the online
help or the TMS320C54x DSP/BIOS Users Guide (which is provided as an
Adobe Acrobat file).
5-20
Chapter 6
Page
6.1
6.2
6.3
6.4
6.5
6.6
6.7
6-1
6.1
volume.c. The source code has been modified to allow you to use
the RTDX module to change the load without stopping the target
program. You examine the changes in section 6.3, page 6-5.
6-2
6.2
Change the period to 2. By default, the PRD manager uses the CLK
manager to drive PRD execution. The default properties for the CLK
class make a clock interrupt trigger a PRD tick each millisecond. So,
this PRD object runs its function every 2 milliseconds.
6-3
7) Click the + sign next to the SWI manager. A SWI object called PRD_swi
was added automatically. This software interrupt executes periodic
functions at run time. Therefore, all PRD functions are called within the
context of a software interrupt and can yield to hardware interrupts. In
contrast, CLK functions run in the context of a hardware interrupt. (The
KNL_swi object runs a function that runs the TSK manager. See the
TMS320C54x DSP/BIOS Users Guide and the online help for
information about tasks, which are not used in this tutorial.)
8) Click the + sign next to the CLK manager. Notice that the CLK object
called PRD_clock runs a function called PRD_F_tick. This function
causes the DSP/BIOS system clock to tick (by calling the PRD_tick API
function) and the PRD_swi software interrupt to be posted if any PRD
functions need to run. PRD_swi runs the functions for all the PRD objects
whose period has elapsed.
9) Right click on the PRD manager, and choose Properties from the pop-up
menu. The PRD manager has a property called Use CLK Manager to
drive PRD. Make sure this box is checked for this example.
In your own projects, if you remove the check mark from this box, the
PRD_clock object would be deleted automatically. Your program could
then call PRD_tick from some other event, such as a hardware interrupt,
to drive periodic functions.
10) Recall that the processing_SWI object has a mailbox value of 10 and that
the mailbox value is decremented by the dataIO_CLK object, which runs
every millisecond. As a result, the processing_SWI runs its function every
10 milliseconds. In contrast, the loadchange_PRD object should run its
function every 2 milliseconds.
11) Choose FileClose. You are asked whether you want to save your
changes to volume.cdb. Click Yes. Saving this file also generates
volumecfg.cmd, volumecfg.s54, and volumecfg.h54.
12) Choose ProjectRebuild All or click the
6-4
6.3
The following function is called by the PRD object you created in section
6.2, page 6-3. This is where the processor is controlled.
6-5
This function uses RTDX API functions to change the load of the processing
signal in real time. Notice the following aspects of these changes:
6-6
The call to RTDX_readNB asks the host to send a load control value on
the control_channel and stores it in the variable called control. This call is
non-blocking; it returns without waiting for the host to send the data. The
data is delivered when the host client writes to control_channel. From the
time of the call to RTDX_readNB until the data is written to the variable
control, this channel is busy, and no additional requests can be posted on
this channel (that is, calls to RTDX_readNB do not succeed). During that
time, the call to RTDX_channelBusy returns TRUE for control_channel.
6.4
6-7
7) Right-click on the Statistics View area and choose Property Page from
the pop-up menu. Highlight the items shown here.
8) Click OK.
9) Resize the Statistics area to see the fields for the statistics you selected.
10) Right-click on the RTA Control Panel and choose Property Page from the
pop-up menu.
11) Set the Refresh Rate for Message Log/Execution Graph to 1 second and
the Refresh Rate for Statistics View/CPU Load Graph to 0.5 seconds.
Then click OK.
12) Choose ToolsRTDX.
13) Notice that RTDX is already enabled. This happened behind-the-scenes
in Step 2 when you opened a DSP/BIOS control. DSP/BIOS controls
configure and enable RTDX in continuous mode. In continuous mode,
RTDX does not record data received from the target in a log file (as it
does in non-continuous mode). This allows continuous data flow. (If your
program does not use DSP/BIOS, you can use the RTDX area to
configure and enable RTDX directly.)
6-8
14) Using the Windows Explorer, run loadctrl.exe, which is located in your
working folder. The Load Control window appears.
Each mark on the slider changes the load value by 50, or about 50,000
instructions.
This simple Windows application was written using Visual Basic and
RTDX. If you have Visual Basic, you can examine the source files for the
loadctrl.exe application stored in the c:\ti\c5400\tutorial\volume4\ folder.
This application uses the following RTDX functions:
Notice that processing_SWI occurs once every 10 time ticks (and PRD
ticks). PRD_swi runs once every 2 PRD ticks. The loadchange_PRD runs
within the context of PRD_swi. These are the expected execution
frequencies.
6-9
PRD statistics are measured in PRD ticks. SWI statistics are measured
in instruction cycles. The Max and Average fields for loadchange_PRD
show that there is less than a full PRD tick between the time this function
needs to start running and its completion. (The actual numbers shown
may vary.)
16) Use the Load Control window to gradually increase the processing load.
(If you move the slider in the Load Control window while the DSP program
is halted, the new load control values are buffered on the host by RTDX.
These have no effect until the DSP application runs again and calls
RTDX_readNB to request updated load values from the host.)
17) Repeat step 16 until you see the Max and Average values for
loadchange_PRD increase and blue squares appear in the Assertions
row of the Execution Graph. Assertions indicate that a thread is not
meeting its real-time deadline.
What is happening? The Max value for loadchange_PRD increases when you
increase the load beyond a certain point. With the increased load, the
processing_SWI takes so long to run that the loadchange_PRD cannot begin
running until long past its real-time deadline.
When you increase the load so much that the low-priority idle loop is no
longer executed, the host stops receiving real-time analysis data and the
DSP/BIOS plug-ins stop updating. Halting the target updates the plug-ins with
the queued data.
6-10
6.5
6-11
Things to Try
6.6
Click
Things to Try
To further explore DSP/BIOS, try the following:
When you increase the load, the Execution Graph shows that
processing_SWI requires more than one PRD tick to run. Does this mean
that processing_SWI is missing its real-time deadline? Recall that
processing_SWI must run every 10 milliseconds, while PRD ticks occur
every millisecond.
What would happen if the processing function were called directly from a
hardware ISR rather than being deferred to a software interrupt? That
would cause the program to miss its real-time deadline because
hardware ISRs run at higher priority than the highest priority SWI object.
Recall that when the load is high, PRD_swi needs to preempt
processing_SWI. If processing_SWI is a hardware interrupt, it cannot be
preempted by PRD_swi.
View the CPU Load Graph. Use the RTA Control Panel to turn the
statistics accumulators on and off. Notice that the CPU Load Graph
appears unaffected. This demonstrates that the statistics accumulators
place a very small load on the processor.
How much do the statistics accumulators affect the statistics for
processing_SWI? Watch the statistics view as you turn the statistics
accumulators on and off. The difference is a precise measurement of the
number of instructions each accumulator requires. Remember to
right-click and clear the statistics view to see the effect.
6-12
Add calls to STS_set and STS_delta in the loadchange function like the
ones you added in section 5.7, page 5-17. How does this change affect
Learning More
the CPU load? Now, add calls to STS_set and STS_delta in the dataIO
function. How does this change affect the CPU load? Why? Consider the
frequency at which each function is executed. Even small increases to
the processing requirements for functions that run frequently can have
dramatic effects on CPU load.
6.7
Learning More
To learn more about the software interrupt priorities and the RTDX and PRD
modules, see the online help and the TMS320C54x DSP/BIOS API
Reference Guide (which is provided as an Adobe Acrobat file).
6-13
6-14
Chapter 7
This chapter introduces RTDX and DSP/BIOS techniques for implementing I/O.
In this chapter, you connect a program to an I/O device using RTDX and
DSP/BIOS. You also use the HST, PIP, and SWI modules of the DSP/BIOS API.
This chapter requires a physical board and cannot be carried out using a
software simulator. Also, this chapter requires the DSP/BIOS and RTDX
components of Code Composer Studio.
Topic
Page
7.1
7.2
7.3
7.4
7.5
Modifying the Source Code to Use Host Channels and Pipes . . . 710
7.6
7.7
7.8
7.9
7-1
7.1
7-2
7.2
Three RTDX channels are declared globally. The first input channel
controls the volume. The second input channel receives the input
signal from the host. The output channel sends the output signal from
the target to the host. (Input and output channels are named from the
perspective of the target application: input channels receive data
from the host, and output channels send data to the host.)
The call to RTDX_write writes the contents of the buffer to the output
RTDX channel if the channel is enabled.
7-3
#include <std.h>
#include <log.h>
#include <rtdx.h>
#include "target.h"
#define BUFSIZE 64
#define MINVOLUME 1
typedef Int sample;
/* Global declarations */
sample inp_buffer[BUFSIZE];
sample out_buffer[BUFSIZE];
Int volume = MINVOLUME; /* the scaling factor for volume control */
/* RTDX channels */
RTDX_CreateInputChannel(control_channel);
RTDX_CreateInputChannel(A2D_channel);
RTDX_CreateOutputChannel(D2A_channel);
/* Objects created by the Configuration Tool */
extern LOG_Obj trace;
/*
* ======== main ========
*/
Void main()
{
sample *input = inp_buffer;
sample *output = out_buffer;
Uns size = BUFSIZE;
TARGET_INITIALIZE();
7-4
}
}
7-5
7.3
Test_ON. This routine runs when you click the Test_ON button. It creates
instances of the RTDX exported interface for the input channel (toDSP)
and for the output channel (fromDsp). Then it opens and enables both of
these channels. The channels in the signalprog.exe application are the
same channels declared globally in the hostio.c source code.
This routine also clears the graphs and starts the timer used to call the
Transmit_Signal and Receive_Signal functions.
These global declarations made earlier in the Visual Basic source code
connected the READ_CHANNEL and WRITE_CHANNEL used in the
Test_ON routine to the D2A_channel and A2D_channel used in hostio.c:
' Channel name constants
Const READ_CHANNEL = "D2A_channel"
Const WRITE_CHANNEL = "A2D_channel"
7-6
Test_OFF. This routine disables, closes, and releases the RTDX objects
created by Test_ON. It also disables the timer.
7.4
The slider.exe program must be started after RTDX is enabled and the
program is running because it creates and opens the RTDX control
channel when you run the program. If RTDX is not enabled at this point,
slider.exe cannot open the channel.
7-7
The signalprog.exe program can be started at any point. It does not use
RTDX until you click the Test On button.
9) Resize the signalprog window so that it is taller. This allows you to see
the axis labels.
10) Click Test On in the signalprog window. This starts the input and output
channels.
7-8
11) Slide the control in the Volume Slider window. This changes the volume
of the output signal. Watch the amplitude of the Received Signal graph
change. (Only the scale values to the left and right of the graph change.
The graph changes scale automatically to accommodate the size of the
sine wave and the size of the window.)
Note: Initial Setting of Volume Slider
The initial setting of the Volume Slider bar is not synchronized with the
application. They are synchronized the first time you move the slider bar.
12) Close the Volume Slider application. This stops the input and output
channels.
13) Click Test OFF in the signalprog window. This closes the control channel.
14) Click
15) You now see the hostio example started message from the call to
LOG_printf in the Message Log area. You did not see this message
earlier because the entire program runs within the main function.
DSP/BIOS communicates with the host PC within the idle loop. Until a
program returns from main, it never enters the idle loop. Therefore, if you
want to see the effects of DSP/BIOS calls at run-time, your program
should perform its functions after returning from main. The modified
version of hostio.c used in the next section shows this technique.
7-9
7.5
hostio.c. The source code has been modified to use the HST and
PIP modules of the DSP/BIOS API instead of RTDX to transfer the
input and output signals
2) Double-click on the hostio.c file in the Project View to see the source code
in the right half of the Code Composer Studio window. The source code
now contains the following differences from the source code used earlier
in this chapter:
/*
/*
*
*
*
*
*
*
Moved the input and output functionality from a while loop in the main
function to the A2DscaleD2A function.
7-10
7-11
7.6
7-12
7.7
7-13
mode. This property determines which end of the pipe the target
program manages, and which end the Host Channel Control plug-in
manages. An input channel sends data from the host to the target.
An output channel sends data from the target to the host.
framesize. This property sets the size of each frame in the channel.
Use 64 wordsthe same value as the BUFSIZE defined in section
7.2, page 7-3.
notify, arg0, arg1. These properties specify the function to run when
this input channel contains a full frame of data and the arguments to
pass to that function. The SWI_andn function provides another way
to manipulate a SWI objects mailbox.
In Chapter 5, you used the SWI_dec function to decrement the
mailbox value and run the SWI objects function when the mailbox
value reached zero.
The SWI_andn function treats the mailbox value as a bitmask. It
clears the bits specified by the second argument passed to the
function. So, when this channel contains a full frame (because the
target filled a frame), it calls SWI_andn for the A2DscaleD2A_SWI
object and causes it to clear bit 0 of the mailbox.
7-14
When this output channel contains an empty frame (because the target
read and released a frame), it uses SWI_andn to clear bit 1 of the
mailbox.
7-15
mailbox. This is the initial value of the mailbox for this object. The
input_HST object clears the first bit of the mask and the output_HST
object clears the second bit of the mask. When this object runs the
A2DscaleD2A function, the mailbox value is reset to 3.
arg0, arg1. The names of the two HST objects are passed to the
A2DscaleD2A function.
10) Choose FileClose. You are asked whether you want to save your
changes to hostio.cdb. Click Yes. Saving the configuration also generates
hostiocfg.cmd, hostiocfg.s54, and hostiocfg.h54.
7-16
7.8
5) Right-click on the input_HST channel and choose Bind from the pop-up
menu.
6) Select the input.dat file in your working folder and click Bind.
7) Right-click on the output_HST channel and choose Bind from the pop-up
menu.
8) Type output.dat in the File Name box and click Bind.
9) Right-click on the input_HST channel and choose Start from the pop-up
menu.
10) Right-click on the output_HST channel and choose Start from the pop-up
menu. Notice that the Transferred column shows that data is being
transferred.
11) When the data has been transferred, click
stop the program.
7.9
Learning More
To learn more about the RTDX, HST, PIP, and SWI modules, see the online
help or the TMS320C54x DSP/BIOS Users Guide (which is provided as an
Adobe Acrobat file).
7-17
7-18
Index
A
animating program 4-10
archiver 1-5
.asm file 1-16
assembler 1-5
assembly translator utility 1-5
assembly vs. C 5-7
assembly, viewing with C source
assertions 6-10
ATM module 1-10
2-12
B
bin folder 1-15
bios folder 1-15
breakpoint
creating 2-9
deleting 2-11
stepping from 2-10
building application 2-6
C
C compiler 1-5
.c file 1-16
C vs. assembly 5-7
C54 module 1-10
C54_A_DIR environment variable 1-17, 2-4
C54_C_DIR environment variable 1-17, 2-4
.cdb file 1-16
cdb file 3-3
cgtools folder 1-15
CLK module 1-10
manager properties 5-8
CLK_gethtime function 5-17
CLK_getltime function 5-20
clock
viewing 4-18
clock manager 5-8
clock, enabling 2-12
D
datatypes for DSP/BIOS 5-3
DEV module 1-10
development cycle 1-2
development flow diagram 1-4
directories 1-15
search path 2-4
docs folder 1-15
DOS environment space, increasing
drivers folder 1-15
DSP/BIOS
API modules 1-8
datatypes 5-3
header files 3-5
1-17
E
edit variable 2-11
enable clock 2-12
environment space
increasing 1-17
environment variables
C54_A_DIR 1-17
C54_C_DIR 1-17
PATH 1-17
Index-1
Index
EPROM programmer 1-5
examples folder 1-15
Execution Graph 5-10
explicit instrumentation 5-17
F
file I/O 4-7
file streaming 1-8
folders 1-15
search path 2-4
font, setting 2-4
function names 5-7
K
KNL_swi object
6-4
GEL
functions 4-15
gel folder 1-15
generated files 3-3
graph
clearing 4-9
viewing 4-9
H
.h file 1-16
halting program
at breakpoint 2-9
header files 3-5
hello1 example 2-2
hello2 example 3-2
hello.c 2-4, 3-4
hex conversion utility 1-5
Host Channel Control 7-17
host operation 5-20
hostio1 example 7-2
hostio2 example 7-10
hostio.c 7-3, 7-10
HST module 1-10, 7-10
creating object 7-13
HST_getpipe function 7-11
HWI module 1-10
object properties 5-8
M
mailbox value 5-9
main function 3-5
.mak file 1-16
MBX module 1-10
MEM module 1-11
Message Log 3-6
mixed source/ASM 2-12
mnemonic-to-algebraic assembly translator
utility 1-5
modules, list of 1-10
myprojects folder 1-15
naming conventions
new project 2-2
Index-2
1-6
5-7
Index
O
.obj file 1-16
object
editing properties 5-7
inserting 3-3
renaming 3-3
options
color 2-9, 4-13
font 2-4
options for project 2-7
.out file 1-16
P
PATH environment variable 1-17
performance monitoring 1-8
PIP module 1-11, 7-10
PIP_alloc function 7-11
PIP_free function 7-11
PIP_get function 7-11
PIP_getReaderAddr function 7-11
PIP_getReaderNumFrames function 7-11
PIP_getReaderSize function 7-11
PIP_getWriterAddr function 7-11
PIP_getWriterNumFrames function 7-11
PIP_put function 7-11
plug-ins
DSP/BIOS 1-8
RTDX 1-12
third party 1-14
plugins folder 1-15
PRD module 1-11
adding object 6-3
PRD_clock CLK object 6-4
PRD_swi object 6-4
PRD_tick function 6-4
preprocessor symbols 2-7
priorities of software interrupts 6-11
Probe Point
connecting 4-8
creating 4-6
profile clock 2-12
profile-point
creating 2-12
viewing statistics 2-13
program
loading onto target 2-6
running 2-6
program tracing 1-8
project
adding files 2-3
building 2-6
creating new 2-2
options 2-7
viewing files in 2-3
project management 1-7
properties
changing 5-7
viewing 5-6
Q
QUE module
1-11
R
Real-Time Data Exchange
See RTDX
real-time deadlines 5-12, 6-10
renaming an object 3-3
resetting DSP 2-5
RTDX
channel declaration 7-3
host interface 1-12
module 1-11
module, configuring 6-8, 7-7
plug-ins 1-12
rtdx folder 1-15
RTDX_channelBusy function 6-5, 7-3
RTDX_enableInput function 6-5, 7-4
RTDX_read function 7-3
RTDX_readNB function 6-5
RTDX_write function 7-3
rtdx.Close 6-9
rtdx.Open 6-9
rtdx.WriteI4 6-9
rts.lib 2-3
running 2-6
animation 4-10
to cursor 2-10
to main 5-10
running Code Composer Studio 2-2
runtime-support libraries 1-5
S
saving 2-8
search path 2-4
sectti utility 3-10
SEM module 1-11
signalprog.exe 7-6
simulator iii, 1-2
SIO module 1-11
slider.exe 7-7
source files
Index-3
Index
adding to project 2-3
mixed C/assembly view 2-12
starting Code Composer Studio 2-2
statistics
units 5-20, 6-10
viewing with profile-points 2-13
Statistics View 5-15
step commands 2-10
structure
watch variables 2-11
STS module 1-11
adding instrumentation 5-17
Statistics View 5-15
STS_delta function 5-17
STS_set function 5-17
SWI module 1-11
object properties 5-9
priorities 6-11
SWI_andn function 7-14
SWI_dec function 5-4
symbols, defining 2-7
syntax errors 2-8
SYS module 1-11
T
third party plug-ins 1-14
time/frequency graph 4-9
TRC module 1-11
TRC_query function 5-17
troubleshooting 2-5
TSK module 1-11
tutorial folder 1-15
Index-4
U
underscore 5-7
uninstall folder 1-15
USER0 tracing 5-18
utility folder (bin) 1-15
V
variables, editing 2-11
vectors.asm 2-3
view statistics 2-13
Visual Basic application
volume1 example 4-2
volume2 example 5-2
volume3 example 6-2
volume4 example 6-2
volume.c 4-4, 5-3, 6-5
W
watch variable
adding 2-9
changing value 2-11
removing 2-11
structures 2-11
.wks file 1-16
6-2