Getting Started with RTDX :: Automation Interface (Embedded IDE Link™ CC)

Embedded IDE Link™ CC

Getting Started with Automation Interface

Getting Started with RTDX

On this page…
Introducing the Tutorial for Using RTDX Creating the ticcs Objects Configuring Communications Channels Running the Application Closing the Connections and Channels or Cleaning Up Listing the Functions for Embedded IDE Link CC software

On this page…

Introducing the Tutorial for Using RTDX

Creating the ticcs Objects

Configuring Communications Channels

Running the Application

Closing the Connections and Channels or Cleaning Up

Listing the Functions for Embedded IDE Link CC software

Embedded IDE Link CC and the objects for CCS IDE and RTDX speed and enhance your ability to develop and deploy digital signal processing systems on Texas Instruments processors. By using MATLAB software and Embedded IDE Link CC, your MathWorks™ tools, CCS IDE and RTDX work together to help you test and analyze your processing algorithms in your MATLAB software workspace.

In contrast to CCS IDE, using links for RTDX lets you interact with your process in real time while it's running on the processor. Across the connection between MATLAB software and CCS, you can:

Send and retrieve data from memory on the processor
Change the operating characteristics of the program
Make changes to algorithms as needed without stopping the program or setting breakpoints in the code

Enabling real-time interaction lets you more easily see your process or algorithm in action, the results as they develop, and the way the process runs.

This tutorial assumes you have Texas Instruments' Code Composer Studio™ software and at least one DSP development board. You can use the hardware simulator in CCS IDE to run this tutorial. The tutorial uses the TMS320C6711 DSK as the board, with the C6711 DSP as the processor.

After you complete the tutorial, either in the demonstration form or by entering the functions along with this text, you are ready to begin using RTDX with your applications and hardware.

Introducing the Tutorial for Using RTDX

Digital signal processing development efforts begin with an idea for processing data; an application area, such as audio or wireless communications or multimedia computing; and a platform or hardware to host the signal processing. Usually these processing efforts involve applying strategies like signal filtering, compression, and transformation to change data content; or isolate features in data; or transfer data from one form to another or one place to another.

Developers create algorithms they need to accomplish the desired result. Once they have the algorithms, they use models and DSP processor development tools to test their algorithms, to determine whether the processing achieves the goal, and whether the processing works on the proposed platform.

Embedded IDE Link CC and the links for RTDX and CCS IDE ease the job of taking algorithms from the model realm to the real world of the processor on which the algorithm runs.

RTDX and links for CCS IDE provide a communications pathway to manipulate data and processing programs on your processor. RTDX offers real-time data exchange in two directions between MATLAB software and your processor process. Data you send to the processor has little effect on the running process and plotting the data you retrieve from the processor lets you see how your algorithms are performing in real time.

To introduce the techniques and tools available in Embedded IDE Link CC for using RTDX, the following procedures use many of the methods in the link software to configure the processor, open and enable channels, send data to the processor, and clean up after you finish your testing. Among the functions covered are:

Functions From Objects for CCS IDE

Function	Description
`ticcs`	Create connections to CCS IDE and RTDX.
`cd`	Change your CCS IDE working directory from MATLAB software.
`open`	Load program files in CCS IDE.
`run`	Run processes on the processor.

Functions From the RTDX Class

Function	Description
`close`	Close the RTDX links between MATLAB software and your processor.
`configure`	Determine how many channel buffers to use and set the size of each buffer.
`disable`	Disable the RTDX links before you close them.
`display`	Return the properties of an object in formatted layout. When you omit the closing semicolon on a function, `disp` (a built-in function) provides the default display for the results of the operation.
`enable`	Enable open channels so you can use them to send and retrieve data from your processor.
`isenabled`	Determine whether channels are enabled for RTDX communications.
`isreadable`	Determine whether MATLAB software can read the specified memory location.
`iswritable`	Determine whether MATLAB software can write to the processor.
`msgcount`	Determine how many messages are waiting in a channel queue.
`open`	Open channels in RTDX.
`readmat`	Read data matrices from the processor into MATLAB software as an array.
`readmsg`	Read one or more messages from a channel.
`writemsg`	Write messages to the processor over a channel.

This tutorial provides the following workflow to show you how to use many of the functions in the links. By performing the steps provided, you work through many of the operations yourself. The tutorial follows the general task flow for developing digital signal processing programs through testing with the links for RTDX.

Within this set of tasks, numbers 1, 2, and 4 are fundamental to all development projects. Whenever you work with MATLAB software and objects for RTDX, you perform the functions and tasks outlined and presented in this tutorial. The differences lie in Task 3. Task 3 is the most important for using Embedded IDE Link CC to develop your processing system.

Create an RTDX link to your desired processor and load the program to the processor.
All projects begin this way. Without the links you cannot load your executable to the processor.
Configure channels to communicate with the processor.
Creating the links in Task 1 did not open communications to the processor. With the links in place, you open as many channels as you need to support the data transfer for your development work. This task includes configuring channel buffers to hold data when the data rate from the processor exceeds the rate at which MATLAB software can capture the data.
Run your application on the processor. You use MATLAB software to investigate the results of your running process.
Close the links to the processor and clean up the links and associated debris left over from your work.
Closing channels and cleaning up the memory and links you created ensures that CCS IDE, RTDX, and Embedded IDE Link CC are ready for the next time you start development on a project.

This tutorial uses an executable program named rtdxtutorial_6xevm.out as your application. When you use the RTDX and CCS IDE links to develop your own applications, replace rtdxtutorial_6xevm.out in Task 3 with the filename and path to your digital signal processing application.

You can view the tutorial M-file used here by clicking rtdxtutorial. To run this tutorial in MATLAB software, click run rtdxtutorial.

Note To be able to open and enable channels over a link to RTDX, the program loaded on your processor must include functions or code that define the channels.

Your C source code might look something like this to create two channels, one to write and one to read.

rtdx_CreateInputChannel(ichan); % processor reads from this. 
rtdx_CreateOutputChannel(ochan); % processor writes to this.

These are the entries we use in int16.c (the source code that generates rtdxtutorial_6xevm.out) to create the read and write channels.

If you are working with a model in Simulink software and using code generation, use the To Rtdx and From Rtdx blocks in your model to add the RTDX communications channels to your model and to the executable code on your processor.

One more note about this tutorial. Throughout the code we use both the dot notation (direct property referencing) to access functions and link properties and the function form.

For example, use the following command to open and configure ichan for write mode.

cc.rtdx.open('ichan','w');

You could use an equivalent syntax, the function form, that does not use direct property referencing.

open(cc.rtdx,'ichan','w');

Or, use

open(rx,'ichan','w');

if you created an alias rx to the RTDX portion of cc, as shown by the following command:

rx = cc.rtdx;

Creating the ticcs Objects

With your processing model converted to an executable suitable for your desired processor, you are ready to use the objects to test and run your model on your processor. Embedded IDE Link CC and the objects do not distinguish the source of the executable — whether you used Embedded IDE Link CC and Real-Time Workshop, CCS IDE, or some other development tool to program and compile your model to an executable does not affect the object connections. So long as your ..out file is acceptable to the processor you select, Embedded IDE Link CC provides the connection to the processor.

Note Program rtdxtutorial_6xevm.out processors the C6711 DSK We compiled, built, and linked the program as an executable to run on the C6711 processor. To use the tutorial without changes, processor your C6711 DSK when you define properties boardnum and procnum.

Before continuing with this tutorial, you must load a valid GEL file to configure the EMIF registers of your processor and perform any required processor initialization steps. Default GEL files provided by CCS are stored in ..\cc\gel in the folder where you installed CCS software. Select File > Load_GEL in CCS IDE to load the default GEL file that matches your processor family, such as init6x0x.gel for the C6x0x processor family, and your configuration.

Begin the process of getting your model onto the processor by creating a link to CCS IDE. Start by clearing all existing handles and setting echo on so you see functions in the M-file execute as the program runs:

clear all; echo on;
clear all has the side effect of removing debugging breakpoints and resetting persistent variables because function breakpoints and persistent variables are cleared whenever the M-file changes or is cleared. Breakpoints within your executable remain after clear. Clearing the MATLAB software workspace does not affect your executable.
Now construct the link to your board and processor by entering
```
cc=ticcs('boardnum',0);
```
boardnum defines which board the new link accesses. In this example, boardnum is 0. Embedded IDE Link CC connects the link to the first, and in this case only, processor on the board. To find the boardnum and procnum values for the boards and simulators on your system, use ccsboardinfo. When you enter the following command at the prompt
```
ccsboardinfo
```
Embedded IDE Link CC returns a list like the following one that identifies the boards and processors in your computer.
Board
Board
Proc
Processor
Processor

Num
Name
Num
Name
Type

1
C6xxx Simulator (Texas Inst...
0
CPU
TMS320C6211

0
C6701 EVM (Texas Instruments)
0
CPU_1
TMS320C6701

To open and load the processor file, change the path for MATLAB software to be able to find the file.

projname =

C:\Temp\LinkForCCSDemos_3.2\rtdxtutorial\c6x\c64xp\rtdxtut_sim.pjt


outFile =

C:\Temp\LinkForCCSDemos_v3.2\rtdxtutorial\c6x\c64xp\rtdxtut_sim.out

processor_dir = demoPjt.DemoDir 

processor_dir =

C:\Temp\LinkForCCSDemos_v3.2\rtdxtutorial\c6x\c64xp


% Go to processor directory
cd(cc,processor_dir);cd(cc,tgt_dir); % Or cc.cd(tgt_dir)
dir(cc); % Or cc.dir

To load the appropriate project file to your processor, enter the following commands at the MATLAB software prompt. getDemoProject is a specialized function for loading Embedded IDE Link CC demo files. It is not supported as a standard Embedded IDE Link CC function.

demoPjt = getDemoProject(cc,'ccstutorial');
demoPjt = 

          isLibProj: 0
    TemplateProject: 'C:\Temp\LinkForCCSDemos_v3.2\template\c6x\c64x.pjt'
            DemoDir: 'C:\Temp\LinkForCCSDemos_v3.2\ccstutorial\c6x\c64xp'
        ProjectFile: 'C:\Temp\LinkForCCSDemos_v3.2\ccstutorial\c6x\c64xp\ccstut.pjt'
        ProgramFile: 'C:\Temp\LinkForCCSDemos_v3.2\ccstutorial\c6x\c64xp\ccstut.out'
            SrcFile: {'$matlabroot\toolbox\ccslink\ccsdemos\ccstutorial\ccstut.c'}
            LibFile: ''
            CmdFile: {'$matlabroot\toolbox\ccslink\ccsdemos\shared\c6x\c64p.cmd'}
            HdrFile: ''
          BuildOpts: [1x1 struct]
      ProjectAction: 'recreateProj-rebuildProg'
        RebuildDemo: 1


demoPjt.ProjectFile

ans =

C:\Temp\LinkForCCSDemos_v3.2\ccstutorial\c6x\c64xp\ccstut.pjt


demoPjt.DemoDir

ans =

C:\Temp\LinkForCCSDemos_v3.2\ccstutorial\c6x\c64xp

Notice where the demo files are stored on your machine. In general, Embedded IDE Link CC software stores the demo project files in

LinkforCCS_vproduct_version

For example, if you are using version 3.2 of Embedded IDE Link CC software, the project demos are stored in LinkforCCS_v3.2\. Embedded IDE Link CC software creates this directory in a location on your machine where you have write permission. Usually, there are two locations where Embedded IDE Link CC software tries to create the demo directory, in the order shown.

In a temporary directory on the C drive, such as C:\temp\.
If Embedded IDE Link CC software cannot use the temp directory, you see a dialog box that asks you to select a location to store the demos.

You have reset the directory path to find the tutorial file. Now open the .out file that matches your processor type, such as rtdxtutorial_c67x.out or rtdxtutorial_c64x.out.
```
cc.open('rtdxtutorial_67x.out')
```
Because open is overloaded for the CCS IDE and RTDX links, this may seem a bit strange. In this syntax, open loads your executable file onto the processor identified by cc. Later in this tutorial, you use open with a different syntax to open channels in RTDX.
In the next section, you use the new link to open and enable communications between MATLAB software and your processor.

Configuring Communications Channels

Communications channels to the processor do not exist until you open and enable them through Embedded IDE Link CC and CCS IDE. Opening channels consists of opening and configuring each channel for reading or writing, and enabling the channels.

In the open function, you provide the channel names as strings for the channel name property. The channel name you use is not random. The channel name string must match a channel defined in the executable file. If you specify a string that does not identify an existing channel in the executable, the open operation fails.

In this tutorial, two channels exist on the processor — ichan and ochan. Although the channels are named ichan for input channel and ochan for output channel, neither channel is configured for input or output until you configure them from MATLAB software or CCS IDE. You could configure ichan as the output channel and ochan as the input channel. The links would work just the same. For simplicity, the tutorial configures ichan for input and ochan for output. One more note—reading and writing are defined as seen by the processor. When you write data from MATLAB software, you write to the channel that the processor reads, ichan in this case. Conversely, when you read from the processor, you read from ochan, the channel that the processor writes to:

Configure buffers in RTDX to store the data until MATLAB software can read it into your workspace. Often, MATLAB software cannot read data as quickly as the processor can write it to the channel.
```
cc.rtdx.configure(1024,4); % define 4 channels of 1024 bytes each
```
Channel buffers are optional. Adding them provides a measure of insurance that data gets from your processor to MATLAB software without getting lost.
Define one of the channels as a write channel. Use 'ichan' for the channel name and 'w' for the mode. Either 'w' or 'r' fits here, for write or read.
```
cc.rtdx.open('ichan','w');
```
Now enable the channel you opened.
```
cc.rtdx.enable('ichan');
```

Repeat steps 2 and 3 to prepare a read channel.

cc.rtdx.open('ochan','r');
cc.rtdx.enable('ochan');

To use the new channels, enable RTDX by entering
```
cc.rtdx.enable;
```
You could do this step before you configure the channels — the order does not matter.
Reset the global time-out to 20 s to provide a little room for error. ticcs applies a default timeout value of 10 s. In some cases this may not be enough.
```
cc.rtdx.get('timeout')
ans =
     10
cc.rtdx.set('timeout', 20); % Reset timeout = 20 seconds
```
Check that the timeout property value is now 20 s and that your link has the correct configuration for the rest of the tutorial.
```
cc.rtdx

RTDX Object:
  API version:       1.0
  Default timeout:   20.00 secs
  Open channels:     2
```

Running the Application

To this point you have been doing housekeeping functions that are common to any application you run on the processor. You load the processor, configure the communications, and set up other properties you need.

In this tutorial task, you use a specific application to demonstrate a few of the functions available in Embedded IDE Link CC that let you experiment with your application while you develop your prototype. To demonstrate the link for RTDX readmat, readmsg, and writemsg functions, you write data to your processor for processing, then read data from the processor after processing:

Restart the program you loaded on the processor. restart ensures the program counter (PC) is at the beginning of the executable code on the processor.
```
cc.restart
```
Restarting the processor does not start the program executing. You use run to start program execution.
Type cc.run('run');
Using 'run' for the run mode tells the processor to continue to execute the loaded program continuously until it receives a halt directive. In this mode, control returns to MATLAB software so you can work in MATLAB software while the program runs. Other options for the mode are
- 'runtohalt' — start to execute the program and wait to return control to MATLAB software until the process reaches a breakpoint or execution terminates.
- 'tohalt' — change the state of a running processor to 'runtohalt' and wait to return until the program halts. Use tohalt mode to stop the running processor cleanly.
Type the following functions to enable the write channel and verify that the enable takes effect.
```
cc.rtdx.enable('ichan');
cc.rtdx.isenabled('ichan')
```
If MATLAB software responds ans = 0 your channel is not enabled and you cannot proceed with the tutorial. Try to enable the channel again and verify the status.
Write some data to the processor. Check that you can write to the processor, then use writemsg to send the data. You do not need to enter the if-test code shown.
```
if cc.rtdx.iswritable('ichan'),  % Used in a script application.
    disp('writing to processor...') % Optional to display progress.
    indata=1:10
    cc.rtdx.writemsg('ichan', int16(indata))
end  % Used in scripts for channel testing.
```
The if statement simulates writing the data from within a MATLAB software script. The script uses iswritable to check that the input channel is functioning. If iswritable returns 0 the script would skip the write and exit the program, or respond in some way. When you are writing or reading data to your processor in a script or M-file, checking the status of the channels can help you avoid errors during execution.
As your application runs you may find it helpful to display progress messages. In this case, the program directed MATLAB software to print a message as it reads the data from the processor by adding the function
```
disp('writing to processor...')
```
Function cc.rtdx.writemsg('ichan', int16(indata)) results in 20 messages stored on the processor. Here's how.
When you write indata to the processor, the following code running on the processor takes your input data from ichan, adds one to the values and copies the data to memory:
```
while ( !RTDX_isInputEnabled(&ichan) )  

{/* wait for channel enable from MATLAB */} 
RTDX_read( &ichan, recvd, sizeof(recvd) );	 
puts("\n\n Read Completed "); 

for (j=1; j<=20; j++) {   
  for (i=0; i<MAX; i++) {
    recvd[i] +=1;
  }   
  while ( !RTDX_isOutputEnabled(&ochan) )
    { /* wait for channel enable from MATLAB */ }
  RTDX_write( &ochan, recvd, sizeof(recvd) );
 	 while ( RTDX_writing != NULL )
  	{ /* wait for data xfer INTERRUPT DRIVEN for C6000 */ }
} 
```
Program int16_rtdx.c contains this source code. You can find the file in a folder in the ..\tidemos\rtdxtutorial directory.
Type the following to check the number of available messages to read from the processor.
```
num_of_msgs = cc.rtdx.msgcount('ochan');
```
num_of_msgs should be zero. Using this process to check the amount of data can make your reads more reliable by letting you or your program know how much data to expect.
Type the following to verify that your read channel ochan is enabled for communications.
```
cc.rtdx.isenabled('ochan')
```
You should get back ans = 0 — you have not enabled the channel yet.
Now enable and verify 'ochan'.
```
cc.rtdx.enable('ochan');
cc.rtdx.isenabled('ochan')
```
To show that ochan is ready, MATLAB software responds ans = 1. If not, try enabling ochan again.
Type
```
pause(5);
```
The pause function gives the processor extra time to process the data in indata and transfer the data to the buffer you configured for ochan.
Repeat the check for the number of messages in the queue. There should be 20 messages available in the buffer.
```
num_of_msgs = cc.rtdx.msgcount('ochan')
```
With num_of_msgs = 20, you could use a looping structure to read the messages from the queue in to MATLAB software. In the next few steps of this tutorial you read data from the ochan queue to different data formats within MATLAB software.
Read one message from the queue into variable outdata.
```
outdata = cc.rtdx.readmsg('ochan','int16')

outdata = 
     2     3     4     5     6     7     8     9     10     11
```
Notice the 'int16' represent option. When you read data from your processor you need to tell MATLAB software the data type you are reading. You wrote the data in step 4 as 16-bit integers so you use the same data type here.
While performing reads and writes, your process continues to run. You did not need to stop the processor to get the data or send the data, unlike using most debuggers and breakpoints in your code. You placed your data in memory across an RTDX channel, the processor used the data, and you read the data from memory across an RTDX channel, without stopping the processor.
You can read data into cell arrays, rather than into simple double-precision variables. Use the following function to read three messages to cell array outdata, an array of three, 1-by-10 vectors. Each message is a 1-by-10 vector stored on the processor.
```
outdata = cc.rtdx.readmsg('ochan','int16',3)

outdata = 
[1x10  int16]  [1x10  int16]  [1x10  int16]
```
Cell array outdata contains three messages. Look at the second message, or matrix, in outdata by using dereferencing with the array.
```
outdata{1,2}

outdata = 
     4     5     6     7     8     9     10     11     12     13
```
Read two messages from the processor into two 2-by-5 matrices in your MATLAB software workspace.
```
outdata = cc.rtdx.readmsg('ochan','int16',[2 5],2)

outdata = 
    [2x5 int16]  [2x5 int16]
```
To specify the number of messages to read and the data format in your workspace, you used the siz and nummsgs options set to [2 5] and 2.

You can look at both matrices in outdata by dereferencing the cell array again.

outdata{1,:}

ans =
     6     8     10     12     14
     7     9     11     13     15
ans = 
     7      9     11     13     15
     8     10     12     14     16

For a change, read a message from the queue into a column vector.

outdata = cc.rtdx.readmsg('ochan','int16',[10 1])

outdata =
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17

Embedded IDE Link CC provides a function for reading messages into matrices–readmat. Use readmat to read a message into a 5-by-2 matrix in MATLAB software.
```
outdata = readmat(cc.rtdx,'ochan','int16',[5 2])

outdata =
     9   14
    10   15
    11   16
    12   17
    13   18
```
Because a 5-by-2 matrix requires ten elements, MATLAB software reads one message into outdata to fill the matrix.
To check your progress, see how many messages remain in the queue. You have read eight messages from the queue so 12 should remain.
```
num_of_msgs = cc.rtdx.msgcount('ochan')

num_of_msgs =
    12
```
To demonstrate the connection between messages and a matrix in MATLAB software, read data from 'ochan' to fill a 4-by-5 matrix in your workspace.
```
outdata = cc.rtdx.readmat('ochan','int16',[4 5])

outdata =
    10   14   18   13   17
    11   15   19   14   18
    12   16   11   15   19
    13   17   12   16   20
```
Filling the matrix required two messages worth of data.
To verify that the last step used two messages recheck the message count. You should find 10 messages waiting in the queue.
```
num_of_msgs = cc.rtdx.msgcount('ochan')
```

Continuing with matrix reads, fill a 10-by-5 matrix (50 matrix elements or five messages).

outdata = cc.rtdx.readmat('ochan','int16',[10 5])

outdata =
    12   13   14   15   16
    13   14   15   16   17
    14   15   16   17   18
    15   16   14   18   19
    16   17   18   19   20
    17   18   19   20   21
    18   19   20   21   22
    19   20   21   22   23
    20   21   22   23   24
    21   22   23   24   25

Recheck the number of messages in the queue to see that five remain.
flush lets you remove messages from the queue without reading them. Data in the message you remove is lost. Use flush to remove the next message in the read queue. Then check the waiting message count.
```
cc.rtdx.flush('ochan',1)
num_of_msgs = cc.rtdx.msgcount('ochan')

num_of_msgs =

     4
```
Empty the remaining messages from the queue and verify that the queue is empty.
```
cc.rtdx.flush('ochan','all')
```
With the all option, flush discards all messages in the ochan queue.

Closing the Connections and Channels or Cleaning Up

One of the most important programmatic processes you should do in every RTDX session is to clean up at the end. Cleaning up includes stopping your processor, disabling the RTDX channels you enabled, disabling RTDX and closing your open channels. Performing this series of tasks ensures that future processes avoid trouble caused by unexpected interactions with remaining handles, channels, and links from earlier development work.

Best practices suggest that you include the following tasks (or an appropriate subset that meets your development needs) in your development scripts and programs.

We use four functions in this section; each has a purpose — the operational details in the following list explain how and why we use each one. They are

clear — remove all RTDX objects and handles associated with a CCS and RTDX link. When you finish a session with RTDX, clear removes all traces of the specified link, or all links when you use the 'all' option in the syntax. When you clear one or more links, they no longer exist and cannot be reopened or used. If you are ending your programming session and do not want to retain any of the channels or links you created, use clear to end the RTDX communications and links and release all channels and resources associated with existing CCS IDE and RTDX links. You do not need to use the close or disable functions first.
To load a new program to a processor on which you have a program running, and to which you have links, you must clear the existing links before you load the new program to the processor.
close — close the specified RTDX channel. To use the channel again, you must open and enable the channel. Compare close to disable. close('rtdx') closes the communications provided by RTDX. After you close RTDX, you cannot communicate with your processor.
disable — remove RTDX communications from the specified channel, but does not remove the channel, or link. Disabling channels may be useful when you do not want to see the data that is being fed to the channel, but you may want to read the channel later. By enabling the channel later, you have access to the data entering the channel buffer. Note that data that entered the channel while it was disabled is lost.
halt — stop a running processor. You may still have one or more messages in the host buffer.

Use the following procedure to shut down communications between MATLAB software and the processor, and end your session:

Begin the process of shutting down the processor and RTDX by stopping the processor. Type the following functions at the prompt.
```
if (isrunning(cc))  % Use this test in scripts.
   cc.halt;         % Halt the processor.
end                 % Done.
```
Your processor may already be stopped at this point. In a script, you might put the function in an if-statement as we have done here. Consider this test to be a safety check. No harm comes to the processor if it is already stopped when you tell it to stop. When you direct a stopped processor to halt, the function returns immediately.
You have stopped the processor. Now disable the RTDX channels you opened to communicate with the processor.
```
cc.rtdx.disable('all');
```
If necessary, using disable with channel name and processor identifier input arguments lets you disable only the channel you choose. When you have more than one board or processor, you may find disabling selected channels meets your needs.
When you finish your RTDX communications session, disable RTDX to ensure that Embedded IDE Link CC releases your open channels before you close them.
```
cc.rtdx.disable;
```
Use one or all of the following function syntaxes to close your open channels. Either close selected channels by using the channel name in the function, or use the all option to close all open channels.
- cc.rtdx.close('ichan') to close your input channel in this tutorial.
- cc.rtdx.close('ochan') to close your output channel in the tutorial.
- cc.rtdx.close('all') to close all of your open RTDX channels, regardless of whether they are part of this tutorial.
Consider using the all option with the close function when you finish your RTDX work. Closing channels reduces unforeseen problems caused by channel objects that may exist but do not get closed correctly when you end your session.

When you created your RTDX object (cc = ticcs('boardnum',1) at the beginning of this tutorial, the ticcs function opened CCS IDE and set the visibility to 0. To avoid problems that occur when you close the interface to RTDX with CCS visibility set to 0, make CCS IDE visible on your desktop. The following if statement checks the CCS IDE visibility and changes it if needed.

if cc.isvisible,
    cc.visible(1);
end

Note Visibility can cause problems. When CCS IDE is running invisibly on your desktop, do not use clear all to get rid of your links for CCS IDE and RTDX. Without a ticcs object that references the CCS IDE you cannot access CCS IDE to change the visibility setting, or close the application. To close CCS IDE when you do not have an existing object, either create a new object to access the CCS IDE, or use Microsoft Windows Task Manager to end the process cc_app.exe, or close the MATLAB software.

You have finished the work in this tutorial, enter the following to close all your remaining links to CCS IDE and release all the associated resources.
```
clear ('all'); % Calls the link destructors to remove all links.
echo off
```
clear all without the parentheses removes all variables from your MATLAB software workspace.

You have completed the tutorial using RTDX. During the tutorial you

Opened connections to CCS IDE and RTDX and used those connections to load an executable program to your processor.
Configured a pair of channels so you could transfer data to and from your processor.
Ran the executable on the processor, sending data to the processor for processing and retrieving the results.
Stopped the executing program and closed the links to CCS IDE and RTDX.

This tutorial provides a working process for using Embedded IDE Link CC and your signal processing programs to develop programs for a range of Texas Instruments processors. While the processor may change, the essentials of the process remain the same.

Listing the Functions for Embedded IDE Link CC software

To review a complete list of functions and methods that operate with ticcs objects, either CCS IDE or RTDX, enter either of the following commands at the prompt.

help ticcs
help rtdx

If you already have a ticcs object cc, you can use dot notation to return the methods for CCS IDE or RTDX by entering one of the following commands at the prompt:

cc.methods
cc.rtdx.methods

In either instance MATLAB software returns a list of the available functions for the specified link type, including both public and private functions. For example, to see the functions (methods) for links to CCS IDE, enter:

help ticcs

TICCS Function that creates handles to Code Composer Studio(tm).
   ---------------------------------------------------------------------
   Description of methods available for TICCS
   ---------------------------------------------------------------------
   ACTIVATE   Set the active project, text file or build configuration
   ADD        Add source file to a project
   ANIMATE    Initiate a processor execution with breakpoint animation
   ADDRESS    Search the processor's symbol table for an address
   BUILD      Compile/Link to build a program file
   TICCS     Constructor which establishes the link to CCS
   CD         Change or query working directory of CCS
   CLOSE      Close CCS project or text file
   CREATEOBJ  Create objects for manipulating processor values
   DIR        List files in CCS working directory
   DISP       Display information about the TICCS object
   HALT       Immediately terminate execution of the processor
   INFO       Produce a list of information about the processor
   INSERT     Insert a debug point into processor memory
   ISREADABLE Query if a block of processor memory is available for reading
   ISRUNNING  Query status of processor execution
   ISRTDXCAPABLE Query if processor supports RTDX communications
   ISVISIBLE  Query visibility of CCS application
   ISWRITABLE Query if a block of processor memory is available for writing
   LIST       Produce various lists of information from CCS
   LOAD       Load a program file into the processor
   NEW        Create a default project, text file or build configuration
   OPEN       Load a workspace, project or program file
   PROFILE    Return measurements from any DSP/BIOS(tm) STS objects
   READ       Return a block of data from the memory of the processor
   REGREAD    Return data stored in a processor register
   REGWRITE   Modify the contents of a processor register
   RELOAD     Reload most recently loaded program file
   REMOVE     Remove a file from a project or a debug point from memory
   RESET      Reset the processor
   RESTART    Return PC to the beginning of a processor program
   RUN        Initiate execution of the processor
   SAVE       Save CCS project or text file
   SYMBOL     Return the processor's entire symbol table
   VISIBLE    Hide or reveal CCS application window
   WRITE      Place a block of MATLAB data into the memory of the processor
 
   For more information on a given method, use the following syntax:
 
     help ccsdebug/(method)
 
   See also get, set, rtdx.

Getting Started with Automation Interface

Constructing ticcs Objects

`Board`	`Board`	`Proc`	`Processor`	`Processor`
`Num`	`Name`	`Num`	`Name`	`Type`
`1`	`C6xxx Simulator (Texas Inst...`	`0`	`CPU`	`TMS320C6211`
`0`	`C6701 EVM (Texas Instruments)`	`0`	`CPU_1`	`TMS320C6701`