Embedded IDE Link™ CC

ticcs - Create object that refers to CCS IDE

Syntax

cc = ticcs cc = ticcs('propertyname','propertyvalue',...)

Description

cc = ticcs returns a ticcs object in cc that MATLAB^® software uses to communicate with the default processor. In the case of no input arguments, ticcs constructs the object with default values for all properties. CCS IDE handles the communications between MATLAB software and the selected CPU. When you use the function, ticcs starts CCS IDE if it is not running. If ticcs opened an instance of the CCS IDE when you issued the ticcs function, CCS IDE becomes invisible after Embedded IDE Link™ CC creates the new object.

Note When ticcs creates the object cc, it sets the working directory for CCS IDE to be the same as your MATLAB software working directory. When you create files or projects in CCS IDE, or save files and projects, this working directory affects where you store the files and projects.

Each object that accesses CCS IDE comprises two objects — a ticcs object and an rtdx object — that include the following properties.

Object	Property Name	Property	Default	Description
`ticcs`	`'apiversion'`	API version	N/A	Defines the API version used to create the link
	`'proctype'`	Processor Type	N/A	Specifies the kind of processor on the target board
	`'procname'`	Processor Name	CPU	Name given to the processor on the board to which this object links
	`'status'`	Running	No	Status of the program currently loaded on the processor
	`'boardnum'`	Board Number	0	Number that CCS assigns to the board. Used to identify the board
	`'procnum'`	Processor number	0	Number the CCS assigns to a processor on a board
	`'timeout'`	Default time-out	10.0 s	Specifies how long MATLAB software waits for a response from CCS after issuing a request. This also applies when you try to construct a `ticcs` object. The create process waits for this time-out period for the connection to the target to complete. If the time-out period expires, you get an error message that the connection to the target failed and MATLAB software could not create the `ticcs` object.
`rtdx`	`'timeout'`	Time-out	10.0 s	Specifies how long CCS waits for a response from the processor after requesting data
`rtdx`	`'numchannels'`	Number of open channels	0	The number of open channels using this link
`type`	`type`	Defined types in the object	`Void, Float, Double, Long, Int, Short, Char`	List of the C data types in the project `cc` accesses. Use `add` to include your C type definitions to the list

cc = ticcs('propertyname','propertyvalue',...) returns a handle in cc that MATLAB software uses to communicate with the specified processor. CCS handles the communications between the MATLAB environment and the CPU.

MATLAB software treats input parameters to ticcs as property definitions. Each property definition consists of a property name/property value pair.

Two properties of the ticcs object are read only after you create the object:

'boardnum' — the identifier for the installed board selected from the active boards recognized by CCS. If you have one board, use the default property value 0 to access the board.
'procnum' — the identifier for the processor on the board defined by boardnum. On boards with more than one processor, use this value to specify the target processor on the board. On boards with one processor, use the default property value 0 to specify the processor.

Given these two properties, the most common forms of the ticcs method are

cc = ticcs('boardnum',value)
cc = ticcs('boardnum',value,'procnum',value)
cc = ticcs(...,'timeout',value)

which specify the target board, and processor in the second example, as the target.

The third example adds the timeout input argument and value to allow you to specify how long MATLAB software waits for the connection to the target or the response to a command to return completed.

Note The output (left-hand argument) object name you provide for ticcs cannot begin with an underscore, such as _cc.

You do not need to specify the boardnum and procnum properties when you have one board with one processor installed. The default property values refer correctly to the processor on the board.

Note Simulators count as boards. If you defined both boards and simulators in CCS IDE, specify the boardnum and procnum properties to connect to specific boards or simulators. Use ccsboardinfo to determine the values for the boardnum and procnum properties of your boards and simulators.

Because these properties are read only after you create the handle, you must set these property values as input arguments when you use ticcs. You cannot change these values after the handle exists. After you create the handle, use the get function to retrieve the boardnum and procnum property values.

Using ticcs with Multiple Processor Targets

When you create ticcs objects that access targets that contain more than one processor, such as the OMAP1510 platform, ticcs behaves a little differently.

For each of the ticcs syntaxes above, the result of the method changes in the multiple processor case, as follows.

cc = ticcs
cc = ticcs('propertyname',propertyvalue)
cc = ticcs('propertyname',propertyvalue,'propertyname',... 
propertyvalue)

In the case where you do not specify a board or processor:

cc = ticcs
Array of TICCS Objects:
 API version             : 1.2
 Board name              : OMAP 3.0 Platform Simulator [Texas 
Instruments]
 Board number            : 0
 Processor 0 (element 1): TMS470R2127 (MPU, Not Running)
 Processor 1 (element 2): TMS320C5500 (DSP, Not Running)

Where you choose to identify your target as an input argument to ticcs, for example, when your target board contains two processors:

cc = ticcs('boardnum',2)
Array of TICCS Objects:
 API version             : 1.2
 Board name             : OMAP 3.0 Platform Simulator [Texas Instruments]
 Board number            : 2
 Processor 0 (element 1) : TMS470R2127 (MPU, Not Running)
 Processor 1 (element 2) : TMS320C5500 (DSP, Not Running)

cc returns a two element object handle with cc(1) corresponding to the first processor and cc(2) corresponding to the second.

You can include both the board number and the processor number in the ticcs syntax, as shown here:

cc = ticcs('boardnum',2,'procnum',[0 1])
Array of TICCS Objects:
 API version           : 1.2
 Board name            : OMAP 3.0 Platform Simulator [Texas 
Instruments]
 Board number          : 2
 Processor 0 (element 1) : TMS470R2127 (MPU, Not Running)
 Processor 1 (element 2) : TMS320C5500 (DSP, Not Running)

Enter procnum as either a single processor on the board (a single value in the input arguments to specify one processor) or a vector of processor numbers, as shown in the example, to select two or more processors.

Support Coemulation and OMAP

Coemulation, defined by Texas Instruments™ to mean simultaneous debugging of two or more CPUs, allows you to coordinate your debugging efforts between two or more processors within one device. Efficient development with OMAP™ hardware requires coemulation support. Instead of creating one cc object when you issue the following command

cc = ticcs

or your target that has multiple processors, the resulting cc object comprises a vector of cc objects cc(1), cc(2), and so on, each of which accesses one processor on your target device, say an OMAP1510. When your target has one processor, cc is a single object. With a multiprocessor target, the cc object returns the new vector of objects. For example, for board 2 with two processors,

cc = ticcs

returns the following information about the board and processors:

cc = ticcs('boardnum',2)
Array of TICCS Objects:
API version              : 1.2
 Board name               : OMAP 3.0 Platform Simulator [Texas 
Instruments]
 Board number             : 2
 Processor 0  (element 1) : TMS470R2127 (MPU, Not Running)
 Processor 1  (element 2) : TMS320C5500 (DSP, Not Running)

Checking the existing boards shows that board 2 does have two processors:

ccsboardinfo

Board Board                             Proc Processor    Processor
Num   Name                              Num  Name         Type
 ---  ----------------------------------  ---  ---------------
2    OMAP 3.0 Platform Simulator [T ... 0    MPU          TMS470R2x
2    OMAP 3.0 Platform Simulator [T ... 1    DSP          TMS320C550
1    MGS3 Simulator [Texas Instruments] 0    CPU          TMS320C5500
0    ARM925 Simulator [Texas Instru ... 0    CPU          TMS470R2x

Examples

On a system with three boards, where the third board has one processor and the first and second boards have two processors each, the following function:

cc = ticcs('boardnum',1,'procnum',0);

returns an object that accesses the first processor on the second board. Similarly, the function

cc = ticcs('boardnum',0,'procnum',1);

returns an object that refers to the second processor on the first board.

To access the processor on the third board, use

cc = ticcs('boardnum',2);

which sets the default property value procnum= 0 to connect to the processor on the third board.