Forums

CCS scripting (perl) & CCS GEL "scripting" problems

Started by Dan November 20, 2003
Hi,
my name is Dan Huff. I've been using Code Composer Studio and the
TMS320VC5510 DSP for several years. I've developed
dsp/hardware-control applications for several different embedded
C5510-based hardware boards, and a few support and test programs for
that hardware. I'm fairly familiar with implementing combination
C/assembly code and using interrupts and peripherals, but don't use
DSP/BIOS, etc because it doesn't fit our needs/requirements.

We now are in a half-prototype, half-"self production" phase, and I am
trying to script many of the repetitive operations we will have to do
for several hundred C5510-based boards.

Normally, I attach my target board to a power supply, plug it into the
emulator, run CCS, open a "board program" project, run it to a
breakpoint, load a pre-created bootable binary image into the DSP's
RAM, and then run the rest of the program to burn that image from DSP
RAM to the Flash chip on the board. I know this method works from
many burn-test-debug cycles.

I attempted to automate this using Code Composer Scripting. I'm
totally unfamiliar with VBA script, and barely familiar with Perl, so
I went the Perl route. In general, it works, except for one VERY
PECULIAR case. When I use the MyCCScripting->MemoryWrite() command
and try to write 0xA0XX (where capital X indicates a "don't care"
value) to an *even* address (0x10000, 0x10002, 0x10004, etc), it
silently writes a 0x0000 instead (or maybe it's not writing anything,
since I've pre-initialized memory to 0x0000.) After some careful
checking, I'm pretty sure the problem is in TI's perl module that does
all this scripting stuff.

Anyone seen this? Included below is my Perl script, which is merely a
minor modification and addition to one of the examples included with
Code Composer Scripting (a web-downloadable addition to Code Composer
Studio).

Beside the fact that it was really really slow, this Perl method
wasn't cutting it, since it wasn't correctly transferring my binary.

So I decided to try using a GEL file to accomplish the same thing.
Unfortunately, individual commands in a GEL command sequence don't
seem to wait for their preceeding commands to finish executing. For
example, I told it to set two breakpoints, run to the first
breakpoint, load a binary.dat file into memory, and then run to the
second breakpoint (i.e. the part of the program that burns the binary
to the flash chip). What happens in practice is that the
GEL_MemoryLoad() command that loads the binary.dat file into RAM is
executed before the GEL_Go(_breakpoint1) command. Or if you don't
want to go look at my GEL code below just yet, it's like the command
sequence happens out of order. Or perhaps each command just spins off
a "thread" (loosely speaking) in Code Composer, and various commands
may take a long time to execute... I would think this is a bug, since
I can't think of any reason you would want it to work that way.
Anyone know how to work around this?

Below the Perl code is my GEL file.

Here's "my" Perl code (i only contributed a teensy bit):
----------------------------------
#start perl script

# boardprogram.pl
# starts CCS
# does all necessary steps to burn a binary to DSP board

# most of this code was copied from:
# ccs_Debug.pl
# (which Demonstrates some of Code Composer Studio Scripting's
debugging functionality)

# Pulls in the Code Composer Studio Scripting declarations and definitions
use CCS_SCRIPTING_PERL;

# Declarations and Initializations
# Create 2 new Code Composer Studio Scripting objects
my $MyCCScripting = new CCS_SCRIPTING_PERL::CCS_Scripting();
my $MyCCScripting2 = new CCS_SCRIPTING_PERL::CCS_Scripting();
my $sCurDir;
my $sLogFile;
my $sProject;
my $sProgram;
my $nPCVal;
my $nPCVal2;
my $nTempAddr;
my $nBreakpoint1;
my $nBreakpoint2;
my $sHexOutput;
my $sBoardName;
my $sCPUName;
my $sVersion;

$sProject = ".\\boardprogram.pjt";
$sProgram = ".\\Debug\\boardprogram.out";
$sBinary1 = "..\\data\\dspbinary.dat";
$sLogFile = ".\\ccs_boardprogram_Debug.log";
$sCurDir = ".\\";

print ("Open log file...\n");

# Open log file and set to maximum level of debug output
$MyCCScripting -> ScriptTraceBegin($sLogFile);
$MyCCScripting -> ScriptTraceVerbose($CCS_SCRIPTING_PERL::VERBOSE_ALL);

# Get the current version of Code Composer Studio Scripting
$sVersion = $MyCCScripting->ScriptGetVersion();
$MyCCScripting -> ScriptTraceWrite("$sVersion\n");
print "$sVersion\n";

print ("Open log ccs...\n");

# Open Code Composer Studio for the C55x Phase 3 Simulator
$MyCCScripting -> CCSOpen($CCS_SCRIPTING_PERL::ISA_C55,
10,
0,
$CCS_SCRIPTING_PERL::PLATFORM_EMULATOR,
1);

# Retrieve the Board name and CPU name of the current configuration
# and write names to log file
$sBoardName = $MyCCScripting -> TargetGetBoardName();
$sCPUName = $MyCCScripting -> TargetGetCPUName();
$MyCCScripting -> ScriptTraceWrite("Board Name: $sBoardName\n");
$MyCCScripting -> ScriptTraceWrite("CPU Name: $sCPUName\n\n");

# Set the Current Directory, if necessary
$MyCCScripting -> CCSSetCurrentDirectory($sCurDir);

print ("Open board programming project; build & load...\n");
# Open the project
$MyCCScripting -> ProjectOpen($sProject);

# Build a project
$MyCCScripting -> ProjectBuild("Debug");

# Load an .out file
$MyCCScripting -> ProgramLoad($sProgram);

print ("Set breakpoints...\n");

# Get the address of main. Set a breakpoint at main.
$nTempAddr = $MyCCScripting -> SymbolGetAddress("breakpoint1");
$nBreakpoint1 = $MyCCScripting -> BreakpointSetAddress($nTempAddr);
$nTempAddr = $MyCCScripting -> SymbolGetAddress("breakpoint2");
$nBreakpoint2 = $MyCCScripting -> BreakpointSetAddress($nTempAddr);

# Run to breakpoint 1
$MyCCScripting -> TargetRun;

# Load DSP binary
open(FID, $sBinary1) || die;
print "file opened\n";
my $sLine = <FID>;
my ($sMagic, $sFoo, $sAddr, $sGoo, $sLen) = split / /, $line;
$nAddr = hex($sAddr);
$nLen = hex($sLen);
print "Loading DSP binary...";
while ($sLine=<FID>) {
last if !$nLen;
my ($sMoo, $sVal) = split /x/, $line;
$nVal = hex($sVal);
print $len, " ", $val, "\n";
$MyCCScripting -> MemoryWrite( $CCS_SCRIPTING_PERL::PAGE_DATA,
$nAddr,
16,
$nVal);
$nAddr += 1;
$nLen -= 1;
#print ".";
}
print "done\n";
close($fid);
print "file closed\n";

# Run to breakpoint 2 to burn DSP binary to Flash
$MyCCScripting -> TargetRun;

# Close all current Code Composer Studio processes
$MyCCScripting -> CCSClose();

# Close the log file
$MyCCScripting -> ScriptTraceEnd;

#end perl script
---------------------------------
// start GEL file

// boardprogram.gel menuitem "boardprogram";

hotmenu Board_Program()
{
GEL_ProjectLoad("boardprogram.pjt");
GEL_ProjectBuild();
GEL_Reset();
GEL_Load(".\\Debug\\boardprogram.out");

GEL_BreakPtAdd(_breakpoint1);
GEL_BreakPtAdd(_breakpoint2);
GEL_BreakPtAdd(_breakpoint3);
GEL_BreakPtAdd(_breakpoint4);

GEL_Go(_breakpoint1);

// supposedly now at _breakpoint1 ?

GEL_MemoryLoad(0x1000, 1, 0x100, "dspbinary.dat");

GEL_Go(_breakpoint2);
// supposedly now at _breakpoint2 ?

// GEL_ProjectClose("staveboardprogram.pjt");
// GEL_TextOut("done.\n");
// GEL_Exit();
}

// end GEL file If you read through this whole thing, THANK YOU!!

I'm pretty familiar with a lot of Code Composer and C5510 issues, so I
hope I can be helpful to this group.

-Dan Huff