Introduction to Code Composer Studio 4

Code Composer
Studio V4
https://www.pantechsolutions.net/products/dsp-
dsc-boards/tms320c6745-tyro

Technology beyond the Dreams™ Copyright © 2014 Pantech Prolabs India Pvt Ltd.
Agenda
• Introduction of CCS4
• Starting a new project

Overview
• CCS 4 is the integrated development environment (IDE) for TI’s Digital Signal Processors
(DSP), microcontrollers and application processors.
• Source code editor
• Project environment
• Compiler
• Debugger
–Software (simulator)
–Hardware (emulator)
• Graph windows
• Image visualization
• Profiler
• Scripting capability
• Flash programmer

IDE: C/C++ Perspective
Project
view
Text
editor
Outline
view
Build
view
Problems
view
Perspectiv
e bar
Fast
view bar

IDE: Debug Perspective
Debug
view
Source
code editor
Register view /
watch view / etc
Graph
window
Memory
view

Agenda
• Compiling a project

Starting a project
 Select the workspace
 Defines the location of your project
 Automatically saved on close
 Contains:
 Project settings
 Macros
 Views on close
 Other custom settings specific for YOUR
personal computer
 Can be changed later on

New Project Wizard
• New projects are created by using the “New Project
Wizard:

New Project Wizard
• This will allow to select:
–The project type
• Processor used: e.g. C6000, C2000, etc…
–The configurations
• Default are
– Debug
– Release
–Referenced projects (if any)
–The used C/C++ indexer
• Full
• Fast
• None
–Output type
–A default linker command file
–Various project settings
• Device variant
• Code Generation tools version
• Runtime Support Library
• Target content
• etc

Adding Files
• There are two ways to add files to the project:
– Create a new source file
– Drop existing source files in the project directory
• All files in the directory of a project are automatically added to the project.
• Take care that you are not adding unwanted content!

C Language Symbols
• Files are automatically parsed and variables, declaration and definitions displayed.
These can be accessed from the outline view or from the project view

Importing an Existing Project
• Accessed from
• You can import a single project or multiple projects in one step:
This will also give you the
opportunity to copy the
projects into your workspace

Importing a CCS 3.3 Project
• The CCS 3.3 import wizard is called from:
• This will help you to import the existing project, but manual re-work might still be
required
– Change or add path names for library functions
• Note: CCS 3.1 and CCS 2.x projects cannot be imported automatically. They need to be
converted to a CCS 3.3 project first (using CCS 3.3)

Agenda
• Building a project

Compile Flow
• You can either write standard assembly directly, or it can be created by the compiler.
• Object files, created by the assembler, are linked together to create the executable output file
of the processor. The map file is an output report of the linker.
• The .out file can be loaded into your system by the debugger portion of CCS.

Build Configurations
• By default, CCS includes two sets of build options:
– Debug
– Release
• Users can create any number of additional build configurations.
• Users can modify the settings of any pre-defined build option

Build Options
• Build options are controlled by the “Properties” dialog
of the project:

Compiler: Basic Options

Compiler: Include Options

Linker: Basic Options
Note:
The stack size field is empty by default, causing a linker warning during build (but the default size of
0x400 will be used). Also, the default linker command file does not include the stack settings, so you
need to set it here!

Linker: File Search Path

Linker: Linker Output

Linker: Runtime Environment

CCS Build: General

Finally, the Actual Build
There are a couple of ways to build the project:
– Use the menu bar:
– Use the drop-down menu:

Build: The Differences
• Build Active Project
– Builds only the active project
– Compiles only new or changed files (incremental build)
• Rebuild Active Project
– Builds only the active project
– Compiles all files, independently of their state
• Build All
– Builds all projects in the workspace
• Rebuild All
– Rebuilds all projects in the workspace
• Build Project
– The same as “Build Active Project”
• Build Working Set
– Build a pre-defined set of projects
• Clean
– Cleans a defined set of projects
• Build Automatically
– Builds automatically once a changed file is saved

Build: One Last Way
• Clicking will build the active project, switch to the debug perspective and load the
executable.
• This will work only if a valid target configuration is loaded.
• If CCS is already in the debug perspective, the project will be recompiled and the
executable loaded.

CCS Debug Options

Debugging a Project
• Once all source files are added to the project and
all project settings are made, the project can be
debugged.
• But, before we can do that, a target description
(aka a target configuration is needed)

Creating the Target
Configuration

Debugging a Program
Run (F8) / Run Low Power / Free Run
Halt program
Terminate debug session. This will switch back to the C/C++ perspective (CTRL+ALT+T)
Step into (F5)
Step over (F6)
Assembly step into
Assembly step over
Step return (F7)
Reset CPU (ALT+R) / Reset Emulator
Restart (ALT+F8)

IDE: Debug Perspective
Debug
view
Source
code
editor
Register view /
watch view / etc
Graph
window
Memory
view

Breakpoints
• Breakpoints can be set in two ways:
–Double clicking in the grey bar at the left side of
the file view
–Right-clicking on the line where the breakpoint
should be located and selecting “New
Breakpoint”
• Breakpoints can be viewed and manipulated
(and if needed added) in the “Breakpoint
View”

Disassembly View
• Opened by selecting
“View  Disassembly
• Shows:
–Address
–Opcode
–Disassembly
• Can be customized
• Can be shown
–Always
–Only if no C-source code is available
• Can also be used to set breakpoints

Watch Views
• Local variables are displayed automatically
• Other watch expressions can be added easily
• Expressions can be a global or a local variable or logical / arithmetic expressions using them (or
use it as a quick calculator)
• Additional watch views can be added and the display can be customized

Memory View
• This view can be opened by
“View  Memory”
• Displays the contents of the memory at a certain
address
–If variables are used to set the address the ‘&’ operator
needs to be used unless the variable is an array.
• Memory contents can be displayed in several ways:
–Floating point
–Integer
–Hexadecimal (TI and C style)
–Binary
–Character
–8/16/32/40/64 bit
• The memory view also allows to save, load and fill
memory
• Several memory views can be open simultaneously

Register View
• Opened from “View  Registers”
• One window will display all the register sets
• Multiple register windows can be opened at
any time
• Registers can be manipulated from this view
• Two different views are available:
–Tree (default)
–Grid (with a selectable number of grids)
• Registers can be copied individually or as
complete set

Graph View
• Can be accessed from
Tools  Graph
• Time-Domain
–Single / Dual
• Different update modes:
–Manual
–Refresh on halt
–Continuous refresh
• Display can be customized
–Line style
–Grid
–etc.
• If in continuous refresh mode, the update interval can be set in the
local menu of the Watch View 
• Data can be exported

Image Analyzer
• Can be accessed from
Tools  Image Analyzer
• Image Format
–RGB
–Bayer
–YUV
–Bitonal

Sections
short m = 10;
short x = 2;
short b = 5;
main()
{
short y = 0;
y = m * x;
y = y + b;
printf("y=%d",y);
}
 Every C program
consists of different
parts called Sections
 All default section
names begin with "."
Let’s review the
list of compiler
sections…
Global Vars (.bss) Init Vals (.cinit)
Local Vars
(.stack)
Code
(.text)
Std C
I/O
(.cio)

DDR2
C000_0000
FLASH
6000_0000
CS2
C6000
CPU
Internal
RAM
Where would
you place
each of these
sections?
Section Location Why
.text FLASH Must exist after reset
.cinit
.bss
.stack
.cio
Initialize
d
Memory

Where would
you place
each of these
sections?
.cinit FLASH Must exist after reset
.bss
.stack
.cio
DDR2
C000_0000
FLASH
6000_0000
CS2
C6000
CPU
Internal
RAM
Initialize
d
Memory

Where would
you place
each of these
sections?
.bss Internal Must be in RAM memory
.stack
.cio
DDR2
C000_0000
FLASH
6000_0000
CS2
C6000
CPU
Internal
RAM
Initialize
d
Memory

Where would
you place
each of these
sections?
.stack Internal Must be in RAM memory
.cio
DDR2
C000_0000
FLASH
6000_0000
CS2
C6000
CPU
Internal
RAM
Initialize
d
Memory

Where would
you place
each of these
sections?
.stack Internal Must be in RAM memory
.cio DDR2 Needs RAM, speed not critical
Initialize
d
Memory
Looking at all of the compiler generated sections ...
DDR2
C000_0000
FLASH
6000_0000
CS2
C6000
CPU
Internal
RAM
Initialize
d
Memory

Compiler's Section Names
Section
Name Description Memory
Type
.text Code initialized
.switch Tables for switch instructions initialized
.const Global and static string literals initialized
.cinit Initial values for global/static vars initialized
.pinit Initial values for C++ constructors initialized
.bss Global and static variables uninitialized
.far Aggregates (arrays & structures) uninitialized
.stack Stack (local variables) uninitialized
.sysmem Memory for malloc fcns (heap) uninitialized
.cio Buffers for stdio functions uninitialized
Compiler's Section Names

Linking
Linker
Linker.cmd
.map
.obj .out
 H/W Memory Description
• Name, location, length
• Ex: IRAM, origin = …, len = …
 S/W Sections
• Name, memory area to link to
• Ex: .far → IRAM

Linker Command File
-l rts6400.lib
-stack 0x800
-heap 0x800
MEMORY {
IRAM: origin = 0x11800000, len = 0x40000
FLASH: origin = 0x64000000, len = 0x400000
DDR: origin = 0xC0000000, len = 0x8000000
}
SECTIONS {
.bss {} > IRAM
.far {} > IRAM
.text {} > DDR
.cinit {} > FLASH
}
LIBRARIES
STACK/HEAP SIZES
MEMORY AREAS
CODE/DATA SECTIONS

CCS GEL File
 The GEL script runs every time you connect to your target (C6748.gel).
 This script sets up the target environment:
• Mem Map • Core Freq
• DDR
• EMIF
• PINMUX
• PLL0
• PLL1
OnTargetConnect( )
{
Clear_Memory_Map();
Setup_Memory_Map();
Core_300MHz_mDDR_132MHz();
}
Setup_Memory_Map()
{
/* DSP */
GEL_MapAddStr( …); //DSP L2 ROM
GEL_MapAddStr( … ); //DSP l2 RAM
GEL_MapAddStr( … ); //DSP L1P RAM
Set_Core_300MHz();
Set_mDDR_132MHz();
Runs at “Connect To Target” .GEL Snippets

Build Steps : CCS/Debug vs FLASH
CCS: Project / Build
file.out
CCS: File / Ld Pgm
CCS: Project / Build
file.out
SPIWriter.OUT
DDR2
AISgen
file.bin
AISgen.cfg
SPIWriter.cmd
L1, L2, L3
SPI Flash
DDR2
eXperimenters
Board
L1, L2, L3
Flash
C6748.gel
CCS forces
entry pt
to _c_int00
User specifies
Entry point
CCS FLASH
eXperimenters
Board

Relationship Diagram-Graphical
Programming
• The relationship between MATLAB, CCS and a Texas
Instruments DSP is shown below:
RTDX - Real-Time Data Exchange
MATLAB
Code Composer Studio
(CCS)
Texas Instruments DSP
Embedded
Target for
Texas
Instruments
DSP
+ Real-Time
Workshop

RTDX Image Processing Example
• A bitmap
image file is
sent from PC
to the DSP.
• The output of
processing by
the DSP is
sent to the PC
display.

?

For more details
– www.pantechsolutions.net
– http://www.slideshare.net/pantechsolutions
– http://www.scribd.com/pantechsolutions
– http://www.youtube.com/pantechsolutions

Introduction to Code Composer Studio 4

More Related Content

What's hot

Viewers also liked

Similar to Introduction to Code Composer Studio 4

More from Pantech ProLabs India Pvt Ltd

Recently uploaded

Introduction to Code Composer Studio 4

Editor's Notes