ccsboardinfo - Information about boards and simulators known to IDE

Syntax

IDEs

This function supports the following IDEs:

• Texas Instruments Code Composer Studio v3

Description

ccsboardinfo returns configuration information about each board and processor installed and recognized by CCS. When you issue the function, ccsboardinfo returns the following information about each board or simulator.

Installed Board Configuration Data	Configuration Item Name	Description
Board number	boardnum	The number CCS assigns to the board or simulator. Board numbering starts at 0 for the first board. You also use boardnum when you create a link to the IDE.
Board name	boardname	The name assigned to the board or simulator. Usually, the name is the board model name, such as TMS320C67xx evaluation module. If you are using a simulator, the name tells you which processor the simulator matches, such as C67xx simulator. If you renamed the board during setup, this item displays the board name.
Processor number	procnum	The number assigned by CCS to the processor on the board or simulator. When the board contains more than one processor, CCS assigns a number to each processor, numbering from 0 for the first processor on the first board. For example, when you have two boards, the first processor on the first board is procnum=0, and the first and second processors on the second board are procnum=1 and procnum=2. You also use this property when you create a link to the IDE.
Processor name	procname	Provides the name of the processor. Usually the name is CPU, unless you assign a different name.
Processor type	proctype	Gives the processor model, such as TMS320C6x1x for the C6xxx series processors.

Each row in the table that you see displayed represents one digital signal processor, either on a board or simulator. As a consequence, you use the information in the table in the function ticcs to identify a selected board in your PC.

boards = ccsboardinfo returns the configuration information about your installed boards in a slightly different manner. Rather return the table of the information, the method returns a list of board names and numbers. In that list, each board has an structure named proc that contains processor information. For example

boards = ccsboardinfo

returns

boards = 

      name: 'C6xxx Simulator (Texas Instruments)'
    number: 0
      proc: [1x1 struct]

where the structure proc contains the processor information for the C6xxx simulator board:

boards.proc

ans = 

      name: 'CPU'
    number: 0
      type: 'TMS320C6200'

Reviewing the output from both function syntaxes shows that the configuration information is the same.

To connect with a specific board when you create an IDE handle object, combine this syntax with the dot notation for accessing elements in a structure. Use the boardnum and procnum properties in the boards structure. For example, when you enter

boards = ccsboardinfo;

boards(1).name returns the name of your second installed board and boards(1).proc(2).name returns the name of the second processor on the second board. To create a link to the second processor on the second board, use

IDE_Obj = ticcs('boardnum',boards(1).number,'procnum',... 
boards(1).proc(2).name);

Examples

On a PC with both a simulator and a DSP Starter Kit (DSK) board installed,

ccsboardinfo

returns something like the following table. Your display may differ slightly based on what you called your boards when you configured them in CCS Setup Utility:

Board Board                        Proc Processor  Processor
Num  Name                          Num  Name       Type
---  ----------------------------------  ---  ---------------
1  C6xxx Simulator (Texas Instrum ..0   CPU        TMS320C6200
0  DSK (Texas Instruments)          0   CPU_3      TMS320C6x1x

When you have one or more boards that have multiple CPUs, ccsboardinfo returns the following table, or one like it:

Board Board                       Proc Processor     Processor
Num  Name                         Num  Name          Type
--  ----------------------------------  ---  -------------------
2  C6xxx Simulator (Texas Instrum .0   CPU            TMS320C6200
1  C6xxx EVM (Texas Instrum ...    1   CPU_Primary    TMS320C6200
1  C6xxx EVM (Texas Instrum ...    0   CPU_Secondary  TMS320C6200
0  C64xx Simulator (Texas Instru...0   CPU            TMS320C64xx

In this example, board number 1 returns two defined CPUs: CPU_Primary and CPU_Secondary. The C6xxx does not in fact have two CPUs; a second CPU is defined for this example.

To demonstrate the syntax boards = ccsboardinfo, this example assumes a PC with two boards installed, one of which has three CPUs.

Enter the following command:

ccsboardinfo

This command generates a list of boards. For example:

Board Board                       Proc Processor Processor
Num  Name                         Num  Name      Type
 ---  ----------------------------------  ---  ------------
1  C6xxx Simulator (Texas Instrum .0   CPU       TMS320C6211
0  C62xx DSK (Texas Instruments)   2   CPU_3     TMS320C6x1x
0  C62xx DSK (Texas Instruments)   1   CPU_4_1   TMS320C6x1x
0  C62xx DSK (Texas Instruments)   0   CPU_4_2   TMS320C6x1x

Now enter

boards = ccsboardinfo

MATLAB software returns

boards=
2x1 struct array with fields
    name
    number
    proc

showing that you have two boards in your PC.

Use the dot notation to determine the names of the boards:

boards.name

returns

ans=
C6xxx Simulator (Texas Instruments)

ans=
C62xx DSK (Texas Instruments)

To identify the processors on each board, again use the dot notation to access the processor information. You have two boards (numbered 0 and 1). Board 0 has three CPUs defined for it. To determine the type of the second processor on board 0 (the board whose boardnum = 0), enter

boards(2).proc(1)

which returns

ans=
     name: 'CPU_3'
     number: 1
     type: 'TMS320C6x1x'

Recall that

boards(2).proc

gives you this information about the board

ans=
3x1 struct array with fields:
    name
    number
    type

indicating that this board has three processors (the 3x1 array).

The dot notation is useful for accessing the contents of a structure when you create a link to the IDE. When you use ticcs to create your CCS link, you can use the dot notation to tell the IDE which processor you are using.

IDE_Obj = ticcs('boardnum',boards(1).proc(1))

See Also

info | ticcs

© 1984-2012- The MathWorks, Inc.    -   Site Help   -   Patents   -   Trademarks   -   Privacy Policy   -   Preventing Piracy   -   RSS