ti FAQ

http://processors.wiki.ti.com/index.php/CCStudio_FAQ#Q:_CCS_allows_me_to_save_memory_as_Addressable_Unit._Can_I_use_the_GEL_function_GEL_MemorySave.28.29_to_save_memory_in_this_format_as_well.3F

Code Composer Studio IDE Frequently Asked Questions

This FAQ pertains to issues related to the CCS IDE (GUI, Debugger, etc). For tools issues related to:

• Code Generation Tools - See the CGT FAQ
• DSP/BIOS - See the DSP/BIOS FAQ
• Scripting - See the Scripting FAQ

NOTE: There is a separate FAQ topic dedicated to Code Composer Studio v4 issues

Non tools related device specific issues usually have their own separate FAQ. Check the main FAQ list for a FAQ topic for the device of interest.

Product

Q: How can I check the status or renew my CCS subscription?

If you email [email protected] TI can provide you with the status of your subscription and help you renew your subscription if it has expired.

Q: Where can I get the latest Service Releases?

You can access service releases from within Code Composer Studio v3.x from the help menu. Alternatively you can directly access the Update Advisor page here.

Installation

Q: I get installation errors when I try to install CCS or install a CCS Service Release. How can I get it to install properly?

Common/General issues:

• Administrator privileges are needed to install CCS (see the release notes for more information)
• Do not overinstall over an existing CCS installation when doing a full install (i.e. - do not install over an existing CCS installation directory)

Failure with a new install: An install log is generated during the installation process. The default location of this log is C:\TI_InstallLog.txt. An errors that occur will be logged here. When an error is encountered during installation, open the log and browse to the end of the log and look for the error. Many times the install error encountered during is an InstallShield error with an InstallShield error code:

• "Error 1334": This error occurs occasionally when installing on a Windows machine with the language set for something other than English. The issue doesn't occur for all non-English languages, but just a small handful. A workaround is to set the Windows language to English for the duration of the installation (and switch back when the installation is complete).

• "Error 1722. There is a problem with this windows installer package. A program run as a part of the setup did not finish as expected": The exact reason for this error can vary. The most common cause for this error with CCS appears to be related to problems launching the DSP/BIOS installer. One known workaround is to include using a custom installer to not install DSP/BIOS (and install a standalone version of DSP/BIOS later). There are separate custom installers for the Full version and the Free Evaluation Tools version. Contact support for more information on how to obtain these custom installers.

— Another reported solution is related to internationalization. Before installing set the location to USA and language to English (USA): go to menu  Start -->  Control Panel -->  Regional and Language Options. In tab  Regional Options set the option  Location: to  United States. In tab  Advancedset the option  Language for non-Unicode programs to  English (United States). These settings can be returned back after installation.

— This error may occur also if you are trying to install CCS to a directory different from "C:\CCStudio_v3.3". Try to install it to the default location. It works in some cases.

• "Error 1904. Module C:\CCStudio_v3.3\C2000\cgtools\bin\Bti2000.dll failed to register. HRESULT -2147221164": This is can be caused when some applications (such as SurfControl) override the path that ATL.DLL was being loaded from. A workaround is to explicitly register both "C:\Windows\System32\ATL.DLL" and "C:\CCStudio_v3.3\C2000\cgtools\bin\Bti2000.dll" using regsvr32.exe.

• "Error 1935. An error occurred during the installation of assembly 'Syncfusion.Grid.Windows,Version="3.0.1.1",PublicKeyToken="036FE6034C821EA4": This error is often coupled with "Internal Error 2908". There are often two causes to the issue:
  • The windows installer version on your PC is old. You will need to update to Windows Installer 3.1 or higher.
  • The .NET Framework is not installed. CCS should install it automatically but also explicitly installing it first can help.

• "Internal Error 2738": This error message indicates that the VBScript engine is not currently registered on the machine where the install/uninstall is taking place. Try registering 'vbscript.dll' (found in %windir%\system32 in Windows 32-bit) via regsvr32 and try to install again.

• "Internal Error 2753 CC_APP.EXE_308F7B0A_0446_46D3_846E_AB968F81FCB3": This error indicated that remnants of a previous install exist on the system and this preventing the windows installer from installing specific files. A workaround is to manually clean up any previous installs (assuming they are not being used) and try again.

Other tips to try when encountering InstallShield errors: http://www.ehow.com/how_2109053_around-install-shield-errors.html

When sending a message to support regarding an installation issue, always attach the 'TI_InstallLog.txt' file.

Failure with installing a CCS SR (Service Release):

Occasionally a CCS SR patch (installation of a Service Release over an existing CCS installation) installation will fail. While the root cause is unknown, one theory is that some running process that is launched at startup of the PC is causing issues with InstallShield. One workaround that has been successful is to run the installer when in Windows safe mode (instead of tying to figure out which specific process is causing the problem).

Note that CCS DSK and FET (Free Evaluation Tools) installations can NOT be updated with CCS SR. Hence CCS SR installations will fail when trying to install over a CCS FET installation.

Q: Does CCSv3.3 support Windows 7?

CCSv3.3 is not officially supported on Windows 7. Windows 7 and Vista are very much the same and CCSv3.3 has been tested on Vista. One important thing to note is that CCSv3.3 is designed for 32bit windows, if you install on a 64bit OS you will see error messages during install (these can be ignored). You need to make sure to get 64bit drivers from your emulator vendor. We do recommend that Windows 7 users switch to CCSv4.

General IDE

Q: How can I configure CCS's editor to show & debug a specific file with extension *.xxx in addition to the normal .cxx,.cpp,.h extensions ?

There is a file extension .ini file that you can modify to add other extensions such as .xxx, so CCS can understand these files and will use it's editor to open these files.

The file is called FileExt.ini and is located in c:\CCStudio_v3.x\cc\bin\editor

In the file, you can modify the line:

text:Header Files (*.h*;*.inc):*.h*;*.inc

to be the following:

text:Header Files (*.h*;*.inc;*.xxx):*.h*;*.inc;*.xxx

for a customization of the file handling properties you can use the options > editor > language menu in CCS, select the .ini extension from the left hand side, and modify as desired

Q: Standard out calls like 'printf()' and 'puts()' no longer work with my BIOS applications in CCStudio 3.0. What happened?

There is a known issue with the build tools in CCStudio 3.0 and BIOS projects where a symbol needed for stdout in CCStudio (_C$$EXIT) is getting stripped. A workaround to get stdout to work properly is to simply define the missing symbol ‘_C$$EXIT’. This can be done in CCStudio by entering ‘_C$$EXIT’ in the field under:

Project->Build Options…->Linker->Advanced->Create Unresolved Ext Symbol (-u)

This issue has been be resolved in CCStudio 3.1 and greater.

Q: Is there any Build Options for C674x DSP project?

Yes, there is a build option for the C674x processor. It is -mv6740.You can use -mv6740 in the compiler command line, though it is not in the pull-down menu in CCS->Build options.

Q: Can the .PJT file or the .MAK file be manually modified?

The .PJT file can be modified by the user, but the .MAK file cannot. The .MAK file contains checksums and other information needed by the project to determine dependencies and so on. In Code Composer Studio, the user can load up a project and right-click on .PJT file in the Project Manager and will be presented with a menu item that says "Open for Editing". This will allow the user to manually edit the .PJT file.

Q: How can I modify the environment variables for my build environment before starting CCS?

Check the following post: Changing BIOS, DVSDK, INSTALL DIR environment variables in XP

Q: When compiling a project the compiler gives an error stating that it cannot find a header file which is part of the project, why?

This is the expected behavior. Code Composer Studio adds the header file to the project when it finds a #include statement. The header file is searched for in the project directory path and if the header file does not exist in this path, the compiler generates an error.

Q: Why does a "build tools not found" error message occur when building a CCS project?

This problem will occur if the build tool interface (BTI) dll file does not get self registered during the installation. Please issue the following command from the command prompt after replacing X with the letter that represents the TI DSP being used.

C:\WINNT\system32>regsvr32 C:\ti\cX000\cgtools\bin\BtiX000.dll

Q: What is the difference between Cycle Accurate Simulator and Device Simulator in CCS?

A cycle accurate simulator has the ability to simulate your board's peripherals and algorithm as close as possible to the real thing.

A device simulator DOES simulate peripherals. The peripherals are considered under "ideal" or "perfect" conditions.

Q: What is Run-Free? How is it different from normal Run(F5) when running a program using CCS?

Code Composer Studio detects when a catastrophic event occurs, regardless of whether the target is running or halted.

Code Composer Studio running the target in a Run-Free state

• Doesn't stop at any break point
• Will not detect any catastrophic event in CCS 2.1
• Doesn't send any printf messages to the host

A catastrophic event is one of the following circumstances:

1. Loss of target power
2. Loss of physical connection (cable unplugged)
3. Timeout that is caused by the Ready signal pulled active

Q: Is there a way to have CCS save break points on exit and reload them on startup?

The feature is implemented in CCS using the workspace concept. What needs to be done is to save the workspace after setting the breakpoints using File -> Workspace -> Save Workspace As.

Then to load that workspace on startup you can do the following:

1. Right click on the CCS icon on your desktop.
2. Choose properties and for your "Target" path enter c:\ti\cc\bin\cc_app.exe c:\test\test.wks where c:\test\test.wks is the path of your saved workspace.

This will automatically open up that workspace with breakpoints on startup.

Q: How do I re-enable the CCStudio Monitor once I've disabled it (2.40+)?

There are two ways to re-enable the CCStudio Monitor:

• Launch ‘CCSMonitor.exe’ located in \cc\bin

OR

• Open the ‘CCSMonitor.ini’ file located in \cc\bin. Set the value for the ‘Enabled’ property to ‘1’.

In CCStudio 3.1 and greater, the CCStudio Monitor can be re-enabled from the IDE by simply clicking on the ‘Help->CCS Monitor’ option.

Q: How do I prevent long include path's from being truncated from CCS?

If you have a long search path specified in the options of a project, CCS might truncate this path when loading the make file. So the workaround is to direct Code Composer Studio to use predefined search paths for the compiler by specifying the path in the C6X_C_DIR environment variable for your operating system, as an example.

Q: What are these *.dmp files generated by CCStudio (2.30+)?

A mini-dump (*.dmp) is a binary file that contains information about a running process. Microsoft provides the tools that permit creation and analysis of these files (windbg).

When an exception occurs in cc_app.exe, the exception may be caught in one of three ways:

1. It may be caught and handled in the code that generated the exception (by a try/catch) block. Since the exception is handled, no dump file is generated.
2. It may be caught by the cc_app exception handler and a dump file created.
3. If no hander is found, it will be caught by the unhandled exception handler and dump file will be created.

If CCStudio crashes ("unexpected fatal error") and the exception-handler or the unhandled exception-handler catches the process exception, a mini-dump file will be created. These mini-dump files are useful to include when reporting CCStudio issues to customer support, and can help engineers diagnose the cause of the crash. The file will be located in the \cc\bin\Logs directory (except for CCStudio 2.30, see next FAQ). Mini-dump files are approximately 50k in size.

Q: CCStudio v2.30 crashed on me but I don't see the mini-dump file in the .\logs subdirectory described above. Where is it?

There is a known issue with v2.30 where the mini-dump files are not being placed in the .\logs folder described above but being placed in the current windows directory at the time of the crash. This issue has been resolved in later versions of CCStudio. The best way to find mini-dump files generated by CCStudio v2.30 is to simply do a windows search for files with the *.dmp file extension at the root of the CCStudio install directory.

Q: I’m using an older compiler to link in a library built with a newer compiler and I get an error message from the linker similar to: “>> error: illegal relocation type 050002 found in section .debug_something, file filename”. What’s wrong, and what can I do about it?

The object code in the library (or file) includes Dwarf debug information that the older linker cannot read. Dwarf is a new and improved way to encode debug information. Debug information is read by a debugger like Code Composer Studio (CCS). The format of the debug information changed between the compilers released with CCS 2.X and CCS 3.X. If you are seeing this message, you are doing the final build with a CCS 2.X compiler while using a library (or other object module) built with a CCS 3.X compiler.

The rest of this FAQ presumes a library is the source of the problem. If you have this problem with a single object file instead, then the problem is no different conceptually. But the details of how you address the problem change. The rest of this FAQ presumes you are dealing with a library. The adjustments when handling a file instead are straightforward.

Presuming you cannot update to the newer compiler, you have two options. One is to rebuild the library to not use Dwarf debug information. The other option is to strip the debug information out of the library.

Rebuild the Library:

These directions presume you are using a CCS 3.X compiler to rebuild the library. Build the library the same as before, but use an additional switch to change the format of the debug information. The compiler switch --symdebug:none turns off all debug information. The switch --symdebug:coff enables the old style Stabs (sometimes called COFF) debug information that the old compiler can read. Note using --symdebug:coff interferes with optimization.

Strip the Library:

This process removes all the debug information from the library. These directions use executables from the C5500 compiler toolset. If you are using a different toolset, replace the “55” with the abbreviation for your toolset. For instance, C6000 users should replace ar55 with ar6x.

The name of the example library is: mylib.lib.

1. Copy the library to an empty directory
2. Extract all the library members: ar55 -x mylib.lib
3. Strip the debug information by applying strip55 to each .obj file in the directory: strip55 *.obj
4. Delete the old library: del mylib.lib
5. Rebuild the library: ar55 -r mylib.lib *.obj

Note you have to perform these steps each time you receive an update of the library.

Q: What is the purpose of the *.CS_ folder that gets generated in the same location as the project I'm working with in CCStudio (v2.40/v3.1+)?

The *.CS_ folder is cached information for CodeSense (the “CodeMaestro” feature for the CodeWright editor – auto-completion, where referenced, etc…) generated by CCStudio when you start editing a source file for the associated project using CodeWright. CodeWright is the default editor integrated with CCS version 2.40 and 3.1+.

Q: Using the CCscripting BreakpointSetLine() API puts the breakpoint in the Breakpoint table but doesn't show the file or source line. Why?

If you are using the CCScripting method to set a breakpoint at a given line of a .c source file, you would do the following (example code in Jscript) : -

var rtnCode = ccs.BreakpointSetLine("scom.c", 86);

However, you may observe that the breakpoint is indeed set and hit by your script, but the source code nor red-dot at the line number never appears.

This is often due to the fact that CCStudio cannot find your source file – its not in its search path since it may be e.g. outside the .pjt.

2 ways to fix this: -

(i) In CCStudio do Option -> Customize -> Directories -> then add the name of the directories containing sources which you’ll be setting breakpoints on.

This has the downside of hardcoding paths in CCStudio and not being automated.

(ii) create a GEL file which adds the directories to the CCStudio search path, and invoke that GEL file from CCScripting.

You can do this with the following scripting code: -

ccs.TargetEvalExpression('GEL_LoadGel("./scompath.gel");')
…
ccs.BreakpointSetLine("scom.c", 86);

And in your scompath.gel put e.g. : -

/*-----------------------------------------------------------------*/
/* OnFileLoaded() is called after a program is loaded. */
/* Customize this function to automate actions before a */
/* program is loaded */
/*-----------------------------------------------------------------*/
OnFileLoaded (int nErrorCode, int bSymbolsOnly)
{
	// check for errors in loading program
	if (nErrorCode) {
		GEL_TextOut("An error occurred while loading a file. -%d-\n",,,,, nErrorCode);
	} else {
		GEL_TextOut("File was loaded successfully. -%d-\n",,,,, nErrorCode);
	}
	
	// Check to see if only symbols are loaded
	if (bSymbolsOnly) {
		GEL_TextOut("Only symbols were loaded.\n");
	} else{
		GEL_TextOut("Full load.\n");
	}
	
	// Add my source search paths
	DebugSourceSearchPaths(); 
}

hotmenu DebugSourceSearchPaths()
{
    // Source search paths   
    GEL_SrcDirAdd("$(GEL_file_dir)\\..\\..\\src\\scom");

    GEL_TextOut("Added dir to path for source-level debug and file, line BPs etc\n");
}

There’s more detail here than necessary. The keys are simply: -

• Use GEL_SrcDirAdd() to add the directotries for source-level debug. Note that $(GEL_file_dir) is a macro available in CCStudio 3.1 or greater, indicating the path of the current gel file invoked. Its handy in creating portable gel scripts, with no hardcoded paths. If you’re using a CCStudio version prior to CCStudio 3.1 you need to hardcode the whole directory path.
• Add the call to the function in a CCStudio GEL callback that you know will be executed at an appropriate point. We chose OnFileLoaded() since it is called immediately after a program is loaded.

Q: I’m trying to use the CCStudio IDE integrated support for MS Visual SourceSafe but CCStudio doesn’t seem to recognize that my project/files are in source control even though I have correctly selected MS Visual SourceSafe as my provider in CCStudio . What do I need to do to get CCStudio to recognize that my project is in source control?

When having problems trying to get CCStudio to recognize files in source control, try the option to auto-connect to the default source control provider selected.

This can be done by going to Project->Source Control->Options and selecting the ‘Attempt connection to default provider’ option for the ‘Connect:’ drop-down options box:

Q: What is the purpose of the exclude.dat file and how does it work?

Code Composer uses an exclusion file, ‘exclude.dat’ (located in .\cc\bin), to prevent scans for dependencies on certain files. This will also, in effect, hide these files from view in the ‘Includes’ folder of the CCS IDE Project View. In its initial state, exclude.dat contains a list of system include files which are unlikely to change. You can edit this file to exclude scans of other files, such as your header files that will never change, or to include scans of system files that you need to alter.

Q: How can I set file type associations with extensions unknown to the CCStudio built-in editor?

There is a file called FileExt.ini, located in .\cc\bin\editor, that allows you to set file type associations with the CCStudio built-in text editor. This will allow for non-native file types to be recognized and opened by the built-in text editor when the file is ‘double-clicked’ on in the Project View. This will also allow you to filter for that file type (using the ‘Types of Files’ in the drop down) when opening a file in CCStudio via File->Open…

Example of a FileExt.ini file. Note the last two entries are custom entries:

text:C/C++ Source files (*.c*):*.c*
text:Asm Source Files (*.a*;*.s*):*.a*;*.s*
text:Header Files (*.h*;*.inc):*.h*;*.inc
text:Memory Map Files (*.map):*.map
text:Linker Command Files (*.cmd;*.lcf;*.lkf):*.cmd;*.lcf;*.lkf
text:General Extension Language Files (*.gel):*.gel
text:Text Files (*.txt;*.log):*.txt;*.log
text:Data Files (*.dat):*.dat
text:Project Files (*.pjt):*.pjt
text:Makefiles (*.mak):*.mak
text:Generated List Files (*.lst):*.lst
text:Configuration Files (*.tcf;*.cdb):*.tcf;*.cdb
text:Configuration Include Files (*.tci):*.tci
text:JScript Files (*.js):*.js
text:My New File Association (*.zzz):*.zzz

Screenshot of File->Open..

Q: How do I add custom build steps (eg partial link) to CCStudio library pjt's?

In CCStudio it is tricky to add complex custom build steps when building an archive. This can be necessary if say, you wish to build a library which you pre-build with partial linking in order to create a relocatable object file with certain global symbols hidden. This technique is often used with 3rd party code which runs on other processors i.e. the 3rd party is not keen to change symbol names hence the –h linker switch is used to hide symbols and prevent symbol collision in end-applications.

The problem is that it’s tricky to add such steps to a CCStudio pjt of type Library i.e.

There is no Linker Tab in this Built Tools Interface. Hence its cumbersome to try and add lnk6x based steps.

One solution is to flip the Project Type to Executable. Ie open the pjt for Editing and change it from: -

[Project Settings]
ProjectName="fir_ti64"
ProjectDir="C:\my_c_drive_stuff\localwork\perf_audio\rf_v3_21_00_01\referenceframeworks\src\fir_ti\"
ProjectType=Library
CPUFamily=TMS320C64XX
Tool="Archiver"
Tool="Compiler"
Tool="CustomBuilder"
Tool="DspBiosBuilder"
Config="Debug"

to: -

[Project Settings]
ProjectName="fir_ti64"
ProjectDir="C:\my_c_drive_stuff\localwork\perf_audio\rf_v3_21_00_01\referenceframeworks\src\fir_ti\"
ProjectType=Executable
CPUFamily=TMS320C64XX
Tool="Compiler"
Tool="CustomBuilder"
Tool="DspBiosBuilder"
Tool="Linker"
Config="Debug"

This gives us a linker Tab as follows: -

The –r switch is essential so we can further relink the code, once more with the final application. –h hides the necessary symbols. –o”.\Debug\fir_ti64_plink.obj” is the output partially linked relocatable object file.

1 caveat with this technique is that N input files get coalesced into the 1 object file. This reduces the linker granularity in eliminating unused functions, hence codesize may increase versus standard archives, if not all functions in the library are used by a given application.

A linker command file similar to the following is typically used for the partial link: -

/* expose global symbols which the end-application interfaces with */
-g _FIR_TI_IFIR  
-g _FIR_TI_IALG
-g _FIR_TI_init
-g _FIR_TI_exit

SECTIONS
{
      /* expose sections which user may wish to manually place */
	.text:algAlloc {}
	.text:algInit {}
	.text:algFree {}
	.text:algActivate {}
	.text:algMoved {}
	.text:algDeactivate {}
	.text:algControl {}
	.text:algNumAlloc {}

	.text:exit {}
	.text:init {}

	.text:filter {}

	.text:myDoMult {}			
}

A final custom build step can then be applied to turn this into an archive.

This step gets applied by CCStudio after the partial link step.

Important Notes

• Many algorithm vendors use the -mo switch to put all functions in subsections (to enable function placement granularity in the linker). In such cases, make sure you dont use the -w switch in the above partial link. Otherwise you'll get lots of warnings like this...

>> warning: creating output section .text:_MYUTIL_TI_doMult without
            SECTIONS specification

This is because -r (without -a) does not combine subsections into the base (parent) section. So .text:_MYUTIL_TI_doMult is treated like its own section, not a subsection of .text. Hence with -w we get a warning that this section has not been explicitly placed.

Thus, when partial linking (particularly with -mo) dont use -w.

• To preserve all important codec performance, algorithm vendors often do clever layout in linker command files to group key code sections together for L1P cache conflict minimization.

However 1 important note is that you should avoid using the MEMORY directive in the linker command file of a partial link - it doesnt really mean anything in partial links (there's no placement) and it can have serious side-effects. One such side effect is if you create a MEMORY section that's > 4Mb. Since -r (without -a) disables trampolines if you had code, then a large amount of data, then more code there's a high chance it won't link. ie you'll get relocation overflow errors because it's beyond the reach of near calls (assuming you're not using far calls...which you shouldnt be!)

• So the advice is: -
  • dont use -w in a partial link
  • dont have MEMORY directives in the cmd file of a partial link
    • if you do need MEMORY directives in a partial link make sure the length of them is <= 4Mb if you're placing code.

Q: How do I create a subsection within a linker section in which selected object files can be placed?

All versions of CCS: The following Linker Command file (cmd) statements will create a subsection named "sect1" in the ‘.text’ section. The ‘.text’ part of the object file (hello.obj) will be placed in ‘sect1’.

The ‘.text’ section will be placed in SDRAM at 0x80000000 followed by ‘sect1’. The user can also place multiple object files names separated by commas.

 SDRAM: len=0x80000000 org=0x4000 

.text:sect1 > SDRAM
 {
     hello.obj(.text)
 }

Q: Why the error message " Try to map memory with your target device" being displayed when I build my source code?

This error message is usually generated when you are trying to load a section of the code to a memory section which is reserved or when you are trying to access an undefined memory location.

This can be avoided by referring to the memory map of the particular device.

Q:What is the reason for the message " Invalid Object file " when trying to load my program ?

The linker is producing an executable with the TI new COFF format (default in current revisions is COFF2). Some TI emulators and simulators do not understand this new format and can only treat these files as invalid objects. A workaround is to link with the "-v0" option to use the old COFF format. Another solution is to use the latest emulator or simulator releases which support the new COFF format.

Q: What does a map file contain and how can I generate the map file for my project in CCS?

The map file designates:

- Memory configuration.

- Input and output section allocation.

- The addresses of external symbols after they have been relocated.

Map file for a project can be generated by using the Build options in the CCS. The steps below can be followed in order to generate the map file using CCS.

1. Go to Project --> Build Options.

2. In Linker tab, select Basic in the category.

3. Specify the name and path of the file in the Map Filename (-m) field.

The specific compiler user guide documentation of the can be referred to for further informataion.

Q: How do I debug overlays with CCStudio ?

See: Debugging Overlays With CCStudio

Q: The contents of the CCStudio Component Manager is blank. What happened and how can I resolve this?

This is caused when the ‘ccs_Compdb.ini’ file has been corrupted or has a blank entry. The exact cause of this is unknown. Every time CCStudio needs to update the ‘ccs_Compdb.ini’ file, it will generate a backup of the existing file with a *.bak extension in the same folder. If the backup is not also corrupted (this can occur when an already corrupted ‘ccs_Compdb.ini’ file is backed up) then overwriting the corrupt file with the backup can restore your CCStudio environment to the state when the backup file was created. The location of the ‘ccs_Compdb.ini’ file is located in ‘C:\Program Files\Common Files\Texas Instruments’

Q: Assuming I boot the C6000 DSP from flash which is not programmed. After the boot process, possible invalid instructions will reside in IPRAM and the DSP will execute them. Is there a way to gain control over the DSP through the JTAG interface, while it might be executing invalid code, so that I can load a valid program and start it executing?

If the DSP starts executing `garbage` data from flash, the DSP will `fly off in the left field.` You will not be able to gain control of the DSP once it starts executing garbage data from flash. You can try to use the no boot process so that the DSP doesnot execute garbage from flash. This feature is available on the C620x/C670x and C64x only. For more information, refer to chapter discussing Boot Modes and Configuration in the TMS320C6000 Peripherals Reference Guide

Q: Why are the RTA plug-ins updating so slowly?

There is an issue with RTDX and RTA with certain versions of CCStudio. This caused RTA updates to occur very slowly if the application execution is started before the RTA plug-ins were opened. The workaround is to either make sure RTA plug-ins are opened before application execution or to halt and continue execution if the RTA plug-ins are opened after application execution and the RTA updates are coming out slowly. This has been resolved in CCStudio 3.3.

Q: Why does CCStudio keep hanging or crashing on startup?

There are conflict issues with a CodeWright dll (cwctls32.dll) that comes with certain versions of CCStudio and certain PCs that use a particular set of audio drivers. This will cause problems when trying to launch CCStudio. This is resolved in CCStudio 3.3 and CCStudio 3.1 Service Pack 1 build number 29 and greater.

Q: How can I specify my own custom memory mapped registers to appear in the CCStudio 3.3 Register Window?

See: Creating Custom Memory Mapped CCStudio Register Windows

Q: How come the RTA plug-ins in CCStudio no longer update when the target is running and only when I halt the target?

If the PC that is being used has a history of prior CCStudio installations, then the issue may be caused by left over registry entries that confuse COM and its type library resolution. In order for the problem to trigger users would have to install (or have previously installed) a newer version of CCStudio than what they are currently using and then uninstall that newer version. E.g. user installs 3.1 and 3.3, then uninstalls 3.3. The issue is that the 3.3 type library information is still in the registry, hence COM type library resolution mechanism is picking the most recent one… which does not exist anymore. This issue is only affecting clients that do not use SDK wrapper libraries. CCScripting is one of them and RTA plug-ins are another.

A fix will be made to CCStudio to make sure that there are no such stale registry entries remain under the registry entry with the CCStudio type library information. This fix will be made in CCStudio 3.3 SR2+ and CCStudio 3.1 SP1 build 31+. In the meantime, there is a workaround that can be used.

Workaround: A workaround is to remove extra registry entries. CCStudio type library information can be found under:

HKEY_LOCAL_MACHINE\SOFTWARE\Classes\TypeLib\{7037933C-B77F-11D1-B009-0040055C1953}.

The entire registry key can be removed since launching CCStudio (after removing the key) will re-create the registry key. You can remove the entire key by executing the following line in a Windows Command Prompt:

reg delete HKEY_LOCAL_MACHINE\SOFTWARE\Classes\TypeLib\{7037933C-B77F-11D1-B009-0040055C1953}

In the example below, there are two entries, one from CCStudio 3.1 (1.29) and one from CCStudio 3.3 (1.32). CCStudio 3.3 has since been uninstalled but the registry entry remains. Removing the 1.32 subkey that points to a non existent version of CCStudio will also resolve the issue.

NOTE: If the entire registry key is removed, CCS scripting will not work correctly. The user must manually start CCStudio once for the registry key to be re-created. Any subsequent launches of CCStudio using CCStudio Scripting will not have any issues.

Q: How come my CCStudio 3.1 installation no longer works properly after I uninstalled CCStudio 3.3?

A common cause is that newer type library information from CCStudio 3.3 is not “uninstalled” or cleaned up from the registry when CCStudio 3.3 is uninstalled.

A fix will be made to CCStudio to make sure that there are no such stale registry entries remain under the registry entry with the CCStudio type library information. This fix will be made in one of the later CCStudio 3.3 Service Releases (SR).

Workaround: A workaround is to remove the following type lib registry entries from CCStudio 3.3:

KEY_CLASSES_ROOT\TypeLib\{7037933C-B77F-11D1-B009-0040055C1953}\1.32H
HKEY_LOCAL_MACHINE\SOFTWARE\Classes\TypeLib\{7037933C-B77F-11D1-B009-0040055C1953}\1.32

You can remove these entries by executing the following line in a Windows Command Prompt:

*reg delete HKEY_CLASSES_ROOT\TypeLib\{7037933C-B77F-11D1-B009-0040055C1953}\1.32
*reg delete HKEY_LOCAL_MACHINE\SOFTWARE\Classes\TypeLib\{7037933C-B77F-11D1-B009-0040055C1953}\1.32

Q: Will CCStudio run on Microsoft Vista?

See: Running CCStudio v3.3 on Windows Vista

Q: When I updated to the latest version of CCS, the previous version was stored in an uninstall folder. Can this be removed?

When Code Composer Studio is updated through the update advisor, the files from the previous version are stored in an uninstall directory in the CCS folder. This information allows you to uninstall the last update to your CCS installation in case an error occurs. This information can be deleted if you do not plan on uninstalling the latest update to CCS.

Q: When upgrading to newer versions of Code Composer Studio, how do I clean the Windows Registry?

When upgrading to newer versions of Code Composer Studio, the Windows Registry may not be updated to remove the prevoius version's elements.

If you experience problems with overinstalling on previous versions of CCS, try removing residual registry entries before installation (Note: errors in the registry can prevent your PC from booting properly):

Please follow these steps to completely remove CCS from your machine.

1. Go through the Add/Remove programs step in Control panel to remove CCS.

2. When the uninstallation is complete, check to see if there is a Details button to the left of the ok button. If a Details button does exist, please click on it and look at the directories that are remaining and then delete them from your drive.

3. Then go into regedit. From regedit, go to the following places in the registry and delete the Go DSP, TI and Texas Instruments keys (if they continue to exist).

HKEY_CURRENT_USER -> Software -> Go DSP

HKEY_CURRENT_USER -> Software -> Texas Instruments

HKEY_CURRENT_USER -> Software -> Texas Instruments' RTDX Log File Dumper

HKEY_CURRENT_USER -> Software -> TI

4. In the registry go to HKEY_LOCAL_MACHINE -> Software. From here delete the GODSP and TI and Texas Instruments keys (if they exist).

After following these steps, reboot your machine. By eliminating all of the references to CCS from your computer, you will be installing CCS on a clean machine.

Adding a clean-up routine to the installation to remove residual registry entries would alleviate any concern in this area.

Q: I can't find the DSP/BIOS Manual in the CCS help!

Please check the DSP BIOS FAQ page .

Q: Does CCStudio support debug of ELF output?

CCStudio 3.3 supports debug of ARM ELF output. Older versions of CCStudio has more limited debug support, hence it is recommend to upgrade to CCStudio 3.3. Make sure the latest CCStudio 3.3 Service Release is installed to ensure the latest support.

Q: Can I build my CCStudio project file outside of CCStudio?

Yes. CCStudio come with a utility called timake.exe that allows you to build your CCStudio project (*.pjt) file from the command line. Building a project with timake has the same effect as building the project from within the CCStudio IDE (timake uses the same project manager and versions of Code Generation Tools and DSP/BIOS that CCStudio is configured for).

To Invoke the timake Utility:

1. Open a DOS Command Prompt.
2. Setup the necessary environment variables by running the batch file DosRun.bat. This batch file must be run before using timake. If you installed the Code Composer Studio product in C:\CCStudio_v3.3, the batch file is located at: C:\CCStudio_v3.3\DosRun.bat
3. Run the timake utility.

The syntax for invoking the timake utility is:

>timake.exe PJT -lc | CFG [ -a | -clean ]

The first parameter is required.

• PJT - The name of a Code Composer Studio project file (.pjt).

The second parameter must be one of the following:

• lc: Lists the names of all configurations within the specified project. No build is performed.
• CFG: The name of a project configuration. Performs an incremental build of the specified configuration. Only files that have been modified since the last build are recompiled. For additional information, see Building a Program.

When a project configuration (CFG) is specified as the second parameter, one of the following options can be specified as the third parameter:

• -a: Rebuilds all files. By default, an incremental build is performed. This options forces the recompilation of all files.
• -clean: Removes all intermediate files that may remain following a build.

Ex:

>timake.exe modem.pjt Debug -a

Q: CCS crashes with message "Unexpected fatal Error Encountered which may have been caused by a stack overflow, out of memory condition, or access violation. I m going to try save your work before TERMINATING this application."

This is a generic CCS error message that occurs when an exception occurs in CCS and handled by the default CCS exception handler. This exception can be caused by a variety of factors. Some potential causes:

• One of the more common fatal editor crashes is caused by working on files that have been edited in a Linux/Unix environment. Sometimes the editor has trouble handling the different carriage return symbols that are used and it can crash because of this.

• It could also be caused by using CCS version 3.1 with workspace (.WKS) files generated using older CCS versions. Please ensure that you use workspaces created only with the latest version.

• Verify that whether "Code Sense" feature in CCS is disabled? In older versions of CCS, one such situation is when the "Code Sense" feature tries to search for a function definition repeatedly. In that case, please try to disable CodeSense.

When such a crash occurs, CCS will generate a crash mini-dump file. This file is useful to help diagnose the cause of the crash and should be attached when reporting a CCS crashing issue to support, along with a very detailed and reproducible test case.

Q: How can I find out which CCStudio 3.3 Service Release number is installed?

Go to the CCStudio menu 'Help->About' to see the CCStudio Version Number:

In the screenshot above, it is 3.3.77. Using the Version Number, you can find which Service Release is installed:

3.3.38.2  = CCStudio 3.3 RTM
3.3.42.1  = Service Release 1
3.3.46.1  = Service Release 2
3.3.49.1  = Service Release 3
3.3.50.2  = Service Release 4
3.3.54.1  = Service Release 5
3.3.57    = Service Release 6
3.3.67    = Service Release 7
3.3.77    = Service Release 8
3.3.79    = Service Release 9
3.3.80.11 = Service Release 10
3.3.81.6.2= Service Release 11
3.3.82.13 = Service Release 12

We can see that CCStudio 3.3.77 = Service Release 8 for our example.

Q: Which Service Release has a fix for issue 'x'?

See the CCStudio 3.3 Service Release page for a list of release notes for all the Service Releases

Q: Which option in CCS shows complete List of Files, Functions, and Local Variables used?

The "Symbol Browser" displays all of the associated files, functions, global variables, types, and labels of a loaded COFF file (*.out). This option is avaialble under "View" option of CCS. Please refer to the picture.

It allows the user to see where defined symbols occur in the disassembly output, the user can analyze cache performance and have a better idea on placement of a function in a program in order to reduce thrashing or improve cache performance.

For further information you can refer CCS-> Help under "Debugging Windows and Analysis tools". 

Q: How do I resolve error "Load Failed. A section of your program falls into a memory region that is not writable. Check your linker configuration and/or memory map."?

The error message means that you are trying to load a section of the code to a memory section which is not writable. If you are using Simulator then please go to Options -> memory map and uncheck the "enable memory mapping" box and click done. This will convert whole memory into unified RAM. Now load the .out file and execute it. The cause for the problem is that when you are loading sections from the .out file into the target memory (in this case Simulator memory) if the memory is not available at the address you specified in the linker command file then you cannot load the .out file.

Please refer the TMS320C55x Assembly Language Tools User's Guide for details about linker command files.[SPRU280]

Q: What does the error message "Because this program contains initialised RAM data it may run successfully under Code Composer studio but not as a standalone system. If your flash program requires initialised data in RAM, you will need to write Flash code to initialise Ram memory." mean and why does it occur?

The error you have received is a result of the fact that your whole application is linked to RAM and not to flash memory. You need to check your linker command file to see if you really link sections to the flash memory.

To be more elaborate, this appears each time you program the flash memory, if your application has code in RAM, to remind you that having application code in RAM prevents your application from working as a standalone system. So you need modify your CMD file.

Please refer to the application note SPRA958H (includes also code examples) to get an idea how to run an application from the DSP internal flash memory.

Q: Difference between Debug and Release mode

CCS creates two sets of build options - called Configurations: one called Debug, the other Release (Optimized one).

Debug is unoptimized build configuration and it maintains the symbolic debug information. The Release (optimized) configuration invokes the optimizer with -o3 and disables source-level, symbolic debugging by omitting -g (which disables some optimizations to enable debug). In many cases you might also want to add the -g option to the Release configuration as this makes it easier to evaluate the performance of optimized code.

Now in CCS3.3, -gp,-gt,-gw complier options are replaced by new option --symdebug:dwarf or -g

While converting from debug mode to release mode, please add the path for the header files in Project -> Build Options -> Compiler -> Preprocessor -> Include Search Path. When you change your mode from debug mode to release mode, the search path for the header files changes.

For more information on this, you can refer to the contextual help in CCS i.e

CCS Help -> Contents -> Code Generation Tools Build Options -> Compiler Options -> Preprocessor.

Q: Why am I not able to view the proper axes values on my graph in CCS?

It is quite commonly found that values on the axes of the graph in CCS do not appear as they are expected to appear. For example, instead of a value 4096 being displayed 5.739719e-42 might be displayed.

This can be avoided by taking care of the settings in the graph properties dialog box.

1. Please see that the Q-value is 0. This is because Q-value gives a fractional representation of an integer value, formed by inserting a decimal space inside a binary representation of an integer. This increases precision. The formula that is applied to convert an integer value to a value specified by a setting in Q-Value is:

New_integer_value = integer/2^Q-Value

2. Change the scale from log to linear scale, if not required.

3. Please be sure of the DSP data type that needs to be displayed.

Note: If your version of CCS is SR7 or below it is advisable to upgrade to the latest version of the CCS and Codegen tools.

Q: Code Composer Studio End-User License Agreement Details

Usually the license is for a single-user host computer. The user may not be able to install the licensed version on a network server or otherwise use the licensed copy on more than one host computer at the same time. Additionally, if this package contains multiple versions of the licensed copies, users may only use one version of the licensed copy on a single host computer. The users may install the licensed copies on additional single-user host computers, provided however, that in no event may more than one copy of the Licensed Materials be in use at any time. Basically, this means that if the user has a laptop and a desktop, he can install it on both but can use only one at a time.

Please note that the agreement is bound to the individual person in whose name is stands.

Below is the link available for Software License Agreement http://focus.ti.com/lit/ml/sprz273/sprz273.pdf

Q: What are the differences between DSK version, Evaluation version & Full version of CCS?

Code Composer Studio is made available in the following version

• DSK version of the CCS - This is often bundled either with an evaluation board.
• Free evaluation version – With the release of CCSv4, this version is not available for download anymore.
• Full version of the CCS – Available at cost

DSK version of the CCS

• Every DSK comes with DSK version of the CCS.
• This type of CCS can only work with the DSK hardware accompanying it. This is a restriction hard coded in the development tools and cannot be changed.
• One cannot upgrade the DSK Version of the CCS as this includes a "one time license" which is NOT like the annual subscription type.
• This version does NOT support Simulator.

Free evaluation version

With the release of CCSv4, this version is not available for download anymore

• The free evaluation version is available on the TI website.
• This version has all the features of a full version.
• They can be used with an external emulator.
• They have a 120 day expiration date that can NOT be renewed.

Full version of the CCS

• The Full version of CCS can be procured from a TI reseller in your local area.
• The service pack patches are also available for the full version .
• The availability of the updates depends on the License period.(or the sales contract)
• After the successful registration of the CCS users can download the updates through Update Advisor i.e. In CCS IDE ->help ->Update Advisor.

Q: How can I debug my program and be able to use breakpoints in CCS while running from on-chip FLASH of C28x devices?

Load the program into flash using one of the FLASH programming tools and bring up the Code Composer Studio Software. Load the project that generated the COFF file that you programmed on FLASH. Now load symbols by using `File --> Load Symbols --> Load Symbols Only` in Code Composer Studio menu and select exactly the same COFF (.out) file you used to program the FLASH. When running your program from on-chip Flash, you will need to use hardware(h/w) breakpoints. When debugging code in Flash on the 28x devices, you are limited to 2 H/W breakpoints. CCS may automatically set certain breakpoints which will utilize both of your available 2 breakpoints unless you disable certain options. See this article for more info.

Q: While using CCS what happens when the system clock is changed?

If the system clock is changed the CCS License is broken. The license breakage occurs for the following CCS version:

1. FET version of CCS
2. CCS with EVM

This problem does not occur if the customer uses

• Full version of the CCS
• CCS with DSK

Precaution: When you are using FET version of CCS, CCS with EVM the system clock should not be adjusted.

Q:  How to resolve" Command-line error: cannot open command file C:\Documents 1 fatal error detected in this compilation. Compilation terminated. "

Check what your environment variable TEMP is set to (Look in "My computer -> right click -> Properties -> Advanced -> Environment variables"). If they're set to "C:\Documents and settings\admin\temp,” please change the TEMP variable to use "C:\windows\temp,” the error message should go away.
If you are still facing any issues then try to uninstall and reinstall CCS completely. This will resolve the issue.

Q: When I try to build the project, CCS cannot find stb.lib. Where can I find this?

Stb.lib is part of the Software Test Bench software. You need to install this as well, when using the FFT library.

Q: Why does hex6x (Hex utility) give the warning message,"WARNING: Can't convert RAM-model .cinit with -image"?

ISA: C6000, All CCS versions: When linked with the -cr option, the loader uses the data in the .cinit section to auto initialize all the global variables. The .cinit section is marked with the COPY flag, which means that the auto-initialization data exists in the .out file, but does not take up any space in the memory defined with the MEMORY linker directive.

In the memory map, the user will find that the .cinit section has been overlapped with ome other section that actually takes up space in the memory. Since the .cinit section is marked with the COPY attributes, and it is technically overlapping other sections, the hex utility does not include it when run with the -image option. The user probably should link their code with the -c option in this case.

Q: Why is my .out file larger in CCS 3.0 than in CCS v2.2x?

You may notice an increase in the size of the object files because the default debug format for the code generation tools shipped with CCS 3.0 is DWARF, which is a richer language than the debug format used in previous releases (STABS). An increase in object file size does not necessarily reflect an increase in the application’s code size as the DWARF information is not loaded onto the target.

Q: What happens if an exception occurs during exception processing (a nested exception)?

When the CPU enters an exception service routine, the EXC bit in TSR is set to indicate an exception is being processed. If a new exception is recognized while this bit is set, then the reset vector is used when redirecting program execution to service the second exception. In this case, NTSR and NRP are left unchanged. TSR is copied to ITSR and the current PC is copied to IRP. TSR is set to the default exception processing value and the NMIE bit in IER is cleared in this case preventing any further external exceptions.

The NTSR, ITSR, IRP, and the NRP can be tested in the users boot code to determine if reset pin initiated reset or a reset caused by a nested exception. For information on C64x+ exception refer SPRU732

Q: Is there a way to have CCS save break points on exit and reload them on startup?

Currently this feature is implemented in CCS using the workspace concept. What needs to be done is to save the workspace after setting the breakpoints using File -> Workspace -> Save Workspace As. Then to load that workspace on startup you can do the following:

1. Right click on the CCS icon on your desktop.

2. Choose properties and for your "Target" path enter c:\ti\cc\bin\cc_app.exe c:\test\test.wks where c:\test\test.wks is the path of your saved workspace.

This will automatically open up that workspace with breakpoints on startup.

Q: When single-stepping through assembly code in CCS, why does each 'step' command step through several assembly instructions?

If the C source file is not open in CCS, and the user has loaded the symbols, you may notice that while single-stepping, CCS executes several assembly instructions per step command. This is because CCS is stepping in C source mode, which in some cases, could translate to several assembly instructions for each line of C source. To view the correct stepping, select Mixed Mode.

Q: How to resolve the IBQ stalls?

IBQ stalls are produced by the fetch pipeline and most of the time they are related to PC discontinuities. They can be encountered with BLOCKREPEAT, BRANCH, and CALL Instructions. This application report for TMS320C55x DSP SPRA865 shows how to resolve the IBQ stalls and align the target address (loop starting address) on a 32-bit boundary by adding nop instructions before the beginning of the loop. In order to optimize assembly code with respect to pipeline stalls, the DSP programmer needs to determine where the stalls occur, what the origin of the stalls is, and how, if possible, to remove the stalls.

Q: Using the Pipeline Stall Analyzer Tool

In a pipelined DSP processor, as the instruction flows through the pipeline, many internal registers and states are modified before the instruction has completed its execution. Due to depth of pipeline at a certain point of time (Clock Cycle), many instructions reside in the pipeline and affect the processor state. It is sometimes difficult to understand what states are affected and when exactly an instruction enters and exits the pipeline.

Also, in pipeline-protected machines, hardware NOP cycles (Stalls) are introduced by hardware to maintain the programmer’s view. Appropriate instruction scheduling is important to avoid such stalls so that software running on the processor can execute in less number of cycles. So, while running a simulation session, it is highly beneficial if some kind of a visual aid is provided which describes the instruction flow through each stage of the pipeline and highlights resource conflicts so that you can optimize your code accordingly. Code Composer Studio™ IDE has provided such a tool: the Pipeline Stall Analyzer.

The Pipeline Stall Analyzer tool allows you to see the following:

• Pipeline stages and instructions residing in each stage of the pipeline as they enter and exit it.
• Stalls, including:

1. the instructions involved in a stall, and
2. conflicting resources, if any.

• Statistics about various stalls.
• Optional visibility into instruction buffer queue (IBQ).

To use Pipeline Stall Analyzer click on CCS menu->Tools->Pipeline Stall Analyzer. Ensure that Flush Pipeline on Halt is disabled (deselected) in the Debug menu. The pipeline stall analyzer tool was developed to help the TMS320C55x DSP assembly programmers to efficiently optimize the critical sections of his code. For more information on pipeline stall analyzer refer CCS contextual help.

Q: What is the reason the Stdout window of CCS doesn't open, when executing printf in my project?

One reason is the lack of heap space on the target. By default, printf() internally makes calls to malloc(). If no heap is configured or no space is remaining on the heap, printf will silently fail (actually, it returns a negative number). No output will be shown, specifically the "Stdout" window in CCS will not be opened automatically.

Another possibility is not having a '\n' string terminator to flush the line.

See Tips_for_using_printf#How_to_use_printf_in_a_project for more details.

Q: I get link time errors when building a BIOS5 application project in CCS3.3 with 'tcf' and 'cfg' files ?

Tconf scripts (*.tcf) are the legacy content configuration format that is used by BIOS5. In the BIOS5 build flow '*.tcf' scripts are evaluated using the legacy 'tconf' tool. Tconf scripts have been superseded by RTSC configuration (*.cfg) scripts which are more generalized and can be used to consume any RTSC content like - BIOS6 and Codec Engine. Note that if you are planning to use BIOS5 you are required to use tconf scripts. XDCtools ships a tool named 'configuro' that can be used to evaluate both '*.tcf' and '*.cfg' scripts. In your particular case you have both the 'tcf' and 'cfg' files in your project. In order for the build to succeed only the 'configuro' tool need to be invoked. When both 'tconf' and 'configuro' are executed you will see linker errors.

This problem can be easily resolved by excluding the 'tcf' file from your build - right click on the tcf file and then select "File Specific Options...". Click on the "General" tab and then check the "Exclude file from build" checkbox. This will prevent the tconf tool from running. However the 'configuro' tool will evaluate both the 'cfg' and 'tcf' files and you should be able to build your application successfully.

Q: I keep getting a "CodeWright: cc_app.exe - Application Error". What is the cause?

CodeWright is the integrated editor with CCS. While the cause can vary, there are several workaround to try which can resolve the issue:

• Disable CodeSense: The CodeSense capability in CodeWright has been known to cause some stability issues. You can disable it via one of the following options:
  • Disable via editor properties: 'Option->Editor->Languages->Codesense'
  • Rename the '\cc\bin\cwsense.dll' file (ex: cwsense.bak)
• Delete the '.CS_' folder that is in the project folder. The '.CS' folder is used by CodeSense to store some cached data. The contents occasionally get corrupted and cause problems.
• 'Kaspersky Anti-Virus' has been known to conflict with CodeWright functionality and disabling/removing it has resolved the conflict

---

GEL

Q: How can GEL files help you?

There are several benefits to GEL files:

• They can help you get started developing code very quickly by doing fundamental things like PLL and EMIF configuration. (Don't forget to transfer this capability to your bootloader eventually!)
• They can setup a CCS memory map which specifies which addresses the emulator is allowed to read/write. This increases stability.
• They help automate tasks to speed debugging. For example, when reloading code you need to make sure the cache gets invalidated. A gel file can accomplish this by resetting the device on a reload or by writing to the cache invalidation registers of the device.

Q: Where I can find the details of the available GEL functions?

For the description of all the available GEL functions, in CCS please navigate to Help->Contents. This is the best source of information pertaining to the usage of the GEL functions.

Q: Is the behavior of GEL synchronous or asynchronous?

All custom actions via GEL are synchronous. There are certain built-in GEL functions that exhibit asynchronous behavior.

See Application Note SPRAA74 Appendix A for a list of built-in GEL functions and their behavior.

Q: Is it possible to declare arrays in a GEL file in CCS?

You cannot declare arrays in a GEL file, as GEL does not support arrays.

Q: I get a CCStudio popup "Cannot evaluate GEL_OpenWindow() without a valid Control window" in CCStudio 2.2x?

You may have a GEL file like this: -
/*
 * The StartUp() function is called every time you start
 * Code Composer.  You can customize this function to
 * initialize wait states in the EMIF or to perform 
 * other initialization.
 */
StartUp()
{
    GEL_OpenWindow("My EVM Board",0,15);

    clear_memory_map();
    GEL_Reset();
    init_emif();

    // misc user stuff to initialize peripherals etc
    
    GEL_TextOut("\nMy EVM GEL file loaded\n","My EVM Board");
    GEL_TextOut("\nStartup completed\n");
}

You would expect that GEL_OpenWindow() would create an Output Window to be used for My EVM Board specific confidence/status messages.

However, this may not work. You may get an error popup in certain CCStudio revisions as follows: -

The reason is that StartUp() runs before any control window is open. Hence GEL_OpenWindow() fails.

GEL_TextOut() to the standard CCStudio output window is also often used in StartUp(). Such calls wont give an error, but wont necessarily print out the message you’d hoped for either.

Hence, options to remedy this are: -

• Remove calls to GEL_TextOut or GEL_OpenWindow from StartUp().
• Put your GEL_TextOut or GEL_OpenWindow calls in a hotmenu function. These are called on user-demand clearly after StartUp() completes.
• Put your GEL_TextOut or GEL_OpenWindow calls in a callback function such as OnPreFileLoaded() which is called when ‘Load Program’ is selected.
• Put a big delay loop in your StartUp() gel content before calling GEL_OpenWindow. The latter is probably not advisable since its timing dependent. Also, CCStudio will detect that your GEL file is taking along time and additional popups will occur notifying you of this.

Q: What changes must be made to the startup GEL files to support versions of CCStudio that support Connect/Disconnect?

When CCStudio is launched, startup gel files defined in the CCStudio setup utility will be loaded into host memory and any actions defined in the ‘StartUp()’ function will be executed (if one is defined). Often both host and target initializations steps are done in the StartUp() call to help automate the process of initialization. However with versions of CCStudio that support Connect/Disconnect, these gel files may not work properly since CCStudio will startup disconnected to the target… hence actions in StartUp() that attempt to access the target will fail. A new built-in GEL callback function called ‘OnTargetConnect()’ has been provided for essential target initialization that needs to be done to put the target in a ‘good state.’ This function will get called by CCStudio after connection with the target has been established. Any initialization steps that do not access the target may be left alone in StartUp().

See Application Note SPRAA74 for more information.

Q: If I configure the IDE to 'Connect to the target when a control window is opened' (Options->Customize->Debug Properties->Target connection actions), can I then leave calls that access the target in the 'StartUp()' function?

No. Even if you configure CCStudio to connect to the target automatically when you open a control window, it will still call StartUp() before it automatically then tries to connect to the target. ‘OnTargetConnect()’ should still be used to automate target initialization steps.

Q: Can I make any call that accesses the target in the 'OnTargetConnect()' call?

Not for versions of CCStudio prior to version 3.1. Calls to any built-in GEL function that accesses the target are not recommended (ex. GEL_Reset(), GEL_MemoryFill(), etc…). Calls to custom GEL functions are fine. The reason why built-in GEL calls that access the target are not recommended (other than ‘OnTargetConnect()’ itself) is because the behavior of some built-in calls can potentially disrupt the connect/disconnect process in CCStudio. If GEL built-in calls that access the target are needed for additional initialization, it is recommended that they are called (manually via GEL hotmenu for example) after target connection has been established and OnTargetConnect() has finished execution.

Examples of some OnTargetConnect() calls:

// This example will run with no problems
OnTargetConnect()
{
    *0x8000 = 1;		// simple write to a memory location (ok)
    MyCustomGELFunc();	        // no issues calling custom gel functions
}
 
// This will have problems
OnTargetConnect()
{
    GEL_RefreshWindows(); 	// this is a built-in GEL callback!
}

For versions 3.1 and greater, this limitation has been removed. OnTargetConnect() will now only be called after the entire connect phase has been successfully completed. Thus any target access call can now be made in OnTargetConnect(). An undocumented ‘OnTargetInit()’ callback function now exists in place of where OnTargetConnect() used to be called.

Q: Can we use GEL_MemoryLoad command to load a hex file into the flash memory? Why is GEL_MemoryLoad not recognizing the .hex file?

It is not possible to use the GEL_MemoryLoad() function to load the hex file into the flash memory. The GEL_MemoryLoad() function is used to load a block of target memory not the external flash memory. The user can use GEL_MemoryLoad() to load a block of target memory from a specified file. If the filename contains a *.out for the file extension, COFF format is used; otherwise, the Code Composer Studio debugger uses the header information in the file to determine the file format. The gel function GEL_MemoryLoad can only recognize and load .out file and data files which contain magic number in the header. The hex file does have the header information that GEL_MemoryLoad expecting. After generating a .hex file using HEX utility, use a FLASH programming utility to write the hex image into the FLASH memory. Flashburn is a new FLASH programmer capable of programming the entire FLASH memories available on the board at specified logical address.

Q: CCS allows me to save memory as Addressable Unit. Can I use the GEL function GEL_MemorySave() to save memory in this format as well?

This option is actually supported, it just is not documented (as of May/08).

The GEL documentation says: io_format is an integer that represents the format in which memory words will be written to the specified output file. The default output is 1 (hexadecimal). It accepts the following Parameters:

1    *.dat Hexadecimal
2    *.dat Integer
3    *.dat Long
4    *.dat Float
5    *.out COFF

However, if you specify a 6 for the io_format, this will map to the addressable unit option internally.

To save memory in this format using CCS 3.3 go to menu File -> Data -> Save and select Addressable Unit (*.dat) in the Save as type: box.

---

Profiling

Q: How do I set up a Profile Range where my start point is in one function and my end point is in another function that precedes the function with the start point?

You cannot. The CCStudio profiler defines a range as linear block consecutive instructions (and not as an execution flow) with the start address <= end address. Also the range cannot go across function boundaries. To do such profiling, the user should manually use breakpoints at the start and end points and view the profile clock.

Q: Why does it take so long to enable all my functions for profiling?

The new behavior when enabling functions/loops/ranges for profiling is to calculate the ranges and apply all breakpoints needed ahead of time. This improves profiling performance in terms of speed. The drawback is that for applications with many functions/loops/ranges, it can take quite some time to enable all those functions/loops/ranges since it needs to do breakpoint calculation and application for all the functions/loops/ranges being enabled. This tends to happen when people select the ‘Enable all Functions’ option for a large application.

Q: I get errors and CCStudio hangs on me when I am enabling all my functions to be profiled. What is going on?

In older versions of CCStudio, there is a limit to the number of SW breakpoints available. Currently the limit is 10K. Applications large enough can have enough branches in it so that the number of breakpoints needed to enable the profiling of all functions exceed the limit. This caused bad behavior in CCStudio (hanging (or the appearance of), constant error messages, etc). The following enhancements have been made for CCStudio v3.1 and greater:

• increase the limit for SW BP’s
• warn the user when the BP limit has been reached
• stop attempting to add ranges when BP’s have been used up

Q: C55x Profiling does not seem to work on my OMAP2420 target. Is profiling supported for this target?

Profiling of the 55x portion of the OMAP2420 processor in earlier versions of Code Composer Studio may not work correctly with Code Composer Studio's default installation configuration. As a result, attempting to use the Profile Clock or advanced profiling tools may not return the expected results.

To work around the problem and enable profiling, please perform the following:

If using Code Composer Studio version 2.3:

• Go to the directory in which Code Composer Studio has been installed:
• Within the installation directory, open the directory cc/bin;
• Locate the file named "cTools2000.dll". Rename this file to something other than "cTools2000.dll" (for example, "cTools2000.dll.bak").

When CCS starts you'll receive a message indicating that AET could not be initialized. This message can be ignored. You should now be able to view the Profile Clock to retrieve the number of cycles executed by the target and use the CCStudio profiler normally.

If using Code Composer Studio version 2.4:

• Go to the directory in which Code Composer Studio has been installed:
• Within the installation directory, open the directory cc/bin/aet_config
• Locate the file named "5500.xml". Rename this file to something other than "5500.xml" (for example, "5500.xml.bak").

You should now be able to view the Profile Clock to retrieve the number of cycles executed by the target and use the CCStudio profiler normally.

Q: Can we simultaneously use profiling and RTDX in Code Composer Studio v 3.3?

On actual DSP targets you cannot use both profiling and RTDX at the same time. Code Composer Studio displays resource conflict message in this case. However it is possible to use both profiling and RTDX in the Simulator mode (i.e without connecting a target board).

Q: Why the results I get with the profiling tool do not match my expected results?

There are limitations using the profiling tool with hardware; these limitations and considerations are documented in the Help CCS menu. Go to menu Helpand select the Search tab. Search for the keyword profile clock and check the following topics in the results box:

• Hardware Profiling Limitations
• Profile Clock Accuracy
• Important Notes on Profiling

Q: Profiling in Flash Memory for C28x Devices.

Profiling in Flash is possible but you cannot do as much as you could in RAM because the profiler will need to use the analysis resources for counting and also for hardware breakpoints.

On C28x target you have two resources available for analysis at given time. One resource can be used as a hardware breakpoint, watch point, or a counter. The other one can only be used as a hardware breakpoint or a watch point. In order to profile, you need to use the analysis counter which uses up one of your resources therefore, now, you can set only one hardware breakpoint. In order to step through the source in flash, for example, you need two hardware breakpoints, therefore you won't be able to simultaneously step through the source in flash and profile.

If the user wants to get the number of cycles it takes to execute a function in flash, it might be better to use the analysis plug-in directly to configure the benchmark counters.

Q: What are the limitations of using the External Counter located on the Emulator in profiling applications?

The external counter contained inside most emulators can be used to count “roll-overs” of an internal counter by counting EMU pin signals that are strobed whenever the internal counter rolls over. This external counter effectively gives the internal counter an additional 16-bits (on XDS510 based emulators) or 32-bits (on XDS560 based emulators) of resolution.

The limitations of the use of this counter in this manner depend on the Emulator being used. A few of the different options are listed below:

Emulator	Maximum Count Rate
TI XDS560	~50 MHz
TI XDS510	(Depends on TCLK)
Spectrum Digital USB510	80MHz
Spectrum Digital XDS510PP Plus	80MHz

If we’re profiling cycles, the maximum CPU speed is dependent on the size of the internal counter. If the internal counter is 5 bits, then we get a “roll-over” signal every 32 cycles. On a 200 MHz processor, the effective rollover frequency is 6.25 MHz. If the internal counter is 16 bits, then the effective rollover frequency would be ~3KHz.

Q: Difference between the clock cycle and execution packet?

With "clock" as the measurement option (Profiler-> Clock Setup->Count) you will get the actual clock cycles taken to execute your range of code. With "Execution Packet", you get the number of execute packets it executes in that range.

It is correct that in one clock cycle one Execute Packet gets executed. But apart from executing the execute packet the processor has to fetch the instructions, which is the reason for the difference in the values shown by the profiler. The statistics shown with the measurement option as "clock" will be greater than the statistics shown from the measurement option as "Execution Packet".

Enabling the cache will reduce the difference.

Q: What is Analysis Tool Kit?

The Analysis Tool Kit (ATK), which is the code coverage and exclusive profile tool, aids you to analyze the robustness and efficiency of embedded digital signal processing (DSP) applications. It assists you in developing correct and efficient application software. The code coverage and exclusive profile tool provides visualization of source line coverage. With this information, you can construct tests to ensure adequate coverage of your code. The code coverage and exclusive profile tool is supported on all the C5500 and C6000 simulators in Code Composer Studio version 3.1 or higher.

Please refer to "Analysis Toolkit for Code Composer Studio User's Guide" (SPRU623) for more information.

SPRU623d

---

ExpressDSP component Wizard Tool

Q: How to get the Express DSP component Wizard tool in CCS->tools? It is present in CCS 3.1 but eliminated in CCS 3.3? why??

The XDAIS component wizard was a CCSv3 plugin developed by a 3rd party. The XDAIS product removed this wizard in XDAIS 5.00.

XDAIS 4.00 contains the tool, however algorithm developers are encouraged to implement the XDM interfaces provided with XDAIS 5.00 and later to ease integration into upper layer frameworks. Note that recent releases of XDAIS (also provided in CCS Eclipse) include the XDM GenAlg Wizard, as well asQualiTI for XDAIS compliance checking.

For further reference, the XDAIS product includes example algorithms (see $(XDAIS_INSTALL_DIR)/examples) and this article includes some XDAIS examplesas well.